笔者在上篇中写了一个初步的nv21与yuv444互转的代码，这里重新写了一下，提速不少！

    1. void nv21_to_yuv444(String nv21_file, Mat & YUV_img, int height, int width)
    2. {
    3.     FILE * fp;
    4.     // fopen_s(&fp, nv21_file.c_str(), "rb");
    5.     fp = fopen(nv21_file.c_str(), "rb");
    6.     // nv21_to_yuv444
    7.     int nv21_size = height * width;
    8.     int half_nv21_size = nv21_size >> 1;
    9.     // int quarter_nv21_size = nv21_size >> 2;
    10.     // int half_height = height >> 1;
    11.     int half_width = width >> 1;
    12.     uchar *Y_block_ptr = (uchar *)malloc(nv21_size * sizeof(uchar));
    13.     uchar *vu_block_ptr = (uchar *)malloc(half_nv21_size * sizeof(uchar));
    14.     // uchar *v_block_ptr = (uchar *)malloc(quarter_nv21_size * sizeof(uchar));
    15.     // uchar *u_block_ptr = (uchar *)malloc(quarter_nv21_size * sizeof(uchar));
    16.     fread(Y_block_ptr, sizeof(uchar), nv21_size, fp);
    17.     fseek(fp, nv21_size, SEEK_SET);
    18.     fread(vu_block_ptr, sizeof(uchar), half_nv21_size, fp);
    19.     // uchar * V_block_ptr = (uchar *)malloc(nv21_size * sizeof(uchar));
    20.     // uchar * U_block_ptr = (uchar *)malloc(nv21_size * sizeof(uchar));
    22.     // Mat Y_img(height, width, CV_8UC1, Y_block_ptr);
    24.     Vec3b * YUV_img_ptr = (Vec3b *)YUV_img.data;
    26.     for (int i = 0; i < half_nv21_size;)
    27.     {
    28.         for (int j = 0; j < half_width; ++j)
    29.         {
    30.             uchar v_val = *vu_block_ptr++;
    31.             uchar u_val = *vu_block_ptr++;
    33.             // method_1
    34.             /*
    35.             Vec3b & yuv_img_pixel_1 = *YUV_img_ptr;
    36.             Vec3b & yuv_img_pixel_3 = *(YUV_img_ptr + width);
    37.             Vec3b & yuv_img_pixel_2 = *(++YUV_img_ptr);
    38.             Vec3b & yuv_img_pixel_4 = *(YUV_img_ptr + width);
    39.             YUV_img_ptr++;
    41.             // Y, U, V
    42.             yuv_img_pixel_1 = Vec3b(*Y_block_ptr, u_val, v_val);
    43.             yuv_img_pixel_3 = Vec3b(*(Y_block_ptr + width), u_val, v_val);
    44.             yuv_img_pixel_2 = Vec3b(*(++Y_block_ptr), u_val, v_val);
    45.             yuv_img_pixel_4 = Vec3b(*(Y_block_ptr + width), u_val, v_val);
    46.             Y_block_ptr++;
    47.             */
    49. #if 0        
    50.              // method_2: slow
    51.             *YUV_img_ptr = Vec3b(*Y_block_ptr, u_val, v_val);
    52.             *(YUV_img_ptr + width) = Vec3b(*(Y_block_ptr + width), u_val, v_val);
    54.             ++YUV_img_ptr;
    55.             ++Y_block_ptr;
    57.             *(YUV_img_ptr) = Vec3b(*Y_block_ptr, u_val, v_val);
    58.             *(YUV_img_ptr + width) = Vec3b(*(Y_block_ptr + width), u_val, v_val);
    60.             ++YUV_img_ptr;
    61.             ++Y_block_ptr;
    62. #else
    64.             // method_3: fast
    65.             Vec3b & yuv_img_pixel_1 = *YUV_img_ptr;
    66.             Vec3b & yuv_img_pixel_3 = *(YUV_img_ptr + width);
    67.             Vec3b & yuv_img_pixel_2 = *(++YUV_img_ptr);
    68.             Vec3b & yuv_img_pixel_4 = *(YUV_img_ptr + width);
    69.             ++YUV_img_ptr;
    71.             // Y, U, V
    72.             yuv_img_pixel_1[0] = *Y_block_ptr;
    73.             yuv_img_pixel_3[0] = *(Y_block_ptr + width);
    74.             yuv_img_pixel_2[0] = *(++Y_block_ptr);
    75.             yuv_img_pixel_4[0] = *(Y_block_ptr + width);
    76.             ++Y_block_ptr;
    78.             yuv_img_pixel_1[1] = u_val;
    79.             yuv_img_pixel_3[1] = u_val;
    80.             yuv_img_pixel_2[1] = u_val;
    81.             yuv_img_pixel_4[1] = u_val;
    83.             yuv_img_pixel_1[2] = v_val;
    84.             yuv_img_pixel_3[2] = v_val;
    85.             yuv_img_pixel_2[2] = v_val;
    86.             yuv_img_pixel_4[2] = v_val;
    87. #endif
    88.             i += 2;
    89.         }
    90.         YUV_img_ptr += width;
    91.         Y_block_ptr += width;
    92.     }
    93. }
    Mat yuv444_to_nv21(Mat & YUV_srcImg, int height, int width)
{
    int size = height * width;
    int quarter_size = size >> 2;
    int half_height = height >> 1;
    int half_width = width >> 1;
    Mat nv21_img(height + half_height, width, CV_8UC1);
    uchar *y_nv21_img_ptr = nv21_img.data;
    uchar *vu_nv21_img_ptr = nv21_img.data +  size;
    Vec3b * YUV_srcImg_ptr = (Vec3b *)YUV_srcImg.data;
    for (int i = 0; i < size; ++i)
    {
        Vec3b & YUV_srcImg_pixel = *YUV_srcImg_ptr++;
        *y_nv21_img_ptr++ = YUV_srcImg_pixel[0];
    }

    YUV_srcImg_ptr = (Vec3b *)YUV_srcImg.data;
    for (int i = 0; i < half_height; ++i) {
        for (int j = 0; j < half_width; ++j)
        {
            Vec3b & YUV_srcImg_pixel = *YUV_srcImg_ptr++;
            *vu_nv21_img_ptr++ = YUV_srcImg_pixel[2];
            *vu_nv21_img_ptr++ = YUV_srcImg_pixel[1];

            YUV_srcImg_ptr++;
        }
        YUV_srcImg_ptr += width;
    }
    return nv21_img;
}