falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
28498 Commits
32 Branches
552MB
Tree: 9aa91043f3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9aa91043f3'
${ noResults }
FFmpeg/libswscale/swscale_template.c

946 lines
39KB
Raw Blame History 

  1. /*

  2.  * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>

  3.  *

  4.  * This file is part of Libav.

  5.  *

  6.  * Libav 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.  * Libav 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 Libav; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. static inline void yuv2yuvX_c(SwsContext *c, const int16_t *lumFilter,

  22.                               const int16_t **lumSrc, int lumFilterSize,

  23.                               const int16_t *chrFilter, const int16_t **chrSrc,

  24.                               int chrFilterSize, const int16_t **alpSrc,

  25.                               uint8_t *dest, uint8_t *uDest, uint8_t *vDest,

  26.                               uint8_t *aDest, long dstW, long chrDstW)

  27. {

  28.     yuv2yuvXinC(lumFilter, lumSrc, lumFilterSize,

  29.                 chrFilter, chrSrc, chrFilterSize,

  30.                 alpSrc, dest, uDest, vDest, aDest, dstW, chrDstW);

  31. }

  32. 

  33. static inline void yuv2nv12X_c(SwsContext *c, const int16_t *lumFilter,

  34.                                const int16_t **lumSrc, int lumFilterSize,

  35.                                const int16_t *chrFilter, const int16_t **chrSrc,

  36.                                int chrFilterSize, uint8_t *dest, uint8_t *uDest,

  37.                                int dstW, int chrDstW, enum PixelFormat dstFormat)

  38. {

  39.     yuv2nv12XinC(lumFilter, lumSrc, lumFilterSize,

  40.                  chrFilter, chrSrc, chrFilterSize,

  41.                  dest, uDest, dstW, chrDstW, dstFormat);

  42. }

  43. 

  44. static inline void yuv2yuv1_c(SwsContext *c, const int16_t *lumSrc,

  45.                               const int16_t *chrSrc, const int16_t *alpSrc,

  46.                               uint8_t *dest, uint8_t *uDest, uint8_t *vDest,

  47.                               uint8_t *aDest, long dstW, long chrDstW)

  48. {

  49.     int i;

  50.     for (i=0; i<dstW; i++) {

  51.         int val= (lumSrc[i]+64)>>7;

  52. 

  53.         if (val&256) {

  54.             if (val<0) val=0;

  55.             else       val=255;

  56.         }

  57. 

  58.         dest[i]= val;

  59.     }

  60. 

  61.     if (uDest)

  62.         for (i=0; i<chrDstW; i++) {

  63.             int u=(chrSrc[i       ]+64)>>7;

  64.             int v=(chrSrc[i + VOFW]+64)>>7;

  65. 

  66.             if ((u|v)&256) {

  67.                 if (u<0)        u=0;

  68.                 else if (u>255) u=255;

  69.                 if (v<0)        v=0;

  70.                 else if (v>255) v=255;

  71.             }

  72. 

  73.             uDest[i]= u;

  74.             vDest[i]= v;

  75.         }

  76. 

  77.     if (CONFIG_SWSCALE_ALPHA && aDest)

  78.         for (i=0; i<dstW; i++) {

  79.             int val= (alpSrc[i]+64)>>7;

  80.             aDest[i]= av_clip_uint8(val);

  81.         }

  82. }

  83. 

  84. 

  85. /**

  86.  * vertical scale YV12 to RGB

  87.  */

  88. static inline void yuv2packedX_c(SwsContext *c, const int16_t *lumFilter,

  89.                                  const int16_t **lumSrc, int lumFilterSize,

  90.                                  const int16_t *chrFilter, const int16_t **chrSrc,

  91.                                  int chrFilterSize, const int16_t **alpSrc,

  92.                                  uint8_t *dest, long dstW, long dstY)

  93. {

  94.         yuv2packedXinC(c, lumFilter, lumSrc, lumFilterSize,

  95.                        chrFilter, chrSrc, chrFilterSize,

  96.                        alpSrc, dest, dstW, dstY);

  97. }

  98. 

  99. /**

  100.  * vertical bilinear scale YV12 to RGB

  101.  */

  102. static inline void yuv2packed2_c(SwsContext *c, const uint16_t *buf0,

  103.                                  const uint16_t *buf1, const uint16_t *uvbuf0,

  104.                                  const uint16_t *uvbuf1, const uint16_t *abuf0,

  105.                                  const uint16_t *abuf1, uint8_t *dest, int dstW,

  106.                                  int yalpha, int uvalpha, int y)

  107. {

  108.     int  yalpha1=4095- yalpha;

  109.     int uvalpha1=4095-uvalpha;

  110.     int i;

  111. 

  112.     YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGB2_C, YSCALE_YUV_2_PACKED2_C(void,0), YSCALE_YUV_2_GRAY16_2_C, YSCALE_YUV_2_MONO2_C)

  113. }

  114. 

  115. /**

  116.  * YV12 to RGB without scaling or interpolating

  117.  */

  118. static inline void yuv2packed1_c(SwsContext *c, const uint16_t *buf0,

  119.                                  const uint16_t *uvbuf0, const uint16_t *uvbuf1,

  120.                                  const uint16_t *abuf0, uint8_t *dest, int dstW,

  121.                                  int uvalpha, enum PixelFormat dstFormat,

  122.                                  int flags, int y)

  123. {

  124.     const int yalpha1=0;

  125.     int i;

  126. 

  127.     const uint16_t *buf1= buf0; //FIXME needed for RGB1/BGR1

  128.     const int yalpha= 4096; //FIXME ...

  129. 

  130.     if (flags&SWS_FULL_CHR_H_INT) {

  131.         c->yuv2packed2(c, buf0, buf0, uvbuf0, uvbuf1, abuf0, abuf0, dest, dstW, 0, uvalpha, y);

  132.         return;

  133.     }

  134. 

  135.     if (uvalpha < 2048) {

  136.         YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGB1_C, YSCALE_YUV_2_PACKED1_C(void,0), YSCALE_YUV_2_GRAY16_1_C, YSCALE_YUV_2_MONO2_C)

  137.     } else {

  138.         YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGB1B_C, YSCALE_YUV_2_PACKED1B_C(void,0), YSCALE_YUV_2_GRAY16_1_C, YSCALE_YUV_2_MONO2_C)

  139.     }

  140. }

  141. 

  142. //FIXME yuy2* can read up to 7 samples too much

  143. 

  144. static inline void yuy2ToY_c(uint8_t *dst, const uint8_t *src, long width,

  145.                              uint32_t *unused)

  146. {

  147.     int i;

  148.     for (i=0; i<width; i++)

  149.         dst[i]= src[2*i];

  150. }

  151. 

  152. static inline void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  153.                               const uint8_t *src2, long width, uint32_t *unused)

  154. {

  155.     int i;

  156.     for (i=0; i<width; i++) {

  157.         dstU[i]= src1[4*i + 1];

  158.         dstV[i]= src1[4*i + 3];

  159.     }

  160.     assert(src1 == src2);

  161. }

  162. 

  163. static inline void LEToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  164.                             const uint8_t *src2, long width, uint32_t *unused)

  165. {

  166.     int i;

  167.     for (i=0; i<width; i++) {

  168.         dstU[i]= src1[2*i + 1];

  169.         dstV[i]= src2[2*i + 1];

  170.     }

  171. }

  172. 

  173. /* This is almost identical to the previous, end exists only because

  174.  * yuy2ToY/UV)(dst, src+1, ...) would have 100% unaligned accesses. */

  175. static inline void uyvyToY_c(uint8_t *dst, const uint8_t *src, long width,

  176.                              uint32_t *unused)

  177. {

  178.     int i;

  179.     for (i=0; i<width; i++)

  180.         dst[i]= src[2*i+1];

  181. }

  182. 

  183. static inline void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  184.                               const uint8_t *src2, long width, uint32_t *unused)

  185. {

  186.     int i;

  187.     for (i=0; i<width; i++) {

  188.         dstU[i]= src1[4*i + 0];

  189.         dstV[i]= src1[4*i + 2];

  190.     }

  191.     assert(src1 == src2);

  192. }

  193. 

  194. static inline void BEToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  195.                             const uint8_t *src2, long width, uint32_t *unused)

  196. {

  197.     int i;

  198.     for (i=0; i<width; i++) {

  199.         dstU[i]= src1[2*i];

  200.         dstV[i]= src2[2*i];

  201.     }

  202. }

  203. 

  204. static inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,

  205.                               const uint8_t *src, long width)

  206. {

  207.     int i;

  208.     for (i = 0; i < width; i++) {

  209.         dst1[i] = src[2*i+0];

  210.         dst2[i] = src[2*i+1];

  211.     }

  212. }

  213. 

  214. static inline void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,

  215.                               const uint8_t *src1, const uint8_t *src2,

  216.                               long width, uint32_t *unused)

  217. {

  218.     nvXXtoUV_c(dstU, dstV, src1, width);

  219. }

  220. 

  221. static inline void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,

  222.                               const uint8_t *src1, const uint8_t *src2,

  223.                               long width, uint32_t *unused)

  224. {

  225.     nvXXtoUV_c(dstV, dstU, src1, width);

  226. }

  227. 

  228. // FIXME Maybe dither instead.

  229. #define YUV_NBPS(depth) \

  230. static inline void yuv ## depth ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \

  231.                                           const uint8_t *_srcU, const uint8_t *_srcV, \

  232.                                           long width, uint32_t *unused) \

  233. { \

  234.     int i; \

  235.     const uint16_t *srcU = (const uint16_t*)_srcU; \

  236.     const uint16_t *srcV = (const uint16_t*)_srcV; \

  237.     for (i = 0; i < width; i++) { \

  238.         dstU[i] = srcU[i]>>(depth-8); \

  239.         dstV[i] = srcV[i]>>(depth-8); \

  240.     } \

  241. } \

  242. \

  243. static inline void yuv ## depth ## ToY_c(uint8_t *dstY, const uint8_t *_srcY, long width, uint32_t *unused) \

  244. { \

  245.     int i; \

  246.     const uint16_t *srcY = (const uint16_t*)_srcY; \

  247.     for (i = 0; i < width; i++) \

  248.         dstY[i] = srcY[i]>>(depth-8); \

  249. } \

  250. 

  251. YUV_NBPS( 9)

  252. YUV_NBPS(10)

  253. 

  254. static inline void bgr24ToY_c(uint8_t *dst, const uint8_t *src,

  255.                               long width, uint32_t *unused)

  256. {

  257.     int i;

  258.     for (i=0; i<width; i++) {

  259.         int b= src[i*3+0];

  260.         int g= src[i*3+1];

  261.         int r= src[i*3+2];

  262. 

  263.         dst[i]= ((RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);

  264.     }

  265. }

  266. 

  267. static inline void bgr24ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  268.                                const uint8_t *src2, long width, uint32_t *unused)

  269. {

  270.     int i;

  271.     for (i=0; i<width; i++) {

  272.         int b= src1[3*i + 0];

  273.         int g= src1[3*i + 1];

  274.         int r= src1[3*i + 2];

  275. 

  276.         dstU[i]= (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;

  277.         dstV[i]= (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;

  278.     }

  279.     assert(src1 == src2);

  280. }

  281. 

  282. static inline void bgr24ToUV_half_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  283.                                     const uint8_t *src2, long width, uint32_t *unused)

  284. {

  285.     int i;

  286.     for (i=0; i<width; i++) {

  287.         int b= src1[6*i + 0] + src1[6*i + 3];

  288.         int g= src1[6*i + 1] + src1[6*i + 4];

  289.         int r= src1[6*i + 2] + src1[6*i + 5];

  290. 

  291.         dstU[i]= (RU*r + GU*g + BU*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

  292.         dstV[i]= (RV*r + GV*g + BV*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

  293.     }

  294.     assert(src1 == src2);

  295. }

  296. 

  297. static inline void rgb24ToY_c(uint8_t *dst, const uint8_t *src, long width,

  298.                               uint32_t *unused)

  299. {

  300.     int i;

  301.     for (i=0; i<width; i++) {

  302.         int r= src[i*3+0];

  303.         int g= src[i*3+1];

  304.         int b= src[i*3+2];

  305. 

  306.         dst[i]= ((RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);

  307.     }

  308. }

  309. 

  310. static inline void rgb24ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  311.                                const uint8_t *src2, long width, uint32_t *unused)

  312. {

  313.     int i;

  314.     assert(src1==src2);

  315.     for (i=0; i<width; i++) {

  316.         int r= src1[3*i + 0];

  317.         int g= src1[3*i + 1];

  318.         int b= src1[3*i + 2];

  319. 

  320.         dstU[i]= (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;

  321.         dstV[i]= (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;

  322.     }

  323. }

  324. 

  325. static inline void rgb24ToUV_half_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  326.                                     const uint8_t *src2, long width, uint32_t *unused)

  327. {

  328.     int i;

  329.     assert(src1==src2);

  330.     for (i=0; i<width; i++) {

  331.         int r= src1[6*i + 0] + src1[6*i + 3];

  332.         int g= src1[6*i + 1] + src1[6*i + 4];

  333.         int b= src1[6*i + 2] + src1[6*i + 5];

  334. 

  335.         dstU[i]= (RU*r + GU*g + BU*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

  336.         dstV[i]= (RV*r + GV*g + BV*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

  337.     }

  338. }

  339. 

  340. 

  341. // bilinear / bicubic scaling

  342. static inline void hScale_c(int16_t *dst, int dstW, const uint8_t *src,

  343.                             int srcW, int xInc,

  344.                             const int16_t *filter, const int16_t *filterPos,

  345.                             long filterSize)

  346. {

  347.     int i;

  348.     for (i=0; i<dstW; i++) {

  349.         int j;

  350.         int srcPos= filterPos[i];

  351.         int val=0;

  352.         //printf("filterPos: %d\n", filterPos[i]);

  353.         for (j=0; j<filterSize; j++) {

  354.             //printf("filter: %d, src: %d\n", filter[i], src[srcPos + j]);

  355.             val += ((int)src[srcPos + j])*filter[filterSize*i + j];

  356.         }

  357.         //filter += hFilterSize;

  358.         dst[i] = FFMIN(val>>7, (1<<15)-1); // the cubic equation does overflow ...

  359.         //dst[i] = val>>7;

  360.     }

  361. }

  362. 

  363. //FIXME all pal and rgb srcFormats could do this convertion as well

  364. //FIXME all scalers more complex than bilinear could do half of this transform

  365. static void chrRangeToJpeg_c(uint16_t *dst, int width)

  366. {

  367.     int i;

  368.     for (i = 0; i < width; i++) {

  369.         dst[i     ] = (FFMIN(dst[i     ],30775)*4663 - 9289992)>>12; //-264

  370.         dst[i+VOFW] = (FFMIN(dst[i+VOFW],30775)*4663 - 9289992)>>12; //-264

  371.     }

  372. }

  373. static void chrRangeFromJpeg_c(uint16_t *dst, int width)

  374. {

  375.     int i;

  376.     for (i = 0; i < width; i++) {

  377.         dst[i     ] = (dst[i     ]*1799 + 4081085)>>11; //1469

  378.         dst[i+VOFW] = (dst[i+VOFW]*1799 + 4081085)>>11; //1469

  379.     }

  380. }

  381. static void lumRangeToJpeg_c(uint16_t *dst, int width)

  382. {

  383.     int i;

  384.     for (i = 0; i < width; i++)

  385.         dst[i] = (FFMIN(dst[i],30189)*19077 - 39057361)>>14;

  386. }

  387. static void lumRangeFromJpeg_c(uint16_t *dst, int width)

  388. {

  389.     int i;

  390.     for (i = 0; i < width; i++)

  391.         dst[i] = (dst[i]*14071 + 33561947)>>14;

  392. }

  393. 

  394. static inline void hyscale_fast_c(SwsContext *c, int16_t *dst, long dstWidth,

  395.                                   const uint8_t *src, int srcW, int xInc)

  396. {

  397.     int i;

  398.     unsigned int xpos=0;

  399.     for (i=0;i<dstWidth;i++) {

  400.         register unsigned int xx=xpos>>16;

  401.         register unsigned int xalpha=(xpos&0xFFFF)>>9;

  402.         dst[i]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;

  403.         xpos+=xInc;

  404.     }

  405. }

  406. 

  407.       // *** horizontal scale Y line to temp buffer

  408. static inline void hyscale_c(SwsContext *c, uint16_t *dst, long dstWidth,

  409.                              const uint8_t *src, int srcW, int xInc,

  410.                              const int16_t *hLumFilter,

  411.                              const int16_t *hLumFilterPos, int hLumFilterSize,

  412.                              uint8_t *formatConvBuffer,

  413.                              uint32_t *pal, int isAlpha)

  414. {

  415.     void (*toYV12)(uint8_t *, const uint8_t *, long, uint32_t *) = isAlpha ? c->alpToYV12 : c->lumToYV12;

  416.     void (*convertRange)(uint16_t *, int) = isAlpha ? NULL : c->lumConvertRange;

  417. 

  418.     src += isAlpha ? c->alpSrcOffset : c->lumSrcOffset;

  419. 

  420.     if (toYV12) {

  421.         toYV12(formatConvBuffer, src, srcW, pal);

  422.         src= formatConvBuffer;

  423.     }

  424. 

  425.     if (!c->hyscale_fast) {

  426.         c->hScale(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);

  427.     } else { // fast bilinear upscale / crap downscale

  428.         c->hyscale_fast(c, dst, dstWidth, src, srcW, xInc);

  429.     }

  430. 

  431.     if (convertRange)

  432.         convertRange(dst, dstWidth);

  433. }

  434. 

  435. static inline void hcscale_fast_c(SwsContext *c, int16_t *dst,

  436.                                   long dstWidth, const uint8_t *src1,

  437.                                   const uint8_t *src2, int srcW, int xInc)

  438. {

  439.     int i;

  440.     unsigned int xpos=0;

  441.     for (i=0;i<dstWidth;i++) {

  442.         register unsigned int xx=xpos>>16;

  443.         register unsigned int xalpha=(xpos&0xFFFF)>>9;

  444.         dst[i]=(src1[xx]*(xalpha^127)+src1[xx+1]*xalpha);

  445.         dst[i+VOFW]=(src2[xx]*(xalpha^127)+src2[xx+1]*xalpha);

  446.         /* slower

  447.         dst[i]= (src1[xx]<<7) + (src1[xx+1] - src1[xx])*xalpha;

  448.         dst[i+VOFW]=(src2[xx]<<7) + (src2[xx+1] - src2[xx])*xalpha;

  449.         */

  450.         xpos+=xInc;

  451.     }

  452. }

  453. 

  454. inline static void hcscale_c(SwsContext *c, uint16_t *dst, long dstWidth,

  455.                              const uint8_t *src1, const uint8_t *src2,

  456.                              int srcW, int xInc, const int16_t *hChrFilter,

  457.                              const int16_t *hChrFilterPos, int hChrFilterSize,

  458.                              uint8_t *formatConvBuffer, uint32_t *pal)

  459. {

  460. 

  461.     src1 += c->chrSrcOffset;

  462.     src2 += c->chrSrcOffset;

  463. 

  464.     if (c->chrToYV12) {

  465.         c->chrToYV12(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);

  466.         src1= formatConvBuffer;

  467.         src2= formatConvBuffer+VOFW;

  468.     }

  469. 

  470.     if (!c->hcscale_fast) {

  471.         c->hScale(dst     , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);

  472.         c->hScale(dst+VOFW, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);

  473.     } else { // fast bilinear upscale / crap downscale

  474.         c->hcscale_fast(c, dst, dstWidth, src1, src2, srcW, xInc);

  475.     }

  476. 

  477.     if (c->chrConvertRange)

  478.         c->chrConvertRange(dst, dstWidth);

  479. }

  480. 

  481. #define DEBUG_SWSCALE_BUFFERS 0

  482. #define DEBUG_BUFFERS(...) if (DEBUG_SWSCALE_BUFFERS) av_log(c, AV_LOG_DEBUG, __VA_ARGS__)

  483. 

  484. static int swScale_c(SwsContext *c, const uint8_t* src[], int srcStride[],

  485.                      int srcSliceY, int srcSliceH, uint8_t* dst[], int dstStride[])

  486. {

  487.     /* load a few things into local vars to make the code more readable? and faster */

  488.     const int srcW= c->srcW;

  489.     const int dstW= c->dstW;

  490.     const int dstH= c->dstH;

  491.     const int chrDstW= c->chrDstW;

  492.     const int chrSrcW= c->chrSrcW;

  493.     const int lumXInc= c->lumXInc;

  494.     const int chrXInc= c->chrXInc;

  495.     const enum PixelFormat dstFormat= c->dstFormat;

  496.     const int flags= c->flags;

  497.     int16_t *vLumFilterPos= c->vLumFilterPos;

  498.     int16_t *vChrFilterPos= c->vChrFilterPos;

  499.     int16_t *hLumFilterPos= c->hLumFilterPos;

  500.     int16_t *hChrFilterPos= c->hChrFilterPos;

  501.     int16_t *vLumFilter= c->vLumFilter;

  502.     int16_t *vChrFilter= c->vChrFilter;

  503.     int16_t *hLumFilter= c->hLumFilter;

  504.     int16_t *hChrFilter= c->hChrFilter;

  505.     int32_t *lumMmxFilter= c->lumMmxFilter;

  506.     int32_t *chrMmxFilter= c->chrMmxFilter;

  507.     int32_t av_unused *alpMmxFilter= c->alpMmxFilter;

  508.     const int vLumFilterSize= c->vLumFilterSize;

  509.     const int vChrFilterSize= c->vChrFilterSize;

  510.     const int hLumFilterSize= c->hLumFilterSize;

  511.     const int hChrFilterSize= c->hChrFilterSize;

  512.     int16_t **lumPixBuf= c->lumPixBuf;

  513.     int16_t **chrPixBuf= c->chrPixBuf;

  514.     int16_t **alpPixBuf= c->alpPixBuf;

  515.     const int vLumBufSize= c->vLumBufSize;

  516.     const int vChrBufSize= c->vChrBufSize;

  517.     uint8_t *formatConvBuffer= c->formatConvBuffer;

  518.     const int chrSrcSliceY= srcSliceY >> c->chrSrcVSubSample;

  519.     const int chrSrcSliceH= -((-srcSliceH) >> c->chrSrcVSubSample);

  520.     int lastDstY;

  521.     uint32_t *pal=c->pal_yuv;

  522. 

  523.     /* vars which will change and which we need to store back in the context */

  524.     int dstY= c->dstY;

  525.     int lumBufIndex= c->lumBufIndex;

  526.     int chrBufIndex= c->chrBufIndex;

  527.     int lastInLumBuf= c->lastInLumBuf;

  528.     int lastInChrBuf= c->lastInChrBuf;

  529. 

  530.     if (isPacked(c->srcFormat)) {

  531.         src[0]=

  532.         src[1]=

  533.         src[2]=

  534.         src[3]= src[0];

  535.         srcStride[0]=

  536.         srcStride[1]=

  537.         srcStride[2]=

  538.         srcStride[3]= srcStride[0];

  539.     }

  540.     srcStride[1]<<= c->vChrDrop;

  541.     srcStride[2]<<= c->vChrDrop;

  542. 

  543.     DEBUG_BUFFERS("swScale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",

  544.                   src[0], srcStride[0], src[1], srcStride[1], src[2], srcStride[2], src[3], srcStride[3],

  545.                   dst[0], dstStride[0], dst[1], dstStride[1], dst[2], dstStride[2], dst[3], dstStride[3]);

  546.     DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d dstY: %d dstH: %d\n",

  547.                    srcSliceY,    srcSliceH,    dstY,    dstH);

  548.     DEBUG_BUFFERS("vLumFilterSize: %d vLumBufSize: %d vChrFilterSize: %d vChrBufSize: %d\n",

  549.                    vLumFilterSize,    vLumBufSize,    vChrFilterSize,    vChrBufSize);

  550. 

  551.     if (dstStride[0]%8 !=0 || dstStride[1]%8 !=0 || dstStride[2]%8 !=0 || dstStride[3]%8 != 0) {

  552.         static int warnedAlready=0; //FIXME move this into the context perhaps

  553.         if (flags & SWS_PRINT_INFO && !warnedAlready) {

  554.             av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"

  555.                    "         ->cannot do aligned memory accesses anymore\n");

  556.             warnedAlready=1;

  557.         }

  558.     }

  559. 

  560.     /* Note the user might start scaling the picture in the middle so this

  561.        will not get executed. This is not really intended but works

  562.        currently, so people might do it. */

  563.     if (srcSliceY ==0) {

  564.         lumBufIndex=-1;

  565.         chrBufIndex=-1;

  566.         dstY=0;

  567.         lastInLumBuf= -1;

  568.         lastInChrBuf= -1;

  569.     }

  570. 

  571.     lastDstY= dstY;

  572. 

  573.     for (;dstY < dstH; dstY++) {

  574.         unsigned char *dest =dst[0]+dstStride[0]*dstY;

  575.         const int chrDstY= dstY>>c->chrDstVSubSample;

  576.         unsigned char *uDest=dst[1]+dstStride[1]*chrDstY;

  577.         unsigned char *vDest=dst[2]+dstStride[2]*chrDstY;

  578.         unsigned char *aDest=(CONFIG_SWSCALE_ALPHA && alpPixBuf) ? dst[3]+dstStride[3]*dstY : NULL;

  579. 

  580.         const int firstLumSrcY= vLumFilterPos[dstY]; //First line needed as input

  581.         const int firstLumSrcY2= vLumFilterPos[FFMIN(dstY | ((1<<c->chrDstVSubSample) - 1), dstH-1)];

  582.         const int firstChrSrcY= vChrFilterPos[chrDstY]; //First line needed as input

  583.         int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; // Last line needed as input

  584.         int lastLumSrcY2=firstLumSrcY2+ vLumFilterSize -1; // Last line needed as input

  585.         int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; // Last line needed as input

  586.         int enough_lines;

  587. 

  588.         //handle holes (FAST_BILINEAR & weird filters)

  589.         if (firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;

  590.         if (firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1;

  591.         assert(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1);

  592.         assert(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1);

  593. 

  594.         DEBUG_BUFFERS("dstY: %d\n", dstY);

  595.         DEBUG_BUFFERS("\tfirstLumSrcY: %d lastLumSrcY: %d lastInLumBuf: %d\n",

  596.                          firstLumSrcY,    lastLumSrcY,    lastInLumBuf);

  597.         DEBUG_BUFFERS("\tfirstChrSrcY: %d lastChrSrcY: %d lastInChrBuf: %d\n",

  598.                          firstChrSrcY,    lastChrSrcY,    lastInChrBuf);

  599. 

  600.         // Do we have enough lines in this slice to output the dstY line

  601.         enough_lines = lastLumSrcY2 < srcSliceY + srcSliceH && lastChrSrcY < -((-srcSliceY - srcSliceH)>>c->chrSrcVSubSample);

  602. 

  603.         if (!enough_lines) {

  604.             lastLumSrcY = srcSliceY + srcSliceH - 1;

  605.             lastChrSrcY = chrSrcSliceY + chrSrcSliceH - 1;

  606.             DEBUG_BUFFERS("buffering slice: lastLumSrcY %d lastChrSrcY %d\n",

  607.                                             lastLumSrcY, lastChrSrcY);

  608.         }

  609. 

  610.         //Do horizontal scaling

  611.         while(lastInLumBuf < lastLumSrcY) {

  612.             const uint8_t *src1= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];

  613.             const uint8_t *src2= src[3]+(lastInLumBuf + 1 - srcSliceY)*srcStride[3];

  614.             lumBufIndex++;

  615.             assert(lumBufIndex < 2*vLumBufSize);

  616.             assert(lastInLumBuf + 1 - srcSliceY < srcSliceH);

  617.             assert(lastInLumBuf + 1 - srcSliceY >= 0);

  618.             hyscale_c(c, lumPixBuf[ lumBufIndex ], dstW, src1, srcW, lumXInc,

  619.                       hLumFilter, hLumFilterPos, hLumFilterSize,

  620.                       formatConvBuffer,

  621.                       pal, 0);

  622.             if (CONFIG_SWSCALE_ALPHA && alpPixBuf)

  623.                 hyscale_c(c, alpPixBuf[ lumBufIndex ], dstW, src2, srcW,

  624.                           lumXInc, hLumFilter, hLumFilterPos, hLumFilterSize,

  625.                           formatConvBuffer,

  626.                           pal, 1);

  627.             lastInLumBuf++;

  628.             DEBUG_BUFFERS("\t\tlumBufIndex %d: lastInLumBuf: %d\n",

  629.                                lumBufIndex,    lastInLumBuf);

  630.         }

  631.         while(lastInChrBuf < lastChrSrcY) {

  632.             const uint8_t *src1= src[1]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[1];

  633.             const uint8_t *src2= src[2]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[2];

  634.             chrBufIndex++;

  635.             assert(chrBufIndex < 2*vChrBufSize);

  636.             assert(lastInChrBuf + 1 - chrSrcSliceY < (chrSrcSliceH));

  637.             assert(lastInChrBuf + 1 - chrSrcSliceY >= 0);

  638.             //FIXME replace parameters through context struct (some at least)

  639. 

  640.             if (c->needs_hcscale)

  641.                 hcscale_c(c, chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,

  642.                                 hChrFilter, hChrFilterPos, hChrFilterSize,

  643.                                 formatConvBuffer,

  644.                                 pal);

  645.             lastInChrBuf++;

  646.             DEBUG_BUFFERS("\t\tchrBufIndex %d: lastInChrBuf: %d\n",

  647.                                chrBufIndex,    lastInChrBuf);

  648.         }

  649.         //wrap buf index around to stay inside the ring buffer

  650.         if (lumBufIndex >= vLumBufSize) lumBufIndex-= vLumBufSize;

  651.         if (chrBufIndex >= vChrBufSize) chrBufIndex-= vChrBufSize;

  652.         if (!enough_lines)

  653.             break; //we can't output a dstY line so let's try with the next slice

  654. 

  655.         if (dstY < dstH-2) {

  656.             const int16_t **lumSrcPtr= (const int16_t **) lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

  657.             const int16_t **chrSrcPtr= (const int16_t **) chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

  658.             const int16_t **alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **) alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;

  659.             if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21) {

  660.                 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

  661.                 if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi

  662.                 c->yuv2nv12X(c,

  663.                              vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

  664.                              vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  665.                              dest, uDest, dstW, chrDstW, dstFormat);

  666.             } else if (isPlanarYUV(dstFormat) || dstFormat==PIX_FMT_GRAY8) { //YV12 like

  667.                 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

  668.                 if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi

  669.                 if (is16BPS(dstFormat)) {

  670.                     yuv2yuvX16inC(

  671.                                   vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

  672.                                   vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  673.                                   alpSrcPtr, (uint16_t *) dest, (uint16_t *) uDest, (uint16_t *) vDest, (uint16_t *) aDest, dstW, chrDstW,

  674.                                   dstFormat);

  675.                 } else if (vLumFilterSize == 1 && vChrFilterSize == 1) { // unscaled YV12

  676.                     const int16_t *lumBuf = lumSrcPtr[0];

  677.                     const int16_t *chrBuf= chrSrcPtr[0];

  678.                     const int16_t *alpBuf= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? alpSrcPtr[0] : NULL;

  679.                     c->yuv2yuv1(c, lumBuf, chrBuf, alpBuf, dest, uDest, vDest, aDest, dstW, chrDstW);

  680.                 } else { //General YV12

  681.                     c->yuv2yuvX(c,

  682.                                 vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

  683.                                 vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  684.                                 alpSrcPtr, dest, uDest, vDest, aDest, dstW, chrDstW);

  685.                 }

  686.             } else {

  687.                 assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

  688.                 assert(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

  689.                 if (vLumFilterSize == 1 && vChrFilterSize == 2) { //unscaled RGB

  690.                     int chrAlpha= vChrFilter[2*dstY+1];

  691.                     if(flags & SWS_FULL_CHR_H_INT) {

  692.                         yuv2rgbXinC_full(c, //FIXME write a packed1_full function

  693.                                          vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

  694.                                          vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  695.                                          alpSrcPtr, dest, dstW, dstY);

  696.                     } else {

  697.                         c->yuv2packed1(c, *lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),

  698.                                        alpPixBuf ? *alpSrcPtr : NULL,

  699.                                        dest, dstW, chrAlpha, dstFormat, flags, dstY);

  700.                     }

  701.                 } else if (vLumFilterSize == 2 && vChrFilterSize == 2) { //bilinear upscale RGB

  702.                     int lumAlpha= vLumFilter[2*dstY+1];

  703.                     int chrAlpha= vChrFilter[2*dstY+1];

  704.                     lumMmxFilter[2]=

  705.                     lumMmxFilter[3]= vLumFilter[2*dstY   ]*0x10001;

  706.                     chrMmxFilter[2]=

  707.                     chrMmxFilter[3]= vChrFilter[2*chrDstY]*0x10001;

  708.                     if(flags & SWS_FULL_CHR_H_INT) {

  709.                         yuv2rgbXinC_full(c, //FIXME write a packed2_full function

  710.                                          vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

  711.                                          vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  712.                                          alpSrcPtr, dest, dstW, dstY);

  713.                     } else {

  714.                         c->yuv2packed2(c, *lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),

  715.                                        alpPixBuf ? *alpSrcPtr : NULL, alpPixBuf ? *(alpSrcPtr+1) : NULL,

  716.                                        dest, dstW, lumAlpha, chrAlpha, dstY);

  717.                     }

  718.                 } else { //general RGB

  719.                     if(flags & SWS_FULL_CHR_H_INT) {

  720.                         yuv2rgbXinC_full(c,

  721.                                          vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

  722.                                          vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  723.                                          alpSrcPtr, dest, dstW, dstY);

  724.                     } else {

  725.                         c->yuv2packedX(c,

  726.                                        vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

  727.                                        vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  728.                                        alpSrcPtr, dest, dstW, dstY);

  729.                     }

  730.                 }

  731.             }

  732.         } else { // hmm looks like we can't use MMX here without overwriting this array's tail

  733.             const int16_t **lumSrcPtr= (const int16_t **)lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

  734.             const int16_t **chrSrcPtr= (const int16_t **)chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

  735.             const int16_t **alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **)alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;

  736.             if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21) {

  737.                 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

  738.                 if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi

  739.                 yuv2nv12XinC(

  740.                              vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

  741.                              vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  742.                              dest, uDest, dstW, chrDstW, dstFormat);

  743.             } else if (isPlanarYUV(dstFormat) || dstFormat==PIX_FMT_GRAY8) { //YV12

  744.                 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

  745.                 if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi

  746.                 if (is16BPS(dstFormat)) {

  747.                     yuv2yuvX16inC(

  748.                                   vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

  749.                                   vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  750.                                   alpSrcPtr, (uint16_t *) dest, (uint16_t *) uDest, (uint16_t *) vDest, (uint16_t *) aDest, dstW, chrDstW,

  751.                                   dstFormat);

  752.                 } else {

  753.                     yuv2yuvXinC(

  754.                                 vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

  755.                                 vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  756.                                 alpSrcPtr, dest, uDest, vDest, aDest, dstW, chrDstW);

  757.                 }

  758.             } else {

  759.                 assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

  760.                 assert(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

  761.                 if(flags & SWS_FULL_CHR_H_INT) {

  762.                     yuv2rgbXinC_full(c,

  763.                                      vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

  764.                                      vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  765.                                      alpSrcPtr, dest, dstW, dstY);

  766.                 } else {

  767.                     yuv2packedXinC(c,

  768.                                    vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

  769.                                    vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  770.                                    alpSrcPtr, dest, dstW, dstY);

  771.                 }

  772.             }

  773.         }

  774.     }

  775. 

  776.     if ((dstFormat == PIX_FMT_YUVA420P) && !alpPixBuf)

  777.         fillPlane(dst[3], dstStride[3], dstW, dstY-lastDstY, lastDstY, 255);

  778. 

  779.     /* store changed local vars back in the context */

  780.     c->dstY= dstY;

  781.     c->lumBufIndex= lumBufIndex;

  782.     c->chrBufIndex= chrBufIndex;

  783.     c->lastInLumBuf= lastInLumBuf;

  784.     c->lastInChrBuf= lastInChrBuf;

  785. 

  786.     return dstY - lastDstY;

  787. }

  788. 

  789. static void sws_init_swScale_c(SwsContext *c)

  790. {

  791.     enum PixelFormat srcFormat = c->srcFormat;

  792. 

  793.     c->yuv2nv12X    = yuv2nv12X_c;

  794.     c->yuv2yuv1     = yuv2yuv1_c;

  795.     c->yuv2yuvX     = yuv2yuvX_c;

  796.     c->yuv2packed1  = yuv2packed1_c;

  797.     c->yuv2packed2  = yuv2packed2_c;

  798.     c->yuv2packedX  = yuv2packedX_c;

  799. 

  800.     c->hScale       = hScale_c;

  801. 

  802.     if (c->flags & SWS_FAST_BILINEAR)

  803.     {

  804.         c->hyscale_fast = hyscale_fast_c;

  805.         c->hcscale_fast = hcscale_fast_c;

  806.     }

  807. 

  808.     c->chrToYV12 = NULL;

  809.     switch(srcFormat) {

  810.         case PIX_FMT_YUYV422  : c->chrToYV12 = yuy2ToUV_c; break;

  811.         case PIX_FMT_UYVY422  : c->chrToYV12 = uyvyToUV_c; break;

  812.         case PIX_FMT_NV12     : c->chrToYV12 = nv12ToUV_c; break;

  813.         case PIX_FMT_NV21     : c->chrToYV12 = nv21ToUV_c; break;

  814.         case PIX_FMT_RGB8     :

  815.         case PIX_FMT_BGR8     :

  816.         case PIX_FMT_PAL8     :

  817.         case PIX_FMT_BGR4_BYTE:

  818.         case PIX_FMT_RGB4_BYTE: c->chrToYV12 = palToUV; break;

  819.         case PIX_FMT_YUV420P9BE:

  820.         case PIX_FMT_YUV420P9LE: c->chrToYV12 = yuv9ToUV_c; break;

  821.         case PIX_FMT_YUV420P10BE:

  822.         case PIX_FMT_YUV420P10LE: c->chrToYV12 = yuv10ToUV_c; break;

  823.         case PIX_FMT_YUV420P16BE:

  824.         case PIX_FMT_YUV422P16BE:

  825.         case PIX_FMT_YUV444P16BE: c->chrToYV12 = BEToUV_c; break;

  826.         case PIX_FMT_YUV420P16LE:

  827.         case PIX_FMT_YUV422P16LE:

  828.         case PIX_FMT_YUV444P16LE: c->chrToYV12 = LEToUV_c; break;

  829.     }

  830.     if (c->chrSrcHSubSample) {

  831.         switch(srcFormat) {

  832.         case PIX_FMT_RGB48BE:

  833.         case PIX_FMT_RGB48LE: c->chrToYV12 = rgb48ToUV_half; break;

  834.         case PIX_FMT_BGR48BE:

  835.         case PIX_FMT_BGR48LE: c->chrToYV12 = bgr48ToUV_half; break;

  836.         case PIX_FMT_RGB32  : c->chrToYV12 = bgr32ToUV_half;  break;

  837.         case PIX_FMT_RGB32_1: c->chrToYV12 = bgr321ToUV_half; break;

  838.         case PIX_FMT_BGR24  : c->chrToYV12 = bgr24ToUV_half_c; break;

  839.         case PIX_FMT_BGR565 : c->chrToYV12 = bgr16ToUV_half; break;

  840.         case PIX_FMT_BGR555 : c->chrToYV12 = bgr15ToUV_half; break;

  841.         case PIX_FMT_BGR32  : c->chrToYV12 = rgb32ToUV_half;  break;

  842.         case PIX_FMT_BGR32_1: c->chrToYV12 = rgb321ToUV_half; break;

  843.         case PIX_FMT_RGB24  : c->chrToYV12 = rgb24ToUV_half_c; break;

  844.         case PIX_FMT_RGB565 : c->chrToYV12 = rgb16ToUV_half; break;

  845.         case PIX_FMT_RGB555 : c->chrToYV12 = rgb15ToUV_half; break;

  846.         }

  847.     } else {

  848.         switch(srcFormat) {

  849.         case PIX_FMT_RGB48BE:

  850.         case PIX_FMT_RGB48LE: c->chrToYV12 = rgb48ToUV; break;

  851.         case PIX_FMT_BGR48BE:

  852.         case PIX_FMT_BGR48LE: c->chrToYV12 = bgr48ToUV; break;

  853.         case PIX_FMT_RGB32  : c->chrToYV12 = bgr32ToUV;  break;

  854.         case PIX_FMT_RGB32_1: c->chrToYV12 = bgr321ToUV; break;

  855.         case PIX_FMT_BGR24  : c->chrToYV12 = bgr24ToUV_c; break;

  856.         case PIX_FMT_BGR565 : c->chrToYV12 = bgr16ToUV; break;

  857.         case PIX_FMT_BGR555 : c->chrToYV12 = bgr15ToUV; break;

  858.         case PIX_FMT_BGR32  : c->chrToYV12 = rgb32ToUV;  break;

  859.         case PIX_FMT_BGR32_1: c->chrToYV12 = rgb321ToUV; break;

  860.         case PIX_FMT_RGB24  : c->chrToYV12 = rgb24ToUV_c; break;

  861.         case PIX_FMT_RGB565 : c->chrToYV12 = rgb16ToUV; break;

  862.         case PIX_FMT_RGB555 : c->chrToYV12 = rgb15ToUV; break;

  863.         }

  864.     }

  865. 

  866.     c->lumToYV12 = NULL;

  867.     c->alpToYV12 = NULL;

  868.     switch (srcFormat) {

  869.     case PIX_FMT_YUV420P9BE:

  870.     case PIX_FMT_YUV420P9LE: c->lumToYV12 = yuv9ToY_c; break;

  871.     case PIX_FMT_YUV420P10BE:

  872.     case PIX_FMT_YUV420P10LE: c->lumToYV12 = yuv10ToY_c; break;

  873.     case PIX_FMT_YUYV422  :

  874.     case PIX_FMT_YUV420P16BE:

  875.     case PIX_FMT_YUV422P16BE:

  876.     case PIX_FMT_YUV444P16BE:

  877.     case PIX_FMT_Y400A    :

  878.     case PIX_FMT_GRAY16BE : c->lumToYV12 = yuy2ToY_c; break;

  879.     case PIX_FMT_UYVY422  :

  880.     case PIX_FMT_YUV420P16LE:

  881.     case PIX_FMT_YUV422P16LE:

  882.     case PIX_FMT_YUV444P16LE:

  883.     case PIX_FMT_GRAY16LE : c->lumToYV12 = uyvyToY_c; break;

  884.     case PIX_FMT_BGR24    : c->lumToYV12 = bgr24ToY_c; break;

  885.     case PIX_FMT_BGR565   : c->lumToYV12 = bgr16ToY; break;

  886.     case PIX_FMT_BGR555   : c->lumToYV12 = bgr15ToY; break;

  887.     case PIX_FMT_RGB24    : c->lumToYV12 = rgb24ToY_c; break;

  888.     case PIX_FMT_RGB565   : c->lumToYV12 = rgb16ToY; break;

  889.     case PIX_FMT_RGB555   : c->lumToYV12 = rgb15ToY; break;

  890.     case PIX_FMT_RGB8     :

  891.     case PIX_FMT_BGR8     :

  892.     case PIX_FMT_PAL8     :

  893.     case PIX_FMT_BGR4_BYTE:

  894.     case PIX_FMT_RGB4_BYTE: c->lumToYV12 = palToY; break;

  895.     case PIX_FMT_MONOBLACK: c->lumToYV12 = monoblack2Y; break;

  896.     case PIX_FMT_MONOWHITE: c->lumToYV12 = monowhite2Y; break;

  897.     case PIX_FMT_RGB32  : c->lumToYV12 = bgr32ToY;  break;

  898.     case PIX_FMT_RGB32_1: c->lumToYV12 = bgr321ToY; break;

  899.     case PIX_FMT_BGR32  : c->lumToYV12 = rgb32ToY;  break;

  900.     case PIX_FMT_BGR32_1: c->lumToYV12 = rgb321ToY; break;

  901.     case PIX_FMT_RGB48BE:

  902.     case PIX_FMT_RGB48LE: c->lumToYV12 = rgb48ToY; break;

  903.     case PIX_FMT_BGR48BE:

  904.     case PIX_FMT_BGR48LE: c->lumToYV12 = bgr48ToY; break;

  905.     }

  906.     if (c->alpPixBuf) {

  907.         switch (srcFormat) {

  908.         case PIX_FMT_RGB32  :

  909.         case PIX_FMT_RGB32_1:

  910.         case PIX_FMT_BGR32  :

  911.         case PIX_FMT_BGR32_1: c->alpToYV12 = abgrToA; break;

  912.         case PIX_FMT_Y400A  : c->alpToYV12 = yuy2ToY_c; break;

  913.         }

  914.     }

  915. 

  916.     switch (srcFormat) {

  917.     case PIX_FMT_Y400A  :

  918.         c->alpSrcOffset = 1;

  919.         break;

  920.     case PIX_FMT_RGB32  :

  921.     case PIX_FMT_BGR32  :

  922.         c->alpSrcOffset = 3;

  923.         break;

  924.     case PIX_FMT_RGB48LE:

  925.     case PIX_FMT_BGR48LE:

  926.         c->lumSrcOffset = 1;

  927.         c->chrSrcOffset = 1;

  928.         c->alpSrcOffset = 1;

  929.         break;

  930.     }

  931. 

  932.     if (c->srcRange != c->dstRange && !isAnyRGB(c->dstFormat)) {

  933.         if (c->srcRange) {

  934.             c->lumConvertRange = lumRangeFromJpeg_c;

  935.             c->chrConvertRange = chrRangeFromJpeg_c;

  936.         } else {

  937.             c->lumConvertRange = lumRangeToJpeg_c;

  938.             c->chrConvertRange = chrRangeToJpeg_c;

  939.         }

  940.     }

  941. 

  942.     if (!(isGray(srcFormat) || isGray(c->dstFormat) ||

  943.           srcFormat == PIX_FMT_MONOBLACK || srcFormat == PIX_FMT_MONOWHITE))

  944.         c->needs_hcscale = 1;

  945. }