swscale_internal.h 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729
  1. /*
  2. * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
  3. *
  4. * This file is part of FFmpeg.
  5. *
  6. * FFmpeg is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU Lesser General Public
  8. * License as published by the Free Software Foundation; either
  9. * version 2.1 of the License, or (at your option) any later version.
  10. *
  11. * FFmpeg is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * Lesser General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU Lesser General Public
  17. * License along with FFmpeg; if not, write to the Free Software
  18. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19. */
  20. #ifndef SWSCALE_SWSCALE_INTERNAL_H
  21. #define SWSCALE_SWSCALE_INTERNAL_H
  22. #include "config.h"
  23. #if HAVE_ALTIVEC_H
  24. #include <altivec.h>
  25. #endif
  26. #include "libavutil/avutil.h"
  27. #include "libavutil/log.h"
  28. #include "libavutil/pixfmt.h"
  29. #include "libavutil/pixdesc.h"
  30. #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
  31. #define YUVRGB_TABLE_HEADROOM 128
  32. #define FAST_BGR2YV12 // use 7-bit instead of 15-bit coefficients
  33. #define MAX_FILTER_SIZE 256
  34. #define DITHER1XBPP
  35. #if HAVE_BIGENDIAN
  36. #define ALT32_CORR (-1)
  37. #else
  38. #define ALT32_CORR 1
  39. #endif
  40. #if ARCH_X86_64
  41. # define APCK_PTR2 8
  42. # define APCK_COEF 16
  43. # define APCK_SIZE 24
  44. #else
  45. # define APCK_PTR2 4
  46. # define APCK_COEF 8
  47. # define APCK_SIZE 16
  48. #endif
  49. struct SwsContext;
  50. typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
  51. int srcStride[], int srcSliceY, int srcSliceH,
  52. uint8_t *dst[], int dstStride[]);
  53. /**
  54. * Write one line of horizontally scaled data to planar output
  55. * without any additional vertical scaling (or point-scaling).
  56. *
  57. * @param src scaled source data, 15bit for 8-10bit output,
  58. * 19-bit for 16bit output (in int32_t)
  59. * @param dest pointer to the output plane. For >8bit
  60. * output, this is in uint16_t
  61. * @param dstW width of destination in pixels
  62. * @param dither ordered dither array of type int16_t and size 8
  63. * @param offset Dither offset
  64. */
  65. typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW,
  66. const uint8_t *dither, int offset);
  67. /**
  68. * Write one line of horizontally scaled data to planar output
  69. * with multi-point vertical scaling between input pixels.
  70. *
  71. * @param filter vertical luma/alpha scaling coefficients, 12bit [0,4096]
  72. * @param src scaled luma (Y) or alpha (A) source data, 15bit for 8-10bit output,
  73. * 19-bit for 16bit output (in int32_t)
  74. * @param filterSize number of vertical input lines to scale
  75. * @param dest pointer to output plane. For >8bit
  76. * output, this is in uint16_t
  77. * @param dstW width of destination pixels
  78. * @param offset Dither offset
  79. */
  80. typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize,
  81. const int16_t **src, uint8_t *dest, int dstW,
  82. const uint8_t *dither, int offset);
  83. /**
  84. * Write one line of horizontally scaled chroma to interleaved output
  85. * with multi-point vertical scaling between input pixels.
  86. *
  87. * @param c SWS scaling context
  88. * @param chrFilter vertical chroma scaling coefficients, 12bit [0,4096]
  89. * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
  90. * 19-bit for 16bit output (in int32_t)
  91. * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
  92. * 19-bit for 16bit output (in int32_t)
  93. * @param chrFilterSize number of vertical chroma input lines to scale
  94. * @param dest pointer to the output plane. For >8bit
  95. * output, this is in uint16_t
  96. * @param dstW width of chroma planes
  97. */
  98. typedef void (*yuv2interleavedX_fn)(struct SwsContext *c,
  99. const int16_t *chrFilter,
  100. int chrFilterSize,
  101. const int16_t **chrUSrc,
  102. const int16_t **chrVSrc,
  103. uint8_t *dest, int dstW);
  104. /**
  105. * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
  106. * output without any additional vertical scaling (or point-scaling). Note
  107. * that this function may do chroma scaling, see the "uvalpha" argument.
  108. *
  109. * @param c SWS scaling context
  110. * @param lumSrc scaled luma (Y) source data, 15bit for 8-10bit output,
  111. * 19-bit for 16bit output (in int32_t)
  112. * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
  113. * 19-bit for 16bit output (in int32_t)
  114. * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
  115. * 19-bit for 16bit output (in int32_t)
  116. * @param alpSrc scaled alpha (A) source data, 15bit for 8-10bit output,
  117. * 19-bit for 16bit output (in int32_t)
  118. * @param dest pointer to the output plane. For 16bit output, this is
  119. * uint16_t
  120. * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
  121. * to write into dest[]
  122. * @param uvalpha chroma scaling coefficient for the second line of chroma
  123. * pixels, either 2048 or 0. If 0, one chroma input is used
  124. * for 2 output pixels (or if the SWS_FLAG_FULL_CHR_INT flag
  125. * is set, it generates 1 output pixel). If 2048, two chroma
  126. * input pixels should be averaged for 2 output pixels (this
  127. * only happens if SWS_FLAG_FULL_CHR_INT is not set)
  128. * @param y vertical line number for this output. This does not need
  129. * to be used to calculate the offset in the destination,
  130. * but can be used to generate comfort noise using dithering
  131. * for some output formats.
  132. */
  133. typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
  134. const int16_t *chrUSrc[2],
  135. const int16_t *chrVSrc[2],
  136. const int16_t *alpSrc, uint8_t *dest,
  137. int dstW, int uvalpha, int y);
  138. /**
  139. * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
  140. * output by doing bilinear scaling between two input lines.
  141. *
  142. * @param c SWS scaling context
  143. * @param lumSrc scaled luma (Y) source data, 15bit for 8-10bit output,
  144. * 19-bit for 16bit output (in int32_t)
  145. * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
  146. * 19-bit for 16bit output (in int32_t)
  147. * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
  148. * 19-bit for 16bit output (in int32_t)
  149. * @param alpSrc scaled alpha (A) source data, 15bit for 8-10bit output,
  150. * 19-bit for 16bit output (in int32_t)
  151. * @param dest pointer to the output plane. For 16bit output, this is
  152. * uint16_t
  153. * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
  154. * to write into dest[]
  155. * @param yalpha luma/alpha scaling coefficients for the second input line.
  156. * The first line's coefficients can be calculated by using
  157. * 4096 - yalpha
  158. * @param uvalpha chroma scaling coefficient for the second input line. The
  159. * first line's coefficients can be calculated by using
  160. * 4096 - uvalpha
  161. * @param y vertical line number for this output. This does not need
  162. * to be used to calculate the offset in the destination,
  163. * but can be used to generate comfort noise using dithering
  164. * for some output formats.
  165. */
  166. typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
  167. const int16_t *chrUSrc[2],
  168. const int16_t *chrVSrc[2],
  169. const int16_t *alpSrc[2],
  170. uint8_t *dest,
  171. int dstW, int yalpha, int uvalpha, int y);
  172. /**
  173. * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
  174. * output by doing multi-point vertical scaling between input pixels.
  175. *
  176. * @param c SWS scaling context
  177. * @param lumFilter vertical luma/alpha scaling coefficients, 12bit [0,4096]
  178. * @param lumSrc scaled luma (Y) source data, 15bit for 8-10bit output,
  179. * 19-bit for 16bit output (in int32_t)
  180. * @param lumFilterSize number of vertical luma/alpha input lines to scale
  181. * @param chrFilter vertical chroma scaling coefficients, 12bit [0,4096]
  182. * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
  183. * 19-bit for 16bit output (in int32_t)
  184. * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
  185. * 19-bit for 16bit output (in int32_t)
  186. * @param chrFilterSize number of vertical chroma input lines to scale
  187. * @param alpSrc scaled alpha (A) source data, 15bit for 8-10bit output,
  188. * 19-bit for 16bit output (in int32_t)
  189. * @param dest pointer to the output plane. For 16bit output, this is
  190. * uint16_t
  191. * @param dstW width of lumSrc and alpSrc in pixels, number of pixels
  192. * to write into dest[]
  193. * @param y vertical line number for this output. This does not need
  194. * to be used to calculate the offset in the destination,
  195. * but can be used to generate comfort noise using dithering
  196. * or some output formats.
  197. */
  198. typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
  199. const int16_t **lumSrc, int lumFilterSize,
  200. const int16_t *chrFilter,
  201. const int16_t **chrUSrc,
  202. const int16_t **chrVSrc, int chrFilterSize,
  203. const int16_t **alpSrc, uint8_t *dest,
  204. int dstW, int y);
  205. /* This struct should be aligned on at least a 32-byte boundary. */
  206. typedef struct SwsContext {
  207. /**
  208. * info on struct for av_log
  209. */
  210. const AVClass *av_class;
  211. /**
  212. * Note that src, dst, srcStride, dstStride will be copied in the
  213. * sws_scale() wrapper so they can be freely modified here.
  214. */
  215. SwsFunc swScale;
  216. int srcW; ///< Width of source luma/alpha planes.
  217. int srcH; ///< Height of source luma/alpha planes.
  218. int dstH; ///< Height of destination luma/alpha planes.
  219. int chrSrcW; ///< Width of source chroma planes.
  220. int chrSrcH; ///< Height of source chroma planes.
  221. int chrDstW; ///< Width of destination chroma planes.
  222. int chrDstH; ///< Height of destination chroma planes.
  223. int lumXInc, chrXInc;
  224. int lumYInc, chrYInc;
  225. enum PixelFormat dstFormat; ///< Destination pixel format.
  226. enum PixelFormat srcFormat; ///< Source pixel format.
  227. int dstFormatBpp; ///< Number of bits per pixel of the destination pixel format.
  228. int srcFormatBpp; ///< Number of bits per pixel of the source pixel format.
  229. int dstBpc, srcBpc;
  230. int chrSrcHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source image.
  231. int chrSrcVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in source image.
  232. int chrDstHSubSample; ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination image.
  233. int chrDstVSubSample; ///< Binary logarithm of vertical subsampling factor between luma/alpha and chroma planes in destination image.
  234. int vChrDrop; ///< Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user.
  235. int sliceDir; ///< Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
  236. double param[2]; ///< Input parameters for scaling algorithms that need them.
  237. uint32_t pal_yuv[256];
  238. uint32_t pal_rgb[256];
  239. /**
  240. * @name Scaled horizontal lines ring buffer.
  241. * The horizontal scaler keeps just enough scaled lines in a ring buffer
  242. * so they may be passed to the vertical scaler. The pointers to the
  243. * allocated buffers for each line are duplicated in sequence in the ring
  244. * buffer to simplify indexing and avoid wrapping around between lines
  245. * inside the vertical scaler code. The wrapping is done before the
  246. * vertical scaler is called.
  247. */
  248. //@{
  249. int16_t **lumPixBuf; ///< Ring buffer for scaled horizontal luma plane lines to be fed to the vertical scaler.
  250. int16_t **chrUPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
  251. int16_t **chrVPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
  252. int16_t **alpPixBuf; ///< Ring buffer for scaled horizontal alpha plane lines to be fed to the vertical scaler.
  253. int vLumBufSize; ///< Number of vertical luma/alpha lines allocated in the ring buffer.
  254. int vChrBufSize; ///< Number of vertical chroma lines allocated in the ring buffer.
  255. int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
  256. int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer.
  257. int lumBufIndex; ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source.
  258. int chrBufIndex; ///< Index in ring buffer of the last scaled horizontal chroma line from source.
  259. //@}
  260. uint8_t *formatConvBuffer;
  261. /**
  262. * @name Horizontal and vertical filters.
  263. * To better understand the following fields, here is a pseudo-code of
  264. * their usage in filtering a horizontal line:
  265. * @code
  266. * for (i = 0; i < width; i++) {
  267. * dst[i] = 0;
  268. * for (j = 0; j < filterSize; j++)
  269. * dst[i] += src[ filterPos[i] + j ] * filter[ filterSize * i + j ];
  270. * dst[i] >>= FRAC_BITS; // The actual implementation is fixed-point.
  271. * }
  272. * @endcode
  273. */
  274. //@{
  275. int16_t *hLumFilter; ///< Array of horizontal filter coefficients for luma/alpha planes.
  276. int16_t *hChrFilter; ///< Array of horizontal filter coefficients for chroma planes.
  277. int16_t *vLumFilter; ///< Array of vertical filter coefficients for luma/alpha planes.
  278. int16_t *vChrFilter; ///< Array of vertical filter coefficients for chroma planes.
  279. int32_t *hLumFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
  280. int32_t *hChrFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for chroma planes.
  281. int32_t *vLumFilterPos; ///< Array of vertical filter starting positions for each dst[i] for luma/alpha planes.
  282. int32_t *vChrFilterPos; ///< Array of vertical filter starting positions for each dst[i] for chroma planes.
  283. int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels.
  284. int hChrFilterSize; ///< Horizontal filter size for chroma pixels.
  285. int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels.
  286. int vChrFilterSize; ///< Vertical filter size for chroma pixels.
  287. //@}
  288. int lumMmx2FilterCodeSize; ///< Runtime-generated MMX2 horizontal fast bilinear scaler code size for luma/alpha planes.
  289. int chrMmx2FilterCodeSize; ///< Runtime-generated MMX2 horizontal fast bilinear scaler code size for chroma planes.
  290. uint8_t *lumMmx2FilterCode; ///< Runtime-generated MMX2 horizontal fast bilinear scaler code for luma/alpha planes.
  291. uint8_t *chrMmx2FilterCode; ///< Runtime-generated MMX2 horizontal fast bilinear scaler code for chroma planes.
  292. int canMMX2BeUsed;
  293. int dstY; ///< Last destination vertical line output from last slice.
  294. int flags; ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
  295. void *yuvTable; // pointer to the yuv->rgb table start so it can be freed()
  296. uint8_t *table_rV[256 + 2*YUVRGB_TABLE_HEADROOM];
  297. uint8_t *table_gU[256 + 2*YUVRGB_TABLE_HEADROOM];
  298. int table_gV[256 + 2*YUVRGB_TABLE_HEADROOM];
  299. uint8_t *table_bU[256 + 2*YUVRGB_TABLE_HEADROOM];
  300. //Colorspace stuff
  301. int contrast, brightness, saturation; // for sws_getColorspaceDetails
  302. int srcColorspaceTable[4];
  303. int dstColorspaceTable[4];
  304. int srcRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (source image).
  305. int dstRange; ///< 0 = MPG YUV range, 1 = JPG YUV range (destination image).
  306. int src0Alpha;
  307. int dst0Alpha;
  308. int yuv2rgb_y_offset;
  309. int yuv2rgb_y_coeff;
  310. int yuv2rgb_v2r_coeff;
  311. int yuv2rgb_v2g_coeff;
  312. int yuv2rgb_u2g_coeff;
  313. int yuv2rgb_u2b_coeff;
  314. #define RED_DITHER "0*8"
  315. #define GREEN_DITHER "1*8"
  316. #define BLUE_DITHER "2*8"
  317. #define Y_COEFF "3*8"
  318. #define VR_COEFF "4*8"
  319. #define UB_COEFF "5*8"
  320. #define VG_COEFF "6*8"
  321. #define UG_COEFF "7*8"
  322. #define Y_OFFSET "8*8"
  323. #define U_OFFSET "9*8"
  324. #define V_OFFSET "10*8"
  325. #define LUM_MMX_FILTER_OFFSET "11*8"
  326. #define CHR_MMX_FILTER_OFFSET "11*8+4*4*256"
  327. #define DSTW_OFFSET "11*8+4*4*256*2" //do not change, it is hardcoded in the ASM
  328. #define ESP_OFFSET "11*8+4*4*256*2+8"
  329. #define VROUNDER_OFFSET "11*8+4*4*256*2+16"
  330. #define U_TEMP "11*8+4*4*256*2+24"
  331. #define V_TEMP "11*8+4*4*256*2+32"
  332. #define Y_TEMP "11*8+4*4*256*2+40"
  333. #define ALP_MMX_FILTER_OFFSET "11*8+4*4*256*2+48"
  334. #define UV_OFF_PX "11*8+4*4*256*3+48"
  335. #define UV_OFF_BYTE "11*8+4*4*256*3+56"
  336. #define DITHER16 "11*8+4*4*256*3+64"
  337. #define DITHER32 "11*8+4*4*256*3+80"
  338. DECLARE_ALIGNED(8, uint64_t, redDither);
  339. DECLARE_ALIGNED(8, uint64_t, greenDither);
  340. DECLARE_ALIGNED(8, uint64_t, blueDither);
  341. DECLARE_ALIGNED(8, uint64_t, yCoeff);
  342. DECLARE_ALIGNED(8, uint64_t, vrCoeff);
  343. DECLARE_ALIGNED(8, uint64_t, ubCoeff);
  344. DECLARE_ALIGNED(8, uint64_t, vgCoeff);
  345. DECLARE_ALIGNED(8, uint64_t, ugCoeff);
  346. DECLARE_ALIGNED(8, uint64_t, yOffset);
  347. DECLARE_ALIGNED(8, uint64_t, uOffset);
  348. DECLARE_ALIGNED(8, uint64_t, vOffset);
  349. int32_t lumMmxFilter[4 * MAX_FILTER_SIZE];
  350. int32_t chrMmxFilter[4 * MAX_FILTER_SIZE];
  351. int dstW; ///< Width of destination luma/alpha planes.
  352. DECLARE_ALIGNED(8, uint64_t, esp);
  353. DECLARE_ALIGNED(8, uint64_t, vRounder);
  354. DECLARE_ALIGNED(8, uint64_t, u_temp);
  355. DECLARE_ALIGNED(8, uint64_t, v_temp);
  356. DECLARE_ALIGNED(8, uint64_t, y_temp);
  357. int32_t alpMmxFilter[4 * MAX_FILTER_SIZE];
  358. // alignment of these values is not necessary, but merely here
  359. // to maintain the same offset across x8632 and x86-64. Once we
  360. // use proper offset macros in the asm, they can be removed.
  361. DECLARE_ALIGNED(8, ptrdiff_t, uv_off); ///< offset (in pixels) between u and v planes
  362. DECLARE_ALIGNED(8, ptrdiff_t, uv_offx2); ///< offset (in bytes) between u and v planes
  363. DECLARE_ALIGNED(8, uint16_t, dither16)[8];
  364. DECLARE_ALIGNED(8, uint32_t, dither32)[8];
  365. const uint8_t *chrDither8, *lumDither8;
  366. #if HAVE_ALTIVEC
  367. vector signed short CY;
  368. vector signed short CRV;
  369. vector signed short CBU;
  370. vector signed short CGU;
  371. vector signed short CGV;
  372. vector signed short OY;
  373. vector unsigned short CSHIFT;
  374. vector signed short *vYCoeffsBank, *vCCoeffsBank;
  375. #endif
  376. #if ARCH_BFIN
  377. DECLARE_ALIGNED(4, uint32_t, oy);
  378. DECLARE_ALIGNED(4, uint32_t, oc);
  379. DECLARE_ALIGNED(4, uint32_t, zero);
  380. DECLARE_ALIGNED(4, uint32_t, cy);
  381. DECLARE_ALIGNED(4, uint32_t, crv);
  382. DECLARE_ALIGNED(4, uint32_t, rmask);
  383. DECLARE_ALIGNED(4, uint32_t, cbu);
  384. DECLARE_ALIGNED(4, uint32_t, bmask);
  385. DECLARE_ALIGNED(4, uint32_t, cgu);
  386. DECLARE_ALIGNED(4, uint32_t, cgv);
  387. DECLARE_ALIGNED(4, uint32_t, gmask);
  388. #endif
  389. #if HAVE_VIS
  390. DECLARE_ALIGNED(8, uint64_t, sparc_coeffs)[10];
  391. #endif
  392. int use_mmx_vfilter;
  393. /* function pointers for swScale() */
  394. yuv2planar1_fn yuv2plane1;
  395. yuv2planarX_fn yuv2planeX;
  396. yuv2interleavedX_fn yuv2nv12cX;
  397. yuv2packed1_fn yuv2packed1;
  398. yuv2packed2_fn yuv2packed2;
  399. yuv2packedX_fn yuv2packedX;
  400. /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
  401. void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
  402. int width, uint32_t *pal);
  403. /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
  404. void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
  405. int width, uint32_t *pal);
  406. /// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
  407. void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
  408. const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
  409. int width, uint32_t *pal);
  410. /**
  411. * Functions to read planar input, such as planar RGB, and convert
  412. * internally to Y/UV.
  413. */
  414. /** @{ */
  415. void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width);
  416. void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
  417. int width);
  418. /** @} */
  419. /**
  420. * Scale one horizontal line of input data using a bilinear filter
  421. * to produce one line of output data. Compared to SwsContext->hScale(),
  422. * please take note of the following caveats when using these:
  423. * - Scaling is done using only 7bit instead of 14bit coefficients.
  424. * - You can use no more than 5 input pixels to produce 4 output
  425. * pixels. Therefore, this filter should not be used for downscaling
  426. * by more than ~20% in width (because that equals more than 5/4th
  427. * downscaling and thus more than 5 pixels input per 4 pixels output).
  428. * - In general, bilinear filters create artifacts during downscaling
  429. * (even when <20%), because one output pixel will span more than one
  430. * input pixel, and thus some pixels will need edges of both neighbor
  431. * pixels to interpolate the output pixel. Since you can use at most
  432. * two input pixels per output pixel in bilinear scaling, this is
  433. * impossible and thus downscaling by any size will create artifacts.
  434. * To enable this type of scaling, set SWS_FLAG_FAST_BILINEAR
  435. * in SwsContext->flags.
  436. */
  437. /** @{ */
  438. void (*hyscale_fast)(struct SwsContext *c,
  439. int16_t *dst, int dstWidth,
  440. const uint8_t *src, int srcW, int xInc);
  441. void (*hcscale_fast)(struct SwsContext *c,
  442. int16_t *dst1, int16_t *dst2, int dstWidth,
  443. const uint8_t *src1, const uint8_t *src2,
  444. int srcW, int xInc);
  445. /** @} */
  446. /**
  447. * Scale one horizontal line of input data using a filter over the input
  448. * lines, to produce one (differently sized) line of output data.
  449. *
  450. * @param dst pointer to destination buffer for horizontally scaled
  451. * data. If the number of bits per component of one
  452. * destination pixel (SwsContext->dstBpc) is <= 10, data
  453. * will be 15bpc in 16bits (int16_t) width. Else (i.e.
  454. * SwsContext->dstBpc == 16), data will be 19bpc in
  455. * 32bits (int32_t) width.
  456. * @param dstW width of destination image
  457. * @param src pointer to source data to be scaled. If the number of
  458. * bits per component of a source pixel (SwsContext->srcBpc)
  459. * is 8, this is 8bpc in 8bits (uint8_t) width. Else
  460. * (i.e. SwsContext->dstBpc > 8), this is native depth
  461. * in 16bits (uint16_t) width. In other words, for 9-bit
  462. * YUV input, this is 9bpc, for 10-bit YUV input, this is
  463. * 10bpc, and for 16-bit RGB or YUV, this is 16bpc.
  464. * @param filter filter coefficients to be used per output pixel for
  465. * scaling. This contains 14bpp filtering coefficients.
  466. * Guaranteed to contain dstW * filterSize entries.
  467. * @param filterPos position of the first input pixel to be used for
  468. * each output pixel during scaling. Guaranteed to
  469. * contain dstW entries.
  470. * @param filterSize the number of input coefficients to be used (and
  471. * thus the number of input pixels to be used) for
  472. * creating a single output pixel. Is aligned to 4
  473. * (and input coefficients thus padded with zeroes)
  474. * to simplify creating SIMD code.
  475. */
  476. /** @{ */
  477. void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
  478. const uint8_t *src, const int16_t *filter,
  479. const int32_t *filterPos, int filterSize);
  480. void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
  481. const uint8_t *src, const int16_t *filter,
  482. const int32_t *filterPos, int filterSize);
  483. /** @} */
  484. /// Color range conversion function for luma plane if needed.
  485. void (*lumConvertRange)(int16_t *dst, int width);
  486. /// Color range conversion function for chroma planes if needed.
  487. void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
  488. int needs_hcscale; ///< Set if there are chroma planes to be converted.
  489. } SwsContext;
  490. //FIXME check init (where 0)
  491. SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c);
  492. int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
  493. int fullRange, int brightness,
  494. int contrast, int saturation);
  495. void ff_yuv2rgb_init_tables_altivec(SwsContext *c, const int inv_table[4],
  496. int brightness, int contrast, int saturation);
  497. void updateMMXDitherTables(SwsContext *c, int dstY, int lumBufIndex, int chrBufIndex,
  498. int lastInLumBuf, int lastInChrBuf);
  499. SwsFunc ff_yuv2rgb_init_mmx(SwsContext *c);
  500. SwsFunc ff_yuv2rgb_init_vis(SwsContext *c);
  501. SwsFunc ff_yuv2rgb_init_altivec(SwsContext *c);
  502. SwsFunc ff_yuv2rgb_get_func_ptr_bfin(SwsContext *c);
  503. void ff_bfin_get_unscaled_swscale(SwsContext *c);
  504. #if FF_API_SWS_FORMAT_NAME
  505. /**
  506. * @deprecated Use av_get_pix_fmt_name() instead.
  507. */
  508. attribute_deprecated
  509. const char *sws_format_name(enum PixelFormat format);
  510. #endif
  511. #define is16BPS(x) \
  512. (av_pix_fmt_descriptors[x].comp[0].depth_minus1 == 15)
  513. #define is9_OR_10BPS(x) \
  514. (av_pix_fmt_descriptors[x].comp[0].depth_minus1 == 8 || \
  515. av_pix_fmt_descriptors[x].comp[0].depth_minus1 == 9)
  516. #define isNBPS(x) is9_OR_10BPS(x)
  517. #define isBE(x) \
  518. (av_pix_fmt_descriptors[x].flags & PIX_FMT_BE)
  519. #define isYUV(x) \
  520. (!(av_pix_fmt_descriptors[x].flags & PIX_FMT_RGB) && \
  521. av_pix_fmt_descriptors[x].nb_components >= 2)
  522. #define isPlanarYUV(x) \
  523. ((av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR) && \
  524. isYUV(x))
  525. #define isRGB(x) \
  526. (av_pix_fmt_descriptors[x].flags & PIX_FMT_RGB)
  527. #if 0 // FIXME
  528. #define isGray(x) \
  529. (!(av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) && \
  530. av_pix_fmt_descriptors[x].nb_components <= 2)
  531. #else
  532. #define isGray(x) \
  533. ((x) == PIX_FMT_GRAY8 || \
  534. (x) == PIX_FMT_Y400A || \
  535. (x) == PIX_FMT_GRAY16BE || \
  536. (x) == PIX_FMT_GRAY16LE)
  537. #endif
  538. #define isRGBinInt(x) \
  539. ( \
  540. (x)==PIX_FMT_RGB48BE || \
  541. (x)==PIX_FMT_RGB48LE || \
  542. (x)==PIX_FMT_RGBA64BE || \
  543. (x)==PIX_FMT_RGBA64LE || \
  544. (x)==PIX_FMT_RGB32 || \
  545. (x)==PIX_FMT_RGB32_1 || \
  546. (x)==PIX_FMT_RGB24 || \
  547. (x)==PIX_FMT_RGB565BE || \
  548. (x)==PIX_FMT_RGB565LE || \
  549. (x)==PIX_FMT_RGB555BE || \
  550. (x)==PIX_FMT_RGB555LE || \
  551. (x)==PIX_FMT_RGB444BE || \
  552. (x)==PIX_FMT_RGB444LE || \
  553. (x)==PIX_FMT_RGB8 || \
  554. (x)==PIX_FMT_RGB4 || \
  555. (x)==PIX_FMT_RGB4_BYTE || \
  556. (x)==PIX_FMT_MONOBLACK || \
  557. (x)==PIX_FMT_MONOWHITE \
  558. )
  559. #define isBGRinInt(x) \
  560. ( \
  561. (x)==PIX_FMT_BGR48BE || \
  562. (x)==PIX_FMT_BGR48LE || \
  563. (x)==PIX_FMT_BGRA64BE || \
  564. (x)==PIX_FMT_BGRA64LE || \
  565. (x)==PIX_FMT_BGR32 || \
  566. (x)==PIX_FMT_BGR32_1 || \
  567. (x)==PIX_FMT_BGR24 || \
  568. (x)==PIX_FMT_BGR565BE || \
  569. (x)==PIX_FMT_BGR565LE || \
  570. (x)==PIX_FMT_BGR555BE || \
  571. (x)==PIX_FMT_BGR555LE || \
  572. (x)==PIX_FMT_BGR444BE || \
  573. (x)==PIX_FMT_BGR444LE || \
  574. (x)==PIX_FMT_BGR8 || \
  575. (x)==PIX_FMT_BGR4 || \
  576. (x)==PIX_FMT_BGR4_BYTE|| \
  577. (x)==PIX_FMT_MONOBLACK|| \
  578. (x)==PIX_FMT_MONOWHITE \
  579. )
  580. #define isRGBinBytes(x) ( \
  581. (x)==PIX_FMT_RGB48BE \
  582. || (x)==PIX_FMT_RGB48LE \
  583. || (x)==PIX_FMT_RGBA64BE \
  584. || (x)==PIX_FMT_RGBA64LE \
  585. || (x)==PIX_FMT_RGBA \
  586. || (x)==PIX_FMT_ARGB \
  587. || (x)==PIX_FMT_RGB24 \
  588. )
  589. #define isBGRinBytes(x) ( \
  590. (x)==PIX_FMT_BGR48BE \
  591. || (x)==PIX_FMT_BGR48LE \
  592. || (x)==PIX_FMT_BGRA64BE \
  593. || (x)==PIX_FMT_BGRA64LE \
  594. || (x)==PIX_FMT_BGRA \
  595. || (x)==PIX_FMT_ABGR \
  596. || (x)==PIX_FMT_BGR24 \
  597. )
  598. #define isAnyRGB(x) \
  599. ( \
  600. isRGBinInt(x) || \
  601. isBGRinInt(x) || \
  602. (x)==PIX_FMT_GBR24P \
  603. )
  604. #define isALPHA(x) \
  605. (av_pix_fmt_descriptors[x].nb_components == 2 || \
  606. av_pix_fmt_descriptors[x].nb_components == 4)
  607. #if 1
  608. #define isPacked(x) ( \
  609. (x)==PIX_FMT_PAL8 \
  610. || (x)==PIX_FMT_YUYV422 \
  611. || (x)==PIX_FMT_UYVY422 \
  612. || (x)==PIX_FMT_Y400A \
  613. || isRGBinInt(x) \
  614. || isBGRinInt(x) \
  615. )
  616. #else
  617. #define isPacked(x) \
  618. ((av_pix_fmt_descriptors[x].nb_components >= 2 && \
  619. !(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) || \
  620. (x) == PIX_FMT_PAL8)
  621. #endif
  622. #define isPlanar(x) \
  623. (av_pix_fmt_descriptors[x].nb_components >= 2 && \
  624. (av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR))
  625. #define isPackedRGB(x) \
  626. ((av_pix_fmt_descriptors[x].flags & \
  627. (PIX_FMT_PLANAR | PIX_FMT_RGB)) == PIX_FMT_RGB)
  628. #define isPlanarRGB(x) \
  629. ((av_pix_fmt_descriptors[x].flags & \
  630. (PIX_FMT_PLANAR | PIX_FMT_RGB)) == (PIX_FMT_PLANAR | PIX_FMT_RGB))
  631. #define usePal(x) ((av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) || \
  632. (av_pix_fmt_descriptors[x].flags & PIX_FMT_PSEUDOPAL) || \
  633. (x) == PIX_FMT_Y400A)
  634. extern const uint64_t ff_dither4[2];
  635. extern const uint64_t ff_dither8[2];
  636. extern const uint8_t dithers[8][8][8];
  637. extern const uint16_t dither_scale[15][16];
  638. extern const AVClass sws_context_class;
  639. /**
  640. * Set c->swScale to an unscaled converter if one exists for the specific
  641. * source and destination formats, bit depths, flags, etc.
  642. */
  643. void ff_get_unscaled_swscale(SwsContext *c);
  644. void ff_swscale_get_unscaled_altivec(SwsContext *c);
  645. /**
  646. * Return function pointer to fastest main scaler path function depending
  647. * on architecture and available optimizations.
  648. */
  649. SwsFunc ff_getSwsFunc(SwsContext *c);
  650. void ff_sws_init_input_funcs(SwsContext *c);
  651. void ff_sws_init_output_funcs(SwsContext *c,
  652. yuv2planar1_fn *yuv2plane1,
  653. yuv2planarX_fn *yuv2planeX,
  654. yuv2interleavedX_fn *yuv2nv12cX,
  655. yuv2packed1_fn *yuv2packed1,
  656. yuv2packed2_fn *yuv2packed2,
  657. yuv2packedX_fn *yuv2packedX);
  658. void ff_sws_init_swScale_altivec(SwsContext *c);
  659. void ff_sws_init_swScale_mmx(SwsContext *c);
  660. #endif /* SWSCALE_SWSCALE_INTERNAL_H */