devbox
寸_铁
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

MIPIRaw转UnpackRaw_mipi raw

作者：寸_铁 | 2024-08-10 15:01:42

赞

踩

mipi raw

Mipiraw和unpackraw区别 

传感器采集的RAW数据通常为10bit，存储RAW数据需要两个Byte，而其中有6个bit位是空着的，这样就有存储空间浪费。MIPI RAW数据充分利用了这个特性，采用5个Byte，共40bit存储4个RAW数据。大部分UnpackRaw图都是以小端模式存储，MipiRaw则是大端存储。Raw图只有数据，没有其他属性信息。

下面依次详细解释raw图存储格式 和 MSB、LSB的排列方式 以及 转换方法。

上图：

一、10Bit转换

1、大小端和MSB、LSB解释

1.1、十六进制示意图

.对应MiPiRaw的十六进制

.对应UnpackRaw的十六进制

1.2、大小端判断

UnpackRaw：

从UnpackRaw的十六进制看，前两个字节为 5D 00，像素值为93，而十六进制0x5D对应的十进制就是93。从结果推理前两个字节标识的像素字节为单位排列应该是 00 5D，从而判断是小端模式存储。

小端模式：高有效位在高地址，低有效在低地址，从右向左读就是正确的数据排列。

大端模式：高有效位在低地址，低有效位在高地址，从左向右都就是正确的数据排列。

注意大小端模式以字节为单位。

MIpiRaw：

从上面MipiRaw的十六进制来看是大端模式，将两个最低有效位存储到公共字节中，如下图：

0x17 << 2 + 0x39 & 0x03 = 0x0001011101，即0x00 5D，即93

1.3、MSB和LSB的判断

首先看一张图片：

大端模式和小端模式字节内均有两种存储方式。

UnpackRaw：

从1.3的图中可以看出

UnpackRaw是小端模式 + 字节内MSB优先的存储方式

MipiRaw是大端模式 + 字节内MSB优先的存储方式

结论：UnpackRaw是小端模式 + 字节内MSB优先的存储方式。

MipiRaw是大端模式 + 字节内MSB优先的存储方式。

2、转换方法

2.1、存储示意图

10 Bpp：

Unpackraw

4个像素占用8个字节。灰色是空置未使用的bit位。

MipiRaw

4个像素占用5个字节

2.2、代码实现

代码实现将MipiRaw的排列改为UnpackRaw的排列，代码实现如下：

参数：

pIn：指源文件指针

pOut：指输出文件指针

number：指MipiRaw的像素个数，即宽*高

代码实现将MipiRaw的排列改为UnpackRaw的排列，代码实现如下：

1.0版本

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <iostream>
  5.  
  6. typedef unsigned char BYTE; // 定义BYTE类型，占1个字节
  7.  
  8. void MipiRaw10ToP10(BYTE* pIn, BYTE* pOut, long number)
  9. {
  10.     printf("enter MipiRaw10ToP10\n");
  11.     int index = 0;
  12.     // 5个字节4个像素
  13.     // 前面4个字节都是对应像素的高8位，最后一个字(第五个)每个像素的低2位
  14.     // MIPIRaw 大端模式
  15.     // BYTE0 :P1[0:7]
  16.     // BYTE1 :P2[0:7]
  17.     // BYTE2 :P3[0:7]
  18.     // BYTE3 :P4[0:7]
  19.     // BYTE4 :P4[8:9]P3[8:9]P2[8:9]P1[8:9]
  20.     // UnpackRaw 小端模式
  21.     // Pix1: BYTE0:[2:9], BYTE1:[0:1] == BYTE0:(P1[0:7]<< 2 + P1[8:9]), BYTE1:(P1[0:7] >> 6)
  22.     // Pix2: 上同
  23.     // Pix3: 上同
  24.     // Pix4: 上同
  25.     // Big endian
  26.     for (long i = 0; i < (number * 5) / 4; i = i + 5)
  27.     {
  28.         pOut[index++] = ((pIn[i] << 2) & 0xfc) | (pIn[i + 4] & 0x03);
  29.         pOut[index++] = (pIn[i] >> 6) & 0x03;
  30.  
  31.         //pIn[i+4] >>= 2;
  32.         pOut[index++] = ((pIn[i + 1] << 2) & 0xfc) | ((pIn[i + 4] >> 2) & 0x03);
  33.         pOut[index++] = (pIn[i + 1] >> 6) & 0x03;
  34.  
  35.         //pIn[i+4] >>= 2;
  36.         pOut[index++] = ((pIn[i + 2] << 2) & 0xfc) | ((pIn[i + 4] >> 4) & 0x03);
  37.         pOut[index++] = (pIn[i + 2] >> 6) & 0x03;
  38.  
  39.         //pIn[i+4] >>= 2;
  40.         pOut[index++] = ((pIn[i + 3] << 2) & 0xfc) | ((pIn[i + 4] >> 6) & 0x03);
  41.         pOut[index++] = (pIn[i + 3] >> 6) & 0x03;
  42.     }
  43.     printf("MipiRaw10ToP10 over\n");
  44. }

二、12Bit转换

一个像素占用12个bit，两个字节空置4个bit未使用。MipiRaw则是3个字节存储两个像素，最后一个字节保留两个像素最低四位的有效位数据。

1、大小端、MSB和LSB

1.1、十六进制示意图

MipiRaw：

Unpackraw：

1.2、大小端及MSB和LSB的判断

根据十六进制上示意图：

根据像素值，然后从十六进制就可以看出Unpack是小端模式。根据如上示意图，看出字节内是MSB优先。

从示意图看出，MipiRaw是大端存储方式，最低四位有效位放在公共字节。

结论：UnpackRaw是小端模式 + 字节内MSB优先的存储方式。

MipiRaw是大端模式 + 字节内MSB优先的存储方式。

2、转换方法

2.1、存储示意图

12Bpp：

UnpackRaw

2个像素占用4个字节

MipiRaw

2个像素占用3个字节

2.2代码实现

1.0版本

代码实现：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <iostream>
  5.  
  6. typedef unsigned char BYTE; // 定义BYTE类型，占1个字节
  7.  
  8. void MipiRaw12ToP12(BYTE* pIn, BYTE* pOut, long number)
  9. {
  10.     printf("enter MipiRaw12ToP12\n");
  11.     int index = 0;
  12.     // 3个字节2个像素
  13.     // 前面2个字节都是对应像素的高8位，最后一个字(第3个)每个像素的低4位
  14.     // MIPIRaw 大端模式
  15.     // BYTE0 :P1[0:7]
  16.     // BYTE1 :P2[0:7]
  17.     // BYTE2 :P2[8:11]P1[8:11]
  18.     // UnpackRaw 小端模式
  19.     // Pix1: BYTE0:[4:11], BYTE1:[0:3] == BYTE0:(P1[0:7]<< 4 + P1[8:11]), BYTE1:(P1[0:7] >> 4)
  20.     // Pix2: 上同
  21.     // Big endian
  22.     for (long i = 0; i < (number * 3) / 2; i = i + 3)
  23.     {
  24.         pOut[index++] = ((pIn[i] << 4) & 0xf0) | (pIn[i + 2] & 0x0f);
  25.         pOut[index++] = (pIn[i] >> 4) & 0x0f;
  26.  
  27.         //pIn[i+2] >>= 4;
  28.         pOut[index++] = ((pIn[i + 1] << 4) & 0xf0) | ((pIn[i + 2] >> 4) & 0x0f);
  29.         pOut[index++] = (pIn[i + 1] >> 4) & 0x0f;
  30.     }
  31.     printf("MipiRaw12ToP12 over\n");
  32. }

三、14Bit转换

一个像素占用14个bit，两个字节空置2个bit未使用。MipiRaw则是7个字节存储4个像素，最后3个字节保留四个像素最低6位的有效位数据。

1、大小端、MSB和LSB

1.1、十六进制示意图

MipiRaw

UnpackRaw

1.2、大小端及MGS和LSB的判断

根据像素值，然后从十六进制就可以看出Unpack是小端模式。根据如上示意图，看出字节内是MSB优先。

从示意图看出，MipiRaw是大端存储方式，最低6位有效位放在公共字节。

结论：UnpackRaw是小端模式 + 字节内MSB优先的存储方式。

MipiRaw是大端模式 + 字节内MSB优先的存储方式。

2、代码实现

1.0版本

  1. void MipiRaw14ToP14(BYTE* pIn, BYTE* pOut, long number)
  2. {
  3.     printf("enter MipiRaw14ToP14\n");
  4.     int index = 0;
  5.     // 7个字节4个像素
  6.     // 前面4个字节都是对应像素的高8位，最后3个字对应每个像素的低6位
  7.     // BYTE0 :P1[0:7]
  8.     // BYTE1 :P2[0:7]
  9.     // BYTE2 :P3[0:7]
  10.     // BYTE3 :P4[0:7]
  11.     // BYTE4 :P1[8:13]P2[8:9]
  12.     // BYTE5 :P2[10:13]P3[8:11]
  13.     // BYTE6 :P3[12:13]P4[8:13]
  14.     // Big endian
  15.     for (long i = 0; i < (number * 7) / 4; i = i + 7)
  16.     {
  17.         // Pix1
  18.         pOut[index++] = ((pIn[i] << 6) & 0xc0) | ((pIn[i + 4] >> 2) & 0xcf);
  19.         pOut[index++] = (pIn[i] >> 2) & 0x3f;
  20.  
  21.         // Pix2
  22.         pOut[index++] = ((pIn[i + 1] << 6) & 0xc0) | ((pIn[i + 4] << 4) & 0x30) + ((pIn[i + 5] >> 4) & 0x0f);
  23.         pOut[index++] = (pIn[i + 1] >> 2) & 0x3f;
  24.  
  25.         // Pix3
  26.         pOut[index++] = ((pIn[i + 2] << 6) & 0xc0) | ((pIn[i + 5] << 2) & 0x3c) + ((pIn[i + 6] >> 6) & 0x03);
  27.         pOut[index++] = (pIn[i + 2] >> 2) & 0x3f;
  28.  
  29.         // Pix4
  30.         pOut[index++] = ((pIn[i + 3] << 6) & 0xc0) | ((pIn[i + 6]) & 0x3f);
  31.         pOut[index++] = (pIn[i + 3] >> 2) & 0x3f;
  32.     }
  33.     printf("MipiRaw14ToP14 over\n");
  34. }

四、整体代码

1、1.0

这里是单纯的转换，需要输入正确的宽高。

10bit计算公式

文件大小 = width * height * 5 / 4

12bit

文件大小 = width * height * 3 / 2

14bit

文件大小 = width * height * 7 / 4

如果dump出来的文件大小比算出来的大小大，那应该是stride和width不一致，这是如果使用1.0的话，那么输入的width就是stride的大小了，不然转化可能会有问题。14bit的除外，14bit转化1.0和2.0一致，输入width即width不是stride，其余照旧。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <iostream>
  5.  
  6. typedef unsigned char BYTE; // 定义BYTE类型，占1个字节
  7.  
  8. void MipiRaw10ToP10(BYTE* pIn, BYTE* pOut, long number)
  9. {
  10.     printf("enter MipiRaw10ToP10\n");
  11.     int index = 0;
  12.     // 5个字节4个像素
  13.     // 前面4个字节都是对应像素的高8位，最后一个字(第五个)每个像素的低2位
  14.     // MIPIRaw 大端模式
  15.     // BYTE0 :P1[0:7]
  16.     // BYTE1 :P2[0:7]
  17.     // BYTE2 :P3[0:7]
  18.     // BYTE3 :P4[0:7]
  19.     // BYTE4 :P4[8:9]P3[8:9]P2[8:9]P1[8:9]
  20.     // UnpackRaw 小端模式
  21.     // Pix1: BYTE0:[2:9], BYTE1:[0:1] == BYTE0:(P1[0:7]<< 2 + P1[8:9]), BYTE1:(P1[0:7] >> 6)
  22.     // Pix2: 上同
  23.     // Pix3: 上同
  24.     // Pix4: 上同
  25.     // Big endian
  26.     for (long i = 0; i < (number * 5) / 4; i = i + 5)
  27.     {
  28.         pOut[index++] = ((pIn[i] << 2) & 0xfc) | (pIn[i + 4] & 0x03);
  29.         pOut[index++] = (pIn[i] >> 6) & 0x03;
  30.  
  31.         //pIn[i+4] >>= 2;
  32.         pOut[index++] = ((pIn[i + 1] << 2) & 0xfc) | ((pIn[i + 4] >> 2) & 0x03);
  33.         pOut[index++] = (pIn[i + 1] >> 6) & 0x03;
  34.  
  35.         //pIn[i+4] >>= 2;
  36.         pOut[index++] = ((pIn[i + 2] << 2) & 0xfc) | ((pIn[i + 4] >> 4) & 0x03);
  37.         pOut[index++] = (pIn[i + 2] >> 6) & 0x03;
  38.  
  39.         //pIn[i+4] >>= 2;
  40.         pOut[index++] = ((pIn[i + 3] << 2) & 0xfc) | ((pIn[i + 4] >> 6) & 0x03);
  41.         pOut[index++] = (pIn[i + 3] >> 6) & 0x03;
  42.     }
  43.     printf("MipiRaw10ToP10 over\n");
  44. }
  45.  
  46. void MipiRaw12ToP12(BYTE* pIn, BYTE* pOut, long number)
  47. {
  48.     printf("enter MipiRaw12ToP12\n");
  49.     int index = 0;
  50.     // 3个字节2个像素
  51.     // 前面2个字节都是对应像素的高8位，最后一个字(第3个)每个像素的低4位
  52.     // MIPIRaw 大端模式
  53.     // BYTE0 :P1[0:7]
  54.     // BYTE1 :P2[0:7]
  55.     // BYTE2 :P2[8:11]P1[8:11]
  56.     // UnpackRaw 小端模式
  57.     // Pix1: BYTE0:[4:11], BYTE1:[0:3] == BYTE0:(P1[0:7]<< 4 + P1[8:11]), BYTE1:(P1[0:7] >> 4)
  58.     // Pix2: 上同
  59.     // Big endian
  60.     for (long i = 0; i < (number * 3) / 2; i = i + 3)
  61.     {
  62.         pOut[index++] = ((pIn[i] << 4) & 0xf0) | (pIn[i + 2] & 0x0f);
  63.         pOut[index++] = (pIn[i] >> 4) & 0x0f;
  64.  
  65.         //pIn[i+2] >>= 4;
  66.         pOut[index++] = ((pIn[i + 1] << 4) & 0xf0) | ((pIn[i + 2] >> 4) & 0x0f);
  67.         pOut[index++] = (pIn[i + 1] >> 4) & 0x0f;
  68.     }
  69.     printf("MipiRaw12ToP12 over\n");
  70. }
  71.  
  72. void MipiRaw14ToP14(BYTE* pIn, BYTE* pOut, long number)
  73. {
  74.     printf("enter MipiRaw14ToP14\n");
  75.     int index = 0;
  76.     // 7个字节4个像素
  77.     // 前面4个字节都是对应像素的高8位，最后3个字对应每个像素的低6位
  78.     // BYTE0 :P1[0:7]
  79.     // BYTE1 :P2[0:7]
  80.     // BYTE2 :P3[0:7]
  81.     // BYTE3 :P4[0:7]
  82.     // BYTE4 :P1[8:13]P2[8:9]
  83.     // BYTE5 :P2[10:13]P3[8:11]
  84.     // BYTE6 :P3[12:13]P4[8:13]
  85.     // Big endian
  86.     for (long i = 0; i < (number * 7) / 4; i = i + 7)
  87.     {
  88.         // Pix1
  89.         pOut[index++] = ((pIn[i] << 6) & 0xc0) | ((pIn[i + 4] >> 2) & 0xcf);
  90.         pOut[index++] = (pIn[i] >> 2) & 0x3f;
  91.  
  92.         // Pix2
  93.         pOut[index++] = ((pIn[i + 1] << 6) & 0xc0) | ((pIn[i + 4] << 4) & 0x30) + ((pIn[i + 5] >> 4) & 0x0f);
  94.         pOut[index++] = (pIn[i + 1] >> 2) & 0x3f;
  95.  
  96.         // Pix3
  97.         pOut[index++] = ((pIn[i + 2] << 6) & 0xc0) | ((pIn[i + 5] << 2) & 0x3c) + ((pIn[i + 6] >> 6) & 0x03);
  98.         pOut[index++] = (pIn[i + 2] >> 2) & 0x3f;
  99.  
  100.         // Pix4
  101.         pOut[index++] = ((pIn[i + 3] << 6) & 0xc0) | ((pIn[i + 6]) & 0x3f);
  102.         pOut[index++] = (pIn[i + 3] >> 2) & 0x3f;
  103.     }
  104.     printf("MipiRaw14ToP14 over\n");
  105. }
  106.  
  107. int main(int argc, char* argv[])
  108. {
  109.     FILE* fp = NULL;
  110.     BYTE* ptr;
  111.     BYTE* outptr = NULL;
  112.     int err = 0;
  113.     if (argc < 6) {
  114.         return -1;
  115.     }
  116.     const char* filepath = argv[1];
  117.     const char* height_str = argv[2];
  118.     const char* width_str = argv[3];
  119.     const char* bpp_str = argv[4];
  120.     const char* outfilepath = argv[5];
  121.     int width = 0;
  122.     int height = 0;
  123.     int bpp = 0;
  124.     width = atoi(width_str);
  125.     height = atoi(height_str);
  126.     bpp = atoi(bpp_str);
  127.     printf("width: %d, height: %d, bpp: %d\n", width, height, bpp);
  128.  
  129.     // 输入源路径并打开raw图像文件
  130.     printf("=======raw image process===========\n");
  131.     err = fopen_s(&fp, filepath, "rb");
  132.     if (NULL == fp)
  133.     {
  134.         printf("can not open the raw image ");
  135.         return 0;
  136.     }
  137.     else
  138.     {
  139.         printf("read OK\n");
  140.     }
  141.     //Sleep(1000);    /* windows 使用Sleep，参数为毫秒 */
  142.     // 分配内存并将图像读到二维数组中
  143.     fseek(fp, 0, SEEK_END);
  144.     unsigned long fsize = ftell(fp);
  145.     rewind(fp);
  146.     ptr = (BYTE*)malloc(fsize * sizeof(BYTE));
  147.     if (ptr == NULL) {
  148.         printf("ptr malloc fail\n");
  149.         return -2;
  150.     }
  151.     if (fread(ptr, 1, fsize, fp) != fsize) {
  152.         printf("read file error.\n");
  153.         return -1;
  154.     }
  155.     fclose(fp);
  156.  
  157.     unsigned long outsize = width * height * 2;
  158.     outptr = (BYTE*)malloc(outsize * sizeof(BYTE));
  159.     if (outptr == NULL) {
  160.         printf("outptr malloc fail\n");
  161.         return -2;
  162.     }
  163.     if (10 == bpp) {
  164.         MipiRaw10ToP10(ptr, outptr, (width * height));
  165.     }
  166.     else if (12 == bpp) {
  167.         MipiRaw12ToP12(ptr, outptr, (width * height));
  168.     }
  169.     else if (14 == bpp) {
  170.         MipiRaw14ToP14(ptr, outptr, (width * height));
  171.     }
  172.  
  173.     free(ptr);
  174.     ptr = NULL;
  175.     // 将处理后的图像数据保存
  176.     printf("Input the raw_image path for save: \n");
  177.     FILE* outfp = NULL;
  178.     err = fopen_s(&outfp, outfilepath, "wb");
  179.     if (outfp == NULL) {
  180.         printf("can not create the raw_image\n");
  181.         return 0;
  182.     }
  183.     else {
  184.         printf("fopen OK\n");
  185.     }
  186.     printf("creat file OK\n");
  187.     if (fwrite(outptr, 1, outsize, outfp) != outsize) {
  188.         printf("outptr write fail");
  189.         return -3;
  190.     }
  191.     printf("write OK\n");
  192.     fclose(outfp);
  193.     free(outptr);
  194.     outptr = NULL;
  195.     return 0;
  196. }

2、2.0

加了一个升级版的，可以兼顾stride和width不同时，把stride和width之间的像素裁剪掉，防止出现绿边的情况。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <iostream>
  5.  
  6. typedef unsigned char BYTE; // 定义BYTE类型，占1个字节
  7.  
  8. void MipiRaw10ToP10(BYTE* pIn, unsigned long fsize, BYTE* pOut, unsigned long outsize, int width, int height, int stride)
  9. {
  10.     printf("enter MipiRaw10ToP10\n");
  11.     int index = 0;
  12.     // 5个字节4个像素
  13.     // 前面4个字节都是对应像素的高8位，最后一个字(第五个)每个像素的低2位
  14.     // MIPIRaw 大端模式
  15.     // BYTE0 :P1[0:7]
  16.     // BYTE1 :P2[0:7]
  17.     // BYTE2 :P3[0:7]
  18.     // BYTE3 :P4[0:7]
  19.     // BYTE4 :P4[8:9]P3[8:9]P2[8:9]P1[8:9]
  20.     // UnpackRaw 小端模式
  21.     // Pix1: BYTE0:[2:9], BYTE1:[0:1] == BYTE0:(P1[0:7]<< 2 + P1[8:9]), BYTE1:(P1[0:7] >> 6)
  22.     // Pix2: 上同
  23.     // Pix3: 上同
  24.     // Pix4: 上同
  25.     // Big endian
  26.     int count = 0;
  27.     bool unjustified = false;
  28.     if (stride - width > 0) {
  29.         unjustified = true;
  30.     }
  31.     for (long i = 0; i < fsize; i = i + 5)
  32.     {
  33.         if (unjustified) {
  34.             // 一次转化4个像素，需要5个字节，转化后为8个字节
  35.             if (count > width - 1) {
  36.                 // 偏移时按照stride和width的差值 * 1.25，即width和stride差的像素实际占用的字节数
  37.                 i = i + int((stride - width) * 1.25);
  38.                 count = 0;
  39.             }
  40.         }
  41.         if (i > fsize || index > outsize) {
  42.             break;
  43.         }
  44.         pOut[index++] = ((pIn[i] << 2) & 0xfc) | (pIn[i + 4] & 0x03);
  45.         pOut[index++] = (pIn[i] >> 6) & 0x03;
  46.  
  47.         //pIn[i+4] >>= 2;
  48.         pOut[index++] = ((pIn[i + 1] << 2) & 0xfc) | ((pIn[i + 4] >> 2) & 0x03);
  49.         pOut[index++] = (pIn[i + 1] >> 6) & 0x03;
  50.  
  51.         //pIn[i+4] >>= 2;
  52.         pOut[index++] = ((pIn[i + 2] << 2) & 0xfc) | ((pIn[i + 4] >> 4) & 0x03);
  53.         pOut[index++] = (pIn[i + 2] >> 6) & 0x03;
  54.  
  55.         //pIn[i+4] >>= 2;
  56.         pOut[index++] = ((pIn[i + 3] << 2) & 0xfc) | ((pIn[i + 4] >> 6) & 0x03);
  57.         pOut[index++] = (pIn[i + 3] >> 6) & 0x03;
  58.         count = count + 4;
  59.     }
  60.     printf("MipiRaw10ToP10 over\n");
  61. }
  62.  
  63. void MipiRaw12ToP12(BYTE* pIn, unsigned long fsize, BYTE* pOut, unsigned long outsize, int width, int height, int stride)
  64. {
  65.     printf("enter MipiRaw12ToP12\n");
  66.     int index = 0;
  67.     int count = 0;
  68.     bool unjustified = false;
  69.     if (stride - width > 0) {
  70.         unjustified = true;
  71.     }
  72.     // 3个字节2个像素
  73.     // 前面2个字节都是对应像素的高8位，最后一个字(第3个)每个像素的低4位
  74.     // MIPIRaw 大端模式
  75.     // BYTE0 :P1[0:7]
  76.     // BYTE1 :P2[0:7]
  77.     // BYTE2 :P2[8:11]P1[8:11]
  78.     // UnpackRaw 小端模式
  79.     // Pix1: BYTE0:[4:11], BYTE1:[0:3] == BYTE0:(P1[0:7]<< 4 + P1[8:11]), BYTE1:(P1[0:7] >> 4)
  80.     // Pix2: 上同
  81.     // Big endian
  82.     for (long i = 0; i < fsize; i = i + 3)
  83.     {
  84.         if (unjustified) {
  85.             // 一次转化2个像素，需要3个字节，转化后为4个字节
  86.             if (count > width - 1) {
  87.                 // 偏移时按照stride和width的差值 * 1.5，即width和stride差的像素实际占用的字节数
  88.                 i = i + int((stride - width) * 1.5);
  89.                 count = 0;
  90.             }
  91.         }
  92.         if (i > fsize || index > outsize) {
  93.             break;
  94.         }
  95.         pOut[index++] = ((pIn[i] << 4) & 0xf0) | (pIn[i + 2] & 0x0f);
  96.         pOut[index++] = (pIn[i] >> 4) & 0x0f;
  97.  
  98.         //pIn[i+2] >>= 4;
  99.         pOut[index++] = ((pIn[i + 1] << 4) & 0xf0) | ((pIn[i + 2] >> 4) & 0x0f);
  100.         pOut[index++] = (pIn[i + 1] >> 4) & 0x0f;
  101.         count = count + 2;
  102.     }
  103.     printf("MipiRaw12ToP12 over\n");
  104. }
  105.  
  106. void MipiRaw14ToP14(BYTE* pIn, BYTE* pOut, long number)
  107. {
  108.     printf("enter MipiRaw14ToP14\n");
  109.     int index = 0;
  110.     // 7个字节4个像素
  111.     // 前面4个字节都是对应像素的高8位，最后3个字对应每个像素的低6位
  112.     // BYTE0 :P1[0:7]
  113.     // BYTE1 :P2[0:7]
  114.     // BYTE2 :P3[0:7]
  115.     // BYTE3 :P4[0:7]
  116.     // BYTE4 :P1[8:13]P2[8:9]
  117.     // BYTE5 :P2[10:13]P3[8:11]
  118.     // BYTE6 :P3[12:13]P4[8:13]
  119.     // Big endian
  120.     for (long i = 0; i < (number * 7) / 4; i = i + 7)
  121.     {
  122.          // Pix1
  123.          pOut[index++] = ((pIn[i] << 6) & 0xc0) | ((pIn[i + 4] >> 2) & 0xcf);
  124.           pOut[index++] = (pIn[i] >> 2) & 0x3f;
  125.  
  126.           // Pix2
  127.           pOut[index++] = ((pIn[i + 1] << 6) & 0xc0) | ((pIn[i + 4] << 4) & 0x30) + ((pIn[i + 5] >> 4) & 0x0f);
  128.           pOut[index++] = (pIn[i + 1] >> 2) & 0x3f;
  129.  
  130.           // Pix3
  131.           pOut[index++] = ((pIn[i + 2] << 6) & 0xc0) | ((pIn[i + 5] << 2) & 0x3c) + ((pIn[i + 6] >> 6) & 0x03);
  132.           pOut[index++] = (pIn[i + 2] >> 2) & 0x3f;
  133.  
  134.           // Pix4
  135.           pOut[index++] = ((pIn[i + 3] << 6) & 0xc0) | ((pIn[i + 6]) & 0x3f);
  136.           pOut[index++] = (pIn[i + 3] >> 2) & 0x3f;
  137.     }
  138.     printf("MipiRaw14ToP14 over\n");
  139. }
  140.  
  141. int main(int argc, char* argv[])
  142. {
  143.     FILE* fp = NULL;
  144.     BYTE* ptr;
  145.     BYTE* outptr = NULL;
  146.     int err = 0;
  147.     if (argc < 6) {
  148.         return -1;
  149.     }
  150.     const char* filepath = argv[1];
  151.     const char* height_str = argv[2];
  152.     const char* width_str = argv[3];
  153.     //const char* stride_str = argv[4];
  154.     const char* bpp_str = argv[4];
  155.     const char* outfilepath = argv[5];
  156.     int width = 0;
  157.     int height = 0;
  158.     int stride = 0;
  159.     int bpp = 0;
  160.     width = atoi(width_str);
  161.     height = atoi(height_str);
  162.     bpp = atoi(bpp_str);
  163.     //stride = atoi(stride_str);
  164.     printf("width: %d, height: %d, bpp: %d, stride: %d\n", width, height, bpp, stride);
  165.  
  166.     // 输入源路径并打开raw图像文件
  167.     printf("=======raw image process===========\n");
  168.     err = fopen_s(&fp, filepath, "rb");
  169.     if (NULL == fp)
  170.     {
  171.         printf("can not open the raw image ");
  172.         return 0;
  173.     }
  174.     else
  175.     {
  176.         printf("read OK\n");
  177.     }
  178.     //Sleep(1000);    /* windows 使用Sleep，参数为毫秒 */
  179.     // 分配内存并将图像读到二维数组中
  180.     fseek(fp, 0, SEEK_END);
  181.     unsigned long fsize = ftell(fp);
  182.     rewind(fp);
  183.     // 根据raw图实际大小，计算raw的stride
  184.     if (10 == bpp) {
  185.         stride = int(fsize * 4 / 5 / height);
  186.         if (stride % 64 > 0) {
  187.             stride = 0;
  188.         }
  189.     } else if (12 == bpp) {
  190.         stride = int(fsize * 2 / 3 / height);
  191.         if (stride % 64 > 0) {
  192.             stride = 0;
  193.         }
  194.     } else if (14 == bpp) {
  195.         stride = int(fsize * 4 / 7 / height);
  196.         if (stride % 64 > 0) {
  197.             stride = 0;
  198.         }
  199.     }
  200.     ptr = (BYTE*)malloc(fsize * sizeof(BYTE));
  201.     if (ptr == NULL) {
  202.         printf("ptr malloc fail\n");
  203.         return -2;
  204.     }
  205.     if (fread(ptr, 1, fsize, fp) != fsize) {
  206.         printf("read file error.\n");
  207.         return -1;
  208.     }
  209.     fclose(fp);
  210.  
  211.     unsigned long outsize = width * height * 2;
  212.     outptr = (BYTE*)malloc(outsize * sizeof(BYTE));
  213.     if (outptr == NULL) {
  214.         printf("outptr malloc fail\n");
  215.         return -2;
  216.     }
  217.     if (10 == bpp) {
  218.         MipiRaw10ToP10(ptr, fsize, outptr, outsize, width, height, stride);
  219.     }
  220.     else if (12 == bpp) {
  221.         MipiRaw12ToP12(ptr, fsize, outptr, outsize, width, height, stride);
  222.     }
  223.     else if (14 == bpp) {
  224.          MipiRaw14ToP14(ptr, outptr, width * height);
  225.     }
  226.  
  227.     free(ptr);
  228.     ptr = NULL;
  229.     // 这里可以对二维数组中的图像数据进行处理
  230.     // 将处理后的图像数据输出至文件
  231.     printf("Input the raw_image path for save: \n");
  232.     //scanf("%s",outpath);
  233.     FILE* outfp = NULL;
  234.     err = fopen_s(&outfp, outfilepath, "wb");
  235.     if (outfp == NULL) {
  236.         printf("can not create the raw_image\n");
  237.         return 0;
  238.     }
  239.     else {
  240.         printf("fopen OK\n");
  241.     }
  242.     printf("creat file OK\n");
  243.     if (fwrite(outptr, 1, outsize, outfp) != outsize) {
  244.         printf("outptr write fail");
  245.         return -3;
  246.     }
  247.     printf("write OK\n");
  248.     fclose(outfp);
  249.     free(outptr);
  250.     outptr = NULL;
  251.     return 0;
  252. }

注意：这里的存储方式是UnpackRaw是小端模式 + MSB优先的存储方式，MipiRaw是大端模式 + MSB优先的存储方式。可能还有别的存储方式，大家在转换的时候，先搞明白UnpackRaw和MipiRaw的存储方式再写具体代码。共勉！！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/寸_铁/article/detail/959059
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号