[OpenCL] 读取一张jpg图像，将其remap操作,并做耗时统计。

已于 2024-07-08 15:36:30 修改
阅读量553 收藏
点赞数 13
文章标签： opencv c++ gpu算力 图像处理
于 2024-07-04 17:28:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AndreLe/article/details/140185047
版权

本文示例为利用opencv读取一张jpg图像，并且利用gpu-opencl对其进行左右翻转，并将结果保存到jpg。

代码如下：

首先读取和保存图像接口：

1.data_io.h


#ifdef APPLE        //平台相关代码
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif

#include <opencv2/opencv.hpp>
#include <opencv2/highgui.hpp>

cl_int Load_image_by_opencv(const std::string &filename,cl_mem *imageObjects,cl_context context,int &img_h,int &img_w);

void Save_pic_by_opencv(const std::string &filename,unsigned char  *rd,int &img_h,int &img_w);

 2.data_io.cpp

#include "data_io.h"


cl_int Load_image_by_opencv(const std::string &filename,cl_mem *imageObjects,cl_context context,int &img_h,int &img_w)
{
    //3.加载图像
    cl_int errNum;
    src_Image = cv::imread(filename);
    img_h = src_Image.rows;
    img_w = src_Image.cols;
    u_char *rd=src_Image.data;
    imageObjects[0] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, 
                                    sizeof(u_char)*3*img_h*img_w, rd, &errNum);                

    return errNum;
}


void Save_pic_by_opencv(const std::string &filename,unsigned char  *rd,int &img_h,int &img_w)
{
   cv::Mat src_Image =cv::Mat(img_h, img_w, CV_8UC3, (void*)rd);
   cv::Mat dst_Image(img_h, img_w, CV_8UC3);
   cv::cvtColor(src_Image, dst_Image,cv::COLOR_RGB2BGR);
   cv::imwrite(filename, dst_Image);

}

其次，主函数：

3.main.cp

#include <iostream>
#include <fstream>
#include <sstream>


#ifdef APPLE        //平台相关代码
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif

#include "data_io.h"



//在第一个平台中创建只包括GPU的上下文
cl_context CreateContext()
{
    cl_int errNum;
    cl_uint numPlatforms;
    cl_platform_id firstPlatformId;
    cl_context context = NULL;
    
    
    // 选择第一个平台
    errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
    if (errNum != CL_SUCCESS || numPlatforms <= 0)
    {
        std::cerr << "Failed to find any OpenCL platforms." << std::endl;
        return NULL;
    }
 
    //cout<<"numPlatforms="<<numPlatforms<<endl; 1

    // 接下来尝试通过GPU设备建立上下文
    cl_context_properties contextProperties[] =
    {
        CL_CONTEXT_PLATFORM,
        (cl_context_properties)firstPlatformId,
        0
    };
    context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
                                      NULL, NULL, &errNum);

    

    if (errNum != CL_SUCCESS)
    {
        std::cout << "Could not create GPU context, trying CPU..." << std::endl;
        context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,
                                          NULL, NULL, &errNum);
        if (errNum != CL_SUCCESS)
        {
            std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
            return NULL;
        }
    }
 
    return context;
}


//在第一个设备上创建命令队列
cl_command_queue CreateCommandQueue(cl_context context, cl_device_id *device)
{
    cl_int errNum;
    cl_device_id *devices;
    cl_command_queue commandQueue = NULL;
    size_t deviceBufferSize = -1;
 
    // 首先获得设备的信息
    errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &deviceBufferSize);
    if (errNum != CL_SUCCESS)
    {
        std::cerr << "Failed call to clGetContextInfo(...,GL_CONTEXT_DEVICES,...)";
        return NULL;
    }
 
    if (deviceBufferSize <= 0)
    {
        std::cerr << "No devices available.";
        return NULL;
    }
 
    //为设备分配内存
    devices = new cl_device_id[deviceBufferSize / sizeof(cl_device_id)];
    errNum = clGetContextInfo(context, CL_CONTEXT_DEVICES, deviceBufferSize, devices, NULL);
    if (errNum != CL_SUCCESS)
    {
        std::cerr << "Failed to get device IDs";
        return NULL;
    }
 
    // 选择第一个设备并为其创建命令队列
    commandQueue = clCreateCommandQueue(context, devices[0], CL_QUEUE_PROFILING_ENABLE, NULL);
    //commandQueue = clCreateCommandQueue(context, devices[0], 0, NULL);
    if (commandQueue == NULL)
    {
        std::cerr << "Failed to create commandQueue for device 0";
        return NULL;
    }
    
    //释放信息
    *device = devices[0];
    delete [] devices;
    return commandQueue;
}
 

 //  创建OpenCL程序对象
cl_program CreateProgram(cl_context context, cl_device_id device, const char* fileName)
{
    cl_int errNum;
    cl_program program;
 
    std::ifstream kernelFile(fileName, std::ios::in);
    if (!kernelFile.is_open())
    {
        std::cerr << "Failed to open file for reading: " << fileName << std::endl;
        return NULL;
    }
 
    std::ostringstream oss;
    oss << kernelFile.rdbuf();
 
    std::string srcStdStr = oss.str();
    const char *srcStr = srcStdStr.c_str();
    program = clCreateProgramWithSource(context, 1,
                                        (const char**)&srcStr,
                                        NULL, NULL);
    if (program == NULL)
    {
        std::cerr << "Failed to create CL program from source." << std::endl;
        return NULL;
    }
 
    errNum = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
    if (errNum != CL_SUCCESS)
    {
        // 输出错误信息
        char buildLog[16384];
        clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,
                              sizeof(buildLog), buildLog, NULL);
 
        std::cerr << "Error in kernel: " << std::endl;
        std::cerr << buildLog;
        clReleaseProgram(program);
        return NULL;
    }
 
    return program;
}


//获取最接近的倍数
size_t RoundUp(int groupSize, int globalSize)
{
    int r = globalSize % groupSize;
    if(r == 0)
    {
         return globalSize;
    }
    else
    {
         return globalSize + groupSize - r;
    }
}


//清除资源
void Cleanup(cl_context context, cl_command_queue commandQueue,
             cl_program program, cl_kernel kernel, cl_mem imageObjects[2])
{
    for (int i = 0; i < 2; i++)
    {
        if (imageObjects[i] != 0)
            clReleaseMemObject(imageObjects[i]);
    }
    if (commandQueue != 0)
        clReleaseCommandQueue(commandQueue);
 
    if (kernel != 0)
        clReleaseKernel(kernel);
 
    if (program != 0)
        clReleaseProgram(program);
    

    if (context != 0)
        clReleaseContext(context);
 
}

int main()
{
    


    //initial varibles
    cl_int errNum=0;
    cl_device_id device = 0;
    cl_context context = 0;
    cl_program program = 0;
    cl_kernel kernel = 0;
    cl_command_queue commandQueue = 0;
    cl_sampler sampler = 0;
    cl_mem imageObjects[2] = { 0, 0 };
    
    int img_w = 3840;
    int img_h = 2176; 

    size_t read_size=img_w*img_h*3;

    size_t g_w=0;
    size_t g_h=0;
    
    std::string input_file,output_jpgfile;
    char *kernel_file=new char [100];
    char *kernel_name=new char [100];
   
    int new_w=0;
    int new_h=0;

   input_file="../data/dst1.jpg";
   output_jpgfile="../data/01dst_remap.jpg";
   strcpy(kernel_file,"remap.cl");
   strcpy(kernel_name,"kernel_remap");
        
   
     // 1.选择platform,创建contex上下文
    context = CreateContext();
    if (context == NULL)
    {
        std::cerr << "Failed to create OpenCL context." << std::endl;
        return 1;
    }
    
    
    // 2.创建命令队列
    commandQueue = CreateCommandQueue(context, &device);
    if (commandQueue == NULL)
    {
        std::cerr <<"CreateCommandQueue failed"<<std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;
    }
    
    
    // 3. 确保设备支持这种图像格式
    cl_bool imageSupport = CL_FALSE;
    clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof(cl_bool),
                    &imageSupport, NULL);
    if (imageSupport != CL_TRUE)
    {
        std::cerr << "OpenCL device does not support images." << std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        
        return 1;
    }
    
     //4.准备输入数据 
    
    
    errNum=Load_image_by_opencv(input_file,imageObjects,context,img_h,img_w);
  
    if (errNum != CL_SUCCESS)
    { 
        std::cerr << "Load_image failed." << std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;

    }

    
    // 5.创建输出的图像对象
   
     new_w=img_w;
     new_h=img_h;
     read_size=sizeof(u_char)*img_h*img_w*3;
         
    imageObjects[1] = clCreateBuffer(context, CL_MEM_WRITE_ONLY, 
                                    read_size, NULL, &errNum);
    
     if (errNum != CL_SUCCESS)
    { 
        std::cerr << "create output imageobject failed." << std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;

    }

 
    //6.创建OpenCL-program对象
    
    program = CreateProgram(context, device, kernel_file);
    if (program == NULL)
    {
        std::cerr <<"CreateProgram failed"<<std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;
    }
    
    // 7.创建OpenCL核

    kernel = clCreateKernel(program, kernel_name, NULL);
    
    if (kernel == NULL)
    {
        std::cerr << "Failed to create kernel" << std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;
    }
 
  
    //8. 设定参数
   
        float map_x[img_w];
        float map_y[img_h];

        for (int i = 0; i < img_w; i++) 
        {
            map_x[i] = img_w - i - 1;
        }
        for (int j = 0; j < img_h; j++) 
        {
            map_y[j] = j;
        }

        int ioff=0;
        int hoff=0;

        cl_mem mem_mapx = clCreateBuffer(context, CL_MEM_READ_ONLY| CL_MEM_COPY_HOST_PTR, 
                                    sizeof(float)*img_w, &map_x, &errNum);

        cl_mem mem_mapy = clCreateBuffer(context, CL_MEM_READ_ONLY| CL_MEM_COPY_HOST_PTR, 
                                    sizeof(float)*img_h, &map_y, &errNum);
        
        errNum  = clSetKernelArg(kernel, 0, sizeof(cl_mem), &imageObjects[0]);
        errNum |= clSetKernelArg(kernel, 1, sizeof(cl_mem) ,&mem_mapx);
        errNum |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &mem_mapy);
        errNum |= clSetKernelArg(kernel, 3, sizeof(cl_int) ,&ioff);
        errNum = clSetKernelArg(kernel, 4, sizeof(cl_int), &hoff);
        errNum |= clSetKernelArg(kernel, 5, sizeof(cl_mem), &imageObjects[1]);
        
    if (errNum != CL_SUCCESS)
    {
        std::cerr << "Error setting kernel arguments." << std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;
    }
    
    g_w=new_w;
    g_h=new_h;

    size_t localWorkSize[2] = { 16, 16 };
    size_t globalWorkSize[2] =  { RoundUp(localWorkSize[0], g_w),
                                  RoundUp(localWorkSize[1], g_h) };
    
    //9.启动内核，内核执行完成后，会将evt置为CL_SUCCESS/CL_COMPLETE
    cl_event evt;
    
    errNum = clEnqueueNDRangeKernel(commandQueue, kernel,  
                               2, 0, globalWorkSize, localWorkSize, 
                               0, NULL, &evt);  
     if (errNum != CL_SUCCESS)
    {
        std::cerr << "Error clEnqueueNDRangeKernel errNum=." <<errNum<< std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;
    }

    clFinish(commandQueue);
    clWaitForEvents(1, &evt);   //等待命令事件发生
    
    cl_ulong time_start= (cl_ulong)0;
    cl_ulong time_end= (cl_ulong)0;
    double total_time;
    
    clGetEventProfilingInfo(evt, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, NULL);
    clGetEventProfilingInfo(evt, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, NULL);
    clReleaseEvent(evt);
    

    total_time =(double)( time_end - time_start);
    printf("\nExecution time in milliseconds = %f ms\n", (total_time / 1000000.0) );

    //10.读回数据
      
    u_char *read_data = new u_char [read_size];
    errNum =clEnqueueReadBuffer(commandQueue, imageObjects[1], 
                            CL_TRUE, 
                            0, 
                            read_size, 
                            read_data, 0, NULL, NULL);
    if (errNum != CL_SUCCESS)
    {
        std::cerr << "Error reading result buffer enume." <<errNum<< std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;
    }
     
    if (read_data == NULL)
    {
        std::cerr << "Error reading result buffer null." <<errNum<< std::endl;
        Cleanup(context, commandQueue, program, kernel, imageObjects);
        return 1;
    }
    
    //显示图像
   
    Save_pic_by_opencv(output_jpgfile,read_data,img_h,img_w);

    Cleanup(context, commandQueue, program, kernel, imageObjects);
    
    std::cout<<"NV12 convert to rgb via opencl success!"<<std::endl;

    return 0;
}

4.remap.cl


#define BRD_CHECK(x, y, X, Y, input_ptr, data)            \
    if ((x) >= 0 && (x) < (X) && (y) >= 0 && (y) < (Y)) { \
        const int inoff = mad24((y), (X), (x));           \
        data = vload3(inoff, (input_ptr));                \
    }

        
__kernel void kernel_remap(const __global uchar *vinput,
        const __global float *mapx, const __global float *mapy, const int ioff,
        const int bhoff,__global uchar *vout)
        {
      //获取当前线程中输出的(w,h)坐标
    const int w = get_global_id(0);
    const int h = get_global_id(1);
    
    const int WIDTH = 3840;
    const int HEIGHT = 2176;

    const int dmMaxX = 3840;
    const int dmMaxY = 2176;

    uchar3 data = 0;

  
    const float src_x = mapx[w];
    const float src_y = mapy[h];


    const int x1 = convert_int_rtn(src_x);
    const int y1 = convert_int_rtn(src_y);
    const int x2 = x1 + 1;
    const int y2 = y1 + 1;

    int bh = h;
    do {
        vinput += ioff;
        bh += bhoff;
        float3 out = 0;
        {
            uchar3 src_reg = 0;
            BRD_CHECK(x1, y1, dmMaxX, dmMaxY, vinput, src_reg);
            out = out + convert_float3(src_reg) * ((x2 - src_x) * (y2 - src_y));
        }
        {
            uchar3 src_reg = 0;
            BRD_CHECK(x2, y1, dmMaxX, dmMaxY, vinput, src_reg);
            out = out + convert_float3(src_reg) * ((src_x - x1) * (y2 - src_y));
        }
        {
            uchar3 src_reg = 0;
            BRD_CHECK(x1, y2, dmMaxX, dmMaxY, vinput, src_reg);
            out = out + convert_float3(src_reg) * ((x2 - src_x) * (src_y - y1));
        }
        {
            uchar3 src_reg = 0;
            BRD_CHECK(x2, y2, dmMaxX, dmMaxY, vinput, src_reg);
            out = out + convert_float3(src_reg) * ((src_x - x1) * (src_y - y1));
        }

        float3 rgb = out;

        //用于将一个`float3`类型的向量存储到指定的内存地址中
        vstore3(convert_uchar3_sat(rgb), mad24(bh, WIDTH, w), vout);

        
    } while (0);
}

5.Makefile

demo : main.cpp data_io.cpp
	g++ `pkg-config opencv4 --cflags` main.cpp data_io.cpp -o demo `pkg-config opencv4 --libs` -D CL_TARGET_OPENCL_VERSION=100 -lOpenCL

AndreLe
关注
Boost：在OpenCL并将图像渲染为OpenGL中的纹理
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-24 420
Boost：在OpenCL并将图像渲染为OpenGL中的纹理实现功能C++实现代码 实现功能 Boost的compute模块，在OpenCL并将图像渲染为OpenGL中的纹理 C++实现代码 #include <iostream> #include <algorithm> #include <QtGlobal> #if QT_VERSION >= 0x050000 #include <QtWidgets> #else #include <QtGui
C语言利用opencl实现图像处理 包括yuv(NV12)转rgb、remap、resize、crop等，并做了耗时统计
07-08
代码包括8个分支功能的实现： token=0；读取raw文件（NV12格式），转rgb，输出jpg图像。 token=1；读取jpg文件，remap操作，输出jpg图像。 token=2；读取jpg文件，resize操作，输出jpg图像。 token=3；读取jpg文件，crop操作，输出jpg图像。 token=4；读取raw文件（NV12格式），转rgb+remap操作，输出jpg图像。 token=5；读取raw文件（NV12格式），转rgb+resize操作，输出jpg图像。 token=6；读取raw文件（NV12格式），转rgb+remap+resize操作，输出jpg图像。 token=7；读取raw文件（NV12格式），转rgb+remap+crop操作，输出jpg图像。 其中： scale_w、scale_h为缩放因子。 s_x，s_y为裁剪起始坐标。 new_w，new_h为输出图像大小。
opencl解码jpeg图像
05-31
详情参考这篇文章：一个使用opencl解码jpeg图像的demo https://blog.csdn.net/u014691333/article/details/125071119?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22125071119%22%2C%22source%22%3A%22u014691333%22%7D&ctrtid=fMeUc
RK3588使用 opengl 版的opencv 报错 OpenCL program build log: imgproc/color_rgb 解决记录
最新发布
weixin_57069064的博客
07-26 483
而后又看到了 这篇文章 【RK opencv CPU && GPU】： https://blog.csdn.net/qq_36784503/article/details/130306905。当我使用下面代码进行测试时（其实就是使用了 GPU 版的 Opencv进行处理时，开启了 Opencl加速，开启加速后，就出现问题了）找到 ./opencv/modules/imgproc/src/imgwarp.cpp 文件 的 ocl_remap 函数，找到。所以，这个方式自然不能解决我的问题。
[OpenCL] 读取一张raw图像(NV12格式)，转rgb格式并remap操作，输出jpg图像，并统计GPU-kernel耗时。
AndreLe的博客
07-08 212
对于raw文件而言，读取其中的NV12格式的数据，需要利用二进制进行读取，再经过GPU处理后，保存输出的数据为jpg文件。
[OpenCL-C++绑定] 利用opencl，读取并resize一张raw图(NV12格式)，指定quality的JPEG压缩，输出jpg图像,并统计耗时。
AndreLe的博客
07-09 332
本文采用opencl，读取一张raw图(NV12格式)的,对数据进行resize+指定quality(例如：60)的压缩，最后输出一张jpg图像保存在本地。
OpenCL测试内核运行时间
qq_39229006的博客
10-10 1535
1、创建命令队列时需要设置CL_QUEUE_PROFILING_ENABLE cl_command_queue command_queue; command_queue = clCreateCommandQueue(context, device_id, CL_QUEUE_PROFILING_ENABLE, &err); 2、运行内核时绑定一个event cl_event event; err=clEnqueueNDRangeKernel(queue, kernel, 1 ,NULL, work
利用opencl，读取并resize一张raw图(NV12格式)，指定quality的JPEG压缩，输出jpg图像,并统计耗时
07-09
本资源采用opencl的C++绑定。 首先，读取一张raw图（NV12格式）， 其次，利用gpiu对其进行resize并以指定quality对其进行JPEG压缩， 最后，输出一张jpg图像到本地。
利用opencl，读取一张raw图（NV12格式），并对其进行指定quality的JPEG压缩，输出jpg图像到本地,并统计耗时
07-09
本资源采用opencl的C++绑定，实现了对nv12数据的JPEG压缩，可自定义quality。
opencl GPU加速rgb图像缩放 核函数参考
05-23
RGB图像缩放是图像处理中的基本操作，它涉及将图像的尺寸调整到新的大小，可以是等比例放大或缩小，也可以是非等比例变换。OpenCL通过定义核函数（Kernel Function）可以在GPU上执行像素级别的并行计算，这对于处理...
简单"(8bit)Raw图像文件转换为(RGB24)Bmp图像文件"演示源码
04-06
程序功能: 简单"(8bit)Raw图像文件转换为(RGB24)Bmp图像文件"演示. 程序说明: 此程序只适合8bit的Raw图像文件转换, 如果是为10bit或12bit等, 请自己修改程序. "测试图片"文件夹中提供了"8bitRaw图像文件"以及"转换后的Bmp文件".
Bayer数据转RGB（RGGB格式的纯软件简易快速转换）
07-27
Bayer数据转RGB源码，编译通过，目前只支持1080P并且格式为RGGB，不同平台表现可能不同，本人在zynq7000测试时间23ms，PC端测试5ms，其他平台的转换速度可能有差异，甚至更慢。另外需要说明转换比较简单，对转换效果有要求的请注意。
Verilog实现 Bayer转RGB Vivado IP核
09-22
Verilog编写的cmos摄像头驱动，bayer转RGB格式的vivado IP核 可直接加入工程使用。
一个使用opencl解码jpeg图像的demo
u014691333的博客
05-31 729
前言 参考这篇文章：Jpeg 库的解码OpenCL优化 然后自己写了一个符合自己代码风格的demo，在这里分享一下 工程组织形式 . ├── .vscode // vscode的隐藏目录 ├── CMakeLists.txt ├── prebuild.sh // 这个脚本用来编译libjpeg库的 ├── bin // 生成执行文件的目录 ├── inc ├──...
opencv raw转rgb_使用OpenCV将12位拜耳图像转换为8位RGB
weixin_34797871的博客
01-14 2873
我可以使用以下代码将我的数据转换为8位RGB：// Copy the data into an OpenCV Mat structurecv::Mat bayer16BitMat(height, width, CV_16UC1, inputBuffer);// Convert the Bayer data from 16-bit to to 8-bitcv::Mat bayer8BitMat = ...
OpenCV之remap的使用
hulinhulin的专栏
08-15 1444
opencv的remap使用例子
用python打开视频_Python 读取 YUV(NV12) 视频文件实例
weixin_39529903的博客
11-26 1322
一、YUV 简介YUV：是一种颜色编码方法，常使用在各个视频处理组件中Y'UV, YCbCr, YPbPr等专有名词都可以称为 YUV，彼此有重叠Y表示明亮度（单取此通道即可得灰度图），U和V则是色度、浓度主流的采样方式有三种，YUV4:4:4，YUV4:2:2，YUV4:2:0可以根据其采样格式来从码流中还原每个像素点的 YUV 值，进而通过 YUV 与 RGB 的转换公式提取出每个像素点的 R...
Opencl 图像处理
qq_40553788的博客
06-11 435
上述代码中，我们首先使用libjpeg库读取JPEG图像数据，并将其存储在一个unsigned char类型的数组中。然后，我们使用OpenCL对图像进行处理，最后将处理后的图像数据保存为JPEG格式。在OpenCL部分，我们首先初始化OpenCL环境，然后加载OpenCL内核代码，创建OpenCL内存对象，并将JPEG图像数据复制到OpenCL内存对象中。最后，我们启动内核函数，从OpenCL内存对象中读取处理后的图像数据，并将其保存为JPEG格式。在程序结束时，我们释放OpenCL资源和内存。
OpenGL Shader编程：NV12 转 RGB
WuNL的博客
08-09 5833
OpenGL Shader编程：NV12 转 RGB最近在学习FFmpeg调用Nvidia硬件编解码，其中在解码这里计划做一个多路硬件解码加显示。由于使用了显卡来干活那么CPU注定是个酱油角色，初步规划CPU只完成解码后的scale工作。据我观察老黄的显卡里面有个视频引擎应该是个独立的部分只负责处理编解码，视频引擎之外的计算能力当然不能浪费，格式转换准备拿到GPU中完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值