jpg转yuv420抠图后转为jpg

　　最近遇到个需求，已有全景图和其中的人脸坐标，将人脸小图从全景图中抠出来，最开始使用libjpeg，奈何使用libjpeg将jpg转为yuv420的资料实在少，libjpeg自身的readme和example也是异常简陋，只介绍了常用函数，却没有具体的yuv数据计算方法，搞了两天最后jpg解码yuv成功后，再切图后继续转为jpg后将数据写到文件发现问题，小图始终没有数据。

　　无奈只能copy代码中原有的一份算法解码库，进行类似操作后，小图转为jpg后还是空的，求助算法大佬后发现自己一开始就给自己写了个大bug，就是小图yuv转为jpg后是存储在malloc的一段内存里的，类型为char*,一开始为了数据copy方便，就直接将jpg的指针赋给了std::string,再利用string中数据写到文件里，导致文件一直是空的，其实小图的jpg数据已经成功的转化了，只是自己没理解char*指针和string的区别，以为所有指针都可以直接赋给std::string，其实char*型指针里如果保存的是类似图片数据这种不是标准的字符串的话，是很容易出现数据被截断的情况的，如果实在要赋值的话，需要加上需要复制的长度才行，实在汗颜，期间遇到很多指针操作，如三级指针、指针数组、指针分配内存（要使用指针必须分配内存或者指向已分配内存的地址，还要注意不要提前释放掉还在使用的指针指向的内存）、指针转string(指针若指向的非标准字符串则赋给std::string时需要加上需要复制的长度)，char*和unsigned char*的区别（例如16进制0xffffffff存储在char*里表示为-1，存储在unsigned char*里表示为0xff），感觉自己对C的指针了解还是太少。

　　除此之外，我发现一个更深层次的问题就是自己遇到新的东西不愿意去思考和了解，固步自封，只知道百度现成代码复制粘贴，也不去思考复制过来的代码是什么原理，适不适用现有业务，也不知道看官方的例子（虽然libjpeg官方的例子实在是有点垃圾，但是最好还是要先看下官方文档），也让我了解到需要学习的地方还有很多，基础知识还是相当的薄弱，还需要不断学习。

　　说了这么多，还是把这次研究了好几天的jpg转yuv420p，yuv420p转jpg的代码分享出来下，供大家参考(参考博文：https://www.cnblogs.com/zhq-blog/p/8858293.html)：

　　

#include <windows.h>
#include <iostream>
#include <vector>
#include <memory>
#include <jpeglib.h>

#define NEW_BUFFER(param, len) if(!param)\
{ param = new unsigned char[len];}\
else { delete param; param = new unsigned char[len];};

using namespace std;

unsigned char** yuvptr_[3];
std::vector< std::vector<unsigned char*> > yuvbuf_(3);
unsigned char* m_pYbuffer = NULL;
unsigned char* m_pUbuffer = NULL;
unsigned char* m_pVbuffer = NULL; 

std::string jpg_to_yuv420p(char* pBuffer, int nSize, int &uPicWidth, int &uPicHeight)
{
    struct jpeg_error_mgr e_;
    jpeg_decompress_struct info_;
    info_.err = jpeg_std_error(&e_);
    jpeg_create_decompress(&info_);
    jpeg_mem_src(&info_, (unsigned char*)pBuffer, nSize); //// 指定图片在内存的地址及大小 
    jpeg_read_header(&info_, 1);
    info_.out_color_space = JCS_YCbCr;
    info_.raw_data_out = 1;
    info_.do_fancy_upsampling = FALSE;
    jpeg_start_decompress(&info_);


    for (int i = 0; i < 3; ++i)
    {
        yuvbuf_[i].resize(info_.output_width);
        yuvptr_[i] = &yuvbuf_[i][0];
    }

    int nLen = info_.output_width * info_.output_height;

    NEW_BUFFER(m_pYbuffer, nLen);
    NEW_BUFFER(m_pUbuffer, nLen);
    NEW_BUFFER(m_pVbuffer, nLen);

    unsigned char* row = m_pYbuffer;
    yuvptr_[0][0] = row;
    for (int i = 0; i < info_.output_height; ++i, row += info_.output_width)
    {
        yuvptr_[0][i] = row; //y 分量空间初始化 
    }

    row = m_pUbuffer;
    for (int i = 0; i < info_.output_height; i += 2, row += info_.output_width / 2)
    {
        yuvptr_[1][i / 2] = row; //u 分量初始化

    }

    row = m_pVbuffer;
    for (int i = 0; i < info_.output_height; i += 2, row += info_.output_width / 2)
    {
        yuvptr_[2][i / 2] = row; //v 分量初始化
    }

    for (int i = 0; i < info_.output_height; i += 16)
    {
        int nRows = 16;
        if ((info_.output_height) < (i + 16))
        {
            nRows = info_.output_height - i;
        }
        jpeg_read_raw_data(&info_, yuvptr_, nRows);
        yuvptr_[0] += 16;
        yuvptr_[1] += 8;
        yuvptr_[2] += 8;
    }
    uPicWidth = info_.image_width;
    uPicHeight = info_.image_height;


    std::string Y((char*)yuvbuf_[0][0], uPicWidth*uPicHeight);

    std::string U((char*)yuvbuf_[1][0], uPicWidth*uPicHeight / 4);

    std::string V((char*)yuvbuf_[2][0], uPicWidth*uPicHeight / 4);

    
    std::string YUV = Y + U + V;

    cout << YUV.size() << endl;

    jpeg_finish_decompress(&info_);
    jpeg_destroy_decompress(&info_);

    return YUV;
}

int yuv420p_to_jpeg(unsigned char* pdata, int image_width, int image_height, int quality)
{
    if (image_width == 0 || image_height == 0) {
        cout << "err param\n";
        return 0;
    }
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);
    unsigned char *outbuffer;
    unsigned long size = 0;
    jpeg_mem_dest(&cinfo, &outbuffer, &size);

    cinfo.image_width = image_width; // image width and height, in pixels 
    cinfo.image_height = image_height;
    cinfo.input_components = 3; // # of color components per pixel 
    cinfo.in_color_space = JCS_YCbCr; //colorspace of input image 
    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, quality, TRUE);

    ////////////////////////////// 
    // cinfo.raw_data_in = TRUE; 
    cinfo.jpeg_color_space = JCS_YCbCr;
    cinfo.comp_info[0].h_samp_factor = 2;
    cinfo.comp_info[0].v_samp_factor = 2;
    ///////////////////////// 
    jpeg_start_compress(&cinfo, TRUE);

    JSAMPROW row_pointer[1];

    unsigned char *yuvbuf;
    if ((yuvbuf = (unsigned char *)malloc(image_width * 3)) != NULL)
        memset(yuvbuf, 0, image_width * 3);

    unsigned char *ybase, *ubase, *vbase;
    ybase = pdata;
    ubase = pdata + image_width*image_height;
    vbase = ubase + image_width*image_height / 4;
    int j = 0;
    while (cinfo.next_scanline < cinfo.image_height)
    {
        int idx = 0;
        for (int i = 0; i < image_width; i++)
        {
            yuvbuf[idx++] = ybase[i + j * image_width];
            yuvbuf[idx++] = ubase[j / 2 * image_width/2 + (i / 2)];
            yuvbuf[idx++] = vbase[j / 2 * image_width/2 + (i / 2)];
        }
        row_pointer[0] = yuvbuf;
        jpeg_write_scanlines(&cinfo, row_pointer, 1);
        j++;
    }
    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);
    if (yuvbuf != NULL)
    {
        free(yuvbuf);
    }

    FILE *fp = NULL;
    errno_t err;
    err = fopen_s(&fp, "C:/Users/chenwenjun/Desktop/ok.jpg", "wb");
    if (fp) {
        fwrite(outbuffer, size, 1, fp);
        fclose(fp);
    }
    else {
        cout << "nok\n";
    }

    free(outbuffer);
}

int main()
{
    std::shared_ptr<char> PicData = NULL;

    //get pic data 
    FILE* fp = NULL;
    errno_t err;
    err = fopen_s(&fp, "C:/Users/chenwenjun/Desktop/test.jpg", "rb");
    if (!err) {
        PicData.reset(new char[2 * 2448 * 3264]);
        fread((void*)PicData.get(), 2 * 2448 * 3264, 1, fp);
        fclose(fp);
    }
    else {
        cout << "nok\n";
    }

    //jpg -> yuv
    int uPicWidth = 0, uPicHeight = 0;
    std::string YUVData = jpg_to_yuv420p(PicData.get(), 2 * 2448 * 3264, uPicWidth, uPicHeight);

    //yuv -> jpg
    yuv420p_to_jpeg((unsigned char*)const_cast<char*>(YUVData.c_str()), uPicWidth, uPicHeight, 100);

    Sleep(1000000);
    
    return 0;
}