失败的2x2 Mipi Raw10转RGB565

已于 2023-12-21 20:37:39 修改
阅读量440 收藏 8
点赞数 6
分类专栏： 检讨书 小项目 FPGA学习 文章标签： 人工智能 算法
于 2023-12-13 21:28:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NoNoUnknow/article/details/134979676
版权
FPGA学习 同时被 3 个专栏收录
57 篇文章 7 订阅
订阅专栏
小项目
11 篇文章 0 订阅
订阅专栏
检讨书
5 篇文章 0 订阅
订阅专栏

反转了，有思路改了，待我思考一番。

---------------------------------------------------------------------------------------------------------------------------------

希望完成的目标：

MIPI在解析以后是四个像素四个像素地产出数据，

我原本希望能够通过2x2窗口来完成de bayer filter操作，

但是写完了，通过验证发现存在以下问题：

首先，1920x1080的图像经过filter，会被缩减行列，这个时候就需要使用Padding操作，

        但是Padding操作会遇到一个问题：此处是四个像素一同进来的，而我仅需要填充一行一列，也就是说，padding会产生额外的三个无用像素，并写进DDR3中，这三个无用像素如何产生的呢？

        我的Padding方式是：在传输完该行数据以后，再进行一次传输，可是因为FIFO的位宽设置为4个像素（raw10的高八位）比较方便，所以最小的执行单位是4个像素，这就是Padding产生的原因！

那么这个问题该如何解决呢？其实也容易，那就是通过拼接直接完成Padding就好了！

但是拼接不可避免地需要考虑到：传输速率是4个像素/一个时钟周期的问题，那我还不如写到DDR3中，再读出来，那一定容易很多！

失败案例：

module Mipi_Bayer_2_RGB #(
    parameter   Image_width = 1920,
    parameter   Image_Higth = 1080,
    parameter   Pixel_Num = 4     ,
    parameter   Col_Max = Image_width/Pixel_Num,
    parameter   I_w = 40
)(
    input   wire                           I_CLK   ,
    input   wire                           I_Rst_n ,
    input   wire                           I_Mipi_Unpacket_V_sync      ,
    input   wire [I_w-1:0]                 I_Mipi_raw10_depacker_Data  ,
    input   wire                           I_Mipi_raw10_depacker_Vaild ,
    output  reg                            O_RGB_Vaild                 ,
    output  wire [63:0]                    O_RGB_Data                   
);
            reg  [12:0]         Row_Cnt_wr     ;
            reg  [12:0]         Row_Cnt_rd     ;
            reg  [12:0]         Col_Cnt_wr     ;          
            reg  [12:0]         Col_Cnt_rd     ;   

        //FIFO
           wire                 FIFO_Wr_EN     ;
            reg                 r_FIFO_Wr_EN   ;
            reg                 rr_FIFO_Wr_EN  ;
           wire  [31:0]         FIFO_Wr_Data   ;
            reg  [31:0]         r1_FIFO_Wr_Data;
            reg  [31:0]         r2_FIFO_Wr_Data;
            reg                 FIFO_Rd_EN     ;
            reg                 r_FIFO_Rd_EN   ;
            reg                 rr_FIFO_Rd_EN  ;
           wire  [31:0]         FIFO_Rd_Data   ;
            reg  [31:0]         r_FIFO_Rd_Data ;
        //Pixel
            reg  [23:0]         Pixel   [3:0]  ;
            reg                 Pixel_flag     ;
        //FIFO 
            wire                full           ;
            wire                empty          ;
            wire                wr_rst_busy    ;
            wire                rd_rst_busy    ;
            reg                 Padding_Lock   ;
            reg [2:0]           Padding_Locking;
    //Col_Cnt_wr
    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            Col_Cnt_wr <= 'd0;
        end else if(I_Mipi_Unpacket_V_sync == 1'b1) begin
            Col_Cnt_wr <= 'd0;
        end else if(I_Mipi_raw10_depacker_Vaild == 1'b1) begin
            if(Col_Cnt_wr == Col_Max - 1'b1) begin
                Col_Cnt_wr <= 'd0;
            end else begin
                Col_Cnt_wr <= Col_Cnt_wr + 1'b1;
            end
        end else begin
            Col_Cnt_wr <= Col_Cnt_wr;
        end
    end 

    //Row_Cnt_wr
    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            Row_Cnt_wr <= 'd0;
        end else if(I_Mipi_Unpacket_V_sync == 1'b1) begin
            Row_Cnt_wr <= 'd0;
        end else if(I_Mipi_raw10_depacker_Vaild == 1'b1 && Col_Cnt_wr == Col_Max - 1'b1) begin
            if(Row_Cnt_wr == Image_Higth - 1'b1) begin
                Row_Cnt_wr <= 'd0;
            end else begin
                Row_Cnt_wr <= Row_Cnt_wr + 1'b1;
            end
        end else begin
            Row_Cnt_wr <= Row_Cnt_wr;
        end
    end 

    //Col_Cnt_rd:
    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            Col_Cnt_rd <= 'd0;
        end else if(I_Mipi_Unpacket_V_sync == 1'b1) begin
            Col_Cnt_rd <= 'd0;
        end else if(FIFO_Rd_EN == 1'b1) begin
            if(Col_Cnt_rd == Col_Max - 1'b1) begin
                Col_Cnt_rd <= 'd0;
            end else begin
                Col_Cnt_rd <= Col_Cnt_rd + 1'b1;
            end
        end else begin
            Col_Cnt_rd <= Col_Cnt_rd;
        end
    end 

    //Row_Cnt_rd 
    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            Row_Cnt_rd <= 'd0;
        end else if(I_Mipi_Unpacket_V_sync == 1'b1) begin
            Row_Cnt_rd <= 'd0;
        end else if(FIFO_Rd_EN == 1'b1 && Col_Cnt_rd == Col_Max - 1'b1) begin 
            if(Row_Cnt_rd == Image_Higth - 1'd1) begin
                Row_Cnt_rd <= 'd0;
            end else begin
                Row_Cnt_rd <= Row_Cnt_rd + 1'b1;
            end
        end else begin
            Row_Cnt_rd <= Row_Cnt_rd;
        end
    end 

    //Pixel_flag
    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            Pixel_flag <= 1'b0;
        end else if(I_Mipi_Unpacket_V_sync == 1'b1) begin
            Pixel_flag <= 1'b0;
        end else if(FIFO_Rd_EN == 1'b1 && Col_Cnt_rd == Col_Max - 1'b1) begin
            Pixel_flag <= ~Pixel_flag;
        end else begin
            Pixel_flag <= Pixel_flag;
        end
    end 

    //FIFO
        assign   FIFO_Wr_EN   =  I_Mipi_raw10_depacker_Vaild ;//方便padding
        assign   FIFO_Wr_Data = {I_Mipi_raw10_depacker_Data[32+:8],
                                 I_Mipi_raw10_depacker_Data[22+:8],
                                 I_Mipi_raw10_depacker_Data[12+:8],
                                 I_Mipi_raw10_depacker_Data[02+:8]}; 

    //FIFO_Rd_EN
    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            FIFO_Rd_EN <= 1'b0;
        end else if(FIFO_Rd_EN == 1'b1 && Col_Cnt_rd == Col_Max - 1'b1) begin
            FIFO_Rd_EN <= 1'b0;
        end else if((Row_Cnt_wr > 'd0) && (I_Mipi_raw10_depacker_Vaild == 1'b1)) begin
            FIFO_Rd_EN <= 1'b1;
        end else begin
            FIFO_Rd_EN <= FIFO_Rd_EN;
        end
    end 

    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            r_FIFO_Rd_EN  <= 'd0;
            rr_FIFO_Rd_EN <= 'd0;
            r_FIFO_Wr_EN  <= 'd0;
            rr_FIFO_Wr_EN <= 'd0;
        end else begin
            r_FIFO_Rd_EN  <= FIFO_Rd_EN  ;
            rr_FIFO_Rd_EN <= r_FIFO_Rd_EN;
            r_FIFO_Wr_EN  <= FIFO_Wr_EN  ;
            rr_FIFO_Wr_EN <= r_FIFO_Wr_EN;
        end
    end 

    //reg
    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            r1_FIFO_Wr_Data <= 'd0;
            r_FIFO_Rd_Data <= 'd0;
            r2_FIFO_Wr_Data <= 'd0;
        end else if(I_Mipi_Unpacket_V_sync == 1'b1) begin
            r1_FIFO_Wr_Data <= 'd0;
            r_FIFO_Rd_Data <= 'd0;
            r2_FIFO_Wr_Data <= 'd0;
        end else begin
            r1_FIFO_Wr_Data <= FIFO_Wr_Data;
            r_FIFO_Rd_Data <= FIFO_Rd_Data;
            r2_FIFO_Wr_Data<= r1_FIFO_Wr_Data;
        end
    end 

    //Padding
    always @(posedge I_CLK) begin
        Padding_Locking <= {Padding_Locking[1:0],Padding_Lock};
    end
    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            Padding_Lock <= 1'b0;
        end else if(rr_FIFO_Rd_EN == 1'b1 && r_FIFO_Rd_EN == 1'b0) begin
            Padding_Lock <= 1'b1;
        end else if(Padding_Locking[2] == 1'b1) begin
            Padding_Lock <= 1'b0;
        end
    end 

    //Pixel
    always @(*) begin
        if(Padding_Lock != 1'b1) begin
            if(Row_Cnt_wr >'d0) begin
                O_RGB_Vaild <= rr_FIFO_Rd_EN;
            end else if(Row_Cnt_wr == 'd0)begin
                O_RGB_Vaild <= rr_FIFO_Wr_EN;
            end        
        end else if(Padding_Lock == 1'b1) begin
            if(Padding_Locking[1] == 1'b1) begin
                O_RGB_Vaild <= 1'b1;
            end else begin
                O_RGB_Vaild <= 1'b0;
            end
        end else begin
            O_RGB_Vaild <= 1'b0;
        end
    end
    assign  O_RGB_Data  = (O_RGB_Vaild)?
                          ({{Pixel[0][23-:5],Pixel[0][15-:6],Pixel[0][7-:5]},
                           {Pixel[1][23-:5],Pixel[1][15-:6],Pixel[1][7-:5]},
                           {Pixel[2][23-:5],Pixel[2][15-:6],Pixel[2][7-:5]},
                           {Pixel[3][23-:5],Pixel[3][15-:6],Pixel[3][7-:5]}}):(64'd0);

    always @(posedge I_CLK or negedge I_Rst_n) begin
        if(I_Rst_n == 1'b0) begin
            Pixel[0] <= 24'd0;     
            Pixel[1] <= 24'd0;   
            Pixel[2] <= 24'd0;  
            Pixel[3] <= 24'd0;
        end else if(Padding_Lock == 1'b1) begin
            Pixel[0] = {r2_FIFO_Wr_Data[16+:8],
                    (r_FIFO_Rd_Data[16+:8]+r2_FIFO_Wr_Data[24+:08])>>1,
                        r_FIFO_Rd_Data[24+:8]};
            Pixel[1] = {r2_FIFO_Wr_Data[16+:8],
                    (r_FIFO_Rd_Data[16+:8]+r2_FIFO_Wr_Data[08+:08])>>1,
                        r_FIFO_Rd_Data[08+:8]};
            Pixel[2] = {r2_FIFO_Wr_Data[00+:8],
                    (r_FIFO_Rd_Data[00+:8]+r2_FIFO_Wr_Data[08+:08])>>1,
                        r_FIFO_Rd_Data[08+:8]};
            Pixel[3] = {r2_FIFO_Wr_Data[00+:8],
                    (r_FIFO_Rd_Data[00+:8]+  r1_FIFO_Wr_Data[24+:08])>>1,
                        FIFO_Rd_Data[24+:8]};
        end else if(Padding_Lock == 1'b0) begin
                if((Row_Cnt_wr > 'd0) && (r_FIFO_Rd_EN == 1'b1)) begin
                    case (Pixel_flag)
                        1'b0:begin
                            Pixel[0] = {r2_FIFO_Wr_Data[16+:8],
                                    (r_FIFO_Rd_Data[16+:8]+r2_FIFO_Wr_Data[24+:08])>>1,
                                        r_FIFO_Rd_Data[24+:8]};
                            Pixel[1] = {r2_FIFO_Wr_Data[16+:8],
                                    (r_FIFO_Rd_Data[16+:8]+r2_FIFO_Wr_Data[08+:08])>>1,
                                        r_FIFO_Rd_Data[08+:8]};
                            Pixel[2] = {r2_FIFO_Wr_Data[00+:8],
                                    (r_FIFO_Rd_Data[00+:8]+r2_FIFO_Wr_Data[08+:08])>>1,
                                        r_FIFO_Rd_Data[08+:8]};
                            Pixel[3] = {r2_FIFO_Wr_Data[00+:8],
                                    (r_FIFO_Rd_Data[00+:8]+  r1_FIFO_Wr_Data[24+:08])>>1,
                                        FIFO_Rd_Data[24+:8]};
                        end
                        1'b1:begin
                            Pixel[0] = {r_FIFO_Rd_Data[16+:8],
                                    (r_FIFO_Rd_Data[24+:8]+r2_FIFO_Wr_Data[16+:08])>>1,
                                        r2_FIFO_Wr_Data[24+:8]};
                            Pixel[1] = {r_FIFO_Rd_Data[16+:8],
                                    (r_FIFO_Rd_Data[08+:8]+r2_FIFO_Wr_Data[16+:08])>>1,
                                        r2_FIFO_Wr_Data[08+:8]};
                            Pixel[2] = {r_FIFO_Rd_Data[00+:8],
                                    (r_FIFO_Rd_Data[08+:8]+r2_FIFO_Wr_Data[00+:08])>>1,
                                        r2_FIFO_Wr_Data[08+:8]};
                            Pixel[3] = {r_FIFO_Rd_Data[00+:8],
                                    (r2_FIFO_Wr_Data[00+:8]+  FIFO_Rd_Data[24+:08])>>1,
                                        r1_FIFO_Wr_Data[24+:8]};
                        end
                        default: begin
                            Pixel[0] = {r2_FIFO_Wr_Data[16+:8],
                                    (r_FIFO_Rd_Data[16+:8]+r2_FIFO_Wr_Data[24+:08])>>1,
                                        r_FIFO_Rd_Data[24+:8]};
                            Pixel[1] = {r2_FIFO_Wr_Data[16+:8],
                                    (r_FIFO_Rd_Data[16+:8]+r2_FIFO_Wr_Data[08+:08])>>1,
                                        r_FIFO_Rd_Data[08+:8]};
                            Pixel[2] = {r2_FIFO_Wr_Data[00+:8],
                                    (r_FIFO_Rd_Data[00+:8]+r2_FIFO_Wr_Data[08+:08])>>1,
                                        r_FIFO_Rd_Data[08+:8]};
                            Pixel[3] = {r2_FIFO_Wr_Data[00+:8],
                                    (r_FIFO_Rd_Data[00+:8]+r1_FIFO_Wr_Data[24+:08])>>1,
                                        FIFO_Rd_Data[24+:8]};
                        end
                    endcase
            end else if((Row_Cnt_wr == 'd0) &&(r_FIFO_Wr_EN)) begin
                            Pixel[0] = {8'b0,
                                        r2_FIFO_Wr_Data[16+:8],
                                        r2_FIFO_Wr_Data[24+:8]};
                            Pixel[1] = {8'b0,
                                        r2_FIFO_Wr_Data[16+:8],
                                        r2_FIFO_Wr_Data[08+:8]};
                            Pixel[2] = {8'b0,
                                        r2_FIFO_Wr_Data[00+:8],
                                        r2_FIFO_Wr_Data[08+:8]};
                            Pixel[3] = {8'b0,
                                        r2_FIFO_Wr_Data[00+:8],
                                      r1_FIFO_Wr_Data[24+:8]};
            end
        end else begin
            Pixel[0] <= 24'd0;     
            Pixel[1] <= 24'd0;   
            Pixel[2] <= 24'd0;  
            Pixel[3] <= 24'd0;
        end
    end


    Sfifo_Raw2RGB_w32x1024_r32x1024  Raw2RGB_FIFO_0(
    .rst        (!I_Rst_n                     ),// input wire rst
    .wr_clk     ( I_CLK                       ),// input wire wr_clk
    .rd_clk     ( I_CLK                       ),// input wire rd_clk
    .din        ( FIFO_Wr_Data                ),// input wire [31 : 0] din
    .wr_en      ( I_Mipi_raw10_depacker_Vaild ),// input wire wr_en
    .rd_en      ( FIFO_Rd_EN                  ),// input wire rd_en
    .dout       ( FIFO_Rd_Data                ),// output wire [31 : 0] dout
    .full       ( full                        ),// output wire full
    .empty      ( empty                       ),// output wire empty
    .wr_rst_busy( wr_rst_busy                 ),// output wire wr_rst_busy
    .rd_rst_busy( rd_rst_busy                 ) // output wire rd_rst_busy
    );
endmodule

NoNoUnknow
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字图像处理（实践篇）三十一 Raw图像数据转为RGB图像实践
静谧、淡雅
01-26 926
数字图像处理（实践篇）三十一 Raw图像数据转为RGB图像实践
RGB转MIPI DSI 桥接芯片 SSD2828库函数 .h
08-24
标签"ssd2828 RGB转MIPI"强调了这个库函数主要服务于将RGB信号转换为MIPI DSI信号的场景。在实际应用中，例如开发一款带有MIPI DSI接口的智能设备显示屏，开发者可以利用这些库函数来简化开发流程，提高代码的可读性...
python opencv 查看MIPI RAW10图像
qq_41079606的博客
04-16 792
非紧凑型是指将sensor输出的raw10数据按16bit存储。根据 CSI-2 协议，RAW10数据packed后数据流如下图。在图像处理中，通常需要将紧凑型转换为非紧凑型。
Unity 3D : RAW 10 bit 轉 RGB ( GPU 版 ) [ 新版本 ]
攝影界的碼農
06-13 904
前言 : 這是改進之前這篇文章 https://blog.csdn.net/weixin_38884324/article/details/80464484 之前寫的方式不完美，所以這次出了一個改進板，性能提升好幾個檔次。 改進之前呼叫兩次 ComputeShader (一次處理 RAW, 一次處理 RGB)，而這次新版本只要呼叫一次 ComputeShader 就好，改進了效能，避免 C...
Unity 3D : RAW 10 bit 轉 RGB
攝影界的碼農
05-26 1105
前言 : 建議先看這篇文章 https://blog.csdn.net/weixin_38884324/article/details/80457594 RAW 轉 RGB 解析度會是原圖的四分之一，這篇程式碼就是將四個像素合併成一個的範例 C # : using System.IO; using UnityEngine; using UnityEngine.UI; public cl...
转rgb565
yuanfen139re的专栏
11-17 820
private void genRGB565() { Bitmap mBitmap = BitmapFactory.decodeFile("/sdcard/test.jpg"); Bitmap mRGB565Bitmap = mBitmap.copy(Bitmap.Config.RGB_565, false); //String mRGB565FileName = "frame
Raw格式的图片理解、读取、转换、显示、对raw10应用和COLOR_BayerBG2RGB理解
qq_45813590的博客
09-28 9677
MIPI raw就充分利用了这6个bit位，每5个字节存储4个像素值，如图1.1所示，每格代表两个bit位，前4个红色的格子存储的是第一个像素的高8位，接着4个黄色的格子存储的是第二个像素的高8位，接着4个绿色的格子存储的是第三个像素的高8位，接着4个蓝色的格子存储的第四个像素的高8位，接着1个蓝色的格子存储的是第4个像素的低2位，接着一个绿色的格子存储的是第3个像素的低2位，接着一个个黄色的格子存储的是第2个像素的低2位，最后一个红色的格子存储的是第1个像素的低2位。每种格式种存在两个G分量。
RGB转MIPI原理图(SSD2828).rar_RGB转MIPI接口_rgb转mipi的原理_ssd2828_ssd2828
07-15
这个是RGB转换MIPI接口原理图，需要的朋友可以拿去。
MIPI raw格式转换，紧凑转非紧凑，mipi raw转16bitraw
07-08
MIPI raw格式转换，紧凑转非紧凑，mipi raw转16bitraw，示例代码，支持的类型转换： enum raw_trans_type{ raw10_continuous, raw10_4_1_low, raw10_4_1_high, raw10_unpacked, unknown_type };
简单"(8bit)Raw图像文件转换为(RGB24)Bmp图像文件"演示源码
04-06
程序功能: 简单"(8bit)Raw图像文件转换为(RGB24)Bmp图像文件"演示. 程序说明: 此程序只适合8bit的Raw图像文件转换, 如果是为10bit或12bit等, 请自己修改程序. "测试图片"文件夹中提供了"8bitRaw图像文件"以及"转换后的Bmp文件".
YUV和MIPI RAW解析、转换和看图软件
11-26
在MIPI RAW中，图像传感器以原始未经处理的像素值输出，这些数据通常包含每个像素的RGB或 Bayer滤镜阵列数据。MIPI CSI-2（MIPI Camera Serial Interface - 2）是实现这种数据传输的常见协议。解析MIPI RAW数据涉及...
10_OpenCV读取原始raw（raw10和raw8），转换成rgb和灰度图，并显示
sinat_41752325的博客
03-14 9184
void ReadRaw8(){ std::string strFilename = "raw8.raw"; int nWidth = 1456; int nHeight = 1096; uint8_t* pRawbuf = new uint8_t[(size_t)nWidth * nHeight]; if (!pRawbuf) { std::cout << "ERROR: 开辟内存失败！" << std::endl; return; } FILE* pfi.
ov5647 mipi-csi2协议解析，纯Verilog编写
qq_43356098的博客
07-24 470
【闲鱼】https://m.tb.cn/h.5c0wxcM?tk=lawOduoa6gc CZ0001 「我在闲鱼发布了【ov5647 mipi-csi2 平替mipi摄像头】」\n点击链接直接打开。ov5647 mipi-csi2 平替mipi摄像头 纯verilog解析代码 bayer阵列 raw10转rgb 代码 未使用xilinx mipi的IP。仅代码，售出不退，介意勿拍。免费提供后续的HDMI显示验证代码，该代码未使用乒乓缓存，会有图片撕裂现象。
基于FPGA的bayer转RGB算法
一个早起的程序员
07-19 3151
Raw RGB 每个像素只有一种颜色（R、G、B中的一种）； RGB 每个像素都有三种颜色，每一个的值在0~255之间； 在手机摄像头的测试过程中，由sensor输出的数据就是Raw data（Raw RGB），经过彩色插值就变成RGB。 也不一定就是测试过程，想要获得真正的图像，都必须有的一个过程； sensor输出的数据格式，主要分两种：YUV（比较流行），RGB，这就是sonsor的数据输出；这其中的GRB就是Raw RGB，是sensor的bayer阵列获取的数据（每种传感器获得对应的颜色亮度）；
Zedboard & Zynq 图像采集 视频开发 (二) FPGA图像采集raw转rgb888
neufeifatonju的博客
03-28 6800
前一篇已经介绍了Zedboard上面搭建图像采集系统的硬件结构，这一篇主要介绍Zynq内部Fpga部分系统设计下面是在本工程的系统框图图像采集OV7725是一款CMOS图像传感器，VGA分辨率，帧率60fps，SCCB协议，与I2C协议通用。这里用HDL编写一个I2C 模块，对ov7725进行初始化，i2c模块是直接采用的crazybingo的设计，这里不再赘述，只是列出ov7725寄存器初始化列...
LINUX下简单实现ISP图像处理从RAW到RGB，BMP算法、RGB到JPEG库的使用（一）
zzzzzz_9的博客
04-13 2576
在LINUX环境下用软件简单实现一部分ISP图像处理功能，并尝试了解处理流程，以及各个域之间的关系。
摄像头工程师说 Camera - 数据格式 RAW、RGB(1)
wangyx1234的博客
09-19 3771
1）本文从摄像头工作的基本原理说起，讲述 RAW、RGB、ARGB、RGB24 等数据格式的定义。2）RAW 格式的数据，根据对每种颜色的表示使用几个 bit，也可以分为 RAW8、RAW10、RAW12 等类型。3）RGB 数据是 RAW 数据组合得到的，根据组合顺序，可以组合得到 RGB、BGR 等格式的数据。4）一些应用场景需要的数据带宽小、或者需要采集的颜色类型不多，这种情况下可以使用数据量更小的 RGB565、RGB555 等格式。
2024钉钉杯A题思路详解
最新发布
全栈川川
07-26 1801
2024钉钉杯思路
mipi raw10转换成 raw10的C代码和raw10转raw8的代码
06-11
下面是 mipi raw10 转换成 raw10 的 C 代码： ```c #include <stdio.h> void mipi_raw10_to_raw10(unsigned char *input, unsigned char *output, int width, int height) { int i, j; int index = 0; int output_index = 0; unsigned short pixel; for (i = 0; i < height; i++) { for (j = 0; j < width; j += 4) { pixel = input[index++] << 2; pixel |= input[index] >> 6; output[output_index++] = pixel & 0xff; output[output_index++] = (pixel >> 8) & 0xff; pixel = (input[index++] & 0x3f) << 4; pixel |= input[index] >> 4; output[output_index++] = pixel & 0xff; output[output_index++] = (pixel >> 8) & 0xff; pixel = (input[index++] & 0x0f) << 6; pixel |= input[index] >> 2; output[output_index++] = pixel & 0xff; output[output_index++] = (pixel >> 8) & 0xff; pixel = (input[index++] & 0x03) << 8; pixel |= input[index++]; output[output_index++] = pixel & 0xff; output[output_index++] = (pixel >> 8) & 0xff; } } } ``` 下面是 raw10 转换成 raw8 的 C 代码： ```c #include <stdio.h> void raw10_to_raw8(unsigned char *input, unsigned char *output, int width, int height) { int i, j; int index = 0; int output_index = 0; unsigned short pixel; for (i = 0; i < height; i++) { for (j = 0; j < width; j += 4) { pixel = input[index++] << 2; pixel |= input[index] >> 6; output[output_index++] = pixel >> 2; pixel = (input[index++] & 0x3f) << 4; pixel |= input[index] >> 4; output[output_index++] = pixel >> 2; pixel = (input[index++] & 0x0f) << 6; pixel |= input[index] >> 2; output[output_index++] = pixel >> 2; pixel = (input[index++] & 0x03) << 8; pixel |= input[index++]; output[output_index++] = pixel >> 2; } } } ``` 以上代码仅供参考，具体实现需要根据具体的需求进行修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值