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

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

Symbian

开发平台：

Visual C++

444.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: 444.c,v 1.2.8.1 2004/07/09 02:00:07 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. #include <stdlib.h>
  51. #include "nostatic/colorlib.h"
  52. #include "nostatic/yuv.h"
  54. /*
  55.  * Format-conversion routines.
  56.  * Use:
  57.  *  int XXXXtoYYYYEx (unsigned char *dest_ptr, int dest_width, int dest_height,
  58.  *      int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  59.  *      unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  60.  *      int src_x, int src_y, int src_dx, int src_dy);
  61.  * Input:
  62.  *  dest_ptr - pointer to a destination buffer
  63.  *  dest_width, dest_height - width/height of the destination image (pixels)
  64.  *  dest_pitch - pitch of the dest. buffer (in bytes; <0 - if bottom up image)
  65.  *  dest_x, dest_y, dest_dx, dest_dy - destination rectangle (pixels)
  66.  *  src_ptr - pointer to an input image
  67.  *  src_width, src_height - width/height of the input image (pixels)
  68.  *  src_pitch - pitch of the source buffer (in bytes; <0 - if bottom up image)
  69.  *  src_x, src_y, src_dx, src_dy - source rectangle (pixels)
  70.  * Returns:
  71.  *  0 - if success; -1 if failure.
  72.  * Notes:
  73.  *  a) In all cases, pointers to the source and destination buffers must be
  74.  *     DWORD aligned, and both pitch parameters must be multiple of 4!!!
  75.  *  b) Converters that deal with YUV 4:2:2, or 4:2:0 formats may also require
  76.  *     rectangle parameters (x,y,dx,dy) to be multiple of 2. Failure to provide
  77.  *     aligned rectangles will result in partially converted image.
  78.  *  c) Currently only scale factors of 1:1 and 2:1 are supported; if the rates
  79.  *     dest_dx/src_dx & dest_dy/src_dy are neither 1, or 2, the converters
  80.  *     will fail.
  81.  */
  83. #define BYTESPERPIXEL 2
  85. /* Indexing tables */
  86. static const int next[3] = {1, 2, 0};                 /* (ibuf+1)%3 table */
  87. static const int next2[3] = {2, 0, 1};                /* (ibuf+2)%3 table */
  89. /* Half resolution converter.  */
  90. static void halfI420toRGB444 (unsigned char *d1,
  91. int dest_x, unsigned char *sy1, 
  92. unsigned char *sy2, unsigned char *su, 
  93. unsigned char *sv, int src_x, int dx, int isodd,
  94.       color_data_t* pcd)
  95. {
  96.   /* check if we have misaligned input/output: */
  97.   if ((src_x ^ dest_x) & 1) {
  98.     
  99.     ; /* not implemented yet */
  100.     
  101.   } else {
  102.     
  103.     /* aligned input/output: */
  104.     register int y11, y12;
  105.     register int rv1, guv1, bu1, rv2, guv2, bu2;
  106.     register int i;
  107.     
  108.     /* source width should always be multiples of 4 */
  109.     /*    assert((src_x & 3)==0); */
  111.     /* convert all integral 2x4 blocks: */
  112.     if (isodd)
  113.       for (i = 0; i < dx/4; i ++) {
  115. /* first 2x2 block */
  116. rv1 = pcd->rvtab[sv[0]];
  117. guv1 = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  118. bu1 = pcd->butab[su[0]];
  119. y11 = (pcd->ytab[sy1[0]] + pcd->ytab[sy1[1]] + pcd->ytab[sy2[0]] + pcd->ytab[sy2[1]])>>2; /* avg */
  121. /* second 2x2 block */
  122. rv2  = pcd->rvtab[sv[1]];
  123. guv2 = pcd->gutab[su[1]] + pcd->gvtab[sv[1]];
  124. bu2  = pcd->butab[su[1]];
  125. y12 = (pcd->ytab[sy1[2]] + pcd->ytab[sy1[3]] + pcd->ytab[sy2[2]] + pcd->ytab[sy2[3]])>>2;
  127. /* output 4 bytes at a time */
  128. *(unsigned int *)(d1+0) =
  129.   (CLIP4[y11 + bu1  + DITH4L] << 0)  |
  130.   (CLIP4[y11 + guv1 + DITH4L] << 4)  |
  131.   (CLIP4[y11 + rv1  + DITH4L] << 8) |
  132.   (CLIP4[y12 + bu2  + DITH4H] << 16) |
  133.   (CLIP4[y12 + guv2 + DITH4H] << 20) |
  134.   (CLIP4[y12 + rv2  + DITH4H] << 24) ;
  136. /* next 4x2 block */
  137. sy1 += 4; sy2 += 4;
  138. su += 2; sv += 2;
  139. d1 += 2*BPP2;
  140.       }
  141.     else
  142.       for (i = 0; i < dx/4; i ++) {
  144. /* first 2x2 block */
  145. rv1 = pcd->rvtab[sv[0]];
  146. guv1 = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  147. bu1 = pcd->butab[su[0]];
  148. y11 = (pcd->ytab[sy1[0]] + pcd->ytab[sy1[1]] + pcd->ytab[sy2[0]] + pcd->ytab[sy2[1]])>>2; /* avg */
  150. /* second 2x2 block */
  151. rv2  = pcd->rvtab[sv[1]];
  152. guv2 = pcd->gutab[su[1]] + pcd->gvtab[sv[1]];
  153. bu2  = pcd->butab[su[1]];
  154. y12 = (pcd->ytab[sy1[2]] + pcd->ytab[sy1[3]] + pcd->ytab[sy2[2]] + pcd->ytab[sy2[3]])>>2;
  156. /* output 4 bytes at a time */
  157. *(unsigned int *)(d1+0) =
  158.   (CLIP4[y11 + bu1  + DITH4H] << 0)  |
  159.   (CLIP4[y11 + guv1 + DITH4H] << 4)  |
  160.   (CLIP4[y11 + rv1  + DITH4H] << 8) |
  161.   (CLIP4[y12 + bu2  + DITH4L] << 16) |
  162.   (CLIP4[y12 + guv2 + DITH4L] << 20) |
  163.   (CLIP4[y12 + rv2  + DITH4L] << 24) ;
  165. /* next 4x2 block */
  166. sy1 += 4; sy2 += 4;
  167. su += 2; sv += 2;
  168. d1 += 2*BPP2;
  169.       }
  171.   }
  172. }
  174. static void dblineI420toRGB444 (unsigned char *d1, unsigned char *d2, 
  175. int dest_x, unsigned char *sy1, 
  176. unsigned char *sy2, unsigned char *su, 
  177. unsigned char *sv, int src_x, int dx,
  178. color_data_t* pcd)
  179. {
  180.     /* check if we have misaligned input/output: */
  181.     if ((src_x ^ dest_x) & 1) {
  183.         ; /* not implemented yet */
  185.     } else {
  187.         /* aligned input/output: */
  188.         register int y11, y12, y21, y22;
  189.         register int rv, guv, bu;
  190.         register int i;
  192.         /* convert first 2x1 block: */
  193.         if (dest_x & 1) {
  195.             rv  = pcd->rvtab[sv[0]];
  196.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  197.             bu  = pcd->butab[su[0]];
  198.             y11 = pcd->ytab[sy1[0]];
  199.             y21 = pcd->ytab[sy2[0]];
  201.             /* output 2 bytes at a time */
  202.             *(unsigned short *)(d1+0) =
  203.                 (CLIP4[y11 + bu  + DITH4L] << 0)  |
  204.                 (CLIP4[y11 + guv + DITH4L] << 4)  |
  205.                 (CLIP4[y11 + rv  + DITH4L] << 8) ;
  207.             *(unsigned short *)(d2+0) =
  208.                 (CLIP4[y21 + bu  + DITH4H] << 0)  |
  209.                 (CLIP4[y21 + guv + DITH4H] << 4)  |
  210.                 (CLIP4[y21 + rv  + DITH4H] << 8) ;
  212.             sy1 += 1; sy2 += 1;
  213.             su += 1; sv += 1;
  214.             d1 += BPP2; d2 += BPP2;
  215.             dest_x ++; dx --;
  216.         }
  218.         /* convert first 2x2 block: */
  219.         if (dest_x & 2) {
  221.             rv  = pcd->rvtab[sv[0]];
  222.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  223.             bu  = pcd->butab[su[0]];
  224.             y11 = pcd->ytab[sy1[0]];
  225.             y12 = pcd->ytab[sy1[1]];
  227.             /* output 4 bytes at a time */
  228.             *(unsigned int *)(d1+0) =
  229.                 (CLIP4[y11 + bu  + DITH4L] << 0)  |
  230.                 (CLIP4[y11 + guv + DITH4L] << 4)  |
  231.                 (CLIP4[y11 + rv  + DITH4L] << 8) |
  232.                 (CLIP4[y12 + bu  + DITH4H] << 16) |
  233.                 (CLIP4[y12 + guv + DITH4H] << 20) |
  234.                 (CLIP4[y12 + rv  + DITH4H] << 24) ;
  236.             y21 = pcd->ytab[sy2[0]];
  237.             y22 = pcd->ytab[sy2[1]];
  239.             *(unsigned int *)(d2+0) =
  240.                 (CLIP4[y21 + bu  + DITH4H] << 0)  |
  241.                 (CLIP4[y21 + guv + DITH4H] << 4)  |
  242.                 (CLIP4[y21 + rv  + DITH4H] << 8) |
  243.                 (CLIP4[y22 + bu  + DITH4L] << 16) |
  244.                 (CLIP4[y22 + guv + DITH4L] << 20) |
  245.                 (CLIP4[y22 + rv  + DITH4L] << 24) ;
  247.             sy1 += 2; sy2 += 2;
  248.             su += 1; sv += 1;
  249.             d1 += 2*BPP2; d2 += 2*BPP2;
  250.             dest_x += 2; dx -= 2;
  251.         }
  253.         /* convert all integral 2x4 blocks: */
  254.         for (i = 0; i < dx/4; i ++) {
  256.             /* first 2x2 block */
  257.             rv = pcd->rvtab[sv[0]];
  258.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  259.             bu = pcd->butab[su[0]];
  260.             y11 = pcd->ytab[sy1[0]];
  261.             y12 = pcd->ytab[sy1[1]];
  263.             /* output 4 bytes at a time */
  264.             *(unsigned int *)(d1+0) =
  265.                 (CLIP4[y11 + bu  + DITH4L] << 0)  |
  266.                 (CLIP4[y11 + guv + DITH4L] << 4)  |
  267.                 (CLIP4[y11 + rv  + DITH4L] << 8) |
  268.                 (CLIP4[y12 + bu  + DITH4H] << 16) |
  269.                 (CLIP4[y12 + guv + DITH4H] << 20) |
  270.                 (CLIP4[y12 + rv  + DITH4H] << 24) ;
  272.             y21 = pcd->ytab[sy2[0]];
  273.             y22 = pcd->ytab[sy2[1]];
  275.             *(unsigned int *)(d2+0) =
  276.                 (CLIP4[y21 + bu  + DITH4H] << 0)  |
  277.                 (CLIP4[y21 + guv + DITH4H] << 4)  |
  278.                 (CLIP4[y21 + rv  + DITH4H] << 8) |
  279.                 (CLIP4[y22 + bu  + DITH4L] << 16) |
  280.                 (CLIP4[y22 + guv + DITH4L] << 20) |
  281.                 (CLIP4[y22 + rv  + DITH4L] << 24) ;
  283.             /* second 2x2 block */
  284.             rv  = pcd->rvtab[sv[1]];
  285.             guv = pcd->gutab[su[1]] + pcd->gvtab[sv[1]];
  286.             bu  = pcd->butab[su[1]];
  287.             y11 = pcd->ytab[sy1[2]];
  288.             y12 = pcd->ytab[sy1[3]];
  290.             *(unsigned int *)(d1+2*BPP2) =
  291.                 (CLIP4[y11 + bu  + DITH4L] << 0)  |
  292.                 (CLIP4[y11 + guv + DITH4L] << 4)  |
  293.                 (CLIP4[y11 + rv  + DITH4L] << 8) |
  294.                 (CLIP4[y12 + bu  + DITH4H] << 16) |
  295.                 (CLIP4[y12 + guv + DITH4H] << 20) |
  296.                 (CLIP4[y12 + rv  + DITH4H] << 24) ;
  298.             y21 = pcd->ytab[sy2[2]];
  299.             y22 = pcd->ytab[sy2[3]];
  301.             *(unsigned int *)(d2+2*BPP2) =
  302.                 (CLIP4[y21 + bu  + DITH4H] << 0)  |
  303.                 (CLIP4[y21 + guv + DITH4H] << 4)  |
  304.                 (CLIP4[y21 + rv  + DITH4H] << 8) |
  305.                 (CLIP4[y22 + bu  + DITH4L] << 16) |
  306.                 (CLIP4[y22 + guv + DITH4L] << 20) |
  307.                 (CLIP4[y22 + rv  + DITH4L] << 24) ;
  309.             /* next 4x2 block */
  310.             sy1 += 4; sy2 += 4;
  311.             su += 2; sv += 2;
  312.             d1 += 4*BPP2; d2 += 4*BPP2;
  313.         }
  315.         /* convert last 2x2 block: */
  316.         if (dx & 2) {
  318.             rv = pcd->rvtab[sv[0]];
  319.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  320.             bu = pcd->butab[su[0]];
  321.             y11 = pcd->ytab[sy1[0]];
  322.             y12 = pcd->ytab[sy1[1]];
  324.             /* output 4 bytes at a time */
  325.             *(unsigned int *)(d1+0) =
  326.                 (CLIP4[y11 + bu  + DITH4L] << 0)  |
  327.                 (CLIP4[y11 + guv + DITH4L] << 4)  |
  328.                 (CLIP4[y11 + rv  + DITH4L] << 8) |
  329.                 (CLIP4[y12 + bu  + DITH4H] << 16) |
  330.                 (CLIP4[y12 + guv + DITH4H] << 20) |
  331.                 (CLIP4[y12 + rv  + DITH4H] << 24) ;
  333.             y21 = pcd->ytab[sy2[0]];
  334.             y22 = pcd->ytab[sy2[1]];
  336.             *(unsigned int *)(d2+0) =
  337.                 (CLIP4[y21 + bu  + DITH4H] << 0)  |
  338.                 (CLIP4[y21 + guv + DITH4H] << 4)  |
  339.                 (CLIP4[y21 + rv  + DITH4H] << 8) |
  340.                 (CLIP4[y22 + bu  + DITH4L] << 16) |
  341.                 (CLIP4[y22 + guv + DITH4L] << 20) |
  342.                 (CLIP4[y22 + rv  + DITH4L] << 24) ;
  344.             sy1 += 2; sy2 += 2;
  345.             su += 1; sv += 1;
  346.             d1 += 2*BPP2; d2 += 2*BPP2;
  347.             dx -= 2;
  348.         }
  350.         /* convert last 2x1 block: */
  351.         if (dx & 1) {
  353.             rv  = pcd->rvtab[sv[0]];
  354.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  355.             bu  = pcd->butab[su[0]];
  356.             y11 = pcd->ytab[sy1[0]];
  357.             y21 = pcd->ytab[sy2[0]];
  359.             /* output 2 bytes at a time */
  360.             *(unsigned short *)(d1+0) =
  361.                 (CLIP4[y11 + bu  + DITH4L] << 0)  |
  362.                 (CLIP4[y11 + guv + DITH4L] << 4)  |
  363.                 (CLIP4[y11 + rv  + DITH4L] << 8) ;
  365.             *(unsigned short *)(d2+0) =
  366.                 (CLIP4[y21 + bu  + DITH4H] << 0)  |
  367.                 (CLIP4[y21 + guv + DITH4H] << 4)  |
  368.                 (CLIP4[y21 + rv  + DITH4H] << 8) ;
  369.         }
  370.     }
  371. }
  373. #define DITH1X4L 0x01002004
  374. #define DITH1X4H 0x0300600C
  376. #define DITH2X4L 0x02004008
  377. #define DITH2X4H 0x0600C018
  379. #define DITH4X4L 0x04008010
  380. #define DITH4X4H 0x0C018030
  382. /* RGB444 version: */
  383. static void dblineXRGBtoRGB444x2 (unsigned char *d1, unsigned char *d2, int dest_x,
  384.     unsigned char *s1, unsigned char *s2, int src_x, int dx,
  385. color_data_t* pcd)
  386. {
  387.     register unsigned int a, b, c, d, e, f;
  388.     register unsigned int w, x, y, z;
  390.     /* convert first 2x1 block: */
  391.     if (dest_x & 1) {
  393.         /* Input pels  =>   Output pels
  394.          *  a b             w  x
  395.          *  c d             w' x'
  396.          */
  398.         /* top line */
  399.         a = *(unsigned int *)s1;
  400.         b = *(unsigned int *)(s1+BPP4);
  402.         w = a     + DITH1X4L;
  403.         x = a + b + DITH2X4H;
  405.         /* pack and store */
  406.         *(unsigned int *)d1 =
  407.             ((w & 0x000000f0) >> 4)  |
  408.             ((w & 0x00078000) >> 11) |
  409.             ((w & 0x3c000000) >> 18) |
  410.             ((x & 0x000001e0) << 11) |
  411.             ((x & 0x000f0000) << 4)  |
  412.             ((x & 0x78000000) >> 3);
  414.         /* bottom line */
  415.         c = *(unsigned int *)s2;
  416.         d = *(unsigned int *)(s2+BPP4);
  418.         w = a + c         + DITH2X4H;
  419.         x = a + b + c + d + DITH4X4L;
  421.         /* pack and store */
  422.         *(unsigned int *)d2 =
  423.             ((w & 0x000001e0) >> 5)  |
  424.             ((w & 0x000f0000) >> 12) |
  425.             ((w & 0x78000000) >> 19) |
  426.             ((x & 0x000003c0) << 10) |
  427.             ((x & 0x001e0000) << 3)  |
  428.             ((x & 0xf0000000) >> 4);
  430.         /* bump pointers to next block */
  431.         s1 += BPP4; s2 += BPP4;
  432.         d1 += 2*BPP2; d2 += 2*BPP2;
  433.         dx -= 1;
  434.     }
  436.     /* process all integral 2x2 blocks: */
  437.     while (dx > 2) {    /* we need to leave at least one block */
  439.         /*
  440.          * Input stored as 00 RRRRRRRR 000 GGGGGGGG 000 BBBBBBBB
  441.          *
  442.          * Input pels       Output pels
  443.          *  a b e           w  x  y  z
  444.          *  c d f           w' x' y' z'
  445.          */
  447.         /* top line */
  448.         a = *(unsigned int *)s1;
  449.         b = *(unsigned int *)(s1+BPP4);
  450.         e = *(unsigned int *)(s1+2*BPP4);
  452.         w = a     + DITH1X4L;
  453.         x = a + b + DITH2X4H;
  454.         y = b     + DITH1X4L;
  455.         z = b + e + DITH2X4H;
  457.         /* pack and store */
  458.         *(unsigned int *)d1 =
  459.             ((w & 0x000000f0) >> 4)  |
  460.             ((w & 0x00078000) >> 11) |
  461.             ((w & 0x3c000000) >> 18) |
  462.             ((x & 0x000001e0) << 11) |
  463.             ((x & 0x000f0000) << 4)  |
  464.             ((x & 0x78000000) >> 3);
  465.         *(unsigned int *)(d1+2*BPP2) =
  466.             ((y & 0x000000f0) >> 4)  |
  467.             ((y & 0x00078000) >> 11) |
  468.             ((y & 0x3c000000) >> 18) |
  469.             ((z & 0x000001e0) << 11) |
  470.             ((z & 0x000f0000) << 4)  |
  471.             ((z & 0x78000000) >> 3);
  473.         /* bottom line */
  474.         c = *(unsigned int *)s2;
  475.         d = *(unsigned int *)(s2+BPP4);
  476.         f = *(unsigned int *)(s2+2*BPP4);
  478.         w = a + c         + DITH2X4H;
  479.         x = a + b + c + d + DITH4X4L;
  480.         y = b + d         + DITH2X4H;
  481.         z = b + e + d + f + DITH4X4L;
  483.         /* pack and store */
  484.         *(unsigned int *)d2 =
  485.             ((w & 0x000001e0) >> 5)  |
  486.             ((w & 0x000f0000) >> 12) |
  487.             ((w & 0x78000000) >> 19) |
  488.             ((x & 0x000003c0) << 10) |
  489.             ((x & 0x001e0000) << 3)  |
  490.             ((x & 0xf0000000) >> 4);
  491.         *(unsigned int *)(d2+2*BPP2) =
  492.             ((y & 0x000001e0) >> 5)  |
  493.             ((y & 0x000f0000) >> 12) |
  494.             ((y & 0x78000000) >> 19) |
  495.             ((z & 0x000003c0) << 10) |
  496.             ((z & 0x001e0000) << 3)  |
  497.             ((z & 0xf0000000) >> 4);
  499.         /* next 2x2 input block */
  500.         s1 += 2*BPP4; s2 += 2*BPP4;
  501.         d1 += 4*BPP2; d2 += 4*BPP2;
  502.         dx -= 2;
  503.     }
  505.     /* check if this is the last 2x2 block: */
  506.     if (dx > 1) {
  508.         /*
  509.          * For last 4 output pels, repeat final input pel
  510.          * for offscreen input.  Equivalent to pixel-doubling the
  511.          * last output pel.
  512.          */
  514.         /* top line */
  515.         a = *(unsigned int *)s1;
  516.         b = *(unsigned int *)(s1+BPP4);
  517.         e = b;      /* repeat last input pel */
  519.         w = a     + DITH1X4L;
  520.         x = a + b + DITH2X4H;
  521.         y = b     + DITH1X4L;
  522.         z = b + e + DITH2X4H;
  524.         /* pack and store */
  525.         *(unsigned int *)d1 =
  526.             ((w & 0x000000f0) >> 4)  |
  527.             ((w & 0x00078000) >> 11) |
  528.             ((w & 0x3c000000) >> 18) |
  529.             ((x & 0x000001e0) << 11) |
  530.             ((x & 0x000f0000) << 4)  |
  531.             ((x & 0x78000000) >> 3);
  532.         *(unsigned int *)(d1+2*BPP2) =
  533.             ((y & 0x000000f0) >> 4)  |
  534.             ((y & 0x00078000) >> 11) |
  535.             ((y & 0x3c000000) >> 18) |
  536.             ((z & 0x000001e0) << 11) |
  537.             ((z & 0x000f0000) << 4)  |
  538.             ((z & 0x78000000) >> 3);
  540.         /* bottom line */
  541.         c = *(unsigned int *)s2;
  542.         d = *(unsigned int *)(s2+BPP4);
  543.         f = d;      /* repeat last input pel */
  545.         w = a + c         + DITH2X4H;
  546.         x = a + b + c + d + DITH4X4L;
  547.         y = b + d         + DITH2X4H;
  548.         z = b + e + d + f + DITH4X4L;
  550.         *(unsigned int *)d2 =
  551.             ((w & 0x000001e0) >> 5)  |
  552.             ((w & 0x000f0000) >> 12) |
  553.             ((w & 0x78000000) >> 19) |
  554.             ((x & 0x000003c0) << 10) |
  555.             ((x & 0x001e0000) << 3)  |
  556.             ((x & 0xf0000000) >> 4);
  557.         *(unsigned int *)(d2+2*BPP2) =
  558.             ((y & 0x000001e0) >> 5)  |
  559.             ((y & 0x000f0000) >> 12) |
  560.             ((y & 0x78000000) >> 19) |
  561.             ((z & 0x000003c0) << 10) |
  562.             ((z & 0x001e0000) << 3)  |
  563.             ((z & 0xf0000000) >> 4);
  565.     } else {
  566.         /* last 2x1 block: */
  568.         /* Input pels  =>   Output pels
  569.          *  a b             w  x
  570.          *  c d             w' x'
  571.          */
  573.         /* top line */
  574.         a = *(unsigned int *)s1;
  575.         b = a;      /* repeat last input pel */
  577.         w = a     + DITH1X4L;
  578.         x = a + b + DITH2X4H;
  580.         /* pack and store */
  581.         *(unsigned int *)d1 =
  582.             ((w & 0x000000f0) >> 4)  |
  583.             ((w & 0x00078000) >> 11) |
  584.             ((w & 0x3c000000) >> 18) |
  585.             ((x & 0x000001e0) << 11) |
  586.             ((x & 0x000f0000) << 4)  |
  587.             ((x & 0x78000000) >> 3);
  589.         /* bottom line */
  590.         c = *(unsigned int *)s2;
  591.         d = c;      /* repeat last input pel */
  593.         w = a + c         + DITH2X4H;
  594.         x = a + b + c + d + DITH4X4L;
  596.         /* pack and store */
  597.         *(unsigned int *)d2 =
  598.             ((w & 0x000001e0) >> 5)  |
  599.             ((w & 0x000f0000) >> 12) |
  600.             ((w & 0x78000000) >> 19) |
  601.             ((x & 0x000003c0) << 10) |
  602.             ((x & 0x001e0000) << 3)  |
  603.             ((x & 0xf0000000) >> 4);
  604.     }
  605. }
  607. /*
  608.  * Convert two YUV lines into RGB linebufs.
  609.  * Produces two RGB lines per call.
  610.  * Output in padded RGB format, needed for SIMD interpolation.
  611.  */
  612. static void dblineI420toXRGB (unsigned char *d1, unsigned char *d2, int dest_x,
  613.     unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  614.       int src_x, int dx,
  615.       color_data_t* pcd)
  616. {
  617.     register int y1, y2, rv, guv, bu;
  618.     register int i;
  620.     /* convert first 2x1 block: */
  621.     if (src_x & 1) {
  623.         bu  = pcd->butab[su[0]];
  624.         guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  625.         rv  = pcd->rvtab[sv[0]];
  626.         y1  = pcd->ytab[sy1[0]];
  627.         y2  = pcd->ytab[sy2[0]];
  629.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  630.         *(unsigned int *)(d1+0) =
  631.             (CLIP8[y1 + bu])        |
  632.             (CLIP8[y1 + guv] << 11) |
  633.             (CLIP8[y1 + rv]  << 22) ;
  635.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  636.         *(unsigned int *)(d2+0) =
  637.             (CLIP8[y2 + bu])        |
  638.             (CLIP8[y2 + guv] << 11) |
  639.             (CLIP8[y2 + rv]  << 22) ;
  641.         sy1 += 1; sy2 += 1;
  642.         su += 1; sv += 1;
  643.         d1 += BPP4; d2 += BPP4;
  644.         dx --;
  645.     }
  647.     /* convert all integral 2x2 blocks: */
  648.     for (i = 0; i < dx/2; i ++) {
  650.         bu = pcd->butab[su[0]];
  651.         guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  652.         rv = pcd->rvtab[sv[0]];
  653.         y1 = pcd->ytab[sy1[0]];
  654.         y2 = pcd->ytab[sy2[0]];
  656.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  657.         *(unsigned int *)(d1+0) =
  658.             (CLIP8[y1 + bu])        |
  659.             (CLIP8[y1 + guv] << 11) |
  660.             (CLIP8[y1 + rv]  << 22) ;
  662.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  663.         *(unsigned int *)(d2+0) =
  664.             (CLIP8[y2 + bu])        |
  665.             (CLIP8[y2 + guv] << 11) |
  666.             (CLIP8[y2 + rv]  << 22) ;
  668.         /* 2nd row: */
  669.         y1 = pcd->ytab[sy1[1]];
  670.         y2 = pcd->ytab[sy2[1]];
  672.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  673.         *(unsigned int *)(d1+BPP4) =
  674.             (CLIP8[y1 + bu])        |
  675.             (CLIP8[y1 + guv] << 11) |
  676.             (CLIP8[y1 + rv]  << 22) ;
  678.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  679.         *(unsigned int *)(d2+BPP4) =
  680.             (CLIP8[y2 + bu])        |
  681.             (CLIP8[y2 + guv] << 11) |
  682.             (CLIP8[y2 + rv]  << 22) ;
  684.         /* next 2x2 block */
  685.         sy1 += 2; sy2 += 2;
  686.         su += 1; sv += 1;
  687.         d1 += 2*BPP4; d2 += 2*BPP4;
  688.     }
  690.     /* convert last 2x1 block: */
  691.     if (dx & 1) {
  693.         bu = pcd->butab[su[0]];
  694.         guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  695.         rv = pcd->rvtab[sv[0]];
  696.         y1 = pcd->ytab[sy1[0]];
  697.         y2 = pcd->ytab[sy2[0]];
  699.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  700.         *(unsigned int *)(d1+0) =
  701.             (CLIP8[y1 + bu])        |
  702.             (CLIP8[y1 + guv] << 11) |
  703.             (CLIP8[y1 + rv]  << 22) ;
  705.         /* second line BGR0 */
  706.         *(unsigned int *)(d2+0) =
  707.             (CLIP8[y2 + bu])        |
  708.             (CLIP8[y2 + guv] << 11) |
  709.             (CLIP8[y2 + rv]  << 22) ;
  710.     }
  711. }
  713. /*
  714.  * I420->RGB444 converter:
  715.  */
  716. int I420toRGB444 (unsigned char *dest_ptr, int dest_width, int dest_height,
  717.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  718.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  719.     int src_x, int src_y, int src_dx, int src_dy,
  720.   color_data_t* pcd)
  721. {
  722.     /* scale factors: */
  723.     int scale_x, scale_y;
  725.     /* check arguments: */
  726.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  727.    dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, 
  728.    src_height, src_pitch, src_x, src_y, src_dx, src_dy, 
  729.    &scale_x, &scale_y))
  730.       return -1;
  732.     /* check if bottop-up images: */
  733.     if (dest_pitch < 0) dest_ptr -= (dest_height-1) * dest_pitch;
  734.     if (src_pitch <= 0) return -1;          /* not supported */
  736.     /* check if 1:1 scale: */
  737.     if (scale_x == 1 && scale_y == 1) {
  739.         /* color converter to use: */
  740.         void (*dbline) (unsigned char *d1, unsigned char *d2, int dest_x,
  741.             unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  742.             int src_x, int dx, color_data_t* pcd) = 
  743.             dblineI420toRGB444;
  745.         /* local variables: */
  746.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  747.         register int j;
  749.         /* get pointers: */
  750.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  751.         sy2 = sy1 + src_pitch;
  752.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  753.         sv  = su + src_height * src_pitch / 4;
  754.         d1  = dest_ptr + dest_x * 2 + dest_y * dest_pitch; /* RGB offset */
  755.         d2  = d1 + dest_pitch;
  757.         /* convert a top line: */
  758.         if (src_y & 1) {                        /* chroma shift */
  760.             /* this is a bit inefficient, but who cares??? */
  761.             (* dbline) (d1, d1, dest_x, sy1, sy1, su, sv, src_x, src_dx, pcd);
  763.             sy1 += src_pitch;   sy2 += src_pitch;
  764.             su  += src_pitch/2; sv  += src_pitch/2;
  765.             d1  += dest_pitch;  d2  += dest_pitch;
  766.             dest_dy --;
  767.         }
  769.         /* convert aligned portion of the image: */
  770.         for (j = 0; j < dest_dy/2; j ++) {
  772.             /* convert two lines a time: */
  773.             (* dbline) (d1, d2, dest_x, sy1, sy2, su, sv, src_x, src_dx, pcd);
  775.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  776.             su  += src_pitch/2; sv  += src_pitch/2;
  777.             d1  += dest_pitch*2; d2 += dest_pitch*2;
  778.         }
  780.         /* convert bottom line (if dest_dy is odd): */
  781.         if (dest_dy & 1) {
  783.             /* convert one line only: */
  784.             (* dbline) (d1, d1, dest_x, sy1, sy1, su, sv, src_x, src_dx, pcd);
  785.         }
  786.         return 0;
  787.     }
  789.     /* check if 2:1 scale: */
  790.     if (scale_x == 2 && scale_y == 2) {
  791.         /* color converter & interpolator to use: */
  792.         void (*cvt) (unsigned char *d1, unsigned char *d2, int dest_x,
  793.             unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  794.             int src_x, int dx, color_data_t* pcd) = dblineI420toXRGB;
  795.         void (*x2) (unsigned char *d1, unsigned char *d2, int dest_x,
  796.             unsigned char *s1, unsigned char *s2, int src_x, int dx, color_data_t* pcd) = dblineXRGBtoRGB444x2;
  798.         /* local variables: */
  799.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  800.         register int dy = src_dy;
  802.         /* line buffers (we want them to be as compact as possible): */
  803.         int ibuf = 0;                           /* circular buffer index */
  804.         unsigned char * buf[3];                 /* actual pointers  */
  805.         buf[0] = pcd->linebuf;
  806.         buf[1] = pcd->linebuf + src_dx * BPP4;
  807.         buf[2] = pcd->linebuf + 2 * src_dx * BPP4;
  809.         /* get pointers: */
  810.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  811.         sy2 = sy1 + src_pitch;
  812.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  813.         sv  = su + src_height * src_pitch / 4;
  814.         d1  = dest_ptr + dest_x * BYTESPERPIXEL + dest_y * dest_pitch; /* RGB offset */
  815.         d2  = d1 + dest_pitch;
  817.         /* check if we have misaligned top line: */
  818.         if (src_y & 1) {
  820.             /* convert an odd first line: */
  821.             (*cvt) (buf[ibuf], buf[ibuf], 0, sy1, sy1, su, sv, src_x, src_dx, pcd);
  822.             sy1 += src_pitch;   sy2 += src_pitch;
  823.             su  += src_pitch/2; sv  += src_pitch/2;
  824.             dy --;
  826.         } else {
  828.             /* otherwise, convert first two lines: */
  829.             (*cvt) (buf[next[ibuf]], buf[next2[ibuf]], 0, sy1, sy2, su, sv, src_x, src_dx, pcd);
  830.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  831.             su  += src_pitch/2; sv  += src_pitch/2;
  832.             ibuf = next[ibuf];      /* skip first interpolation: */
  834.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  835.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  836.             ibuf = next[ibuf];
  837.             dy -= 2;
  838.         }
  840.         /*
  841.          * Convert & interpolate the main portion of image:
  842.          *
  843.          *  source:      temp.store:                destination:
  844.          *
  845.          *               buf[ibuf] -------    /--> d1
  846.          *                                  x2  --> d2
  847.          *  s1 --   /-> buf[next[ibuf]] -<    /--> d1'=d1+2*pitch
  848.          *        cvt                       x2 ---> d2'=d2+2*pitch
  849.          *  s2 --/   -> buf[next2[ibuf]] /
  850.          */
  851.         while (dy >= 2) {
  853.             /* convert two lines into XRGB buffers: */
  854.             (*cvt) (buf[next[ibuf]], buf[next2[ibuf]], 0, sy1, sy2, su, sv, src_x, src_dx, pcd);
  855.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  856.             su  += src_pitch/2; sv  += src_pitch/2;
  858.             /* interpolate first line: */
  859.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  860.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  861.             ibuf = next[ibuf];
  863.             /* interpolate second one: */
  864.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  865.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  866.             ibuf = next[ibuf];
  867.             dy -= 2;
  868.         }
  870.         /* check the # of remaining rows: */
  871.         if (dy & 1) {
  873.             /* convert the last odd line: */
  874.             (*cvt) (buf[next[ibuf]], buf[next[ibuf]], 0, sy1, sy1, su, sv, src_x, src_dx, pcd);
  876.             /* interpolate first line: */
  877.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  878.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  879.             ibuf = next[ibuf];
  881.             /* replicate the last line: */
  882.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[ibuf], 0, src_dx, pcd);
  884.         } else {
  886.             /* replicate the last line: */
  887.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[ibuf], 0, src_dx, pcd);
  888.         }
  889.         return 0;
  890.     }
  892.     /* check for 1/2 X scaling */
  893.     if (scale_x == 0 && scale_y == 0) {
  895.         /* local variables: */
  896.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  897.         register int j;
  899.         /* get pointers: */
  900.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  901.         sy2 = sy1 + src_pitch;
  902.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  903.         sv  = su + src_height * src_pitch / 4;
  904.         d1  = dest_ptr + dest_x * 2 + dest_y * dest_pitch; /* RGB offset */
  905.         d2  = d1 + dest_pitch;
  907.         /* convert aligned portion of the image: */
  908.         for (j = 0; j < dest_dy>>1; j ++) {
  910.             /* convert two lines a time: */
  911.             halfI420toRGB444 (d1, dest_x, sy1, sy2, su, sv, src_x, src_dx, 0, pcd);
  912.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  913.             su  += src_pitch/2; sv  += src_pitch/2;
  914.             d1  += dest_pitch;
  916.             halfI420toRGB444 (d1, dest_x, sy1, sy2, su, sv, src_x, src_dx, 1, pcd);
  917.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  918.             su  += src_pitch/2; sv  += src_pitch/2;
  919.             d1  += dest_pitch;
  920.         }
  922.         return 0;
  923.     }
  925.     /* conversion is not supported */
  926.     return -1;
  927. }
  929. /*
  930.  * InitI420toRGB444 initializes the minimum set of clip tables necessary to perform
  931.  * color conversion to 12 bit RGB.  The 8-bit clip table is necessary for 2x
  932.  * interpolation.
  933.  *
  934.  * This routine also calls SetSrcI420Colors, which initializes color conversion tables
  935.  * and adds color balance.
  936.  */
  937. void InitI420toRGB444(float brightness, float contrast, float saturation, float hue,
  938.       color_data_t* pcd)
  939. {
  940.     InitColorData(pcd);
  941.     SetSrcI420Colors (brightness, contrast, saturation, hue, pcd);
  942. }
  944. void UninitI420toRGB444( ){
  945.     /* noop */
  946. }