├── README.md
└── imageconvert
    ├── main.cpp
    ├── Makefile
    ├── imageconvert.h
    └── imageconvert.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # imageconvert
2 | imageconvert source code
3 | 


--------------------------------------------------------------------------------
/imageconvert/main.cpp:
--------------------------------------------------------------------------------
 1 | /*************************************************************************
 2 | 	> File Name: main.cpp
 3 | 	> Author:maobin
 4 | 	> Mail:
 5 | 	> Created Time: Wed 13 Dec 2017 08:37:29 PM CST
 6 |  ************************************************************************/
 7 | 
 8 | #include <iostream>
 9 | #include <stdio.h>
10 | #include <string.h>
11 | #include <fstream>
12 | #include <libgen.h>
13 | #include "imageconvert.h"
14 | #include <opencv2/opencv.hpp>
15 | using namespace std;
16 | 
17 | int main(int argc, char *argv[])
18 | {
19 |   ImageConvert *imageconvert = new ImageConvert;
20 |   if (imageconvert->Init(argc,argv) != 0)
21 |   {
22 |     delete imageconvert;
23 |     return -1;
24 |   }
25 |   imageconvert->Convert();
26 | 
27 |   delete imageconvert;
28 |   return 0;
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/imageconvert/Makefile:
--------------------------------------------------------------------------------
 1 | CXX=$(CROSS_COMPILE)g++
 2 | AR=$(CROSS_COMPILE)ar
 3 | 
 4 | #CXXFLAGS= -g -I/usr/include -I./utils/ -I../src -I/usr/include/libcamhal/ `pkg-config --cflags gstreamer-1.0 glib-2.0 gstreamer-video-1.0 gtk+-3.0`
 5 | #LDFLAGS= -L/usr/lib64/ -lcamhal -lpthread `pkg-config --libs  gstreamer-1.0 gobject-2.0  glib-2.0 gstreamer-video-1.0 gtk+-3.0`
 6 | 
 7 | CXXFLAGS= -I/usr/local/include -L/usr/local/lib  `pkg-config --cflags --libs opencv ` -g -std=c++11
 8 | LDFLAGS= -I/usr/local/include -L/usr/local/lib ` pkg-config --cflags --libs opencv ` -g -std=c++11
 9 | 
10 | casedir=.
11 | 
12 | srcobjs=$(patsubst %.cpp, %.o, $(shell ls $(casedir)/*.cpp))
13 | 
14 | mainobj=main.o
15 | 
16 | testbin=imageconvert
17 | 
18 | all: $(testbin)
19 | 
20 | %.o: %.cpp
21 | 	$(CXX) $(CXXFLAGS) -o $@ -c $<
22 | 
23 | $(testbin): $(mainobj) $(srcobjs)
24 | 	$(CXX) -o $@ $^ $(LDFLAGS)
25 | .PHONY : clean
26 | clean:
27 | 	rm -f $(mainobj) $(srcobjs) $(testbin)
28 | 


--------------------------------------------------------------------------------
/imageconvert/imageconvert.h:
--------------------------------------------------------------------------------
  1 | /*************************************************************************
  2 | 	> File Name: imageconvert.h
  3 | 	> Author:maobin
  4 | 	> Mail:
  5 | 	> Created Time: Wed 13 Dec 2017 08:39:14 PM CST
  6 |  ************************************************************************/
  7 | 
  8 | #ifndef _IMAGECONVERT_H
  9 | #define _IMAGECONVERT_H
 10 | #include <iostream>
 11 | #include <opencv2/opencv.hpp>
 12 | #include <stdio.h>
 13 | #include <string.h>
 14 | #include <fstream>
 15 | #include <libgen.h>
 16 | #define BYTE unsigned char
 17 | #define ULONG unsigned long
 18 | using namespace std;
 19 | using namespace cv;
 20 | 
 21 | enum MEDIA_FORMAT
 22 | {
 23 |     MEDIA_FORMAT_UNKNOWN,
 24 |     MEDIA_FORMAT_NV12,
 25 |     MEDIA_FORMAT_NV16,
 26 |     MEDIA_FORMAT_UYVY,
 27 |     MEDIA_FORMAT_YUY2,
 28 |     MEDIA_FORMAT_XRGB,
 29 |     MEDIA_FORMAT_XBGR,
 30 |     MEDIA_FORMAT_I420,
 31 |     MEDIA_FORMAT_ARGB,
 32 |     MEDIA_FORMAT_BGRA,
 33 |     MEDIA_FORMAT_BGR24,
 34 |     MEDIA_FORMAT_RGB565
 35 | };
 36 | 
 37 | 
 38 | #define DEBUG_LEVEL 1
 39 | enum DebugLevel
 40 | {
 41 |    INFO,
 42 |    ERROR,
 43 |    RESULT,
 44 |    DEBUG
 45 | };
 46 | class ImageConvert
 47 | {
 48 | 
 49 | public:
 50 |     ImageConvert();
 51 |     ~ImageConvert();
 52 |     void Usage();
 53 |     void PrintInfo();
 54 |     int Init(int argc, char *argv[]);
 55 |     int Spilt_parameters(const char *arg, char *key, char *value);
 56 |     int Convert();
 57 | private:
 58 |     typedef void (*func_convert_format)(uchar *buff, int stride, int w, int h, Mat &dst);
 59 |     static inline BYTE Clip(int clr);
 60 |     static inline void ConvertYCrCbToRGB(
 61 |                                    BYTE y,
 62 |                                    BYTE cr,
 63 |                                    BYTE cb,
 64 |                                    BYTE &r,
 65 |                                    BYTE &g,
 66 |                                    BYTE &b
 67 |                                  );
 68 |     static void convert_nv122bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 69 |     static void convert_nv162bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 70 |     static void convert_yuy22bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 71 |     static void convert_uyvy2bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 72 |     static void convert_i4202bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 73 |     static void convert_xbgr2bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 74 |     static void convert_xrgb2bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 75 |     static void convert_argb2bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 76 |     static void convert_bgra2bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 77 |     static void convert_bgr2bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 78 |     static void convert_rgb162bgr(uchar *buff, int stride, int w, int h, Mat &dst);
 79 | private:
 80 |     ULONG ReadRawData(const char *filename, uchar **pnv12);
 81 |     ULONG DataLength(const char *filename);
 82 |     MEDIA_FORMAT GetFormatFromString(char *strRawDumpFormat);
 83 | private:
 84 |     int checkParameters();
 85 |     void debug(char *msg,DebugLevel level);
 86 | 
 87 | private:
 88 |     int m_width;
 89 |     int m_height;
 90 |     int m_count;
 91 |     int m_frame;
 92 |     int m_oneimagesize;
 93 |     ULONG m_dataLength;
 94 |     char m_format[16];
 95 |     char m_filename[256];
 96 | 
 97 | 
 98 | };
 99 | #endif
100 | 


--------------------------------------------------------------------------------
/imageconvert/imageconvert.cpp:
--------------------------------------------------------------------------------
  1 | /*************************************************************************
  2 | 	> File Name: imageconvert.cpp
  3 | 	> Author:maobin
  4 | 	> Mail:
  5 | 	> Created Time: Wed 13 Dec 2017 04:47:58 PM CST
  6 |  ************************************************************************/
  7 | 
  8 | #include "imageconvert.h"
  9 | #define ULONG unsigned long
 10 | ImageConvert::ImageConvert():m_width(0),m_height(0),m_count(0),m_oneimagesize(0),m_dataLength(0),m_frame(0)
 11 | {
 12 |     memset(m_filename,0,sizeof(m_filename));
 13 |     memset(m_format,0,sizeof(m_format));
 14 |     cout << "ImageConvert:" << __FUNCTION__ << __LINE__ <<endl;
 15 | }
 16 | 
 17 | ImageConvert::~ImageConvert()
 18 | {
 19 | 
 20 | }
 21 | 
 22 | void ImageConvert::Usage()
 23 | {
 24 | 	cout <<"Usage*******************************************************************"<<endl;
 25 | 	cout <<"--width=" << endl;
 26 | 	cout <<"--height=" << endl;
 27 | 	cout <<"--format=" << endl;
 28 | 	cout <<"--filename=" << endl;
 29 |     cout <<"--count=" << endl;
 30 |     cout <<"--frame=" <<"   which frame need to convert" <<endl;
 31 |     cout <<"example: " << endl;
 32 |     cout <<"          imageconvert --width=1920 --height=1080 --format=nv12 --filename=test.nv12" << endl;
 33 |     cout <<"          imageconvert --width=1920 --height=1080 --format=nv12 --count=100 --filename=test.raw" << endl;
 34 |     cout <<"usage********************************************************************" << endl;
 35 | }
 36 | int ImageConvert::Init(int argc,char *argv[])
 37 | {
 38 |   cout << "ImageConvert:" << __FUNCTION__ << __LINE__ <<endl;
 39 |   char key[256], value[256];
 40 | 
 41 |   for(int i = 0; i < argc ; i++)
 42 |   {
 43 |   	   memset(key,0,sizeof(key));
 44 |   	   memset(value,0,sizeof(value));
 45 |        Spilt_parameters(argv[i],key,value);
 46 |        if ((!strcmp("--help", key)) || (!strcmp("-h", key)) || argc <= 1 )
 47 |         {
 48 |             Usage();
 49 |             return -1;
 50 |         }
 51 |        else if (0 == strcmp("--width", key))
 52 |        {
 53 |            m_width = atoi(value);
 54 |        }
 55 |        else if (0 == strcmp("--height", key))
 56 |        {
 57 |        	    m_height = atoi(value);
 58 |        }
 59 |        else if (0 == strcmp("--count", key))
 60 |        {
 61 |             m_count = atoi(value);
 62 |        }
 63 |       else if (0 == strcmp("--frame", key))
 64 |        {
 65 |             m_frame = atoi(value);
 66 |        }
 67 |        else if (0 == strcmp("--format", key))
 68 |        {
 69 |        	    strncpy(m_format,value,16);
 70 |        }
 71 |        else if (0 == strcmp("--filename",key))
 72 |        {
 73 |        	    strncpy(m_filename,value,256);
 74 |        }
 75 | 
 76 | 
 77 |   }
 78 | 
 79 |   PrintInfo();
 80 |   if ( -1 == checkParameters())
 81 |   {
 82 |     return -1;
 83 |   }
 84 | 
 85 |   return 0;
 86 | }
 87 | 
 88 | int ImageConvert::Spilt_parameters(const char *arg, char *key, char *value)
 89 | {
 90 |     char buffer[256];
 91 |     strcpy(buffer, arg);
 92 |     char *p = strtok(buffer, "=");
 93 |     if (!p)
 94 |         return -1;
 95 |     strcpy(key, p);
 96 |     p = strtok(NULL, "=");
 97 |     if (!p)
 98 |         return -1;
 99 |     strcpy(value, p);
100 |     return 0;
101 | }
102 | 
103 | void ImageConvert::PrintInfo()
104 | {
105 |   cout <<"image info ************************************************************************" << endl;
106 |     cout <<"width:" << m_width << endl;
107 |     cout <<"height:" << m_height << endl;
108 |     cout <<"format:" << m_format << endl;
109 |     cout <<"filename:" << m_filename << endl;
110 |     cout <<"one_img_size:" << m_oneimagesize << endl;
111 |     cout <<"datalength:" << m_dataLength << endl;
112 |     cout << "count:" << m_count  << endl;
113 |   cout << "image info ************************************************************************" << endl;
114 | }
115 | 
116 | int ImageConvert::Convert()
117 | {
118 |     cout << "function:" << __FUNCTION__ << " line:"<< __LINE__ <<endl;
119 |     if (m_count == 0)
120 |     {
121 |       m_count = 1;
122 |       m_frame = 0;
123 |     }
124 |     else
125 |     {
126 |       if (m_frame == 0 )
127 |       {
128 |           m_frame=5;
129 |       }
130 | 
131 |     }
132 |     char outputjpg[256], outputbmp[256], outputpng[256];
133 |     memset(outputjpg,0,sizeof(outputjpg));
134 |     memset(outputbmp,0,sizeof(outputbmp));
135 |     memset(outputpng,0,sizeof(outputpng));
136 |     sprintf(outputjpg,"%s.jpg",m_filename);
137 |     sprintf(outputbmp,"%s.bmp",m_filename);
138 |     sprintf(outputpng,"%s.png",m_filename);
139 |     Mat image;
140 |     bool ret = true;
141 |     uchar *pRawData = NULL;
142 |     m_dataLength = DataLength(m_filename);
143 |     m_oneimagesize = m_dataLength/m_count;
144 |     cout <<"datalength:" << m_dataLength << endl;
145 |     cout << "one_img_size:" << m_oneimagesize << endl;
146 |     ULONG nDataLen = ReadRawData(m_filename, &pRawData);
147 |     ULONG one_img_size = 0;
148 |     int stride = 0;
149 |     MEDIA_FORMAT foramt = GetFormatFromString(m_format);
150 | 
151 |     func_convert_format func = NULL;
152 |     switch (foramt)
153 |     {
154 |     case MEDIA_FORMAT_NV12:
155 |         one_img_size = m_width * m_height * 3 / 2;
156 |         func=convert_nv122bgr;
157 |         stride = m_width;
158 |         break;
159 |     case MEDIA_FORMAT_NV16:
160 |         one_img_size = m_width * m_height * 2;
161 |         func = convert_nv162bgr;
162 |         stride = m_width;
163 |         break;
164 |     case MEDIA_FORMAT_UYVY:
165 |         one_img_size = m_width * m_height * 2;
166 |         func = convert_uyvy2bgr;
167 |         stride = 2*m_width;
168 |         break;
169 |     case MEDIA_FORMAT_YUY2:
170 |         one_img_size = m_width * m_height * 2;
171 |         func = convert_yuy22bgr;
172 |         stride = 2*m_width;
173 |         break;
174 |     case MEDIA_FORMAT_XRGB:
175 |         one_img_size = m_width * m_height * 4;
176 |         func = convert_xrgb2bgr;
177 |         stride = 4*m_width;
178 |         break;
179 |     case MEDIA_FORMAT_XBGR:
180 |         one_img_size = m_width * m_height * 4;
181 |         func = convert_xbgr2bgr;
182 |         stride = 4*m_width;
183 |         break;
184 |     // Vaapipostproc output format
185 |     case MEDIA_FORMAT_I420:
186 |         one_img_size = m_width * m_height * 3 / 2;
187 |         func = convert_i4202bgr;
188 |         stride = m_width;
189 |         break;
190 |     case MEDIA_FORMAT_ARGB:
191 |         one_img_size = m_width * m_height * 4;
192 |         func = convert_argb2bgr;
193 |         stride = 4*m_width;
194 |         break;
195 |     case MEDIA_FORMAT_BGRA:
196 |         one_img_size = m_width * m_height * 4;
197 |         func = convert_bgra2bgr;
198 |         stride = 4*m_width;
199 |         break;
200 |     case MEDIA_FORMAT_BGR24:
201 |         one_img_size = m_width * m_height * 3;
202 |         func = convert_bgr2bgr;
203 |         stride = 3*m_width;
204 |         break;
205 |     case MEDIA_FORMAT_RGB565:
206 |         one_img_size = m_width * m_height * 2;
207 |         func = convert_rgb162bgr;
208 |         stride = 2*m_width;
209 |         break;
210 |     default:
211 |         free(pRawData);
212 |         cout << "unknown format" << endl;
213 |         return -1;
214 |         break;
215 | 
216 |     }
217 |      if (stride % 64 != 0)
218 |          {
219 |             stride += 64 - stride % 64;
220 |          }
221 |      cout << __LINE__ << "start convert" << endl;
222 |      func(pRawData, stride, m_width, m_height, image);
223 |      cout << __LINE__ << "end convert" << endl;
224 |      imwrite(outputbmp,image);
225 |      imwrite(outputjpg,image);
226 |      imwrite(outputpng,image);
227 |      free(pRawData);
228 | 
229 | }
230 | 
231 | void ImageConvert::convert_nv122bgr(uchar *buff, int stride, int w, int h, Mat &dst)
232 | {
233 |     dst.create(Size(w, h), CV_8UC3);
234 |     uchar *pY = NULL;
235 |     uchar *pCbCr = NULL;
236 |     uchar *pBGR = NULL;
237 | 
238 |     BYTE Y = 0, Cr = 0, Cb = 0;
239 |     BYTE R = 0, G = 0, B = 0;
240 | 
241 |     // NV12 to BGR
242 |     for (int y = 0; y < h; y++)
243 |     {
244 |         pY = buff + y * stride;
245 |         pCbCr = buff + (h + y / 2) * stride;
246 |         pBGR = dst.data + y * dst.step;
247 | 
248 |         for (int x = 0, x3 = 0; x < w; x++, x3 += 3)
249 |         {
250 |             Y  = pY[x];
251 |             Cr = pCbCr[x / 2 * 2 + 1];
252 |             Cb = pCbCr[x / 2 * 2];
253 | 
254 |             ConvertYCrCbToRGB(Y, Cr, Cb, R, G, B);
255 | 
256 |             pBGR[x3] = B;
257 |             pBGR[x3 + 1] = G;
258 |             pBGR[x3 + 2] = R;
259 |         }
260 |     }
261 | }
262 | 
263 | void ImageConvert::convert_nv162bgr(uchar *buff, int stride, int w, int h, Mat &dst)
264 | {
265 |     dst.create(Size(w, h), CV_8UC3);
266 |     uchar *pY = NULL;
267 |     uchar *pCbCr = NULL;
268 |     uchar *pBGR = NULL;
269 | 
270 |     BYTE Y = 0, Cr = 0, Cb = 0;
271 |     BYTE R = 0, G = 0, B = 0;
272 | 
273 |     // NV16 to BGR
274 |     for (int y = 0; y < h; y++)
275 |     {
276 |         pY = buff + y * stride;
277 |         pCbCr = buff + h*stride + y*stride;
278 |         pBGR = dst.data + y * dst.step;
279 | 
280 |         for (int x = 0, x6 = 0; x < w; x += 2, x6 += 6)
281 |         {
282 |             Y  = pY[x];
283 |             Cr = pCbCr[x+1];
284 |             Cb = pCbCr[x];
285 | 
286 |             ConvertYCrCbToRGB(Y, Cr, Cb, R, G, B);
287 | 
288 |             pBGR[x6] = B;
289 |             pBGR[x6 + 1] = G;
290 |             pBGR[x6 + 2] = R;
291 | 
292 |             Y  = pY[x + 1];
293 |             ConvertYCrCbToRGB(Y, Cr, Cb, R, G, B);
294 |             pBGR[x6 + 3] = B;
295 |             pBGR[x6 + 4] = G;
296 |             pBGR[x6 + 5] = R;
297 |         }
298 |     }
299 | }
300 | 
301 | void ImageConvert::convert_yuy22bgr(uchar *buff, int stride, int w, int h, Mat &dst)
302 | {
303 |     dst.create(Size(w, h), CV_8UC3);
304 | 
305 |     uchar *pBGR = NULL;
306 |     uchar *pYUY2 = NULL;
307 |     uchar *pCbCr = NULL;
308 | 
309 |     int yuy2step = w * 2;
310 | 
311 |     BYTE Y = 0, Cr = 0, Cb = 0;
312 |     BYTE R = 0, G = 0, B = 0;
313 | 
314 |     // YUY2 to BGR
315 |     for (int y = 0; y < h; y++)
316 |     {
317 |         pBGR = dst.data + y * dst.step;
318 |         pYUY2 = buff + y * stride;
319 | 
320 |         for (int x4 = 0, x6 = 0; x4 < yuy2step; x4 += 4, x6 += 6)
321 |         {
322 |             Cb = pYUY2[x4 + 1];
323 |             Cr = pYUY2[x4 + 3];
324 | 
325 |             Y = pYUY2[x4];
326 | 
327 |             ConvertYCrCbToRGB(Y, Cr, Cb, R, G, B);
328 | 
329 |             pBGR[x6] = B;
330 |             pBGR[x6 + 1] = G;
331 |             pBGR[x6 + 2] = R;
332 | 
333 |             Y = pYUY2[x4 + 2];
334 | 
335 |             ConvertYCrCbToRGB(Y, Cr, Cb, R, G, B);
336 | 
337 |             pBGR[x6 + 3] = B;
338 |             pBGR[x6 + 4] = G;
339 |             pBGR[x6 + 5] = R;
340 |         }
341 |     }
342 | }
343 | 
344 | void ImageConvert::convert_uyvy2bgr(uchar *buff, int stride, int w, int h, Mat &dst)
345 | {
346 |     dst.create(Size(w, h), CV_8UC3);
347 | 
348 |     uchar *pBGR = NULL;
349 |     uchar *pYUY2 = NULL;
350 |     uchar *pCbCr = NULL;
351 | 
352 |     int yuy2step = w * 2;
353 | 
354 |     BYTE Y = 0, Cr = 0, Cb = 0;
355 |     BYTE R = 0, G = 0, B = 0;
356 | 
357 |     // UYVY to BGR
358 |     for (int y = 0; y < h; y++)
359 |     {
360 |         pBGR = dst.data + y * dst.step;
361 |         pYUY2 = buff + y * stride;
362 | 
363 |         for (int x4 = 0, x6 = 0; x4 < yuy2step; x4 += 4, x6 += 6)
364 |         {
365 |             Cb = pYUY2[x4];
366 |             Y = pYUY2[x4 + 1];
367 |             Cr = pYUY2[x4 + 2];
368 | 
369 |             ConvertYCrCbToRGB(Y, Cr, Cb, R, G, B);
370 | 
371 |             pBGR[x6] = B;
372 |             pBGR[x6 + 1] = G;
373 |             pBGR[x6 + 2] = R;
374 | 
375 |             Y = pYUY2[x4 + 3];
376 | 
377 |             ConvertYCrCbToRGB(Y, Cr, Cb, R, G, B);
378 | 
379 |             pBGR[x6 + 3] = B;
380 |             pBGR[x6 + 4] = G;
381 |             pBGR[x6 + 5] = R;
382 |         }
383 |     }
384 | }
385 | 
386 | void ImageConvert::convert_i4202bgr(uchar *buff, int stride, int w, int h, Mat &dst)
387 | {
388 |     dst.create(Size(w, h), CV_8UC3);
389 | 
390 |     uchar *pBGR0 = NULL;
391 |     uchar *pBGR1 = NULL;
392 |     uchar *pYUV0 = NULL;
393 |     uchar *pYUV1 = NULL;
394 |     uchar *pCbCr = NULL;
395 |     uchar *pV = NULL;
396 |     uchar *pU = NULL;
397 |     uchar *Vorg = NULL;
398 |     uchar *Uorg = NULL;
399 | 
400 |     BYTE Y00 = 0, Y01 = 0, Y10 = 0, Y11 = 0, Cr = 0, Cb = 0;
401 |     BYTE R = 0, G = 0, B = 0;
402 | 
403 |     int yuvstep = w;
404 | 
405 |     Vorg = buff + h * stride;
406 |     Uorg = buff + h * stride + h * stride / 4;
407 | 
408 |     // I420 to BGR
409 |     for (int y2 = 0; y2 < h; y2 += 2)
410 |     {
411 |         pBGR0 = dst.data + y2 * dst.step;
412 |         pBGR1 = dst.data + (y2 + 1) * dst.step;
413 | 
414 |         pYUV0 = buff + y2 * stride;
415 |         pYUV1 = buff + (y2 + 1) * stride;
416 | 
417 |         pV = Vorg + (y2 / 2) * (stride / 2);
418 |         pU = Uorg + (y2 / 2) * (stride / 2);
419 | 
420 |         for (int x = 0, x2 = 0, x6 = 0; x2 < yuvstep; x++, x2 += 2, x6 += 6)
421 |         {
422 |             Y00 = pYUV0[x2];
423 |             Y01 = pYUV0[x2+1];
424 |             Y10 = pYUV1[x2];
425 |             Y11 = pYUV1[x2+1];
426 | 
427 |             Cr = pU[x];
428 |             Cb = pV[x];
429 | 
430 |             ConvertYCrCbToRGB(Y00, Cr, Cb, R, G, B);
431 | 
432 |             pBGR0[x6] = B;
433 |             pBGR0[x6 + 1] = G;
434 |             pBGR0[x6 + 2] = R;
435 | 
436 |             ConvertYCrCbToRGB(Y01, Cr, Cb, R, G, B);
437 | 
438 |             pBGR0[x6 + 3] = B;
439 |             pBGR0[x6 + 4] = G;
440 |             pBGR0[x6 + 5] = R;
441 | 
442 |             ConvertYCrCbToRGB(Y10, Cr, Cb, R, G, B);
443 | 
444 |             pBGR1[x6] = B;
445 |             pBGR1[x6 + 1] = G;
446 |             pBGR1[x6 + 2] = R;
447 | 
448 |             ConvertYCrCbToRGB(Y11, Cr, Cb, R, G, B);
449 | 
450 |             pBGR1[x6 + 3] = B;
451 |             pBGR1[x6 + 4] = G;
452 |             pBGR1[x6 + 5] = R;
453 |         }
454 |     }
455 | }
456 | 
457 | void ImageConvert::convert_xbgr2bgr(uchar *buff, int stride, int w, int h, Mat &dst)
458 | {
459 |     dst.create(Size(w, h), CV_8UC3);
460 | 
461 |     uchar *pBGR = NULL;
462 |     uchar *pXBGR = NULL;
463 | 
464 |     int xbgrstep = w * 4;
465 | 
466 |     // XBGR to BGR
467 |     for (int y = 0; y < h; y++)
468 |     {
469 |         pBGR = dst.data + y * dst.step;
470 |         pXBGR = buff + y * stride;
471 | 
472 |         for (int x4 = 0, x3 = 0; x4 < xbgrstep; x4 += 4, x3 += 3)
473 |         {
474 |             pBGR[x3] = pXBGR[x4+0];
475 |             pBGR[x3 + 1] = pXBGR[x4+1];
476 |             pBGR[x3 + 2] = pXBGR[x4+2];
477 |         }
478 |     }
479 | }
480 | 
481 | void ImageConvert::convert_xrgb2bgr(uchar *buff, int stride, int w, int h, Mat &dst)
482 | {
483 |     dst.create(Size(w, h), CV_8UC3);
484 | 
485 |     uchar *pBGR = NULL;
486 |     uchar *pXRGB = NULL;
487 | 
488 |     int xbgrstep = w * 4;
489 | 
490 |     // XRGB to BGR
491 |     for (int y = 0; y < h; y++)
492 |     {
493 |         pBGR = dst.data + y * dst.step;
494 |         pXRGB = buff + y * stride;
495 | 
496 |         for (int x4 = 0, x3 = 0; x4 < xbgrstep; x4 += 4, x3 += 3)
497 |         {
498 |             pBGR[x3] = pXRGB[x4+0] << 3;
499 |             pBGR[x3 + 1] = pXRGB[x4+1] << 2;
500 |             pBGR[x3 + 2] = pXRGB[x4+2] << 3;
501 |         }
502 |     }
503 | }
504 | 
505 | void ImageConvert::convert_argb2bgr(uchar *buff, int stride, int w, int h, Mat &dst)
506 | {
507 |     dst.create(Size(w, h), CV_8UC3);
508 | 
509 |     uchar *pBGR = NULL;
510 |     uchar *pXRGB = NULL;
511 | 
512 |     int xbgrstep = w * 4;
513 | 
514 |     // ARGB to BGR
515 |     for (int y = 0; y < h; y++)
516 |     {
517 |         pBGR = dst.data + y * dst.step;
518 |         pXRGB = buff + y * stride;
519 | 
520 |         for (int x4 = 0, x3 = 0; x4 < xbgrstep; x4 += 4, x3 += 3)
521 |         {
522 |             pBGR[x3] = pXRGB[x4+0]; // B
523 |             pBGR[x3 + 1] = pXRGB[x4+1]; // G
524 |             pBGR[x3 + 2] = pXRGB[x4+2]; // R
525 |         }
526 |     }
527 | }
528 | 
529 | void ImageConvert::convert_bgra2bgr(uchar *buff, int stride, int w, int h, Mat &dst)
530 | {
531 |     dst.create(Size(w, h), CV_8UC3);
532 | 
533 |     uchar *pBGR = NULL;
534 |     uchar *pBGRA = NULL;
535 | 
536 |     int xbgrstep = w * 4;
537 | 
538 |     for (int y = 0; y < h; y++)
539 |     {
540 |         pBGR = dst.data + y * dst.step;
541 |         pBGRA = buff + y * stride;
542 | 
543 |         for (int x4 = 0, x3 = 0; x4 < xbgrstep; x4 += 4, x3 += 3)
544 |         {
545 |             pBGR[x3] = pBGRA[x4]; // B
546 |             pBGR[x3 + 1] = pBGRA[x4+1]; // G
547 |             pBGR[x3 + 2] = pBGRA[x4+2]; // R
548 |         }
549 |     }
550 | }
551 | 
552 | void ImageConvert::convert_bgr2bgr(uchar *buff, int stride, int w, int h, Mat &dst)
553 | {
554 |     dst.create(Size(w, h), CV_8UC3);
555 | 
556 |     uchar *pSrcBGR = NULL;
557 |     uchar *pDstRGB = NULL;
558 | 
559 |     int srcstep = w * 3;
560 | 
561 |     // BGR to BGR
562 |     for (int y = 0; y < h; y++)
563 |     {
564 |         pDstRGB = dst.data + y * dst.step;
565 |         pSrcBGR = buff + y * stride;
566 | 
567 |         for (int x3 = 0; x3 < srcstep; x3 += 3)
568 |         {
569 |             pDstRGB[x3] = pSrcBGR[x3]; // B
570 |             pDstRGB[x3 + 1] = pSrcBGR[x3+1]; // G
571 |             pDstRGB[x3 + 2] = pSrcBGR[x3+2]; // R
572 |         }
573 |     }
574 | }
575 | 
576 | void ImageConvert::convert_rgb162bgr(uchar *buff, int stride, int w, int h, Mat &dst)
577 | {
578 |     dst.create(Size(w, h), CV_8UC3);
579 | 
580 |     uchar *pSrcBGR = NULL;
581 |     uchar *pDstRGB = NULL;
582 | 
583 |     int srcstep = w * 2;
584 | 
585 |     // BGR to BGR
586 |     for (int y = 0; y < h; y++)
587 |     {
588 |         pDstRGB = dst.data + y * dst.step;
589 |         pSrcBGR = buff + y * stride;
590 | 
591 |         for (int x2 = 0, x3 = 0; x2 < srcstep; x2 += 2, x3 += 3)
592 |         {
593 |             pDstRGB[x3] = (pSrcBGR[x2] & 0x1F) << 3; // B
594 |             pDstRGB[x3 + 1] = ((pSrcBGR[x2] >> 5) + (pSrcBGR[x2+1]&0x7) << 3) << 2; // G
595 |             pDstRGB[x3 + 2] = (pSrcBGR[x2+1]&0xF8); // R
596 |         }
597 |     }
598 | }
599 | 
600 | inline BYTE ImageConvert::Clip(int clr)
601 | {
602 |     return (BYTE) (clr < 0 ? 0 : (clr > 255 ? 255 : clr));
603 | }
604 | 
605 | inline void ImageConvert::ConvertYCrCbToRGB(
606 |     BYTE y,
607 |     BYTE cr,
608 |     BYTE cb,
609 |     BYTE &r,
610 |     BYTE &g,
611 |     BYTE &b
612 |     )
613 | {
614 |     int c = (int)y - 16;
615 |     int d = (int) cb - 128;
616 |     int e = (int) cr - 128;
617 | 
618 |     r = Clip((298 * c + 409 * e + 128) >> 8);
619 |     g = Clip((298 * c - 100 * d - 208 * e + 128) >> 8);
620 |     b = Clip((298 * c + 516 * d + 128) >> 8);
621 | }
622 | 
623 | ULONG ImageConvert::ReadRawData(const char *filename, uchar **pnv12)
624 | {
625 |     FILE *fp = NULL;
626 | 
627 |     fp = fopen(filename, "rb");
628 | 
629 |     if (fp == NULL)
630 |     {
631 |         cout << "fail to open file " << endl;
632 |         return -1;
633 |     }
634 | 
635 | 
636 | 
637 |     fseek(fp, m_oneimagesize * m_frame, SEEK_SET);
638 |     ULONG datalen = ftell(fp);
639 |     cout << "datalen:" << datalen << endl;
640 |     *pnv12 = (uchar *)malloc((size_t) m_oneimagesize);
641 | 
642 |     size_t readlen = fread(*pnv12, 1, m_oneimagesize, fp);
643 | 
644 |     fclose(fp);
645 | 
646 |     if (readlen != m_oneimagesize)
647 |     {
648 |         cout << "readlength:"<< readlen <<" != imagesize" << m_oneimagesize << endl;
649 |         return -2;
650 |     }
651 | 
652 |     return readlen;
653 | }
654 | 
655 | ULONG ImageConvert::DataLength(const char *filename)
656 | {
657 |     FILE *fp = NULL;
658 | 
659 |     fp = fopen(filename, "rb");
660 | 
661 |     if (fp == NULL)
662 |     {
663 |         cout << "fail to open file " << endl;
664 |         return -1;
665 |     }
666 | 
667 |     fseek(fp, 0L, SEEK_END);
668 |     ULONG datalen = ftell(fp);
669 |     cout << "datalen:" << datalen << endl;
670 |     fseek(fp, 0L, SEEK_SET);
671 |     fclose(fp);
672 |     return datalen;
673 | }
674 | MEDIA_FORMAT ImageConvert:: GetFormatFromString(char *strRawDumpFormat)
675 | {
676 |     MEDIA_FORMAT RawDumpFormat = MEDIA_FORMAT_UNKNOWN;
677 | 
678 |     if (strcmp(strRawDumpFormat, "UYVY") == 0 || strcmp(strRawDumpFormat, "uyvy") == 0)
679 |     {
680 |         RawDumpFormat = MEDIA_FORMAT_UYVY;
681 |     }
682 |     else if (strcmp(strRawDumpFormat, "YUY2") == 0 || strcmp(strRawDumpFormat, "yuy2") == 0 || strcmp(strRawDumpFormat, "YUYV") == 0 || strcmp(strRawDumpFormat, "yuyv") == 0)
683 |     {
684 |         RawDumpFormat = MEDIA_FORMAT_YUY2;
685 |     }
686 |     else if (strcmp(strRawDumpFormat, "NV12") == 0 || strcmp(strRawDumpFormat, "nv12") == 0)
687 |     {
688 |         RawDumpFormat = MEDIA_FORMAT_NV12;
689 |     }
690 |     else if (strcmp(strRawDumpFormat, "NV16") == 0 || strcmp(strRawDumpFormat, "nv16") == 0)
691 |     {
692 |         RawDumpFormat = MEDIA_FORMAT_NV16;
693 |     }
694 |     else if (strcmp(strRawDumpFormat, "XRGB") == 0 || strcmp(strRawDumpFormat, "RGBx") == 0)
695 |     {
696 |         RawDumpFormat = MEDIA_FORMAT_XRGB;
697 |     }
698 |     else if (strcmp(strRawDumpFormat, "XBGR") == 0 || strcmp(strRawDumpFormat, "BGRx") == 0)
699 |     {
700 |         RawDumpFormat = MEDIA_FORMAT_XBGR;
701 |     }
702 |     else if (strcmp(strRawDumpFormat, "I420") == 0 || strcmp(strRawDumpFormat, "i420") == 0)
703 |     {
704 |         RawDumpFormat = MEDIA_FORMAT_I420;
705 |     }
706 |     else if (strcmp(strRawDumpFormat, "ARGB") == 0)
707 |     {
708 |         RawDumpFormat = MEDIA_FORMAT_ARGB;
709 |     }
710 |     else if (strcmp(strRawDumpFormat, "BGRA") == 0)
711 |     {
712 |         RawDumpFormat = MEDIA_FORMAT_BGRA;
713 |     }
714 |     else if (strcmp(strRawDumpFormat, "BGR") == 0 ||
715 |              strcmp(strRawDumpFormat, "BGR888") == 0 ||
716 |              strcmp(strRawDumpFormat, "BGR24") == 0)
717 |     {
718 |         RawDumpFormat = MEDIA_FORMAT_BGR24;
719 |     }
720 |     else if (strcmp(strRawDumpFormat, "RGB16") == 0 ||
721 |              strcmp(strRawDumpFormat, "RGB565") == 0 )
722 |     {
723 |         RawDumpFormat = MEDIA_FORMAT_RGB565;
724 |     }
725 |     return RawDumpFormat;
726 | }
727 | 
728 | void ImageConvert::debug(char *msg,DebugLevel level)
729 | {
730 | 
731 |     if (DEBUG_LEVEL == 1 )
732 |     {
733 |       cout << "function:" <<__FUNCTION__<<"line:" << __LINE__<< level << ":" <<"msg:"<< msg << endl;
734 |     }
735 | 
736 | }
737 | int ImageConvert::checkParameters()
738 |   {
739 |      if (m_filename[0] == 0)
740 |      {
741 |        cout << "please type filename...." << endl;
742 |        return -1;
743 |      }
744 | 
745 |      if (m_format[0] == 0)
746 |      {
747 |        cout << "please type format ..." << endl;
748 |        return -1;
749 |      }
750 |      if (m_width == 0)
751 |      {
752 |       cout <<"please type width..." << endl;
753 |       return -1;
754 |      }
755 |      if (m_height == 0)
756 |      {
757 |       cout <<"pleae type height .." << endl;
758 |       return -1;
759 |      }
760 | 
761 |      return 0;
762 |   }
763 | 


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