提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  移动开发

当前栏目

【Android RTMP】NV21 图像旋转处理 ( 图像旋转算法 | 后置摄像头顺时针旋转 90 度 | 前置摄像头顺时针旋转 90 度 )

Android算法 处理 图像 摄像头 旋转 90 RTMP
2023-06-13 09:17:42 时间

文章目录

一、 后置摄像头顺时针旋转 90 度

1 . NV21 格式图像数据的排列 :

16

个 Y 灰度数据在前 , 然后

4

组 (

8

个 ) VU 色彩值 , 饱和度 , 数据交替存放 ;

\begin{bmatrix} y1 & y2 & y3 & y4 \\\\ y5 & y6 & y7 & y8 \\\\ y9 & y10& y11& y12 \\\\ y13& y14& y15& y16 \\\\ v1 & u1 & v2 & u2 \\\\ v3 & u3 & v4 & u4\\ \end{bmatrix}

2 . NV21 格式的图像的 YUV 值顺时针旋转 90 度后的 YUV 矩阵为 :

\begin{bmatrix} y13 & y9 & y5 & y1 \\\\ y14 & y10 & y6 & y2 \\\\ y15 & y11& y7& y3 \\\\ y16& y12& y8& y4 \\\\ v3 & u3 & v1 & u1 \\\\ v4 & u4 & v2 & u2\\ \end{bmatrix}

3 . 灰度值 Y 数据读取顺序 :

① 外层循环 : 逐行遍历, 从第一行遍历到最后一行, 从 0 到 mWidth - 1 ;

② 内存循环 : 遍历每一行时, 从底部遍历到顶部, 从 mHeight - 1 到 0 ;

for (int i = 0; i < mWidth; i++) {
    // 第 i 行, 从每一列的最后一个像素 ( 索引 mHeight - 1 ) 遍历到第一个像素 ( 索引 0 )
    for (int j = mHeight - 1; j >= 0; j--) {
        // 将读取到的 Y 灰度值存储到 mNv21DataBuffer 缓冲区中
        mNv21DataBuffer[positionIndex++] = data[mWidth * j + i];
    }
}

4 . 饱和度 色彩值 UV 数据读取顺序 :

① 数据高度个数 : Y 数据的高度与图像高度相等 , UV 数据高度相当于 Y 数据高度的一半 ;

② UV 数据排列 : V 色彩值在前, U 饱和度在后, UV 数据交替排列 , 一行 mWidth 中, 排布了 mWidth / 2 组 UV 数据 ;

③ UV 数据组有 mWidth / 2 行, mHeight / 2 列, 因此遍历时, 有如下规则 :

  • 按照行遍历 : 遍历 mWidth / 2 次
  • 按照列遍历 : 遍历 mHeight / 2 次

④ 外层遍历 : 每隔 2 行, 遍历一次, 遍历 mWidth / 2 次 ; 遍历行从 0 到 mWidth / 2 - 1 ;

⑤ 内层遍历 : UV 数据也需要倒着读 , 从 mHeight / 2 - 1 遍历到 0 ;

for (int i = 0; i < mWidth / 2; i ++) {
    for (int j = UVByteHeight - 1; j >= 0; j--) {
        // 读取数据时, 要从 YByteCount 之后的数据开始遍历
        // 使用 mWidth 和 UVByteHeight 定位要遍历的位置
        // 拷贝 V 色彩值数据
        mNv21DataBuffer[positionIndex++] = data[YByteCount + mWidth / 2 * 2 * j + i];
        // 拷贝 U 饱和度数据
        mNv21DataBuffer[positionIndex++] = data[YByteCount + mWidth / 2 * 2 * j + i + 1];
    }
}

二、 前置摄像头顺时针旋转 90 度

1 . NV21 格式图像数据的排列 :

16

个 Y 灰度数据在前 , 然后

4

组 (

8

个 ) VU 色彩值 , 饱和度 , 数据交替存放 ;

\begin{bmatrix} y1 & y2 & y3 & y4 \\\\ y5 & y6 & y7 & y8 \\\\ y9 & y10& y11& y12 \\\\ y13& y14& y15& y16 \\\\ v1 & u1 & v2 & u2 \\\\ v3 & u3 & v4 & u4\\ \end{bmatrix}

2 . NV21 格式的图像的 YUV 值逆时针旋转 90 度后的 YUV 矩阵为 :

\begin{bmatrix} y4 & y8 & y12 & y16 \\\\ y3 & y7 & y11 & y15 \\\\ y2 & y6& y10& y14 \\\\ y1& y5& y9 & y13 \\\\ v2 & u2 & v4 & u4 \\\\ v1 & u1 & v3 & u3 \\ \end{bmatrix}

3 . 灰度值 Y 数据读取顺序 :

① 外层循环 : 逐行遍历, 从最后一行遍历到第一行, 从 mWidth - 1 到 0 ;

② 内存循环 : 遍历第 i 行时, 从顶部遍历到底部, 从 0 到 mHeight - 1

for (int i = mWidth - 1; i >= 0; i--) {
    // 第 i 行, 从每一列的最后一个像素 ( 索引 mHeight - 1 ) 遍历到第一个像素 ( 索引 0 )
    for (int j = 0; j < mHeight; j++) {
        // 将读取到的 Y 灰度值存储到 mNv21DataBuffer 缓冲区中
        mNv21DataBuffer[positionIndex++] = data[mWidth * j + i];
    }
}

4 . 饱和度 色彩值 UV 数据读取顺序 :

① 数据高度个数 : Y 数据的高度与图像高度相等 , UV 数据高度相当于 Y 数据高度的一半 ;

② UV 数据排列 : V 色彩值在前, U 饱和度在后, UV 数据交替排列 , 一行 mWidth 中, 排布了 mWidth / 2 组 UV 数据 ;

③ UV 数据组有 mWidth / 2 行, mHeight / 2 列, 因此遍历时, 有如下规则 :

  • 按照行遍历 : 遍历 mWidth / 2 次
  • 按照列遍历 : 遍历 mHeight / 2 次

④ 外层遍历 : 每隔 2 行, 遍历一次, 遍历 mWidth / 2 次 ; 遍历行从mWidth / 2 - 1 到 0 ;

⑤ 内层遍历 : UV 数据也需要倒着读 , 从 0 遍历到 mHeight / 2 - 1 ;

for (int i = mWidth / 2 - 1; i >= 0 ; i --) {
    for (int j = 0; j < UVByteHeight; j++) {
        // 读取数据时, 要从 YByteCount 之后的数据开始遍历
        // 使用 mWidth 和 UVByteHeight 定位要遍历的位置
        // 拷贝 V 色彩值数据
        mNv21DataBuffer[positionIndex++] = data[YByteCount + mWidth / 2 * 2 * j + i];
        // 拷贝 U 饱和度数据
        mNv21DataBuffer[positionIndex++] = data[YByteCount + mWidth / 2 * 2 * j + i + 1];
    }
}

三、 NV21 格式图像旋转代码

    /**
     * 将 NV21 格式的图片数据顺时针旋转 90 度
     * 后置摄像头顺时针旋转 90 度
     * 前置摄像头逆时针旋转 90 度
     * @param data
     */
    private void nv21PictureDataClockwiseRotation90(byte[] data){
        // Y 灰度数据的个数
        int YByteCount = mWidth * mHeight;

        // 色彩度 U, 饱和度 V 数据高度
        int UVByteHeight = mHeight / 2;

        // 色彩度 U, 饱和度 V 数据个数
        int UVByteCount = YByteCount / 4;

        // 数据处理索引值, 用于记录写入到 mNv21DataBuffer 中的元素个数
        // 及下一个将要写入的元素的索引
        int positionIndex = 0;

        /*
            后置摄像头处理
            后置摄像头需要将图像顺时针旋转 90 度
         */
        if(mCameraFacing == Camera.CameraInfo.CAMERA_FACING_BACK){

            /*
                读取 Y 灰度数据
                顺时针旋转 90 度
                外层循环 : 逐行遍历, 从第一行遍历到最后一行
                内存循环 : 遍历每一行时, 从底部遍历到顶部
             */
            for (int i = 0; i < mWidth; i++) {
                // 第 i 行, 从每一列的最后一个像素 ( 索引 mHeight - 1 ) 遍历到第一个像素 ( 索引 0 )
                for (int j = mHeight - 1; j >= 0; j--) {
                    // 将读取到的 Y 灰度值存储到 mNv21DataBuffer 缓冲区中
                    mNv21DataBuffer[positionIndex++] = data[mWidth * j + i];
                }
            }

            /*
                读取 UV 数据

                Y 数据的高度与图像高度相等
                UV 数据高度相当于 Y 数据高度的一半

                UV 数据排列 : V 色彩值在前, U 饱和度在后, UV 数据交替排列
                UV 数据交替排列, 一行 mWidth 中, 排布了 mWidth / 2 组 UV 数据

                UV 数据组有 mWidth / 2 行, mHeight / 2 列, 因此遍历时, 有如下规则 :
                按照行遍历 : 遍历 mWidth / 2 次
                按照列遍历 : 遍历 mHeight / 2 次

                外层遍历 : 遍历行从 0 到 mWidth / 2
                外层按照行遍历时, 每隔 2 行, 遍历一次, 遍历 mWidth / 2 次

                内层遍历时 : 遍历列, 从 mHeight / 2 - 1 遍历到 0
                UV 数据也需要倒着读 , 从 mHeight / 2 - 1 遍历到 0
             */
            for (int i = 0; i < mWidth / 2; i ++) {
                for (int j = UVByteHeight - 1; j >= 0; j--) {
                    // 读取数据时, 要从 YByteCount 之后的数据开始遍历
                    // 使用 mWidth 和 UVByteHeight 定位要遍历的位置
                    // 拷贝 V 色彩值数据
                    mNv21DataBuffer[positionIndex++] = data[YByteCount + mWidth / 2 * 2 * j + i];
                    // 拷贝 U 饱和度数据
                    mNv21DataBuffer[positionIndex++] = data[YByteCount + mWidth / 2 * 2 * j + i + 1];
                }
            }


        }else if(mCameraFacing == Camera.CameraInfo.CAMERA_FACING_FRONT){
            /*
                前置摄像头处理
                前置摄像头与后置摄像头相反, 后置摄像头顺时针旋转 90 度
                前置摄像头需要将图像逆时针旋转 90 度
             */

            /*
                读取 Y 灰度数据
                逆时针旋转 90 度
                外层循环 : 逐行遍历, 从最后一行遍历到第一行, 从 mWidth - 1 到 0
                内存循环 : 遍历第 i 行时, 从顶部遍历到底部, 从 0 到 mHeight - 1
             */
            for (int i = mWidth - 1; i >= 0; i--) {
                // 第 i 行, 从每一列的最后一个像素 ( 索引 mHeight - 1 ) 遍历到第一个像素 ( 索引 0 )
                for (int j = 0; j < mHeight; j++) {
                    // 将读取到的 Y 灰度值存储到 mNv21DataBuffer 缓冲区中
                    mNv21DataBuffer[positionIndex++] = data[mWidth * j + i];
                }
            }

            /*
                读取 UV 数据

                Y 数据的高度与图像高度相等
                UV 数据高度相当于 Y 数据高度的一半

                UV 数据排列 : V 色彩值在前, U 饱和度在后, UV 数据交替排列
                UV 数据交替排列, 一行 mWidth 中, 排布了 mWidth / 2 组 UV 数据

                UV 数据组有 mWidth / 2 行, mHeight / 2 列, 因此遍历时, 有如下规则 :
                按照行遍历 : 遍历 mWidth / 2 次
                按照列遍历 : 遍历 mHeight / 2 次

                外层遍历 : 遍历行从 mWidth / 2 - 1 到 0
                外层按照行遍历时, 每隔 2 行, 遍历一次, 遍历 mWidth / 2 次

                内层遍历时 : 遍历列, 从 0 遍历到 mHeight / 2 - 1
                UV 数据也需要倒着读 , 从 0 遍历到 mHeight / 2 - 1
             */
            for (int i = mWidth / 2 - 1; i >= 0 ; i --) {
                for (int j = 0; j < UVByteHeight; j++) {
                    // 读取数据时, 要从 YByteCount 之后的数据开始遍历
                    // 使用 mWidth 和 UVByteHeight 定位要遍历的位置
                    // 拷贝 V 色彩值数据
                    mNv21DataBuffer[positionIndex++] = data[YByteCount + mWidth / 2 * 2 * j + i];
                    // 拷贝 U 饱和度数据
                    mNv21DataBuffer[positionIndex++] = data[YByteCount + mWidth / 2 * 2 * j + i + 1];
                }
            }

        }
    }

相关文章