图像YUV转RGB以及缩放

已于 2024-01-23 18:12:25 修改
阅读量485 收藏 7
点赞数 9
文章标签： 视频编解码
于 2023-12-12 14:09:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43346673/article/details/134948010
版权

NV12图像存储格式：
在这里插入图片描述
YUV转RGBA

typedef struct
{
    int width;
    int height;
    unsigned char *pY;
    unsigned char *pUv;
    char *pRgb;
}t_workThreadData;

void ConvertYuv420SPToRgbV6ForThread(unsigned char* pYuvBuff, unsigned char* pUv, char* pRgbBuff, int imgWidth, int imgHeight)
{
    int r,g,b;
    int y,u,v;
    int rowIdx = 0, colIdx = 0;
    if (imgWidth < 1 || imgHeight < 1 || pYuvBuff == NULL || pRgbBuff == NULL)
        return ;
    unsigned char* yData = pYuvBuff;
    unsigned char* uvData = pUv;
    int rowOffset = 0;
    int tmp298Y = 0;

    int yIdx,uvIdx;
    PRINT_VAAPI_LOG("Convert:  w:%d, h:%d\n", imgWidth, imgHeight);
    for (rowIdx = 0; rowIdx < imgHeight; rowIdx++){ //height
        rowOffset = rowIdx * imgWidth;
        for (colIdx = 0; colIdx < imgWidth; colIdx++){ //width
            yIdx = rowOffset + colIdx;

            uvIdx = (rowIdx>>1) * imgWidth + (colIdx>>1<<1);

            y = yData[yIdx];
            u = uvData[uvIdx];
            v = uvData[uvIdx+1];

            tmp298Y = 298*y;
            r = (tmp298Y + 411*v - 57344) >> 8;
            g = (tmp298Y - 101*u - 211*v + 34739) >> 8;
            b = (tmp298Y + 519*u - 71117) >> 8;

            if(r > 255) {
               r = 255;
            }
            if(r < 0) {
               r = 0;
            }
            if(g > 255) {
               g = 255;
            }
            if(g < 0) {
               g = 0;
            }
            if(b > 255) {
               b = 255;
            }
            if(b < 0) {
               b = 0;
            }

            pRgbBuff[4*yIdx] = b;
            pRgbBuff[4*yIdx+1] = g;
            pRgbBuff[4*yIdx+2] = r;
            pRgbBuff[4*yIdx+3] = 255;
        }
    }
}

void* workThreadForYuvConvert(void* argv)
{
    t_workThreadData* pThreadData = (t_workThreadData*)argv;

    ConvertYuv420SPToRgbV6ForThread(pThreadData->pY, pThreadData->pUv, pThreadData->pRgb, pThreadData->width, pThreadData->height);
    return NULL;
}
void AssignThreadForYuvConvert(int threadCount, unsigned char* pYuvBuff, char* pRgbBuff, int imgWidth, int imgHeight) {
    int partHeight = 0;
    int i = 0;
    t_workThreadData *pThreadData = NULL;
    pthread_t *pThreadId = NULL;
    unsigned char* uvData = &pYuvBuff[imgWidth * imgHeight];

    //Ensure threadCount is 2^n!
    if ((threadCount&(threadCount - 1))) {
        return;
    }

    pThreadData = malloc(threadCount * sizeof(t_workThreadData));
    pThreadId = malloc(threadCount * sizeof(t_workThreadData));
    partHeight = imgHeight / threadCount;

    for (i = 0; i < threadCount; i++) {
        pThreadData[i].height = partHeight;
        pThreadData[i].width = imgWidth;
        pThreadData[i].pY = pYuvBuff + i * partHeight * imgWidth;
        pThreadData[i].pUv = uvData + i * (partHeight>>1) * imgWidth;
        pThreadData[i].pRgb = pRgbBuff + ((i * partHeight * imgWidth) << 2);
        pthread_create(&pThreadId[i],NULL,workThreadForYuvConvert,(void*)&pThreadData[i]);
    }

    for (i = 0; i < threadCount; i++) {
        pthread_join(pThreadId[i], NULL);
    }

    free(pThreadData);
    free(pThreadId);


}

RGBA转YUV

typedef struct
{
    int width;
    int height;
    unsigned char *pY;
    unsigned char *pUv;
    char *pRgb;
}t_workThreadData;

void rgb_convert_yuv(unsigned char* pYuvBuff, unsigned char* pUv, char* pRgbBuff, int imgWidth, int imgHeight)
{
    int r,g,b;
    int y,u,v;
    int rowIdx = 0, colIdx = 0;
    if (imgWidth < 1 || imgHeight < 1 || pYuvBuff == NULL || pRgbBuff == NULL)
        return ;
    unsigned char* yData = pYuvBuff;
    unsigned char* uvData = pUv;
    int rowOffset = 0;

    int yIdx,uvIdx = 0;
    PRINT_VAAPI_LOG("Convert:  w:%d, h:%d\n", imgWidth, imgHeight);
    for (rowIdx = 0; rowIdx < imgHeight; rowIdx++){ //height
        rowOffset = rowIdx * imgWidth;
        for (colIdx = 0; colIdx < imgWidth; colIdx++){ //width
            yIdx = rowOffset + colIdx;

            uvIdx = (rowIdx>>1) * imgWidth + (colIdx>>1<<1);

            b = pRgbBuff[4*yIdx];
            g = pRgbBuff[4*yIdx+1];
            r = pRgbBuff[4*yIdx+2];

            y = ((66*r + 129*g + 25*b) >> 8) + 16;
            u = ((-38*r - 74*g + 112*b) >> 8) + 128;
            v = ((112*r - 94*g - 18*b) >> 8) + 128;

            if(y < 16) {
                y = 16;
            }
            if(y > 235) {
                y = 235;
            }
            if(u < 16) {
                u = 16;
            }
            if(u > 240) {
                u = 240;
            }
            if(v < 16) {
                v = 16;
            }
            if(v > 240) {
                v = 240;
            }
            yData[yIdx] = y;
            uvData[uvIdx] = u;
            uvData[uvIdx+1] = v;
        }
    }
}

void* workThreadForRGBConvert(void* argv)
{
    t_workThreadData* pThreadData = (t_workThreadData*)argv;

    rgb_convert_yuv(pThreadData->pY, pThreadData->pUv, pThreadData->pRgb, pThreadData->width, pThreadData->height);

    return NULL;
}

void AssignThreadForRGBConvert(int threadCount, unsigned char* pYuvBuff, char* pRgbBuff, int imgWidth, int imgHeight) {
    int partHeight = 0;
    int i = 0;
    t_workThreadData *pThreadData = NULL;
    pthread_t *pThreadId = NULL;
    unsigned char* uvData = &pYuvBuff[imgWidth * imgHeight];

    //Ensure threadCount is 2^n!
    if ((threadCount&(threadCount - 1))) {
        return;
    }

    pThreadData = malloc(threadCount * sizeof(t_workThreadData));
    pThreadId = malloc(threadCount * sizeof(pthread_t));
    partHeight = imgHeight / threadCount;

    for (i = 0; i < threadCount; i++) {
        pThreadData[i].height = partHeight;
        pThreadData[i].width = imgWidth;
        pThreadData[i].pY = pYuvBuff + i * partHeight * imgWidth;
        pThreadData[i].pUv = uvData + i * (partHeight>>1) * imgWidth;
        pThreadData[i].pRgb = pRgbBuff + ((i * partHeight * imgWidth) << 2);
        pthread_create(&pThreadId[i],NULL,workThreadForRGBConvert,(void*)&pThreadData[i]);
    }

    for (i = 0; i < threadCount; i++) {
        pthread_join(pThreadId[i], NULL);
    }

    free(pThreadData);
    free(pThreadId);
}

RGBA缩放
理论依据：https://blog.csdn.net/qq_37756660/article/details/133874378


/* nearest neighbor interpolation */
int image_scale_v2(u8 *src_rgba, u8 * dst_rgba, int src_w, int src_h, int dst_w, int dst_h)
{
    //scale up or down ratio
    float ratio_w = (float)src_w / (float)dst_w;
    float ratio_h = (float)src_h / (float)dst_h;
    int x0, y0;
    unsigned int src_pix_idx, dst_pix_idx;

    for(int dst_y = 0; dst_y < dst_h; dst_y++) {
        for(int dst_x = 0; dst_x < dst_w; dst_x++) {
            // coordinate map from dst to src
            x0 = (float)dst_x * ratio_w;
            y0 = (float)dst_y * ratio_h;

            /* pixel index */
            dst_pix_idx = (dst_y * dst_w + dst_x) << 2;
            src_pix_idx = (y0 * src_w + x0) << 2;
            // compute dst rgba piexl, b g r a
            // for(int i = 0; i < 4; i++) {
            //     /* nearest neighbor interpolation */
            //     dst_rgba[dst_pix_idx + i] = src_rgba[src_pix_idx + i];
            // }
            /* vectorized */
            uint8x8_t src_vec8x8 = vld1_u8(src_rgba+src_pix_idx);
            vst1_u8(dst_rgba+dst_pix_idx, src_vec8x8);


        }
    }
}

/* bilinear interpolation */
int image_scale_v1(u8 *src_rgba, u8 * dst_rgba, int src_w, int src_h, int dst_w, int dst_h)
{
    //scale up or down ratio
    float ratio_w = (float)src_w / (float)dst_w;
    float ratio_h = (float)src_h / (float)dst_h;
    float src_x, src_y, dealt_x, dealt_y;
    int x0, y0;
    float k0, k1, k2, k3;
    unsigned int src_pix_idx, dst_pix_idx, src_pix_idx_y_next;

    for(int dst_y = 0; dst_y < dst_h; dst_y++) {
        for(int dst_x = 0; dst_x < dst_w; dst_x++) {
            // coordinate map from dst to src
            src_x = (float)dst_x * ratio_w;
            src_y = (float)dst_y * ratio_h;
            // the nearest src coordinate after map
            x0 = (int)src_x;
            y0 = (int)src_y;
            /* pixel index */
            dst_pix_idx = 4 * (dst_y * dst_w + dst_x);
            src_pix_idx = 4 * (y0 * src_w + x0);
            src_pix_idx_y_next = 4*((y0+1)*src_w + x0);
            // the weight of around four coordinate pixel
            dealt_x = (src_x - (float)x0);
            dealt_y = (src_y - (float)y0);
            k0 = dealt_x * dealt_y;
            k1 = (1.0 - dealt_x) * dealt_y;
            k2 = dealt_x * (1.0 - dealt_y);
            k3 = (1.0 - dealt_x) * (1.0 - dealt_y);
            // compute dst rgba piexl, b g r a
            for(int i = 0; i < 4; i++) {
                /* bilinear interpolation */
                dst_rgba[dst_pix_idx + i] = k3 * src_rgba[src_pix_idx + i] + 
                                            k2 * src_rgba[src_pix_idx + i + 4] +
                                            k1 * src_rgba[src_pix_idx_y_next + i] +
                                            k0 * src_rgba[src_pix_idx_y_next + i + 4];
            }
        }
    }
    return 0;
}


void *workThreadForImageScale(void *argv)
{
    pthread_data *thread_data = (pthread_data *)argv;
    image_scale_v1(thread_data->pRgbBuffSrc, thread_data->pRgbBuffDst,
                thread_data->src_w, thread_data->src_h,
                thread_data->dst_w, thread_data->dst_h);
    return NULL;
}

void AssignThreadForImageScale(char *pRgbBuffSrc, char *pRgbBuffDst, 
                               int width, int height, 
                               int winWidth, int winHeight)
{
    if(pRgbBuffSrc == NULL || pRgbBuffDst == NULL) {
        return;
    }
    pthread_t *thread_id = NULL;
    pthread_data *thread_data = NULL;
    int thread_count = 4;
    int part_height_src = height / thread_count;
    int part_height_dst = winHeight / thread_count;
    thread_id = malloc(thread_count * sizeof(pthread_t));
    thread_data = malloc(thread_count * sizeof(pthread_data));
    
    for(int i = 0; i < thread_count; i++) {
        thread_data[i].pRgbBuffSrc = pRgbBuffSrc + i * part_height_src * width * 4;
        thread_data[i].pRgbBuffDst = pRgbBuffDst + i * part_height_dst * winWidth * 4;
        thread_data[i].src_w = width;
        thread_data[i].src_h = part_height_src;
        thread_data[i].dst_w = winWidth;
        thread_data[i].dst_h = part_height_dst;
        pthread_create(&thread_id[i], NULL, workThreadForImageScale, (void *)&thread_data[i]);
    }
    
    for(int i = 0; i < thread_count; i++) {
        pthread_join(thread_id[i], NULL);
    }

    free(thread_id);
    free(thread_data);

    return;
}
悟空不再悟空
关注
python实现yuv转RGB图片程序
11-09
为了实现这个转换，你需要创建一个函数，接受YUV图像数据，然后使用上述公式计算出对应的RGB值。这可以通过遍历YUV数组的每个元素并执行转换来完成。最后，你可以使用PIL或numpy的保存函数将结果写入新的RGB图像文件...
图像放缩算法
青城的专栏
03-09 2438
   最近要对图像进行放缩研究，网上有不少的例子，但是都不是很全面，亲自写了一个，直接上代码   这个图像放缩主要是针对YUV 4:2:0进行的， 图像的大小也是整16的倍数，自己压缩的流。   现在基本图像放缩算法主要有三种： 1：最近邻域法，就是取坐标反向变换后最接近的点。 优点：速度快 缺点：画质不好 2：双线性差值，利用坐标反向面换后坐标的周围点，然后根据距离关
RGB和YUV的转换
qq_1335857320的博客
10-24 186
RGB和YUV的转换
分别使用Opencv、FFmepg、LibYUV将YUV数据转换为RGB
学无止尽，谨言慎行！
08-27 6224
前言 本文主要针对他们的效率讨论为目的，而不做具体的转换分析。 在日常开发中，特别是在编解码的项目中，数据格式转换是很常见的，如YUV转RGB、YU12转I420、亦或者其他格式等等，我们常用的转换方式，要么使用Opencv的cvtColor()，要么使用FFmepg的sws_scale()，单帧图片进行转换还好，但如果我们在视频处理过程中使用，就会发现数据延迟，内存增长等各种问题，常见的处理方...
libyuv
最新发布
李峰的专栏
01-25 716
1：先使用libyuv的ConvertToI420函数把UYVY格式转换为I420格式，再对I420进行缩放，再对I420进行旋转，再使用libyuv的I420ToRGB565函数把I420格式转换为RGB565格式。用下面方案把大尺寸的UYVY视频转换为小尺寸的RGB565视频，输出画面内容混乱，偏绿，画面很不清晰，画面有很多小网格，请分析下面代码，并给出修正后能使输出的RGB565画面正常的代码，并给出完整的新方案。
非整数倍率YUV422图像的自由缩放算法
ninver2007的专栏
10-18 1966
下面的代码,实现将一幅YUV422的双通道图片(640x480大小)，取中间区域(560x400大小)使用插值的办法放大至(640x480)。这个算法可以用来实现将图片外围区域截掉。 #define X_RATIO (8) #define Y_RATIO (6) PUBLIC void YUVScale(JINF_YUV_CHN_T *const yuv_ptr,const uint
图像处理算法大全（基于libyuv或IPP）----RGB24缩放
xjb2006的专栏
06-27 1456
《周星星教你学ffmpeg》技巧ipp源码：static void RGB_Resize(BYTE* pin, BYTE* pout, int width,int height,int desWidth,int desHeight)//RGB缩放函数{ IppiSize srcsz={width,height}, dstroi={desWidth,desHeight};  IppiRect src...
RGB32转换yuv420方法
01-29
这些公式是基于ITU-R BT.601标准，将RGB的每个分量线性缩放并加权后得到YUV的相应分量。其中，Y表示亮度，U和V表示色差，它们有助于保留图像的色彩信息。在YUV420格式中，U和V的采样率只有Y的一半，这意味着每4个...
C# YUV数据转RGB转bitmap图源码，保证能用
09-14
综上所述，"C# YUV数据转RGB转bitmap图源码"涉及到的知识点包括YUV和RGB颜色模型、YUV到RGB的色彩空间转换、C# Bitmap类的使用以及从视频流中提取帧数据的技巧。掌握这些技能对于处理视频捕获、图像处理和多媒体应用...
yuv420转rgb565
10-22
### YUV420转RGB565：深入解析与实现 #### 一、YUV420格式介绍 在图像处理领域，YUV是一种广泛使用的颜色空间模型，它将图像的颜色信息分解为亮度（Y）和色度（U、V）两个分量。其中，Y代表亮度（Luminance），而U...
YUV转RGB图片格式转换
01-26
YUV转RGB
opengl es2.0 -YUV-RGB互转+显示到手机屏幕 DEMO
04-30
opengl es2.0 读取位图 先用opengl转换成yuv然后再转回rgb最后输出到显示屏上
uyvy422(yuv422)到RGB888转换详解
06-12
总结来说，uyvy422到RGB888的转换是一个常见的图像处理任务，涉及到YUV色彩空间与RGB色彩空间的相互转换，这个过程中需要注意色彩分量的提取、转换以及范围调整。通过实践并理解这个转换过程，对于深入理解图像处理...
基于YUV422的图像缩放 (双线性插值)
热门推荐
jtujtujtu的专栏
03-31 1万+
      通常的摄像头读取的数据都是YUV422格式的,如果想要支持数码变焦,我们需要对他进行缩放操作,当然具体点应该是放大操作,因为我们都是把采集到的图像的局部放大,称为数码变焦.      在测试过程中尝试了很多不同的方法,包括了Gdiplus, Opencv, Ippi 以及自己编写的基于YUV422的插值操作.      这里简单介绍下基于Gdiplus, Opencv和Ippi
YUV转RGB（Android）
细心程度决定你的成败
08-14 7401
在相机中我们需要对相机拍摄回调时，进行一些预处理，这样方便我们进行转码。mCamera.setPreviewCallback(new PreviewCallback(){ @Override public void onPreviewFrame(byte[] data, Camera camera) { });在这个回调里我们就能够获取到
图像处理算法大全（基于libyuv或IPP）----YUV420缩放
xjb2006的专栏
06-27 2584
《周星星教你学ffmpeg》技巧libyuv源码：static void Resize_YV12(BYTE* pIn, BYTE* pOut, LONG nInWidth, LONG nInHeight, LONG nOutWidth, LONG nOutHeight){ BYTE *inY=pIn; BYTE *inU=pIn+nInWidth*nInHeight; BYTE *inV=pIn+...
YUV(二)-YUV格式转换缩放
朱韦刚(zhuweigangzwg)的技术博客
12-09 1万+
YUV(二)-YUV格式转换缩放    本文主要讲解yuv各种格式相互转换的功能实现及原理，以常用的yuv420p,yuv422p,yuv444p作为转换格式比较清晰的解析各 种格式，以及用ffmpeg做转换的实现，同时有需要的朋友也可以用opencv做实现。    （一）：内存采样     YUV码流的存储格式其实与其采样的方式密切相关，主流的采样方式有三种，YUV4:4:4，YUV4:
过采样将YUV420P图像展宽一倍
皮皮#2500
02-22 344
过采样将YUV420P图像展宽一倍YUV420P的数据格式完整代码实现效果参考链接 想要完成平面纹理与球面纹理的映射，平面纹理图像比例必须是width:height=2:1,因为这个比例的全景图片刚好可以还原成一张球形全景图。如果拿到的图像源宽高比是1:1，需要将其过采样到宽高比2:1才能完成映射。 YUV420P的数据格式 YUV由Y、U、V这三个分量组成，Y分量主管亮度的（其实就是灰度图），U...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值