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

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

Symbian

开发平台：

Visual C++

565.c：源码内容
  1. 1/* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: 565.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.  * Color conversion routines for converting YUV420 as produced by the
  56.  * RealVideo decoders to RGB565.
  57.  */
  59. /*
  60.  * Format-conversion routines.
  61.  * Use:
  62.  *  int XXXXtoYYYYEx (unsigned char *dest_ptr, int dest_width, int dest_height,
  63.  *      int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  64.  *      unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  65.  *      int src_x, int src_y, int src_dx, int src_dy);
  66.  * Input:
  67.  *  dest_ptr - pointer to a destination buffer
  68.  *  dest_width, dest_height - width/height of the destination image (pixels)
  69.  *  dest_pitch - pitch of the dest. buffer (in bytes; <0 - if bottom up image)
  70.  *  dest_x, dest_y, dest_dx, dest_dy - destination rectangle (pixels)
  71.  *  src_ptr - pointer to an input image
  72.  *  src_width, src_height - width/height of the input image (pixels)
  73.  *  src_pitch - pitch of the source buffer (in bytes; <0 - if bottom up image)
  74.  *  src_x, src_y, src_dx, src_dy - source rectangle (pixels)
  75.  * Returns:
  76.  *  0 - if success; -1 if failure.
  77.  * Notes:
  78.  *  a) In all cases, pointers to the source and destination buffers must be
  79.  *     DWORD aligned, and both pitch parameters must be multiple of 4!!!
  80.  *  b) Converters that deal with YUV 4:2:2, or 4:2:0 formats may also require
  81.  *     rectangle parameters (x,y,dx,dy) to be multiple of 2. Failure to provide
  82.  *     aligned rectangles will result in partially converted image.
  83.  *  c) Currently only scale factors of 1:1 and 2:1 are supported; if the rates
  84.  *     dest_dx/src_dx & dest_dy/src_dy are neither 1, or 2, the converters
  85.  *     will fail.
  86.  */
  88. #define BYTESPERPIXEL 2
  90. /* Indexing tables */
  91. static const int next[3] = {1, 2, 0};                 /* (ibuf+1)%3 table */
  92. static const int next2[3] = {2, 0, 1};                /* (ibuf+2)%3 table */
  94. /* Half resolution converter.  */
  95. static void halfI420toRGB565 (unsigned char *d1,
  96.       int dest_x, unsigned char *sy1, 
  97.       unsigned char *sy2, unsigned char *su, 
  98.       unsigned char *sv, int src_x, int dx, int isodd,
  99.       color_data_t* pcd)
  100. {
  101.   /* check if we have misaligned input/output: */
  102.   if ((src_x ^ dest_x) & 1) {
  103.     
  104.     ; /* not implemented yet */
  105.     
  106.   } else {
  107.     
  108.     /* aligned input/output: */
  109.     register int y11, y12;
  110.     register int rv1, guv1, bu1, rv2, guv2, bu2;
  111.     register int i;
  112.     
  113.     /* source width should always be multiples of 4 */
  114.     /*    assert((src_x & 3)==0); */
  116.     /* convert all integral 2x4 blocks: */
  117.     if (isodd)
  118.       for (i = 0; i < dx/4; i ++) {
  120. /* first 2x2 block */
  121. rv1 = pcd->rvtab[sv[0]];
  122. guv1 = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  123. bu1 = pcd->butab[su[0]];
  124. y11 = (pcd->ytab[sy1[0]] + pcd->ytab[sy1[1]] + pcd->ytab[sy2[0]] + pcd->ytab[sy2[1]])>>2; /* avg */
  126. /* second 2x2 block */
  127. rv2  = pcd->rvtab[sv[1]];
  128. guv2 = pcd->gutab[su[1]] + pcd->gvtab[sv[1]];
  129. bu2  = pcd->butab[su[1]];
  130. y12 = (pcd->ytab[sy1[2]] + pcd->ytab[sy1[3]] + pcd->ytab[sy2[2]] + pcd->ytab[sy2[3]])>>2;
  132. /* output 4 bytes at a time */
  133. *(unsigned int *)(d1+0) =
  134.   (CLIP5[y11 + bu1  + DITH5L] << 0)  |
  135.   (CLIP6[y11 + guv1 + DITH6L] << 5)  |
  136.   (CLIP5[y11 + rv1  + DITH5L] << 11) |
  137.   (CLIP5[y12 + bu2  + DITH5H] << 16) |
  138.   (CLIP6[y12 + guv2 + DITH6H] << 21) |
  139.   (CLIP5[y12 + rv2  + DITH5H] << 27) ;
  141. /* next 4x2 block */
  142. sy1 += 4; sy2 += 4;
  143. su += 2; sv += 2;
  144. d1 += 2*BPP2;
  145.       }
  146.     else
  147.       for (i = 0; i < dx/4; i ++) {
  149. /* first 2x2 block */
  150. rv1 = pcd->rvtab[sv[0]];
  151. guv1 = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  152. bu1 = pcd->butab[su[0]];
  153. y11 = (pcd->ytab[sy1[0]] + pcd->ytab[sy1[1]] + pcd->ytab[sy2[0]] + pcd->ytab[sy2[1]])>>2; /* avg */
  155. /* second 2x2 block */
  156. rv2  = pcd->rvtab[sv[1]];
  157. guv2 = pcd->gutab[su[1]] + pcd->gvtab[sv[1]];
  158. bu2  = pcd->butab[su[1]];
  159. y12 = (pcd->ytab[sy1[2]] + pcd->ytab[sy1[3]] + pcd->ytab[sy2[2]] + pcd->ytab[sy2[3]])>>2;
  161. /* output 4 bytes at a time */
  162. *(unsigned int *)(d1+0) =
  163.   (CLIP5[y11 + bu1  + DITH5H] << 0)  |
  164.   (CLIP6[y11 + guv1 + DITH6H] << 5)  |
  165.   (CLIP5[y11 + rv1  + DITH5H] << 11) |
  166.   (CLIP5[y12 + bu2  + DITH5L] << 16) |
  167.   (CLIP6[y12 + guv2 + DITH6L] << 21) |
  168.   (CLIP5[y12 + rv2  + DITH5L] << 27) ;
  170. /* next 4x2 block */
  171. sy1 += 4; sy2 += 4;
  172. su += 2; sv += 2;
  173. d1 += 2*BPP2;
  174.       }
  176.   }
  177. }
  179. static void dblineI420toRGB565 (unsigned char *d1, unsigned char *d2, 
  180. int dest_x, unsigned char *sy1, 
  181. unsigned char *sy2, unsigned char *su, 
  182. unsigned char *sv, int src_x, int dx,
  183. color_data_t* pcd)
  184. {
  185.     /* check if we have misaligned input/output: */
  186.     if ((src_x ^ dest_x) & 1) {
  188.         ; /* not implemented yet */
  190.     } else {
  192.         /* aligned input/output: */
  193.         register int y11, y12, y21, y22;
  194.         register int rv, guv, bu;
  195.         register int i;
  197.         /* convert first 2x1 block: */
  198.         if (dest_x & 1) {
  200.             rv  = pcd->rvtab[sv[0]];
  201.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  202.             bu  = pcd->butab[su[0]];
  203.             y11 = pcd->ytab[sy1[0]];
  204.             y21 = pcd->ytab[sy2[0]];
  206.             /* output 2 bytes at a time */
  207.             *(unsigned short *)(d1+0) =
  208.                 (CLIP5[y11 + bu  + DITH5L] << 0)  |
  209.                 (CLIP6[y11 + guv + DITH6L] << 5)  |
  210.                 (CLIP5[y11 + rv  + DITH5L] << 11) ;
  212.             *(unsigned short *)(d2+0) =
  213.                 (CLIP5[y21 + bu  + DITH5H] << 0)  |
  214.                 (CLIP6[y21 + guv + DITH6H] << 5)  |
  215.                 (CLIP5[y21 + rv  + DITH5H] << 11) ;
  217.             sy1 += 1; sy2 += 1;
  218.             su += 1; sv += 1;
  219.             d1 += BPP2; d2 += BPP2;
  220.             dest_x ++; dx --;
  221.         }
  223.         /* convert first 2x2 block: */
  224.         if (dest_x & 2) {
  226.             rv  = pcd->rvtab[sv[0]];
  227.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  228.             bu  = pcd->butab[su[0]];
  229.             y11 = pcd->ytab[sy1[0]];
  230.             y12 = pcd->ytab[sy1[1]];
  232.             /* output 4 bytes at a time */
  233.             *(unsigned int *)(d1+0) =
  234.                 (CLIP5[y11 + bu  + DITH5L] << 0)  |
  235.                 (CLIP6[y11 + guv + DITH6L] << 5)  |
  236.                 (CLIP5[y11 + rv  + DITH5L] << 11) |
  237.                 (CLIP5[y12 + bu  + DITH5H] << 16) |
  238.                 (CLIP6[y12 + guv + DITH6H] << 21) |
  239.                 (CLIP5[y12 + rv  + DITH5H] << 27) ;
  241.             y21 = pcd->ytab[sy2[0]];
  242.             y22 = pcd->ytab[sy2[1]];
  244.             *(unsigned int *)(d2+0) =
  245.                 (CLIP5[y21 + bu  + DITH5H] << 0)  |
  246.                 (CLIP6[y21 + guv + DITH6H] << 5)  |
  247.                 (CLIP5[y21 + rv  + DITH5H] << 11) |
  248.                 (CLIP5[y22 + bu  + DITH5L] << 16) |
  249.                 (CLIP6[y22 + guv + DITH6L] << 21) |
  250.                 (CLIP5[y22 + rv  + DITH5L] << 27) ;
  252.             sy1 += 2; sy2 += 2;
  253.             su += 1; sv += 1;
  254.             d1 += 2*BPP2; d2 += 2*BPP2;
  255.             dest_x += 2; dx -= 2;
  256.         }
  258.         /* convert all integral 2x4 blocks: */
  259.         for (i = 0; i < dx/4; i ++) {
  261.             /* first 2x2 block */
  262.             rv = pcd->rvtab[sv[0]];
  263.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  264.             bu = pcd->butab[su[0]];
  265.             y11 = pcd->ytab[sy1[0]];
  266.             y12 = pcd->ytab[sy1[1]];
  268.             /* output 4 bytes at a time */
  269.             *(unsigned int *)(d1+0) =
  270.                 (CLIP5[y11 + bu  + DITH5L] << 0)  |
  271.                 (CLIP6[y11 + guv + DITH6L] << 5)  |
  272.                 (CLIP5[y11 + rv  + DITH5L] << 11) |
  273.                 (CLIP5[y12 + bu  + DITH5H] << 16) |
  274.                 (CLIP6[y12 + guv + DITH6H] << 21) |
  275.                 (CLIP5[y12 + rv  + DITH5H] << 27) ;
  277.             y21 = pcd->ytab[sy2[0]];
  278.             y22 = pcd->ytab[sy2[1]];
  280.             *(unsigned int *)(d2+0) =
  281.                 (CLIP5[y21 + bu  + DITH5H] << 0)  |
  282.                 (CLIP6[y21 + guv + DITH6H] << 5)  |
  283.                 (CLIP5[y21 + rv  + DITH5H] << 11) |
  284.                 (CLIP5[y22 + bu  + DITH5L] << 16) |
  285.                 (CLIP6[y22 + guv + DITH6L] << 21) |
  286.                 (CLIP5[y22 + rv  + DITH5L] << 27) ;
  288.             /* second 2x2 block */
  289.             rv  = pcd->rvtab[sv[1]];
  290.             guv = pcd->gutab[su[1]] + pcd->gvtab[sv[1]];
  291.             bu  = pcd->butab[su[1]];
  292.             y11 = pcd->ytab[sy1[2]];
  293.             y12 = pcd->ytab[sy1[3]];
  295.             *(unsigned int *)(d1+2*BPP2) =
  296.                 (CLIP5[y11 + bu  + DITH5L] << 0)  |
  297.                 (CLIP6[y11 + guv + DITH6L] << 5)  |
  298.                 (CLIP5[y11 + rv  + DITH5L] << 11) |
  299.                 (CLIP5[y12 + bu  + DITH5H] << 16) |
  300.                 (CLIP6[y12 + guv + DITH6H] << 21) |
  301.                 (CLIP5[y12 + rv  + DITH5H] << 27) ;
  303.             y21 = pcd->ytab[sy2[2]];
  304.             y22 = pcd->ytab[sy2[3]];
  306.             *(unsigned int *)(d2+2*BPP2) =
  307.                 (CLIP5[y21 + bu  + DITH5H] << 0)  |
  308.                 (CLIP6[y21 + guv + DITH6H] << 5)  |
  309.                 (CLIP5[y21 + rv  + DITH5H] << 11) |
  310.                 (CLIP5[y22 + bu  + DITH5L] << 16) |
  311.                 (CLIP6[y22 + guv + DITH6L] << 21) |
  312.                 (CLIP5[y22 + rv  + DITH5L] << 27) ;
  314.             /* next 4x2 block */
  315.             sy1 += 4; sy2 += 4;
  316.             su += 2; sv += 2;
  317.             d1 += 4*BPP2; d2 += 4*BPP2;
  318.         }
  320.         /* convert last 2x2 block: */
  321.         if (dx & 2) {
  323.             rv = pcd->rvtab[sv[0]];
  324.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  325.             bu = pcd->butab[su[0]];
  326.             y11 = pcd->ytab[sy1[0]];
  327.             y12 = pcd->ytab[sy1[1]];
  329.             /* output 4 bytes at a time */
  330.             *(unsigned int *)(d1+0) =
  331.                 (CLIP5[y11 + bu  + DITH5L] << 0)  |
  332.                 (CLIP6[y11 + guv + DITH6L] << 5)  |
  333.                 (CLIP5[y11 + rv  + DITH5L] << 11) |
  334.                 (CLIP5[y12 + bu  + DITH5H] << 16) |
  335.                 (CLIP6[y12 + guv + DITH6H] << 21) |
  336.                 (CLIP5[y12 + rv  + DITH5H] << 27) ;
  338.             y21 = pcd->ytab[sy2[0]];
  339.             y22 = pcd->ytab[sy2[1]];
  341.             *(unsigned int *)(d2+0) =
  342.                 (CLIP5[y21 + bu  + DITH5H] << 0)  |
  343.                 (CLIP6[y21 + guv + DITH6H] << 5)  |
  344.                 (CLIP5[y21 + rv  + DITH5H] << 11) |
  345.                 (CLIP5[y22 + bu  + DITH5L] << 16) |
  346.                 (CLIP6[y22 + guv + DITH6L] << 21) |
  347.                 (CLIP5[y22 + rv  + DITH5L] << 27) ;
  349.             sy1 += 2; sy2 += 2;
  350.             su += 1; sv += 1;
  351.             d1 += 2*BPP2; d2 += 2*BPP2;
  352.             dx -= 2;
  353.         }
  355.         /* convert last 2x1 block: */
  356.         if (dx & 1) {
  358.             rv  = pcd->rvtab[sv[0]];
  359.             guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  360.             bu  = pcd->butab[su[0]];
  361.             y11 = pcd->ytab[sy1[0]];
  362.             y21 = pcd->ytab[sy2[0]];
  364.             /* output 2 bytes at a time */
  365.             *(unsigned short *)(d1+0) =
  366.                 (CLIP5[y11 + bu  + DITH5L] << 0)  |
  367.                 (CLIP6[y11 + guv + DITH6L] << 5)  |
  368.                 (CLIP5[y11 + rv  + DITH5L] << 11) ;
  370.             *(unsigned short *)(d2+0) =
  371.                 (CLIP5[y21 + bu  + DITH5H] << 0)  |
  372.                 (CLIP6[y21 + guv + DITH6H] << 5)  |
  373.                 (CLIP5[y21 + rv  + DITH5H] << 11) ;
  374.         }
  375.     }
  376. }
  378. #define DITH1X4L 0x01002004
  379. #define DITH1X4H 0x0300600C
  381. #define DITH2X4L 0x02004008
  382. #define DITH2X4H 0x0600C018
  384. #define DITH4X4L 0x04008010
  385. #define DITH4X4H 0x0C018030
  387. /* RGB565 version: */
  388. static void dblineXRGBtoRGB565x2 (unsigned char *d1, unsigned char *d2, int dest_x,
  389.   unsigned char *s1, unsigned char *s2, int src_x, int dx,
  390.   color_data_t* pcd)
  391. {
  392.     register unsigned int a, b, c, d, e, f;
  393.     register unsigned int w, x, y, z;
  395.     /* convert first 2x1 block: */
  396.     if (dest_x & 1) {
  398.         /* Input pels  =>   Output pels
  399.          *  a b             w  x
  400.          *  c d             w' x'
  401.          */
  403.         /* top line */
  404.         a = *(unsigned int *)s1;
  405.         b = *(unsigned int *)(s1+BPP4);
  407.         w = a     + DITH1X4L;
  408.         x = a + b + DITH2X4H;
  410.         /* pack and store */
  411.         *(unsigned int *)d1 =
  412.             ((w & 0x000000f8) >> 3)  |
  413.             ((w & 0x0007e000) >> 8)  |
  414.             ((w & 0x3e000000) >> 14) |
  415.             ((x & 0x000001f0) << 12) |
  416.             ((x & 0x000fc000) << 7)  |
  417.             ((x & 0x7c000000) << 1);
  419.         /* bottom line */
  420.         c = *(unsigned int *)s2;
  421.         d = *(unsigned int *)(s2+BPP4);
  423.         w = a + c         + DITH2X4H;
  424.         x = a + b + c + d + DITH4X4L;
  426.         /* pack and store */
  427.         *(unsigned int *)d2 =
  428.             ((w & 0x000001f0) >> 4)  |
  429.             ((w & 0x000fc000) >> 9)  |
  430.             ((w & 0x7c000000) >> 15) |
  431.             ((x & 0x000003e0) << 11) |
  432.             ((x & 0x001f8000) << 6)  |
  433.             ((x & 0xf8000000) << 0);
  435.         /* bump pointers to next block */
  436.         s1 += BPP4; s2 += BPP4;
  437.         d1 += 2*BPP2; d2 += 2*BPP2;
  438.         dx -= 1;
  439.     }
  441.     /* process all integral 2x2 blocks: */
  442.     while (dx > 2) {    /* we need to leave at least one block */
  444.         /*
  445.          * Input stored as 00 RRRRRRRR 000 GGGGGGGG 000 BBBBBBBB
  446.          *
  447.          * Input pels       Output pels
  448.          *  a b e           w  x  y  z
  449.          *  c d f           w' x' y' z'
  450.          */
  452.         /* top line */
  453.         a = *(unsigned int *)s1;
  454.         b = *(unsigned int *)(s1+BPP4);
  455.         e = *(unsigned int *)(s1+2*BPP4);
  457.         w = a     + DITH1X4L;
  458.         x = a + b + DITH2X4H;
  459.         y = b     + DITH1X4L;
  460.         z = b + e + DITH2X4H;
  462.         /* pack and store */
  463.         *(unsigned int *)d1 =
  464.             ((w & 0x000000f8) >> 3)  |
  465.             ((w & 0x0007e000) >> 8)  |
  466.             ((w & 0x3e000000) >> 14) |
  467.             ((x & 0x000001f0) << 12) |
  468.             ((x & 0x000fc000) << 7)  |
  469.             ((x & 0x7c000000) << 1);
  470.         *(unsigned int *)(d1+2*BPP2) =
  471.             ((y & 0x000000f8) >> 3)  |
  472.             ((y & 0x0007e000) >> 8)  |
  473.             ((y & 0x3e000000) >> 14) |
  474.             ((z & 0x000001f0) << 12) |
  475.             ((z & 0x000fc000) << 7)  |
  476.             ((z & 0x7c000000) << 1);
  478.         /* bottom line */
  479.         c = *(unsigned int *)s2;
  480.         d = *(unsigned int *)(s2+BPP4);
  481.         f = *(unsigned int *)(s2+2*BPP4);
  483.         w = a + c         + DITH2X4H;
  484.         x = a + b + c + d + DITH4X4L;
  485.         y = b + d         + DITH2X4H;
  486.         z = b + e + d + f + DITH4X4L;
  488.         /* pack and store */
  489.         *(unsigned int *)d2 =
  490.             ((w & 0x000001f0) >> 4)  |
  491.             ((w & 0x000fc000) >> 9)  |
  492.             ((w & 0x7c000000) >> 15) |
  493.             ((x & 0x000003e0) << 11) |
  494.             ((x & 0x001f8000) << 6)  |
  495.             ((x & 0xf8000000) << 0);
  496.         *(unsigned int *)(d2+2*BPP2) =
  497.             ((y & 0x000001f0) >> 4)  |
  498.             ((y & 0x000fc000) >> 9)  |
  499.             ((y & 0x7c000000) >> 15) |
  500.             ((z & 0x000003e0) << 11) |
  501.             ((z & 0x001f8000) << 6)  |
  502.             ((z & 0xf8000000) << 0);
  504.         /* next 2x2 input block */
  505.         s1 += 2*BPP4; s2 += 2*BPP4;
  506.         d1 += 4*BPP2; d2 += 4*BPP2;
  507.         dx -= 2;
  508.     }
  510.     /* check if this is the last 2x2 block: */
  511.     if (dx > 1) {
  513.         /*
  514.          * For last 4 output pels, repeat final input pel
  515.          * for offscreen input.  Equivalent to pixel-doubling the
  516.          * last output pel.
  517.          */
  519.         /* top line */
  520.         a = *(unsigned int *)s1;
  521.         b = *(unsigned int *)(s1+BPP4);
  522.         e = b;      /* repeat last input pel */
  524.         w = a     + DITH1X4L;
  525.         x = a + b + DITH2X4H;
  526.         y = b     + DITH1X4L;
  527.         z = b + e + DITH2X4H;
  529.         /* pack and store */
  530.         *(unsigned int *)d1 =
  531.             ((w & 0x000000f8) >> 3)  |
  532.             ((w & 0x0007e000) >> 8)  |
  533.             ((w & 0x3e000000) >> 14) |
  534.             ((x & 0x000001f0) << 12) |
  535.             ((x & 0x000fc000) << 7)  |
  536.             ((x & 0x7c000000) << 1);
  537.         *(unsigned int *)(d1+2*BPP2) =
  538.             ((y & 0x000000f8) >> 3)  |
  539.             ((y & 0x0007e000) >> 8)  |
  540.             ((y & 0x3e000000) >> 14) |
  541.             ((z & 0x000001f0) << 12) |
  542.             ((z & 0x000fc000) << 7)  |
  543.             ((z & 0x7c000000) << 1);
  545.         /* bottom line */
  546.         c = *(unsigned int *)s2;
  547.         d = *(unsigned int *)(s2+BPP4);
  548.         f = d;      /* repeat last input pel */
  550.         w = a + c         + DITH2X4H;
  551.         x = a + b + c + d + DITH4X4L;
  552.         y = b + d         + DITH2X4H;
  553.         z = b + e + d + f + DITH4X4L;
  555.         /* pack and store */
  556.         *(unsigned int *)d2 =
  557.             ((w & 0x000001f0) >> 4)  |
  558.             ((w & 0x000fc000) >> 9)  |
  559.             ((w & 0x7c000000) >> 15) |
  560.             ((x & 0x000003e0) << 11) |
  561.             ((x & 0x001f8000) << 6)  |
  562.             ((x & 0xf8000000) << 0);
  563.         *(unsigned int *)(d2+2*BPP2) =
  564.             ((y & 0x000001f0) >> 4)  |
  565.             ((y & 0x000fc000) >> 9)  |
  566.             ((y & 0x7c000000) >> 15) |
  567.             ((z & 0x000003e0) << 11) |
  568.             ((z & 0x001f8000) << 6)  |
  569.             ((z & 0xf8000000) << 0);
  571.     } else {
  572.         /* last 2x1 block: */
  574.         /* Input pels  =>   Output pels
  575.          *  a b             w  x
  576.          *  c d             w' x'
  577.          */
  579.         /* top line */
  580.         a = *(unsigned int *)s1;
  581.         b = a;      /* repeat last input pel */
  583.         w = a     + DITH1X4L;
  584.         x = a + b + DITH2X4H;
  586.         /* pack and store */
  587.         *(unsigned int *)d1 =
  588.             ((w & 0x000000f8) >> 3)  |
  589.             ((w & 0x0007e000) >> 8)  |
  590.             ((w & 0x3e000000) >> 14) |
  591.             ((x & 0x000001f0) << 12) |
  592.             ((x & 0x000fc000) << 7)  |
  593.             ((x & 0x7c000000) << 1);
  595.         /* bottom line */
  596.         c = *(unsigned int *)s2;
  597.         d = c;      /* repeat last input pel */
  599.         w = a + c         + DITH2X4H;
  600.         x = a + b + c + d + DITH4X4L;
  602.         /* pack and store */
  603.         *(unsigned int *)d2 =
  604.             ((w & 0x000001f0) >> 4)  |
  605.             ((w & 0x000fc000) >> 9)  |
  606.             ((w & 0x7c000000) >> 15) |
  607.             ((x & 0x000003e0) << 11) |
  608.             ((x & 0x001f8000) << 6)  |
  609.             ((x & 0xf8000000) << 0);
  610.     }
  611. }
  613. /*
  614.  * Convert two YUV lines into RGB linebufs.
  615.  * Produces two RGB lines per call.
  616.  * Output in padded RGB format, needed for SIMD interpolation.
  617.  */
  618. static void dblineI420toXRGB (unsigned char *d1, unsigned char *d2, int dest_x,
  619.     unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  620.       int src_x, int dx,
  621.       color_data_t* pcd)
  622. {
  623.     register int y1, y2, rv, guv, bu;
  624.     register int i;
  626.     /* convert first 2x1 block: */
  627.     if (src_x & 1) {
  629.         bu = pcd->butab[su[0]];
  630.         guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  631.         rv = pcd->rvtab[sv[0]];
  632.         y1 = pcd->ytab[sy1[0]];
  633.         y2 = pcd->ytab[sy2[0]];
  635.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  636.         *(unsigned int *)(d1+0) =
  637.             (CLIP8[y1 + bu])        |
  638.             (CLIP8[y1 + guv] << 11) |
  639.             (CLIP8[y1 + rv]  << 22) ;
  641.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  642.         *(unsigned int *)(d2+0) =
  643.             (CLIP8[y2 + bu])        |
  644.             (CLIP8[y2 + guv] << 11) |
  645.             (CLIP8[y2 + rv]  << 22) ;
  647.         sy1 += 1; sy2 += 1;
  648.         su += 1; sv += 1;
  649.         d1 += BPP4; d2 += BPP4;
  650.         dx --;
  651.     }
  653.     /* convert all integral 2x2 blocks: */
  654.     for (i = 0; i < dx/2; i ++) {
  656.         bu = pcd->butab[su[0]];
  657.         guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  658.         rv = pcd->rvtab[sv[0]];
  659.         y1 = pcd->ytab[sy1[0]];
  660.         y2 = pcd->ytab[sy2[0]];
  662.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  663.         *(unsigned int *)(d1+0) =
  664.             (CLIP8[y1 + bu])        |
  665.             (CLIP8[y1 + guv] << 11) |
  666.             (CLIP8[y1 + rv]  << 22) ;
  668.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  669.         *(unsigned int *)(d2+0) =
  670.             (CLIP8[y2 + bu])        |
  671.             (CLIP8[y2 + guv] << 11) |
  672.             (CLIP8[y2 + rv]  << 22) ;
  674.         /* 2nd row: */
  675.         y1 = pcd->ytab[sy1[1]];
  676.         y2 = pcd->ytab[sy2[1]];
  678.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  679.         *(unsigned int *)(d1+BPP4) =
  680.             (CLIP8[y1 + bu])        |
  681.             (CLIP8[y1 + guv] << 11) |
  682.             (CLIP8[y1 + rv]  << 22) ;
  684.         /* second line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  685.         *(unsigned int *)(d2+BPP4) =
  686.             (CLIP8[y2 + bu])        |
  687.             (CLIP8[y2 + guv] << 11) |
  688.             (CLIP8[y2 + rv]  << 22) ;
  690.         /* next 2x2 block */
  691.         sy1 += 2; sy2 += 2;
  692.         su += 1; sv += 1;
  693.         d1 += 2*BPP4; d2 += 2*BPP4;
  694.     }
  696.     /* convert last 2x1 block: */
  697.     if (dx & 1) {
  699.         bu = pcd->butab[su[0]];
  700.         guv = pcd->gutab[su[0]] + pcd->gvtab[sv[0]];
  701.         rv = pcd->rvtab[sv[0]];
  702.         y1 = pcd->ytab[sy1[0]];
  703.         y2 = pcd->ytab[sy2[0]];
  705.         /* first line 00rrrrrr.rr000ggg.ggggg000.bbbbbbbb: */
  706.         *(unsigned int *)(d1+0) =
  707.             (CLIP8[y1 + bu])        |
  708.             (CLIP8[y1 + guv] << 11) |
  709.             (CLIP8[y1 + rv]  << 22) ;
  711.         /* second line BGR0 */
  712.         *(unsigned int *)(d2+0) =
  713.             (CLIP8[y2 + bu])        |
  714.             (CLIP8[y2 + guv] << 11) |
  715.             (CLIP8[y2 + rv]  << 22) ;
  716.     }
  717. }
  719. /*
  720.  * I420->RGB565 converter:
  721.  */
  722. int I420toRGB565 (unsigned char *dest_ptr, int dest_width, int dest_height,
  723.     int dest_pitch, int dest_x, int dest_y, int dest_dx, int dest_dy,
  724.     unsigned char *src_ptr, int src_width, int src_height, int src_pitch,
  725.     int src_x, int src_y, int src_dx, int src_dy,
  726.   color_data_t* pcd)
  727. {
  728.     /* scale factors: */
  729.     int scale_x, scale_y;
  731.     /* check arguments: */
  732.     if (!chk_args (dest_ptr, dest_width, dest_height, dest_pitch,
  733.         dest_x, dest_y, dest_dx, dest_dy, src_ptr, src_width, src_height,
  734.         src_pitch, src_x, src_y, src_dx, src_dy, &scale_x, &scale_y))
  735.         return -1;
  737.     /* check if bottop-up images: */
  738.     if (dest_pitch < 0) dest_ptr -= (dest_height-1) * dest_pitch;
  739.     if (src_pitch <= 0) return -1;          /* not supported */
  741.     /* check if 1:1 scale: */
  742.     if (scale_x == 1 && scale_y == 1) {
  744.         /* color converter to use: */
  745.         void (*dbline) (unsigned char *d1, unsigned char *d2, int dest_x,
  746.             unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  747.             int src_x, int dx, color_data_t* pcd) = 
  748.             dblineI420toRGB565;
  750.         /* local variables: */
  751.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  752.         register int j;
  754.         /* get pointers: */
  755.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  756.         sy2 = sy1 + src_pitch;
  757.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  758.         sv  = su + src_height * src_pitch / 4;
  759.         d1  = dest_ptr + dest_x * 2 + dest_y * dest_pitch; /* RGB offset */
  760.         d2  = d1 + dest_pitch;
  762.         /* convert a top line: */
  763.         if (src_y & 1) {                        /* chroma shift */
  765.             /* this is a bit inefficient, but who cares??? */
  766.             (* dbline) (d1, d1, dest_x, sy1, sy1, su, sv, src_x, src_dx, pcd);
  768.             sy1 += src_pitch;   sy2 += src_pitch;
  769.             su  += src_pitch/2; sv  += src_pitch/2;
  770.             d1  += dest_pitch;  d2  += dest_pitch;
  771.             dest_dy --;
  772.         }
  774.         /* convert aligned portion of the image: */
  775.         for (j = 0; j < dest_dy/2; j ++) {
  777.             /* convert two lines a time: */
  778.             (* dbline) (d1, d2, dest_x, sy1, sy2, su, sv, src_x, src_dx, pcd);
  780.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  781.             su  += src_pitch/2; sv  += src_pitch/2;
  782.             d1  += dest_pitch*2; d2 += dest_pitch*2;
  783.         }
  785.         /* convert bottom line (if dest_dy is odd): */
  786.         if (dest_dy & 1) {
  788.             /* convert one line only: */
  789.             (* dbline) (d1, d1, dest_x, sy1, sy1, su, sv, src_x, src_dx, pcd);
  790.         }
  791.         return 0;
  792.     }
  794.     /* check if 2:1 scale: */
  795.     if (scale_x == 2 && scale_y == 2) {
  796.         /* color converter & interpolator to use: */
  797.         void (*cvt) (unsigned char *d1, unsigned char *d2, int dest_x,
  798.             unsigned char *sy1, unsigned char *sy2, unsigned char *su, unsigned char *sv,
  799.             int src_x, int dx, color_data_t* pcd) = dblineI420toXRGB;
  800.         void (*x2) (unsigned char *d1, unsigned char *d2, int dest_x,
  801.             unsigned char *s1, unsigned char *s2, int src_x, int dx, color_data_t* pcd) = dblineXRGBtoRGB565x2;
  803.         /* local variables: */
  804.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  805.         register int dy = src_dy;
  807.         /* line buffers (we want them to be as compact as possible): */
  808.         int ibuf = 0;                           /* circular buffer index */
  809.         unsigned char * buf[3];                 /* actual pointers  */
  810.         buf[0] = pcd->linebuf;
  811.         buf[1] = pcd->linebuf + src_dx * BPP4;
  812.         buf[2] = pcd->linebuf + 2 * src_dx * BPP4;
  814.         /* get pointers: */
  815.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  816.         sy2 = sy1 + src_pitch;
  817.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  818.         sv  = su + src_height * src_pitch / 4;
  819.         d1  = dest_ptr + dest_x * BYTESPERPIXEL + dest_y * dest_pitch; /* RGB offset */
  820.         d2  = d1 + dest_pitch;
  822.         /* check if we have misaligned top line: */
  823.         if (src_y & 1) {
  825.             /* convert an odd first line: */
  826.             (*cvt) (buf[ibuf], buf[ibuf], 0, sy1, sy1, su, sv, src_x, src_dx, pcd);
  827.             sy1 += src_pitch;   sy2 += src_pitch;
  828.             su  += src_pitch/2; sv  += src_pitch/2;
  829.             dy --;
  831.         } else {
  833.             /* otherwise, convert first two lines: */
  834.             (*cvt) (buf[next[ibuf]], buf[next2[ibuf]], 0, sy1, sy2, su, sv, src_x, src_dx, pcd);
  835.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  836.             su  += src_pitch/2; sv  += src_pitch/2;
  837.             ibuf = next[ibuf];      /* skip first interpolation: */
  839.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  840.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  841.             ibuf = next[ibuf];
  842.             dy -= 2;
  843.         }
  845.         /*
  846.          * Convert & interpolate the main portion of image:
  847.          *
  848.          *  source:      temp.store:                destination:
  849.          *
  850.          *               buf[ibuf] -------    /--> d1
  851.          *                                  x2  --> d2
  852.          *  s1 --   /-> buf[next[ibuf]] -<    /--> d1'=d1+2*pitch
  853.          *        cvt                       x2 ---> d2'=d2+2*pitch
  854.          *  s2 --/   -> buf[next2[ibuf]] /
  855.          */
  856.         while (dy >= 2) {
  858.             /* convert two lines into XRGB buffers: */
  859.             (*cvt) (buf[next[ibuf]], buf[next2[ibuf]], 0, sy1, sy2, su, sv, src_x, src_dx, pcd);
  860.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  861.             su  += src_pitch/2; sv  += src_pitch/2;
  863.             /* interpolate first line: */
  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];
  868.             /* interpolate second one: */
  869.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  870.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  871.             ibuf = next[ibuf];
  872.             dy -= 2;
  873.         }
  875.         /* check the # of remaining rows: */
  876.         if (dy & 1) {
  878.             /* convert the last odd line: */
  879.             (*cvt) (buf[next[ibuf]], buf[next[ibuf]], 0, sy1, sy1, su, sv, src_x, src_dx, pcd);
  881.             /* interpolate first line: */
  882.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[next[ibuf]], 0, src_dx, pcd);
  883.             d1  += dest_pitch*2; d2  += dest_pitch*2;
  884.             ibuf = next[ibuf];
  886.             /* replicate the last line: */
  887.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[ibuf], 0, src_dx, pcd);
  889.         } else {
  891.             /* replicate the last line: */
  892.             (*x2) (d1, d2, dest_x, buf[ibuf], buf[ibuf], 0, src_dx, pcd);
  893.         }
  894.         return 0;
  895.     }
  897.     /* check for 1/2 X scaling */
  898.     if (scale_x == 0 && scale_y == 0) {
  900.         /* local variables: */
  901.         unsigned char *sy1, *sy2, *su, *sv, *d1, *d2;
  902.         register int j;
  904.         /* get pointers: */
  905.         sy1 = src_ptr + (src_x + src_y * src_pitch);        /* luma offset */
  906.         sy2 = sy1 + src_pitch;
  907.         su  = src_ptr + src_height * src_pitch + (src_x/2 + src_y/2 * src_pitch);
  908.         sv  = su + src_height * src_pitch / 4;
  909.         d1  = dest_ptr + dest_x * 2 + dest_y * dest_pitch; /* RGB offset */
  910.         d2  = d1 + dest_pitch;
  912.         /* convert aligned portion of the image: */
  913.         for (j = 0; j < dest_dy>>1; j ++) {
  915.             /* convert two lines a time: */
  916.             halfI420toRGB565 (d1, dest_x, sy1, sy2, su, sv, src_x, src_dx, 0, pcd);
  917.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  918.             su  += src_pitch/2; sv  += src_pitch/2;
  919.             d1  += dest_pitch;
  921.             halfI420toRGB565 (d1, dest_x, sy1, sy2, su, sv, src_x, src_dx, 1, pcd);
  922.             sy1 += src_pitch*2; sy2 += src_pitch*2;
  923.             su  += src_pitch/2; sv  += src_pitch/2;
  924.             d1  += dest_pitch;
  925.         }
  927.         return 0;
  928.     }
  930.     /* conversion is not supported */
  931.     return -1;
  932. }
  934. /*
  935.  * InitI420toRGB565 initializes the minimum set of clip tables necessary to perform
  936.  * color conversion to 16 bit RGB.  The 8-bit clip table is necessary for 2x
  937.  * interpolation.
  938.  *
  939.  * This routine also calls SetSrcI420Colors, which initializes color conversion tables
  940.  * and adds color balance.
  941.  */
  942. void InitI420toRGB565(float brightness, float contrast, float saturation, float hue,
  943.       color_data_t* pcd)
  944. {
  945.     InitColorData(pcd);
  946.     SetSrcI420Colors (brightness, contrast, saturation, hue, pcd);
  947. }
  949. void UninitI420toRGB565( ){
  950.     /* noop */
  951. }