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;
}