开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
imgconvert.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：68k
源码类别：

Audio

开发平台：

Visual C++

imgconvert.c：源码内容
  1. /*  * Misc image convertion routines  * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.  *  * This library is free software; you can redistribute it and/or  * modify it under the terms of the GNU Lesser General Public  * License as published by the Free Software Foundation; either  * version 2 of the License, or (at your option) any later version.  *  * This library is distributed in the hope that it will be useful,  * but WITHOUT ANY WARRANTY; without even the implied warranty of  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU  * Lesser General Public License for more details.  *  * You should have received a copy of the GNU Lesser General Public  * License along with this library; if not, write to the Free Software  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  */ /**  * @file imgconvert.c  * Misc image convertion routines.  */ /* TODO:  * - write 'ffimg' program to test all the image related stuff  * - move all api to slice based system  * - integrate deinterlacing, postprocessing and scaling in the conversion process  */ #include "avcodec.h" #include "dsputil.h" #ifdef USE_FASTMEMCPY #include "fastmemcpy.h" #endif #ifdef HAVE_MMX //#include "i386/mmx.h" //Del by ty
  2. #endif #define xglue(x, y) x ## y #define glue(x, y) xglue(x, y) #define FF_COLOR_RGB      0 /* RGB color space */ #define FF_COLOR_GRAY     1 /* gray color space */ #define FF_COLOR_YUV      2 /* YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */ #define FF_COLOR_YUV_JPEG 3 /* YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */ #define FF_PIXEL_PLANAR   0 /* each channel has one component in AVPicture */ #define FF_PIXEL_PACKED   1 /* only one components containing all the channels */ #define FF_PIXEL_PALETTE  2  /* one components containing indexes for a palette */ typedef struct PixFmtInfo {     const char *name;     uint8_t nb_channels;     /* number of channels (including alpha) */     uint8_t color_type;      /* color type (see FF_COLOR_xxx constants) */     uint8_t pixel_type;      /* pixel storage type (see FF_PIXEL_xxx constants) */     uint8_t is_alpha : 1;    /* true if alpha can be specified */     uint8_t x_chroma_shift;  /* X chroma subsampling factor is 2 ^ shift */     uint8_t y_chroma_shift;  /* Y chroma subsampling factor is 2 ^ shift */     uint8_t depth;           /* bit depth of the color components */ } PixFmtInfo; //CS by ty
  3. /* this table gives more information about formats */ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = {     /* YUV formats */
  4. {
  5.         "yuv420p",         3,         FF_COLOR_YUV,         FF_PIXEL_PLANAR,         8,         1,
  6. 1,      }, //    PIX_FMT_YUV420P = 
  7. // {
  8. //        .name = "yuv420p",
  9. //        .nb_channels = 3,
  10. //        .color_type = FF_COLOR_YUV,
  11. //        .pixel_type = FF_PIXEL_PLANAR,
  12. //        .depth = 8,
  13. //        .x_chroma_shift = 1, .y_chroma_shift = 1, 
  14. //    },
  15. //    [PIX_FMT_YUV422P] = {
  16. //        .name = "yuv422p",
  17. //        .nb_channels = 3,
  18. //        .color_type = FF_COLOR_YUV,
  19. //        .pixel_type = FF_PIXEL_PLANAR,
  20. //        .depth = 8,
  21. //        .x_chroma_shift = 1, .y_chroma_shift = 0, 
  22. //    },
  23. //    [PIX_FMT_YUV444P] = {
  24. //        .name = "yuv444p",
  25. //        .nb_channels = 3,
  26. //        .color_type = FF_COLOR_YUV,
  27. //        .pixel_type = FF_PIXEL_PLANAR,
  28. //        .depth = 8,
  29. //        .x_chroma_shift = 0, .y_chroma_shift = 0, 
  30. //    },
  31. //    [PIX_FMT_YUV422] = {
  32. //        .name = "yuv422",
  33. //        .nb_channels = 1,
  34. //        .color_type = FF_COLOR_YUV,
  35. //        .pixel_type = FF_PIXEL_PACKED,
  36. //        .depth = 8,
  37. //        .x_chroma_shift = 1, .y_chroma_shift = 0,
  38. //    },
  39. //    [PIX_FMT_YUV410P] = {
  40. //        .name = "yuv410p",
  41. //        .nb_channels = 3,
  42. //        .color_type = FF_COLOR_YUV,
  43. //        .pixel_type = FF_PIXEL_PLANAR,
  44. //        .depth = 8,
  45. //        .x_chroma_shift = 2, .y_chroma_shift = 2,
  46. //    },
  47. //    [PIX_FMT_YUV411P] = {
  48. //        .name = "yuv411p",
  49. //        .nb_channels = 3,
  50. //        .color_type = FF_COLOR_YUV,
  51. //        .pixel_type = FF_PIXEL_PLANAR,
  52. //        .depth = 8,
  53. //        .x_chroma_shift = 2, .y_chroma_shift = 0,
  54. //    },
  55. //    /* JPEG YUV */
  56. //    [PIX_FMT_YUVJ420P] = {
  57. //        .name = "yuvj420p",
  58. //        .nb_channels = 3,
  59. //        .color_type = FF_COLOR_YUV_JPEG,
  60. //        .pixel_type = FF_PIXEL_PLANAR,
  61. //        .depth = 8,
  62. //        .x_chroma_shift = 1, .y_chroma_shift = 1, 
  63. //    },
  64. //    [PIX_FMT_YUVJ422P] = {
  65. //        .name = "yuvj422p",
  66. //        .nb_channels = 3,
  67. //        .color_type = FF_COLOR_YUV_JPEG,
  68. //        .pixel_type = FF_PIXEL_PLANAR,
  69. //        .depth = 8,
  70. //        .x_chroma_shift = 1, .y_chroma_shift = 0, 
  71. //    },
  72. //    [PIX_FMT_YUVJ444P] = {
  73. //        .name = "yuvj444p",
  74. //        .nb_channels = 3,
  75. //        .color_type = FF_COLOR_YUV_JPEG,
  76. //        .pixel_type = FF_PIXEL_PLANAR,
  77. //        .depth = 8,
  78. //        .x_chroma_shift = 0, .y_chroma_shift = 0, 
  79. //    },
  80. //    /* RGB formats */
  81. //    [PIX_FMT_RGB24] = {
  82. //        .name = "rgb24",
  83. //        .nb_channels = 3,
  84. //        .color_type = FF_COLOR_RGB,
  85. //        .pixel_type = FF_PIXEL_PACKED,
  86. //        .depth = 8,
  87. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  88. //    },
  89. //    [PIX_FMT_BGR24] = {
  90. //        .name = "bgr24",
  91. //        .nb_channels = 3,
  92. //        .color_type = FF_COLOR_RGB,
  93. //        .pixel_type = FF_PIXEL_PACKED,
  94. //        .depth = 8,
  95. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  96. //    },
  97. //    [PIX_FMT_RGBA32] = {
  98. //        .name = "rgba32",
  99. //        .nb_channels = 4, .is_alpha = 1,
  100. //        .color_type = FF_COLOR_RGB,
  101. //        .pixel_type = FF_PIXEL_PACKED,
  102. //        .depth = 8,
  103. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  104. //    },
  105. //    [PIX_FMT_RGB565] = {
  106. //        .name = "rgb565",
  107. //        .nb_channels = 3,
  108. //        .color_type = FF_COLOR_RGB,
  109. //        .pixel_type = FF_PIXEL_PACKED,
  110. //        .depth = 5,
  111. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  112. //    },
  113. //    [PIX_FMT_RGB555] = {
  114. //        .name = "rgb555",
  115. //        .nb_channels = 4, .is_alpha = 1,
  116. //        .color_type = FF_COLOR_RGB,
  117. //        .pixel_type = FF_PIXEL_PACKED,
  118. //        .depth = 5,
  119. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  120. //    },
  121. //    /* gray / mono formats */
  122. //    [PIX_FMT_GRAY8] = {
  123. //        .name = "gray",
  124. //        .nb_channels = 1,
  125. //        .color_type = FF_COLOR_GRAY,
  126. //        .pixel_type = FF_PIXEL_PLANAR,
  127. //        .depth = 8,
  128. //    },
  129. //    [PIX_FMT_MONOWHITE] = {
  130. //        .name = "monow",
  131. //        .nb_channels = 1,
  132. //        .color_type = FF_COLOR_GRAY,
  133. //        .pixel_type = FF_PIXEL_PLANAR,
  134. //        .depth = 1,
  135. //    },
  136. //    [PIX_FMT_MONOBLACK] = {
  137. //        .name = "monob",
  138. //        .nb_channels = 1,
  139. //        .color_type = FF_COLOR_GRAY,
  140. //        .pixel_type = FF_PIXEL_PLANAR,
  141. //        .depth = 1,
  142. //    },
  143. //    /* paletted formats */
  144. //    [PIX_FMT_PAL8] = {
  145. //        .name = "pal8",
  146. //        .nb_channels = 4, .is_alpha = 1,
  147. //        .color_type = FF_COLOR_RGB,
  148. //        .pixel_type = FF_PIXEL_PALETTE,
  149. //        .depth = 8,
  150. //    },
  151. }; //static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = {
  152. //    /* YUV formats */
  153. ////CS by ty
  154. ////    [PIX_FMT_YUV420P] = {
  155. ////    [0] = {
  156. // {
  157. //        "yuv420p",
  158. //        3,
  159. //        FF_COLOR_YUV,
  160. //        FF_PIXEL_PLANAR,
  161. //        8,
  162. //        1,
  163. // 1, 
  164. //    },
  165. ////    PIX_FMT_YUV420P = 
  166. //// {
  167. ////        .name = "yuv420p",
  168. ////        .nb_channels = 3,
  169. ////        .color_type = FF_COLOR_YUV,
  170. ////        .pixel_type = FF_PIXEL_PLANAR,
  171. ////        .depth = 8,
  172. ////        .x_chroma_shift = 1, .y_chroma_shift = 1, 
  173. ////    },
  174. ////CE by ty
  175. //    [PIX_FMT_YUV422P] = {
  176. //        .name = "yuv422p",
  177. //        .nb_channels = 3,
  178. //        .color_type = FF_COLOR_YUV,
  179. //        .pixel_type = FF_PIXEL_PLANAR,
  180. //        .depth = 8,
  181. //        .x_chroma_shift = 1, .y_chroma_shift = 0, 
  182. //    },
  183. //    [PIX_FMT_YUV444P] = {
  184. //        .name = "yuv444p",
  185. //        .nb_channels = 3,
  186. //        .color_type = FF_COLOR_YUV,
  187. //        .pixel_type = FF_PIXEL_PLANAR,
  188. //        .depth = 8,
  189. //        .x_chroma_shift = 0, .y_chroma_shift = 0, 
  190. //    },
  191. //    [PIX_FMT_YUV422] = {
  192. //        .name = "yuv422",
  193. //        .nb_channels = 1,
  194. //        .color_type = FF_COLOR_YUV,
  195. //        .pixel_type = FF_PIXEL_PACKED,
  196. //        .depth = 8,
  197. //        .x_chroma_shift = 1, .y_chroma_shift = 0,
  198. //    },
  199. //    [PIX_FMT_YUV410P] = {
  200. //        .name = "yuv410p",
  201. //        .nb_channels = 3,
  202. //        .color_type = FF_COLOR_YUV,
  203. //        .pixel_type = FF_PIXEL_PLANAR,
  204. //        .depth = 8,
  205. //        .x_chroma_shift = 2, .y_chroma_shift = 2,
  206. //    },
  207. //    [PIX_FMT_YUV411P] = {
  208. //        .name = "yuv411p",
  209. //        .nb_channels = 3,
  210. //        .color_type = FF_COLOR_YUV,
  211. //        .pixel_type = FF_PIXEL_PLANAR,
  212. //        .depth = 8,
  213. //        .x_chroma_shift = 2, .y_chroma_shift = 0,
  214. //    },
  215. //
  216. //    /* JPEG YUV */
  217. //    [PIX_FMT_YUVJ420P] = {
  218. //        .name = "yuvj420p",
  219. //        .nb_channels = 3,
  220. //        .color_type = FF_COLOR_YUV_JPEG,
  221. //        .pixel_type = FF_PIXEL_PLANAR,
  222. //        .depth = 8,
  223. //        .x_chroma_shift = 1, .y_chroma_shift = 1, 
  224. //    },
  225. //    [PIX_FMT_YUVJ422P] = {
  226. //        .name = "yuvj422p",
  227. //        .nb_channels = 3,
  228. //        .color_type = FF_COLOR_YUV_JPEG,
  229. //        .pixel_type = FF_PIXEL_PLANAR,
  230. //        .depth = 8,
  231. //        .x_chroma_shift = 1, .y_chroma_shift = 0, 
  232. //    },
  233. //    [PIX_FMT_YUVJ444P] = {
  234. //        .name = "yuvj444p",
  235. //        .nb_channels = 3,
  236. //        .color_type = FF_COLOR_YUV_JPEG,
  237. //        .pixel_type = FF_PIXEL_PLANAR,
  238. //        .depth = 8,
  239. //        .x_chroma_shift = 0, .y_chroma_shift = 0, 
  240. //    },
  241. //
  242. //    /* RGB formats */
  243. //    [PIX_FMT_RGB24] = {
  244. //        .name = "rgb24",
  245. //        .nb_channels = 3,
  246. //        .color_type = FF_COLOR_RGB,
  247. //        .pixel_type = FF_PIXEL_PACKED,
  248. //        .depth = 8,
  249. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  250. //    },
  251. //    [PIX_FMT_BGR24] = {
  252. //        .name = "bgr24",
  253. //        .nb_channels = 3,
  254. //        .color_type = FF_COLOR_RGB,
  255. //        .pixel_type = FF_PIXEL_PACKED,
  256. //        .depth = 8,
  257. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  258. //    },
  259. //    [PIX_FMT_RGBA32] = {
  260. //        .name = "rgba32",
  261. //        .nb_channels = 4, .is_alpha = 1,
  262. //        .color_type = FF_COLOR_RGB,
  263. //        .pixel_type = FF_PIXEL_PACKED,
  264. //        .depth = 8,
  265. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  266. //    },
  267. //    [PIX_FMT_RGB565] = {
  268. //        .name = "rgb565",
  269. //        .nb_channels = 3,
  270. //        .color_type = FF_COLOR_RGB,
  271. //        .pixel_type = FF_PIXEL_PACKED,
  272. //        .depth = 5,
  273. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  274. //    },
  275. //    [PIX_FMT_RGB555] = {
  276. //        .name = "rgb555",
  277. //        .nb_channels = 4, .is_alpha = 1,
  278. //        .color_type = FF_COLOR_RGB,
  279. //        .pixel_type = FF_PIXEL_PACKED,
  280. //        .depth = 5,
  281. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  282. //    },
  283. //
  284. //    /* gray / mono formats */
  285. //    [PIX_FMT_GRAY8] = {
  286. //        .name = "gray",
  287. //        .nb_channels = 1,
  288. //        .color_type = FF_COLOR_GRAY,
  289. //        .pixel_type = FF_PIXEL_PLANAR,
  290. //        .depth = 8,
  291. //    },
  292. //    [PIX_FMT_MONOWHITE] = {
  293. //        .name = "monow",
  294. //        .nb_channels = 1,
  295. //        .color_type = FF_COLOR_GRAY,
  296. //        .pixel_type = FF_PIXEL_PLANAR,
  297. //        .depth = 1,
  298. //    },
  299. //    [PIX_FMT_MONOBLACK] = {
  300. //        .name = "monob",
  301. //        .nb_channels = 1,
  302. //        .color_type = FF_COLOR_GRAY,
  303. //        .pixel_type = FF_PIXEL_PLANAR,
  304. //        .depth = 1,
  305. //    },
  306. //
  307. //    /* paletted formats */
  308. //    [PIX_FMT_PAL8] = {
  309. //        .name = "pal8",
  310. //        .nb_channels = 4, .is_alpha = 1,
  311. //        .color_type = FF_COLOR_RGB,
  312. //        .pixel_type = FF_PIXEL_PALETTE,
  313. //        .depth = 8,
  314. //    },
  315. //};
  316. //CE by ty
  318. void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift) {     *h_shift = pix_fmt_info[pix_fmt].x_chroma_shift;     *v_shift = pix_fmt_info[pix_fmt].y_chroma_shift; } const char *avcodec_get_pix_fmt_name(int pix_fmt)
  319. {
  320.     if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB)
  321.         return "???";
  322.     else
  323.         return pix_fmt_info[pix_fmt].name;
  324. }
  325. enum PixelFormat avcodec_get_pix_fmt(const char* name)
  326. {
  327.     int i; 
  328.     
  329.     for (i=0; i < PIX_FMT_NB; i++)
  330.          if (!strcmp(pix_fmt_info[i].name, name))
  331.      break;
  332.     return i;
  333. }
  334. /* Picture field are filled with 'ptr' addresses. Also return size */
  335. int avpicture_fill(AVPicture *picture, uint8_t *ptr,
  336.    int pix_fmt, int width, int height)
  337. {
  338.     int size, w2, h2, size2;
  339.     PixFmtInfo *pinfo;
  340.     
  341.     pinfo = &pix_fmt_info[pix_fmt];
  342.     size = width * height;
  343.     switch(pix_fmt) {
  344.     case PIX_FMT_YUV420P:
  345.     case PIX_FMT_YUV422P:
  346.     case PIX_FMT_YUV444P:
  347.     case PIX_FMT_YUV410P:
  348.     case PIX_FMT_YUV411P:
  349.     case PIX_FMT_YUVJ420P:
  350.     case PIX_FMT_YUVJ422P:
  351.     case PIX_FMT_YUVJ444P:
  352.         w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
  353.         h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
  354.         size2 = w2 * h2;
  355.         picture->data[0] = ptr;
  356.         picture->data[1] = picture->data[0] + size;
  357.         picture->data[2] = picture->data[1] + size2;
  358.         picture->linesize[0] = width;
  359.         picture->linesize[1] = w2;
  360.         picture->linesize[2] = w2;
  361.         return size + 2 * size2;
  362.     case PIX_FMT_RGB24:
  363.     case PIX_FMT_BGR24:
  364.         picture->data[0] = ptr;
  365.         picture->data[1] = NULL;
  366.         picture->data[2] = NULL;
  367.         picture->linesize[0] = width * 3;
  368.         return size * 3;
  369.     case PIX_FMT_RGBA32:
  370.         picture->data[0] = ptr;
  371.         picture->data[1] = NULL;
  372.         picture->data[2] = NULL;
  373.         picture->linesize[0] = width * 4;
  374.         return size * 4;
  375.     case PIX_FMT_RGB555:
  376.     case PIX_FMT_RGB565:
  377.     case PIX_FMT_YUV422:
  378.         picture->data[0] = ptr;
  379.         picture->data[1] = NULL;
  380.         picture->data[2] = NULL;
  381.         picture->linesize[0] = width * 2;
  382.         return size * 2;
  383.     case PIX_FMT_GRAY8:
  384.         picture->data[0] = ptr;
  385.         picture->data[1] = NULL;
  386.         picture->data[2] = NULL;
  387.         picture->linesize[0] = width;
  388.         return size;
  389.     case PIX_FMT_MONOWHITE:
  390.     case PIX_FMT_MONOBLACK:
  391.         picture->data[0] = ptr;
  392.         picture->data[1] = NULL;
  393.         picture->data[2] = NULL;
  394.         picture->linesize[0] = (width + 7) >> 3;
  395.         return picture->linesize[0] * height;
  396.     case PIX_FMT_PAL8:
  397.         size2 = (size + 3) & ~3;
  398.         picture->data[0] = ptr;
  399.         picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */
  400.         picture->data[2] = NULL;
  401.         picture->linesize[0] = width;
  402.         picture->linesize[1] = 4;
  403.         return size2 + 256 * 4;
  404.     default:
  405.         picture->data[0] = NULL;
  406.         picture->data[1] = NULL;
  407.         picture->data[2] = NULL;
  408.         picture->data[3] = NULL;
  409.         return -1;
  410.     }
  411. }
  412. //int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height,
  413. //                     unsigned char *dest, int dest_size)
  414. //{
  415. //    PixFmtInfo* pf = &pix_fmt_info[pix_fmt];
  416. //    int i, j, w, h, data_planes;
  417. //    const unsigned char* s; 
  418. //    int size = avpicture_get_size(pix_fmt, width, height);
  419. //    if (size > dest_size)
  420. //        return -1;
  421. //    if (pf->pixel_type == FF_PIXEL_PACKED || pf->pixel_type == FF_PIXEL_PALETTE) {
  422. //        if (pix_fmt == PIX_FMT_YUV422 || pix_fmt == PIX_FMT_RGB565 ||
  423. //     pix_fmt == PIX_FMT_RGB555)
  424. //   w = width * 2;
  425. // else if (pix_fmt == PIX_FMT_PAL8)
  426. //   w = width;
  427. // else
  428. //   w = width * (pf->depth * pf->nb_channels / 8);
  429. //   
  430. // data_planes = 1;
  431. // h = height;
  432. //    } else {
  433. //        data_planes = pf->nb_channels;
  434. // w = width;
  435. // h = height;
  436. //    }
  437. //    
  438. //    for (i=0; i<data_planes; i++) {
  439. //         if (i == 1) {
  440. //      w = width >> pf->x_chroma_shift;
  441. //      h = height >> pf->y_chroma_shift;
  442. //  }
  443. //         s = src->data[i];
  444. //  for(j=0; j<h; j++) {
  445. //      memcpy(dest, s, w);
  446. //      dest += w;
  447. //      s += src->linesize[i];
  448. //  }
  449. //    }
  450. //    
  451. //    if (pf->pixel_type == FF_PIXEL_PALETTE)
  452. // memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4);
  453. //    
  454. //    return size;
  455. //}
  456. //int avpicture_get_size(int pix_fmt, int width, int height)
  457. //{
  458. //    AVPicture dummy_pict;
  459. //    return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);
  460. //}
  461. ///**
  462. // * compute the loss when converting from a pixel format to another 
  463. // */
  464. //int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt,
  465. //                             int has_alpha)
  466. //{
  467. //    const PixFmtInfo *pf, *ps;
  468. //    int loss;
  469. //    ps = &pix_fmt_info[src_pix_fmt];
  470. //    pf = &pix_fmt_info[dst_pix_fmt];
  471. //    /* compute loss */
  472. //    loss = 0;
  473. //    pf = &pix_fmt_info[dst_pix_fmt];
  474. //    if (pf->depth < ps->depth ||
  475. //        (dst_pix_fmt == PIX_FMT_RGB555 && src_pix_fmt == PIX_FMT_RGB565))
  476. //        loss |= FF_LOSS_DEPTH;
  477. //    if (pf->x_chroma_shift > ps->x_chroma_shift ||
  478. //        pf->y_chroma_shift > ps->y_chroma_shift)
  479. //        loss |= FF_LOSS_RESOLUTION;
  480. //    switch(pf->color_type) {
  481. //    case FF_COLOR_RGB:
  482. //        if (ps->color_type != FF_COLOR_RGB &&
  483. //            ps->color_type != FF_COLOR_GRAY)
  484. //            loss |= FF_LOSS_COLORSPACE;
  485. //        break;
  486. //    case FF_COLOR_GRAY:
  487. //        if (ps->color_type != FF_COLOR_GRAY)
  488. //            loss |= FF_LOSS_COLORSPACE;
  489. //        break;
  490. //    case FF_COLOR_YUV:
  491. //        if (ps->color_type != FF_COLOR_YUV)
  492. //            loss |= FF_LOSS_COLORSPACE;
  493. //        break;
  494. //    case FF_COLOR_YUV_JPEG:
  495. //        if (ps->color_type != FF_COLOR_YUV_JPEG &&
  496. //            ps->color_type != FF_COLOR_YUV && 
  497. //            ps->color_type != FF_COLOR_GRAY)
  498. //            loss |= FF_LOSS_COLORSPACE;
  499. //        break;
  500. //    default:
  501. //        /* fail safe test */
  502. //        if (ps->color_type != pf->color_type)
  503. //            loss |= FF_LOSS_COLORSPACE;
  504. //        break;
  505. //    }
  506. //    if (pf->color_type == FF_COLOR_GRAY &&
  507. //        ps->color_type != FF_COLOR_GRAY)
  508. //        loss |= FF_LOSS_CHROMA;
  509. //    if (!pf->is_alpha && (ps->is_alpha && has_alpha))
  510. //        loss |= FF_LOSS_ALPHA;
  511. //    if (pf->pixel_type == FF_PIXEL_PALETTE && 
  512. //        (ps->pixel_type != FF_PIXEL_PALETTE && ps->color_type != FF_COLOR_GRAY))
  513. //        loss |= FF_LOSS_COLORQUANT;
  514. //    return loss;
  515. //}
  516. //static int avg_bits_per_pixel(int pix_fmt)
  517. //{
  518. //    int bits;
  519. //    const PixFmtInfo *pf;
  520. //    pf = &pix_fmt_info[pix_fmt];
  521. //    switch(pf->pixel_type) {
  522. //    case FF_PIXEL_PACKED:
  523. //        switch(pix_fmt) {
  524. //        case PIX_FMT_YUV422:
  525. //        case PIX_FMT_RGB565:
  526. //        case PIX_FMT_RGB555:
  527. //            bits = 16;
  528. //            break;
  529. //        default:
  530. //            bits = pf->depth * pf->nb_channels;
  531. //            break;
  532. //        }
  533. //        break;
  534. //    case FF_PIXEL_PLANAR:
  535. //        if (pf->x_chroma_shift == 0 && pf->y_chroma_shift == 0) {
  536. //            bits = pf->depth * pf->nb_channels;
  537. //        } else {
  538. //            bits = pf->depth + ((2 * pf->depth) >> 
  539. //                                (pf->x_chroma_shift + pf->y_chroma_shift));
  540. //        }
  541. //        break;
  542. //    case FF_PIXEL_PALETTE:
  543. //        bits = 8;
  544. //        break;
  545. //    default:
  546. //        bits = -1;
  547. //        break;
  548. //    }
  549. //    return bits;
  550. //}
  551. //static int avcodec_find_best_pix_fmt1(int pix_fmt_mask, 
  552. //                                      int src_pix_fmt,
  553. //                                      int has_alpha,
  554. //                                      int loss_mask)
  555. //{
  556. //    int dist, i, loss, min_dist, dst_pix_fmt;
  557. //    /* find exact color match with smallest size */
  558. //    dst_pix_fmt = -1;
  559. //    min_dist = 0x7fffffff;
  560. //    for(i = 0;i < PIX_FMT_NB; i++) {
  561. //        if (pix_fmt_mask & (1 << i)) {
  562. //            loss = avcodec_get_pix_fmt_loss(i, src_pix_fmt, has_alpha) & loss_mask;
  563. //            if (loss == 0) {
  564. //                dist = avg_bits_per_pixel(i);
  565. //                if (dist < min_dist) {
  566. //                    min_dist = dist;
  567. //                    dst_pix_fmt = i;
  568. //                }
  569. //            }
  570. //        }
  571. //    }
  572. //    return dst_pix_fmt;
  573. //}
  574. ///** 
  575. // * find best pixel format to convert to. Return -1 if none found 
  576. // */
  577. //int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt,
  578. //                              int has_alpha, int *loss_ptr)
  579. //{
  580. //    int dst_pix_fmt, loss_mask, i;
  581. //    static const int loss_mask_order[] = {
  582. //        ~0, /* no loss first */
  583. //        ~FF_LOSS_ALPHA,
  584. //        ~FF_LOSS_RESOLUTION,
  585. //        ~(FF_LOSS_COLORSPACE | FF_LOSS_RESOLUTION),
  586. //        ~FF_LOSS_COLORQUANT,
  587. //        ~FF_LOSS_DEPTH,
  588. //        0,
  589. //    };
  590. //    /* try with successive loss */
  591. //    i = 0;
  592. //    for(;;) {
  593. //        loss_mask = loss_mask_order[i++];
  594. //        dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_mask, src_pix_fmt, 
  595. //                                                 has_alpha, loss_mask);
  596. //        if (dst_pix_fmt >= 0)
  597. //            goto found;
  598. //        if (loss_mask == 0)
  599. //            break;
  600. //    }
  601. //    return -1;
  602. // found:
  603. //    if (loss_ptr)
  604. //        *loss_ptr = avcodec_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
  605. //    return dst_pix_fmt;
  606. //}
  607. static void img_copy_plane(uint8_t *dst, int dst_wrap, 
  608.                            const uint8_t *src, int src_wrap,
  609.                            int width, int height)
  610. {
  611.     for(;height > 0; height--) {
  612.         memcpy(dst, src, width);
  613.         dst += dst_wrap;
  614.         src += src_wrap;
  615.     }
  616. }
  617. /**
  618.  * Copy image 'src' to 'dst'.
  619.  */
  620. void img_copy(AVPicture *dst, const AVPicture *src,
  621.               int pix_fmt, int width, int height)
  622. {
  623.     int bwidth, bits, i;
  624.     PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
  625.     
  626.     pf = &pix_fmt_info[pix_fmt];
  627.     switch(pf->pixel_type) {
  628.     case FF_PIXEL_PACKED:
  629.         switch(pix_fmt) {
  630.         case PIX_FMT_YUV422:
  631.         case PIX_FMT_RGB565:
  632.         case PIX_FMT_RGB555:
  633.             bits = 16;
  634.             break;
  635.         default:
  636.             bits = pf->depth * pf->nb_channels;
  637.             break;
  638.         }
  639.         bwidth = (width * bits + 7) >> 3;
  640.         img_copy_plane(dst->data[0], dst->linesize[0],
  641.                        src->data[0], src->linesize[0],
  642.                        bwidth, height);
  643.         break;
  644.     case FF_PIXEL_PLANAR:
  645.         for(i = 0; i < pf->nb_channels; i++) {
  646.             int w, h;
  647.             w = width;
  648.             h = height;
  649.             if (i == 1 || i == 2) {
  650.                 w >>= pf->x_chroma_shift;
  651.                 h >>= pf->y_chroma_shift;
  652.             }
  653.             bwidth = (w * pf->depth + 7) >> 3;
  654.             img_copy_plane(dst->data[i], dst->linesize[i],
  655.                            src->data[i], src->linesize[i],
  656.                            bwidth, h);
  657.         }
  658.         break;
  659.     case FF_PIXEL_PALETTE:
  660.         img_copy_plane(dst->data[0], dst->linesize[0],
  661.                        src->data[0], src->linesize[0],
  662.                        width, height);
  663.         /* copy the palette */
  664.         img_copy_plane(dst->data[1], dst->linesize[1],
  665.                        src->data[1], src->linesize[1],
  666.                        4, 256);
  667.         break;
  668.     }
  669. }
  670. ///* XXX: totally non optimized */
  671. //static void yuv422_to_yuv420p(AVPicture *dst, const AVPicture *src,
  672. //                              int width, int height)
  673. //{
  674. //    const uint8_t *p, *p1;
  675. //    uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  676. //    int w;
  677. // 
  678. //    p1 = src->data[0];
  679. //    lum1 = dst->data[0];
  680. //    cb1 = dst->data[1];
  681. //    cr1 = dst->data[2];
  682. //    for(;height >= 1; height -= 2) {
  683. //        p = p1;
  684. //        lum = lum1;
  685. //        cb = cb1;
  686. //        cr = cr1;
  687. //        for(w = width; w >= 2; w -= 2) {
  688. //            lum[0] = p[0];
  689. //            cb[0] = p[1];
  690. //            lum[1] = p[2];
  691. //            cr[0] = p[3];
  692. //            p += 4;
  693. //            lum += 2;
  694. //            cb++;
  695. //            cr++;
  696. //        }
  697. //        if (w) {
  698. //            lum[0] = p[0];
  699. //            cb[0] = p[1];
  700. //            cr[0] = p[3];
  701. //            cb++;
  702. //            cr++;
  703. //        }
  704. //        p1 += src->linesize[0];
  705. //        lum1 += dst->linesize[0];
  706. //        if (height>1) {
  707. //            p = p1;
  708. //            lum = lum1;
  709. //            for(w = width; w >= 2; w -= 2) {
  710. //                lum[0] = p[0];
  711. //                lum[1] = p[2];
  712. //                p += 4;
  713. //                lum += 2;
  714. //            }
  715. //            if (w) {
  716. //                lum[0] = p[0];
  717. //            }
  718. //            p1 += src->linesize[0];
  719. //            lum1 += dst->linesize[0];
  720. //        }
  721. //        cb1 += dst->linesize[1];
  722. //        cr1 += dst->linesize[2];
  723. //    }
  724. //}
  725. //static void yuv422_to_yuv422p(AVPicture *dst, const AVPicture *src,
  726. //                              int width, int height)
  727. //{
  728. //    const uint8_t *p, *p1;
  729. //    uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  730. //    int w;
  731. //    p1 = src->data[0];
  732. //    lum1 = dst->data[0];
  733. //    cb1 = dst->data[1];
  734. //    cr1 = dst->data[2];
  735. //    for(;height > 0; height--) {
  736. //        p = p1;
  737. //        lum = lum1;
  738. //        cb = cb1;
  739. //        cr = cr1;
  740. //        for(w = width; w >= 2; w -= 2) {
  741. //            lum[0] = p[0];
  742. //            cb[0] = p[1];
  743. //            lum[1] = p[2];
  744. //            cr[0] = p[3];
  745. //            p += 4;
  746. //            lum += 2;
  747. //            cb++;
  748. //            cr++;
  749. //        }
  750. //        p1 += src->linesize[0];
  751. //        lum1 += dst->linesize[0];
  752. //        cb1 += dst->linesize[1];
  753. //        cr1 += dst->linesize[2];
  754. //    }
  755. //}
  756. //static void yuv422p_to_yuv422(AVPicture *dst, const AVPicture *src,
  757. //                              int width, int height)
  758. //{
  759. //    uint8_t *p, *p1;
  760. //    const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  761. //    int w;
  762. //    p1 = dst->data[0];
  763. //    lum1 = src->data[0];
  764. //    cb1 = src->data[1];
  765. //    cr1 = src->data[2];
  766. //    for(;height > 0; height--) {
  767. //        p = p1;
  768. //        lum = lum1;
  769. //        cb = cb1;
  770. //        cr = cr1;
  771. //        for(w = width; w >= 2; w -= 2) {
  772. //            p[0] = lum[0];
  773. //            p[1] = cb[0];
  774. //            p[2] = lum[1];
  775. //            p[3] = cr[0];
  776. //            p += 4;
  777. //            lum += 2;
  778. //            cb++;
  779. //            cr++;
  780. //        }
  781. //        p1 += dst->linesize[0];
  782. //        lum1 += src->linesize[0];
  783. //        cb1 += src->linesize[1];
  784. //        cr1 += src->linesize[2];
  785. //    }
  786. //}
  787. //#define SCALEBITS 10
  788. //#define ONE_HALF  (1 << (SCALEBITS - 1))
  789. //#define FIX(x)   ((int) ((x) * (1<<SCALEBITS) + 0.5))
  790. //#define YUV_TO_RGB1_CCIR(cb1, cr1)
  791. //{
  792. //    cb = (cb1) - 128;
  793. //    cr = (cr1) - 128;
  794. //    r_add = FIX(1.40200*255.0/224.0) * cr + ONE_HALF;
  795. //    g_add = - FIX(0.34414*255.0/224.0) * cb - FIX(0.71414*255.0/224.0) * cr + 
  796. //            ONE_HALF;
  797. //    b_add = FIX(1.77200*255.0/224.0) * cb + ONE_HALF;
  798. //}
  799. //#define YUV_TO_RGB2_CCIR(r, g, b, y1)
  800. //{
  801. //    y = ((y1) - 16) * FIX(255.0/219.0);
  802. //    r = cm[(y + r_add) >> SCALEBITS];
  803. //    g = cm[(y + g_add) >> SCALEBITS];
  804. //    b = cm[(y + b_add) >> SCALEBITS];
  805. //}
  806. //#define YUV_TO_RGB1(cb1, cr1)
  807. //{
  808. //    cb = (cb1) - 128;
  809. //    cr = (cr1) - 128;
  810. //    r_add = FIX(1.40200) * cr + ONE_HALF;
  811. //    g_add = - FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
  812. //    b_add = FIX(1.77200) * cb + ONE_HALF;
  813. //}
  814. //#define YUV_TO_RGB2(r, g, b, y1)
  815. //{
  816. //    y = (y1) << SCALEBITS;
  817. //    r = cm[(y + r_add) >> SCALEBITS];
  818. //    g = cm[(y + g_add) >> SCALEBITS];
  819. //    b = cm[(y + b_add) >> SCALEBITS];
  820. //}
  821. //#define Y_CCIR_TO_JPEG(y)
  822. // cm[((y) * FIX(255.0/219.0) + (ONE_HALF - 16 * FIX(255.0/219.0))) >> SCALEBITS]
  823. //#define Y_JPEG_TO_CCIR(y)
  824. // (((y) * FIX(219.0/255.0) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
  825. //#define C_CCIR_TO_JPEG(y)
  826. // cm[(((y) - 128) * FIX(127.0/112.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS]
  827. ///* NOTE: the clamp is really necessary! */
  828. //static inline int C_JPEG_TO_CCIR(int y) {
  829. //    y = (((y - 128) * FIX(112.0/127.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS);
  830. //    if (y < 16)
  831. // y = 16;
  832. //    return y;
  833. //}
  834. //#define RGB_TO_Y(r, g, b) 
  835. //((FIX(0.29900) * (r) + FIX(0.58700) * (g) + 
  836. //  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
  837. //#define RGB_TO_U(r1, g1, b1, shift)
  838. //(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         
  839. //     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
  840. //#define RGB_TO_V(r1, g1, b1, shift)
  841. //(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           
  842. //   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
  843. //#define RGB_TO_Y_CCIR(r, g, b) 
  844. //((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + 
  845. //  FIX(0.11400*219.0/255.0) * (b) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
  846. //#define RGB_TO_U_CCIR(r1, g1, b1, shift)
  847. //(((- FIX(0.16874*224.0/255.0) * r1 - FIX(0.33126*224.0/255.0) * g1 +         
  848. //     FIX(0.50000*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
  849. //#define RGB_TO_V_CCIR(r1, g1, b1, shift)
  850. //(((FIX(0.50000*224.0/255.0) * r1 - FIX(0.41869*224.0/255.0) * g1 -           
  851. //   FIX(0.08131*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
  852. //static uint8_t y_ccir_to_jpeg[256];
  853. //static uint8_t y_jpeg_to_ccir[256];
  854. //static uint8_t c_ccir_to_jpeg[256];
  855. //static uint8_t c_jpeg_to_ccir[256];
  856. ///* init various conversion tables */
  857. //static void img_convert_init(void)
  858. //{
  859. //    int i;
  860. //    uint8_t *cm = cropTbl + MAX_NEG_CROP;
  861. //    for(i = 0;i < 256; i++) {
  862. //        y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i);
  863. //        y_jpeg_to_ccir[i] = Y_JPEG_TO_CCIR(i);
  864. //        c_ccir_to_jpeg[i] = C_CCIR_TO_JPEG(i);
  865. //        c_jpeg_to_ccir[i] = C_JPEG_TO_CCIR(i);
  866. //    }
  867. //}
  868. ///* apply to each pixel the given table */
  869. //static void img_apply_table(uint8_t *dst, int dst_wrap, 
  870. //                            const uint8_t *src, int src_wrap,
  871. //                            int width, int height, const uint8_t *table1)
  872. //{
  873. //    int n;
  874. //    const uint8_t *s;
  875. //    uint8_t *d;
  876. //    const uint8_t *table;
  877. //    table = table1;
  878. //    for(;height > 0; height--) {
  879. //        s = src;
  880. //        d = dst;
  881. //        n = width;
  882. //        while (n >= 4) {
  883. //            d[0] = table[s[0]];
  884. //            d[1] = table[s[1]];
  885. //            d[2] = table[s[2]];
  886. //            d[3] = table[s[3]];
  887. //            d += 4;
  888. //            s += 4;
  889. //            n -= 4;
  890. //        }
  891. //        while (n > 0) {
  892. //            d[0] = table[s[0]];
  893. //            d++;
  894. //            s++;
  895. //            n--;
  896. //        }
  897. //        dst += dst_wrap;
  898. //        src += src_wrap;
  899. //    }
  900. //}
  901. ///* XXX: use generic filter ? */
  902. ///* XXX: in most cases, the sampling position is incorrect */
  903. ///* 4x1 -> 1x1 */
  904. //static void shrink41(uint8_t *dst, int dst_wrap, 
  905. //                     const uint8_t *src, int src_wrap,
  906. //                     int width, int height)
  907. //{
  908. //    int w;
  909. //    const uint8_t *s;
  910. //    uint8_t *d;
  911. //    for(;height > 0; height--) {
  912. //        s = src;
  913. //        d = dst;
  914. //        for(w = width;w > 0; w--) {
  915. //            d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2;
  916. //            s += 4;
  917. //            d++;
  918. //        }
  919. //        src += src_wrap;
  920. //        dst += dst_wrap;
  921. //    }
  922. //}
  923. ///* 2x1 -> 1x1 */
  924. //static void shrink21(uint8_t *dst, int dst_wrap, 
  925. //                     const uint8_t *src, int src_wrap,
  926. //                     int width, int height)
  927. //{
  928. //    int w;
  929. //    const uint8_t *s;
  930. //    uint8_t *d;
  931. //    for(;height > 0; height--) {
  932. //        s = src;
  933. //        d = dst;
  934. //        for(w = width;w > 0; w--) {
  935. //            d[0] = (s[0] + s[1]) >> 1;
  936. //            s += 2;
  937. //            d++;
  938. //        }
  939. //        src += src_wrap;
  940. //        dst += dst_wrap;
  941. //    }
  942. //}
  943. ///* 1x2 -> 1x1 */
  944. //static void shrink12(uint8_t *dst, int dst_wrap, 
  945. //                     const uint8_t *src, int src_wrap,
  946. //                     int width, int height)
  947. //{
  948. //    int w;
  949. //    uint8_t *d;
  950. //    const uint8_t *s1, *s2;
  951. //    for(;height > 0; height--) {
  952. //        s1 = src;
  953. //        s2 = s1 + src_wrap;
  954. //        d = dst;
  955. //        for(w = width;w >= 4; w-=4) {
  956. //            d[0] = (s1[0] + s2[0]) >> 1;
  957. //            d[1] = (s1[1] + s2[1]) >> 1;
  958. //            d[2] = (s1[2] + s2[2]) >> 1;
  959. //            d[3] = (s1[3] + s2[3]) >> 1;
  960. //            s1 += 4;
  961. //            s2 += 4;
  962. //            d += 4;
  963. //        }
  964. //        for(;w > 0; w--) {
  965. //            d[0] = (s1[0] + s2[0]) >> 1;
  966. //            s1++;
  967. //            s2++;
  968. //            d++;
  969. //        }
  970. //        src += 2 * src_wrap;
  971. //        dst += dst_wrap;
  972. //    }
  973. //}
  974. ///* 2x2 -> 1x1 */
  975. //static void shrink22(uint8_t *dst, int dst_wrap, 
  976. //                     const uint8_t *src, int src_wrap,
  977. //                     int width, int height)
  978. //{
  979. //    int w;
  980. //    const uint8_t *s1, *s2;
  981. //    uint8_t *d;
  982. //    for(;height > 0; height--) {
  983. //        s1 = src;
  984. //        s2 = s1 + src_wrap;
  985. //        d = dst;
  986. //        for(w = width;w >= 4; w-=4) {
  987. //            d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
  988. //            d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;
  989. //            d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;
  990. //            d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;
  991. //            s1 += 8;
  992. //            s2 += 8;
  993. //            d += 4;
  994. //        }
  995. //        for(;w > 0; w--) {
  996. //            d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
  997. //            s1 += 2;
  998. //            s2 += 2;
  999. //            d++;
  1000. //        }
  1001. //        src += 2 * src_wrap;
  1002. //        dst += dst_wrap;
  1003. //    }
  1004. //}
  1005. ///* 4x4 -> 1x1 */
  1006. //static void shrink44(uint8_t *dst, int dst_wrap, 
  1007. //                     const uint8_t *src, int src_wrap,
  1008. //                     int width, int height)
  1009. //{
  1010. //    int w;
  1011. //    const uint8_t *s1, *s2, *s3, *s4;
  1012. //    uint8_t *d;
  1013. //    for(;height > 0; height--) {
  1014. //        s1 = src;
  1015. //        s2 = s1 + src_wrap;
  1016. //        s3 = s2 + src_wrap;
  1017. //        s4 = s3 + src_wrap;
  1018. //        d = dst;
  1019. //        for(w = width;w > 0; w--) {
  1020. //            d[0] = (s1[0] + s1[1] + s1[2] + s1[3] +
  1021. //                    s2[0] + s2[1] + s2[2] + s2[3] +
  1022. //                    s3[0] + s3[1] + s3[2] + s3[3] +
  1023. //                    s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4;
  1024. //            s1 += 4;
  1025. //            s2 += 4;
  1026. //            s3 += 4;
  1027. //            s4 += 4;
  1028. //            d++;
  1029. //        }
  1030. //        src += 4 * src_wrap;
  1031. //        dst += dst_wrap;
  1032. //    }
  1033. //}
  1034. //static void grow21_line(uint8_t *dst, const uint8_t *src,
  1035. //                        int width)
  1036. //{
  1037. //    int w;
  1038. //    const uint8_t *s1;
  1039. //    uint8_t *d;
  1040. //    s1 = src;
  1041. //    d = dst;
  1042. //    for(w = width;w >= 4; w-=4) {
  1043. //        d[1] = d[0] = s1[0];
  1044. //        d[3] = d[2] = s1[1];
  1045. //        s1 += 2;
  1046. //        d += 4;
  1047. //    }
  1048. //    for(;w >= 2; w -= 2) {
  1049. //        d[1] = d[0] = s1[0];
  1050. //        s1 ++;
  1051. //        d += 2;
  1052. //    }
  1053. //    /* only needed if width is not a multiple of two */
  1054. //    /* XXX: veryfy that */
  1055. //    if (w) {
  1056. //        d[0] = s1[0];
  1057. //    }
  1058. //}
  1059. //static void grow41_line(uint8_t *dst, const uint8_t *src,
  1060. //                        int width)
  1061. //{
  1062. //    int w, v;
  1063. //    const uint8_t *s1;
  1064. //    uint8_t *d;
  1065. //    s1 = src;
  1066. //    d = dst;
  1067. //    for(w = width;w >= 4; w-=4) {
  1068. //        v = s1[0];
  1069. //        d[0] = v;
  1070. //        d[1] = v;
  1071. //        d[2] = v;
  1072. //        d[3] = v;
  1073. //        s1 ++;
  1074. //        d += 4;
  1075. //    }
  1076. //}
  1077. ///* 1x1 -> 2x1 */
  1078. //static void grow21(uint8_t *dst, int dst_wrap,
  1079. //                   const uint8_t *src, int src_wrap,
  1080. //                   int width, int height)
  1081. //{
  1082. //    for(;height > 0; height--) {
  1083. //        grow21_line(dst, src, width);
  1084. //        src += src_wrap;
  1085. //        dst += dst_wrap;
  1086. //    }
  1087. //}
  1088. ///* 1x1 -> 2x2 */
  1089. //static void grow22(uint8_t *dst, int dst_wrap,
  1090. //                   const uint8_t *src, int src_wrap,
  1091. //                   int width, int height)
  1092. //{
  1093. //    for(;height > 0; height--) {
  1094. //        grow21_line(dst, src, width);
  1095. //        if (height%2)
  1096. //            src += src_wrap;
  1097. //        dst += dst_wrap;
  1098. //    }
  1099. //}
  1100. ///* 1x1 -> 4x1 */
  1101. //static void grow41(uint8_t *dst, int dst_wrap,
  1102. //                   const uint8_t *src, int src_wrap,
  1103. //                   int width, int height)
  1104. //{
  1105. //    for(;height > 0; height--) {
  1106. //        grow41_line(dst, src, width);
  1107. //        src += src_wrap;
  1108. //        dst += dst_wrap;
  1109. //    }
  1110. //}
  1111. ///* 1x1 -> 4x4 */
  1112. //static void grow44(uint8_t *dst, int dst_wrap,
  1113. //                   const uint8_t *src, int src_wrap,
  1114. //                   int width, int height)
  1115. //{
  1116. //    for(;height > 0; height--) {
  1117. //        grow41_line(dst, src, width);
  1118. //        if ((height & 3) == 1)
  1119. //            src += src_wrap;
  1120. //        dst += dst_wrap;
  1121. //    }
  1122. //}
  1123. ///* 1x2 -> 2x1 */
  1124. //static void conv411(uint8_t *dst, int dst_wrap, 
  1125. //                    const uint8_t *src, int src_wrap,
  1126. //                    int width, int height)
  1127. //{
  1128. //    int w, c;
  1129. //    const uint8_t *s1, *s2;
  1130. //    uint8_t *d;
  1131. //    width>>=1;
  1132. //    for(;height > 0; height--) {
  1133. //        s1 = src;
  1134. //        s2 = src + src_wrap;
  1135. //        d = dst;
  1136. //        for(w = width;w > 0; w--) {
  1137. //            c = (s1[0] + s2[0]) >> 1;
  1138. //            d[0] = c;
  1139. //            d[1] = c;
  1140. //            s1++;
  1141. //            s2++;
  1142. //            d += 2;
  1143. //        }
  1144. //        src += src_wrap * 2;
  1145. //        dst += dst_wrap;
  1146. //    }
  1147. //}
  1148. ///* XXX: add jpeg quantize code */
  1149. //#define TRANSP_INDEX (6*6*6)
  1150. ///* this is maybe slow, but allows for extensions */
  1151. //static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
  1152. //{
  1153. //    return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));
  1154. //}
  1155. //static void build_rgb_palette(uint8_t *palette, int has_alpha)
  1156. //{
  1157. //    uint32_t *pal;
  1158. //    static const uint8_t pal_value[6] = { 0x00, 0x33, 0x66, 0x99, 0xcc, 0xff };
  1159. //    int i, r, g, b;
  1160. //    pal = (uint32_t *)palette;
  1161. //    i = 0;
  1162. //    for(r = 0; r < 6; r++) {
  1163. //        for(g = 0; g < 6; g++) {
  1164. //            for(b = 0; b < 6; b++) {
  1165. //                pal[i++] = (0xff << 24) | (pal_value[r] << 16) | 
  1166. //                    (pal_value[g] << 8) | pal_value[b];
  1167. //            }
  1168. //        }
  1169. //    }
  1170. //    if (has_alpha)
  1171. //        pal[i++] = 0;
  1172. //    while (i < 256)
  1173. //        pal[i++] = 0xff000000;
  1174. //}
  1175. ///* copy bit n to bits 0 ... n - 1 */
  1176. //static inline unsigned int bitcopy_n(unsigned int a, int n)
  1177. //{
  1178. //    int mask;
  1179. //    mask = (1 << n) - 1;
  1180. //    return (a & (0xff & ~mask)) | ((-((a >> n) & 1)) & mask);
  1181. //}
  1182. ///* rgb555 handling */
  1183. //#define RGB_NAME rgb555
  1184. //#define RGB_IN(r, g, b, s)
  1185. //{
  1186. //    unsigned int v = ((const uint16_t *)(s))[0];
  1187. //    r = bitcopy_n(v >> (10 - 3), 3);
  1188. //    g = bitcopy_n(v >> (5 - 3), 3);
  1189. //    b = bitcopy_n(v << 3, 3);
  1190. //}
  1191. //#define RGBA_IN(r, g, b, a, s)
  1192. //{
  1193. //    unsigned int v = ((const uint16_t *)(s))[0];
  1194. //    r = bitcopy_n(v >> (10 - 3), 3);
  1195. //    g = bitcopy_n(v >> (5 - 3), 3);
  1196. //    b = bitcopy_n(v << 3, 3);
  1197. //    a = (-(v >> 15)) & 0xff;
  1198. //}
  1199. //#define RGBA_OUT(d, r, g, b, a)
  1200. //{
  1201. //    ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3) | 
  1202. //                           ((a << 8) & 0x8000);
  1203. //}
  1204. //#define BPP 2
  1205. //#include "imgconvert_template.h"
  1206. ///* rgb565 handling */
  1207. //#define RGB_NAME rgb565
  1208. //#define RGB_IN(r, g, b, s)
  1209. //{
  1210. //    unsigned int v = ((const uint16_t *)(s))[0];
  1211. //    r = bitcopy_n(v >> (11 - 3), 3);
  1212. //    g = bitcopy_n(v >> (5 - 2), 2);
  1213. //    b = bitcopy_n(v << 3, 3);
  1214. //}
  1215. //#define RGB_OUT(d, r, g, b)
  1216. //{
  1217. //    ((uint16_t *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
  1218. //}
  1219. //#define BPP 2
  1220. //#include "imgconvert_template.h"
  1221. ///* bgr24 handling */
  1222. //#define RGB_NAME bgr24
  1223. //#define RGB_IN(r, g, b, s)
  1224. //{
  1225. //    b = (s)[0];
  1226. //    g = (s)[1];
  1227. //    r = (s)[2];
  1228. //}
  1229. //#define RGB_OUT(d, r, g, b)
  1230. //{
  1231. //    (d)[0] = b;
  1232. //    (d)[1] = g;
  1233. //    (d)[2] = r;
  1234. //}
  1235. //#define BPP 3
  1236. //#include "imgconvert_template.h"
  1237. //#undef RGB_IN
  1238. //#undef RGB_OUT
  1239. //#undef BPP
  1240. ///* rgb24 handling */
  1241. //#define RGB_NAME rgb24
  1242. //#define FMT_RGB24
  1243. //#define RGB_IN(r, g, b, s)
  1244. //{
  1245. //    r = (s)[0];
  1246. //    g = (s)[1];
  1247. //    b = (s)[2];
  1248. //}
  1249. //#define RGB_OUT(d, r, g, b)
  1250. //{
  1251. //    (d)[0] = r;
  1252. //    (d)[1] = g;
  1253. //    (d)[2] = b;
  1254. //}
  1255. //#define BPP 3
  1256. //#include "imgconvert_template.h"
  1257. ///* rgba32 handling */
  1258. //#define RGB_NAME rgba32
  1259. //#define FMT_RGBA32
  1260. //#define RGB_IN(r, g, b, s)
  1261. //{
  1262. //    unsigned int v = ((const uint32_t *)(s))[0];
  1263. //    r = (v >> 16) & 0xff;
  1264. //    g = (v >> 8) & 0xff;
  1265. //    b = v & 0xff;
  1266. //}
  1267. //#define RGBA_IN(r, g, b, a, s)
  1268. //{
  1269. //    unsigned int v = ((const uint32_t *)(s))[0];
  1270. //    a = (v >> 24) & 0xff;
  1271. //    r = (v >> 16) & 0xff;
  1272. //    g = (v >> 8) & 0xff;
  1273. //    b = v & 0xff;
  1274. //}
  1275. //#define RGBA_OUT(d, r, g, b, a)
  1276. //{
  1277. //    ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;
  1278. //}
  1279. //#define BPP 4
  1280. //#include "imgconvert_template.h"
  1281. //static void mono_to_gray(AVPicture *dst, const AVPicture *src,
  1282. //                         int width, int height, int xor_mask)
  1283. //{
  1284. //    const unsigned char *p;
  1285. //    unsigned char *q;
  1286. //    int v, dst_wrap, src_wrap;
  1287. //    int y, w;
  1288. //    p = src->data[0];
  1289. //    src_wrap = src->linesize[0] - ((width + 7) >> 3);
  1290. //    q = dst->data[0];
  1291. //    dst_wrap = dst->linesize[0] - width;
  1292. //    for(y=0;y<height;y++) {
  1293. //        w = width; 
  1294. //        while (w >= 8) {
  1295. //            v = *p++ ^ xor_mask;
  1296. //            q[0] = -(v >> 7);
  1297. //            q[1] = -((v >> 6) & 1);
  1298. //            q[2] = -((v >> 5) & 1);
  1299. //            q[3] = -((v >> 4) & 1);
  1300. //            q[4] = -((v >> 3) & 1);
  1301. //            q[5] = -((v >> 2) & 1);
  1302. //            q[6] = -((v >> 1) & 1);
  1303. //            q[7] = -((v >> 0) & 1);
  1304. //            w -= 8;
  1305. //            q += 8;
  1306. //        }
  1307. //        if (w > 0) {
  1308. //            v = *p++ ^ xor_mask;
  1309. //            do {
  1310. //                q[0] = -((v >> 7) & 1);
  1311. //                q++;
  1312. //                v <<= 1;
  1313. //            } while (--w);
  1314. //        }
  1315. //        p += src_wrap;
  1316. //        q += dst_wrap;
  1317. //    }
  1318. //}
  1319. //static void monowhite_to_gray(AVPicture *dst, const AVPicture *src,
  1320. //                               int width, int height)
  1321. //{
  1322. //    mono_to_gray(dst, src, width, height, 0xff);
  1323. //}
  1324. //static void monoblack_to_gray(AVPicture *dst, const AVPicture *src,
  1325. //                               int width, int height)
  1326. //{
  1327. //    mono_to_gray(dst, src, width, height, 0x00);
  1328. //}
  1329. //static void gray_to_mono(AVPicture *dst, const AVPicture *src,
  1330. //                         int width, int height, int xor_mask)
  1331. //{
  1332. //    int n;
  1333. //    const uint8_t *s;
  1334. //    uint8_t *d;
  1335. //    int j, b, v, n1, src_wrap, dst_wrap, y;
  1336. //    s = src->data[0];
  1337. //    src_wrap = src->linesize[0] - width;
  1338. //    d = dst->data[0];
  1339. //    dst_wrap = dst->linesize[0] - ((width + 7) >> 3);
  1340. //    for(y=0;y<height;y++) {
  1341. //        n = width;
  1342. //        while (n >= 8) {
  1343. //            v = 0;
  1344. //            for(j=0;j<8;j++) {
  1345. //                b = s[0];
  1346. //                s++;
  1347. //                v = (v << 1) | (b >> 7);
  1348. //            }
  1349. //            d[0] = v ^ xor_mask;
  1350. //            d++;
  1351. //            n -= 8;
  1352. //        }
  1353. //        if (n > 0) {
  1354. //            n1 = n;
  1355. //            v = 0;
  1356. //            while (n > 0) {
  1357. //                b = s[0];
  1358. //                s++;
  1359. //                v = (v << 1) | (b >> 7);
  1360. //                n--;
  1361. //            }
  1362. //            d[0] = (v << (8 - (n1 & 7))) ^ xor_mask;
  1363. //            d++;
  1364. //        }
  1365. //        s += src_wrap;
  1366. //        d += dst_wrap;
  1367. //    }
  1368. //}
  1369. //static void gray_to_monowhite(AVPicture *dst, const AVPicture *src,
  1370. //                              int width, int height)
  1371. //{
  1372. //    gray_to_mono(dst, src, width, height, 0xff);
  1373. //}
  1374. //static void gray_to_monoblack(AVPicture *dst, const AVPicture *src,
  1375. //                              int width, int height)
  1376. //{
  1377. //    gray_to_mono(dst, src, width, height, 0x00);
  1378. //}
  1379. //typedef struct ConvertEntry {
  1380. //    void (*convert)(AVPicture *dst,
  1381. //     const AVPicture *src, int width, int height);
  1382. //} ConvertEntry;
  1383. ///* Add each new convertion function in this table. In order to be able
  1384. //   to convert from any format to any format, the following constraints
  1385. //   must be satisfied:
  1386. //   - all FF_COLOR_RGB formats must convert to and from PIX_FMT_RGB24 
  1387. //   - all FF_COLOR_GRAY formats must convert to and from PIX_FMT_GRAY8
  1388. //   - all FF_COLOR_RGB formats with alpha must convert to and from PIX_FMT_RGBA32
  1389. //   - PIX_FMT_YUV444P and PIX_FMT_YUVJ444P must convert to and from
  1390. //     PIX_FMT_RGB24.
  1391. //   - PIX_FMT_422 must convert to and from PIX_FMT_422P.
  1392. //   The other conversion functions are just optimisations for common cases.
  1393. //*/
  1394. //static ConvertEntry convert_table[PIX_FMT_NB][PIX_FMT_NB] = {
  1395. //    [PIX_FMT_YUV420P] = {
  1396. //        [PIX_FMT_RGB555] = { 
  1397. //            .convert = yuv420p_to_rgb555
  1398. //        },
  1399. //        [PIX_FMT_RGB565] = { 
  1400. //            .convert = yuv420p_to_rgb565
  1401. //        },
  1402. //        [PIX_FMT_BGR24] = { 
  1403. //            .convert = yuv420p_to_bgr24
  1404. //        },
  1405. //        [PIX_FMT_RGB24] = { 
  1406. //            .convert = yuv420p_to_rgb24
  1407. //        },
  1408. //        [PIX_FMT_RGBA32] = { 
  1409. //            .convert = yuv420p_to_rgba32
  1410. //        },
  1411. //    },
  1412. //    [PIX_FMT_YUV422P] = { 
  1413. //        [PIX_FMT_YUV422] = { 
  1414. //            .convert = yuv422p_to_yuv422,
  1415. //        },
  1416. //    },
  1417. //    [PIX_FMT_YUV444P] = { 
  1418. //        [PIX_FMT_RGB24] = { 
  1419. //            .convert = yuv444p_to_rgb24
  1420. //        },
  1421. //    },
  1422. //    [PIX_FMT_YUVJ420P] = {
  1423. //        [PIX_FMT_RGB555] = { 
  1424. //            .convert = yuvj420p_to_rgb555
  1425. //        },
  1426. //        [PIX_FMT_RGB565] = { 
  1427. //            .convert = yuvj420p_to_rgb565
  1428. //        },
  1429. //        [PIX_FMT_BGR24] = { 
  1430. //            .convert = yuvj420p_to_bgr24
  1431. //        },
  1432. //        [PIX_FMT_RGB24] = { 
  1433. //            .convert = yuvj420p_to_rgb24
  1434. //        },
  1435. //        [PIX_FMT_RGBA32] = { 
  1436. //            .convert = yuvj420p_to_rgba32
  1437. //        },
  1438. //    },
  1439. //    [PIX_FMT_YUVJ444P] = { 
  1440. //        [PIX_FMT_RGB24] = { 
  1441. //            .convert = yuvj444p_to_rgb24
  1442. //        },
  1443. //    },
  1444. //    [PIX_FMT_YUV422] = { 
  1445. //        [PIX_FMT_YUV420P] = { 
  1446. //            .convert = yuv422_to_yuv420p,
  1447. //        },
  1448. //        [PIX_FMT_YUV422P] = { 
  1449. //            .convert = yuv422_to_yuv422p,
  1450. //        },
  1451. //    },
  1452. //    [PIX_FMT_RGB24] = {
  1453. //        [PIX_FMT_YUV420P] = { 
  1454. //            .convert = rgb24_to_yuv420p
  1455. //        },
  1456. //        [PIX_FMT_RGB565] = { 
  1457. //            .convert = rgb24_to_rgb565
  1458. //        },
  1459. //        [PIX_FMT_RGB555] = { 
  1460. //            .convert = rgb24_to_rgb555
  1461. //        },
  1462. //        [PIX_FMT_RGBA32] = { 
  1463. //            .convert = rgb24_to_rgba32
  1464. //        },
  1465. //        [PIX_FMT_BGR24] = { 
  1466. //            .convert = rgb24_to_bgr24
  1467. //        },
  1468. //        [PIX_FMT_GRAY8] = { 
  1469. //            .convert = rgb24_to_gray
  1470. //        },
  1471. //        [PIX_FMT_PAL8] = {
  1472. //            .convert = rgb24_to_pal8
  1473. //        },
  1474. //        [PIX_FMT_YUV444P] = { 
  1475. //            .convert = rgb24_to_yuv444p
  1476. //        },
  1477. //        [PIX_FMT_YUVJ420P] = { 
  1478. //            .convert = rgb24_to_yuvj420p
  1479. //        },
  1480. //        [PIX_FMT_YUVJ444P] = { 
  1481. //            .convert = rgb24_to_yuvj444p
  1482. //        },
  1483. //    },
  1484. //    [PIX_FMT_RGBA32] = {
  1485. //        [PIX_FMT_RGB24] = { 
  1486. //            .convert = rgba32_to_rgb24
  1487. //        },
  1488. //        [PIX_FMT_RGB555] = { 
  1489. //            .convert = rgba32_to_rgb555
  1490. //        },
  1491. //        [PIX_FMT_PAL8] = { 
  1492. //            .convert = rgba32_to_pal8
  1493. //        },
  1494. //        [PIX_FMT_YUV420P] = { 
  1495. //            .convert = rgba32_to_yuv420p
  1496. //        },
  1497. //        [PIX_FMT_GRAY8] = { 
  1498. //            .convert = rgba32_to_gray
  1499. //        },
  1500. //    },
  1501. //    [PIX_FMT_BGR24] = {
  1502. //        [PIX_FMT_RGB24] = { 
  1503. //            .convert = bgr24_to_rgb24
  1504. //        },
  1505. //        [PIX_FMT_YUV420P] = { 
  1506. //            .convert = bgr24_to_yuv420p
  1507. //        },
  1508. //        [PIX_FMT_GRAY8] = { 
  1509. //            .convert = bgr24_to_gray
  1510. //        },
  1511. //    },
  1512. //    [PIX_FMT_RGB555] = {
  1513. //        [PIX_FMT_RGB24] = { 
  1514. //            .convert = rgb555_to_rgb24
  1515. //        },
  1516. //        [PIX_FMT_RGBA32] = { 
  1517. //            .convert = rgb555_to_rgba32
  1518. //        },
  1519. //        [PIX_FMT_YUV420P] = { 
  1520. //            .convert = rgb555_to_yuv420p
  1521. //        },
  1522. //        [PIX_FMT_GRAY8] = { 
  1523. //            .convert = rgb555_to_gray
  1524. //        },
  1525. //    },
  1526. //    [PIX_FMT_RGB565] = {
  1527. //        [PIX_FMT_RGB24] = { 
  1528. //            .convert = rgb565_to_rgb24
  1529. //        },
  1530. //        [PIX_FMT_YUV420P] = { 
  1531. //            .convert = rgb565_to_yuv420p
  1532. //        },
  1533. //        [PIX_FMT_GRAY8] = { 
  1534. //            .convert = rgb565_to_gray
  1535. //        },
  1536. //    },
  1537. //    [PIX_FMT_GRAY8] = {
  1538. //        [PIX_FMT_RGB555] = { 
  1539. //            .convert = gray_to_rgb555
  1540. //        },
  1541. //        [PIX_FMT_RGB565] = { 
  1542. //            .convert = gray_to_rgb565
  1543. //        },
  1544. //        [PIX_FMT_RGB24] = { 
  1545. //            .convert = gray_to_rgb24
  1546. //        },
  1547. //        [PIX_FMT_BGR24] = { 
  1548. //            .convert = gray_to_bgr24
  1549. //        },
  1550. //        [PIX_FMT_RGBA32] = { 
  1551. //            .convert = gray_to_rgba32
  1552. //        },
  1553. //        [PIX_FMT_MONOWHITE] = { 
  1554. //            .convert = gray_to_monowhite
  1555. //        },
  1556. //        [PIX_FMT_MONOBLACK] = { 
  1557. //            .convert = gray_to_monoblack
  1558. //        },
  1559. //    },
  1560. //    [PIX_FMT_MONOWHITE] = {
  1561. //        [PIX_FMT_GRAY8] = { 
  1562. //            .convert = monowhite_to_gray
  1563. //        },
  1564. //    },
  1565. //    [PIX_FMT_MONOBLACK] = {
  1566. //        [PIX_FMT_GRAY8] = { 
  1567. //            .convert = monoblack_to_gray
  1568. //        },
  1569. //    },
  1570. //    [PIX_FMT_PAL8] = {
  1571. //        [PIX_FMT_RGB555] = { 
  1572. //            .convert = pal8_to_rgb555
  1573. //        },
  1574. //        [PIX_FMT_RGB565] = { 
  1575. //            .convert = pal8_to_rgb565
  1576. //        },
  1577. //        [PIX_FMT_BGR24] = { 
  1578. //            .convert = pal8_to_bgr24
  1579. //        },
  1580. //        [PIX_FMT_RGB24] = { 
  1581. //            .convert = pal8_to_rgb24
  1582. //        },
  1583. //        [PIX_FMT_RGBA32] = { 
  1584. //            .convert = pal8_to_rgba32
  1585. //        },
  1586. //    },
  1587. //};
  1588. //int avpicture_alloc(AVPicture *picture,
  1589. //                           int pix_fmt, int width, int height)
  1590. //{
  1591. //    unsigned int size;
  1592. //    void *ptr;
  1593. //    size = avpicture_get_size(pix_fmt, width, height);
  1594. //    ptr = av_malloc(size);
  1595. //    if (!ptr)
  1596. //        goto fail;
  1597. //    avpicture_fill(picture, ptr, pix_fmt, width, height);
  1598. //    return 0;
  1599. // fail:
  1600. //    memset(picture, 0, sizeof(AVPicture));
  1601. //    return -1;
  1602. //}
  1603. //void avpicture_free(AVPicture *picture)
  1604. //{
  1605. //    av_free(picture->data[0]);
  1606. //}
  1607. ///* return true if yuv planar */
  1608. //static inline int is_yuv_planar(PixFmtInfo *ps)
  1609. //{
  1610. //    return (ps->color_type == FF_COLOR_YUV ||
  1611. //            ps->color_type == FF_COLOR_YUV_JPEG) && 
  1612. //        ps->pixel_type == FF_PIXEL_PLANAR;
  1613. //}
  1614. ///* XXX: always use linesize. Return -1 if not supported */
  1615. //int img_convert(AVPicture *dst, int dst_pix_fmt,
  1616. //                const AVPicture *src, int src_pix_fmt, 
  1617. //                int src_width, int src_height)
  1618. //{
  1619. //    static int inited;
  1620. //    int i, ret, dst_width, dst_height, int_pix_fmt;
  1621. //    PixFmtInfo *src_pix, *dst_pix;
  1622. //    ConvertEntry *ce;
  1623. //    AVPicture tmp1, *tmp = &tmp1;
  1624. //    if (src_pix_fmt < 0 || src_pix_fmt >= PIX_FMT_NB ||
  1625. //        dst_pix_fmt < 0 || dst_pix_fmt >= PIX_FMT_NB)
  1626. //        return -1;
  1627. //    if (src_width <= 0 || src_height <= 0)
  1628. //        return 0;
  1629. //    if (!inited) {
  1630. //        inited = 1;
  1631. //        img_convert_init();
  1632. //    }
  1633. //    dst_width = src_width;
  1634. //    dst_height = src_height;
  1635. //    dst_pix = &pix_fmt_info[dst_pix_fmt];
  1636. //    src_pix = &pix_fmt_info[src_pix_fmt];
  1637. //    if (src_pix_fmt == dst_pix_fmt) {
  1638. //        /* no conversion needed: just copy */
  1639. //        img_copy(dst, src, dst_pix_fmt, dst_width, dst_height);
  1640. //        return 0;
  1641. //    }
  1642. //    ce = &convert_table[src_pix_fmt][dst_pix_fmt];
  1643. //    if (ce->convert) {
  1644. //        /* specific convertion routine */
  1645. //        ce->convert(dst, src, dst_width, dst_height);
  1646. //        return 0;
  1647. //    }
  1648. //    /* gray to YUV */
  1649. //    if (is_yuv_planar(dst_pix) &&
  1650. //        src_pix_fmt == PIX_FMT_GRAY8) {
  1651. //        int w, h, y;
  1652. //        uint8_t *d;
  1653. //        if (dst_pix->color_type == FF_COLOR_YUV_JPEG) {
  1654. //            img_copy_plane(dst->data[0], dst->linesize[0],
  1655. //                     src->data[0], src->linesize[0],
  1656. //                     dst_width, dst_height);
  1657. //        } else {
  1658. //            img_apply_table(dst->data[0], dst->linesize[0],
  1659. //                            src->data[0], src->linesize[0],
  1660. //                            dst_width, dst_height,
  1661. //                            y_jpeg_to_ccir);
  1662. //        }
  1663. //        /* fill U and V with 128 */
  1664. //        w = dst_width;
  1665. //        h = dst_height;
  1666. //        w >>= dst_pix->x_chroma_shift;
  1667. //        h >>= dst_pix->y_chroma_shift;
  1668. //        for(i = 1; i <= 2; i++) {
  1669. //            d = dst->data[i];
  1670. //            for(y = 0; y< h; y++) {
  1671. //                memset(d, 128, w);
  1672. //                d += dst->linesize[i];
  1673. //            }
  1674. //        }
  1675. //        return 0;
  1676. //    }
  1677. //    /* YUV to gray */
  1678. //    if (is_yuv_planar(src_pix) && 
  1679. //        dst_pix_fmt == PIX_FMT_GRAY8) {
  1680. //        if (src_pix->color_type == FF_COLOR_YUV_JPEG) {
  1681. //            img_copy_plane(dst->data[0], dst->linesize[0],
  1682. //                     src->data[0], src->linesize[0],
  1683. //                     dst_width, dst_height);
  1684. //        } else {
  1685. //            img_apply_table(dst->data[0], dst->linesize[0],
  1686. //                            src->data[0], src->linesize[0],
  1687. //                            dst_width, dst_height,
  1688. //                            y_ccir_to_jpeg);
  1689. //        }
  1690. //        return 0;
  1691. //    }
  1692. //    /* YUV to YUV planar */
  1693. //    if (is_yuv_planar(dst_pix) && is_yuv_planar(src_pix)) {
  1694. //        int x_shift, y_shift, w, h, xy_shift;
  1695. //        void (*resize_func)(uint8_t *dst, int dst_wrap, 
  1696. //                            const uint8_t *src, int src_wrap,
  1697. //                            int width, int height);
  1698. //        /* compute chroma size of the smallest dimensions */
  1699. //        w = dst_width;
  1700. //        h = dst_height;
  1701. //        if (dst_pix->x_chroma_shift >= src_pix->x_chroma_shift)
  1702. //            w >>= dst_pix->x_chroma_shift;
  1703. //        else
  1704. //            w >>= src_pix->x_chroma_shift;
  1705. //        if (dst_pix->y_chroma_shift >= src_pix->y_chroma_shift)
  1706. //            h >>= dst_pix->y_chroma_shift;
  1707. //        else
  1708. //            h >>= src_pix->y_chroma_shift;
  1709. //        x_shift = (dst_pix->x_chroma_shift - src_pix->x_chroma_shift);
  1710. //        y_shift = (dst_pix->y_chroma_shift - src_pix->y_chroma_shift);
  1711. //        xy_shift = ((x_shift & 0xf) << 4) | (y_shift & 0xf);
  1712. //        /* there must be filters for conversion at least from and to
  1713. //           YUV444 format */
  1714. //        switch(xy_shift) {
  1715. //        case 0x00:
  1716. //            resize_func = img_copy_plane;
  1717. //            break;
  1718. //        case 0x10:
  1719. //            resize_func = shrink21;
  1720. //            break;
  1721. //        case 0x20:
  1722. //            resize_func = shrink41;
  1723. //            break;
  1724. //        case 0x01:
  1725. //            resize_func = shrink12;
  1726. //            break;
  1727. //        case 0x11:
  1728. //            resize_func = shrink22;
  1729. //            break;
  1730. //        case 0x22:
  1731. //            resize_func = shrink44;
  1732. //            break;
  1733. //        case 0xf0:
  1734. //            resize_func = grow21;
  1735. //            break;
  1736. //        case 0xe0:
  1737. //            resize_func = grow41;
  1738. //            break;
  1739. //        case 0xff:
  1740. //            resize_func = grow22;
  1741. //            break;
  1742. //        case 0xee:
  1743. //            resize_func = grow44;
  1744. //            break;
  1745. //        case 0xf1:
  1746. //            resize_func = conv411;
  1747. //            break;
  1748. //        default:
  1749. //            /* currently not handled */
  1750. //            goto no_chroma_filter;
  1751. //        }
  1752. //        img_copy_plane(dst->data[0], dst->linesize[0],
  1753. //                       src->data[0], src->linesize[0],
  1754. //                       dst_width, dst_height);
  1755. //        for(i = 1;i <= 2; i++)
  1756. //            resize_func(dst->data[i], dst->linesize[i],
  1757. //                        src->data[i], src->linesize[i],
  1758. //                        dst_width>>dst_pix->x_chroma_shift, dst_height>>dst_pix->y_chroma_shift);
  1759. //        /* if yuv color space conversion is needed, we do it here on
  1760. //           the destination image */
  1761. //        if (dst_pix->color_type != src_pix->color_type) {
  1762. //            const uint8_t *y_table, *c_table;
  1763. //            if (dst_pix->color_type == FF_COLOR_YUV) {
  1764. //                y_table = y_jpeg_to_ccir;
  1765. //                c_table = c_jpeg_to_ccir;
  1766. //            } else {
  1767. //                y_table = y_ccir_to_jpeg;
  1768. //                c_table = c_ccir_to_jpeg;
  1769. //            }
  1770. //            img_apply_table(dst->data[0], dst->linesize[0],
  1771. //                            dst->data[0], dst->linesize[0],
  1772. //                            dst_width, dst_height,
  1773. //                            y_table);
  1774. //            for(i = 1;i <= 2; i++)
  1775. //                img_apply_table(dst->data[i], dst->linesize[i],
  1776. //                                dst->data[i], dst->linesize[i],
  1777. //                                dst_width>>dst_pix->x_chroma_shift, 
  1778. //                                dst_height>>dst_pix->y_chroma_shift,
  1779. //                                c_table);
  1780. //        }
  1781. //        return 0;
  1782. //    }
  1783. // no_chroma_filter:
  1784. //    /* try to use an intermediate format */
  1785. //    if (src_pix_fmt == PIX_FMT_YUV422 ||
  1786. //        dst_pix_fmt == PIX_FMT_YUV422) {
  1787. //        /* specific case: convert to YUV422P first */
  1788. //        int_pix_fmt = PIX_FMT_YUV422P;
  1789. //    } else if ((src_pix->color_type == FF_COLOR_GRAY &&
  1790. //                src_pix_fmt != PIX_FMT_GRAY8) || 
  1791. //               (dst_pix->color_type == FF_COLOR_GRAY &&
  1792. //                dst_pix_fmt != PIX_FMT_GRAY8)) {
  1793. //        /* gray8 is the normalized format */
  1794. //        int_pix_fmt = PIX_FMT_GRAY8;
  1795. //    } else if ((is_yuv_planar(src_pix) && 
  1796. //                src_pix_fmt != PIX_FMT_YUV444P &&
  1797. //                src_pix_fmt != PIX_FMT_YUVJ444P)) {
  1798. //        /* yuv444 is the normalized format */
  1799. //        if (src_pix->color_type == FF_COLOR_YUV_JPEG)
  1800. //            int_pix_fmt = PIX_FMT_YUVJ444P;
  1801. //        else
  1802. //            int_pix_fmt = PIX_FMT_YUV444P;
  1803. //    } else if ((is_yuv_planar(dst_pix) && 
  1804. //                dst_pix_fmt != PIX_FMT_YUV444P &&
  1805. //                dst_pix_fmt != PIX_FMT_YUVJ444P)) {
  1806. //        /* yuv444 is the normalized format */
  1807. //        if (dst_pix->color_type == FF_COLOR_YUV_JPEG)
  1808. //            int_pix_fmt = PIX_FMT_YUVJ444P;
  1809. //        else
  1810. //            int_pix_fmt = PIX_FMT_YUV444P;
  1811. //    } else {
  1812. //        /* the two formats are rgb or gray8 or yuv[j]444p */
  1813. //        if (src_pix->is_alpha && dst_pix->is_alpha)
  1814. //            int_pix_fmt = PIX_FMT_RGBA32;
  1815. //        else
  1816. //            int_pix_fmt = PIX_FMT_RGB24;
  1817. //    }
  1818. //    if (avpicture_alloc(tmp, int_pix_fmt, dst_width, dst_height) < 0)
  1819. //        return -1;
  1820. //    ret = -1;
  1821. //    if (img_convert(tmp, int_pix_fmt,
  1822. //                    src, src_pix_fmt, src_width, src_height) < 0)
  1823. //        goto fail1;
  1824. //    if (img_convert(dst, dst_pix_fmt,
  1825. //                    tmp, int_pix_fmt, dst_width, dst_height) < 0)
  1826. //        goto fail1;
  1827. //    ret = 0;
  1828. // fail1:
  1829. //    avpicture_free(tmp);
  1830. //    return ret;
  1831. //}
  1832. ///* NOTE: we scan all the pixels to have an exact information */
  1833. //static int get_alpha_info_pal8(const AVPicture *src, int width, int height)
  1834. //{
  1835. //    const unsigned char *p;
  1836. //    int src_wrap, ret, x, y;
  1837. //    unsigned int a;
  1838. //    uint32_t *palette = (uint32_t *)src->data[1];
  1839. //    
  1840. //    p = src->data[0];
  1841. //    src_wrap = src->linesize[0] - width;
  1842. //    ret = 0;
  1843. //    for(y=0;y<height;y++) {
  1844. //        for(x=0;x<width;x++) {
  1845. //            a = palette[p[0]] >> 24;
  1846. //            if (a == 0x00) {
  1847. //                ret |= FF_ALPHA_TRANSP;
  1848. //            } else if (a != 0xff) {
  1849. //                ret |= FF_ALPHA_SEMI_TRANSP;
  1850. //            }
  1851. //            p++;
  1852. //        }
  1853. //        p += src_wrap;
  1854. //    }
  1855. //    return ret;
  1856. //}
  1857. ///**
  1858. // * Tell if an image really has transparent alpha values.
  1859. // * @return ored mask of FF_ALPHA_xxx constants
  1860. // */
  1861. //int img_get_alpha_info(const AVPicture *src,
  1862. //        int pix_fmt, int width, int height)
  1863. //{
  1864. //    PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
  1865. //    int ret;
  1866. //    pf = &pix_fmt_info[pix_fmt];
  1867. //    /* no alpha can be represented in format */
  1868. //    if (!pf->is_alpha)
  1869. //        return 0;
  1870. //    switch(pix_fmt) {
  1871. //    case PIX_FMT_RGBA32:
  1872. //        ret = get_alpha_info_rgba32(src, width, height);
  1873. //        break;
  1874. //    case PIX_FMT_RGB555:
  1875. //        ret = get_alpha_info_rgb555(src, width, height);
  1876. //        break;
  1877. //    case PIX_FMT_PAL8:
  1878. //        ret = get_alpha_info_pal8(src, width, height);
  1879. //        break;
  1880. //    default:
  1881. //        /* we do not know, so everything is indicated */
  1882. //        ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP;
  1883. //        break;
  1884. //    }
  1885. //    return ret;
  1886. //}
  1887. //#ifdef HAVE_MMX
  1888. //#define DEINT_INPLACE_LINE_LUM 
  1889. //                    movd_m2r(lum_m4[0],mm0);
  1890. //                    movd_m2r(lum_m3[0],mm1);
  1891. //                    movd_m2r(lum_m2[0],mm2);
  1892. //                    movd_m2r(lum_m1[0],mm3);
  1893. //                    movd_m2r(lum[0],mm4);
  1894. //                    punpcklbw_r2r(mm7,mm0);
  1895. //                    movd_r2m(mm2,lum_m4[0]);
  1896. //                    punpcklbw_r2r(mm7,mm1);
  1897. //                    punpcklbw_r2r(mm7,mm2);
  1898. //                    punpcklbw_r2r(mm7,mm3);
  1899. //                    punpcklbw_r2r(mm7,mm4);
  1900. //                    paddw_r2r(mm3,mm1);
  1901. //                    psllw_i2r(1,mm2);
  1902. //                    paddw_r2r(mm4,mm0);
  1903. //                    psllw_i2r(2,mm1);
  1904. //                    paddw_r2r(mm6,mm2);
  1905. //                    paddw_r2r(mm2,mm1);
  1906. //                    psubusw_r2r(mm0,mm1);
  1907. //                    psrlw_i2r(3,mm1);
  1908. //                    packuswb_r2r(mm7,mm1);
  1909. //                    movd_r2m(mm1,lum_m2[0]);
  1910. //#define DEINT_LINE_LUM 
  1911. //                    movd_m2r(lum_m4[0],mm0);
  1912. //                    movd_m2r(lum_m3[0],mm1);
  1913. //                    movd_m2r(lum_m2[0],mm2);
  1914. //                    movd_m2r(lum_m1[0],mm3);
  1915. //                    movd_m2r(lum[0],mm4);
  1916. //                    punpcklbw_r2r(mm7,mm0);
  1917. //                    punpcklbw_r2r(mm7,mm1);
  1918. //                    punpcklbw_r2r(mm7,mm2);
  1919. //                    punpcklbw_r2r(mm7,mm3);
  1920. //                    punpcklbw_r2r(mm7,mm4);
  1921. //                    paddw_r2r(mm3,mm1);
  1922. //                    psllw_i2r(1,mm2);
  1923. //                    paddw_r2r(mm4,mm0);
  1924. //                    psllw_i2r(2,mm1);
  1925. //                    paddw_r2r(mm6,mm2);
  1926. //                    paddw_r2r(mm2,mm1);
  1927. //                    psubusw_r2r(mm0,mm1);
  1928. //                    psrlw_i2r(3,mm1);
  1929. //                    packuswb_r2r(mm7,mm1);
  1930. //                    movd_r2m(mm1,dst[0]);
  1931. //#endif
  1932. ///* filter parameters: [-1 4 2 4 -1] // 8 */
  1933. //static void deinterlace_line(uint8_t *dst, 
  1934. //      const uint8_t *lum_m4, const uint8_t *lum_m3, 
  1935. //      const uint8_t *lum_m2, const uint8_t *lum_m1, 
  1936. //      const uint8_t *lum,
  1937. //      int size)
  1938. //{
  1939. //#ifndef HAVE_MMX
  1940. //    uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1941. //    int sum;
  1942. //    for(;size > 0;size--) {
  1943. //        sum = -lum_m4[0];
  1944. //        sum += lum_m3[0] << 2;
  1945. //        sum += lum_m2[0] << 1;
  1946. //        sum += lum_m1[0] << 2;
  1947. //        sum += -lum[0];
  1948. //        dst[0] = cm[(sum + 4) >> 3];
  1949. //        lum_m4++;
  1950. //        lum_m3++;
  1951. //        lum_m2++;
  1952. //        lum_m1++;
  1953. //        lum++;
  1954. //        dst++;
  1955. //    }
  1956. //#else
  1957. //    {
  1958. //        mmx_t rounder;
  1959. //        rounder.uw[0]=4;
  1960. //        rounder.uw[1]=4;
  1961. //        rounder.uw[2]=4;
  1962. //        rounder.uw[3]=4;
  1963. //        pxor_r2r(mm7,mm7);
  1964. //        movq_m2r(rounder,mm6);
  1965. //    }
  1966. //    for (;size > 3; size-=4) {
  1967. //        DEINT_LINE_LUM
  1968. //        lum_m4+=4;
  1969. //        lum_m3+=4;
  1970. //        lum_m2+=4;
  1971. //        lum_m1+=4;
  1972. //        lum+=4;
  1973. //        dst+=4;
  1974. //    }
  1975. //#endif
  1976. //}
  1977. //static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum,
  1978. //                             int size)
  1979. //{
  1980. //#ifndef HAVE_MMX
  1981. //    uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1982. //    int sum;
  1983. //    for(;size > 0;size--) {
  1984. //        sum = -lum_m4[0];
  1985. //        sum += lum_m3[0] << 2;
  1986. //        sum += lum_m2[0] << 1;
  1987. //        lum_m4[0]=lum_m2[0];
  1988. //        sum += lum_m1[0] << 2;
  1989. //        sum += -lum[0];
  1990. //        lum_m2[0] = cm[(sum + 4) >> 3];
  1991. //        lum_m4++;
  1992. //        lum_m3++;
  1993. //        lum_m2++;
  1994. //        lum_m1++;
  1995. //        lum++;
  1996. //    }
  1997. //#else
  1998. //    {
  1999. //        mmx_t rounder;
  2000. //        rounder.uw[0]=4;
  2001. //        rounder.uw[1]=4;
  2002. //        rounder.uw[2]=4;
  2003. //        rounder.uw[3]=4;
  2004. //        pxor_r2r(mm7,mm7);
  2005. //        movq_m2r(rounder,mm6);
  2006. //    }
  2007. //    for (;size > 3; size-=4) {
  2008. //        DEINT_INPLACE_LINE_LUM
  2009. //        lum_m4+=4;
  2010. //        lum_m3+=4;
  2011. //        lum_m2+=4;
  2012. //        lum_m1+=4;
  2013. //        lum+=4;
  2014. //    }
  2015. //#endif
  2016. //}
  2017. ///* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
  2018. //   top field is copied as is, but the bottom field is deinterlaced
  2019. //   against the top field. */
  2020. //static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap,
  2021. //                                    const uint8_t *src1, int src_wrap,
  2022. //                                    int width, int height)
  2023. //{
  2024. //    const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
  2025. //    int y;
  2026. //    src_m2 = src1;
  2027. //    src_m1 = src1;
  2028. //    src_0=&src_m1[src_wrap];
  2029. //    src_p1=&src_0[src_wrap];
  2030. //    src_p2=&src_p1[src_wrap];
  2031. //    for(y=0;y<(height-2);y+=2) {
  2032. //        memcpy(dst,src_m1,width);
  2033. //        dst += dst_wrap;
  2034. //        deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width);
  2035. //        src_m2 = src_0;
  2036. //        src_m1 = src_p1;
  2037. //        src_0 = src_p2;
  2038. //        src_p1 += 2*src_wrap;
  2039. //        src_p2 += 2*src_wrap;
  2040. //        dst += dst_wrap;
  2041. //    }
  2042. //    memcpy(dst,src_m1,width);
  2043. //    dst += dst_wrap;
  2044. //    /* do last line */
  2045. //    deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);
  2046. //}
  2047. //static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap,
  2048. //      int width, int height)
  2049. //{
  2050. //    uint8_t *src_m1, *src_0, *src_p1, *src_p2;
  2051. //    int y;
  2052. //    uint8_t *buf;
  2053. //    buf = (uint8_t*)av_malloc(width);
  2054. //    src_m1 = src1;
  2055. //    memcpy(buf,src_m1,width);
  2056. //    src_0=&src_m1[src_wrap];
  2057. //    src_p1=&src_0[src_wrap];
  2058. //    src_p2=&src_p1[src_wrap];
  2059. //    for(y=0;y<(height-2);y+=2) {
  2060. //        deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width);
  2061. //        src_m1 = src_p1;
  2062. //        src_0 = src_p2;
  2063. //        src_p1 += 2*src_wrap;
  2064. //        src_p2 += 2*src_wrap;
  2065. //    }
  2066. //    /* do last line */
  2067. //    deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width);
  2068. //    av_free(buf);
  2069. //}
  2070. ///* deinterlace - if not supported return -1 */
  2071. //int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
  2072. //                          int pix_fmt, int width, int height)
  2073. //{
  2074. //    int i;
  2075. //    if (pix_fmt != PIX_FMT_YUV420P &&
  2076. //        pix_fmt != PIX_FMT_YUV422P &&
  2077. //        pix_fmt != PIX_FMT_YUV444P &&
  2078. // pix_fmt != PIX_FMT_YUV411P)
  2079. //        return -1;
  2080. //    if ((width & 3) != 0 || (height & 3) != 0)
  2081. //        return -1;
  2082. //    for(i=0;i<3;i++) {
  2083. //        if (i == 1) {
  2084. //            switch(pix_fmt) {
  2085. //            case PIX_FMT_YUV420P:
  2086. //                width >>= 1;
  2087. //                height >>= 1;
  2088. //                break;
  2089. //            case PIX_FMT_YUV422P:
  2090. //                width >>= 1;
  2091. //                break;
  2092. //            case PIX_FMT_YUV411P:
  2093. //                width >>= 2;
  2094. //                break;
  2095. //            default:
  2096. //                break;
  2097. //            }
  2098. //        }
  2099. //        if (src == dst) {
  2100. //            deinterlace_bottom_field_inplace(dst->data[i], dst->linesize[i],
  2101. //                                 width, height);
  2102. //        } else {
  2103. //            deinterlace_bottom_field(dst->data[i],dst->linesize[i],
  2104. //                                        src->data[i], src->linesize[i],
  2105. //                                        width, height);
  2106. //        }
  2107. //    }
  2108. //#ifdef HAVE_MMX
  2109. //    emms();
  2110. //#endif
  2111. //    return 0;
  2112. //}
  2113. //#undef FIX