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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
yuv2yuv.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：145k
源码类别：

Symbian

开发平台：

Visual C++

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