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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
imgconvert.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：82k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

imgconvert.c：源码内容
  1. /*
  2.  * Misc image conversion routines
  3.  * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  22. /**
  23.  * @file imgconvert.c
  24.  * misc image conversion routines
  25.  */
  27. /* TODO:
  28.  * - write 'ffimg' program to test all the image related stuff
  29.  * - move all api to slice based system
  30.  * - integrate deinterlacing, postprocessing and scaling in the conversion process
  31.  */
  33. #include "avcodec.h"
  34. #include "dsputil.h"
  35. #include "colorspace.h"
  36. #include "define.h"
  37. #include <stdio.h>
  39. #ifdef HAVE_MMX
  40. #include "i386/mmx.h"
  41. #endif
  43. #define xglue(x, y) x ## y
  44. #define glue(x, y) xglue(x, y)
  46. #define FF_COLOR_RGB      0 /**< RGB color space */
  47. #define FF_COLOR_GRAY     1 /**< gray color space */
  48. #define FF_COLOR_YUV      2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
  49. #define FF_COLOR_YUV_JPEG 3 /**< YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
  51. #define FF_PIXEL_PLANAR   0 /**< each channel has one component in AVPicture */
  52. #define FF_PIXEL_PACKED   1 /**< only one components containing all the channels */
  53. #define FF_PIXEL_PALETTE  2  /**< one components containing indexes for a palette */
  55. typedef struct PixFmtInfo {
  56.     const char *name;
  57.     uint8_t nb_channels;     /**< number of channels (including alpha) */
  58.     uint8_t color_type;      /**< color type (see FF_COLOR_xxx constants) */
  59.     uint8_t pixel_type;      /**< pixel storage type (see FF_PIXEL_xxx constants) */
  60.     uint8_t is_alpha : 1;    /**< true if alpha can be specified */
  61.     uint8_t x_chroma_shift;  /**< X chroma subsampling factor is 2 ^ shift */
  62.     uint8_t y_chroma_shift;  /**< Y chroma subsampling factor is 2 ^ shift */
  63.     uint8_t depth;           /**< bit depth of the color components */
  64. } PixFmtInfo;
  66. /* this table gives more information about formats */
  67. static const PixFmtInfo pix_fmt_info[100] ;
  68.     /* YUV formats */
  69. //    [PIX_FMT_YUV420P] = {
  70. //        .name = "yuv420p",
  71. //        .nb_channels = 3,
  72. //        .color_type = FF_COLOR_YUV,
  73. //        .pixel_type = FF_PIXEL_PLANAR,
  74. //        .depth = 8,
  75. //        .x_chroma_shift = 1, .y_chroma_shift = 1,
  76. //    },
  77. //    [PIX_FMT_YUV422P] = {
  78. //        .name = "yuv422p",
  79. //        .nb_channels = 3,
  80. //        .color_type = FF_COLOR_YUV,
  81. //        .pixel_type = FF_PIXEL_PLANAR,
  82. //        .depth = 8,
  83. //        .x_chroma_shift = 1, .y_chroma_shift = 0,
  84. //    },
  85. //    [PIX_FMT_YUV444P] = {
  86. //        .name = "yuv444p",
  87. //        .nb_channels = 3,
  88. //        .color_type = FF_COLOR_YUV,
  89. //        .pixel_type = FF_PIXEL_PLANAR,
  90. //        .depth = 8,
  91. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  92. //    },
  93. //    [PIX_FMT_YUYV422] = {
  94. //        .name = "yuyv422",
  95. //        .nb_channels = 1,
  96. //        .color_type = FF_COLOR_YUV,
  97. //        .pixel_type = FF_PIXEL_PACKED,
  98. //        .depth = 8,
  99. //        .x_chroma_shift = 1, .y_chroma_shift = 0,
  100. //    },
  101. //    [PIX_FMT_UYVY422] = {
  102. //        .name = "uyvy422",
  103. //        .nb_channels = 1,
  104. //        .color_type = FF_COLOR_YUV,
  105. //        .pixel_type = FF_PIXEL_PACKED,
  106. //        .depth = 8,
  107. //        .x_chroma_shift = 1, .y_chroma_shift = 0,
  108. //    },
  109. //    [PIX_FMT_YUV410P] = {
  110. //        .name = "yuv410p",
  111. //        .nb_channels = 3,
  112. //        .color_type = FF_COLOR_YUV,
  113. //        .pixel_type = FF_PIXEL_PLANAR,
  114. //        .depth = 8,
  115. //        .x_chroma_shift = 2, .y_chroma_shift = 2,
  116. //    },
  117. //    [PIX_FMT_YUV411P] = {
  118. //        .name = "yuv411p",
  119. //        .nb_channels = 3,
  120. //        .color_type = FF_COLOR_YUV,
  121. //        .pixel_type = FF_PIXEL_PLANAR,
  122. //        .depth = 8,
  123. //        .x_chroma_shift = 2, .y_chroma_shift = 0,
  124. //    },
  125. //    [PIX_FMT_YUV440P] = {
  126. //        .name = "yuv440p",
  127. //        .nb_channels = 3,
  128. //        .color_type = FF_COLOR_YUV,
  129. //        .pixel_type = FF_PIXEL_PLANAR,
  130. //        .depth = 8,
  131. //        .x_chroma_shift = 0, .y_chroma_shift = 1,
  132. //    },
  133. //
  134. //    /* YUV formats with alpha plane */
  135. //    [PIX_FMT_YUVA420P] = {
  136. //        .name = "yuva420p",
  137. //        .nb_channels = 4,
  138. //        .color_type = FF_COLOR_YUV,
  139. //        .pixel_type = FF_PIXEL_PLANAR,
  140. //        .depth = 8,
  141. //        .x_chroma_shift = 1, .y_chroma_shift = 1,
  142. //    },
  143. //
  144. //    /* JPEG YUV */
  145. //    [PIX_FMT_YUVJ420P] = {
  146. //        .name = "yuvj420p",
  147. //        .nb_channels = 3,
  148. //        .color_type = FF_COLOR_YUV_JPEG,
  149. //        .pixel_type = FF_PIXEL_PLANAR,
  150. //        .depth = 8,
  151. //        .x_chroma_shift = 1, .y_chroma_shift = 1,
  152. //    },
  153. //    [PIX_FMT_YUVJ422P] = {
  154. //        .name = "yuvj422p",
  155. //        .nb_channels = 3,
  156. //        .color_type = FF_COLOR_YUV_JPEG,
  157. //        .pixel_type = FF_PIXEL_PLANAR,
  158. //        .depth = 8,
  159. //        .x_chroma_shift = 1, .y_chroma_shift = 0,
  160. //    },
  161. //    [PIX_FMT_YUVJ444P] = {
  162. //        .name = "yuvj444p",
  163. //        .nb_channels = 3,
  164. //        .color_type = FF_COLOR_YUV_JPEG,
  165. //        .pixel_type = FF_PIXEL_PLANAR,
  166. //        .depth = 8,
  167. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  168. //    },
  169. //    [PIX_FMT_YUVJ440P] = {
  170. //        .name = "yuvj440p",
  171. //        .nb_channels = 3,
  172. //        .color_type = FF_COLOR_YUV_JPEG,
  173. //        .pixel_type = FF_PIXEL_PLANAR,
  174. //        .depth = 8,
  175. //        .x_chroma_shift = 0, .y_chroma_shift = 1,
  176. //    },
  177. //
  178. //    /* RGB formats */
  179. //    [PIX_FMT_RGB24] = {
  180. //        .name = "rgb24",
  181. //        .nb_channels = 3,
  182. //        .color_type = FF_COLOR_RGB,
  183. //        .pixel_type = FF_PIXEL_PACKED,
  184. //        .depth = 8,
  185. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  186. //    },
  187. //    [PIX_FMT_BGR24] = {
  188. //        .name = "bgr24",
  189. //        .nb_channels = 3,
  190. //        .color_type = FF_COLOR_RGB,
  191. //        .pixel_type = FF_PIXEL_PACKED,
  192. //        .depth = 8,
  193. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  194. //    },
  195. //    [PIX_FMT_RGB32] = {
  196. //        .name = "rgb32",
  197. //        .nb_channels = 4, .is_alpha = 1,
  198. //        .color_type = FF_COLOR_RGB,
  199. //        .pixel_type = FF_PIXEL_PACKED,
  200. //        .depth = 8,
  201. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  202. //    },
  203. //    [PIX_FMT_RGB565] = {
  204. //        .name = "rgb565",
  205. //        .nb_channels = 3,
  206. //        .color_type = FF_COLOR_RGB,
  207. //        .pixel_type = FF_PIXEL_PACKED,
  208. //        .depth = 5,
  209. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  210. //    },
  211. //    [PIX_FMT_RGB555] = {
  212. //        .name = "rgb555",
  213. //        .nb_channels = 3,
  214. //        .color_type = FF_COLOR_RGB,
  215. //        .pixel_type = FF_PIXEL_PACKED,
  216. //        .depth = 5,
  217. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  218. //    },
  219. //
  220. //    /* gray / mono formats */
  221. //    [PIX_FMT_GRAY16BE] = {
  222. //        .name = "gray16be",
  223. //        .nb_channels = 1,
  224. //        .color_type = FF_COLOR_GRAY,
  225. //        .pixel_type = FF_PIXEL_PLANAR,
  226. //        .depth = 16,
  227. //    },
  228. //    [PIX_FMT_GRAY16LE] = {
  229. //        .name = "gray16le",
  230. //        .nb_channels = 1,
  231. //        .color_type = FF_COLOR_GRAY,
  232. //        .pixel_type = FF_PIXEL_PLANAR,
  233. //        .depth = 16,
  234. //    },
  235. //    [PIX_FMT_GRAY8] = {
  236. //        .name = "gray",
  237. //        .nb_channels = 1,
  238. //        .color_type = FF_COLOR_GRAY,
  239. //        .pixel_type = FF_PIXEL_PLANAR,
  240. //        .depth = 8,
  241. //    },
  242. //    [PIX_FMT_MONOWHITE] = {
  243. //        .name = "monow",
  244. //        .nb_channels = 1,
  245. //        .color_type = FF_COLOR_GRAY,
  246. //        .pixel_type = FF_PIXEL_PLANAR,
  247. //        .depth = 1,
  248. //    },
  249. //    [PIX_FMT_MONOBLACK] = {
  250. //        .name = "monob",
  251. //        .nb_channels = 1,
  252. //        .color_type = FF_COLOR_GRAY,
  253. //        .pixel_type = FF_PIXEL_PLANAR,
  254. //        .depth = 1,
  255. //    },
  256. //
  257. //    /* paletted formats */
  258. //    [PIX_FMT_PAL8] = {
  259. //        .name = "pal8",
  260. //        .nb_channels = 4, .is_alpha = 1,
  261. //        .color_type = FF_COLOR_RGB,
  262. //        .pixel_type = FF_PIXEL_PALETTE,
  263. //        .depth = 8,
  264. //    },
  265. //    [PIX_FMT_XVMC_MPEG2_MC] = {
  266. //        .name = "xvmcmc",
  267. //    },
  268. //    [PIX_FMT_XVMC_MPEG2_IDCT] = {
  269. //        .name = "xvmcidct",
  270. //    },
  271. //    [PIX_FMT_UYYVYY411] = {
  272. //        .name = "uyyvyy411",
  273. //        .nb_channels = 1,
  274. //        .color_type = FF_COLOR_YUV,
  275. //        .pixel_type = FF_PIXEL_PACKED,
  276. //        .depth = 8,
  277. //        .x_chroma_shift = 2, .y_chroma_shift = 0,
  278. //    },
  279. //    [PIX_FMT_BGR32] = {
  280. //        .name = "bgr32",
  281. //        .nb_channels = 4, .is_alpha = 1,
  282. //        .color_type = FF_COLOR_RGB,
  283. //        .pixel_type = FF_PIXEL_PACKED,
  284. //        .depth = 8,
  285. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  286. //    },
  287. //    [PIX_FMT_BGR565] = {
  288. //        .name = "bgr565",
  289. //        .nb_channels = 3,
  290. //        .color_type = FF_COLOR_RGB,
  291. //        .pixel_type = FF_PIXEL_PACKED,
  292. //        .depth = 5,
  293. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  294. //    },
  295. //    [PIX_FMT_BGR555] = {
  296. //        .name = "bgr555",
  297. //        .nb_channels = 3,
  298. //        .color_type = FF_COLOR_RGB,
  299. //        .pixel_type = FF_PIXEL_PACKED,
  300. //        .depth = 5,
  301. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  302. //    },
  303. //    [PIX_FMT_RGB8] = {
  304. //        .name = "rgb8",
  305. //        .nb_channels = 1,
  306. //        .color_type = FF_COLOR_RGB,
  307. //        .pixel_type = FF_PIXEL_PACKED,
  308. //        .depth = 8,
  309. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  310. //    },
  311. //    [PIX_FMT_RGB4] = {
  312. //        .name = "rgb4",
  313. //        .nb_channels = 1,
  314. //        .color_type = FF_COLOR_RGB,
  315. //        .pixel_type = FF_PIXEL_PACKED,
  316. //        .depth = 4,
  317. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  318. //    },
  319. //    [PIX_FMT_RGB4_BYTE] = {
  320. //        .name = "rgb4_byte",
  321. //        .nb_channels = 1,
  322. //        .color_type = FF_COLOR_RGB,
  323. //        .pixel_type = FF_PIXEL_PACKED,
  324. //        .depth = 8,
  325. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  326. //    },
  327. //    [PIX_FMT_BGR8] = {
  328. //        .name = "bgr8",
  329. //        .nb_channels = 1,
  330. //        .color_type = FF_COLOR_RGB,
  331. //        .pixel_type = FF_PIXEL_PACKED,
  332. //        .depth = 8,
  333. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  334. //    },
  335. //    [PIX_FMT_BGR4] = {
  336. //        .name = "bgr4",
  337. //        .nb_channels = 1,
  338. //        .color_type = FF_COLOR_RGB,
  339. //        .pixel_type = FF_PIXEL_PACKED,
  340. //        .depth = 4,
  341. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  342. //    },
  343. //    [PIX_FMT_BGR4_BYTE] = {
  344. //        .name = "bgr4_byte",
  345. //        .nb_channels = 1,
  346. //        .color_type = FF_COLOR_RGB,
  347. //        .pixel_type = FF_PIXEL_PACKED,
  348. //        .depth = 8,
  349. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  350. //    },
  351. //    [PIX_FMT_NV12] = {
  352. //        .name = "nv12",
  353. //        .nb_channels = 2,
  354. //        .color_type = FF_COLOR_YUV,
  355. //        .pixel_type = FF_PIXEL_PLANAR,
  356. //        .depth = 8,
  357. //        .x_chroma_shift = 1, .y_chroma_shift = 1,
  358. //    },
  359. //    [PIX_FMT_NV21] = {
  360. //        .name = "nv12",
  361. //        .nb_channels = 2,
  362. //        .color_type = FF_COLOR_YUV,
  363. //        .pixel_type = FF_PIXEL_PLANAR,
  364. //        .depth = 8,
  365. //        .x_chroma_shift = 1, .y_chroma_shift = 1,
  366. //    },
  367. //
  368. //    [PIX_FMT_BGR32_1] = {
  369. //        .name = "bgr32_1",
  370. //        .nb_channels = 4, .is_alpha = 1,
  371. //        .color_type = FF_COLOR_RGB,
  372. //        .pixel_type = FF_PIXEL_PACKED,
  373. //        .depth = 8,
  374. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  375. //    },
  376. //    [PIX_FMT_RGB32_1] = {
  377. //        .name = "rgb32_1",
  378. //        .nb_channels = 4, .is_alpha = 1,
  379. //        .color_type = FF_COLOR_RGB,
  380. //        .pixel_type = FF_PIXEL_PACKED,
  381. //        .depth = 8,
  382. //        .x_chroma_shift = 0, .y_chroma_shift = 0,
  383.  //   },
  385. //};
  387. void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift)
  388. {
  389.     *h_shift = pix_fmt_info[pix_fmt].x_chroma_shift;
  390.     *v_shift = pix_fmt_info[pix_fmt].y_chroma_shift;
  391. }
  393. const char *avcodec_get_pix_fmt_name(int pix_fmt)
  394. {
  395.     if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB)
  396.         return "???";
  397.     else
  398.         return pix_fmt_info[pix_fmt].name;
  399. }
  401. enum PixelFormat avcodec_get_pix_fmt(const char* name)
  402. {
  403.     int i;
  405.     for (i=0; i < PIX_FMT_NB; i++)
  406.          if (!strcmp(pix_fmt_info[i].name, name))
  407.              break;
  408.     return i;
  409. }
  411. void avcodec_pix_fmt_string (char *buf, int buf_size, int pix_fmt)
  412. {
  413.     /* print header */
  414.     if (pix_fmt < 0)
  415.         snprintf (buf, buf_size,
  416.                   "name      " " nb_channels" " depth" " is_alpha"
  417.             );
  418.     else{
  419.         PixFmtInfo info= pix_fmt_info[pix_fmt];
  421.         char is_alpha_char= info.is_alpha ? 'y' : 'n';
  423.         snprintf (buf, buf_size,
  424.                   "%-10s" "      %1d     " "   %2d " "     %c   ",
  425.                   info.name,
  426.                   info.nb_channels,
  427.                   info.depth,
  428.                   is_alpha_char
  429.             );
  430.     }
  431. }
  433. int ff_fill_linesize(AVPicture *picture, int pix_fmt, int width)
  434. {
  435.     int w2;
  436.     const PixFmtInfo *pinfo;
  438.     memset(picture->linesize, 0, sizeof(picture->linesize));
  440.     pinfo = &pix_fmt_info[pix_fmt];
  441.     switch(pix_fmt) {
  442.     case PIX_FMT_YUV420P:
  443.     case PIX_FMT_YUV422P:
  444.     case PIX_FMT_YUV444P:
  445.     case PIX_FMT_YUV410P:
  446.     case PIX_FMT_YUV411P:
  447.     case PIX_FMT_YUV440P:
  448.     case PIX_FMT_YUVJ420P:
  449.     case PIX_FMT_YUVJ422P:
  450.     case PIX_FMT_YUVJ444P:
  451.     case PIX_FMT_YUVJ440P:
  452.         w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
  453.         picture->linesize[0] = width;
  454.         picture->linesize[1] = w2;
  455.         picture->linesize[2] = w2;
  456.         break;
  457.     case PIX_FMT_YUVA420P:
  458.         w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
  459.         picture->linesize[0] = width;
  460.         picture->linesize[1] = w2;
  461.         picture->linesize[2] = w2;
  462.         picture->linesize[3] = width;
  463.         break;
  464.     case PIX_FMT_NV12:
  465.     case PIX_FMT_NV21:
  466.         w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
  467.         picture->linesize[0] = width;
  468.         picture->linesize[1] = w2;
  469.         break;
  470.     case PIX_FMT_RGB24:
  471.     case PIX_FMT_BGR24:
  472.         picture->linesize[0] = width * 3;
  473.         break;
  474.     case PIX_FMT_RGB32:
  475.     case PIX_FMT_BGR32:
  476.     case PIX_FMT_RGB32_1:
  477.     case PIX_FMT_BGR32_1:
  478.         picture->linesize[0] = width * 4;
  479.         break;
  480.     case PIX_FMT_GRAY16BE:
  481.     case PIX_FMT_GRAY16LE:
  482.     case PIX_FMT_BGR555:
  483.     case PIX_FMT_BGR565:
  484.     case PIX_FMT_RGB555:
  485.     case PIX_FMT_RGB565:
  486.     case PIX_FMT_YUYV422:
  487.         picture->linesize[0] = width * 2;
  488.         break;
  489.     case PIX_FMT_UYVY422:
  490.         picture->linesize[0] = width * 2;
  491.         break;
  492.     case PIX_FMT_UYYVYY411:
  493.         picture->linesize[0] = width + width/2;
  494.         break;
  495.     case PIX_FMT_RGB8:
  496.     case PIX_FMT_BGR8:
  497.     case PIX_FMT_RGB4_BYTE:
  498.     case PIX_FMT_BGR4_BYTE:
  499.     case PIX_FMT_GRAY8:
  500.         picture->linesize[0] = width;
  501.         break;
  502.     case PIX_FMT_RGB4:
  503.     case PIX_FMT_BGR4:
  504.         picture->linesize[0] = width / 2;
  505.         break;
  506.     case PIX_FMT_MONOWHITE:
  507.     case PIX_FMT_MONOBLACK:
  508.         picture->linesize[0] = (width + 7) >> 3;
  509.         break;
  510.     case PIX_FMT_PAL8:
  511.         picture->linesize[0] = width;
  512.         picture->linesize[1] = 4;
  513.         break;
  514.     default:
  515.         return -1;
  516.     }
  517.     return 0;
  518. }
  520. int ff_fill_pointer(AVPicture *picture, uint8_t *ptr, int pix_fmt,
  521.                     int height)
  522. {
  523.     int size, h2, size2;
  524.     const PixFmtInfo *pinfo;
  526.     pinfo = &pix_fmt_info[pix_fmt];
  527.     size = picture->linesize[0] * height;
  528.     switch(pix_fmt) {
  529.     case PIX_FMT_YUV420P:
  530.     case PIX_FMT_YUV422P:
  531.     case PIX_FMT_YUV444P:
  532.     case PIX_FMT_YUV410P:
  533.     case PIX_FMT_YUV411P:
  534.     case PIX_FMT_YUV440P:
  535.     case PIX_FMT_YUVJ420P:
  536.     case PIX_FMT_YUVJ422P:
  537.     case PIX_FMT_YUVJ444P:
  538.     case PIX_FMT_YUVJ440P:
  539.         h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
  540.         size2 = picture->linesize[1] * h2;
  541.         picture->data[0] = ptr;
  542.         picture->data[1] = picture->data[0] + size;
  543.         picture->data[2] = picture->data[1] + size2;
  544.         picture->data[3] = NULL;
  545.         return size + 2 * size2;
  546.     case PIX_FMT_YUVA420P:
  547.         h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
  548.         size2 = picture->linesize[1] * h2;
  549.         picture->data[0] = ptr;
  550.         picture->data[1] = picture->data[0] + size;
  551.         picture->data[2] = picture->data[1] + size2;
  552.         picture->data[3] = picture->data[1] + size2 + size2;
  553.         return 2 * size + 2 * size2;
  554.     case PIX_FMT_NV12:
  555.     case PIX_FMT_NV21:
  556.         h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
  557.         size2 = picture->linesize[1] * h2 * 2;
  558.         picture->data[0] = ptr;
  559.         picture->data[1] = picture->data[0] + size;
  560.         picture->data[2] = NULL;
  561.         picture->data[3] = NULL;
  562.         return size + 2 * size2;
  563.     case PIX_FMT_RGB24:
  564.     case PIX_FMT_BGR24:
  565.     case PIX_FMT_RGB32:
  566.     case PIX_FMT_BGR32:
  567.     case PIX_FMT_RGB32_1:
  568.     case PIX_FMT_BGR32_1:
  569.     case PIX_FMT_GRAY16BE:
  570.     case PIX_FMT_GRAY16LE:
  571.     case PIX_FMT_BGR555:
  572.     case PIX_FMT_BGR565:
  573.     case PIX_FMT_RGB555:
  574.     case PIX_FMT_RGB565:
  575.     case PIX_FMT_YUYV422:
  576.     case PIX_FMT_UYVY422:
  577.     case PIX_FMT_UYYVYY411:
  578.     case PIX_FMT_RGB8:
  579.     case PIX_FMT_BGR8:
  580.     case PIX_FMT_RGB4_BYTE:
  581.     case PIX_FMT_BGR4_BYTE:
  582.     case PIX_FMT_GRAY8:
  583.     case PIX_FMT_RGB4:
  584.     case PIX_FMT_BGR4:
  585.     case PIX_FMT_MONOWHITE:
  586.     case PIX_FMT_MONOBLACK:
  587.         picture->data[0] = ptr;
  588.         picture->data[1] = NULL;
  589.         picture->data[2] = NULL;
  590.         picture->data[3] = NULL;
  591.         return size;
  592.     case PIX_FMT_PAL8:
  593.         size2 = (size + 3) & ~3;
  594.         picture->data[0] = ptr;
  595.         picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */
  596.         picture->data[2] = NULL;
  597.         picture->data[3] = NULL;
  598.         return size2 + 256 * 4;
  599.     default:
  600.         picture->data[0] = NULL;
  601.         picture->data[1] = NULL;
  602.         picture->data[2] = NULL;
  603.         picture->data[3] = NULL;
  604.         return -1;
  605.     }
  606. }
  608. int avpicture_fill(AVPicture *picture, uint8_t *ptr,
  609.                    int pix_fmt, int width, int height)
  610. {
  612.     if(avcodec_check_dimensions(NULL, width, height))
  613.         return -1;
  615.     if (ff_fill_linesize(picture, pix_fmt, width))
  616.         return -1;
  618.     return ff_fill_pointer(picture, ptr, pix_fmt, height);
  619. }
  621. int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height,
  622.                      unsigned char *dest, int dest_size)
  623. {
  624.     const PixFmtInfo* pf = &pix_fmt_info[pix_fmt];
  625.     int i, j, w, h, data_planes;
  626.     const unsigned char* s;
  627.     int size = avpicture_get_size(pix_fmt, width, height);
  629.     if (size > dest_size || size < 0)
  630.         return -1;
  632.     if (pf->pixel_type == FF_PIXEL_PACKED || pf->pixel_type == FF_PIXEL_PALETTE) {
  633.         if (pix_fmt == PIX_FMT_YUYV422 ||
  634.             pix_fmt == PIX_FMT_UYVY422 ||
  635.             pix_fmt == PIX_FMT_BGR565 ||
  636.             pix_fmt == PIX_FMT_BGR555 ||
  637.             pix_fmt == PIX_FMT_RGB565 ||
  638.             pix_fmt == PIX_FMT_RGB555)
  639.             w = width * 2;
  640.         else if (pix_fmt == PIX_FMT_UYYVYY411)
  641.           w = width + width/2;
  642.         else if (pix_fmt == PIX_FMT_PAL8)
  643.           w = width;
  644.         else
  645.           w = width * (pf->depth * pf->nb_channels / 8);
  647.         data_planes = 1;
  648.         h = height;
  649.     } else {
  650.         data_planes = pf->nb_channels;
  651.         w = (width*pf->depth + 7)/8;
  652.         h = height;
  653.     }
  655.     for (i=0; i<data_planes; i++) {
  656.          if (i == 1) {
  657.              w = width >> pf->x_chroma_shift;
  658.              h = height >> pf->y_chroma_shift;
  659.          }
  660.          s = src->data[i];
  661.          for(j=0; j<h; j++) {
  662.              memcpy(dest, s, w);
  663.              dest += w;
  664.              s += src->linesize[i];
  665.          }
  666.     }
  668.     if (pf->pixel_type == FF_PIXEL_PALETTE)
  669.         memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4);
  671.     return size;
  672. }
  674. int avpicture_get_size(int pix_fmt, int width, int height)
  675. {
  676.     AVPicture dummy_pict;
  677.     return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);
  678. }
  680. int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt,
  681.                              int has_alpha)
  682. {
  683.     const PixFmtInfo *pf, *ps;
  684.     int loss;
  686.     ps = &pix_fmt_info[src_pix_fmt];
  687.     pf = &pix_fmt_info[dst_pix_fmt];
  689.     /* compute loss */
  690.     loss = 0;
  691.     pf = &pix_fmt_info[dst_pix_fmt];
  692.     if (pf->depth < ps->depth ||
  693.         (dst_pix_fmt == PIX_FMT_RGB555 && src_pix_fmt == PIX_FMT_RGB565))
  694.         loss |= FF_LOSS_DEPTH;
  695.     if (pf->x_chroma_shift > ps->x_chroma_shift ||
  696.         pf->y_chroma_shift > ps->y_chroma_shift)
  697.         loss |= FF_LOSS_RESOLUTION;
  698.     switch(pf->color_type) {
  699.     case FF_COLOR_RGB:
  700.         if (ps->color_type != FF_COLOR_RGB &&
  701.             ps->color_type != FF_COLOR_GRAY)
  702.             loss |= FF_LOSS_COLORSPACE;
  703.         break;
  704.     case FF_COLOR_GRAY:
  705.         if (ps->color_type != FF_COLOR_GRAY)
  706.             loss |= FF_LOSS_COLORSPACE;
  707.         break;
  708.     case FF_COLOR_YUV:
  709.         if (ps->color_type != FF_COLOR_YUV)
  710.             loss |= FF_LOSS_COLORSPACE;
  711.         break;
  712.     case FF_COLOR_YUV_JPEG:
  713.         if (ps->color_type != FF_COLOR_YUV_JPEG &&
  714.             ps->color_type != FF_COLOR_YUV &&
  715.             ps->color_type != FF_COLOR_GRAY)
  716.             loss |= FF_LOSS_COLORSPACE;
  717.         break;
  718.     default:
  719.         /* fail safe test */
  720.         if (ps->color_type != pf->color_type)
  721.             loss |= FF_LOSS_COLORSPACE;
  722.         break;
  723.     }
  724.     if (pf->color_type == FF_COLOR_GRAY &&
  725.         ps->color_type != FF_COLOR_GRAY)
  726.         loss |= FF_LOSS_CHROMA;
  727.     if (!pf->is_alpha && (ps->is_alpha && has_alpha))
  728.         loss |= FF_LOSS_ALPHA;
  729.     if (pf->pixel_type == FF_PIXEL_PALETTE &&
  730.         (ps->pixel_type != FF_PIXEL_PALETTE && ps->color_type != FF_COLOR_GRAY))
  731.         loss |= FF_LOSS_COLORQUANT;
  732.     return loss;
  733. }
  735. static int avg_bits_per_pixel(int pix_fmt)
  736. {
  737.     int bits;
  738.     const PixFmtInfo *pf;
  740.     pf = &pix_fmt_info[pix_fmt];
  741.     switch(pf->pixel_type) {
  742.     case FF_PIXEL_PACKED:
  743.         switch(pix_fmt) {
  744.         case PIX_FMT_YUYV422:
  745.         case PIX_FMT_UYVY422:
  746.         case PIX_FMT_RGB565:
  747.         case PIX_FMT_RGB555:
  748.         case PIX_FMT_BGR565:
  749.         case PIX_FMT_BGR555:
  750.             bits = 16;
  751.             break;
  752.         case PIX_FMT_UYYVYY411:
  753.             bits = 12;
  754.             break;
  755.         default:
  756.             bits = pf->depth * pf->nb_channels;
  757.             break;
  758.         }
  759.         break;
  760.     case FF_PIXEL_PLANAR:
  761.         if (pf->x_chroma_shift == 0 && pf->y_chroma_shift == 0) {
  762.             bits = pf->depth * pf->nb_channels;
  763.         } else {
  764.             bits = pf->depth + ((2 * pf->depth) >>
  765.                                 (pf->x_chroma_shift + pf->y_chroma_shift));
  766.         }
  767.         break;
  768.     case FF_PIXEL_PALETTE:
  769.         bits = 8;
  770.         break;
  771.     default:
  772.         bits = -1;
  773.         break;
  774.     }
  775.     return bits;
  776. }
  778. static int avcodec_find_best_pix_fmt1(int pix_fmt_mask,
  779.                                       int src_pix_fmt,
  780.                                       int has_alpha,
  781.                                       int loss_mask)
  782. {
  783.     int dist, i, loss, min_dist, dst_pix_fmt;
  785.     /* find exact color match with smallest size */
  786.     dst_pix_fmt = -1;
  787.     min_dist = 0x7fffffff;
  788.     for(i = 0;i < PIX_FMT_NB; i++) {
  789.         if (pix_fmt_mask & (1 << i)) {
  790.             loss = avcodec_get_pix_fmt_loss(i, src_pix_fmt, has_alpha) & loss_mask;
  791.             if (loss == 0) {
  792.                 dist = avg_bits_per_pixel(i);
  793.                 if (dist < min_dist) {
  794.                     min_dist = dist;
  795.                     dst_pix_fmt = i;
  796.                 }
  797.             }
  798.         }
  799.     }
  800.     return dst_pix_fmt;
  801. }
  803. int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt,
  804.                               int has_alpha, int *loss_ptr)
  805. {
  806.     int dst_pix_fmt, loss_mask, i;
  807.     static const int loss_mask_order[] = {
  808.         ~0, /* no loss first */
  809.         ~FF_LOSS_ALPHA,
  810.         ~FF_LOSS_RESOLUTION,
  811.         ~(FF_LOSS_COLORSPACE | FF_LOSS_RESOLUTION),
  812.         ~FF_LOSS_COLORQUANT,
  813.         ~FF_LOSS_DEPTH,
  814.         0,
  815.     };
  817.     /* try with successive loss */
  818.     i = 0;
  819.     for(;;) {
  820.         loss_mask = loss_mask_order[i++];
  821.         dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_mask, src_pix_fmt,
  822.                                                  has_alpha, loss_mask);
  823.         if (dst_pix_fmt >= 0)
  824.             goto found;
  825.         if (loss_mask == 0)
  826.             break;
  827.     }
  828.     return -1;
  829.  found:
  830.     if (loss_ptr)
  831.         *loss_ptr = avcodec_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
  832.     return dst_pix_fmt;
  833. }
  835. void ff_img_copy_plane(uint8_t *dst, int dst_wrap,
  836.                            const uint8_t *src, int src_wrap,
  837.                            int width, int height)
  838. {
  839.     if((!dst) || (!src))
  840.         return;
  841.     for(;height > 0; height--) {
  842.         memcpy(dst, src, width);
  843.         dst += dst_wrap;
  844.         src += src_wrap;
  845.     }
  846. }
  848. int ff_get_plane_bytewidth(enum PixelFormat pix_fmt, int width, int plane)
  849. {
  850.     int bits;
  851.     const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
  853.     pf = &pix_fmt_info[pix_fmt];
  854.     switch(pf->pixel_type) {
  855.     case FF_PIXEL_PACKED:
  856.         switch(pix_fmt) {
  857.         case PIX_FMT_YUYV422:
  858.         case PIX_FMT_UYVY422:
  859.         case PIX_FMT_RGB565:
  860.         case PIX_FMT_RGB555:
  861.         case PIX_FMT_BGR565:
  862.         case PIX_FMT_BGR555:
  863.             bits = 16;
  864.             break;
  865.         case PIX_FMT_UYYVYY411:
  866.             bits = 12;
  867.             break;
  868.         default:
  869.             bits = pf->depth * pf->nb_channels;
  870.             break;
  871.         }
  872.         return (width * bits + 7) >> 3;
  873.         break;
  874.     case FF_PIXEL_PLANAR:
  875.             if (plane == 1 || plane == 2)
  876.                 width >>= pf->x_chroma_shift;
  878.             return (width * pf->depth + 7) >> 3;
  879.         break;
  880.     case FF_PIXEL_PALETTE:
  881.         if (plane == 0)
  882.             return width;
  883.         break;
  884.     }
  886.     return -1;
  887. }
  889. void av_picture_copy(AVPicture *dst, const AVPicture *src,
  890.               int pix_fmt, int width, int height)
  891. {
  892.     int i;
  893.     const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
  895.     pf = &pix_fmt_info[pix_fmt];
  896.     switch(pf->pixel_type) {
  897.     case FF_PIXEL_PACKED:
  898.     case FF_PIXEL_PLANAR:
  899.         for(i = 0; i < pf->nb_channels; i++) {
  900.             int w, h;
  901.             int bwidth = ff_get_plane_bytewidth(pix_fmt, width, i);
  902.             w = width;
  903.             h = height;
  904.             if (i == 1 || i == 2) {
  905.                 w >>= pf->x_chroma_shift;
  906.                 h >>= pf->y_chroma_shift;
  907.             }
  908.             ff_img_copy_plane(dst->data[i], dst->linesize[i],
  909.                            src->data[i], src->linesize[i],
  910.                            bwidth, h);
  911.         }
  912.         break;
  913.     case FF_PIXEL_PALETTE:
  914.         ff_img_copy_plane(dst->data[0], dst->linesize[0],
  915.                        src->data[0], src->linesize[0],
  916.                        width, height);
  917.         /* copy the palette */
  918.         ff_img_copy_plane(dst->data[1], dst->linesize[1],
  919.                        src->data[1], src->linesize[1],
  920.                        4, 256);
  921.         break;
  922.     }
  923. }
  925. /* XXX: totally non optimized */
  927. static void yuyv422_to_yuv420p(AVPicture *dst, const AVPicture *src,
  928.                               int width, int height)
  929. {
  930.     const uint8_t *p, *p1;
  931.     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  932.     int w;
  934.     p1 = src->data[0];
  935.     lum1 = dst->data[0];
  936.     cb1 = dst->data[1];
  937.     cr1 = dst->data[2];
  939.     for(;height >= 1; height -= 2) {
  940.         p = p1;
  941.         lum = lum1;
  942.         cb = cb1;
  943.         cr = cr1;
  944.         for(w = width; w >= 2; w -= 2) {
  945.             lum[0] = p[0];
  946.             cb[0] = p[1];
  947.             lum[1] = p[2];
  948.             cr[0] = p[3];
  949.             p += 4;
  950.             lum += 2;
  951.             cb++;
  952.             cr++;
  953.         }
  954.         if (w) {
  955.             lum[0] = p[0];
  956.             cb[0] = p[1];
  957.             cr[0] = p[3];
  958.             cb++;
  959.             cr++;
  960.         }
  961.         p1 += src->linesize[0];
  962.         lum1 += dst->linesize[0];
  963.         if (height>1) {
  964.             p = p1;
  965.             lum = lum1;
  966.             for(w = width; w >= 2; w -= 2) {
  967.                 lum[0] = p[0];
  968.                 lum[1] = p[2];
  969.                 p += 4;
  970.                 lum += 2;
  971.             }
  972.             if (w) {
  973.                 lum[0] = p[0];
  974.             }
  975.             p1 += src->linesize[0];
  976.             lum1 += dst->linesize[0];
  977.         }
  978.         cb1 += dst->linesize[1];
  979.         cr1 += dst->linesize[2];
  980.     }
  981. }
  983. static void uyvy422_to_yuv420p(AVPicture *dst, const AVPicture *src,
  984.                               int width, int height)
  985. {
  986.     const uint8_t *p, *p1;
  987.     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  988.     int w;
  990.     p1 = src->data[0];
  992.     lum1 = dst->data[0];
  993.     cb1 = dst->data[1];
  994.     cr1 = dst->data[2];
  996.     for(;height >= 1; height -= 2) {
  997.         p = p1;
  998.         lum = lum1;
  999.         cb = cb1;
  1000.         cr = cr1;
  1001.         for(w = width; w >= 2; w -= 2) {
  1002.             lum[0] = p[1];
  1003.             cb[0] = p[0];
  1004.             lum[1] = p[3];
  1005.             cr[0] = p[2];
  1006.             p += 4;
  1007.             lum += 2;
  1008.             cb++;
  1009.             cr++;
  1010.         }
  1011.         if (w) {
  1012.             lum[0] = p[1];
  1013.             cb[0] = p[0];
  1014.             cr[0] = p[2];
  1015.             cb++;
  1016.             cr++;
  1017.         }
  1018.         p1 += src->linesize[0];
  1019.         lum1 += dst->linesize[0];
  1020.         if (height>1) {
  1021.             p = p1;
  1022.             lum = lum1;
  1023.             for(w = width; w >= 2; w -= 2) {
  1024.                 lum[0] = p[1];
  1025.                 lum[1] = p[3];
  1026.                 p += 4;
  1027.                 lum += 2;
  1028.             }
  1029.             if (w) {
  1030.                 lum[0] = p[1];
  1031.             }
  1032.             p1 += src->linesize[0];
  1033.             lum1 += dst->linesize[0];
  1034.         }
  1035.         cb1 += dst->linesize[1];
  1036.         cr1 += dst->linesize[2];
  1037.     }
  1038. }
  1041. static void uyvy422_to_yuv422p(AVPicture *dst, const AVPicture *src,
  1042.                               int width, int height)
  1043. {
  1044.     const uint8_t *p, *p1;
  1045.     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  1046.     int w;
  1048.     p1 = src->data[0];
  1049.     lum1 = dst->data[0];
  1050.     cb1 = dst->data[1];
  1051.     cr1 = dst->data[2];
  1052.     for(;height > 0; height--) {
  1053.         p = p1;
  1054.         lum = lum1;
  1055.         cb = cb1;
  1056.         cr = cr1;
  1057.         for(w = width; w >= 2; w -= 2) {
  1058.             lum[0] = p[1];
  1059.             cb[0] = p[0];
  1060.             lum[1] = p[3];
  1061.             cr[0] = p[2];
  1062.             p += 4;
  1063.             lum += 2;
  1064.             cb++;
  1065.             cr++;
  1066.         }
  1067.         p1 += src->linesize[0];
  1068.         lum1 += dst->linesize[0];
  1069.         cb1 += dst->linesize[1];
  1070.         cr1 += dst->linesize[2];
  1071.     }
  1072. }
  1075. static void yuyv422_to_yuv422p(AVPicture *dst, const AVPicture *src,
  1076.                               int width, int height)
  1077. {
  1078.     const uint8_t *p, *p1;
  1079.     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  1080.     int w;
  1082.     p1 = src->data[0];
  1083.     lum1 = dst->data[0];
  1084.     cb1 = dst->data[1];
  1085.     cr1 = dst->data[2];
  1086.     for(;height > 0; height--) {
  1087.         p = p1;
  1088.         lum = lum1;
  1089.         cb = cb1;
  1090.         cr = cr1;
  1091.         for(w = width; w >= 2; w -= 2) {
  1092.             lum[0] = p[0];
  1093.             cb[0] = p[1];
  1094.             lum[1] = p[2];
  1095.             cr[0] = p[3];
  1096.             p += 4;
  1097.             lum += 2;
  1098.             cb++;
  1099.             cr++;
  1100.         }
  1101.         p1 += src->linesize[0];
  1102.         lum1 += dst->linesize[0];
  1103.         cb1 += dst->linesize[1];
  1104.         cr1 += dst->linesize[2];
  1105.     }
  1106. }
  1108. static void yuv422p_to_yuyv422(AVPicture *dst, const AVPicture *src,
  1109.                               int width, int height)
  1110. {
  1111.     uint8_t *p, *p1;
  1112.     const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  1113.     int w;
  1115.     p1 = dst->data[0];
  1116.     lum1 = src->data[0];
  1117.     cb1 = src->data[1];
  1118.     cr1 = src->data[2];
  1119.     for(;height > 0; height--) {
  1120.         p = p1;
  1121.         lum = lum1;
  1122.         cb = cb1;
  1123.         cr = cr1;
  1124.         for(w = width; w >= 2; w -= 2) {
  1125.             p[0] = lum[0];
  1126.             p[1] = cb[0];
  1127.             p[2] = lum[1];
  1128.             p[3] = cr[0];
  1129.             p += 4;
  1130.             lum += 2;
  1131.             cb++;
  1132.             cr++;
  1133.         }
  1134.         p1 += dst->linesize[0];
  1135.         lum1 += src->linesize[0];
  1136.         cb1 += src->linesize[1];
  1137.         cr1 += src->linesize[2];
  1138.     }
  1139. }
  1141. static void yuv422p_to_uyvy422(AVPicture *dst, const AVPicture *src,
  1142.                               int width, int height)
  1143. {
  1144.     uint8_t *p, *p1;
  1145.     const uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  1146.     int w;
  1148.     p1 = dst->data[0];
  1149.     lum1 = src->data[0];
  1150.     cb1 = src->data[1];
  1151.     cr1 = src->data[2];
  1152.     for(;height > 0; height--) {
  1153.         p = p1;
  1154.         lum = lum1;
  1155.         cb = cb1;
  1156.         cr = cr1;
  1157.         for(w = width; w >= 2; w -= 2) {
  1158.             p[1] = lum[0];
  1159.             p[0] = cb[0];
  1160.             p[3] = lum[1];
  1161.             p[2] = cr[0];
  1162.             p += 4;
  1163.             lum += 2;
  1164.             cb++;
  1165.             cr++;
  1166.         }
  1167.         p1 += dst->linesize[0];
  1168.         lum1 += src->linesize[0];
  1169.         cb1 += src->linesize[1];
  1170.         cr1 += src->linesize[2];
  1171.     }
  1172. }
  1174. static void uyyvyy411_to_yuv411p(AVPicture *dst, const AVPicture *src,
  1175.                               int width, int height)
  1176. {
  1177.     const uint8_t *p, *p1;
  1178.     uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1;
  1179.     int w;
  1181.     p1 = src->data[0];
  1182.     lum1 = dst->data[0];
  1183.     cb1 = dst->data[1];
  1184.     cr1 = dst->data[2];
  1185.     for(;height > 0; height--) {
  1186.         p = p1;
  1187.         lum = lum1;
  1188.         cb = cb1;
  1189.         cr = cr1;
  1190.         for(w = width; w >= 4; w -= 4) {
  1191.             cb[0] = p[0];
  1192.             lum[0] = p[1];
  1193.             lum[1] = p[2];
  1194.             cr[0] = p[3];
  1195.             lum[2] = p[4];
  1196.             lum[3] = p[5];
  1197.             p += 6;
  1198.             lum += 4;
  1199.             cb++;
  1200.             cr++;
  1201.         }
  1202.         p1 += src->linesize[0];
  1203.         lum1 += dst->linesize[0];
  1204.         cb1 += dst->linesize[1];
  1205.         cr1 += dst->linesize[2];
  1206.     }
  1207. }
  1210. static void yuv420p_to_yuyv422(AVPicture *dst, const AVPicture *src,
  1211.                               int width, int height)
  1212. {
  1213.     int w, h;
  1214.     uint8_t *line1, *line2, *linesrc = dst->data[0];
  1215.     uint8_t *lum1, *lum2, *lumsrc = src->data[0];
  1216.     uint8_t *cb1, *cb2 = src->data[1];
  1217.     uint8_t *cr1, *cr2 = src->data[2];
  1219.     for(h = height / 2; h--;) {
  1220.         line1 = linesrc;
  1221.         line2 = linesrc + dst->linesize[0];
  1223.         lum1 = lumsrc;
  1224.         lum2 = lumsrc + src->linesize[0];
  1226.         cb1 = cb2;
  1227.         cr1 = cr2;
  1229.         for(w = width / 2; w--;) {
  1230.                 *line1++ = *lum1++; *line2++ = *lum2++;
  1231.                 *line1++ =          *line2++ = *cb1++;
  1232.                 *line1++ = *lum1++; *line2++ = *lum2++;
  1233.                 *line1++ =          *line2++ = *cr1++;
  1234.         }
  1236.         linesrc += dst->linesize[0] * 2;
  1237.         lumsrc += src->linesize[0] * 2;
  1238.         cb2 += src->linesize[1];
  1239.         cr2 += src->linesize[2];
  1240.     }
  1241. }
  1243. static void yuv420p_to_uyvy422(AVPicture *dst, const AVPicture *src,
  1244.                               int width, int height)
  1245. {
  1246.     int w, h;
  1247.     uint8_t *line1, *line2, *linesrc = dst->data[0];
  1248.     uint8_t *lum1, *lum2, *lumsrc = src->data[0];
  1249.     uint8_t *cb1, *cb2 = src->data[1];
  1250.     uint8_t *cr1, *cr2 = src->data[2];
  1252.     for(h = height / 2; h--;) {
  1253.         line1 = linesrc;
  1254.         line2 = linesrc + dst->linesize[0];
  1256.         lum1 = lumsrc;
  1257.         lum2 = lumsrc + src->linesize[0];
  1259.         cb1 = cb2;
  1260.         cr1 = cr2;
  1262.         for(w = width / 2; w--;) {
  1263.                 *line1++ =          *line2++ = *cb1++;
  1264.                 *line1++ = *lum1++; *line2++ = *lum2++;
  1265.                 *line1++ =          *line2++ = *cr1++;
  1266.                 *line1++ = *lum1++; *line2++ = *lum2++;
  1267.         }
  1269.         linesrc += dst->linesize[0] * 2;
  1270.         lumsrc += src->linesize[0] * 2;
  1271.         cb2 += src->linesize[1];
  1272.         cr2 += src->linesize[2];
  1273.     }
  1274. }
  1276. /* 2x2 -> 1x1 */
  1277. void ff_shrink22(uint8_t *dst, int dst_wrap,
  1278.                      const uint8_t *src, int src_wrap,
  1279.                      int width, int height)
  1280. {
  1281.     int w;
  1282.     const uint8_t *s1, *s2;
  1283.     uint8_t *d;
  1285.     for(;height > 0; height--) {
  1286.         s1 = src;
  1287.         s2 = s1 + src_wrap;
  1288.         d = dst;
  1289.         for(w = width;w >= 4; w-=4) {
  1290.             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
  1291.             d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;
  1292.             d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;
  1293.             d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;
  1294.             s1 += 8;
  1295.             s2 += 8;
  1296.             d += 4;
  1297.         }
  1298.         for(;w > 0; w--) {
  1299.             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
  1300.             s1 += 2;
  1301.             s2 += 2;
  1302.             d++;
  1303.         }
  1304.         src += 2 * src_wrap;
  1305.         dst += dst_wrap;
  1306.     }
  1307. }
  1309. /* 4x4 -> 1x1 */
  1310. void ff_shrink44(uint8_t *dst, int dst_wrap,
  1311.                      const uint8_t *src, int src_wrap,
  1312.                      int width, int height)
  1313. {
  1314.     int w;
  1315.     const uint8_t *s1, *s2, *s3, *s4;
  1316.     uint8_t *d;
  1318.     for(;height > 0; height--) {
  1319.         s1 = src;
  1320.         s2 = s1 + src_wrap;
  1321.         s3 = s2 + src_wrap;
  1322.         s4 = s3 + src_wrap;
  1323.         d = dst;
  1324.         for(w = width;w > 0; w--) {
  1325.             d[0] = (s1[0] + s1[1] + s1[2] + s1[3] +
  1326.                     s2[0] + s2[1] + s2[2] + s2[3] +
  1327.                     s3[0] + s3[1] + s3[2] + s3[3] +
  1328.                     s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4;
  1329.             s1 += 4;
  1330.             s2 += 4;
  1331.             s3 += 4;
  1332.             s4 += 4;
  1333.             d++;
  1334.         }
  1335.         src += 4 * src_wrap;
  1336.         dst += dst_wrap;
  1337.     }
  1338. }
  1340. /* 8x8 -> 1x1 */
  1341. void ff_shrink88(uint8_t *dst, int dst_wrap,
  1342.                      const uint8_t *src, int src_wrap,
  1343.                      int width, int height)
  1344. {
  1345.     int w, i;
  1347.     for(;height > 0; height--) {
  1348.         for(w = width;w > 0; w--) {
  1349.             int tmp=0;
  1350.             for(i=0; i<8; i++){
  1351.                 tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7];
  1352.                 src += src_wrap;
  1353.             }
  1354.             *(dst++) = (tmp + 32)>>6;
  1355.             src += 8 - 8*src_wrap;
  1356.         }
  1357.         src += 8*src_wrap - 8*width;
  1358.         dst += dst_wrap - width;
  1359.     }
  1360. }
  1362. /* XXX: add jpeg quantize code */
  1364. #define TRANSP_INDEX (6*6*6)
  1366. /* this is maybe slow, but allows for extensions */
  1367. static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
  1368. {
  1369.     return (((r) / 47) % 6) * 6 * 6 + (((g) / 47) % 6) * 6 + (((b) / 47) % 6);
  1370. }
  1372. static void build_rgb_palette(uint8_t *palette, int has_alpha)
  1373. {
  1374.     uint32_t *pal;
  1375.     static const uint8_t pal_value[6] = { 0x00, 0x33, 0x66, 0x99, 0xcc, 0xff };
  1376.     int i, r, g, b;
  1378.     pal = (uint32_t *)palette;
  1379.     i = 0;
  1380.     for(r = 0; r < 6; r++) {
  1381.         for(g = 0; g < 6; g++) {
  1382.             for(b = 0; b < 6; b++) {
  1383.                 pal[i++] = (0xff << 24) | (pal_value[r] << 16) |
  1384.                     (pal_value[g] << 8) | pal_value[b];
  1385.             }
  1386.         }
  1387.     }
  1388.     if (has_alpha)
  1389.         pal[i++] = 0;
  1390.     while (i < 256)
  1391.         pal[i++] = 0xff000000;
  1392. }
  1394. /* copy bit n to bits 0 ... n - 1 */
  1395. static inline unsigned int bitcopy_n(unsigned int a, int n)
  1396. {
  1397.     int mask;
  1398.     mask = (1 << n) - 1;
  1399.     return (a & (0xff & ~mask)) | ((-((a >> n) & 1)) & mask);
  1400. }
  1402. /* rgb555 handling */
  1404. #define RGB_NAME rgb555
  1406. #define RGB_IN(r, g, b, s)
  1407. {
  1408.     unsigned int v = ((const uint16_t *)(s))[0];
  1409.     r = bitcopy_n(v >> (10 - 3), 3);
  1410.     g = bitcopy_n(v >> (5 - 3), 3);
  1411.     b = bitcopy_n(v << 3, 3);
  1412. }
  1415. #define RGB_OUT(d, r, g, b)
  1416. {
  1417.     ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);
  1418. }
  1420. #define BPP 2
  1422. //#include "imgconvert_template.h"
  1424. /* rgb565 handling */
  1426. #define RGB_NAME rgb565
  1428. #define RGB_IN(r, g, b, s)
  1429. {
  1430.     unsigned int v = ((const uint16_t *)(s))[0];
  1431.     r = bitcopy_n(v >> (11 - 3), 3);
  1432.     g = bitcopy_n(v >> (5 - 2), 2);
  1433.     b = bitcopy_n(v << 3, 3);
  1434. }
  1436. #define RGB_OUT(d, r, g, b)
  1437. {
  1438.     ((uint16_t *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
  1439. }
  1441. #define BPP 2
  1443. //#include "imgconvert_template.h"
  1445. /* bgr24 handling */
  1447. #define RGB_NAME bgr24
  1449. #define RGB_IN(r, g, b, s)
  1450. {
  1451.     b = (s)[0];
  1452.     g = (s)[1];
  1453.     r = (s)[2];
  1454. }
  1456. #define RGB_OUT(d, r, g, b)
  1457. {
  1458.     (d)[0] = b;
  1459.     (d)[1] = g;
  1460.     (d)[2] = r;
  1461. }
  1463. #define BPP 3
  1465. //#include "imgconvert_template.h"
  1467. #undef RGB_IN
  1468. #undef RGB_OUT
  1469. #undef BPP
  1471. /* rgb24 handling */
  1473. #define RGB_NAME rgb24
  1474. #define FMT_RGB24
  1476. #define RGB_IN(r, g, b, s)
  1477. {
  1478.     r = (s)[0];
  1479.     g = (s)[1];
  1480.     b = (s)[2];
  1481. }
  1483. #define RGB_OUT(d, r, g, b)
  1484. {
  1485.     (d)[0] = r;
  1486.     (d)[1] = g;
  1487.     (d)[2] = b;
  1488. }
  1490. #define BPP 3
  1492. //#include "imgconvert_template.h"
  1494. /* rgb32 handling */
  1496. #define RGB_NAME rgb32
  1497. #define FMT_RGB32
  1499. #define RGB_IN(r, g, b, s)
  1500. {
  1501.     unsigned int v = ((const uint32_t *)(s))[0];
  1502.     r = (v >> 16) & 0xff;
  1503.     g = (v >> 8) & 0xff;
  1504.     b = v & 0xff;
  1505. }
  1507. #define RGBA_IN(r, g, b, a, s)
  1508. {
  1509.     unsigned int v = ((const uint32_t *)(s))[0];
  1510.     a = (v >> 24) & 0xff;
  1511.     r = (v >> 16) & 0xff;
  1512.     g = (v >> 8) & 0xff;
  1513.     b = v & 0xff;
  1514. }
  1516. #define RGBA_OUT(d, r, g, b, a)
  1517. {
  1518.     ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;
  1519. }
  1521. #define BPP 4
  1523. //#include "imgconvert_template.h"
  1525. static void mono_to_gray(AVPicture *dst, const AVPicture *src,
  1526.                          int width, int height, int xor_mask)
  1527. {
  1528.     const unsigned char *p;
  1529.     unsigned char *q;
  1530.     int v, dst_wrap, src_wrap;
  1531.     int y, w;
  1533.     p = src->data[0];
  1534.     src_wrap = src->linesize[0] - ((width + 7) >> 3);
  1536.     q = dst->data[0];
  1537.     dst_wrap = dst->linesize[0] - width;
  1538.     for(y=0;y<height;y++) {
  1539.         w = width;
  1540.         while (w >= 8) {
  1541.             v = *p++ ^ xor_mask;
  1542.             q[0] = -(v >> 7);
  1543.             q[1] = -((v >> 6) & 1);
  1544.             q[2] = -((v >> 5) & 1);
  1545.             q[3] = -((v >> 4) & 1);
  1546.             q[4] = -((v >> 3) & 1);
  1547.             q[5] = -((v >> 2) & 1);
  1548.             q[6] = -((v >> 1) & 1);
  1549.             q[7] = -((v >> 0) & 1);
  1550.             w -= 8;
  1551.             q += 8;
  1552.         }
  1553.         if (w > 0) {
  1554.             v = *p++ ^ xor_mask;
  1555.             do {
  1556.                 q[0] = -((v >> 7) & 1);
  1557.                 q++;
  1558.                 v <<= 1;
  1559.             } while (--w);
  1560.         }
  1561.         p += src_wrap;
  1562.         q += dst_wrap;
  1563.     }
  1564. }
  1566. static void monowhite_to_gray(AVPicture *dst, const AVPicture *src,
  1567.                                int width, int height)
  1568. {
  1569.     mono_to_gray(dst, src, width, height, 0xff);
  1570. }
  1572. static void monoblack_to_gray(AVPicture *dst, const AVPicture *src,
  1573.                                int width, int height)
  1574. {
  1575.     mono_to_gray(dst, src, width, height, 0x00);
  1576. }
  1578. static void gray_to_mono(AVPicture *dst, const AVPicture *src,
  1579.                          int width, int height, int xor_mask)
  1580. {
  1581.     int n;
  1582.     const uint8_t *s;
  1583.     uint8_t *d;
  1584.     int j, b, v, n1, src_wrap, dst_wrap, y;
  1586.     s = src->data[0];
  1587.     src_wrap = src->linesize[0] - width;
  1589.     d = dst->data[0];
  1590.     dst_wrap = dst->linesize[0] - ((width + 7) >> 3);
  1592.     for(y=0;y<height;y++) {
  1593.         n = width;
  1594.         while (n >= 8) {
  1595.             v = 0;
  1596.             for(j=0;j<8;j++) {
  1597.                 b = s[0];
  1598.                 s++;
  1599.                 v = (v << 1) | (b >> 7);
  1600.             }
  1601.             d[0] = v ^ xor_mask;
  1602.             d++;
  1603.             n -= 8;
  1604.         }
  1605.         if (n > 0) {
  1606.             n1 = n;
  1607.             v = 0;
  1608.             while (n > 0) {
  1609.                 b = s[0];
  1610.                 s++;
  1611.                 v = (v << 1) | (b >> 7);
  1612.                 n--;
  1613.             }
  1614.             d[0] = (v << (8 - (n1 & 7))) ^ xor_mask;
  1615.             d++;
  1616.         }
  1617.         s += src_wrap;
  1618.         d += dst_wrap;
  1619.     }
  1620. }
  1622. static void gray_to_monowhite(AVPicture *dst, const AVPicture *src,
  1623.                               int width, int height)
  1624. {
  1625.     gray_to_mono(dst, src, width, height, 0xff);
  1626. }
  1628. static void gray_to_monoblack(AVPicture *dst, const AVPicture *src,
  1629.                               int width, int height)
  1630. {
  1631.     gray_to_mono(dst, src, width, height, 0x00);
  1632. }
  1634. static void gray_to_gray16(AVPicture *dst, const AVPicture *src,
  1635.                               int width, int height)
  1636. {
  1637.     int x, y, src_wrap, dst_wrap;
  1638.     uint8_t *s, *d;
  1639.     s = src->data[0];
  1640.     src_wrap = src->linesize[0] - width;
  1641.     d = dst->data[0];
  1642.     dst_wrap = dst->linesize[0] - width * 2;
  1643.     for(y=0; y<height; y++){
  1644.         for(x=0; x<width; x++){
  1645.             *d++ = *s;
  1646.             *d++ = *s++;
  1647.         }
  1648.         s += src_wrap;
  1649.         d += dst_wrap;
  1650.     }
  1651. }
  1653. static void gray16_to_gray(AVPicture *dst, const AVPicture *src,
  1654.                               int width, int height)
  1655. {
  1656.     int x, y, src_wrap, dst_wrap;
  1657.     uint8_t *s, *d;
  1658.     s = src->data[0];
  1659.     src_wrap = src->linesize[0] - width * 2;
  1660.     d = dst->data[0];
  1661.     dst_wrap = dst->linesize[0] - width;
  1662.     for(y=0; y<height; y++){
  1663.         for(x=0; x<width; x++){
  1664.             *d++ = *s;
  1665.             s += 2;
  1666.         }
  1667.         s += src_wrap;
  1668.         d += dst_wrap;
  1669.     }
  1670. }
  1672. static void gray16be_to_gray(AVPicture *dst, const AVPicture *src,
  1673.                               int width, int height)
  1674. {
  1675.     gray16_to_gray(dst, src, width, height);
  1676. }
  1678. static void gray16le_to_gray(AVPicture *dst, const AVPicture *src,
  1679.                               int width, int height)
  1680. {
  1681.     AVPicture tmpsrc = *src;
  1682.     tmpsrc.data[0]++;
  1683.     gray16_to_gray(dst, &tmpsrc, width, height);
  1684. }
  1686. static void gray16_to_gray16(AVPicture *dst, const AVPicture *src,
  1687.                               int width, int height)
  1688. {
  1689.     int x, y, src_wrap, dst_wrap;
  1690.     uint16_t *s, *d;
  1691.     s = (uint16_t*)src->data[0];
  1692.     src_wrap = (src->linesize[0] - width * 2)/2;
  1693.     d = (uint16_t*)dst->data[0];
  1694.     dst_wrap = (dst->linesize[0] - width * 2)/2;
  1695.     for(y=0; y<height; y++){
  1696.         for(x=0; x<width; x++){
  1697.             *d++ = bswap_16(*s++);
  1698.         }
  1699.         s += src_wrap;
  1700.         d += dst_wrap;
  1701.     }
  1702. }
  1705. typedef struct ConvertEntry {
  1706.     void (*convert)(AVPicture *dst,
  1707.                     const AVPicture *src, int width, int height);
  1708. } ConvertEntry;
  1710. /* Add each new conversion function in this table. In order to be able
  1711.    to convert from any format to any format, the following constraints
  1712.    must be satisfied:
  1714.    - all FF_COLOR_RGB formats must convert to and from PIX_FMT_RGB24
  1716.    - all FF_COLOR_GRAY formats must convert to and from PIX_FMT_GRAY8
  1718.    - all FF_COLOR_RGB formats with alpha must convert to and from PIX_FMT_RGB32
  1720.    - PIX_FMT_YUV444P and PIX_FMT_YUVJ444P must convert to and from
  1721.      PIX_FMT_RGB24.
  1723.    - PIX_FMT_422 must convert to and from PIX_FMT_422P.
  1725.    The other conversion functions are just optimizations for common cases.
  1726. */
  1727. static const ConvertEntry convert_table[PIX_FMT_NB][PIX_FMT_NB];
  1728. // = {
  1729. //    [PIX_FMT_YUV420P] = {
  1730. //        [PIX_FMT_YUYV422] = {
  1731. //            .convert = yuv420p_to_yuyv422,
  1732. //        },
  1733. //        [PIX_FMT_RGB555] = {
  1734. //            .convert = yuv420p_to_rgb555
  1735. //        },
  1736. //        [PIX_FMT_RGB565] = {
  1737. //            .convert = yuv420p_to_rgb565
  1738. //        },
  1739. //        [PIX_FMT_BGR24] = {
  1740. //            .convert = yuv420p_to_bgr24
  1741. //        },
  1742. //        [PIX_FMT_RGB24] = {
  1743. //            .convert = yuv420p_to_rgb24
  1744. //        },
  1745. //        [PIX_FMT_RGB32] = {
  1746. //            .convert = yuv420p_to_rgb32
  1747. //        },
  1748. //        [PIX_FMT_UYVY422] = {
  1749. //            .convert = yuv420p_to_uyvy422,
  1750. //        },
  1751. //    },
  1752. //    [PIX_FMT_YUV422P] = {
  1753. //        [PIX_FMT_YUYV422] = {
  1754. //            .convert = yuv422p_to_yuyv422,
  1755. //        },
  1756. //        [PIX_FMT_UYVY422] = {
  1757. //            .convert = yuv422p_to_uyvy422,
  1758. //        },
  1759. //    },
  1760. //    [PIX_FMT_YUV444P] = {
  1761. //        [PIX_FMT_RGB24] = {
  1762. //            .convert = yuv444p_to_rgb24
  1763. //        },
  1764. //    },
  1765. //    [PIX_FMT_YUVJ420P] = {
  1766. //        [PIX_FMT_RGB555] = {
  1767. //            .convert = yuvj420p_to_rgb555
  1768. //        },
  1769. //        [PIX_FMT_RGB565] = {
  1770. //            .convert = yuvj420p_to_rgb565
  1771. //        },
  1772. //        [PIX_FMT_BGR24] = {
  1773. //            .convert = yuvj420p_to_bgr24
  1774. //        },
  1775. //        [PIX_FMT_RGB24] = {
  1776. //            .convert = yuvj420p_to_rgb24
  1777. //        },
  1778. //        [PIX_FMT_RGB32] = {
  1779. //            .convert = yuvj420p_to_rgb32
  1780. //        },
  1781. //    },
  1782. //    [PIX_FMT_YUVJ444P] = {
  1783. //        [PIX_FMT_RGB24] = {
  1784. //            .convert = yuvj444p_to_rgb24
  1785. //        },
  1786. //    },
  1787. //    [PIX_FMT_YUYV422] = {
  1788. //        [PIX_FMT_YUV420P] = {
  1789. //            .convert = yuyv422_to_yuv420p,
  1790. //        },
  1791. //        [PIX_FMT_YUV422P] = {
  1792. //            .convert = yuyv422_to_yuv422p,
  1793. //        },
  1794. //    },
  1795. //    [PIX_FMT_UYVY422] = {
  1796. //        [PIX_FMT_YUV420P] = {
  1797. //            .convert = uyvy422_to_yuv420p,
  1798. //        },
  1799. //        [PIX_FMT_YUV422P] = {
  1800. //            .convert = uyvy422_to_yuv422p,
  1801. //        },
  1802. //    },
  1803. //    [PIX_FMT_RGB24] = {
  1804. //        [PIX_FMT_YUV420P] = {
  1805. //            .convert = rgb24_to_yuv420p
  1806. //        },
  1807. //        [PIX_FMT_RGB565] = {
  1808. //            .convert = rgb24_to_rgb565
  1809. //        },
  1810. //        [PIX_FMT_RGB555] = {
  1811. //            .convert = rgb24_to_rgb555
  1812. //        },
  1813. //        [PIX_FMT_RGB32] = {
  1814. //            .convert = rgb24_to_rgb32
  1815. //        },
  1816. //        [PIX_FMT_BGR24] = {
  1817. //            .convert = rgb24_to_bgr24
  1818. //        },
  1819. //        [PIX_FMT_GRAY8] = {
  1820. //            .convert = rgb24_to_gray
  1821. //        },
  1822. //        [PIX_FMT_PAL8] = {
  1823. //            .convert = rgb24_to_pal8
  1824. //        },
  1825. //        [PIX_FMT_YUV444P] = {
  1826. //            .convert = rgb24_to_yuv444p
  1827. //        },
  1828. //        [PIX_FMT_YUVJ420P] = {
  1829. //            .convert = rgb24_to_yuvj420p
  1830. //        },
  1831. //        [PIX_FMT_YUVJ444P] = {
  1832. //            .convert = rgb24_to_yuvj444p
  1833. //        },
  1834. //    },
  1835. //    [PIX_FMT_RGB32] = {
  1836. //        [PIX_FMT_RGB24] = {
  1837. //            .convert = rgb32_to_rgb24
  1838. //        },
  1839. //        [PIX_FMT_BGR24] = {
  1840. //            .convert = rgb32_to_bgr24
  1841. //        },
  1842. //        [PIX_FMT_RGB565] = {
  1843. //            .convert = rgb32_to_rgb565
  1844. //        },
  1845. //        [PIX_FMT_RGB555] = {
  1846. //            .convert = rgb32_to_rgb555
  1847. //        },
  1848. //        [PIX_FMT_PAL8] = {
  1849. //            .convert = rgb32_to_pal8
  1850. //        },
  1851. //        [PIX_FMT_YUV420P] = {
  1852. //            .convert = rgb32_to_yuv420p
  1853. //        },
  1854. //        [PIX_FMT_GRAY8] = {
  1855. //            .convert = rgb32_to_gray
  1856. //        },
  1857. //    },
  1858. //    [PIX_FMT_BGR24] = {
  1859. //        [PIX_FMT_RGB32] = {
  1860. //            .convert = bgr24_to_rgb32
  1861. //        },
  1862. //        [PIX_FMT_RGB24] = {
  1863. //            .convert = bgr24_to_rgb24
  1864. //        },
  1865. //        [PIX_FMT_YUV420P] = {
  1866. //            .convert = bgr24_to_yuv420p
  1867. //        },
  1868. //        [PIX_FMT_GRAY8] = {
  1869. //            .convert = bgr24_to_gray
  1870. //        },
  1871. //    },
  1872. //    [PIX_FMT_RGB555] = {
  1873. //        [PIX_FMT_RGB24] = {
  1874. //            .convert = rgb555_to_rgb24
  1875. //        },
  1876. //        [PIX_FMT_RGB32] = {
  1877. //            .convert = rgb555_to_rgb32
  1878. //        },
  1879. //        [PIX_FMT_YUV420P] = {
  1880. //            .convert = rgb555_to_yuv420p
  1881. //        },
  1882. //        [PIX_FMT_GRAY8] = {
  1883. //            .convert = rgb555_to_gray
  1884. //        },
  1885. //    },
  1886. //    [PIX_FMT_RGB565] = {
  1887. //        [PIX_FMT_RGB32] = {
  1888. //            .convert = rgb565_to_rgb32
  1889. //        },
  1890. //        [PIX_FMT_RGB24] = {
  1891. //            .convert = rgb565_to_rgb24
  1892. //        },
  1893. //        [PIX_FMT_YUV420P] = {
  1894. //            .convert = rgb565_to_yuv420p
  1895. //        },
  1896. //        [PIX_FMT_GRAY8] = {
  1897. //            .convert = rgb565_to_gray
  1898. //        },
  1899. //    },
  1900. //    [PIX_FMT_GRAY16BE] = {
  1901. //        [PIX_FMT_GRAY8] = {
  1902. //            .convert = gray16be_to_gray
  1903. //        },
  1904. //        [PIX_FMT_GRAY16LE] = {
  1905. //            .convert = gray16_to_gray16
  1906. //        },
  1907. //    },
  1908. //    [PIX_FMT_GRAY16LE] = {
  1909. //        [PIX_FMT_GRAY8] = {
  1910. //            .convert = gray16le_to_gray
  1911. //        },
  1912. //        [PIX_FMT_GRAY16BE] = {
  1913. //            .convert = gray16_to_gray16
  1914. //        },
  1915. //    },
  1916. //    [PIX_FMT_GRAY8] = {
  1917. //        [PIX_FMT_RGB555] = {
  1918. //            .convert = gray_to_rgb555
  1919. //        },
  1920. //        [PIX_FMT_RGB565] = {
  1921. //            .convert = gray_to_rgb565
  1922. //        },
  1923. //        [PIX_FMT_RGB24] = {
  1924. //            .convert = gray_to_rgb24
  1925. //        },
  1926. //        [PIX_FMT_BGR24] = {
  1927. //            .convert = gray_to_bgr24
  1928. //        },
  1929. //        [PIX_FMT_RGB32] = {
  1930. //            .convert = gray_to_rgb32
  1931. //        },
  1932. //        [PIX_FMT_MONOWHITE] = {
  1933. //            .convert = gray_to_monowhite
  1934. //        },
  1935. //        [PIX_FMT_MONOBLACK] = {
  1936. //            .convert = gray_to_monoblack
  1937. //        },
  1938. //        [PIX_FMT_GRAY16LE] = {
  1939. //            .convert = gray_to_gray16
  1940. //        },
  1941. //        [PIX_FMT_GRAY16BE] = {
  1942. //            .convert = gray_to_gray16
  1943. //        },
  1944. //    },
  1945. //    [PIX_FMT_MONOWHITE] = {
  1946. //        [PIX_FMT_GRAY8] = {
  1947. //            .convert = monowhite_to_gray
  1948. //        },
  1949. //    },
  1950. //    [PIX_FMT_MONOBLACK] = {
  1951. //        [PIX_FMT_GRAY8] = {
  1952. //            .convert = monoblack_to_gray
  1953. //        },
  1954. //    },
  1955. //    [PIX_FMT_PAL8] = {
  1956. //        [PIX_FMT_RGB555] = {
  1957. //            .convert = pal8_to_rgb555
  1958. //        },
  1959. //        [PIX_FMT_RGB565] = {
  1960. //            .convert = pal8_to_rgb565
  1961. //        },
  1962. //        [PIX_FMT_BGR24] = {
  1963. //            .convert = pal8_to_bgr24
  1964. //        },
  1965. //        [PIX_FMT_RGB24] = {
  1966. //            .convert = pal8_to_rgb24
  1967. //        },
  1968. //        [PIX_FMT_RGB32] = {
  1969. //            .convert = pal8_to_rgb32
  1970. //        },
  1971. //    },
  1972. //    [PIX_FMT_UYYVYY411] = {
  1973. //        [PIX_FMT_YUV411P] = {
  1974. //            .convert = uyyvyy411_to_yuv411p,
  1975. //        },
  1976. //    },
  1977. //
  1978. //};
  1980. int avpicture_alloc(AVPicture *picture,
  1981.                            int pix_fmt, int width, int height)
  1982. {
  1983.     int size;
  1984.     void *ptr;
  1986.     size = avpicture_get_size(pix_fmt, width, height);
  1987.     if(size<0)
  1988.         goto fail;
  1989.     ptr = av_malloc(size);
  1990.     if (!ptr)
  1991.         goto fail;
  1992.     avpicture_fill(picture, ptr, pix_fmt, width, height);
  1993.     return 0;
  1994.  fail:
  1995.     memset(picture, 0, sizeof(AVPicture));
  1996.     return -1;
  1997. }
  1999. void avpicture_free(AVPicture *picture)
  2000. {
  2001.     av_free(picture->data[0]);
  2002. }
  2004. /* return true if yuv planar */
  2005. static inline int is_yuv_planar(const PixFmtInfo *ps)
  2006. {
  2007.     return (ps->color_type == FF_COLOR_YUV ||
  2008.             ps->color_type == FF_COLOR_YUV_JPEG) &&
  2009.         ps->pixel_type == FF_PIXEL_PLANAR;
  2010. }
  2012. int av_picture_crop(AVPicture *dst, const AVPicture *src,
  2013.               int pix_fmt, int top_band, int left_band)
  2014. {
  2015.     int y_shift;
  2016.     int x_shift;
  2018.     if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt]))
  2019.         return -1;
  2021.     y_shift = pix_fmt_info[pix_fmt].y_chroma_shift;
  2022.     x_shift = pix_fmt_info[pix_fmt].x_chroma_shift;
  2024.     dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band;
  2025.     dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift);
  2026.     dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift);
  2028.     dst->linesize[0] = src->linesize[0];
  2029.     dst->linesize[1] = src->linesize[1];
  2030.     dst->linesize[2] = src->linesize[2];
  2031.     return 0;
  2032. }
  2034. int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width,
  2035.             int pix_fmt, int padtop, int padbottom, int padleft, int padright,
  2036.             int *color)
  2037. {
  2038.     uint8_t *optr;
  2039.     int y_shift;
  2040.     int x_shift;
  2041.     int yheight;
  2042.     int i, y;
  2044.     if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB ||
  2045.         !is_yuv_planar(&pix_fmt_info[pix_fmt])) return -1;
  2047.     for (i = 0; i < 3; i++) {
  2048.         x_shift = i ? pix_fmt_info[pix_fmt].x_chroma_shift : 0;
  2049.         y_shift = i ? pix_fmt_info[pix_fmt].y_chroma_shift : 0;
  2051.         if (padtop || padleft) {
  2052.             memset(dst->data[i], color[i],
  2053.                 dst->linesize[i] * (padtop >> y_shift) + (padleft >> x_shift));
  2054.         }
  2056.         if (padleft || padright) {
  2057.             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
  2058.                 (dst->linesize[i] - (padright >> x_shift));
  2059.             yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
  2060.             for (y = 0; y < yheight; y++) {
  2061.                 memset(optr, color[i], (padleft + padright) >> x_shift);
  2062.                 optr += dst->linesize[i];
  2063.             }
  2064.         }
  2066.         if (src) { /* first line */
  2067.             uint8_t *iptr = src->data[i];
  2068.             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
  2069.                     (padleft >> x_shift);
  2070.             memcpy(optr, iptr, (width - padleft - padright) >> x_shift);
  2071.             iptr += src->linesize[i];
  2072.             optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
  2073.                 (dst->linesize[i] - (padright >> x_shift));
  2074.             yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
  2075.             for (y = 0; y < yheight; y++) {
  2076.                 memset(optr, color[i], (padleft + padright) >> x_shift);
  2077.                 memcpy(optr + ((padleft + padright) >> x_shift), iptr,
  2078.                        (width - padleft - padright) >> x_shift);
  2079.                 iptr += src->linesize[i];
  2080.                 optr += dst->linesize[i];
  2081.             }
  2082.         }
  2084.         if (padbottom || padright) {
  2085.             optr = dst->data[i] + dst->linesize[i] *
  2086.                 ((height - padbottom) >> y_shift) - (padright >> x_shift);
  2087.             memset(optr, color[i],dst->linesize[i] *
  2088.                 (padbottom >> y_shift) + (padright >> x_shift));
  2089.         }
  2090.     }
  2091.     return 0;
  2092. }
  2094. #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
  2095. void img_copy(AVPicture *dst, const AVPicture *src,
  2096.               int pix_fmt, int width, int height)
  2097. {
  2098.     av_picture_copy(dst, src, pix_fmt, width, height);
  2099. }
  2101. int img_crop(AVPicture *dst, const AVPicture *src,
  2102.               int pix_fmt, int top_band, int left_band)
  2103. {
  2104.     return av_picture_crop(dst, src, pix_fmt, top_band, left_band);
  2105. }
  2107. int img_pad(AVPicture *dst, const AVPicture *src, int height, int width,
  2108.             int pix_fmt, int padtop, int padbottom, int padleft, int padright,
  2109.             int *color)
  2110. {
  2111.     return av_picture_pad(dst, src, height, width, pix_fmt, padtop, padbottom, padleft, padright, color);
  2112. }
  2113. #endif
  2115. #ifndef CONFIG_SWSCALE
  2116. static uint8_t y_ccir_to_jpeg[256];
  2117. static uint8_t y_jpeg_to_ccir[256];
  2118. static uint8_t c_ccir_to_jpeg[256];
  2119. static uint8_t c_jpeg_to_ccir[256];
  2121. /* init various conversion tables */
  2122. static void img_convert_init(void)
  2123. {
  2124.     int i;
  2125.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  2127.     for(i = 0;i < 256; i++) {
  2128.         y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i);
  2129.         y_jpeg_to_ccir[i] = Y_JPEG_TO_CCIR(i);
  2130.         c_ccir_to_jpeg[i] = C_CCIR_TO_JPEG(i);
  2131.         c_jpeg_to_ccir[i] = C_JPEG_TO_CCIR(i);
  2132.     }
  2133. }
  2135. /* apply to each pixel the given table */
  2136. static void img_apply_table(uint8_t *dst, int dst_wrap,
  2137.                             const uint8_t *src, int src_wrap,
  2138.                             int width, int height, const uint8_t *table1)
  2139. {
  2140.     int n;
  2141.     const uint8_t *s;
  2142.     uint8_t *d;
  2143.     const uint8_t *table;
  2145.     table = table1;
  2146.     for(;height > 0; height--) {
  2147.         s = src;
  2148.         d = dst;
  2149.         n = width;
  2150.         while (n >= 4) {
  2151.             d[0] = table[s[0]];
  2152.             d[1] = table[s[1]];
  2153.             d[2] = table[s[2]];
  2154.             d[3] = table[s[3]];
  2155.             d += 4;
  2156.             s += 4;
  2157.             n -= 4;
  2158.         }
  2159.         while (n > 0) {
  2160.             d[0] = table[s[0]];
  2161.             d++;
  2162.             s++;
  2163.             n--;
  2164.         }
  2165.         dst += dst_wrap;
  2166.         src += src_wrap;
  2167.     }
  2168. }
  2170. /* XXX: use generic filter ? */
  2171. /* XXX: in most cases, the sampling position is incorrect */
  2173. /* 4x1 -> 1x1 */
  2174. static void shrink41(uint8_t *dst, int dst_wrap,
  2175.                      const uint8_t *src, int src_wrap,
  2176.                      int width, int height)
  2177. {
  2178.     int w;
  2179.     const uint8_t *s;
  2180.     uint8_t *d;
  2182.     for(;height > 0; height--) {
  2183.         s = src;
  2184.         d = dst;
  2185.         for(w = width;w > 0; w--) {
  2186.             d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2;
  2187.             s += 4;
  2188.             d++;
  2189.         }
  2190.         src += src_wrap;
  2191.         dst += dst_wrap;
  2192.     }
  2193. }
  2195. /* 2x1 -> 1x1 */
  2196. static void shrink21(uint8_t *dst, int dst_wrap,
  2197.                      const uint8_t *src, int src_wrap,
  2198.                      int width, int height)
  2199. {
  2200.     int w;
  2201.     const uint8_t *s;
  2202.     uint8_t *d;
  2204.     for(;height > 0; height--) {
  2205.         s = src;
  2206.         d = dst;
  2207.         for(w = width;w > 0; w--) {
  2208.             d[0] = (s[0] + s[1]) >> 1;
  2209.             s += 2;
  2210.             d++;
  2211.         }
  2212.         src += src_wrap;
  2213.         dst += dst_wrap;
  2214.     }
  2215. }
  2217. /* 1x2 -> 1x1 */
  2218. static void shrink12(uint8_t *dst, int dst_wrap,
  2219.                      const uint8_t *src, int src_wrap,
  2220.                      int width, int height)
  2221. {
  2222.     int w;
  2223.     uint8_t *d;
  2224.     const uint8_t *s1, *s2;
  2226.     for(;height > 0; height--) {
  2227.         s1 = src;
  2228.         s2 = s1 + src_wrap;
  2229.         d = dst;
  2230.         for(w = width;w >= 4; w-=4) {
  2231.             d[0] = (s1[0] + s2[0]) >> 1;
  2232.             d[1] = (s1[1] + s2[1]) >> 1;
  2233.             d[2] = (s1[2] + s2[2]) >> 1;
  2234.             d[3] = (s1[3] + s2[3]) >> 1;
  2235.             s1 += 4;
  2236.             s2 += 4;
  2237.             d += 4;
  2238.         }
  2239.         for(;w > 0; w--) {
  2240.             d[0] = (s1[0] + s2[0]) >> 1;
  2241.             s1++;
  2242.             s2++;
  2243.             d++;
  2244.         }
  2245.         src += 2 * src_wrap;
  2246.         dst += dst_wrap;
  2247.     }
  2248. }
  2250. static void grow21_line(uint8_t *dst, const uint8_t *src,
  2251.                         int width)
  2252. {
  2253.     int w;
  2254.     const uint8_t *s1;
  2255.     uint8_t *d;
  2257.     s1 = src;
  2258.     d = dst;
  2259.     for(w = width;w >= 4; w-=4) {
  2260.         d[1] = d[0] = s1[0];
  2261.         d[3] = d[2] = s1[1];
  2262.         s1 += 2;
  2263.         d += 4;
  2264.     }
  2265.     for(;w >= 2; w -= 2) {
  2266.         d[1] = d[0] = s1[0];
  2267.         s1 ++;
  2268.         d += 2;
  2269.     }
  2270.     /* only needed if width is not a multiple of two */
  2271.     /* XXX: veryfy that */
  2272.     if (w) {
  2273.         d[0] = s1[0];
  2274.     }
  2275. }
  2277. static void grow41_line(uint8_t *dst, const uint8_t *src,
  2278.                         int width)
  2279. {
  2280.     int w, v;
  2281.     const uint8_t *s1;
  2282.     uint8_t *d;
  2284.     s1 = src;
  2285.     d = dst;
  2286.     for(w = width;w >= 4; w-=4) {
  2287.         v = s1[0];
  2288.         d[0] = v;
  2289.         d[1] = v;
  2290.         d[2] = v;
  2291.         d[3] = v;
  2292.         s1 ++;
  2293.         d += 4;
  2294.     }
  2295. }
  2297. /* 1x1 -> 2x1 */
  2298. static void grow21(uint8_t *dst, int dst_wrap,
  2299.                    const uint8_t *src, int src_wrap,
  2300.                    int width, int height)
  2301. {
  2302.     for(;height > 0; height--) {
  2303.         grow21_line(dst, src, width);
  2304.         src += src_wrap;
  2305.         dst += dst_wrap;
  2306.     }
  2307. }
  2309. /* 1x1 -> 1x2 */
  2310. static void grow12(uint8_t *dst, int dst_wrap,
  2311.                    const uint8_t *src, int src_wrap,
  2312.                    int width, int height)
  2313. {
  2314.     for(;height > 0; height-=2) {
  2315.         memcpy(dst, src, width);
  2316.         dst += dst_wrap;
  2317.         memcpy(dst, src, width);
  2318.         dst += dst_wrap;
  2319.         src += src_wrap;
  2320.     }
  2321. }
  2323. /* 1x1 -> 2x2 */
  2324. static void grow22(uint8_t *dst, int dst_wrap,
  2325.                    const uint8_t *src, int src_wrap,
  2326.                    int width, int height)
  2327. {
  2328.     for(;height > 0; height--) {
  2329.         grow21_line(dst, src, width);
  2330.         if (height%2)
  2331.             src += src_wrap;
  2332.         dst += dst_wrap;
  2333.     }
  2334. }
  2336. /* 1x1 -> 4x1 */
  2337. static void grow41(uint8_t *dst, int dst_wrap,
  2338.                    const uint8_t *src, int src_wrap,
  2339.                    int width, int height)
  2340. {
  2341.     for(;height > 0; height--) {
  2342.         grow41_line(dst, src, width);
  2343.         src += src_wrap;
  2344.         dst += dst_wrap;
  2345.     }
  2346. }
  2348. /* 1x1 -> 4x4 */
  2349. static void grow44(uint8_t *dst, int dst_wrap,
  2350.                    const uint8_t *src, int src_wrap,
  2351.                    int width, int height)
  2352. {
  2353.     for(;height > 0; height--) {
  2354.         grow41_line(dst, src, width);
  2355.         if ((height & 3) == 1)
  2356.             src += src_wrap;
  2357.         dst += dst_wrap;
  2358.     }
  2359. }
  2361. /* 1x2 -> 2x1 */
  2362. static void conv411(uint8_t *dst, int dst_wrap,
  2363.                     const uint8_t *src, int src_wrap,
  2364.                     int width, int height)
  2365. {
  2366.     int w, c;
  2367.     const uint8_t *s1, *s2;
  2368.     uint8_t *d;
  2370.     width>>=1;
  2372.     for(;height > 0; height--) {
  2373.         s1 = src;
  2374.         s2 = src + src_wrap;
  2375.         d = dst;
  2376.         for(w = width;w > 0; w--) {
  2377.             c = (s1[0] + s2[0]) >> 1;
  2378.             d[0] = c;
  2379.             d[1] = c;
  2380.             s1++;
  2381.             s2++;
  2382.             d += 2;
  2383.         }
  2384.         src += src_wrap * 2;
  2385.         dst += dst_wrap;
  2386.     }
  2387. }
  2389. /* XXX: always use linesize. Return -1 if not supported */
  2390. int img_convert(AVPicture *dst, int dst_pix_fmt,
  2391.                 const AVPicture *src, int src_pix_fmt,
  2392.                 int src_width, int src_height)
  2393. {
  2394.     static int initialized;
  2395.     int i, ret, dst_width, dst_height, int_pix_fmt;
  2396.     const PixFmtInfo *src_pix, *dst_pix;
  2397.     const ConvertEntry *ce;
  2398.     AVPicture tmp1, *tmp = &tmp1;
  2400.     if (src_pix_fmt < 0 || src_pix_fmt >= PIX_FMT_NB ||
  2401.         dst_pix_fmt < 0 || dst_pix_fmt >= PIX_FMT_NB)
  2402.         return -1;
  2403.     if (src_width <= 0 || src_height <= 0)
  2404.         return 0;
  2406.     if (!initialized) {
  2407.         initialized = 1;
  2408.         img_convert_init();
  2409.     }
  2411.     dst_width = src_width;
  2412.     dst_height = src_height;
  2414.     dst_pix = &pix_fmt_info[dst_pix_fmt];
  2415.     src_pix = &pix_fmt_info[src_pix_fmt];
  2416.     if (src_pix_fmt == dst_pix_fmt) {
  2417.         /* no conversion needed: just copy */
  2418.         av_picture_copy(dst, src, dst_pix_fmt, dst_width, dst_height);
  2419.         return 0;
  2420.     }
  2422.     ce = &convert_table[src_pix_fmt][dst_pix_fmt];
  2423.     if (ce->convert) {
  2424.         /* specific conversion routine */
  2425.         ce->convert(dst, src, dst_width, dst_height);
  2426.         return 0;
  2427.     }
  2429.     /* gray to YUV */
  2430.     if (is_yuv_planar(dst_pix) &&
  2431.         src_pix_fmt == PIX_FMT_GRAY8) {
  2432.         int w, h, y;
  2433.         uint8_t *d;
  2435.         if (dst_pix->color_type == FF_COLOR_YUV_JPEG) {
  2436.             ff_img_copy_plane(dst->data[0], dst->linesize[0],
  2437.                      src->data[0], src->linesize[0],
  2438.                      dst_width, dst_height);
  2439.         } else {
  2440.             img_apply_table(dst->data[0], dst->linesize[0],
  2441.                             src->data[0], src->linesize[0],
  2442.                             dst_width, dst_height,
  2443.                             y_jpeg_to_ccir);
  2444.         }
  2445.         /* fill U and V with 128 */
  2446.         w = dst_width;
  2447.         h = dst_height;
  2448.         w >>= dst_pix->x_chroma_shift;
  2449.         h >>= dst_pix->y_chroma_shift;
  2450.         for(i = 1; i <= 2; i++) {
  2451.             d = dst->data[i];
  2452.             for(y = 0; y< h; y++) {
  2453.                 memset(d, 128, w);
  2454.                 d += dst->linesize[i];
  2455.             }
  2456.         }
  2457.         return 0;
  2458.     }
  2460.     /* YUV to gray */
  2461.     if (is_yuv_planar(src_pix) &&
  2462.         dst_pix_fmt == PIX_FMT_GRAY8) {
  2463.         if (src_pix->color_type == FF_COLOR_YUV_JPEG) {
  2464.             ff_img_copy_plane(dst->data[0], dst->linesize[0],
  2465.                      src->data[0], src->linesize[0],
  2466.                      dst_width, dst_height);
  2467.         } else {
  2468.             img_apply_table(dst->data[0], dst->linesize[0],
  2469.                             src->data[0], src->linesize[0],
  2470.                             dst_width, dst_height,
  2471.                             y_ccir_to_jpeg);
  2472.         }
  2473.         return 0;
  2474.     }
  2476.     /* YUV to YUV planar */
  2477.     if (is_yuv_planar(dst_pix) && is_yuv_planar(src_pix)) {
  2478.         int x_shift, y_shift, w, h, xy_shift;
  2479.         void (*resize_func)(uint8_t *dst, int dst_wrap,
  2480.                             const uint8_t *src, int src_wrap,
  2481.                             int width, int height);
  2483.         /* compute chroma size of the smallest dimensions */
  2484.         w = dst_width;
  2485.         h = dst_height;
  2486.         if (dst_pix->x_chroma_shift >= src_pix->x_chroma_shift)
  2487.             w >>= dst_pix->x_chroma_shift;
  2488.         else
  2489.             w >>= src_pix->x_chroma_shift;
  2490.         if (dst_pix->y_chroma_shift >= src_pix->y_chroma_shift)
  2491.             h >>= dst_pix->y_chroma_shift;
  2492.         else
  2493.             h >>= src_pix->y_chroma_shift;
  2495.         x_shift = (dst_pix->x_chroma_shift - src_pix->x_chroma_shift);
  2496.         y_shift = (dst_pix->y_chroma_shift - src_pix->y_chroma_shift);
  2497.         xy_shift = ((x_shift & 0xf) << 4) | (y_shift & 0xf);
  2498.         /* there must be filters for conversion at least from and to
  2499.            YUV444 format */
  2500.         switch(xy_shift) {
  2501.         case 0x00:
  2502.             resize_func = ff_img_copy_plane;
  2503.             break;
  2504.         case 0x10:
  2505.             resize_func = shrink21;
  2506.             break;
  2507.         case 0x20:
  2508.             resize_func = shrink41;
  2509.             break;
  2510.         case 0x01:
  2511.             resize_func = shrink12;
  2512.             break;
  2513.         case 0x11:
  2514.             resize_func = ff_shrink22;
  2515.             break;
  2516.         case 0x22:
  2517.             resize_func = ff_shrink44;
  2518.             break;
  2519.         case 0xf0:
  2520.             resize_func = grow21;
  2521.             break;
  2522.         case 0x0f:
  2523.             resize_func = grow12;
  2524.             break;
  2525.         case 0xe0:
  2526.             resize_func = grow41;
  2527.             break;
  2528.         case 0xff:
  2529.             resize_func = grow22;
  2530.             break;
  2531.         case 0xee:
  2532.             resize_func = grow44;
  2533.             break;
  2534.         case 0xf1:
  2535.             resize_func = conv411;
  2536.             break;
  2537.         default:
  2538.             /* currently not handled */
  2539.             goto no_chroma_filter;
  2540.         }
  2542.         ff_img_copy_plane(dst->data[0], dst->linesize[0],
  2543.                        src->data[0], src->linesize[0],
  2544.                        dst_width, dst_height);
  2546.         for(i = 1;i <= 2; i++)
  2547.             resize_func(dst->data[i], dst->linesize[i],
  2548.                         src->data[i], src->linesize[i],
  2549.                         dst_width>>dst_pix->x_chroma_shift, dst_height>>dst_pix->y_chroma_shift);
  2550.         /* if yuv color space conversion is needed, we do it here on
  2551.            the destination image */
  2552.         if (dst_pix->color_type != src_pix->color_type) {
  2553.             const uint8_t *y_table, *c_table;
  2554.             if (dst_pix->color_type == FF_COLOR_YUV) {
  2555.                 y_table = y_jpeg_to_ccir;
  2556.                 c_table = c_jpeg_to_ccir;
  2557.             } else {
  2558.                 y_table = y_ccir_to_jpeg;
  2559.                 c_table = c_ccir_to_jpeg;
  2560.             }
  2561.             img_apply_table(dst->data[0], dst->linesize[0],
  2562.                             dst->data[0], dst->linesize[0],
  2563.                             dst_width, dst_height,
  2564.                             y_table);
  2566.             for(i = 1;i <= 2; i++)
  2567.                 img_apply_table(dst->data[i], dst->linesize[i],
  2568.                                 dst->data[i], dst->linesize[i],
  2569.                                 dst_width>>dst_pix->x_chroma_shift,
  2570.                                 dst_height>>dst_pix->y_chroma_shift,
  2571.                                 c_table);
  2572.         }
  2573.         return 0;
  2574.     }
  2575.  no_chroma_filter:
  2577.     /* try to use an intermediate format */
  2578.     if (src_pix_fmt == PIX_FMT_YUYV422 ||
  2579.         dst_pix_fmt == PIX_FMT_YUYV422) {
  2580.         /* specific case: convert to YUV422P first */
  2581.         int_pix_fmt = PIX_FMT_YUV422P;
  2582.     } else if (src_pix_fmt == PIX_FMT_UYVY422 ||
  2583.         dst_pix_fmt == PIX_FMT_UYVY422) {
  2584.         /* specific case: convert to YUV422P first */
  2585.         int_pix_fmt = PIX_FMT_YUV422P;
  2586.     } else if (src_pix_fmt == PIX_FMT_UYYVYY411 ||
  2587.         dst_pix_fmt == PIX_FMT_UYYVYY411) {
  2588.         /* specific case: convert to YUV411P first */
  2589.         int_pix_fmt = PIX_FMT_YUV411P;
  2590.     } else if ((src_pix->color_type == FF_COLOR_GRAY &&
  2591.                 src_pix_fmt != PIX_FMT_GRAY8) ||
  2592.                (dst_pix->color_type == FF_COLOR_GRAY &&
  2593.                 dst_pix_fmt != PIX_FMT_GRAY8)) {
  2594.         /* gray8 is the normalized format */
  2595.         int_pix_fmt = PIX_FMT_GRAY8;
  2596.     } else if ((is_yuv_planar(src_pix) &&
  2597.                 src_pix_fmt != PIX_FMT_YUV444P &&
  2598.                 src_pix_fmt != PIX_FMT_YUVJ444P)) {
  2599.         /* yuv444 is the normalized format */
  2600.         if (src_pix->color_type == FF_COLOR_YUV_JPEG)
  2601.             int_pix_fmt = PIX_FMT_YUVJ444P;
  2602.         else
  2603.             int_pix_fmt = PIX_FMT_YUV444P;
  2604.     } else if ((is_yuv_planar(dst_pix) &&
  2605.                 dst_pix_fmt != PIX_FMT_YUV444P &&
  2606.                 dst_pix_fmt != PIX_FMT_YUVJ444P)) {
  2607.         /* yuv444 is the normalized format */
  2608.         if (dst_pix->color_type == FF_COLOR_YUV_JPEG)
  2609.             int_pix_fmt = PIX_FMT_YUVJ444P;
  2610.         else
  2611.             int_pix_fmt = PIX_FMT_YUV444P;
  2612.     } else {
  2613.         /* the two formats are rgb or gray8 or yuv[j]444p */
  2614.         if (src_pix->is_alpha && dst_pix->is_alpha)
  2615.             int_pix_fmt = PIX_FMT_RGB32;
  2616.         else
  2617.             int_pix_fmt = PIX_FMT_RGB24;
  2618.     }
  2619.     if (src_pix_fmt == int_pix_fmt)
  2620.         return -1;
  2621.     if (avpicture_alloc(tmp, int_pix_fmt, dst_width, dst_height) < 0)
  2622.         return -1;
  2623.     ret = -1;
  2624.     if (img_convert(tmp, int_pix_fmt,
  2625.                     src, src_pix_fmt, src_width, src_height) < 0)
  2626.         goto fail1;
  2627.     if (img_convert(dst, dst_pix_fmt,
  2628.                     tmp, int_pix_fmt, dst_width, dst_height) < 0)
  2629.         goto fail1;
  2630.     ret = 0;
  2631.  fail1:
  2632.     avpicture_free(tmp);
  2633.     return ret;
  2634. }
  2635. #endif
  2637. /* NOTE: we scan all the pixels to have an exact information */
  2638. static int get_alpha_info_pal8(const AVPicture *src, int width, int height)
  2639. {
  2640.     const unsigned char *p;
  2641.     int src_wrap, ret, x, y;
  2642.     unsigned int a;
  2643.     uint32_t *palette = (uint32_t *)src->data[1];
  2645.     p = src->data[0];
  2646.     src_wrap = src->linesize[0] - width;
  2647.     ret = 0;
  2648.     for(y=0;y<height;y++) {
  2649.         for(x=0;x<width;x++) {
  2650.             a = palette[p[0]] >> 24;
  2651.             if (a == 0x00) {
  2652.                 ret |= FF_ALPHA_TRANSP;
  2653.             } else if (a != 0xff) {
  2654.                 ret |= FF_ALPHA_SEMI_TRANSP;
  2655.             }
  2656.             p++;
  2657.         }
  2658.         p += src_wrap;
  2659.     }
  2660.     return ret;
  2661. }
  2663. int img_get_alpha_info(const AVPicture *src,
  2664.                        int pix_fmt, int width, int height)
  2665. {
  2666.     const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
  2667.     int ret;
  2669.     pf = &pix_fmt_info[pix_fmt];
  2670.     /* no alpha can be represented in format */
  2671.     if (!pf->is_alpha)
  2672.         return 0;
  2673.     switch(pix_fmt) {
  2674.     case PIX_FMT_RGB32:
  2675. //        ret = get_alpha_info_rgb32(src, width, height);
  2676.         break;
  2677.     case PIX_FMT_PAL8:
  2678.         ret = get_alpha_info_pal8(src, width, height);
  2679.         break;
  2680.     default:
  2681.         /* we do not know, so everything is indicated */
  2682.         ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP;
  2683.         break;
  2684.     }
  2685.     return ret;
  2686. }
  2688. #ifdef HAVE_MMX
  2689. #define DEINT_INPLACE_LINE_LUM 
  2690.                     movd_m2r(lum_m4[0],mm0);
  2691.                     movd_m2r(lum_m3[0],mm1);
  2692.                     movd_m2r(lum_m2[0],mm2);
  2693.                     movd_m2r(lum_m1[0],mm3);
  2694.                     movd_m2r(lum[0],mm4);
  2695.                     punpcklbw_r2r(mm7,mm0);
  2696.                     movd_r2m(mm2,lum_m4[0]);
  2697.                     punpcklbw_r2r(mm7,mm1);
  2698.                     punpcklbw_r2r(mm7,mm2);
  2699.                     punpcklbw_r2r(mm7,mm3);
  2700.                     punpcklbw_r2r(mm7,mm4);
  2701.                     paddw_r2r(mm3,mm1);
  2702.                     psllw_i2r(1,mm2);
  2703.                     paddw_r2r(mm4,mm0);
  2704.                     psllw_i2r(2,mm1);
  2705.                     paddw_r2r(mm6,mm2);
  2706.                     paddw_r2r(mm2,mm1);
  2707.                     psubusw_r2r(mm0,mm1);
  2708.                     psrlw_i2r(3,mm1);
  2709.                     packuswb_r2r(mm7,mm1);
  2710.                     movd_r2m(mm1,lum_m2[0]);
  2712. #define DEINT_LINE_LUM 
  2713.                     movd_m2r(lum_m4[0],mm0);
  2714.                     movd_m2r(lum_m3[0],mm1);
  2715.                     movd_m2r(lum_m2[0],mm2);
  2716.                     movd_m2r(lum_m1[0],mm3);
  2717.                     movd_m2r(lum[0],mm4);
  2718.                     punpcklbw_r2r(mm7,mm0);
  2719.                     punpcklbw_r2r(mm7,mm1);
  2720.                     punpcklbw_r2r(mm7,mm2);
  2721.                     punpcklbw_r2r(mm7,mm3);
  2722.                     punpcklbw_r2r(mm7,mm4);
  2723.                     paddw_r2r(mm3,mm1);
  2724.                     psllw_i2r(1,mm2);
  2725.                     paddw_r2r(mm4,mm0);
  2726.                     psllw_i2r(2,mm1);
  2727.                     paddw_r2r(mm6,mm2);
  2728.                     paddw_r2r(mm2,mm1);
  2729.                     psubusw_r2r(mm0,mm1);
  2730.                     psrlw_i2r(3,mm1);
  2731.                     packuswb_r2r(mm7,mm1);
  2732.                     movd_r2m(mm1,dst[0]);
  2733. #endif
  2735. /* filter parameters: [-1 4 2 4 -1] // 8 */
  2736. static void deinterlace_line(uint8_t *dst,
  2737.                              const uint8_t *lum_m4, const uint8_t *lum_m3,
  2738.                              const uint8_t *lum_m2, const uint8_t *lum_m1,
  2739.                              const uint8_t *lum,
  2740.                              int size)
  2741. {
  2742. #ifndef HAVE_MMX
  2743.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  2744.     int sum;
  2746.     for(;size > 0;size--) {
  2747.         sum = -lum_m4[0];
  2748.         sum += lum_m3[0] << 2;
  2749.         sum += lum_m2[0] << 1;
  2750.         sum += lum_m1[0] << 2;
  2751.         sum += -lum[0];
  2752.         dst[0] = cm[(sum + 4) >> 3];
  2753.         lum_m4++;
  2754.         lum_m3++;
  2755.         lum_m2++;
  2756.         lum_m1++;
  2757.         lum++;
  2758.         dst++;
  2759.     }
  2760. #else
  2762.     {
  2763.         mmx_t rounder;
  2764.         rounder.uw[0]=4;
  2765.         rounder.uw[1]=4;
  2766.         rounder.uw[2]=4;
  2767.         rounder.uw[3]=4;
  2768.         pxor_r2r(mm7,mm7);
  2769.         movq_m2r(rounder,mm6);
  2770.     }
  2771.     for (;size > 3; size-=4) {
  2772.         DEINT_LINE_LUM
  2773.         lum_m4+=4;
  2774.         lum_m3+=4;
  2775.         lum_m2+=4;
  2776.         lum_m1+=4;
  2777.         lum+=4;
  2778.         dst+=4;
  2779.     }
  2780. #endif
  2781. }
  2782. static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum,
  2783.                              int size)
  2784. {
  2785. #ifndef HAVE_MMX
  2786.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  2787.     int sum;
  2789.     for(;size > 0;size--) {
  2790.         sum = -lum_m4[0];
  2791.         sum += lum_m3[0] << 2;
  2792.         sum += lum_m2[0] << 1;
  2793.         lum_m4[0]=lum_m2[0];
  2794.         sum += lum_m1[0] << 2;
  2795.         sum += -lum[0];
  2796.         lum_m2[0] = cm[(sum + 4) >> 3];
  2797.         lum_m4++;
  2798.         lum_m3++;
  2799.         lum_m2++;
  2800.         lum_m1++;
  2801.         lum++;
  2802.     }
  2803. #else
  2805.     {
  2806.         mmx_t rounder;
  2807.         rounder.uw[0]=4;
  2808.         rounder.uw[1]=4;
  2809.         rounder.uw[2]=4;
  2810.         rounder.uw[3]=4;
  2811.         pxor_r2r(mm7,mm7);
  2812.         movq_m2r(rounder,mm6);
  2813.     }
  2814.     for (;size > 3; size-=4) {
  2815.         DEINT_INPLACE_LINE_LUM
  2816.         lum_m4+=4;
  2817.         lum_m3+=4;
  2818.         lum_m2+=4;
  2819.         lum_m1+=4;
  2820.         lum+=4;
  2821.     }
  2822. #endif
  2823. }
  2825. /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
  2826.    top field is copied as is, but the bottom field is deinterlaced
  2827.    against the top field. */
  2828. static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap,
  2829.                                     const uint8_t *src1, int src_wrap,
  2830.                                     int width, int height)
  2831. {
  2832.     const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
  2833.     int y;
  2835.     src_m2 = src1;
  2836.     src_m1 = src1;
  2837.     src_0=&src_m1[src_wrap];
  2838.     src_p1=&src_0[src_wrap];
  2839.     src_p2=&src_p1[src_wrap];
  2840.     for(y=0;y<(height-2);y+=2) {
  2841.         memcpy(dst,src_m1,width);
  2842.         dst += dst_wrap;
  2843.         deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width);
  2844.         src_m2 = src_0;
  2845.         src_m1 = src_p1;
  2846.         src_0 = src_p2;
  2847.         src_p1 += 2*src_wrap;
  2848.         src_p2 += 2*src_wrap;
  2849.         dst += dst_wrap;
  2850.     }
  2851.     memcpy(dst,src_m1,width);
  2852.     dst += dst_wrap;
  2853.     /* do last line */
  2854.     deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);
  2855. }
  2857. static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap,
  2858.                                              int width, int height)
  2859. {
  2860.     uint8_t *src_m1, *src_0, *src_p1, *src_p2;
  2861.     int y;
  2862.     uint8_t *buf;
  2863.     buf = (uint8_t*)av_malloc(width);
  2865.     src_m1 = src1;
  2866.     memcpy(buf,src_m1,width);
  2867.     src_0=&src_m1[src_wrap];
  2868.     src_p1=&src_0[src_wrap];
  2869.     src_p2=&src_p1[src_wrap];
  2870.     for(y=0;y<(height-2);y+=2) {
  2871.         deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width);
  2872.         src_m1 = src_p1;
  2873.         src_0 = src_p2;
  2874.         src_p1 += 2*src_wrap;
  2875.         src_p2 += 2*src_wrap;
  2876.     }
  2877.     /* do last line */
  2878.     deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width);
  2879.     av_free(buf);
  2880. }
  2882. int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
  2883.                           int pix_fmt, int width, int height)
  2884. {
  2885.     int i;
  2887.     if (pix_fmt != PIX_FMT_YUV420P &&
  2888.         pix_fmt != PIX_FMT_YUV422P &&
  2889.         pix_fmt != PIX_FMT_YUV444P &&
  2890.         pix_fmt != PIX_FMT_YUV411P &&
  2891.         pix_fmt != PIX_FMT_GRAY8)
  2892.         return -1;
  2893.     if ((width & 3) != 0 || (height & 3) != 0)
  2894.         return -1;
  2896.     for(i=0;i<3;i++) {
  2897.         if (i == 1) {
  2898.             switch(pix_fmt) {
  2899.             case PIX_FMT_YUV420P:
  2900.                 width >>= 1;
  2901.                 height >>= 1;
  2902.                 break;
  2903.             case PIX_FMT_YUV422P:
  2904.                 width >>= 1;
  2905.                 break;
  2906.             case PIX_FMT_YUV411P:
  2907.                 width >>= 2;
  2908.                 break;
  2909.             default:
  2910.                 break;
  2911.             }
  2912.             if (pix_fmt == PIX_FMT_GRAY8) {
  2913.                 break;
  2914.             }
  2915.         }
  2916.         if (src == dst) {
  2917.             deinterlace_bottom_field_inplace(dst->data[i], dst->linesize[i],
  2918.                                  width, height);
  2919.         } else {
  2920.             deinterlace_bottom_field(dst->data[i],dst->linesize[i],
  2921.                                         src->data[i], src->linesize[i],
  2922.                                         width, height);
  2923.         }
  2924.     }
  2925.     emms_c();
  2926.     return 0;
  2927. }