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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
yuv2yuv.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：144k
源码类别：

Symbian

开发平台：

C/C++

yuv2yuv.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. /*** #includes: ********************************************/
  38. #include "hxassert.h"
  40. #include "env.h"
  41. #include "yuv.h"    /* YUV-to-RGB conversion tables & macros */
  42. #include "clip.h"   /* macros for clipping & dithering */
  44. #include "hxassert.h"
  45. #include "colorlib.h"
  48. int PackedYUVMemcpyWithPitch( unsigned char *dest_ptr,
  49.                               int dest_width, int dest_height,
  50.                               int dest_pitch,
  51.                               int dest_x, int dest_y, int dest_dx, int dest_dy,
  52.                               unsigned char *src_ptr,
  53.                               int src_width, int src_height, int src_pitch,
  54.                               int src_x, int src_y, int src_dx, int src_dy);
  56. /*** YUV to YUV color converters: **************************/
  58. /*
  59.  * These functions were borrowed from our "old" color conversion library,
  60.  * and they do not support things like stretching or color adjustments.
  61.  * Given some more time this module should be completely rewritten.
  62.  *
  63.  ***************/
  65. static int YUY2toPlanarYUV(unsigned char *dY, unsigned char *dU, unsigned char *dV,
  66.                            int dest_width, int dest_height,
  67.                            int dyPitch, int duPitch, int dvPitch,
  68.                            int dest_x, int dest_y, int dest_dx, int dest_dy,
  69.                            unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  70.                            int src_x, int src_y, int src_dx, int src_dy);
  72. static int UYVYtoPlanarYUV(unsigned char *dY, unsigned char *dU, unsigned char *dV,
  73.                            int dest_width, int dest_height,
  74.                            int dyPitch, int duPitch, int dvPitch,
  75.                            int dest_x, int dest_y, int dest_dx, int dest_dy,
  76.                            unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  77.                            int src_x, int src_y, int src_dx, int src_dy);
  78. /*
  79.  * Checks format conversion parameters.
  80.  * Use:
  81.  *  int chk_args (unsigned char *dest_ptr, int dest_width, int dest_height,
  82.  *      int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  83.  *      unsigned char *src_ptr, int src_width, int src_height,
  84.  *      int src_pitch, int src_x, int src_y, int src_dx, int src_dy,
  85.  *      int *p_scale_x, int *p_scale_y);
  86.  * Input:
  87.  *  dest_ptr - pointer to a destination buffer
  88.  *  dest_width, dest_height - width/height of the destination image (pixels)
  89.  *  dest_pitch - pitch of the dest. buffer (in bytes; <0 - if bottom up image)
  90.  *  dest_x, dest_y, dest_dx, dest_dy - destination rectangle (pixels)
  91.  *  src_ptr - pointer to an input image
  92.  *  src_width, src_height - width/height of the input image (pixels)
  93.  *  src_pitch - pitch of the source buffer (in bytes; <0 - if bottom up image)
  94.  *  src_x, src_y, src_dx, src_dy - source rectangle (pixels)
  95.  * Output:
  96.  *  p_scale_x, p_scale_y - scale factors for x,y axes
  97.  *      (currently only 1:1, and 2:1 scale factors are allowed)
  98.  * Returns:
  99.  *  0 - if success; -1 if failure.
  100.  */
  101. static int
  102. chk_args (unsigned char *dest_ptr, int dest_width, int dest_height,
  103.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  104.     unsigned char *src_ptr, int src_width, int src_height,
  105.     int src_pitch, int src_x, int src_y, int src_dx, int src_dy,
  106.     int *p_scale_x, int *p_scale_y)
  107. {
  108.     /* alignments: */
  109.     if (((unsigned)dest_ptr & 3) || (dest_pitch & 3) ||
  110.         ((unsigned)src_ptr  & 3) || (src_pitch  & 3) ||
  111.     /* image sizes: */
  112.         dest_width <= 0 || dest_height <= 0 ||
  113.         src_width  <= 0 || src_height  <= 0 ||
  114.     /* rectangles: */
  115.         dest_x < 0 || dest_y < 0 || dest_dx <= 0 || dest_dy <= 0 ||
  116.         src_x  < 0 || src_y  < 0 || src_dx  <= 0 || src_dy  <= 0 ||
  117.     /* overlaps: */
  118.         dest_width < dest_x + dest_dx || dest_height < dest_y + dest_dy ||
  119.         src_width  < src_x  + src_dx  || src_height  < src_y  + src_dy)
  120.         goto fail;
  122.     /* scale factors: */
  123.     if (dest_dx == src_dx)          *p_scale_x = 1;
  124.     else if (dest_dx == 2 * src_dx) *p_scale_x = 2;
  125.     else goto fail;
  126.     if (dest_dy == src_dy)          *p_scale_y = 1;
  127.     else if (dest_dy == 2 * src_dy) *p_scale_y = 2;
  128.     else goto fail;
  130.     /* success: */
  131.     return 1;
  133.     /* failure: */
  134. fail:
  135.     return 0;
  136. }
  138. static int adjust_range (int *z1, int *dz1, int *z2, int *dz2, int inc2)
  139. {
  140.     /* skip odd start pixel: */
  141.     if (*z1 & 1) {
  142.         *z1 += 1;
  143.         *dz1 -= 1;
  144.         *z2 += inc2;
  145.         *dz2 -= inc2;
  146.     }
  147.     /* clip the range: */
  148.     if (*dz1 & 1) {
  149.         *dz1 -= 1;
  150.         *dz2 -= inc2;
  151.     }
  152.     return (*dz1 > 0 && *dz2 > 0);
  153. }
  156. /*** "from I420" converters: *******************************/
  158. /*
  159.  * I420toI420x() converter:
  160.  */
  161. int I420toI420x (unsigned char *dest_ptr, int dest_width, int dest_height,
  162.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  163.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  164.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  165.                  int src_x, int src_y, int src_dx, int src_dy)
  166. {
  167.     /* scale factors: */
  168.     int scale_x, scale_y;
  169. /* Chroma Shifting Allowed */
  170. int OddPattern;
  172.     /* check arguments: */
  173.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  174.         dest_x, dest_y, dest_dx, dest_dy, pY, src_width, src_height,
  175.         yPitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  176.         return -1;
  178.     /* remove odd destination pixels: */
  179.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  180.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  181.         return 0;
  183.     /* check if we have matching chroma components: */
  184.     //if ((src_x & 1) || (src_y & 1))
  185.     //   OddCrop= true;                          /* can't shift chromas */
  186. //else
  187. // OddCrop = false;
  189.     /* check if bottop-up images: */
  190.     if (dest_pitch <= 0 || yPitch <= 0)
  191.         return -1;                          /* not supported for this format */
  193.     /* check if 1:1 scale: */
  194.     if (scale_x == 1 && scale_y == 1) {
  196.         /* check if no color adjustmenst: */
  197.         if (!(is_alpha | is_beta | is_gamma | is_kappa)) {
  199.             /* no color adjustments: */
  200.             unsigned char *s, *d, *v, *s2, *v2;
  201.             int dest_uv_offs;
  202.             register int i,j;
  204.             /* copy Y plane: */
  205.             s = pY + src_x + src_y * yPitch;
  206.             d = dest_ptr + dest_x + dest_y * dest_pitch;
  207.             for (i = 0; i < dest_dy; i ++) {
  208.                 memcpy (d, s, dest_dx); /* Flawfinder: ignore */
  209.                 s += yPitch;
  210.                 d += dest_pitch;
  211.             }
  213.             /* get Cr/Cb offsets: */
  214.             dest_uv_offs = dest_height * dest_pitch / 4;
  216.             /* copy Cr/Cb planes: */
  217.             s = pU + src_x/2 + src_y/2 * uPitch;
  218.             v = pV + src_x/2 + src_y/2 * vPitch;
  219.             d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  220. // extremely cheap way to handle 1 pel cropping
  221. OddPattern = ((src_y & 1) << 1) | (src_x & 1);
  222.             for (i = 0; i < dest_dy/2; i++) 
  223. {
  224. if((i+1) < dest_dy/2) {
  225. s2 = s+uPitch;
  226. v2 = v+vPitch;
  227. } else {
  228. s2 = s;
  229. v2 = v;
  230. }
  231. /* convert pixels: */
  232. switch(OddPattern)
  233. {
  234. case(0):
  235. memcpy (d, s, dest_dx/2); /* Flawfinder: ignore */
  236. memcpy (d + dest_uv_offs, v, dest_dx/2); /* Flawfinder: ignore */
  237. //memcpy (d + dest_uv_offs, s + src_uv_offs, dest_dx/2);
  238. break;
  239. case(1):
  240. for (j = 0; j < dest_dx/2 -1; j ++) {
  241. d[j] = ((unsigned int)s[j] + (unsigned int)s[j+1] + 1)>>1;
  242. d[j + dest_uv_offs] = ((unsigned int)v[j] + (unsigned int)v[j+1] + 1)>>1;
  243. }
  244. d[j] = s[j];
  245. d[j + dest_uv_offs] = v[j];
  246. break;
  247. case(2):
  248. for (j = 0; j < dest_dx/2; j ++) {
  249. d[j] = (s[j] + s2[j] + 1)>>1;
  250. d[j + dest_uv_offs] = ((unsigned int)v[j] + (unsigned int)v2[j] + 1)>>1;
  251. }
  252. break;
  253. case(3):
  254. for (j = 0; j < dest_dx/2 -1; j ++) {
  255. d[j] = ((unsigned int)s[j] + (unsigned int)s[j+1] + (unsigned int)s2[j] + (unsigned int)s2[j+1] + 2)>>2;
  256. d[j + dest_uv_offs] = ((unsigned int)v[j] + (unsigned int)v[j+1] + (unsigned int)v2[j] + (unsigned int)v2[j+1] + 2)>>2;
  257. }
  258. d[j] = ((unsigned int)s[j]+ (unsigned int)s2[j] + 1)>>1;
  259. d[j + dest_uv_offs] = ((unsigned int)v[j] + (unsigned int)v2[j] + 1) >> 1;
  260. break;
  261. }
  262.                 s += uPitch;
  263.                 v += vPitch;
  264.                 d += (dest_pitch/2);
  265.             }
  267.         } else {
  269.             /* adjust colors: */
  270.             unsigned char *s, *d, *v, *s2, *v2;
  271.             int dest_uv_offs;
  272.             register int i, j;
  274.             /* convert Y plane: */
  275.             s = pY + src_x + src_y * yPitch;
  276.             d = dest_ptr + dest_x + dest_y * dest_pitch;
  277.             for (i = 0; i < dest_dy; i ++) {
  279.                 /* convert pixels: */
  280.                 for (j = 0; j < dest_dx; j ++)
  281.                     d[j] = _yytab[s[j]];
  283.                 s += yPitch;
  284.                 d += dest_pitch;
  285.             }
  287.             /* get Cr/Cb offsets: */
  288.             dest_uv_offs = dest_height * dest_pitch / 4;
  290.             /* get chroma pointers: */
  291.             s = pU + src_x/2 + src_y/2 * uPitch;
  292.             v = pV + src_x/2 + src_y/2 * vPitch;
  293.             d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  294. OddPattern = ((src_y & 1) << 1) | (src_x & 1);
  295.             /* check if no hue adjustment: */
  296.             if (!is_alpha) {
  297.                 /* no chroma rotation: */
  298.                 for (i = 0; i < dest_dy/2; i ++) {
  299.                     if((i+1) < dest_dy/2) {
  300. s2 = s+uPitch;
  301. v2 = v+vPitch;
  302. } else {
  303. s2 = s;
  304. v2 = v;
  305. }
  306. /* convert pixels: */
  307. switch(OddPattern)
  308. {
  309. case(0):
  310. for (j = 0; j < dest_dx/2; j ++) {
  311. d[j] = _vvtab[s[j]];
  312. d[j + dest_uv_offs] = _uutab[v[j]];
  313. }
  314. break;
  315. case(1):
  316. for (j = 0; j < dest_dx/2 -1; j ++) {
  317. register unsigned int s1 = ((unsigned int)s[j] + (unsigned int)s[j+1] + 1)>>1;
  318. register unsigned int v1 = ((unsigned int)v[j] + (unsigned int)v[j+1] + 1)>>1;
  319. d[j] = _vvtab[s1];
  320. d[j + dest_uv_offs] = _uutab[v1];
  321. }
  322. d[j] = _vvtab[s[j]];
  323. d[j + dest_uv_offs] = _uutab[v[j]];
  324. break;
  325. case(2):
  326. for (j = 0; j < dest_dx/2; j ++) {
  327. register unsigned int s1 = ((unsigned int)s[j] + (unsigned int)s2[j] + 1)>>1;
  328. register unsigned int v1 = ((unsigned int)v[j] + (unsigned int)v2[j] + 1)>>1;
  329. d[j] = _vvtab[s1];
  330. d[j + dest_uv_offs] = _uutab[v1];
  331. }
  332. break;
  333. case(3):
  334. {
  335. register unsigned int s1, v1;
  336. for (j = 0; j < dest_dx/2 -1; j ++) {
  337. s1 = ((unsigned int)s[j] + (unsigned int)s[j+1] + (unsigned int)s2[j] + (unsigned int)s2[j+1] + 2)>>2;
  338. v1 = ((unsigned int)v[j] + (unsigned int)v[j+1] + (unsigned int)v2[j] + (unsigned int)v2[j+1] + 2)>>2; 
  339. d[j] = _vvtab[s1];
  340. d[j + dest_uv_offs] = _uutab[v1];
  341. }
  342. s1 =((unsigned int)s[j]+ (unsigned int)s2[j] + 1) >> 1;
  343. v1 = ((unsigned int)v[j] + (unsigned int)v2[j] + 1) >> 1;
  344. d[j] = _vvtab[s1];
  345. d[j + dest_uv_offs] = _uutab[v1];
  346. }
  347. break;
  348. }
  349.                     s += uPitch;
  350.                     v += vPitch;
  351.                     d += dest_pitch/2;
  352.                 }
  353.             } else {
  354.                 /* adjust hue: */
  355.                 for (i = 0; i < dest_dy/2; i ++) {
  356. if((i+1) < dest_dy/2) {
  357. s2 = s+uPitch;
  358. v2 = v+vPitch;
  359. } else {
  360. s2 = s;
  361. v2 = v;
  362. }
  363.                     /* convert pixels: */
  364.                     switch(OddPattern)
  365. {
  366. case(0):
  367. for (j = 0; j < dest_dx/2; j ++) {
  368. register unsigned v1 = v[j], u1 = s[j];
  369. d[j] = _CLIP(8,_vvtab[v1] + _vutab[u1]);
  370. d[j + dest_uv_offs] = _CLIP(8,_uutab[u1] + _uvtab[v1]);
  371. }
  372. break;
  373. case(1):
  374. {
  375. register unsigned s1, v1;
  376. for (j = 0; j < dest_dx/2 -1; j ++) {
  377. s1 = ((unsigned int)s[j] + (unsigned int)s[j+1] + 1)>>1;
  378. v1 = ((unsigned int)v[j] + (unsigned int)v[j+1] + 1)>>1;
  379. d[j] = _CLIP(8,_vvtab[v1] + _vutab[s1]);
  380. d[j + dest_uv_offs] = _CLIP(8,_uutab[s1] + _uvtab[v1]);
  381. }
  382. v1 = v[j];
  383. s1 = s[j];
  384. d[j] = _CLIP(8,_vvtab[v1] + _vutab[s1]);
  385. d[j + dest_uv_offs] = _CLIP(8,_uutab[s1] + _uvtab[v1]);
  386. }
  387. break;
  388. case(2):
  389. for (j = 0; j < dest_dx/2; j ++) {
  390. register unsigned s1 = ((unsigned int)s[j] + (unsigned int)s2[j] + 1)>>1;
  391. register unsigned v1 = ((unsigned int)v[j] + (unsigned int)v2[j] + 1)>>1;
  392. d[j] = _CLIP(8,_vvtab[v1] + _vutab[s1]);
  393. d[j + dest_uv_offs] = _CLIP(8,_uutab[s1] + _uvtab[v1]);
  394. }
  395. break;
  396. case(3):
  397. {
  398. register unsigned s1, v1;
  399. for (j = 0; j < dest_dx/2 -1; j ++) {
  400. s1 =((unsigned int)s[j] + (unsigned int)s[j+1] + (unsigned int)s2[j] + (unsigned int)s2[j+1] + 2)>>2;
  401. v1 =((unsigned int)v[j] + (unsigned int)v[j+1] + (unsigned int)v2[j] + (unsigned int)v2[j+1] + 2)>>2;
  402. d[j] = _CLIP(8,_vvtab[v1] + _vutab[s1]);
  403. d[j + dest_uv_offs] = _CLIP(8,_uutab[s1] + _uvtab[v1]);
  404. }
  405. s1 = ((unsigned int)s[j]+ (unsigned int)s2[j] + 1)>>1;
  406. v1 = ((unsigned int)v[j] + (unsigned int)v2[j] + 1) >> 1;
  407. d[j] = _CLIP(8,_vvtab[v1] + _vutab[s1]);
  408. d[j + dest_uv_offs] = _CLIP(8,_uutab[s1] + _uvtab[v1]);
  409. }
  410. break;
  411. }
  413.                     s += uPitch;
  414.                     v += vPitch;
  415.                     d += dest_pitch/2;
  416.                 }
  417.             }
  418.         }
  419.         return 0;
  420.     }
  422.     /* conversion is not supported */
  423.     return -1;
  424. }
  426. /*
  427.  * I420toI420() converter:
  428.  */
  429. int I420toI420 (unsigned char *dest_ptr, int dest_width, int dest_height,
  430.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  431.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  432.     int src_x, int src_y, int src_dx, int src_dy)
  433. {
  434. #if 1
  435.     unsigned char *pU = src_ptr+src_height*src_pitch,
  436.                   *pV = pU + src_height*src_pitch/4;
  437.     return I420toI420x(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  438.                        src_ptr, pU, pV, 
  439.                        src_width, src_height, src_pitch, src_pitch/2, src_pitch/2,
  440.                        src_x, src_y, src_dx, src_dy);
  441.                     
  443. #else
  445.     /* scale factors: */
  446.     int scale_x, scale_y;
  448.     /* check arguments: */
  449.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  450.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  451.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  452.         return -1;
  454.     /* remove odd destination pixels: */
  455.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  456.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  457.         return 0;
  459.     /* check if we have matching chroma components: */
  460.     if ((src_x & 1) || (src_y & 1))
  461.         return -1;                          /* can't shift chromas */
  463.     /* check if bottop-up images: */
  464.     if (dest_pitch <= 0 || src_pitch <= 0)
  465.         return -1;                          /* not supported for this format */
  467.     /* check if 1:1 scale: */
  468.     if (scale_x == 1 && scale_y == 1) {
  470.         /* check if no color adjustmenst: */
  471.         if (!(is_alpha | is_beta | is_gamma | is_kappa)) {
  473.             /* no color adjustments: */
  474.             unsigned char *s, *d;
  475.             int src_uv_offs, dest_uv_offs;
  476.             register int i;
  478.             /* copy Y plane: */
  479.             s = src_ptr + src_x + src_y * src_pitch;
  480.             d = dest_ptr + dest_x + dest_y * dest_pitch;
  481.             for (i = 0; i < dest_dy; i ++) {
  482.                 memcpy (d, s, dest_dx); /* Flawfinder: ignore */
  483.                 s += src_pitch;
  484.                 d += dest_pitch;
  485.             }
  487.             /* get Cr/Cb offsets: */
  488.             src_uv_offs = src_height * src_pitch / 4;
  489.             dest_uv_offs = dest_height * dest_pitch / 4;
  491.             /* copy Cr/Cb planes: */
  492.             s = (src_ptr + src_height * src_pitch) + src_x/2 + src_y/2 * src_pitch/2;
  493.             d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  494.             for (i = 0; i < dest_dy/2; i ++) {
  495.                 memcpy (d, s, dest_dx/2); /* Flawfinder: ignore */
  496.                 memcpy (d + dest_uv_offs, s + src_uv_offs, dest_dx/2); /* Flawfinder: ignore */
  497.                 s += src_pitch/2;
  498.                 d += dest_pitch/2;
  499.             }
  501.         } else {
  503.             /* adjust colors: */
  504.             unsigned char *s, *d;
  505.             int src_uv_offs, dest_uv_offs;
  506.             register int i, j;
  508.             /* convert Y plane: */
  509.             s = src_ptr + src_x + src_y * src_pitch;
  510.             d = dest_ptr + dest_x + dest_y * dest_pitch;
  511.             for (i = 0; i < dest_dy; i ++) {
  513.                 /* convert pixels: */
  514.                 for (j = 0; j < dest_dx; j ++)
  515.                     d[j] = _yytab[s[j]];
  517.                 s += src_pitch;
  518.                 d += dest_pitch;
  519.             }
  521.             /* get Cr/Cb offsets: */
  522.             src_uv_offs = src_height * src_pitch / 4;
  523.             dest_uv_offs = dest_height * dest_pitch / 4;
  525.             /* get chroma pointers: */
  526.             s = (src_ptr + src_height * src_pitch) + src_x/2 + src_y/2 * src_pitch/2;
  527.             d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  529.             /* check if no hue adjustment: */
  530.             if (!is_alpha) {
  532.                 /* no chroma rotation: */
  533.                 for (i = 0; i < dest_dy/2; i ++) {
  535.                     /* convert pixels: */
  536.                     for (j = 0; j < dest_dx/2; j ++) {
  537.                         d[j] = _vvtab[s[j]];
  538.                         d[j + dest_uv_offs] = _uutab[s[j + src_uv_offs]];
  539.                     }
  541.                     s += src_pitch/2;
  542.                     d += dest_pitch/2;
  543.                 }
  545.             } else {
  547.                 /* adjust hue: */
  548.                 for (i = 0; i < dest_dy/2; i ++) {
  550.                     /* convert pixels: */
  551.                     for (j = 0; j < dest_dx/2; j ++) {
  552.                         register unsigned v = s[j], u = s[j + src_uv_offs];
  553.                         d[j] = _CLIP(8,_vvtab[v] + _vutab[u]);
  554.                         d[j + dest_uv_offs] = _CLIP(8,_uutab[u] + _uvtab[v]);
  555.                     }
  557.                     s += src_pitch/2;
  558.                     d += dest_pitch/2;
  559.                 }
  560.             }
  561.         }
  562.         return 0;
  563.     }
  565.     /* conversion is not supported */
  566.     return -1;
  567. #endif
  568. }
  570. int I420toYV12x (unsigned char *dest_ptr, int dest_width, int dest_height,
  571.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  572.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  573.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  574.                  int src_x, int src_y, int src_dx, int src_dy)
  575. {
  576.     /* scale factors: */
  577.     int scale_x, scale_y;
  579.     /* check arguments: */
  580.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  581.         dest_x, dest_y, dest_dx, dest_dy, pY, src_width, src_height,
  582.         yPitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  583.         return -1;
  585.     /* remove odd destination pixels: */
  586.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  587.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  588.         return 0;
  590.     /* check if we have matching chroma components: */
  591.     if ((src_x & 1) || (src_y & 1))
  592.         return -1;                          /* can't shift chromas */
  594.     /* check if bottop-up images: */
  595.     if (dest_pitch <= 0 || yPitch <= 0)
  596.         return -1;                          /* not supported for this format */
  598.     /* check if 1:1 scale: */
  599.     if (scale_x == 1 && scale_y == 1) {
  601.         /* check if no color adjustments: */
  602.         if (!(is_alpha | is_beta | is_gamma | is_kappa)) {
  604.             /* no color adjustments: */
  605.             unsigned char *sy, *su, *sv, *d;
  606.             int dest_uv_offs;
  607.             register int i;
  609.             /* copy Y plane: */
  610.             sy = pY + src_x + src_y * yPitch;
  611.             d = dest_ptr + dest_x + dest_y * dest_pitch;
  612.             for (i = 0; i < dest_dy; i ++) {
  613.                 memcpy (d, sy, dest_dx); /* Flawfinder: ignore */
  614.                 sy += yPitch;
  615.                 d += dest_pitch;
  616.             }
  618.             /* get Cr/Cb offsets: */
  619.             dest_uv_offs = dest_height * dest_pitch / 4;
  621.             /* copy Cr/Cb planes: */
  622.             su = pU + src_x/2 + src_y/2 * uPitch;
  623.             sv = pV + src_x/2 + src_y/2 * vPitch;
  624.             
  625.             d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  626.             for (i = 0; i < dest_dy/2; i ++) {
  627.                 memcpy (d, sv, dest_dx/2); /* Flawfinder: ignore */
  628.                 memcpy (d + dest_uv_offs, su, dest_dx/2); /* Flawfinder: ignore */
  629.                 su += uPitch;
  630.                 sv += vPitch;
  631.                 d += dest_pitch/2;
  632.             }
  634.         } else {
  636.             /* adjust colors: */
  637.             unsigned char *sy, *su, *sv, *d;
  638.             int dest_uv_offs;
  639.             register int i, j;
  641.             /* convert Y plane: */
  642.             sy = pY + src_x + src_y * yPitch;
  643.             d = dest_ptr + dest_x + dest_y * dest_pitch;
  644.             for (i = 0; i < dest_dy; i ++) {
  646.                 /* convert pixels: */
  647.                 for (j = 0; j < dest_dx; j ++)
  648.                     d[j] = _yytab[sy[j]];
  650.                 sy += yPitch;
  651.                 d += dest_pitch;
  652.             }
  654.             /* get Cr/Cb offsets: */
  655.             dest_uv_offs = dest_height * dest_pitch / 4;
  657.             /* get chroma pointers: */
  658.             su = pU + src_x/2 + src_y/2 * uPitch;
  659.             sv = pV + src_x/2 + src_y/2 * vPitch;
  660.             d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  662.             /* check if no hue adjustment: */
  663.             if (!is_alpha) {
  665.                 /* no chroma rotation: */
  666.                 for (i = 0; i < dest_dy/2; i ++) {
  668.                     /* convert pixels: */
  669.                     for (j = 0; j < dest_dx/2; j ++) {
  670.                         d[j] = _vvtab[sv[j]];
  671.                         d[j + dest_uv_offs] = _uutab[su[j]];
  672.                     }
  674.                     su += uPitch;
  675.                     sv += vPitch;
  676.                     d += dest_pitch/2;
  677.                 }
  679.             } else {
  681.                 /* adjust hue: */
  682.                 for (i = 0; i < dest_dy/2; i ++) {
  684.                     /* convert pixels: */
  685.                     for (j = 0; j < dest_dx/2; j ++) {
  686.                         register unsigned v = sv[j], u = su[j];
  687.                         d[j] = _CLIP(8,_vvtab[v] + _vutab[u]);
  688.                         d[j + dest_uv_offs] = _CLIP(8,_uutab[u] + _uvtab[v]);
  689.                     }
  691.                     su += uPitch;
  692.                     sv += vPitch;
  693.                     d += dest_pitch/2;
  694.                 }
  695.             }
  696.         }
  697.         return 0;
  698.     }
  700.     /* conversion is not supported */
  701.     return -1;
  702. }
  704. /*
  705.  * I420toYV12() converter:
  706.  */
  707. int I420toYV12 (unsigned char *dest_ptr, int dest_width, int dest_height,
  708.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  709.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  710.     int src_x, int src_y, int src_dx, int src_dy)
  711. {
  712. #if 1
  713.     unsigned char *pU = src_ptr+src_height*src_pitch,
  714.                   *pV = pU + src_height*src_pitch/4;
  715.     return I420toYV12x(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  716.                        src_ptr, pU, pV, 
  717.                        src_width, src_height, src_pitch, src_pitch/2, src_pitch/2,
  718.                        src_x, src_y, src_dx, src_dy);
  719.                     
  721. #else
  722.     /* scale factors: */
  723.     int scale_x, scale_y;
  725.     /* check arguments: */
  726.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  727.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  728.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  729.         return -1;
  731.     /* remove odd destination pixels: */
  732.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  733.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  734.         return 0;
  736.     /* check if we have matching chroma components: */
  737.     if ((src_x & 1) || (src_y & 1))
  738.         return -1;                          /* can't shift chromas */
  740.     /* check if bottop-up images: */
  741.     if (dest_pitch <= 0 || src_pitch <= 0)
  742.         return -1;                          /* not supported for this format */
  744.     /* check if 1:1 scale: */
  745.     if (scale_x == 1 && scale_y == 1) {
  747.         /* check if no color adjustments: */
  748.         if (!(is_alpha | is_beta | is_gamma | is_kappa)) {
  750.             /* no color adjustments: */
  751.             unsigned char *s, *d;
  752.             int src_uv_offs, dest_uv_offs;
  753.             register int i;
  755.             /* copy Y plane: */
  756.             s = src_ptr + src_x + src_y * src_pitch;
  757.             d = dest_ptr + dest_x + dest_y * dest_pitch;
  758.             for (i = 0; i < dest_dy; i ++) {
  759.                 memcpy (d, s, dest_dx); /* Flawfinder: ignore */
  760.                 s += src_pitch;
  761.                 d += dest_pitch;
  762.             }
  764.             /* get Cr/Cb offsets: */
  765.             src_uv_offs = src_height * src_pitch / 4;
  766.             dest_uv_offs = dest_height * dest_pitch / 4;
  768.             /* copy Cr/Cb planes: */
  769.             s = (src_ptr + src_height * src_pitch) + src_x/2 + src_y/2 * src_pitch/2;
  770.             d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  771.             for (i = 0; i < dest_dy/2; i ++) {
  772.                 memcpy (d, s + src_uv_offs, dest_dx/2); /* Flawfinder: ignore */
  773.                 memcpy (d + dest_uv_offs, s, dest_dx/2); /* Flawfinder: ignore */
  774.                 s += src_pitch/2;
  775.                 d += dest_pitch/2;
  776.             }
  778.         } else {
  780.             /* adjust colors: */
  781.             unsigned char *s, *d;
  782.             int src_uv_offs, dest_uv_offs;
  783.             register int i, j;
  785.             /* convert Y plane: */
  786.             s = src_ptr + src_x + src_y * src_pitch;
  787.             d = dest_ptr + dest_x + dest_y * dest_pitch;
  788.             for (i = 0; i < dest_dy; i ++) {
  790.                 /* convert pixels: */
  791.                 for (j = 0; j < dest_dx; j ++)
  792.                     d[j] = _yytab[s[j]];
  794.                 s += src_pitch;
  795.                 d += dest_pitch;
  796.             }
  798.             /* get Cr/Cb offsets: */
  799.             src_uv_offs = src_height * src_pitch / 4;
  800.             dest_uv_offs = dest_height * dest_pitch / 4;
  802.             /* get chroma pointers: */
  803.             s = (src_ptr + src_height * src_pitch) + src_x/2 + src_y/2 * src_pitch/2;
  804.             d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  806.             /* check if no hue adjustment: */
  807.             if (!is_alpha) {
  809.                 /* no chroma rotation: */
  810.                 for (i = 0; i < dest_dy/2; i ++) {
  812.                     /* convert pixels: */
  813.                     for (j = 0; j < dest_dx/2; j ++) {
  814.                         d[j] = _vvtab[s[j + src_uv_offs]];
  815.                         d[j + dest_uv_offs] = _uutab[s[j]];
  816.                     }
  818.                     s += src_pitch/2;
  819.                     d += dest_pitch/2;
  820.                 }
  822.             } else {
  824.                 /* adjust hue: */
  825.                 for (i = 0; i < dest_dy/2; i ++) {
  827.                     /* convert pixels: */
  828.                     for (j = 0; j < dest_dx/2; j ++) {
  829.                         register unsigned v = s[j + src_uv_offs], u = s[j];
  830.                         d[j] = _CLIP(8,_vvtab[v] + _vutab[u]);
  831.                         d[j + dest_uv_offs] = _CLIP(8,_uutab[u] + _uvtab[v]);
  832.                     }
  834.                     s += src_pitch/2;
  835.                     d += dest_pitch/2;
  836.                 }
  837.             }
  838.         }
  839.         return 0;
  840.     }
  842.     /* conversion is not supported */
  843.     return -1;
  844. #endif
  845. }
  849. #if (defined(_M_IX86) || defined(_USE_MMX_BLENDERS)) && !defined(WINCE_EMULATOR)
  851. //Our MMX optimized YUY2 and UYVY to YUV converters.
  852. //No scaling supported yet.
  853. extern void YUY2ToPlanarYUV_MMX( unsigned char* d1,      
  854.                                  unsigned char* d2,      
  855.                                  unsigned char* du,      
  856.                                  unsigned char* dv,      
  857.                                  INT32          dyPitch, 
  858.                                  INT32          duPitch, 
  859.                                  INT32          dvPitch, 
  860.                                  INT32          dest_dx, 
  861.                                  INT32          dest_dy, 
  862.                                  unsigned char* s1,      
  863.                                  unsigned char* s2,      
  864.                                  INT32          src_pitch
  865.                                  );
  866. extern void UYVYToPlanarYUV_MMX( unsigned char* d1,      
  867.                                  unsigned char* d2,      
  868.                                  unsigned char* du,      
  869.                                  unsigned char* dv,      
  870.                                  INT32          dyPitch, 
  871.                                  INT32          duPitch, 
  872.                                  INT32          dvPitch, 
  873.                                  INT32          dest_dx, 
  874.                                  INT32          dest_dy, 
  875.                                  unsigned char* s1,      
  876.                                  unsigned char* s2,      
  877.                                  INT32          src_pitch
  878.                                  );
  880. extern  YUY2toUYVY_MMX( unsigned char* src,
  881.                         unsigned char* dest,
  882.                         ULONG32        dx
  883.                         );
  885. /* MMX version of I420toYUY2 converter: */
  886. extern void _MMX_lineI420toYUY2( unsigned char *sy,
  887.                                  unsigned char *su,
  888.                                  unsigned char *sv,
  889.                                  unsigned char *d,
  890.                                  int count
  891.                                  );
  893. /*  MMX version of I420toUYVY converter */
  894. extern void _MMX_lineI420toUYVY( unsigned char *sy,
  895.                                  unsigned char *su,
  896.                                  unsigned char *sv,
  897.                                  unsigned char *d,
  898.                                  int count
  899.                                  );
  901. #endif
  903. #ifdef _MACINTOSH
  904. #ifdef __cplusplus
  905. extern "C"
  906. #endif
  907. void
  908. AltiVec_lineI420toYUY2 (
  909. unsigned char *sy, 
  910. unsigned char *su, 
  911. unsigned char *sv,
  912. unsigned char *d,
  913. int dest_dx);
  914. #endif
  917. /*
  918.  * Combine 4 bytes in a register for fast transfer to
  919.  * the main memory:
  920.  */
  921. #if BYTE_ORDER == LITTLE_ENDIAN
  922. #define COMBINE(b0,b1,b2,b3)  
  923.     ((unsigned int)(b0) | ((unsigned int)(b1) << 8) | 
  924.     ((unsigned int)(b2) << 16) | ((unsigned int)(b3) << 24))
  925. #else /* BYTE_ORDER != LITTLE_ENDIAN */
  926. #define COMBINE(b0,b1,b2,b3)  
  927.     ((unsigned int)(b3) | ((unsigned int)(b2) << 8) | 
  928.     ((unsigned int)(b1) << 16) | ((unsigned int)(b0) << 24))
  929. #endif
  931. int I420toYUY2x (unsigned char *dest_ptr, int dest_width, int dest_height,
  932.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  933.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  934.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  935.                  int src_x, int src_y, int src_dx, int src_dy)
  936. {
  937.     /* scale factors: */
  938.     int scale_x, scale_y;
  940.     /* check arguments: */
  941.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  942.         dest_x, dest_y, dest_dx, dest_dy, pY, src_width, src_height,
  943.         yPitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  944.         return -1;
  946.     /* remove odd destination columns: */
  947.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x))
  948.         return 0;
  950.     /* check if we have misaligned input: */
  951.     if (src_x & 1)
  952.         return -1;                          /* can't shift chromas */
  954.     /* check if bottop-up images: */
  955.     if (dest_pitch < 0) dest_ptr -= (dest_height-1) * dest_pitch;
  956.     if (yPitch <= 0 ||
  957.         uPitch <= 0 ||
  958.         vPitch <= 0)
  959.         return -1;          /* not supported */
  961.     /* check if 1:1 scale: */
  962.     if (scale_x == 1 && scale_y == 1) {
  964.         /* check if no color adjustments: */
  965.         if (!(is_alpha | is_beta | is_gamma | is_kappa)) {
  967.             /* no color adjustments: */
  968.             unsigned char *sy, *sv, *su, *d;
  969.             register int i, j;
  971.             /* get pointers: */
  972.             sy = pY + src_x + src_y * yPitch;           /* luma offset */
  973.             su = pU + (src_x/2 + src_y/2 * uPitch);
  974.             sv = pV + (src_x/2 + src_y/2 * vPitch);
  975.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  977. #if (defined(_M_IX86) || defined(_USE_MMX_BLENDERS))  && !defined(WINCE_EMULATOR)
  978.             /* check if we can use MMX-optimized code here: */
  979.             if (_x86_MMX_Available)
  980.             {
  981.                 /* process top line (if chroma is not pairable): */
  982.                 if (dest_y & 1) {
  983.                     _MMX_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  984.                     sy += yPitch;
  985.                     su += uPitch;
  986.                     sv += vPitch;
  987.                     d  += dest_pitch;
  988.                     dest_dy --;
  989.                 }
  990.                 /* the main loop (processes two lines a time): */
  991.                 for (i = 0; i < dest_dy/2; i ++) {
  992.                     _MMX_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  993.                     sy += yPitch;
  994.                     d  += dest_pitch;
  995.                     _MMX_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  996.                     sy += yPitch;
  997.                     su += uPitch;
  998.                     sv += vPitch;
  999.                     d  += dest_pitch;
  1000.                 }
  1001.                 /* process the last line (if dy is odd): */
  1002.                 if (dest_dy & 1) {
  1003.                     _MMX_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1004.                 }
  1005.                 /* end of MMX code */
  1006. #if defined(_M_IX86) && !defined(WINCE_EMULATOR)                
  1007.                 __asm emms
  1008. #elif defined(_USE_MMX_BLENDERS) && !defined(WINCE_EMULATOR)
  1009.                __asm__ __volatile__ ( "emms" );
  1010. #endif                    
  1011.             } else
  1012. #endif
  1013. #ifdef _MACINTOSH
  1014.             /* check if we can use MMX-optimized code here: */
  1015.             if (_AltiVec_Available)
  1016.             {
  1017.                 /* process top line (if chroma is not pairable): */
  1018.                 if (dest_y & 1) {
  1019.                     AltiVec_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1020.                     sy += yPitch;
  1021.                     su += uPitch;
  1022.                     sv += vPitch;
  1023.                     d  += dest_pitch;
  1024.                     dest_dy --;
  1025.                 }
  1026.                 /* the main loop (processes two lines a time): */
  1027.                 for (i = 0; i < dest_dy/2; i ++) {
  1028.                     AltiVec_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1029.                     sy += yPitch;
  1030.                     d  += dest_pitch;
  1031.                     AltiVec_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1032.                     sy += yPitch;
  1033.                     su += uPitch;
  1034.                     sv += vPitch;
  1035.                     d  += dest_pitch;
  1036.                 }
  1037.                 /* process the last line (if dy is odd): */
  1038.                 if (dest_dy & 1) {
  1039.                     AltiVec_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1040.                 }
  1041.                 /* end of MMX code */
  1042.             } else
  1043. #endif
  1044.             /* a generic "C" version: */
  1045.             {
  1046.                 /* process top line (if chroma is not pairable): */
  1047.                 if (dest_y & 1) {
  1048.                     for (j = 0; j < dest_dx/2; j ++)
  1049.                         *(unsigned int *)(d + j*4) = COMBINE(sy[j*2], su[j], sy[j*2+1], sv[j]);
  1050.                     sy += yPitch;
  1051.                     su += uPitch;
  1052.                     sv += vPitch;
  1053.                     d  += dest_pitch;
  1054.                     dest_dy --;
  1055.                 }
  1056.                 /* the main loop (processes two lines a time): */
  1057.                 for (i = 0; i < dest_dy/2; i ++) {
  1058.                     for (j = 0; j < dest_dx/2; j ++)
  1059.                         *(unsigned int *)(d + j*4) = COMBINE(sy[j*2], su[j], sy[j*2+1], sv[j]);
  1060.                     sy += yPitch;
  1061.                     d  += dest_pitch;
  1062.                     for (j = 0; j < dest_dx/2; j ++)
  1063.                         *(unsigned int *)(d + j*4) = COMBINE(sy[j*2], su[j], sy[j*2+1], sv[j]);
  1064.                     sy += yPitch;
  1065.                     su += uPitch;
  1066.                     sv += vPitch;
  1067.                     d  += dest_pitch;
  1068.                 }
  1069.                 /* process the last line (if dy is odd): */
  1070.                 if (dest_dy & 1) {
  1071.                     for (j = 0; j < dest_dx/2; j ++)
  1072.                         *(unsigned int *)(d + j*4) = COMBINE(sy[j*2], su[j], sy[j*2+1], sv[j]);
  1073.                 }
  1074.             }
  1076.         } else
  1078.         /* check if no hue adjustment: */
  1079.         if (!is_alpha) {
  1081.             /* no chroma rotation: */
  1082.             unsigned char *sy, *sv, *su, *d;
  1083.             register int i, j;
  1085.             /* get pointers: */
  1086.             sy = pY + src_x + src_y * yPitch;           /* luma offset */
  1087.             su = pU + (src_x/2 + src_y/2 * uPitch);
  1088.             sv = pV + (src_x/2 + src_y/2 * vPitch);
  1089.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1091.             /* process top line (if chroma is not pairable): */
  1092.             if (dest_y & 1) {
  1093.                 for (j = 0; j < dest_dx/2; j ++)
  1094.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], _uutab[su[j]], _yytab[sy[j*2+1]], _vvtab[sv[j]]);
  1095.                 sy += yPitch;
  1096.                 su += uPitch;
  1097.                 sv += vPitch;
  1098.                 d  += dest_pitch;
  1099.                 dest_dy --;
  1100.             }
  1101.             /* the main loop (processes two lines a time): */
  1102.             for (i = 0; i < dest_dy/2; i ++) {
  1103.                 for (j = 0; j < dest_dx/2; j ++)
  1104.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], _uutab[su[j]], _yytab[sy[j*2+1]], _vvtab[sv[j]]);
  1105.                 sy += yPitch;
  1106.                 d  += dest_pitch;
  1107.                 for (j = 0; j < dest_dx/2; j ++)
  1108.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], _uutab[su[j]], _yytab[sy[j*2+1]], _vvtab[sv[j]]);
  1109.                 sy += yPitch;
  1110.                 su += uPitch;
  1111.                 sv += vPitch;
  1112.                 d  += dest_pitch;
  1113.             }
  1114.             /* process the last line (if dy is odd): */
  1115.             if (dest_dy & 1) {
  1116.                 for (j = 0; j < dest_dx/2; j ++)
  1117.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], _uutab[su[j]], _yytab[sy[j*2+1]], _vvtab[sv[j]]);
  1118.             }
  1120.         } else {
  1122.             /* the most complex case (w. hue adjustment): */
  1123.             unsigned char *sy, *sv, *su, *d;
  1124.             register int i, j, u, v;
  1126.             /* get pointers: */
  1127.             sy = pY + src_x + src_y * yPitch;           /* luma offset */
  1128.             su = pU + (src_x/2 + src_y/2 * uPitch);
  1129.             sv = pV + (src_x/2 + src_y/2 * vPitch);
  1130.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1132.             /* process top line (if chroma is not pairable): */
  1133.             if (dest_y & 1) {
  1134.                 for (j = 0; j < dest_dx/2; j ++) {
  1135.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1136.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1137.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], u, _yytab[sy[j*2+1]], v);
  1138.                 }
  1139.                 sy += yPitch;
  1140.                 su += uPitch;
  1141.                 sv += vPitch;
  1142.                 d  += dest_pitch;
  1143.                 dest_dy --;
  1144.             }
  1145.             /* the main loop (processes two lines a time): */
  1146.             for (i = 0; i < dest_dy/2; i ++) {
  1147.                 for (j = 0; j < dest_dx/2; j ++) {
  1148.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1149.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1150.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], u, _yytab[sy[j*2+1]], v);
  1151.                     *(unsigned int *)(d + j*4 + dest_pitch) = COMBINE(_yytab[sy[j*2 + yPitch]], u, _yytab[sy[j*2+1+yPitch]], v);
  1152.                 }
  1153.                 sy += yPitch*2;
  1154.                 su += uPitch;
  1155.                 sv += vPitch;
  1156.                 d  += dest_pitch*2;
  1157.             }
  1158.             /* process the last line (if dy is odd): */
  1159.             if (dest_dy & 1) {
  1160.                 for (j = 0; j < dest_dx/2; j ++) {
  1161.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1162.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1163.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], u, _yytab[sy[j*2+1]], v);
  1164.                 }
  1165.             }
  1166.         }
  1167.         return 0;
  1168.     }
  1170.     /* conversion is not supported */
  1171.     return -1;
  1172. }
  1174. /*
  1175.  * I420toYUY2() converter:
  1176.  */
  1177. int I420toYUY2 (unsigned char *dest_ptr, int dest_width, int dest_height,
  1178.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  1179.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  1180.     int src_x, int src_y, int src_dx, int src_dy)
  1181. {
  1182. #if 1
  1183.     unsigned char *pU = src_ptr+src_height*src_pitch,
  1184.                   *pV = pU + src_height*src_pitch/4;
  1185.     return I420toYUY2x(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  1186.                        src_ptr, pU, pV, 
  1187.                        src_width, src_height, src_pitch, src_pitch/2, src_pitch/2,
  1188.                        src_x, src_y, src_dx, src_dy);
  1189.                     
  1191. #else
  1193.     /* scale factors: */
  1194.     int scale_x, scale_y;
  1196.     /* check arguments: */
  1197.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  1198.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  1199.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  1200.         return -1;
  1202.     /* remove odd destination columns: */
  1203.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x))
  1204.         return 0;
  1206.     /* check if we have misaligned input: */
  1207.     if (src_x & 1)
  1208.         return -1;                          /* can't shift chromas */
  1210.     /* check if bottop-up images: */
  1211.     if (dest_pitch < 0) dest_ptr -= (dest_height-1) * dest_pitch;
  1212.     if (src_pitch <= 0) return -1;          /* not supported */
  1214.     /* check if 1:1 scale: */
  1215.     if (scale_x == 1 && scale_y == 1) {
  1217.         /* check if no color adjustments: */
  1218.         if (!(is_alpha | is_beta | is_gamma | is_kappa)) {
  1220.             /* no color adjustments: */
  1221.             unsigned char *sy, *sv, *su, *d;
  1222.             register int i, j;
  1224.             /* get pointers: */
  1225.             sy = src_ptr + src_x + src_y * src_pitch;           /* luma offset */
  1226.             su = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  1227.             sv = su + src_height * src_pitch / 4;
  1228.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1230. #if (defined(_M_IX86) || defined(_USE_MMX_BLENDERS)) && !defined(WINCE_EMULATOR)
  1231.             /* check if we can use MMX-optimized code here: */
  1232.             if (_x86_MMX_Available)
  1233.             {
  1234.                 /* process top line (if chroma is not pairable): */
  1235.                 if (dest_y & 1) {
  1236.                     _MMX_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1237.                     sy += src_pitch;
  1238.                     su += src_pitch/2;
  1239.                     sv += src_pitch/2;
  1240.                     d  += dest_pitch;
  1241.                     dest_dy --;
  1242.                 }
  1243.                 /* the main loop (processes two lines a time): */
  1244.                 for (i = 0; i < dest_dy/2; i ++) {
  1245.                     _MMX_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1246.                     sy += src_pitch;
  1247.                     d  += dest_pitch;
  1248.                     _MMX_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1249.                     sy += src_pitch;
  1250.                     su += src_pitch/2;
  1251.                     sv += src_pitch/2;
  1252.                     d  += dest_pitch;
  1253.                 }
  1254.                 /* process the last line (if dy is odd): */
  1255.                 if (dest_dy & 1) {
  1256.                     _MMX_lineI420toYUY2 (sy, su, sv, d, dest_dx);
  1257.                 }
  1258.                 /* end of MMX code */
  1259. #if defined(_M_IX86)  && !defined(WINCE_EMULATOR)                
  1260.                 __asm emms
  1261. #elif defined(_USE_MMX_BLENDERS) && !defined(WINCE_EMULATOR)
  1262.                 __asm__ __volatile__ ( "emms" );
  1263. #endif                    
  1265.             } else
  1266. #endif
  1267.             /* a generic "C" version: */
  1268.             {
  1269.                 /* process top line (if chroma is not pairable): */
  1270.                 if (dest_y & 1) {
  1271.                     for (j = 0; j < dest_dx/2; j ++)
  1272.                         *(unsigned int *)(d + j*4) = COMBINE(sy[j*2], su[j], sy[j*2+1], sv[j]);
  1273.                     sy += src_pitch;
  1274.                     su += src_pitch/2;
  1275.                     sv += src_pitch/2;
  1276.                     d  += dest_pitch;
  1277.                     dest_dy --;
  1278.                 }
  1279.                 /* the main loop (processes two lines a time): */
  1280.                 for (i = 0; i < dest_dy/2; i ++) {
  1281.                     for (j = 0; j < dest_dx/2; j ++)
  1282.                         *(unsigned int *)(d + j*4) = COMBINE(sy[j*2], su[j], sy[j*2+1], sv[j]);
  1283.                     sy += src_pitch;
  1284.                     d  += dest_pitch;
  1285.                     for (j = 0; j < dest_dx/2; j ++)
  1286.                         *(unsigned int *)(d + j*4) = COMBINE(sy[j*2], su[j], sy[j*2+1], sv[j]);
  1287.                     sy += src_pitch;
  1288.                     su += src_pitch/2;
  1289.                     sv += src_pitch/2;
  1290.                     d  += dest_pitch;
  1291.                 }
  1292.                 /* process the last line (if dy is odd): */
  1293.                 if (dest_dy & 1) {
  1294.                     for (j = 0; j < dest_dx/2; j ++)
  1295.                         *(unsigned int *)(d + j*4) = COMBINE(sy[j*2], su[j], sy[j*2+1], sv[j]);
  1296.                 }
  1297.             }
  1299.         } else
  1301.         /* check if no hue adjustment: */
  1302.         if (!is_alpha) {
  1304.             /* no chroma rotation: */
  1305.             unsigned char *sy, *sv, *su, *d;
  1306.             register int i, j;
  1308.             /* get pointers: */
  1309.             sy = src_ptr + src_x + src_y * src_pitch;           /* luma offset */
  1310.             su = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  1311.             sv = su + src_height * src_pitch / 4;
  1312.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1314.             /* process top line (if chroma is not pairable): */
  1315.             if (dest_y & 1) {
  1316.                 for (j = 0; j < dest_dx/2; j ++)
  1317.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], _uutab[su[j]], _yytab[sy[j*2+1]], _vvtab[sv[j]]);
  1318.                 sy += src_pitch;
  1319.                 su += src_pitch/2;
  1320.                 sv += src_pitch/2;
  1321.                 d  += dest_pitch;
  1322.                 dest_dy --;
  1323.             }
  1324.             /* the main loop (processes two lines a time): */
  1325.             for (i = 0; i < dest_dy/2; i ++) {
  1326.                 for (j = 0; j < dest_dx/2; j ++)
  1327.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], _uutab[su[j]], _yytab[sy[j*2+1]], _vvtab[sv[j]]);
  1328.                 sy += src_pitch;
  1329.                 d  += dest_pitch;
  1330.                 for (j = 0; j < dest_dx/2; j ++)
  1331.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], _uutab[su[j]], _yytab[sy[j*2+1]], _vvtab[sv[j]]);
  1332.                 sy += src_pitch;
  1333.                 su += src_pitch/2;
  1334.                 sv += src_pitch/2;
  1335.                 d  += dest_pitch;
  1336.             }
  1337.             /* process the last line (if dy is odd): */
  1338.             if (dest_dy & 1) {
  1339.                 for (j = 0; j < dest_dx/2; j ++)
  1340.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], _uutab[su[j]], _yytab[sy[j*2+1]], _vvtab[sv[j]]);
  1341.             }
  1343.         } else {
  1345.             /* the most complex case (w. hue adjustment): */
  1346.             unsigned char *sy, *sv, *su, *d;
  1347.             register int i, j, u, v;
  1349.             /* get pointers: */
  1350.             sy = src_ptr + src_x + src_y * src_pitch;           /* luma offset */
  1351.             su = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch/2);
  1352.             sv = su + src_height * src_pitch / 4;
  1353.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1355.             /* process top line (if chroma is not pairable): */
  1356.             if (dest_y & 1) {
  1357.                 for (j = 0; j < dest_dx/2; j ++) {
  1358.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1359.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1360.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], u, _yytab[sy[j*2+1]], v);
  1361.                 }
  1362.                 sy += src_pitch;
  1363.                 su += src_pitch/2;
  1364.                 sv += src_pitch/2;
  1365.                 d  += dest_pitch;
  1366.                 dest_dy --;
  1367.             }
  1368.             /* the main loop (processes two lines a time): */
  1369.             for (i = 0; i < dest_dy/2; i ++) {
  1370.                 for (j = 0; j < dest_dx/2; j ++) {
  1371.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1372.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1373.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], u, _yytab[sy[j*2+1]], v);
  1374.                     *(unsigned int *)(d + j*4 + dest_pitch) = COMBINE(_yytab[sy[j*2 + src_pitch]], u, _yytab[sy[j*2+1+src_pitch]], v);
  1375.                 }
  1376.                 sy += src_pitch*2;
  1377.                 su += src_pitch/2;
  1378.                 sv += src_pitch/2;
  1379.                 d  += dest_pitch*2;
  1380.             }
  1381.             /* process the last line (if dy is odd): */
  1382.             if (dest_dy & 1) {
  1383.                 for (j = 0; j < dest_dx/2; j ++) {
  1384.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1385.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1386.                     *(unsigned int *)(d + j*4) = COMBINE(_yytab[sy[j*2]], u, _yytab[sy[j*2+1]], v);
  1387.                 }
  1388.             }
  1389.         }
  1390.         return 0;
  1391.     }
  1393.     /* conversion is not supported */
  1394.     return -1;
  1395. #endif //0
  1396. }
  1399. int I420toUYVYx (unsigned char *dest_ptr, int dest_width, int dest_height,
  1400.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  1401.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  1402.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  1403.                  int src_x, int src_y, int src_dx, int src_dy)
  1404. {
  1405.     /* scale factors: */
  1406.     int scale_x, scale_y;
  1408.     /* check arguments: */
  1409.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  1410.         dest_x, dest_y, dest_dx, dest_dy, pY, src_width, src_height,
  1411.         yPitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  1412.         return -1;
  1414.     /* remove odd destination columns: */
  1415.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x))
  1416.         return 0;
  1418.     /* check if we have misaligned input: */
  1419.     if (src_x & 1)
  1420.         return -1;                          /* can't shift chromas */
  1422.     /* check if bottop-up images: */
  1423.     if (dest_pitch < 0) dest_ptr -= (dest_height-1) * dest_pitch;
  1425.     if (yPitch <= 0 ||
  1426.         uPitch <= 0 ||
  1427.         vPitch <= 0)
  1428.         return -1;          /* not supported */
  1430.     /* check if 1:1 scale: */
  1431.     if (scale_x == 1 && scale_y == 1) {
  1433.         /* check if no color adjustments: */
  1434.         if (!(is_alpha | is_beta | is_gamma | is_kappa)) {
  1436.             /* no color adjustments: */
  1437.             unsigned char *sy, *sv, *su, *d;
  1438.             register int i, j;
  1440.             /* get pointers: */
  1441.             sy = pY + src_x + src_y * yPitch;           /* luma offset */
  1442.             su = pU + (src_x/2 + src_y/2 * uPitch);
  1443.             sv = pV + (src_x/2 + src_y/2 * vPitch);
  1444.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1446. #if (defined(_M_IX86) || defined(_USE_MMX_BLENDERS)) && !defined(WINCE_EMULATOR)
  1447.             /* check if we can use MMX-optimized code here: */
  1448.             if (_x86_MMX_Available)
  1449.             {
  1450.                 /* process top line (if chroma is not pairable): */
  1451.                 if (dest_y & 1) {
  1452.                     _MMX_lineI420toUYVY (sy, su, sv, d, dest_dx);
  1453.                     sy += yPitch;
  1454.                     su += uPitch;
  1455.                     sv += vPitch;
  1456.                     d  += dest_pitch;
  1457.                     dest_dy --;
  1458.                 }
  1459.                 /* the main loop (processes two lines a time): */
  1460.                 for (i = 0; i < dest_dy/2; i ++) {
  1461.                     _MMX_lineI420toUYVY (sy, su, sv, d, dest_dx);
  1462.                     sy += yPitch;
  1463.                     d  += dest_pitch;
  1464.                     _MMX_lineI420toUYVY (sy, su, sv, d, dest_dx);
  1465.                     sy += yPitch;
  1466.                     su += uPitch;
  1467.                     sv += vPitch;
  1468.                     d  += dest_pitch;
  1469.                 }
  1470.                 /* process the last line (if dy is odd): */
  1471.                 if (dest_dy & 1) {
  1472.                     _MMX_lineI420toUYVY (sy, su, sv, d, dest_dx);
  1473.                 }
  1474.                 /* end of MMX code */
  1475. #if defined(_M_IX86) && !defined(WINCE_EMULATOR)                
  1476.                 __asm emms
  1477. #elif defined(_USE_MMX_BLENDERS) && !defined(WINCE_EMULATOR)
  1478.                 __asm__ __volatile__ ( "emms" );
  1479. #endif                    
  1480.             } else
  1481. #endif
  1482.             /* a generic "C" version: */
  1483.             {
  1484.                 /* process top line (if chroma is not pairable): */
  1485.                 if (dest_y & 1) {
  1486.                     for (j = 0; j < dest_dx/2; j ++)
  1487.                         *(unsigned int *)(d + j*4) = su[j] | (sy[j*2] << 8) | (sv[j] << 16) | (sy[j*2+1] << 24);
  1488.                     sy += yPitch;
  1489.                     su += uPitch;
  1490.                     sv += vPitch;
  1491.                     d  += dest_pitch;
  1492.                     dest_dy --;
  1493.                 }
  1494.                 /* the main loop (processes two lines a time): */
  1495.                 for (i = 0; i < dest_dy/2; i ++) {
  1496.                     for (j = 0; j < dest_dx/2; j ++)
  1497.                         *(unsigned int *)(d + j*4) = su[j] | (sy[j*2] << 8) | (sv[j] << 16) | (sy[j*2+1] << 24);
  1498.                     sy += yPitch;
  1499.                     d  += dest_pitch;
  1500.                     for (j = 0; j < dest_dx/2; j ++)
  1501.                         *(unsigned int *)(d + j*4) = su[j] | (sy[j*2] << 8) | (sv[j] << 16) | (sy[j*2+1] << 24);
  1502.                     sy += yPitch;
  1503.                     su += uPitch;
  1504.                     sv += vPitch;
  1505.                     d  += dest_pitch;
  1506.                 }
  1507.                 /* process the last line (if dy is odd): */
  1508.                 if (dest_dy & 1) {
  1509.                     for (j = 0; j < dest_dx/2; j ++)
  1510.                         *(unsigned int *)(d + j*4) = su[j] | (sy[j*2] << 8) | (sv[j] << 16) | (sy[j*2+1] << 24);
  1511.                 }
  1512.             }
  1514.         } else
  1516.         /* check if no hue adjustment: */
  1517.         if (!is_alpha) {
  1519.             /* no chroma rotation: */
  1520.             unsigned char *sy, *sv, *su, *d;
  1521.             register int i, j;
  1523.             /* get pointers: */
  1524.             sy = pY + src_x + src_y * yPitch;           /* luma offset */
  1525.             su = pU + (src_x/2 + src_y/2 * uPitch);
  1526.             sv = pV + (src_x/2 + src_y/2 * vPitch);
  1527.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1529.             /* process top line (if chroma is not pairable): */
  1530.             if (dest_y & 1) {
  1531.                 for (j = 0; j < dest_dx/2; j ++)
  1532.                     *(unsigned int *)(d + j*4) = _uutab[su[j]] | (_yytab[sy[j*2]] << 8) | (_vvtab[sv[j]] << 16) | (_yytab[sy[j*2+1]] << 24);
  1533.                 sy += yPitch;
  1534.                 su += uPitch;
  1535.                 sv += vPitch;
  1536.                 d  += dest_pitch;
  1537.                 dest_dy --;
  1538.             }
  1539.             /* the main loop (processes two lines a time): */
  1540.             for (i = 0; i < dest_dy/2; i ++) {
  1541.                 for (j = 0; j < dest_dx/2; j ++)
  1542.                     *(unsigned int *)(d + j*4) = _uutab[su[j]] | (_yytab[sy[j*2]] << 8) | (_vvtab[sv[j]] << 16) | (_yytab[sy[j*2+1]] << 24);
  1543.                 sy += yPitch;
  1544.                 d  += dest_pitch;
  1545.                 for (j = 0; j < dest_dx/2; j ++)
  1546.                     *(unsigned int *)(d + j*4) = _uutab[su[j]] | (_yytab[sy[j*2]] << 8) | (_vvtab[sv[j]] << 16) | (_yytab[sy[j*2+1]] << 24);
  1547.                 sy += yPitch;
  1548.                 su += uPitch;
  1549.                 sv += vPitch;
  1550.                 d  += dest_pitch;
  1551.             }
  1552.             /* process the last line (if dy is odd): */
  1553.             if (dest_dy & 1) {
  1554.                 for (j = 0; j < dest_dx/2; j ++)
  1555.                     *(unsigned int *)(d + j*4) = _uutab[su[j]] | (_yytab[sy[j*2]] << 8) | (_vvtab[sv[j]] << 16) | (_yytab[sy[j*2+1]] << 24);
  1556.             }
  1558.         } else {
  1560.             /* the most complex case (w. hue adjustement): */
  1561.             unsigned char *sy, *sv, *su, *d;
  1562.             register int i, j, u, v;
  1564.             /* get pointers: */
  1565.             sy = pY + src_x + src_y * yPitch;           /* luma offset */
  1566.             su = pU + (src_x/2 + src_y/2 * uPitch);
  1567.             sv = pV + (src_x/2 + src_y/2 * vPitch);
  1568.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1570.             /* process top line (if chroma is not pairable): */
  1571.             if (dest_y & 1) {
  1572.                 for (j = 0; j < dest_dx/2; j ++) {
  1573.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1574.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1575.                     *(unsigned int *)(d + j*4) = u | (_yytab[sy[j*2]] << 8) | (v << 16) | (_yytab[sy[j*2+1]] << 24);
  1576.                 }
  1577.                 sy += yPitch;
  1578.                 su += uPitch;
  1579.                 sv += vPitch;
  1580.                 d  += dest_pitch;
  1581.                 dest_dy --;
  1582.             }
  1583.             /* the main loop (processes two lines a time): */
  1584.             for (i = 0; i < dest_dy/2; i ++) {
  1585.                 for (j = 0; j < dest_dx/2; j ++) {
  1586.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1587.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1588.                     *(unsigned int *)(d + j*4) = u | (_yytab[sy[j*2]] << 8) | (v << 16) | (_yytab[sy[j*2+1]] << 24);
  1589.                     *(unsigned int *)(d + j*4 + dest_pitch) = u | (_yytab[sy[j*2 + yPitch]] << 8) | (v << 16) | (_yytab[sy[j*2+1 + yPitch]] << 24);
  1590.                 }
  1591.                 sy += yPitch*2;
  1592.                 su += uPitch;
  1593.                 sv += vPitch;
  1594.                 d  += dest_pitch*2;
  1595.             }
  1596.             /* process the last line (if dy is odd): */
  1597.             if (dest_dy & 1) {
  1598.                 for (j = 0; j < dest_dx/2; j ++) {
  1599.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1600.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1601.                     *(unsigned int *)(d + j*4) = u | (_yytab[sy[j*2]] << 8) | (v << 16) | (_yytab[sy[j*2+1]] << 24);
  1602.                 }
  1603.             }
  1604.         }
  1605.         return 0;
  1606.     }
  1608.     /* conversion is not supported */
  1609.     return -1;
  1610. }
  1612. /*
  1613.  * I420toUYVY() converter:
  1614.  */
  1615. int I420toUYVY (unsigned char *dest_ptr, int dest_width, int dest_height,
  1616.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  1617.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  1618.     int src_x, int src_y, int src_dx, int src_dy)
  1619. {
  1620. #if 1
  1621.     unsigned char *pU = src_ptr+src_height*src_pitch,
  1622.                   *pV = pU + src_height*src_pitch/4;
  1623.     return I420toUYVYx(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  1624.                        src_ptr, pU, pV, 
  1625.                        src_width, src_height, src_pitch, src_pitch/2, src_pitch/2,
  1626.                        src_x, src_y, src_dx, src_dy);
  1627.                     
  1629. #else
  1631.     /* scale factors: */
  1632.     int scale_x, scale_y;
  1634.     /* check arguments: */
  1635.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  1636.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  1637.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  1638.         return -1;
  1640.     /* remove odd destination columns: */
  1641.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x))
  1642.         return 0;
  1644.     /* check if we have misaligned input: */
  1645.     if (src_x & 1)
  1646.         return -1;                          /* can't shift chromas */
  1648.     /* check if bottop-up images: */
  1649.     if (dest_pitch < 0) dest_ptr -= (dest_height-1) * dest_pitch;
  1650.     if (src_pitch <= 0) return -1;          /* not supported */
  1652.     /* check if 1:1 scale: */
  1653.     if (scale_x == 1 && scale_y == 1) {
  1655.         /* check if no color adjustments: */
  1656.         if (!(is_alpha | is_beta | is_gamma | is_kappa)) {
  1658.             /* no color adjustments: */
  1659.             unsigned char *sy, *sv, *su, *d;
  1660.             register int i, j;
  1662.             /* get pointers: */
  1663.             sy = src_ptr + src_x + src_y * src_pitch;           /* luma offset */
  1664.             su = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  1665.             sv = su + src_height * src_pitch / 4;
  1666.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1668. #if (defined(_M_IX86) || defined(_USE_MMX_BLENDERS))  && !defined(WINCE_EMULATOR)
  1669.             /* check if we can use MMX-optimized code here: */
  1670.             if (_x86_MMX_Available)
  1671.             {
  1672.                 /* process top line (if chroma is not pairable): */
  1673.                 if (dest_y & 1) {
  1674.                     _MMX_lineI420toUYVY (sy, su, sv, d, dest_dx);
  1675.                     sy += src_pitch;
  1676.                     su += src_pitch/2;
  1677.                     sv += src_pitch/2;
  1678.                     d  += dest_pitch;
  1679.                     dest_dy --;
  1680.                 }
  1681.                 /* the main loop (processes two lines a time): */
  1682.                 for (i = 0; i < dest_dy/2; i ++) {
  1683.                     _MMX_lineI420toUYVY (sy, su, sv, d, dest_dx);
  1684.                     sy += src_pitch;
  1685.                     d  += dest_pitch;
  1686.                     _MMX_lineI420toUYVY (sy, su, sv, d, dest_dx);
  1687.                     sy += src_pitch;
  1688.                     su += src_pitch/2;
  1689.                     sv += src_pitch/2;
  1690.                     d  += dest_pitch;
  1691.                 }
  1692.                 /* process the last line (if dy is odd): */
  1693.                 if (dest_dy & 1) {
  1694.                     _MMX_lineI420toUYVY (sy, su, sv, d, dest_dx);
  1695.                 }
  1696.                 /* end of MMX code */
  1697. #if defined(_M_IX86) && !defined(WINCE_EMULATOR)                
  1698.                 __asm emms
  1699. #elif defined(_USE_MMX_BLENDERS) && !defined(WINCE_EMULATOR)
  1700.                 __asm__ __volatile__ ( "emms" );
  1701. #endif                    
  1702.             } else
  1703. #endif
  1704.             /* a generic "C" version: */
  1705.             {
  1706.                 /* process top line (if chroma is not pairable): */
  1707.                 if (dest_y & 1) {
  1708.                     for (j = 0; j < dest_dx/2; j ++)
  1709.                         *(unsigned int *)(d + j*4) = su[j] | (sy[j*2] << 8) | (sv[j] << 16) | (sy[j*2+1] << 24);
  1710.                     sy += src_pitch;
  1711.                     su += src_pitch/2;
  1712.                     sv += src_pitch/2;
  1713.                     d  += dest_pitch;
  1714.                     dest_dy --;
  1715.                 }
  1716.                 /* the main loop (processes two lines a time): */
  1717.                 for (i = 0; i < dest_dy/2; i ++) {
  1718.                     for (j = 0; j < dest_dx/2; j ++)
  1719.                         *(unsigned int *)(d + j*4) = su[j] | (sy[j*2] << 8) | (sv[j] << 16) | (sy[j*2+1] << 24);
  1720.                     sy += src_pitch;
  1721.                     d  += dest_pitch;
  1722.                     for (j = 0; j < dest_dx/2; j ++)
  1723.                         *(unsigned int *)(d + j*4) = su[j] | (sy[j*2] << 8) | (sv[j] << 16) | (sy[j*2+1] << 24);
  1724.                     sy += src_pitch;
  1725.                     su += src_pitch/2;
  1726.                     sv += src_pitch/2;
  1727.                     d  += dest_pitch;
  1728.                 }
  1729.                 /* process the last line (if dy is odd): */
  1730.                 if (dest_dy & 1) {
  1731.                     for (j = 0; j < dest_dx/2; j ++)
  1732.                         *(unsigned int *)(d + j*4) = su[j] | (sy[j*2] << 8) | (sv[j] << 16) | (sy[j*2+1] << 24);
  1733.                 }
  1734.             }
  1736.         } else
  1738.         /* check if no hue adjustment: */
  1739.         if (!is_alpha) {
  1741.             /* no chroma rotation: */
  1742.             unsigned char *sy, *sv, *su, *d;
  1743.             register int i, j;
  1745.             /* get pointers: */
  1746.             sy = src_ptr + src_x + src_y * src_pitch;           /* luma offset */
  1747.             su = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  1748.             sv = su + src_height * src_pitch / 4;
  1749.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1751.             /* process top line (if chroma is not pairable): */
  1752.             if (dest_y & 1) {
  1753.                 for (j = 0; j < dest_dx/2; j ++)
  1754.                     *(unsigned int *)(d + j*4) = _uutab[su[j]] | (_yytab[sy[j*2]] << 8) | (_vvtab[sv[j]] << 16) | (_yytab[sy[j*2+1]] << 24);
  1755.                 sy += src_pitch;
  1756.                 su += src_pitch/2;
  1757.                 sv += src_pitch/2;
  1758.                 d  += dest_pitch;
  1759.                 dest_dy --;
  1760.             }
  1761.             /* the main loop (processes two lines a time): */
  1762.             for (i = 0; i < dest_dy/2; i ++) {
  1763.                 for (j = 0; j < dest_dx/2; j ++)
  1764.                     *(unsigned int *)(d + j*4) = _uutab[su[j]] | (_yytab[sy[j*2]] << 8) | (_vvtab[sv[j]] << 16) | (_yytab[sy[j*2+1]] << 24);
  1765.                 sy += src_pitch;
  1766.                 d  += dest_pitch;
  1767.                 for (j = 0; j < dest_dx/2; j ++)
  1768.                     *(unsigned int *)(d + j*4) = _uutab[su[j]] | (_yytab[sy[j*2]] << 8) | (_vvtab[sv[j]] << 16) | (_yytab[sy[j*2+1]] << 24);
  1769.                 sy += src_pitch;
  1770.                 su += src_pitch/2;
  1771.                 sv += src_pitch/2;
  1772.                 d  += dest_pitch;
  1773.             }
  1774.             /* process the last line (if dy is odd): */
  1775.             if (dest_dy & 1) {
  1776.                 for (j = 0; j < dest_dx/2; j ++)
  1777.                     *(unsigned int *)(d + j*4) = _uutab[su[j]] | (_yytab[sy[j*2]] << 8) | (_vvtab[sv[j]] << 16) | (_yytab[sy[j*2+1]] << 24);
  1778.             }
  1780.         } else {
  1782.             /* the most complex case (w. hue adjustement): */
  1783.             unsigned char *sy, *sv, *su, *d;
  1784.             register int i, j, u, v;
  1786.             /* get pointers: */
  1787.             sy = src_ptr + src_x + src_y * src_pitch;           /* luma offset */
  1788.             su = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch/2);
  1789.             sv = su + src_height * src_pitch / 4;
  1790.             d  = dest_ptr + dest_x * 2 + dest_y * dest_pitch;   /* 2 bytes/pixel */
  1792.             /* process top line (if chroma is not pairable): */
  1793.             if (dest_y & 1) {
  1794.                 for (j = 0; j < dest_dx/2; j ++) {
  1795.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1796.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1797.                     *(unsigned int *)(d + j*4) = u | (_yytab[sy[j*2]] << 8) | (v << 16) | (_yytab[sy[j*2+1]] << 24);
  1798.                 }
  1799.                 sy += src_pitch;
  1800.                 su += src_pitch/2;
  1801.                 sv += src_pitch/2;
  1802.                 d  += dest_pitch;
  1803.                 dest_dy --;
  1804.             }
  1805.             /* the main loop (processes two lines a time): */
  1806.             for (i = 0; i < dest_dy/2; i ++) {
  1807.                 for (j = 0; j < dest_dx/2; j ++) {
  1808.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1809.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1810.                     *(unsigned int *)(d + j*4) = u | (_yytab[sy[j*2]] << 8) | (v << 16) | (_yytab[sy[j*2+1]] << 24);
  1811.                     *(unsigned int *)(d + j*4 + dest_pitch) = u | (_yytab[sy[j*2 + src_pitch]] << 8) | (v << 16) | (_yytab[sy[j*2+1 + src_pitch]] << 24);
  1812.                 }
  1813.                 sy += src_pitch*2;
  1814.                 su += src_pitch/2;
  1815.                 sv += src_pitch/2;
  1816.                 d  += dest_pitch*2;
  1817.             }
  1818.             /* process the last line (if dy is odd): */
  1819.             if (dest_dy & 1) {
  1820.                 for (j = 0; j < dest_dx/2; j ++) {
  1821.                     v = _CLIP(8,_vvtab[sv[j]] + _vutab[su[j]]);
  1822.                     u = _CLIP(8,_uutab[su[j]] + _uvtab[sv[j]]);
  1823.                     *(unsigned int *)(d + j*4) = u | (_yytab[sy[j*2]] << 8) | (v << 16) | (_yytab[sy[j*2+1]] << 24);
  1824.                 }
  1825.             }
  1826.         }
  1827.         return 0;
  1828.     }
  1830.     /* conversion is not supported */
  1831.     return -1;
  1832. #endif //0
  1833. }
  1836. /*** "to I420" converters: *********************************/
  1838. int YV12toI420x (unsigned char *dest_ptr, int dest_width, int dest_height,
  1839.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  1840.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  1841.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  1842.                  int src_x, int src_y, int src_dx, int src_dy)
  1843. {
  1844.     /* scale factors: */
  1845.     int scale_x, scale_y;
  1846. /* Chroma Shifting Allowed */
  1847. int OddPattern;
  1849.     /* check arguments: */
  1850.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  1851.         dest_x, dest_y, dest_dx, dest_dy, pY, src_width, src_height,
  1852.         yPitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  1853.         return -1;
  1855.     /* remove odd destination pixels: */
  1856.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  1857.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  1858.         return 0;
  1860.     /* check if we have matching chroma components: */
  1861.     //if ((src_x & 1) || (src_y & 1))
  1862.     //    return -1;                          /* can't shift chromas */
  1864.     /* check if bottop-up images: */
  1865.     if (dest_pitch <= 0 || yPitch <= 0)
  1866.         return -1;                          /* not supported */
  1867. /*
  1868.  *  if (!is_dest_alpha && !is_dest_beta && !is_dest_gamma && !is_dest_kappa)
  1869.  */
  1870.     {
  1871.         /* just move data in, no color adjustments: */
  1872.         unsigned char *sy, *su, *sv, *d, *su2, *sv2;
  1873.         int dest_uv_offs;
  1874.         register int i,j;
  1876.         /* copy Y plane: */
  1877.         sy = pY + src_x + src_y * yPitch;
  1878.         d = dest_ptr + dest_x + dest_y * dest_pitch;
  1879.         for (i = 0; i < dest_dy; i ++) {
  1880.             memcpy (d, sy, dest_dx); /* Flawfinder: ignore */
  1881.             sy += yPitch;
  1882.             d += dest_pitch;
  1883.         }
  1885.         /* get Cr/Cb offsets: */
  1886.         dest_uv_offs = dest_height * dest_pitch / 4;
  1888.         /* copy & flip Cr/Cb planes: */
  1889.         su = pU + src_x/2 + src_y/2 * uPitch;
  1890.         sv = pV + src_x/2 + src_y/2 * vPitch;
  1891.         d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  1892. OddPattern = ((src_y & 1) << 1) | (src_x & 1);
  1893. // extremely cheap way to handle 1 pel cropping
  1894.         for (i = 0; i < dest_dy/2; i ++) {
  1895. if((i+1) < dest_dy/2) {
  1896. su2 = su+uPitch;
  1897. sv2 = sv+vPitch;
  1898. } else {
  1899. su2 = su;
  1900. sv2 = sv;
  1901. }
  1902. /* convert pixels: */
  1903. switch(OddPattern)
  1904. {
  1905. case(0):
  1906. memcpy (d, su, dest_dx/2); /* Flawfinder: ignore */
  1907. memcpy (d + dest_uv_offs, sv, dest_dx/2); /* Flawfinder: ignore */
  1908. break;
  1909. case(1):
  1910. for (j = 0; j < dest_dx/2 -1; j ++) {
  1911. d[j] = ((unsigned int)su[j] + (unsigned int)su[j+1] + 1)>>1;
  1912. d[j + dest_uv_offs] = ((unsigned int)sv[j] + (unsigned int)sv[j+1] + 1)>>1;
  1913. }
  1914. d[j] = su[j];
  1915. d[j + dest_uv_offs] = sv[j];
  1916. break;
  1917. case(2):
  1918. for (j = 0; j < dest_dx/2; j ++) {
  1919. d[j] = ((unsigned int)su[j] + (unsigned int)su2[j] + 1)>>1;
  1920. d[j + dest_uv_offs] = ((unsigned int)sv[j] + (unsigned int)sv2[j] + 1)>>1;
  1921. }
  1922. break;
  1923. case(3):
  1924. for (j = 0; j < dest_dx/2 -1; j ++) {
  1925. d[j] = ((unsigned int)su[j] + (unsigned int)su[j+1] + (unsigned int)su2[j] + (unsigned int)su2[j+1] + 2)>>2;
  1926. d[j + dest_uv_offs] = ((unsigned int)sv[j] + (unsigned int)sv[j+1] + (unsigned int)sv2[j] + (unsigned int)sv2[j+1] + 2)>>2;
  1927. }
  1928. d[j] = ((unsigned int)su[j]+ (unsigned int)su2[j] + 1)>>1;
  1929. d[j + dest_uv_offs] = ((unsigned int)sv[j] + (unsigned int)sv2[j] + 1) >> 1;
  1930. break;
  1931. }
  1932. su += uPitch;
  1933. sv += vPitch;
  1934.             d += dest_pitch/2;
  1935.         }
  1936.     }
  1937. /*
  1938.  *  else {
  1939.  *      put all the color-dependent stuff here ...
  1940.  *  }
  1941.  */
  1942.     return 0;
  1943. }
  1945. int YV12toI420 (unsigned char *dest_ptr, int dest_width, int dest_height,
  1946.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  1947.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  1948.     int src_x, int src_y, int src_dx, int src_dy)
  1949. {
  1950. #if 1
  1951.     unsigned char *pV = src_ptr+src_height*src_pitch,
  1952.                   *pU = pV + src_height*src_pitch/4;
  1954.     return YV12toI420x(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  1955.                        src_ptr, pU, pV, 
  1956.                        src_width, src_height, src_pitch, src_pitch/2, src_pitch/2,
  1957.                        src_x, src_y, src_dx, src_dy);
  1958. #else    
  1959.     /* scale factors: */
  1960.     int scale_x, scale_y;
  1962.     /* check arguments: */
  1963.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  1964.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  1965.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  1966.         return -1;
  1968.     /* remove odd destination pixels: */
  1969.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  1970.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  1971.         return 0;
  1973.     /* check if we have matching chroma components: */
  1974.     if ((src_x & 1) || (src_y & 1))
  1975.         return -1;                          /* can't shift chromas */
  1977.     /* check if bottop-up images: */
  1978.     if (dest_pitch <= 0 || src_pitch <= 0)
  1979.         return -1;                          /* not supported */
  1980. /*
  1981.  *  if (!is_dest_alpha && !is_dest_beta && !is_dest_gamma && !is_dest_kappa)
  1982.  */
  1983.     {
  1984.         /* just move data in, no color adjustments: */
  1985.         unsigned char *s, *d;
  1986.         int src_uv_offs, dest_uv_offs;
  1987.         register int i;
  1989.         /* copy Y plane: */
  1990.         s = src_ptr + src_x + src_y * src_pitch;
  1991.         d = dest_ptr + dest_x + dest_y * dest_pitch;
  1992.         for (i = 0; i < dest_dy; i ++) {
  1993.             memcpy (d, s, dest_dx); /* Flawfinder: ignore */
  1994.             s += src_pitch;
  1995.             d += dest_pitch;
  1996.         }
  1998.         /* get Cr/Cb offsets: */
  1999.         src_uv_offs = src_height * src_pitch / 4;
  2000.         dest_uv_offs = dest_height * dest_pitch / 4;
  2002.         /* copy & flip Cr/Cb planes: */
  2003.         s = (src_ptr + src_height * src_pitch) + src_x/2 + src_y/2 * src_pitch/2;
  2004.         d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  2005.         for (i = 0; i < dest_dy/2; i ++) {
  2006.             memcpy (d, s + src_uv_offs, dest_dx/2); /* Flawfinder: ignore */
  2007.             memcpy (d + dest_uv_offs, s, dest_dx/2); /* Flawfinder: ignore */
  2008.             s += src_pitch/2;
  2009.             d += dest_pitch/2;
  2010.         }
  2011.     }
  2012. /*
  2013.  *  else {
  2014.  *      put all the color-dependent stuff here ...
  2015.  *  }
  2016.  */
  2017.     return 0;
  2018. #endif
  2019. }
  2021. int YV12toYV12x (unsigned char *dest_ptr, int dest_width, int dest_height,
  2022.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2023.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  2024.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  2025.                  int src_x, int src_y, int src_dx, int src_dy)
  2026. {
  2027.     return I420toYV12x(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  2028.                        pY, pU, pV, 
  2029.                        src_width, src_height, yPitch, uPitch, vPitch,
  2030.                        src_x, src_y, src_dx, src_dy);
  2031. }
  2033. int YV12toYV12 (unsigned char *dest_ptr, int dest_width, int dest_height,
  2034.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2035.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  2036.     int src_x, int src_y, int src_dx, int src_dy)
  2037. {
  2038.     unsigned char *pV = src_ptr+src_height*src_pitch,
  2039.                   *pU = pV + src_height*src_pitch/4;
  2041.     return I420toYV12x(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  2042.                        src_ptr, pU, pV, 
  2043.                        src_width, src_height, src_pitch, src_pitch/2, src_pitch/2,
  2044.                        src_x, src_y, src_dx, src_dy);
  2045. }
  2047. int YV12toYUY2x (unsigned char *dest_ptr, int dest_width, int dest_height,
  2048.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2049.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  2050.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  2051.                  int src_x, int src_y, int src_dx, int src_dy)
  2052. {
  2053.     return I420toYUY2x(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  2054.                        pY, pU, pV, 
  2055.                        src_width, src_height, yPitch, uPitch, vPitch,
  2056.                        src_x, src_y, src_dx, src_dy);
  2057. }
  2059. int YV12toYUY2 (unsigned char *dest_ptr, int dest_width, int dest_height,
  2060.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2061.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  2062.     int src_x, int src_y, int src_dx, int src_dy)
  2063. {
  2064.     unsigned char *pV = src_ptr+src_height*src_pitch,
  2065.                   *pU = pV + src_height*src_pitch/4;
  2067.     return I420toYUY2x(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  2068.                        src_ptr, pU, pV, 
  2069.                        src_width, src_height, src_pitch, src_pitch/2, src_pitch/2,
  2070.                        src_x, src_y, src_dx, src_dy);
  2071. }
  2073. int YV12toUYVYx (unsigned char *dest_ptr, int dest_width, int dest_height,
  2074.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2075.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  2076.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  2077.                  int src_x, int src_y, int src_dx, int src_dy)
  2078. {
  2079.     return I420toUYVYx(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  2080.                        pY, pU, pV, 
  2081.                        src_width, src_height, yPitch, uPitch, vPitch,
  2082.                        src_x, src_y, src_dx, src_dy);
  2083. }
  2085. int YV12toUYVY (unsigned char *dest_ptr, int dest_width, int dest_height,
  2086.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2087.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  2088.     int src_x, int src_y, int src_dx, int src_dy)
  2089. {
  2090.     unsigned char *pV = src_ptr+src_height*src_pitch,
  2091.                   *pU = pV + src_height*src_pitch/4;
  2093.     return I420toUYVYx(dest_ptr, dest_width, dest_height, dest_pitch, dest_x, dest_y, dest_dx, dest_dy,
  2094.                        src_ptr, pU, pV, 
  2095.                        src_width, src_height, src_pitch, src_pitch/2, src_pitch/2,
  2096.                        src_x, src_y, src_dx, src_dy);
  2097. }
  2099. static void lineYVU9toI420 (unsigned char *d, unsigned char *s, int x, int dx)
  2100. {
  2101.     register int i;
  2103.     /* first pixel: */
  2104. // extremely cheap way to handle 1 pel cropping
  2105.     switch(x&3)
  2106. {
  2107. case(0):
  2108. case(1):
  2109. break;    
  2110. case(2):
  2111.         d[0] = s[0];
  2112.         s += 1;
  2113.         d += 1;
  2114.         dx -= 2;
  2115. break;
  2116. case(3):
  2117. //d[0] = s[0];
  2118. s += 1;
  2119. //d += 1;
  2120.         //dx -= 2;
  2121. break;
  2122. }    
  2123.     /* the main loop: */
  2124.     for (i = 0; i < dx/4; i ++) {
  2125.         d[i*2] = s[i];
  2126.         d[i*2+1] = s[i];
  2127.     }
  2128.     /* last pixel: */
  2129.     if (dx & 2)
  2130.         d[dx/2] = s[dx/4];
  2131. }
  2133. #if 1
  2135. /*-----------------2/24/2002 2:01PM-----------------
  2136.  * fixes:
  2137.  *  - switched u and v pointers
  2138.  * --------------------------------------------------*/
  2139. int YVU9toI420 (unsigned char *dest_ptr, int dest_width, int dest_height,
  2140.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2141.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  2142.     int src_x, int src_y, int src_dx, int src_dy)
  2143. {
  2144.     /* scale factors: */
  2145.     int scale_x, scale_y;
  2147.     /* check arguments: */
  2148.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  2149.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  2150.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  2151.         return -1;
  2153.     /* remove odd destination pixels: */
  2154.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  2155.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  2156.         return 0;
  2158.     /* check if we have matching chroma components: */
  2159.     //if ((src_x & 1) || (src_y & 1))
  2160.     //return -1;                          /* can't shift chromas */
  2162.     /* check if bottop-up images: */
  2163.     if (dest_pitch <= 0 || src_pitch <= 0)
  2164.         return -1;                          /* not supported */
  2165. /*
  2166.  *  if (!is_dest_alpha && !is_dest_beta && !is_dest_gamma && !is_dest_kappa)
  2167.  */
  2168.     {
  2169.         /* no color adjustments: */
  2170.         unsigned char *s, *d;
  2171.         int src_uv_offs, dest_uv_offs;
  2172.         register int j;
  2174.         /* copy Y plane: */
  2175.         s = src_ptr + src_x + src_y * src_pitch;
  2176.         d = dest_ptr + dest_x + dest_y * dest_pitch;
  2177.         for (j = 0; j < dest_dy; j ++) {
  2178.             memcpy (d, s, dest_dx); /* Flawfinder: ignore */
  2179.             s += src_pitch;
  2180.             d += dest_pitch;
  2181.         }
  2183.         /* get Cr/Cb offsets: */
  2184.         src_uv_offs = src_height * src_pitch / 16;
  2185.         dest_uv_offs = dest_height * dest_pitch / 4;
  2187.         /* get pointers: */
  2188.         s = (src_ptr + src_height * src_pitch) + src_x/4 + src_y/4 * src_pitch/4;
  2189.         d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  2191.         /* top lines: */
  2192. // extremely cheap way to handle 1 pel cropping
  2193.         switch(src_y & 3) 
  2194. {
  2195. case(2):
  2196. case(3):
  2197.             lineYVU9toI420 (d, s + src_uv_offs, src_x, dest_dx);   /* Cr */
  2198.             lineYVU9toI420 (d + dest_uv_offs, s, src_x, dest_dx);  /* Cb */
  2199.             s += src_pitch/4;
  2200.             d += dest_pitch/2;
  2201.             dest_dy -= 2;
  2202. break;
  2203. case(0):
  2204. case(1):
  2205. break;
  2206.         }
  2207.         /* the main loop (processes two lines a time): */
  2208.         for (j = 0; j < dest_dy/4; j ++) {
  2209.             lineYVU9toI420 (d, s + src_uv_offs, src_x, dest_dx);   /* Cr */
  2210.             memcpy (d + dest_pitch/2, d, dest_dx/2); /* Flawfinder: ignore */
  2211.             lineYVU9toI420 (d + dest_uv_offs, s, src_x, dest_dx);  /* Cb */
  2212.             memcpy (d + dest_pitch/2 + dest_uv_offs, d + dest_uv_offs, dest_dx/2); /* Flawfinder: ignore */
  2213.             s += src_pitch/4;
  2214.             d += dest_pitch;
  2215.         }
  2216.         /* bottom lines: */
  2217.         if (dest_dy & 2) {
  2218.             lineYVU9toI420 (d, s + src_uv_offs, src_x, dest_dx);   /* Cr */
  2219.             lineYVU9toI420 (d + dest_uv_offs, s, src_x, dest_dx);  /* Cb */
  2220.         }
  2221.     }
  2222. /*
  2223.  *  else {
  2224.  *      put all the color-dependent stuff here ...
  2225.  *  }
  2226.  */
  2227.     return 0;
  2228. }
  2231. #else
  2233. int YVU9toI420 (unsigned char *dest_ptr, int dest_width, int dest_height,
  2234.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2235.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  2236.     int src_x, int src_y, int src_dx, int src_dy)
  2237. {
  2238.     /* scale factors: */
  2239.     int scale_x, scale_y;
  2241.     /* check arguments: */
  2242.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  2243.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  2244.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  2245.         return -1;
  2247.     /* remove odd destination pixels: */
  2248.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  2249.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  2250.         return 0;
  2252.     /* check if we have matching chroma components: */
  2253.     if ((src_x & 1) || (src_y & 1))
  2254.         return -1;                          /* can't shift chromas */
  2256.     /* check if bottop-up images: */
  2257.     if (dest_pitch <= 0 || src_pitch <= 0)
  2258.         return -1;                          /* not supported */
  2259. /*
  2260.  *  if (!is_dest_alpha && !is_dest_beta && !is_dest_gamma && !is_dest_kappa)
  2261.  */
  2262.     {
  2263.         /* no color adjustments: */
  2264.         unsigned char *s, *d;
  2265.         int src_uv_offs, dest_uv_offs;
  2266.         register int j;
  2268.         /* copy Y plane: */
  2269.         s = src_ptr + src_x + src_y * src_pitch;
  2270.         d = dest_ptr + dest_x + dest_y * dest_pitch;
  2271.         for (j = 0; j < dest_dy; j ++) {
  2272.             memcpy (d, s, dest_dx); /* Flawfinder: ignore */
  2273.             s += src_pitch;
  2274.             d += dest_pitch;
  2275.         }
  2277.         /* get Cr/Cb offsets: */
  2278.         src_uv_offs = src_height * src_pitch / 16;
  2279.         dest_uv_offs = dest_height * dest_pitch / 4;
  2281.         /* get pointers: */
  2282.         s = (src_ptr + src_height * src_pitch) + src_x/4 + src_y/4 * src_pitch/4;
  2283.         d = (dest_ptr + dest_height * dest_pitch) + dest_x/2 + dest_y/2 * dest_pitch/2;
  2285.         /* top lines: */
  2286.         if (src_y & 2) {
  2287.             lineYVU9toI420 (d, s, src_x, dest_dx);   /* Cr */
  2288.             lineYVU9toI420 (d + dest_uv_offs, s + src_uv_offs, src_x, dest_dx);  /* Cb */
  2289.             s += src_pitch/4;
  2290.             d += dest_pitch/2;
  2291.             dest_dy -= 2;
  2292.         }
  2293.         /* the main loop (processes two lines a time): */
  2294.         for (j = 0; j < dest_dy/4; j ++) {
  2295.             lineYVU9toI420 (d, s, src_x, dest_dx);   /* Cr */
  2296.             memcpy (d + dest_pitch/2, d, dest_dx/2); /* Flawfinder: ignore */
  2297.             lineYVU9toI420 (d + dest_uv_offs, s + src_uv_offs, src_x, dest_dx);  /* Cb */
  2298.             memcpy (d + dest_pitch/2 + dest_uv_offs, d + dest_uv_offs, dest_dx/2); /* Flawfinder: ignore */
  2299.             s += src_pitch/4;
  2300.             d += dest_pitch;
  2301.         }
  2302.         /* bottom lines: */
  2303.         if (dest_dy & 2) {
  2304.             lineYVU9toI420 (d, s, src_x, dest_dx);   /* Cr */
  2305.             lineYVU9toI420 (d + dest_uv_offs, s + src_uv_offs, src_x, dest_dx);  /* Cb */
  2306.         }
  2307.     }
  2308. /*
  2309.  *  else {
  2310.  *      put all the color-dependent stuff here ...
  2311.  *  }
  2312.  */
  2313.     return 0;
  2314. }
  2316. #endif /* YUV9 */
  2320. static int YUY2toPlanarYUV(unsigned char *dY, unsigned char *dU, unsigned char *dV,
  2321.                            int dest_width, int dest_height,
  2322.                            int dyPitch, int duPitch, int dvPitch,
  2323.                            int dest_x, int dest_y, int dest_dx, int dest_dy,
  2324.                            unsigned char *src_ptr,
  2325.                            int src_width, int src_height, int src_pitch,
  2326.                            int src_x, int src_y, int src_dx, int src_dy)
  2327. {
  2328.     /* scale factors: */
  2329.     int scale_x, scale_y;
  2330.     unsigned char *s1, *s2, *d1, *d2, *dv, *du;
  2331.     register int i, j;
  2333.     /* check arguments: */
  2334.     if (!chk_args (dY, dest_width, dest_height, dyPitch,
  2335.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  2336.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  2337.         return -1;
  2339.     /* remove odd destination pixels: */
  2340.     if (!adjust_range (&dest_x, &dest_dx, &src_x, &src_dx, scale_x) ||
  2341.         !adjust_range (&dest_y, &dest_dy, &src_y, &src_dy, scale_y))
  2342.         return 0;
  2344.     /* check if we have misaligned source: */
  2345.     if (src_x & 1)
  2346.         return -1; /* can't shift chromas */
  2348.     /* check if bottop-up images: */
  2349.     if (dyPitch <= 0)
  2350.         return -1;     /* not supported */
  2351.     if (src_pitch < 0)
  2352.         src_ptr -= (src_height-1) * src_pitch;
  2354.     /* just move data in, no color adjustments: */
  2355.     /* get pointers: */
  2356.     s1 = src_ptr + src_x * 2 + src_y * src_pitch;    /* 2 bytes/pixel */
  2357.     s2 = s1 + src_pitch;
  2358.     d1 = dY + dest_x + dest_y * dyPitch;   /* luma offsets  */
  2359.     d2 = d1 + dyPitch;
  2360.     
  2361.     du = dU + (dest_x/2 + dest_y/2 * duPitch);
  2362.     dv = dV + (dest_x/2 + dest_y/2 * dvPitch);
  2364. #if (defined(_M_IX86) || defined(_USE_MMX_BLENDERS)) && !defined(WINCE_EMULATOR)
  2365.     if (_x86_MMX_Available )
  2366.     {
  2367.         //Use our MMX versions.....
  2368.         HX_ASSERT( src_dx==dest_dx && src_dy==dest_dy );
  2369.         YUY2ToPlanarYUV_MMX( d1, d2, du, dv,
  2370.                              dyPitch, duPitch, dvPitch,
  2371.                              dest_dx, dest_dy, 
  2372.                              s1, s2, src_pitch
  2373.                              );
  2374.     }
  2375.     else
  2376. #endif    
  2377.     {
  2378.         /* the main loop (processes lines a time): */
  2379.         for (i = 0; i < dest_dy/2; i ++)
  2380.         {
  2381.             /* copy 2x2 pixels: */
  2382.             for (j = 0; j < dest_dx/2; j ++)
  2383.             {
  2384.                 /* copy luma components: */
  2385.                 d1[j*2]   = s1[j*4];
  2386.                 d1[j*2+1] = s1[j*4+2];
  2387.                 d2[j*2]   = s2[j*4];
  2388.                 d2[j*2+1] = s2[j*4+2];
  2389.                 
  2390.                 /* average chromas: */
  2391.                 du[j] = ((unsigned int) s1[j*4+1] + (unsigned int)s2[j*4+1]) >> 1;
  2392.                 dv[j] = ((unsigned int) s1[j*4+3] + (unsigned int)s2[j*4+3]) >> 1;
  2393.             }
  2394.             
  2395.             s1 += src_pitch*2;  s2 += src_pitch*2;
  2396.             d1 += dyPitch*2;    d2 += dyPitch*2;
  2397.             du += duPitch;      dv += dvPitch;
  2398.         }
  2399.     }
  2401.     return 0;
  2402. }
  2404. int YUY2toI420x (unsigned char *dest_ptr, int dest_width, int dest_height,
  2405.                  int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  2406.                  unsigned char *pY, unsigned char *pU, unsigned char *pV,
  2407.                  int src_width, int src_height, int yPitch, int uPitch, int vPitch,
  2408.                  int src_x, int src_y, int src_dx, int src_dy)
  2409. {
  2410.     // No need for seperate yuv pointers since yuy2 is packed
  2411.     return YUY2toI420(dest_ptr, dest_width, dest_height,
  2412.                       dest_pitch, dest_x, dest_y, dest_dx, dest_dy,  
  2413.                       pY, src_width, src_height, yPitch,
  2414.                       src_x, src_y, src_dx, src_dy);
  2415. }
  2417. /*
  2418.  * Mac YUVU/YVU2 formats: 
  2419.  * 8-bit 4:2:2 Component Y扖bCr format. 
  2420.  * Each 16 bit pixel is represented by an unsigned eight bit luminance 
  2421.  * component and two two抯 complement signed eight bit chroma components. 
  2422.  * Each pair of pixels shares a common set of chroma values. 
  2423.  * The components are ordered in memory; Y0, Cb, Y1, Cr. 
  2424.  * The luminance components have a range of [0, 255], 
  2425.  * the chroma values have a range of [-127, +127]. 
  2426.  * This format is equivalent to the 憏uv2