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

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

Symbian

开发平台：

Visual C++

444v565.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: 444v565.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 halfI420toRGB444v565 (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] << 1)  |
  130.   (CLIP4[y11 + guv1 + DITH4L] << 7)  |
  131.   (CLIP4[y11 + rv1  + DITH4L] << 12) |
  132.   (CLIP4[y12 + bu2  + DITH4H] << 17) |
  133.   (CLIP4[y12 + guv2 + DITH4H] << 23) |
  134.   (CLIP4[y12 + rv2  + DITH4H] << 28) ;
  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] << 1)  |
  159.   (CLIP4[y11 + guv1 + DITH4H] << 7)  |
  160.   (CLIP4[y11 + rv1  + DITH4H] << 12) |
  161.   (CLIP4[y12 + bu2  + DITH4L] << 17) |
  162.   (CLIP4[y12 + guv2 + DITH4L] << 23) |
  163.   (CLIP4[y12 + rv2  + DITH4L] << 28) ;
  165. /* next 4x2 block */
  166. sy1 += 4; sy2 += 4;
  167. su += 2; sv += 2;
  168. d1 += 2*BPP2;
  169.       }
  171.   }
  172. }
  174. static void dblineI420toRGB444v565 (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] << 1)  |
  204.                 (CLIP4[y11 + guv + DITH4L] << 7)  |
  205.                 (CLIP4[y11 + rv  + DITH4L] << 12) ;
  207.             *(unsigned short *)(d2+0) =
  208.                 (CLIP4[y21 + bu  + DITH4H] << 1)  |
  209.                 (CLIP4[y21 + guv + DITH4H] << 7)  |
  210.                 (CLIP4[y21 + rv  + DITH4H] << 12) ;
  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] << 1)  |
  230.                 (CLIP4[y11 + guv + DITH4L] << 7)  |
  231.                 (CLIP4[y11 + rv  + DITH4L] << 12) |
  232.                 (CLIP4[y12 + bu  + DITH4H] << 17) |
  233.                 (CLIP4[y12 + guv + DITH4H] << 23) |
  234.                 (CLIP4[y12 + rv  + DITH4H] << 28) ;
  236.             y21 = pcd->ytab[sy2[0]];
  237.             y22 = pcd->ytab[sy2[1]];
  239.             *(unsigned int *)(d2+0) =
  240.                 (CLIP4[y21 + bu  + DITH4H] << 1)  |
  241.                 (CLIP4[y21 + guv + DITH4H] << 7)  |
  242.                 (CLIP4[y21 + rv  + DITH4H] << 12) |
  243.                 (CLIP4[y22 + bu  + DITH4L] << 17) |
  244.                 (CLIP4[y22 + guv + DITH4L] << 23) |
  245.                 (CLIP4[y22 + rv  + DITH4L] << 28) ;
  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] << 1)  |
  266.                 (CLIP4[y11 + guv + DITH4L] << 7)  |
  267.                 (CLIP4[y11 + rv  + DITH4L] << 12) |
  268.                 (CLIP4[y12 + bu  + DITH4H] << 17) |
  269.                 (CLIP4[y12 + guv + DITH4H] << 23) |
  270.                 (CLIP4[y12 + rv  + DITH4H] << 28) ;
  272.             y21 = pcd->ytab[sy2[0]];
  273.             y22 = pcd->ytab[sy2[1]];
  275.             *(unsigned int *)(d2+0) =
  276.                 (CLIP4[y21 + bu  + DITH4H] << 1)  |
  277.                 (CLIP4[y21 + guv + DITH4H] << 7)  |
  278.                 (CLIP4[y21 + rv  + DITH4H] << 12) |
  279.                 (CLIP4[y22 + bu  + DITH4L] << 17) |
  280.                 (CLIP4[y22 + guv + DITH4L] << 23) |
  281.                 (CLIP4[y22 + rv  + DITH4L] << 28) ;
  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] << 1)  |
  292.                 (CLIP4[y11 + guv + DITH4L] << 7)  |
  293.                 (CLIP4[y11 + rv  + DITH4L] << 12) |
  294.                 (CLIP4[y12 + bu  + DITH4H] << 17) |
  295.                 (CLIP4[y12 + guv + DITH4H] << 23) |
  296.                 (CLIP4[y12 + rv  + DITH4H] << 28) ;
  298.             y21 = pcd->ytab[sy2[2]];
  299.             y22 = pcd->ytab[sy2[3]];
  301.             *(unsigned int *)(d2+2*BPP2) =
  302.                 (CLIP4[y21 + bu  + DITH4H] << 1)  |
  303.                 (CLIP4[y21 + guv + DITH4H] << 7)  |
  304.                 (CLIP4[y21 + rv  + DITH4H] << 12) |
  305.                 (CLIP4[y22 + bu  + DITH4L] << 17) |
  306.                 (CLIP4[y22 + guv + DITH4L] << 23) |
  307.                 (CLIP4[y22 + rv  + DITH4L] << 28) ;
  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] << 1)  |
  327.                 (CLIP4[y11 + guv + DITH4L] << 7)  |
  328.                 (CLIP4[y11 + rv  + DITH4L] << 12) |
  329.                 (CLIP4[y12 + bu  + DITH4H] << 17) |
  330.                 (CLIP4[y12 + guv + DITH4H] << 23) |
  331.                 (CLIP4[y12 + rv  + DITH4H] << 28) ;
  333.             y21 = pcd->ytab[sy2[0]];
  334.             y22 = pcd->ytab[sy2[1]];
  336.             *(unsigned int *)(d2+0) =
  337.                 (CLIP4[y21 + bu  + DITH4H] << 1)  |
  338.                 (CLIP4[y21 + guv + DITH4H] << 7)  |
  339.                 (CLIP4[y21 + rv  + DITH4H] << 12) |
  340.                 (CLIP4[y22 + bu  + DITH4L] << 17) |
  341.                 (CLIP4[y22 + guv + DITH4L] << 23) |
  342.                 (CLIP4[y22 + rv  + DITH4L] << 28) ;
  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] << 1)  |
  362.                 (CLIP4[y11 + guv + DITH4L] << 7)  |
  363.                 (CLIP4[y11 + rv  + DITH4L] << 12) ;
  365.             *(unsigned short *)(d2+0) =
  366.                 (CLIP4[y21 + bu  + DITH4H] << 1)  |
  367.                 (CLIP4[y21 + guv + DITH4H] << 7)  |
  368.                 (CLIP4[y21 + rv  + DITH4H] << 12) ;
  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. #define DITHER_MAGIC 0xc0380700
  385. /* RGB444 version: */
  386. static void dblineXRGBtoRGB444v565x2 (unsigned char *d1, unsigned char *d2, int dest_x,
  387.       unsigned char *s1, unsigned char *s2, int src_x, int dx,
  388.   color_data_t* pcd)
  389. {
  390.     register unsigned int a, b, c, d, e, f;
  391.     register unsigned int w, x, y, z;
  393.     /* convert first 2x1 block: */
  394.     if (dest_x & 1) {
  396.         /* Input pels  =>   Output pels
  397.          *  a b             w  x
  398.          *  c d             w' x'
  399.          */
  401.         /* top line */
  402.         a = *(unsigned int *)s1;
  403.         b = *(unsigned int *)(s1+BPP4);
  405.         w = a     + DITH1X4L;
  406.         x = a + b + DITH2X4H;
  408.         /* pack and store */
  409.         *(unsigned int *)d1 =
  410.             ((w & 0x000000f0) >> 3)  |
  411.             ((w & 0x00078000) >> 8) |
  412.             ((w & 0x3c000000) >> 14) |
  413.             ((x & 0x000001e0) << 12) |
  414.             ((x & 0x000f0000) << 7)  |
  415.             ((x & 0x78000000) << 1);
  417.         /* bottom line */
  418.         c = *(unsigned int *)s2;
  419.         d = *(unsigned int *)(s2+BPP4);
  421.         w = a + c         + DITH2X4H;
  422.         x = a + b + c + d + DITH4X4L;
  424.         /* pack and store */
  425.         *(unsigned int *)d2 =
  426.             ((w & 0x000001e0) >> 4)  |
  427.             ((w & 0x000f0000) >> 9) |
  428.             ((w & 0x78000000) >> 15) |
  429.             ((x & 0x000003c0) << 11) |
  430.             ((x & 0x001e0000) << 6)  |
  431.             ((x & 0xf0000000) << 0);
  433.         /* bump pointers to next block */
  434.         s1 += BPP4; s2 += BPP4;
  435.         d1 += 2*BPP2; d2 += 2*BPP2;
  436.         dx -= 1;
  437.     }
  439.     /* process all integral 2x2 blocks: */
  440.     while (dx > 2) {    /* we need to leave at least one block */
  442.         /*
  443.          * Input stored as 00 RRRRRRRR 000 GGGGGGGG 000 BBBBBBBB
  444.          *
  445.          * Input pels       Output pels
  446.          *  a b e           w  x  y  z
  447.          *  c d f           w' x' y' z'
  448.          */
  450.         /* top line */
  451.         a = *(unsigned int *)s1;
  452.         b = *(unsigned int *)(s1+BPP4);
  453.         e = *(unsigned int *)(s1+2*BPP4);
  455. w = a     + DITH1X4L;
  456. x = a + b + DITH2X4H;
  457. y = b     + DITH1X4L;
  458. z = b + e + DITH2X4H;
  460.         /* pack and store */
  461.         *(unsigned int *)d1 =
  462.             ((w & 0x000000f0) >> 3)  |
  463.             ((w & 0x00078000) >> 8)  |
  464.             ((w & 0x3c000000) >> 14) |
  465.             ((x & 0x000001e0) << 12) |
  466.             ((x & 0x000f0000) << 7)  |
  467.             ((x & 0x78000000) << 1);
  468.         *(unsigned int *)(d1+2*BPP2) =
  469.             ((y & 0x000000f0) >> 3)  |
  470.             ((y & 0x00078000) >> 8)  |
  471.             ((y & 0x3c000000) >> 14) |
  472.             ((z & 0x000001e0) << 12) |
  473.             ((z & 0x000f0000) << 7)  |
  474.             ((z & 0x78000000) << 1);
  476.         /* bottom line */
  477.         c = *(unsigned int *)s2;
  478.         d = *(unsigned int *)(s2+BPP4);
  479.         f = *(unsigned int *)(s2+2*BPP4);
  481. w = a + c         + DITH2X4H;
  482. x = a + b + c + d + DITH4X4L;
  483. y = b + d         + DITH2X4H;
  484. z = b + e + d + f + DITH4X4L;
  486.         /* pack and store */
  487.         *(unsigned int *)d2 =
  488.             ((w & 0x000001e0) >> 4)  |
  489.             ((w & 0x000f0000) >> 9)  |
  490.             ((w & 0x78000000) >> 15) |
  491.             ((x & 0x000003c0) << 11) |
  492.             ((x & 0x001e0000) << 6)  |
  493.             ((x & 0xf0000000) << 0);
  494.         *(unsigned int *)(d2+2*BPP2) =
  495.             ((y & 0x000001e0) >> 4)  |
  496.             ((y & 0x000f0000) >> 9)  |
  497.             ((y & 0x78000000) >> 15) |
  498.             ((z & 0x000003c0) << 11) |
  499.             ((z & 0x001e0000) << 6)  |
  500.             ((z & 0xf0000000) << 0);
  502.         /* next 2x2 input block */
  503.         s1 += 2*BPP4; s2 += 2*BPP4;
  504.         d1 += 4*BPP2; d2 += 4*BPP2;
  505.         dx -= 2;
  506.     }
  508.     /* check if this is the last 2x2 block: */
  509.     if (dx > 1) {
  511.         /*
  512.          * For last 4 output pels, repeat final input pel
  513.          * for offscreen input.  Equivalent to pixel-doubling the
  514.          * last output pel.
  515.          */
  517.         /* top line */
  518.         a = *(unsigned int *)s1;
  519.         b = *(unsigned int *)(s1+BPP4);
  520.         e = b;      /* repeat last input pel */
  522.         w = a     + DITH1X4L;
  523.         x = a + b + DITH2X4H;
  524.         y = b     + DITH1X4L;
  525.         z = b + e + DITH2X4H;
  527.         /* pack and store */
  528.         *(unsigned int *)d1 =
  529.             ((w & 0x000000f0) >> 3)  |
  530.             ((w & 0x00078000) >> 8)  |
  531.             ((w & 0x3c000000) >> 14) |
  532.             ((x & 0x000001e0) << 12) |
  533.             ((x & 0x000f0000) << 7)  |
  534.             ((x & 0x78000000) << 1);
  535.         *(unsigned int *)(d1+2*BPP2) =
  536.             ((y & 0x000000f0) >> 3)  |
  537.             ((y & 0x00078000) >> 8)  |
  538.             ((y & 0x3c000000) >> 14) |
  539.             ((z & 0x000001e0) << 12) |
  540.             ((z & 0x000f0000) << 7)  |
  541.             ((z & 0x78000000) << 1);
  543.         /* bottom line */
  544.         c = *(unsigned int *)s2;
  545.         d = *(unsigned int *)(s2+BPP4);
  546.         f = d;      /* repeat last input pel */
  548.         w = a + c         + DITH2X4H;
  549.         x = a + b + c + d + DITH4X4L;
  550.         y = b + d         + DITH2X4H;
  551.         z = b + e + d + f + DITH4X4L;
  553.         *(unsigned int *)d2 =
  554.             ((w & 0x000001e0) >> 4)  |
  555.             ((w & 0x000f0000) >> 9)  |
  556.             ((w & 0x78000000) >> 15) |
  557.             ((x & 0x000003c0) << 11) |
  558.             ((x & 0x001e0000) << 6)  |
  559.             ((x & 0xf0000000) << 0);
  560.         *(unsigned int *)(d2+2*BPP2) =
  561.             ((y & 0x000001e0) >> 4)  |
  562.             ((y & 0x000f0000) >> 9)  |
  563.             ((y & 0x78000000) >> 15) |
  564.             ((z & 0x000003c0) << 11) |
  565.             ((z & 0x001e0000) << 6)  |
  566.             ((z & 0xf0000000) << 0);
  568.     } else {
  569.         /* last 2x1 block: */
  571.         /* Input pels  =>   Output pels
  572.          *  a b             w  x
  573.          *  c d             w' x'
  574.          */
  576.         /* top line */
  577.         a = *(unsigned int *)s1;
  578.         b = a;      /* repeat last input pel */
  580.         w = a     + DITH1X4L;
  581.         x = a + b + DITH2X4H;
  583.         /* pack and store */
  584.         *(unsigned int *)d1 =
  585.             ((w & 0x000000f0) >> 3)  |
  586.             ((w & 0x00078000) >> 8)  |
  587.             ((w & 0x3c000000) >> 14) |
  588.             ((x & 0x000001e0) << 12) |
  589.             ((x & 0x000f0000) << 7)  |
  590.             ((x & 0x78000000) << 1);
  592.         /* bottom line */
  593.         c = *(unsigned int *)s2;
  594.         d = c;      /* repeat last input pel */
  596.         w = a + c         + DITH2X4H;
  597.         x = a + b + c + d + DITH4X4L;
  599.         /* pack and store */
  600.         *(unsigned int *)d2 =
  601.             ((w & 0x000001e0) >> 4)  |
  602.             ((w & 0x000f0000) >> 9)  |
  603.             ((w & 0x78000000) >> 15) |
  604.             ((x & 0x000003c0) << 11) |
  605.             ((x & 0x001e0000) << 6)  |
  606.             ((x & 0xf0000000) << 0);
  607.     }
  608. }
  610. /*
  611.  * Convert two YUV lines into RGB linebufs.
  612.  * Produces two RGB lines per call.
  613.  * Output in padded RGB format, needed for SIMD interpolation.
  614.  */
  615. static void dblineI420toXRGB (unsigned char *d1, unsigned char *d2, int dest_x,
  616.     unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  617.       int src_x, int dx,
  618.       color_data_t* pcd)
  619. {
  620.     register int y1, y2, rv, guv, bu;
  621.     register int i;
  623.     /* convert first 2x1 block: */
  624.     if (src_x & 1) {
  626.         bu = pcd->butab[su[0]];
  627.         guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  628.         rv = pcd->rvtab[sv[0]];
  629.         y1 = pcd->ytab[sy1[0]];
  630.         y2 = pcd->ytab[sy2[0]];
  632.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  633.         *(unsigned int *)(d1+0) =
  634.             (CLIP8[y1 + bu])        |
  635.             (CLIP8[y1 + guv] << 11) |
  636.             (CLIP8[y1 + rv]  << 22) ;
  638.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  639.         *(unsigned int *)(d2+0) =
  640.             (CLIP8[y2 + bu])        |
  641.             (CLIP8[y2 + guv] << 11) |
  642.             (CLIP8[y2 + rv]  << 22) ;
  644.         sy1 += 1; sy2 += 1;
  645.         su += 1; sv += 1;
  646.         d1 += BPP4; d2 += BPP4;
  647.         dx --;
  648.     }
  650.     /* convert all integral 2x2 blocks: */
  651.     for (i = 0; i < dx/2; i ++) {
  653.         bu = pcd->butab[su[0]];
  654.         guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  655.         rv = pcd->rvtab[sv[0]];
  656.         y1 = pcd->ytab[sy1[0]];
  657.         y2 = pcd->ytab[sy2[0]];
  659.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  660.         *(unsigned int *)(d1+0) =
  661.             (CLIP8[y1 + bu])        |
  662.             (CLIP8[y1 + guv] << 11) |
  663.             (CLIP8[y1 + rv]  << 22) ;
  665.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  666.         *(unsigned int *)(d2+0) =
  667.             (CLIP8[y2 + bu])        |
  668.             (CLIP8[y2 + guv] << 11) |
  669.             (CLIP8[y2 + rv]  << 22) ;
  671.         /* 2nd row: */
  672.         y1 = pcd->ytab[sy1[1]];
  673.         y2 = pcd->ytab[sy2[1]];
  675.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  676.         *(unsigned int *)(d1+BPP4) =
  677.             (CLIP8[y1 + bu])        |
  678.             (CLIP8[y1 + guv] << 11) |
  679.             (CLIP8[y1 + rv]  << 22) ;
  681.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  682.         *(unsigned int *)(d2+BPP4) =
  683.             (CLIP8[y2 + bu])        |
  684.             (CLIP8[y2 + guv] << 11) |
  685.             (CLIP8[y2 + rv]  << 22) ;
  687.         /* next 2x2 block */
  688.         sy1 += 2; sy2 += 2;
  689.         su += 1; sv += 1;
  690.         d1 += 2*BPP4; d2 += 2*BPP4;
  691.     }
  693.     /* convert last 2x1 block: */
  694.     if (dx & 1) {
  696.         bu = pcd->butab[su[0]];
  697. guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  698.         rv = pcd->rvtab[sv[0]];
  699.         y1 = pcd->ytab[sy1[0]];
  700.         y2 = pcd->ytab[sy2[0]];
  702.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  703.         *(unsigned int *)(d1+0) =
  704.             (CLIP8[y1 + bu])        |
  705.             (CLIP8[y1 + guv] << 11) |
  706.             (CLIP8[y1 + rv]  << 22) ;
  708.         /* second line BGR0 */
  709.         *(unsigned int *)(d2+0) =
  710.             (CLIP8[y2 + bu])        |
  711.             (CLIP8[y2 + guv] << 11) |
  712.             (CLIP8[y2 + rv]  << 22) ;
  713.     }
  714. }
  716. /*
  717.  * I420->RGB444 converter:
  718.  */
  719. int I420toRGB444v565 (unsigned char *dest_ptr, int dest_width, int dest_height,
  720.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  721.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  722.     int src_x, int src_y, int src_dx, int src_dy,
  723.       color_data_t* pcd)
  724. {
  725.     /* scale factors: */
  726.     int scale_x, scale_y;
  728.     /* check arguments: */
  729.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  730.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  731.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  732.         return -1;
  734.     /* check if bottop-up images: */
  735.     if (dest_pitch < 0) dest_ptr -= (dest_height-1) * dest_pitch;
  736.     if (src_pitch <= 0) return -1;          /* not supported */
  738.     /* check if 1:1 scale: */
  739.     if (scale_x == 1 && scale_y == 1) {
  741.         /* color converter to use: */
  742.         void (*dbline) (unsigned char *d1, unsigned char *d2, int dest_x,
  743.             unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  744.             int src_x, int dx, color_data_t* pcd) = 
  745.             dblineI420toRGB444v565;
  747.         /* local variables: */
  748.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  749.         register int j;
  751.         /* get pointers: */
  752.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  753.         sy2 = sy1 + src_pitch;
  754.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  755.         sv  = su + src_height * src_pitch / 4;
  756.         d1  = dest_ptr + dest_x * 2 + dest_y * dest_pitch; /* RGB offset */
  757.         d2  = d1 + dest_pitch;
  759.         /* convert a top line: */
  760.         if (src_y & 1) {                        /* chroma shift */
  762.             /* this is a bit inefficient, but who cares??? */
  763.             (* dbline) (d1, d1, dest_x, sy1, sy1, su, sv, src_x, src_dx, pcd);
  765.             sy1 += src_pitch;   sy2 += src_pitch;
  766.             su  += src_pitch/2; sv  += src_pitch/2;
  767.             d1  += dest_pitch;  d2  += dest_pitch;
  768.             dest_dy --;
  769.         }
  771.         /* convert aligned portion of the image: */
  772.         for (j = 0; j < dest_dy/2; j ++) {
  774.             /* convert two lines a time: */
  775.             (* dbline) (d1, d2, dest_x, sy1, sy2, su, sv, src_x, src_dx, pcd);
  777.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  778.             su  += src_pitch/2; sv  += src_pitch/2;
  779.             d1  += dest_pitch*2; d2 += dest_pitch*2;
  780.         }
  782.         /* convert bottom line (if dest_dy is odd): */
  783.         if (dest_dy & 1) {
  785.             /* convert one line only: */
  786.             (* dbline) (d1, d1, dest_x, sy1, sy1, su, sv, src_x, src_dx, pcd);
  787.         }
  788.         return 0;
  789.     }
  791.     /* check if 2:1 scale: */
  792.     if (scale_x == 2 && scale_y == 2) {
  793.         /* color converter & interpolator to use: */
  794.         void (*cvt) (unsigned char *d1, unsigned char *d2, int dest_x,
  795.             unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  796.             int src_x, int dx, color_data_t* pcd) = dblineI420toXRGB;
  797.         void (*x2) (unsigned char *d1, unsigned char *d2, int dest_x,
  798.             unsigned char *s1, unsigned char *s2, int src_x, int dx, color_data_t* pcd) = dblineXRGBtoRGB444v565x2;
  800.         /* local variables: */
  801.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  802.         register int dy = src_dy;
  804.         /* line buffers (we want them to be as compact as possible): */
  805.         int ibuf = 0;                           /* circular buffer index */
  806.         unsigned char * buf[3];                 /* actual pointers  */
  807.         buf[0] = pcd->linebuf;
  808.         buf[1] = pcd->linebuf + src_dx * BPP4;
  809.         buf[2] = pcd->linebuf + 2 * src_dx * BPP4;
  811.         /* get pointers: */
  812.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  813.         sy2 = sy1 + src_pitch;
  814.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  815.         sv  = su + src_height * src_pitch / 4;
  816.         d1  = dest_ptr + dest_x * BYTESPERPIXEL + dest_y * dest_pitch; /* RGB offset */
  817.         d2  = d1 + dest_pitch;
  819.         /* check if we have misaligned top line: */
  820.         if (src_y & 1) {
  822.             /* convert an odd first line: */
  823.             (*cvt) (buf[ibuf], buf[ibuf], 0, sy1, sy1, su, sv, src_x, src_dx, pcd);
  824.             sy1 += src_pitch;   sy2 += src_pitch;
  825.             su  += src_pitch/2; sv  += src_pitch/2;
  826.             dy --;
  828.         } else {
  830.             /* otherwise, convert first two lines: */
  831.             (*cvt) (buf[next[ibuf]], buf[next2[ibuf]], 0, sy1, sy2, su, sv, src_x, src_dx, pcd);
  832.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  833.             su  += src_pitch/2; sv  += src_pitch/2;
  834.             ibuf = next[ibuf];      /* skip first interpolation: */
  836.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  837.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  838.             ibuf = next[ibuf];
  839.             dy -= 2;
  840.         }
  842.         /*
  843.          * Convert & interpolate the main portion of image:
  844.          *
  845.          *  source:      temp.store:                destination:
  846.          *
  847.          *               buf[ibuf] -------    /--> d1
  848.          *                                  x2  --> d2
  849.          *  s1 --   /-> buf[next[ibuf]] -<    /--> d1'=d1+2*pitch
  850.          *        cvt                       x2 ---> d2'=d2+2*pitch
  851.          *  s2 --/   -> buf[next2[ibuf]] /
  852.          */
  853.         while (dy >= 2) {
  855.             /* convert two lines into XRGB buffers: */
  856.             (*cvt) (buf[next[ibuf]], buf[next2[ibuf]], 0, sy1, sy2, su, sv, src_x, src_dx, pcd);
  857.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  858.             su  += src_pitch/2; sv  += src_pitch/2;
  860.             /* interpolate first line: */
  861.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  862.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  863.             ibuf = next[ibuf];
  865.             /* interpolate second one: */
  866.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  867.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  868.             ibuf = next[ibuf];
  869.             dy -= 2;
  870.         }
  872.         /* check the # of remaining rows: */
  873.         if (dy & 1) {
  875.             /* convert the last odd line: */
  876.             (*cvt) (buf[next[ibuf]], buf[next[ibuf]], 0, sy1, sy1, su, sv, src_x, src_dx, pcd);
  878.             /* interpolate first line: */
  879.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  880.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  881.             ibuf = next[ibuf];
  883.             /* replicate the last line: */
  884.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[ibuf], 0, src_dx, pcd);
  886.         } else {
  888.             /* replicate the last line: */
  889.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[ibuf], 0, src_dx, pcd);
  890.         }
  891.         return 0;
  892.     }
  894.     /* check for 1/2 X scaling */
  895.     if (scale_x == 0 && scale_y == 0) {
  897.         /* local variables: */
  898.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  899.         register int j;
  901.         /* get pointers: */
  902.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  903.         sy2 = sy1 + src_pitch;
  904.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  905.         sv  = su + src_height * src_pitch / 4;
  906.         d1  = dest_ptr + dest_x * 2 + dest_y * dest_pitch; /* RGB offset */
  907.         d2  = d1 + dest_pitch;
  909.         /* convert aligned portion of the image: */
  910.         for (j = 0; j < dest_dy>>1; j ++) {
  912.             /* convert two lines a time: */
  913.             halfI420toRGB444v565 (d1, dest_x, sy1, sy2, su, sv, src_x, src_dx, 0, pcd);
  914.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  915.             su  += src_pitch/2; sv  += src_pitch/2;
  916.             d1  += dest_pitch;
  918.             halfI420toRGB444v565 (d1, dest_x, sy1, sy2, su, sv, src_x, src_dx, 1, pcd);
  919.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  920.             su  += src_pitch/2; sv  += src_pitch/2;
  921.             d1  += dest_pitch;
  922.         }
  924.         return 0;
  925.     }
  927.     /* conversion is not supported */
  928.     return -1;
  929. }
  931. /*
  932.  * InitI420toRGB444v565 initializes the minimum set of clip tables necessary to perform
  933.  * color conversion to 12 bit RGB packed into a 565 value.  The 8-bit clip table is 
  934.  * necessary for 2x interpolation.
  935.  *
  936.  * This routine also calls SetSrcI420Colors, which initializes color conversion tables
  937.  * and adds color balance.
  938.  */
  939. void InitI420toRGB444v565(float brightness, float contrast, float saturation, float hue, 
  940.   color_data_t* pcd)
  941. {
  942.     InitColorData(pcd);
  943.     SetSrcI420Colors (brightness, contrast, saturation, hue, pcd);
  944. }
  946. void UninitI420toRGB444v565( ){
  947.     /* noop */
  948. }