uph.c
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:13k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "statname.h"
  36. #include "l3.h"
  37. #ifdef _MSC_VER
  38. #pragma warning(disable: 4505)
  39. #endif
  40. #ifdef __cplusplus
  41. extern "C" {
  42. #endif
  43. void unpack_huff(int xy[][2], int n, int ntable, BITDAT *bitdat);
  44. int unpack_huff_quad(int vwxy[][4], int n, int nbits, int ntable, BITDAT *bitdat);
  45. #ifdef __cplusplus
  46. }
  47. #endif
  48. /*===============================================================*/
  49. /* max bits required for any lookup - change if htable changes */
  50. /* quad required 10 bit w/signs  must have (MAXBITS+2) >= 10   */
  51. #define MAXBITS 9
  52. static const HUFF_ELEMENT huff_table_0[] = { 0, 0, 0, 64 }; /* dummy must not use */
  53. #include "htable.h"
  54. /*-- 6 bit lookup (purgebits, value) --*/
  55. static const unsigned char quad_table_a[][2] = { /* JR - made const */
  56. 6, 11,  6, 15,  6, 13,  6, 14,  6,  7,  6,  5,  5,  9,
  57. 5,  9,  5,  6,  5,  6,  5,  3,  5,  3,  5, 10,  5, 10,  
  58. 5, 12,  5, 12,  4,  2,  4,  2,  4,  2,  4,  2,  4,  1,  
  59. 4,  1,  4,  1,  4,  1,  4,  4,  4,  4,  4,  4,  4,  4,  
  60. 4,  8,  4,  8,  4,  8,  4,  8,  1,  0,  1,  0,  1,  0,  
  61. 1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  
  62. 1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  
  63. 1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  
  64. 1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  1,  0,  
  65. 1,  0,  
  66. };
  67. typedef struct {
  68.     const HUFF_ELEMENT* table;
  69.     int linbits;
  70.     int ncase;
  71. } HUFF_SETUP;
  72. #define no_bits       0
  73. #define one_shot      1
  74. #define no_linbits    2
  75. #define have_linbits  3
  76. #define quad_a        4
  77. #define quad_b        5
  78. /* JR - made const */
  79. static const HUFF_SETUP table_look[] = {
  80. huff_table_0,  0,  no_bits,
  81. huff_table_1,  0,  one_shot,
  82. huff_table_2,  0,  one_shot,
  83. huff_table_3,  0,  one_shot,
  84. huff_table_0,  0,  no_bits,
  85. huff_table_5,  0,  one_shot,
  86. huff_table_6,  0,  one_shot,
  87. huff_table_7,  0,  no_linbits,
  88. huff_table_8,  0,  no_linbits,
  89. huff_table_9,  0,  no_linbits,
  90. huff_table_10, 0,  no_linbits,
  91. huff_table_11, 0,  no_linbits,
  92. huff_table_12, 0,  no_linbits,
  93. huff_table_13, 0,  no_linbits,
  94. huff_table_0,  0,  no_bits,
  95. huff_table_15, 0,  no_linbits,
  96. huff_table_16, 1,  have_linbits,
  97. huff_table_16, 2,  have_linbits,
  98. huff_table_16, 3,  have_linbits,
  99. huff_table_16, 4,  have_linbits,
  100. huff_table_16, 6,  have_linbits,
  101. huff_table_16, 8,  have_linbits,
  102. huff_table_16, 10, have_linbits,
  103. huff_table_16, 13, have_linbits,
  104. huff_table_24, 4,  have_linbits,
  105. huff_table_24, 5,  have_linbits,
  106. huff_table_24, 6,  have_linbits,
  107. huff_table_24, 7,  have_linbits,
  108. huff_table_24, 8,  have_linbits,
  109. huff_table_24, 9,  have_linbits,
  110. huff_table_24, 11, have_linbits,
  111. huff_table_24, 13, have_linbits,
  112. huff_table_0,  0,  quad_a,
  113. huff_table_0,  0,  quad_b,
  114. };
  115. /*========================================================*/
  116. /*------------- get n bits from bitstream -------------*/
  117. static unsigned int bitget(BITDAT *bitdat, int n)
  118. {
  119. unsigned int x;
  120. if( bitdat->bits < n ) {    /* refill bit buf if necessary */
  121.           while( bitdat->bits <= 24 ) {
  122.              bitdat->bitbuf = (bitdat->bitbuf << 8) | *bitdat->bs_ptr++;
  123.              bitdat->bits += 8;
  124.           }
  125. }
  126. bitdat->bits -= n;
  127. x = bitdat->bitbuf >> bitdat->bits;
  128. bitdat->bitbuf -= x << bitdat->bits;
  129. return x;
  130. }
  131. /*----- get n bits  - checks for n+2 avail bits (linbits+sign) -----*/
  132. static unsigned int bitget_lb(BITDAT *bitdat, int n)
  133. {
  134. unsigned int x;
  135. if( bitdat->bits < (n+2) ) {    /* refill bit buf if necessary */
  136.           while( bitdat->bits <= 24 ) {
  137.              bitdat->bitbuf = (bitdat->bitbuf << 8) | *bitdat->bs_ptr++;
  138.              bitdat->bits += 8;
  139.           }
  140. }
  141. bitdat->bits -= n;
  142. x = bitdat->bitbuf >> bitdat->bits;
  143. bitdat->bitbuf -= x << bitdat->bits;
  144. return x;
  145. }
  146. /*------------- get n bits but DO NOT remove from bitstream --*/
  147. static unsigned int bitget2(BITDAT *bitdat, int n)
  148. {
  149. unsigned int x;
  150. if( bitdat->bits < (MAXBITS+2) ) {    /* refill bit buf if necessary */
  151.           while( bitdat->bits <= 24 ) {
  152.              bitdat->bitbuf = (bitdat->bitbuf << 8) | *bitdat->bs_ptr++;
  153.              bitdat->bits += 8;
  154.           }
  155. }
  156. x = bitdat->bitbuf >> (bitdat->bits-n);
  157. return x;
  158. }
  159. /*------------- remove n bits from bitstream ---------*/
  160. static void bitget_purge(BITDAT *bitdat, int n)
  161. {
  162. bitdat->bits -= n;
  163. bitdat->bitbuf -= (bitdat->bitbuf >> bitdat->bits) << bitdat->bits;
  164. }
  165. /*------------- get 1 bit from bitstream NO CHECK -------------*/
  166. static unsigned int bitget_1bit(BITDAT *bitdat)
  167. {
  168. unsigned int x;
  169. bitdat->bits--;
  170. x = bitdat->bitbuf >> bitdat->bits;
  171. bitdat->bitbuf -= x << bitdat->bits;
  172. return x;
  173. }
  174. /*========================================================*/
  175. /*========================================================*/
  176. #define mac_bitget_check(bitdat, n)                 
  177. if( bitdat->bits < (n) ) {                   
  178.     while( bitdat->bits <= 24 ) {            
  179.         bitdat->bitbuf = (bitdat->bitbuf << 8) | *bitdat->bs_ptr++; 
  180.         bitdat->bits += 8;                   
  181.     }                                       
  182. }
  183. /*---------------------------------------------------------*/
  184. #define mac_bitget2(bitdat, n)                
  185.     (bitdat->bitbuf >> (bitdat->bits-n));
  186. /*---------------------------------------------------------*/
  187. #define mac_bitget(bitdat, n)                
  188.        ( bitdat->bits -= n,           
  189.          code  = bitdat->bitbuf >> bitdat->bits,     
  190.          bitdat->bitbuf -= code << bitdat->bits,     
  191.          code )
  192. /*---------------------------------------------------------*/
  193. #define mac_bitget_purge(bitdat, n)                
  194.     bitdat->bits -= n,                    
  195.     bitdat->bitbuf -= (bitdat->bitbuf >> bitdat->bits) << bitdat->bits;
  196. /*---------------------------------------------------------*/
  197. #define mac_bitget_1bit(bitdat)                         
  198.        ( bitdat->bits--,                           
  199.          code  = bitdat->bitbuf >> bitdat->bits,    
  200.          bitdat->bitbuf -= code << bitdat->bits,  
  201.          code )
  202. /*========================================================*/
  203. /*========================================================*/
  204. void unpack_huff(int xy[][2], int n, int ntable, BITDAT *bitdat)
  205. {
  206. int i;
  207. const HUFF_ELEMENT *t; /* JR - made const ptr */
  208. const HUFF_ELEMENT *t0; /* JR - made const ptr */
  209. int linbits;
  210. int bits;
  211. int code;
  212. int x, y;
  213. if( n <= 0 ) return;
  214. n = n >> 1;         /* huff in pairs */
  215. /*-------------*/
  216. t0      = table_look[ntable].table;
  217. linbits = table_look[ntable].linbits;
  218. switch (table_look[ntable].ncase) {
  219. default:
  220. /*------------------------------------------*/
  221. case no_bits:       /*- table 0, no data, x=y=0--*/
  222. for(i=0;i<n;i++) {
  223.     xy[i][0] = 0;
  224.     xy[i][1] = 0;
  225. }
  226. return;
  227. /*------------------------------------------*/
  228. case one_shot:       /*- single lookup, no escapes -*/
  229. for(i=0;i<n;i++) {
  230.     mac_bitget_check(bitdat, (MAXBITS+2));
  231.     bits = t0[0].b.signbits;
  232.     code = mac_bitget2(bitdat, bits);
  233.     mac_bitget_purge(bitdat, t0[1+code].b.purgebits);
  234.     x = t0[1+code].b.x;
  235.     y = t0[1+code].b.y;
  236.     if( x ) if( mac_bitget_1bit(bitdat) ) x = -x;
  237.     if( y ) if( mac_bitget_1bit(bitdat) ) y = -y;
  238.     xy[i][0] = x;
  239.     xy[i][1] = y;
  240.     if( bitdat->bs_ptr > bitdat->bs_ptr_end ) break;  // bad data protect
  241. }
  242. return;
  243. /*------------------------------------------*/
  244. case no_linbits:
  245. for(i=0;i<n;i++) {
  246.     t = t0;
  247.     for(;;) {
  248.         mac_bitget_check(bitdat, (MAXBITS+2));
  249.         bits = t[0].b.signbits;
  250.         code = mac_bitget2(bitdat, bits);
  251.         if( t[1+code].b.purgebits ) break;
  252.         t += t[1+code].ptr;  /* ptr include 1+code */
  253.         mac_bitget_purge(bitdat, bits);
  254.     }
  255.     mac_bitget_purge(bitdat, t[1+code].b.purgebits);
  256.     x = t[1+code].b.x;
  257.     y = t[1+code].b.y;
  258.     if( x ) if( mac_bitget_1bit(bitdat) ) x = -x;
  259.     if( y ) if( mac_bitget_1bit(bitdat) ) y = -y;
  260.     xy[i][0] = x;
  261.     xy[i][1] = y;
  262.     if( bitdat->bs_ptr > bitdat->bs_ptr_end ) break;  // bad data protect
  263. }
  264. return;
  265. /*------------------------------------------*/
  266. case have_linbits:
  267. for(i=0;i<n;i++) {
  268.     t = t0;
  269.     for(;;) {
  270.         bits = t[0].b.signbits;
  271.         code = bitget2(bitdat, bits);
  272.         if( t[1+code].b.purgebits ) break;
  273.         t += t[1+code].ptr;  /* ptr includes 1+code */
  274.         mac_bitget_purge(bitdat, bits);
  275.     }
  276.     mac_bitget_purge(bitdat, t[1+code].b.purgebits);
  277.     x = t[1+code].b.x;
  278.     y = t[1+code].b.y;
  279.     if( x == 15 ) x += bitget_lb(bitdat, linbits);
  280.     if( x ) if( mac_bitget_1bit(bitdat) ) x = -x;
  281.     if( y == 15 ) y += bitget_lb(bitdat, linbits);
  282.     if( y ) if( mac_bitget_1bit(bitdat) ) y = -y;
  283.     xy[i][0] = x;
  284.     xy[i][1] = y;
  285.     if( bitdat->bs_ptr > bitdat->bs_ptr_end ) break;  // bad data protect
  286. }
  287. return;
  288. }  /*--- end switch ---*/
  289. }
  290. /*==========================================================*/
  291. int unpack_huff_quad(int vwxy[][4], int n, int nbits, int ntable, BITDAT *bitdat)
  292. {
  293. int i;
  294. int code;
  295. int x, y, v, w;
  296. int tmp;
  297. int i_non_zero, tmp_nz;
  298. tmp_nz = 15;
  299. i_non_zero = -1;
  300. n = n >> 2;     /* huff in quads */
  301. if( ntable ) goto case_quad_b;
  302. /* case_quad_a: */
  303. for(i=0;i<n;i++) {
  304.     if( nbits <= 0 ) break;
  305.     mac_bitget_check(bitdat, 10);
  306.     code = mac_bitget2(bitdat, 6);
  307.     nbits -= quad_table_a[code][0];
  308.     mac_bitget_purge(bitdat, quad_table_a[code][0]);
  309.     tmp = quad_table_a[code][1];
  310. if( tmp ) { i_non_zero = i; tmp_nz = tmp; }
  311.     v = (tmp>>3) & 1;
  312.     w = (tmp>>2) & 1;
  313.     x = (tmp>>1) & 1;
  314.     y =  tmp & 1;
  315.     if( v ) { if( mac_bitget_1bit(bitdat) ) v = -v; nbits--; }
  316.     if( w ) { if( mac_bitget_1bit(bitdat) ) w = -w; nbits--; }
  317.     if( x ) { if( mac_bitget_1bit(bitdat) ) x = -x; nbits--; }
  318.     if( y ) { if( mac_bitget_1bit(bitdat) ) y = -y; nbits--; }
  319.     vwxy[i][0] = v;
  320.     vwxy[i][1] = w;
  321.     vwxy[i][2] = x;
  322.     vwxy[i][3] = y;
  323.     if( bitdat->bs_ptr > bitdat->bs_ptr_end ) break;  // bad data protect
  324. }
  325. if( nbits < 0 ) {
  326.     i--;
  327.     vwxy[i][0] = 0;
  328.     vwxy[i][1] = 0;
  329.     vwxy[i][2] = 0;
  330.     vwxy[i][3] = 0;
  331. }
  332. i_non_zero = (i_non_zero+1) << 2;
  333. if( (tmp_nz & 3) == 0 ) i_non_zero -= 2;
  334. return i_non_zero;
  335. /*--------------------*/
  336. case_quad_b:
  337. for(i=0;i<n;i++) {
  338.     if( nbits < 4 ) break;
  339.     nbits -= 4;
  340.     mac_bitget_check(bitdat, 8);
  341.     tmp = mac_bitget(bitdat, 4) ^ 15;   /* one's complement of bitstream */
  342.     if( tmp ) { i_non_zero = i; tmp_nz = tmp; }
  343.     v = (tmp>>3) & 1;
  344.     w = (tmp>>2) & 1;
  345.     x = (tmp>>1) & 1;
  346.     y =  tmp & 1;
  347.     if( v ) { if( mac_bitget_1bit(bitdat) ) v = -v; nbits--; }
  348.     if( w ) { if( mac_bitget_1bit(bitdat) ) w = -w; nbits--; }
  349.     if( x ) { if( mac_bitget_1bit(bitdat) ) x = -x; nbits--; }
  350.     if( y ) { if( mac_bitget_1bit(bitdat) ) y = -y; nbits--; }
  351.     vwxy[i][0] = v;
  352.     vwxy[i][1] = w;
  353.     vwxy[i][2] = x;
  354.     vwxy[i][3] = y;
  355.     if( bitdat->bs_ptr > bitdat->bs_ptr_end ) break;  // bad data protect
  356. }
  357. if( nbits < 0 ) {
  358.     i--;
  359.     vwxy[i][0] = 0;
  360.     vwxy[i][1] = 0;
  361.     vwxy[i][2] = 0;
  362.     vwxy[i][3] = 0;
  363. }
  364. i_non_zero = (i_non_zero+1) << 2;
  365. if( (tmp_nz & 3) == 0 ) i_non_zero -= 2;
  366. return i_non_zero;  /* return non-zero sample (to nearest pair) */
  367. }
  368. /*-----------------------------------------------------*/