home *** CD-ROM | disk | FTP | other *** search
/ Geek 6 / Geek-006.iso / linux / video / xmovie-1.5.3.tar.gz / xmovie-1.5.3.tar / xmovie-1.5.3 / quicktime / fastjpg.c < prev    next >
C/C++ Source or Header  |  2000-11-29  |  48KB  |  1,800 lines
  1. #include "fastjpg.h"
  2. #include "fastjpgmacro.h"
  3.  
  4. /* JPEG decoder from XAnim which ended up 10% slower than libjpeg */
  5.  
  6. /* JPEG MARKERS */
  7. #define   M_SOF0    0xc0
  8. #define   M_SOF1    0xc1
  9. #define   M_SOF2    0xc2
  10. #define   M_SOF3    0xc3
  11. #define   M_SOF5    0xc5
  12. #define   M_SOF6    0xc6
  13. #define   M_SOF7    0xc7
  14. #define   M_JPG     0xc8
  15. #define   M_SOF9    0xc9
  16. #define   M_SOF10   0xca
  17. #define   M_SOF11   0xcb
  18. #define   M_SOF13   0xcd
  19. #define   M_SOF14   0xce
  20. #define   M_SOF15   0xcf
  21. #define   M_DHT     0xc4
  22. #define   M_DAC     0xcc
  23. #define   M_RST0    0xd0
  24. #define   M_RST1    0xd1
  25. #define   M_RST2    0xd2
  26. #define   M_RST3    0xd3
  27. #define   M_RST4    0xd4
  28. #define   M_RST5    0xd5
  29. #define   M_RST6    0xd6
  30. #define   M_RST7    0xd7
  31. #define   M_SOI     0xd8
  32. #define   M_EOI     0xd9
  33. #define   M_SOS     0xda
  34. #define   M_DQT     0xdb
  35. #define   M_DNL     0xdc
  36. #define   M_DRI     0xdd
  37. #define   M_DHP     0xde
  38. #define   M_EXP     0xdf
  39. #define   M_APP0    0xe0
  40. #define   M_APP1    0xe1
  41. #define   M_APP2    0xe2
  42. #define   M_APP3    0xe3
  43. #define   M_APP4    0xe4
  44. #define   M_APP5    0xe5
  45. #define   M_APP6    0xe6
  46. #define   M_APP7    0xe7
  47. #define   M_APP8    0xe8
  48. #define   M_APP9    0xe9
  49. #define   M_APP10   0xea
  50. #define   M_APP11   0xeb
  51. #define   M_APP12   0xec
  52. #define   M_APP13   0xed
  53. #define   M_APP14   0xee
  54. #define   M_APP15   0xef
  55. #define   M_JPG0    0xf0
  56. #define   M_JPG13   0xfd
  57. #define   M_COM     0xfe
  58. #define   M_TEM     0x01
  59. #define   M_ERROR   0x100
  60.  
  61. static long JJ_ZAG[DCTSIZE2 + 16] = 
  62. {
  63.   0,  1,  8, 16,  9,  2,  3, 10,
  64.  17, 24, 32, 25, 18, 11,  4,  5,
  65.  12, 19, 26, 33, 40, 48, 41, 34,
  66.  27, 20, 13,  6,  7, 14, 21, 28,
  67.  35, 42, 49, 56, 57, 50, 43, 36,
  68.  29, 22, 15, 23, 30, 37, 44, 51,
  69.  58, 59, 52, 45, 38, 31, 39, 46,
  70.  53, 60, 61, 54, 47, 55, 62, 63,
  71.   0,  0,  0,  0,  0,  0,  0,  0, /* extra entries in case k>63 below */
  72.   0,  0,  0,  0,  0,  0,  0,  0
  73. };
  74.  
  75. static char std_luminance_quant_tbl[64] = {
  76.   16,  11,  12,  14,  12,  10,  16,  14,
  77.   13,  14,  18,  17,  16,  19,  24,  40,
  78.   26,  24,  22,  22,  24,  49,  35,  37,
  79.   29,  40,  58,  51,  61,  60,  57,  51,
  80.   56,  55,  64,  72,  92,  78,  64,  68,
  81.   87,  69,  55,  56,  80, 109,  81,  87,
  82.   95,  98, 103, 104, 103,  62,  77, 113,
  83.  121, 112, 100, 120,  92, 101, 103,  99
  84. };
  85.  
  86. static char std_chrominance_quant_tbl[64] = {
  87.   17,  18,  18,  24,  21,  24,  47,  26,
  88.   26,  47,  99,  66,  56,  66,  99,  99,
  89.   99,  99,  99,  99,  99,  99,  99,  99,
  90.   99,  99,  99,  99,  99,  99,  99,  99,
  91.   99,  99,  99,  99,  99,  99,  99,  99,
  92.   99,  99,  99,  99,  99,  99,  99,  99,
  93.   99,  99,  99,  99,  99,  99,  99,  99,
  94.   99,  99,  99,  99,  99,  99,  99,  99
  95. };
  96.  
  97. int quicktime_fastjpg_skip(quicktime_jpeg_t *jpeg_info, long len)
  98. {
  99.     if(len > jpeg_info->chunk_size)
  100.         jpeg_info->chunk += jpeg_info->chunk_size;
  101.     else
  102.         jpeg_info->chunk += len;
  103.     
  104.     return 0;
  105. }
  106.  
  107. int quicktime_fastjpg_readbyte(quicktime_jpeg_t *jpeg_info)
  108. {
  109.     if(jpeg_info->chunk_size > 0)
  110.     {
  111.         jpeg_info->chunk_size--;
  112.         return *(jpeg_info->chunk++);
  113.     }
  114.     else
  115.         return 0;
  116. }
  117.  
  118. int quicktime_fastjpg_readint16(quicktime_jpeg_t *jpeg_info)
  119. {
  120.     if(jpeg_info->chunk_size > 1)
  121.     {
  122.         jpeg_info->chunk_size -= 2;
  123.         jpeg_info->chunk += 2;
  124.         return ((int)jpeg_info->chunk[-2] << 8) | (unsigned char)jpeg_info->chunk[-1];
  125.     }
  126.     else
  127.         return 0;
  128. }
  129.  
  130. int quicktime_fastjpg_readint32(quicktime_jpeg_t *jpeg_info)
  131. {
  132.     if(jpeg_info->chunk_size > 3)
  133.     {
  134.         jpeg_info->chunk_size -= 4;
  135.         return (((unsigned long)*(jpeg_info->chunk++) << 24) | 
  136.                 ((unsigned long)*(jpeg_info->chunk++) << 16) |
  137.                 ((unsigned long)*(jpeg_info->chunk++) << 8) |
  138.                 ((unsigned long)*(jpeg_info->chunk++)));
  139.     }
  140.     else
  141.         return 0;
  142. }
  143.  
  144. int quicktime_fastjpg_eof(quicktime_jpeg_t *jpeg_info)
  145. {
  146.     if(jpeg_info->chunk_size > 0) 
  147.     return 0;
  148.     else
  149.     return 1;
  150. }
  151.  
  152. int quicktime_fastjpg_init_limittable(quicktime_jpeg_t *jpeg_info)
  153. {
  154.     unsigned char *table;
  155.     int i;
  156.  
  157.     jpeg_info->jpg_samp_limit = (unsigned char *)malloc((5 * (MAXJSAMPLE + 1) + CENTERJSAMPLE));
  158.     jpeg_info->byte_limit = jpeg_info->jpg_samp_limit + MAXJSAMPLE + 1;
  159.  
  160. /* create negative subscripts for simple table */
  161.     table = jpeg_info->jpg_samp_limit + MAXJSAMPLE + 1;
  162.  
  163. /* First segment of "simple" table: limit[x] = 0 for x < 0 */
  164.     memset(table - (MAXJSAMPLE + 1), 0, (MAXJSAMPLE + 1));
  165.  
  166. /* Main part of "simple" table: limit[x] = x */
  167.     for(i = 0; i <= MAXJSAMPLE; i++) table[i] = (unsigned char)i;
  168.  
  169. /* Point to where post-IDCT table starts */
  170.     table += CENTERJSAMPLE;
  171.  
  172. /* End of simple table, rest of first half of post-IDCT table */
  173.  
  174.     for(i = CENTERJSAMPLE; i < 2 * (MAXJSAMPLE + 1); i++) table[i] = MAXJSAMPLE;
  175.  
  176. /* Second half of post-IDCT table */
  177.     memset(table + (2 * (MAXJSAMPLE + 1)), 0, (2 * (MAXJSAMPLE + 1) - CENTERJSAMPLE));
  178.     memcpy(table + (4 * (MAXJSAMPLE + 1) - CENTERJSAMPLE),
  179.         (char*)(jpeg_info->jpg_samp_limit + (MAXJSAMPLE + 1)), CENTERJSAMPLE);
  180. }
  181.  
  182. int quicktime_fastjpg_init_yuv(quicktime_jpeg_t *jpeg_info)
  183. {
  184.     long i;
  185.     float t_ub,  t_vr,  t_ug,  t_vg;
  186.     float t2_ub, t2_vr, t2_ug, t2_vg;
  187.  
  188.     jpeg_info->yuvtabs.YUV_Y_tab = (long*)malloc(256 * sizeof(long));
  189.     jpeg_info->yuvtabs.YUV_UB_tab = (long*)malloc(256 * sizeof(long));
  190.     jpeg_info->yuvtabs.YUV_VR_tab = (long*)malloc(256 * sizeof(long));
  191.     jpeg_info->yuvtabs.YUV_UG_tab = (long*)malloc(256 * sizeof(long));
  192.     jpeg_info->yuvtabs.YUV_VG_tab = (long*)malloc(256 * sizeof(long));
  193.  
  194.     t_ub = (1.77200 / 2.0) * (float)(1 << 6) + 0.5;
  195.     t_vr = (1.40200 / 2.0) * (float)(1 << 6) + 0.5;
  196.     t_ug = (0.34414 / 2.0) * (float)(1 << 6) + 0.5;
  197.     t_vg = (0.71414 / 2.0) * (float)(1 << 6) + 0.5;
  198.     t2_ub = (1.4 * 1.77200 / 2.0) * (float)(1 << 6) + 0.5;
  199.     t2_vr = (1.4 * 1.40200 / 2.0) * (float)(1 << 6) + 0.5;
  200.     t2_ug = (1.4 * 0.34414 / 2.0) * (float)(1 << 6) + 0.5;
  201.     t2_vg = (1.4 * 0.71414 / 2.0) * (float)(1 << 6) + 0.5;
  202.  
  203.     for(i = 0; i < 256; i++)
  204.     {
  205.         float x = (float)(2 * i - 255);
  206.  
  207.         jpeg_info->yuvtabs.YUV_UB_tab[i] = (long)(( t_ub * x) + (1 << 5));
  208.         jpeg_info->yuvtabs.YUV_VR_tab[i] = (long)(( t_vr * x) + (1 << 5));
  209.         jpeg_info->yuvtabs.YUV_UG_tab[i] = (long)((-t_ug * x));
  210.         jpeg_info->yuvtabs.YUV_VG_tab[i] = (long)((-t_vg * x) + (1 << 5));
  211.         jpeg_info->yuvtabs.YUV_Y_tab[i]  = (long)((i << 6) | (i >> 2));
  212.     }
  213.     return 0;
  214. }
  215.  
  216. int quicktime_fastjpg_init(quicktime_jpeg_t *jpeg_info)
  217. {
  218.     int i;
  219.     for(i = 0; i < TOTAL_QUANT_TBLS; i++) jpeg_info->quant_tables[i] = 0;
  220.     quicktime_fastjpg_init_limittable(jpeg_info);
  221.     jpeg_info->mjpg_kludge = 0;
  222.     jpeg_info->jpg_std_DHT_flag = 0;
  223.     jpeg_info->mjpa_info.valid = 0;
  224.     jpeg_info->yuvbufs.allocated = 0;
  225.     jpeg_info->yuvbufs.ybuf = 0;
  226.     jpeg_info->yuvbufs.ubuf = 0;
  227.     jpeg_info->yuvbufs.vbuf = 0;
  228.     quicktime_fastjpg_init_yuv(jpeg_info);
  229.     return 0;
  230. }
  231.  
  232. int quicktime_fastjpg_deleteMCU(quicktime_jpeg_t *jpeg_info)
  233. {
  234.     if(jpeg_info->yuvbufs.allocated)
  235.     {
  236.         free(jpeg_info->yuvbufs.ybuf);
  237.         free(jpeg_info->yuvbufs.ubuf);
  238.         free(jpeg_info->yuvbufs.vbuf);
  239.     }
  240.     jpeg_info->yuvbufs.ybuf = 0;
  241.     jpeg_info->yuvbufs.ubuf = 0;
  242.     jpeg_info->yuvbufs.vbuf = 0;
  243.  
  244.     return 0;
  245. }
  246.  
  247.  
  248. int quicktime_fastjpg_delete(quicktime_jpeg_t *jpeg_info)
  249. {
  250.     int i;
  251.     for(i = 0; i < TOTAL_QUANT_TBLS; i++)
  252.         if(jpeg_info->quant_tables[i])
  253.         {
  254.             free(jpeg_info->quant_tables[i]); 
  255.             jpeg_info->quant_tables[i] = 0; 
  256.         }
  257.  
  258.     if(jpeg_info->jpg_samp_limit)
  259.     {
  260.         free(jpeg_info->jpg_samp_limit); 
  261.         jpeg_info->jpg_samp_limit = 0; 
  262.     }
  263.  
  264.     quicktime_fastjpg_deleteMCU(jpeg_info);
  265.  
  266.     free(jpeg_info->yuvtabs.YUV_Y_tab);
  267.     free(jpeg_info->yuvtabs.YUV_UB_tab);
  268.     free(jpeg_info->yuvtabs.YUV_VR_tab);
  269.     free(jpeg_info->yuvtabs.YUV_UG_tab);
  270.     free(jpeg_info->yuvtabs.YUV_VG_tab);
  271. }
  272.  
  273. int quicktime_fastjpg_resethuffman(quicktime_jpeg_t *jpeg_info)
  274. {
  275.     jpeg_info->jpg_comps[0].dc = 0;
  276.     jpeg_info->jpg_comps[1].dc = 0;
  277.     jpeg_info->jpg_comps[2].dc = 0;
  278.     jpeg_info->jpg_h_bbuf = 0;  /* clear huffman bit buffer */
  279.     jpeg_info->jpg_h_bnum = 0;
  280. }
  281.  
  282. int quicktime_fastjpg_buildhuffman(quicktime_jpeg_t *jpeg_info, 
  283.     quicktime_jpeg_huffman *htable, 
  284.     unsigned char *hbits, 
  285.     unsigned char *hvals)
  286. {
  287.     unsigned long clen, num_syms, p, i, si, code, lookbits;
  288.     unsigned long l, ctr;
  289.     unsigned char huffsize[257];
  290.     unsigned long huffcode[257];
  291.  
  292. /*** generate code lengths for each symbol */
  293.     num_syms = 0;
  294.     for(clen = 1; clen <= 16; clen++)
  295.     {
  296.         for(i = 1; i <= (unsigned long)(hbits[clen]); i++) 
  297.             huffsize[num_syms++] = (unsigned char)(clen);
  298.     }
  299.     huffsize[num_syms] = 0;
  300.  
  301. /*** generate codes */
  302.     code = 0;
  303.     si = huffsize[0];
  304.     p = 0;
  305.     while(huffsize[p])
  306.     {
  307.         while(((unsigned long)huffsize[p]) == si) 
  308.         {
  309.             huffcode[p++] = code;
  310.             code++;
  311.         }
  312.         code <<= 1;
  313.         si++;
  314.     }
  315.  
  316. /* Init mincode/maxcode/valptr arrays */
  317.     p = 0;
  318.     for(l = 1; l <= 16; l++) 
  319.     {
  320.         if (htable->bits[l]) 
  321.         {
  322.             htable->valptr[l] = p; /* huffval[] index of 1st symbol of code length l */
  323.             htable->mincode[l] = huffcode[p]; /* minimum code of length l */
  324.             p += (unsigned long)(htable->bits[l]);
  325.             htable->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
  326.         } 
  327.         else
  328.         {
  329.                 htable->valptr[l] = 0;  /* not needed */
  330.                 htable->mincode[l] = 0; /* not needed */
  331.                 htable->maxcode[l] = 0; /* WAS -1; */   /* -1 if no codes of this length */
  332.         }
  333.     }
  334.     htable->maxcode[17] = 0xFFFFFL; /* ensures huff_DECODE terminates */
  335.  
  336.  
  337. /* Init huffman cache */
  338.     memset((char *)htable->cache, 0, ((1 << HUFF_LOOKAHEAD) * sizeof(unsigned QUICKTIME_INT16)));
  339.     p = 0;
  340.     for (l = 1; l <= HUFF_LOOKAHEAD; l++) 
  341.     {
  342.         for (i = 1; i <= (unsigned long) htable->bits[l]; i++, p++) 
  343.         {
  344.             QUICKTIME_INT16 the_code = (unsigned QUICKTIME_INT16)((l << 8) | htable->vals[p]);
  345.  
  346. /* l = current code's length, p = its index in huffcode[] & huffval[]. */
  347. /* Generate left-justified code followed by all possible bit sequences */
  348.  
  349.             lookbits = huffcode[p] << (HUFF_LOOKAHEAD - l);
  350.             for(ctr = 1 << (HUFF_LOOKAHEAD - l); ctr > 0; ctr--) 
  351.             {
  352.                 htable->cache[lookbits] = the_code;
  353.                 lookbits++;
  354.             }
  355.         }
  356.     }
  357. }
  358.  
  359. int quicktime_fastjpg_buildstdhuffman(quicktime_jpeg_t *jpeg_info)
  360. {
  361.     long ttt, len;
  362.     quicktime_jpeg_huffman *htable;
  363.     unsigned char *hbits, *Sbits;
  364.     unsigned char *hvals, *Svals;
  365.  
  366.     static unsigned char dc_luminance_bits[] =
  367.     { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
  368.     static unsigned char dc_luminance_vals[] =
  369.     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  370.  
  371.     static unsigned char dc_chrominance_bits[] =
  372.     { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
  373.     static unsigned char dc_chrominance_vals[] =
  374.     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  375.  
  376.     static unsigned char ac_luminance_bits[] =
  377.     { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
  378.     static unsigned char ac_luminance_vals[] =
  379.     { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
  380.       0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
  381.       0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
  382.       0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
  383.       0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
  384.       0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
  385.       0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  386.       0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
  387.       0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  388.       0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
  389.       0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
  390.       0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  391.       0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
  392.       0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  393.       0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
  394.       0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
  395.       0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
  396.       0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
  397.       0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
  398.       0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  399.       0xf9, 0xfa };
  400.  
  401.     static unsigned char ac_chrominance_bits[] =
  402.     { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
  403.     static unsigned char ac_chrominance_vals[] =
  404.     { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
  405.       0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
  406.       0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
  407.       0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
  408.       0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
  409.       0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
  410.       0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
  411.       0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
  412.       0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
  413.       0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
  414.       0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
  415.       0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  416.       0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
  417.       0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
  418.       0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
  419.       0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
  420.       0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
  421.       0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
  422.       0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
  423.       0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  424.       0xf9, 0xfa };
  425.  
  426.     for(ttt = 0; ttt < 4; ttt++)
  427.     { 
  428.         unsigned long index = ttt & 1;
  429.         unsigned long i, count;
  430.  
  431.         if (ttt <= 1)  /* DC tables */ 
  432.         {
  433.             htable = &(jpeg_info->jpg_dc_huff[index]);
  434.             hbits = jpeg_info->jpg_dc_huff[index].bits;
  435.             hvals = jpeg_info->jpg_dc_huff[index].vals;
  436.             if(index == 0) 
  437.             { 
  438.                 Sbits = dc_luminance_bits; 
  439.                 Svals = dc_luminance_vals; 
  440.             }
  441.             else 
  442.             { 
  443.                 Sbits = dc_chrominance_bits; 
  444.                 Svals = dc_chrominance_vals; 
  445.             }
  446.         }
  447.         else /* AC tables */
  448.         {
  449.             htable = &(jpeg_info->jpg_ac_huff[index]);
  450.             hbits  = jpeg_info->jpg_ac_huff[index].bits;
  451.             hvals  = jpeg_info->jpg_ac_huff[index].vals;
  452.             if(index == 0) 
  453.             { 
  454.                 Sbits = ac_luminance_bits; 
  455.                 Svals = ac_luminance_vals; 
  456.             }
  457.             else 
  458.             { 
  459.                 Sbits = ac_chrominance_bits; 
  460.                 Svals = ac_chrominance_vals; 
  461.             }
  462.         }
  463.         hbits[0] = 0;
  464.         count = 0;
  465.         for(i = 1; i <= 16; i++)
  466.         {
  467.             hbits[i] = Sbits[i];
  468.             count += hbits[i];
  469.         }
  470.         len -= 17;
  471.         if(count > 256)
  472.         { 
  473.             printf("quicktime_fastjpg_buildstdhuffman: STD DHT bad count %d\n", count); 
  474.             return 1; 
  475.         }
  476.  
  477.         for(i = 0; i < count; i++) hvals[i] = Svals[i];
  478.         len -= count;
  479.  
  480.         quicktime_fastjpg_buildhuffman(jpeg_info, 
  481.             htable, 
  482.             hbits, 
  483.             hvals);
  484.     }
  485.     jpeg_info->jpg_std_DHT_flag = 1;
  486.     return 0;
  487. }
  488.  
  489. int quicktime_fastjpg_buildstdDQT(quicktime_jpeg_t *jpeg_info, long scale)
  490. {
  491.     long i, tbl_num;
  492.       long *quant_table;
  493.       unsigned int *table;
  494.       unsigned int std_luminance_quant_tbl[DCTSIZE2] = 
  495.     {
  496.         16,  11,  10,  16,  24,  40,  51,  61,
  497.         12,  12,  14,  19,  26,  58,  60,  55,
  498.         14,  13,  16,  24,  40,  57,  69,  56,
  499.         14,  17,  22,  29,  51,  87,  80,  62,
  500.         18,  22,  37,  56,  68, 109, 103,  77,
  501.         24,  35,  55,  64,  81, 104, 113,  92,
  502.         49,  64,  78,  87, 103, 121, 120, 101,
  503.         72,  92,  95,  98, 112, 100, 103,  99
  504.     };
  505.     unsigned int std_chrominance_quant_tbl[DCTSIZE2] = 
  506.     {
  507.         17,  18,  24,  47,  99,  99,  99,  99,
  508.         18,  21,  26,  66,  99,  99,  99,  99,
  509.         24,  26,  56,  99,  99,  99,  99,  99,
  510.         47,  66,  99,  99,  99,  99,  99,  99,
  511.         99,  99,  99,  99,  99,  99,  99,  99,
  512.         99,  99,  99,  99,  99,  99,  99,  99,
  513.         99,  99,  99,  99,  99,  99,  99,  99,
  514.         99,  99,  99,  99,  99,  99,  99,  99
  515.     };
  516.  
  517.     tbl_num = 0;
  518.     for(tbl_num = 0; tbl_num <= 1; tbl_num++)
  519.     {
  520.         if(jpeg_info->quant_tables[tbl_num] == 0)
  521.         { 
  522.             jpeg_info->quant_tables[tbl_num] = (long*)malloc(64 * sizeof(long));
  523.         }
  524.  
  525.         if (tbl_num == 0) 
  526.             table = std_luminance_quant_tbl;
  527.         else 
  528.             table = std_chrominance_quant_tbl;
  529.         quant_table = jpeg_info->quant_tables[tbl_num];
  530.  
  531.         for (i = 0; i < DCTSIZE2; i++)
  532.         { 
  533.             long tmp;
  534.              tmp = ((long)table[i] * scale + 50L) / 100L;
  535.             if(tmp <= 0) tmp = 1;
  536.             if(tmp > 255) tmp = 255;
  537.             quant_table[i] = (long)tmp;
  538.         }
  539.     }
  540.     return 0;
  541. }
  542.  
  543. int quicktime_fastjpg_get_marker(quicktime_jpeg_t *jpeg_info)
  544. {
  545.     int c, done = 0;  /* 1 - completion    2 - error */
  546.  
  547.     while(!done)
  548.     {
  549.         c = quicktime_fastjpg_readbyte(jpeg_info);
  550. /* look for FF */
  551.         while(c != 0xFF)
  552.         {
  553.             if(quicktime_fastjpg_eof(jpeg_info)) done = 2;
  554.             c = quicktime_fastjpg_readbyte(jpeg_info);
  555.         }
  556.  
  557. /* now we've got 1 0xFF, keep reading until not 0xFF */
  558.         do
  559.         {
  560.             if(quicktime_fastjpg_eof(jpeg_info)) done = 2;
  561.             c = quicktime_fastjpg_readbyte(jpeg_info);
  562.         }while (c == 0xFF);
  563.         
  564. /* not a 00 or FF */
  565.         if (c != 0) done = 1; 
  566.     }
  567.  
  568.     if(done == 1) 
  569.     return c;
  570.     else
  571.     return 0;
  572. }
  573.  
  574. int quicktime_fastjpg_skip_marker(quicktime_jpeg_t *jpeg_info)
  575. {
  576.     long len, tmp;
  577.     len = quicktime_fastjpg_readint16(jpeg_info);
  578.     len -= 2;
  579.     if(len <= 0) return 1;
  580.     if(quicktime_fastjpg_eof(jpeg_info)) return 1;
  581.     while(len--) quicktime_fastjpg_readbyte(jpeg_info);
  582.     return 0;
  583. }
  584.  
  585. int quicktime_fastjpg_check_for_marker(quicktime_jpeg_t *jpeg_info)
  586. {
  587.     if(jpeg_info->marker) return(jpeg_info->marker);
  588.     if(jpeg_info->chunk_size < 2) return(0);
  589.     if((jpeg_info->chunk[0] == 0xff) && (jpeg_info->chunk[1] != 0x00))
  590.     {
  591.         jpeg_info->marker = jpeg_info->chunk[1];
  592.         {
  593.             if(jpeg_info->jpg_h_bnum)
  594.               {
  595.                 printf("quicktime_fastjpg_check_for_marker: check marker positive - lost %d bits\n",
  596.                                 jpeg_info->jpg_h_bnum);
  597.               }
  598.         }
  599.         jpeg_info->jpg_h_bnum = 0;
  600.         jpeg_info->jpg_h_bbuf = 0;
  601.         jpeg_info->chunk += 2;
  602.         jpeg_info->chunk_size -= 2;
  603.     }
  604.     return(jpeg_info->marker);
  605. }
  606.  
  607. int quicktime_fastjpg_readSOI(quicktime_jpeg_t *jpeg_info)
  608. {
  609.     jpeg_info->jpg_rst_interval = 0;
  610.     return 0;
  611. }
  612.  
  613. int quicktime_fastjpg_readSOF(quicktime_jpeg_t *jpeg_info)
  614. {
  615.     int result = 0;
  616.     int len, i, c;
  617.     quicktime_jpeg_comp_header *comp;
  618.  
  619.     len = quicktime_fastjpg_readint16(jpeg_info);
  620.     if(jpeg_info->mjpg_kludge) 
  621.         len -= 6;
  622.     else 
  623.         len -= 8;
  624.  
  625.     jpeg_info->jpg_dprec = quicktime_fastjpg_readbyte(jpeg_info);
  626.     jpeg_info->jpg_height = quicktime_fastjpg_readint16(jpeg_info);
  627.     jpeg_info->jpg_width = quicktime_fastjpg_readint16(jpeg_info);
  628.     jpeg_info->jpg_num_comps = quicktime_fastjpg_readbyte(jpeg_info);
  629.  
  630.     for(i = 0; i < jpeg_info->jpg_num_comps; i++)
  631.     {
  632.         if(i > MAX_COMPS) 
  633.             comp = &(jpeg_info->jpg_comps[DUMMY_COMP]);
  634.         else 
  635.             comp = &(jpeg_info->jpg_comps[i]);
  636.  
  637.         comp->id = quicktime_fastjpg_readbyte(jpeg_info);
  638.         comp->hvsample = quicktime_fastjpg_readbyte(jpeg_info);
  639.         comp->qtbl_num = quicktime_fastjpg_readbyte(jpeg_info);
  640.     }
  641.     return(quicktime_fastjpg_eof(jpeg_info));
  642. }
  643.  
  644. int quicktime_fastjpg_readSOS(quicktime_jpeg_t *jpeg_info)
  645. {
  646.     int len, i, j;
  647.     int comp_id, htbl_num;
  648.     int jpg_Ss, jpg_Se, jpg_AhAl;
  649.  
  650.     len = quicktime_fastjpg_readint16(jpeg_info);
  651.     jpeg_info->jpg_comps_in_scan = quicktime_fastjpg_readbyte(jpeg_info);
  652.  
  653.     for(i = 0; i < jpeg_info->jpg_comps_in_scan; i++)
  654.     { 
  655.         quicktime_jpeg_comp_header *comp = 0;
  656.         comp_id = quicktime_fastjpg_readbyte(jpeg_info);
  657.         for(j = 0; j < jpeg_info->jpg_num_comps; )
  658.         {
  659.             comp = &(jpeg_info->jpg_comps[j]);
  660.             if(comp->id == comp_id) break;
  661.             j++;
  662.         }
  663.  
  664.         if (j > jpeg_info->jpg_num_comps) 
  665.         {
  666.             printf("quicktime_fastjpg_readSOS: bad id %x", comp_id);
  667.             return 1;
  668.         }
  669.  
  670.         htbl_num = quicktime_fastjpg_readbyte(jpeg_info);
  671.         comp->dc_htbl_num = (htbl_num >> 4) & 0x0f;
  672.         comp->ac_htbl_num = (htbl_num     ) & 0x0f;
  673.     }
  674.     jpg_Ss = quicktime_fastjpg_readbyte(jpeg_info);
  675.     jpg_Se = quicktime_fastjpg_readbyte(jpeg_info);
  676.     jpg_AhAl = quicktime_fastjpg_readbyte(jpeg_info);
  677.     return(quicktime_fastjpg_eof(jpeg_info));
  678. }
  679.  
  680. int quicktime_fastjpg_readDHT(quicktime_jpeg_t *jpeg_info)
  681. {
  682.     int len, i, index, count;
  683.     unsigned long result = 1;
  684.     quicktime_jpeg_huffman *htable;
  685.     unsigned char *hbits;
  686.     unsigned char *hvals;
  687.  
  688.     jpeg_info->jpg_std_DHT_flag = 0;
  689.     len = quicktime_fastjpg_readint16(jpeg_info);
  690.  
  691.     if(jpeg_info->mjpg_kludge) len += 2;
  692.  
  693.       len -= 2;
  694.  
  695.     if(quicktime_fastjpg_eof(jpeg_info)) return 1;
  696.  
  697.     while(len > 0)
  698.     {
  699.         index = quicktime_fastjpg_readbyte(jpeg_info);
  700.         len--;
  701. /* Test indexes */
  702.         if (index & 0x10)                /* AC Table */
  703.         {
  704.             index &= 0x0f;
  705.             if (index >= TOTAL_HUFF_TBLS) break;
  706.             htable = &(jpeg_info->jpg_ac_huff[index]);
  707.             hbits  = jpeg_info->jpg_ac_huff[index].bits;
  708.             hvals  = jpeg_info->jpg_ac_huff[index].vals;
  709.         }
  710.         else                            /* DC Table */
  711.         {
  712.             index &= 0x0f;
  713.             if (index >= TOTAL_HUFF_TBLS) break;
  714.             htable = &(jpeg_info->jpg_dc_huff[index]);
  715.             hbits  = jpeg_info->jpg_dc_huff[index].bits;
  716.             hvals  = jpeg_info->jpg_dc_huff[index].vals;
  717.         }
  718.  
  719.         hbits[0] = 0;
  720.         count = 0;
  721.  
  722.         if(len < 16) break;
  723.         for (i = 1; i <= 16; i++)
  724.         {
  725.             hbits[i] = quicktime_fastjpg_readbyte(jpeg_info);
  726.             count += hbits[i];
  727.         }
  728.         len -= 16;
  729.  
  730.         if(count > 256)
  731.         { 
  732.             printf("quicktime_fastjpg_readDHT: DHT bad count %d using default.\n", count);
  733.             break;
  734.         }
  735.  
  736.         if(len < count)
  737.         {
  738.             printf("quicktime_fastjpg_readDHT: DHT count(%d) > len(%d).\n", count, len);
  739.             break;
  740.         }
  741.  
  742.         for(i = 0; i < count; i++) hvals[i] = quicktime_fastjpg_readbyte(jpeg_info);
  743.         len -= count;
  744.  
  745.         quicktime_fastjpg_buildhuffman(jpeg_info, htable, hbits, hvals);
  746.         result = 0;
  747.     }
  748.  
  749.     if(result)
  750.     {
  751. /* Something is roached, but what the heck, try default DHT instead */
  752.         while(len > 0)
  753.         {
  754.             len--;
  755.             quicktime_fastjpg_readbyte(jpeg_info);
  756.         }
  757.         quicktime_fastjpg_buildstdhuffman(jpeg_info);
  758.         result = 0; 
  759.     }
  760.  
  761.     return result;
  762. }
  763.  
  764. int quicktime_fastjpg_readDQT(quicktime_jpeg_t *jpeg_info)
  765. {
  766.     long len;
  767.       len = quicktime_fastjpg_readint16(jpeg_info);
  768.     if(!jpeg_info->mjpg_kludge) len -= 2;
  769.  
  770.     while(len > 0)
  771.     { 
  772.         long i, tbl_num, prec;
  773.         long *quant_table;
  774.  
  775.         tbl_num = quicktime_fastjpg_readbyte(jpeg_info);
  776.         len -= 1;
  777.  
  778.         prec = (tbl_num >> 4) & 0x0f;
  779.         prec = (prec)?(2 * DCTSIZE2) : (DCTSIZE2);  /* 128 or 64 */
  780.         tbl_num &= 0x0f;
  781.         if (tbl_num > 4)
  782.         { 
  783.             printf("quicktime_fastjpg_readDQT: bad DQT tnum %x\n", tbl_num); 
  784.             return 1; 
  785.         }
  786.  
  787.         if(jpeg_info->quant_tables[tbl_num] == 0)
  788.         {
  789.             jpeg_info->quant_tables[tbl_num] = (long *)malloc(64 * sizeof(long));
  790.         }
  791.         len -= prec;
  792.  
  793.         if(quicktime_fastjpg_eof(jpeg_info)) return 1;
  794.         quant_table = jpeg_info->quant_tables[tbl_num];
  795.         if(prec == 128)
  796.         { 
  797.             unsigned long tmp; 
  798.             for(i = 0; i < DCTSIZE2; i++)
  799.             { 
  800.                 tmp = quicktime_fastjpg_readint16(jpeg_info);
  801.                 quant_table[JJ_ZAG[i]] = (long)tmp;
  802.             }
  803.         }
  804.         else
  805.         {
  806.             unsigned long tmp; 
  807.             for(i = 0; i < DCTSIZE2; i++)
  808.             {
  809.                 tmp = quicktime_fastjpg_readbyte(jpeg_info);
  810.                  quant_table[JJ_ZAG[i]] = (long)tmp; 
  811.             }
  812.         }
  813.     }
  814.     return 0;
  815. }
  816.  
  817. int quicktime_fastjpg_readAPPX(quicktime_jpeg_t *jpeg_info)
  818. {
  819.     long len;
  820.     len = quicktime_fastjpg_readint32(jpeg_info);
  821.     len -= 2;
  822.     if(len > 4)
  823.     {
  824.         unsigned long first;
  825.         first = quicktime_fastjpg_readint32(jpeg_info);
  826.         len -= 4;
  827. /*         if (first == 0x41564931)  /* AVI1 */ */
  828. /*         { */
  829. /*             int interleave; */
  830. /*             interleave = quicktime_fastjpg_readbyte(jpeg_info); */
  831. /*             len--; */
  832. /*             avi_jpeg_info.valid = 1; */
  833. /*             avi_jpeg_info.ileave = interleave; */
  834. /*         } */
  835. /*        else  */
  836.         if(len > (0x28 - 4)) /* Maybe APPLE MJPEG A */
  837.         { 
  838.             unsigned long jid;
  839.             jid = quicktime_fastjpg_readint32(jpeg_info);
  840.             len -= 4;
  841.             if(jid == JPEG_APP1_MJPA)
  842.             {  
  843.                 jpeg_info->mjpa_info.valid = 1;
  844.                 jpeg_info->mjpa_info.field_sz = quicktime_fastjpg_readint32(jpeg_info);
  845.                 jpeg_info->mjpa_info.pad_field_sz = quicktime_fastjpg_readint32(jpeg_info);
  846.                 jpeg_info->mjpa_info.next_off = quicktime_fastjpg_readint32(jpeg_info);
  847.                 jpeg_info->mjpa_info.quant_off = quicktime_fastjpg_readint32(jpeg_info);
  848.                 jpeg_info->mjpa_info.huff_off = quicktime_fastjpg_readint32(jpeg_info);
  849.                 jpeg_info->mjpa_info.image_off = quicktime_fastjpg_readint32(jpeg_info);
  850.                 jpeg_info->mjpa_info.scan_off = quicktime_fastjpg_readint32(jpeg_info);
  851.                 jpeg_info->mjpa_info.data_off = quicktime_fastjpg_readint32(jpeg_info);
  852.                 len -= 32;
  853.             }
  854.         }
  855.     }
  856.     if(len) quicktime_fastjpg_skip(jpeg_info, len);
  857.     return 0;
  858. }
  859.  
  860. int quicktime_fastjpg_readDRI(quicktime_jpeg_t *jpeg_info)
  861. {
  862.     long len;
  863.     len = quicktime_fastjpg_readint16(jpeg_info);
  864.     jpeg_info->jpg_rst_interval = quicktime_fastjpg_readint16(jpeg_info);
  865.     return 0;
  866.     
  867. }
  868.  
  869. int quicktime_fastjpg_readEOI(quicktime_jpeg_t *jpeg_info)
  870. {
  871.     while(jpeg_info->marker = quicktime_fastjpg_get_marker(jpeg_info))
  872.     {
  873.         if(jpeg_info->marker == M_EOI) 
  874.         {
  875.             jpeg_info->jpg_saw_EOI = 1; 
  876.             return 1; 
  877.         }
  878.     }
  879.     return 0;
  880. }
  881.  
  882.  
  883.  
  884.  
  885. int quicktime_fastjpg_read_markers(quicktime_jpeg_t *jpeg_info)
  886. {
  887.     int done = 0;     /* 1 = completion    2 = error */
  888.  
  889.     while(!done)
  890.     { 
  891.         if(!(jpeg_info->marker = quicktime_fastjpg_get_marker(jpeg_info)))
  892.             done = 2;
  893.         else
  894.         {
  895. /*printf("quicktime_fastjpg_read_markers %x\n", jpeg_info->marker); */
  896.             switch(jpeg_info->marker)
  897.             {
  898.                 case M_SOI: 
  899.                     if(quicktime_fastjpg_readSOI(jpeg_info)) done = 2;
  900.                     else
  901.                     jpeg_info->jpg_saw_SOI = 1;
  902.                     break;
  903.  
  904.                 case M_SOF0: 
  905.                 case M_SOF1: 
  906.                 case M_SOF2: 
  907.                     if(quicktime_fastjpg_readSOF(jpeg_info)) done = 2;
  908.                     else
  909.                     jpeg_info->jpg_saw_SOF = 1;
  910.                     break;
  911.  
  912. /* Not yet supported */
  913.                 case M_SOF3:
  914.                 case M_SOF5:
  915.                 case M_SOF6:
  916.                 case M_SOF7:
  917.                 case M_SOF9:
  918.                 case M_SOF10:
  919.                 case M_SOF11:
  920.                 case M_SOF13:
  921.                 case M_SOF14:
  922.                 case M_SOF15:
  923.                     done = 2;
  924.                     break;
  925.                     
  926.                 case M_SOS: 
  927.                     if(quicktime_fastjpg_readSOS(jpeg_info)) done = 2;
  928.                     else
  929.                     {
  930.                         jpeg_info->jpg_saw_SOS = 1;
  931.                         jpeg_info->jpg_nxt_rst_num = 0;
  932.                         done = 1;
  933.                     }
  934.                     break;
  935.  
  936.                 case M_DHT:
  937.                     if(quicktime_fastjpg_readDHT(jpeg_info)) done = 2;
  938.                     else
  939.                         jpeg_info->jpg_saw_DHT = 1;
  940.                     break;
  941.                     
  942.                 case M_DQT:
  943.                     if(quicktime_fastjpg_readDQT(jpeg_info)) done = 2;
  944.                     else
  945.                         jpeg_info->jpg_saw_DQT = 1;
  946.                     break;
  947.  
  948.                 case M_DRI:
  949.                     if(quicktime_fastjpg_readDRI(jpeg_info)) done = 2;
  950.                     break;
  951.  
  952.                 case M_COM:
  953.                 {
  954. /* Comment */
  955.                     int len;
  956.                     len = quicktime_fastjpg_readint16(jpeg_info);
  957.                     len -= 2;
  958.  
  959.                     while(len > 0)
  960.                     {
  961.                         quicktime_fastjpg_readbyte(jpeg_info); len--;
  962.                     }
  963.                 }
  964.                 break;
  965.  
  966.                 case M_APP0:
  967.                 case M_APP1:
  968.                     if(quicktime_fastjpg_readAPPX(jpeg_info)) done = 2;
  969.                     break;
  970.  
  971.                 case M_EOI:
  972.                     printf("quicktime_fastjpg_read_markers: reached EOI without data\n");
  973.                     done = 2;
  974.                     break;
  975.  
  976.                 case M_RST0:                /* these are all parameterless */
  977.                 case M_RST1:
  978.                 case M_RST2:
  979.                 case M_RST3:
  980.                 case M_RST4:
  981.                 case M_RST5:
  982.                 case M_RST6:
  983.                 case M_RST7:
  984.                 case M_TEM:
  985.                     break;
  986.  
  987.                 default:
  988.                     printf("quicktime_fastjpg_read_markers: unknown marker %x\n", jpeg_info->marker);
  989.                     if(quicktime_fastjpg_skip_marker(jpeg_info)) done = 2;
  990.                     break;
  991.             } /* end of switch */
  992.         }
  993.     }
  994.     if(done == 2) return 1; else return 0;
  995. }
  996.  
  997. int quicktime_fastjpg_initMCU(quicktime_jpeg_t *jpeg_info, 
  998.                 int width, 
  999.                 int height,
  1000.                 int full_flag)
  1001. {
  1002.     int twidth = (width + 15) / 16;
  1003.     int theight = (height + 15) / 16;  
  1004.     if(theight & 1) theight++;
  1005.  
  1006.     if(full_flag) 
  1007.         twidth *= (theight << 2);
  1008.     else
  1009.         twidth <<= 2; /* four dct's deep */
  1010.  
  1011.     if(!jpeg_info->yuvbufs.allocated)
  1012.     {
  1013.         jpeg_info->yuvbufs.allocated = 1;
  1014.         jpeg_info->yuvbufs.ybuf = (unsigned char*)malloc(twidth * DCTSIZE2);
  1015.         jpeg_info->yuvbufs.ubuf = (unsigned char*)malloc(twidth * DCTSIZE2);
  1016.         jpeg_info->yuvbufs.vbuf = (unsigned char*)malloc(twidth * DCTSIZE2);
  1017.     }
  1018. }
  1019.  
  1020. int quicktime_fastjpg_skip_to_next_rst(quicktime_jpeg_t *jpeg_info)
  1021. {
  1022.     unsigned long d, last_ff = 0;
  1023.     jpeg_info->jpg_h_bnum = 0;
  1024.     jpeg_info->jpg_h_bbuf = 0;
  1025.     while(jpeg_info->chunk_size)
  1026.     {
  1027.         d = *(jpeg_info->chunk++); 
  1028.         jpeg_info->chunk_size--;
  1029.         if(last_ff)
  1030.         {
  1031.            if((d != 0) && (d != 0xff)) return d;
  1032.         }
  1033.         last_ff = (d == 0xff) ? 1 : 0;
  1034.       }
  1035.       return M_EOI;
  1036. }
  1037.  
  1038. /*  clears dctbuf to zeroes. 
  1039.  *  fills from huffman encode stream
  1040.  */
  1041. int quicktime_fastjpg_huffparse(quicktime_jpeg_t *jpeg_info, 
  1042.                 quicktime_jpeg_comp_header *comp, 
  1043.                 QUICKTIME_INT16 *dct_buf, 
  1044.                 unsigned long *qtab, 
  1045.                 unsigned char *OBuf)
  1046. {
  1047.     unsigned long tmp_, tmp__, hcode_, t1_, shift_, minbits_;
  1048.     long i, dcval, level;
  1049.       unsigned long size, run, tmp, coeff;
  1050.       quicktime_jpeg_huffman *huff_hdr = &(jpeg_info->jpg_dc_huff[comp->dc_htbl_num]);
  1051.       unsigned QUICKTIME_INT16 *huff_tbl = huff_hdr->cache;
  1052.       unsigned char *rnglimit = jpeg_info->jpg_samp_limit + (CENTERJSAMPLE + MAXJSAMPLE + 1);
  1053.       unsigned long c_cnt, pos = 0;
  1054.  
  1055.       QUICKTIME_FASTJPG_HUFF_DECODE(huff_hdr, huff_tbl, jpeg_info->jpg_h_bnum, jpeg_info->jpg_h_bbuf, size);
  1056.  
  1057.       if(size)
  1058.       { 
  1059.         unsigned long bits;
  1060.         QUICKTIME_FASTJPG_GET_BITS(size, jpeg_info->jpg_h_bnum, jpeg_info->jpg_h_bbuf, bits);
  1061.         dcval = QUICKTIME_FASTJPG_HUFF_EXTEND(bits, size);
  1062.         comp->dc += dcval;
  1063.     }
  1064.       dcval = comp->dc;
  1065.  
  1066. /* clear rest of dct buffer */
  1067.       memset((char *)(dct_buf), 0, (DCTSIZE2 * sizeof(QUICKTIME_INT16)));
  1068.       dcval *= (long)qtab[0];
  1069.       dct_buf[0] = (QUICKTIME_INT16)dcval;
  1070.       c_cnt = 0;
  1071.  
  1072.       huff_hdr = &(jpeg_info->jpg_ac_huff[comp->ac_htbl_num]);
  1073.       huff_tbl = huff_hdr->cache;
  1074.      for(i = 1; i < 64; )
  1075.       { 
  1076.         QUICKTIME_FASTJPG_HUFF_DECODE(huff_hdr, huff_tbl, jpeg_info->jpg_h_bnum, jpeg_info->jpg_h_bbuf, tmp); 
  1077.         size =  tmp & 0x0f;
  1078.         run = (tmp >> 4) & 0x0f; /* leading zeroes */
  1079.  
  1080.         if(size)
  1081.         {
  1082.               i += run; /* skip zeroes */
  1083.               QUICKTIME_FASTJPG_GET_BITS(size, jpeg_info->jpg_h_bnum, jpeg_info->jpg_h_bbuf, level);
  1084.               coeff = (long)QUICKTIME_FASTJPG_HUFF_EXTEND(level, size);
  1085.              pos = JJ_ZAG[i];
  1086.               coeff *= (long)qtab[pos];
  1087.              if(coeff)
  1088.               { 
  1089.                 c_cnt++;
  1090.                    dct_buf[pos] = (QUICKTIME_INT16)(coeff);
  1091.               }
  1092.              i++;
  1093.            }
  1094.         else
  1095.         {
  1096.               if(run != 15) break; /* EOB */
  1097.               i += 16;
  1098.         }
  1099.       }
  1100.  
  1101.       if(c_cnt) quicktime_rev_dct(dct_buf, OBuf, rnglimit);
  1102.       else
  1103.       { 
  1104.         register unsigned char *op = OBuf;
  1105.         register int jj = 8;
  1106.         QUICKTIME_INT16 v = *dct_buf;
  1107.         register unsigned char dc;
  1108.  
  1109.         v = (v < 0) ? ((v - 3) >> 3) : ((v + 4) >> 3);
  1110.         dc = rnglimit[(int)(v & RANGE_MASK)];
  1111.         while(jj--)
  1112.         {
  1113.             op[0] = op[1] = op[2] = op[3] = op[4] = op[5] = op[6] = op[7] = dc;
  1114.             op += 8;
  1115.         }
  1116.     }
  1117.       return 0;
  1118. }
  1119.  
  1120.  
  1121. int quicktime_fastjpg_MCU411111_to_RGB(QUICKTIME_MCU_ARGS)
  1122. {
  1123.     QUICKTIME_MCU_VARS
  1124.     QUICKTIME_MCU111111_MID_VARS
  1125.     QUICKTIME_MCU_INNER_VARS
  1126.     
  1127.     while(frame_height > 0)
  1128.     { 
  1129.           yptr = ybuf; 
  1130.         uptr = ubuf; 
  1131.         vptr = vbuf;
  1132.         for(yi = 0; yi < 8; yi++)
  1133.         { 
  1134.             QUICKTIME_MCU111111_MID_DECL;
  1135.             if(frame_height <= 0) return 0;
  1136.               while(xi--)
  1137.             { 
  1138.                 QUICKTIME_MCU_INNER_INIT;
  1139.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip);
  1140.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip);
  1141.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip);
  1142.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip);
  1143.                 QUICKTIME_MCU4H_INNER_TAIL(56, 56);
  1144.             }
  1145.             yptr += 8; 
  1146.             uptr += 8; 
  1147.             vptr += 8; 
  1148.             frame_height--;  
  1149.             row_pointers += interlaced ? 2 : 1;
  1150.         }
  1151.         ybuf += mcu_row_size << 2; 
  1152.         ubuf += mcu_row_size; 
  1153.         vbuf += mcu_row_size;
  1154.     }
  1155. }
  1156.  
  1157. int quicktime_fastjpg_decode_411111(quicktime_jpeg_t *jpeg_info, 
  1158.                                 unsigned char **output_rows,
  1159.                                 int jpeg_width,
  1160.                                 int jpeg_height,
  1161.                                 int interlaced,
  1162.                                 int row_offset,
  1163.                                 int frame_width,
  1164.                                 int frame_height)
  1165. {
  1166.     long x, mcu_cols, mcu_rows;
  1167.     long *qtab0, *qtab1, *qtab2;
  1168.     unsigned char *Ybuf, *Ubuf, *Vbuf;
  1169.     unsigned long rst_count;
  1170.     unsigned long rst_skip = 0;
  1171.     unsigned long orow_size = frame_width * 3 * (interlaced ? 2 : 1);
  1172.  
  1173.     if(interlaced) frame_height >>= 1;
  1174.     frame_width += 3; 
  1175.     frame_width >>= 2; /* 4h */
  1176.     qtab0 = jpeg_info->quant_tables[jpeg_info->jpg_comps[0].qtbl_num];
  1177.     qtab1 = jpeg_info->quant_tables[jpeg_info->jpg_comps[1].qtbl_num];
  1178.     qtab2 = jpeg_info->quant_tables[jpeg_info->jpg_comps[2].qtbl_num];
  1179.  
  1180.     mcu_cols = (jpeg_width + 31) / 32;
  1181.     mcu_rows = (jpeg_height + 7) / 8;
  1182.     jpeg_info->marker = 0x00;
  1183.  
  1184.     rst_count = jpeg_info->jpg_rst_interval;
  1185.     output_rows += row_offset;
  1186.     while(mcu_rows--)
  1187.     { 
  1188.         Ybuf = jpeg_info->yuvbufs.ybuf; 
  1189.         Ubuf = jpeg_info->yuvbufs.ubuf; 
  1190.         Vbuf = jpeg_info->yuvbufs.vbuf;
  1191.         x = mcu_cols; 
  1192.         while(x--)
  1193.         {
  1194.             if(rst_skip)
  1195.             {
  1196.                 rst_skip--;
  1197.                 memset(Ybuf, 0, (DCTSIZE2 << 2));
  1198.                 memset(Ubuf, 0x80, DCTSIZE2);
  1199.                 memset(Vbuf, 0x80, DCTSIZE2);
  1200.                 Ybuf += (DCTSIZE2 << 2);
  1201.                 Ubuf += DCTSIZE2;
  1202.                 Vbuf += DCTSIZE2;
  1203.             }
  1204.             else
  1205.             {
  1206.                 QUICKTIME_FASTJPG_HANDLE_RST(jpeg_info->jpg_rst_interval, rst_count);
  1207.  
  1208. /* Y0 Y1 Y2 Y3 U V */
  1209.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1210.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1211.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1212.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1213.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[1]), jpeg_info->jpg_dct_buf, qtab1, Ubuf); Ubuf += DCTSIZE2;
  1214.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[2]), jpeg_info->jpg_dct_buf, qtab2, Vbuf); Vbuf += DCTSIZE2;
  1215.  
  1216.                 if(jpeg_info->marker == 0)
  1217.                     jpeg_info->marker = quicktime_fastjpg_check_for_marker(jpeg_info);
  1218.                 QUICKTIME_FASTJPG_TEST_MARKER;
  1219.             }
  1220.         } /* end of mcu_cols */
  1221.  
  1222.         quicktime_fastjpg_MCU411111_to_RGB(jpeg_info, 
  1223.                 output_rows,
  1224.                 frame_width,
  1225.                 (frame_height < 8 ? frame_height : 8),
  1226.                 (mcu_cols * DCTSIZE2),
  1227.                 orow_size,
  1228.                 &(jpeg_info->yuvbufs),
  1229.                 interlaced);
  1230.         frame_height -= 8;
  1231.         output_rows += interlaced ? 16 : 8;
  1232.     } /* end of mcu_rows */
  1233.  
  1234.     if(jpeg_info->marker) 
  1235.     { 
  1236.         jpeg_info->jpg_h_bbuf = 0; 
  1237.         jpeg_info->jpg_h_bnum = 0; 
  1238.     }
  1239.     return 0;
  1240. }
  1241.  
  1242. int quicktime_fastjpg_MCU221111_to_RGB(QUICKTIME_MCU_ARGS)
  1243. {
  1244.     QUICKTIME_MCU_VARS
  1245.     QUICKTIME_MCU221111_MID_VARS
  1246.     QUICKTIME_MCU_INNER_VARS
  1247.     
  1248.     while(frame_height > 0)
  1249.     {
  1250.           yptr = ybuf;
  1251.         uptr = ubuf;
  1252.         vptr = vbuf;
  1253.         for(yi = 0; yi < 8; yi++)
  1254.         {
  1255.             QUICKTIME_MCU221111_MID_DECL;
  1256.               while(xi--)
  1257.             {
  1258.                 QUICKTIME_MCU_INNER_INIT;
  1259.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[yp[8]], cr, cg, cb, ip1);
  1260.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip0);
  1261.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[yp[8]], cr, cg, cb, ip1);
  1262.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip0);
  1263.                 QUICKTIME_MCU2H_INNER_TAIL(56, 184);
  1264.             }
  1265.             yptr += 16; 
  1266.             uptr += 8; 
  1267.             vptr += 8; 
  1268.             frame_height -= 2;  
  1269.         }
  1270.         ybuf += mcu_row_size << 2; 
  1271.         ubuf += mcu_row_size; 
  1272.         vbuf += mcu_row_size;
  1273.     }
  1274. }
  1275.  
  1276. int quicktime_fastjpg_decode_221111(quicktime_jpeg_t *jpeg_info, 
  1277.                                 unsigned char **output_rows,
  1278.                                 int jpeg_width,
  1279.                                 int jpeg_height,
  1280.                                 int interlaced,
  1281.                                 int row_offset,
  1282.                                 int frame_width,
  1283.                                 int frame_height)
  1284. {
  1285.     long x, mcu_cols, mcu_rows;
  1286.     long *qtab0, *qtab1, *qtab2;
  1287.     unsigned char *Ybuf, *Ubuf, *Vbuf;
  1288.     unsigned long rst_count;
  1289.     unsigned long rst_skip = 0;
  1290.     unsigned long orow_size = frame_width * 3 * (interlaced ? 2 : 1);
  1291.  
  1292.     if(interlaced) frame_height >>= 1;
  1293.     frame_width += 1; 
  1294.     frame_width >>= 1; /* 2h */
  1295.     qtab0 = jpeg_info->quant_tables[jpeg_info->jpg_comps[0].qtbl_num];
  1296.     qtab1 = jpeg_info->quant_tables[jpeg_info->jpg_comps[1].qtbl_num];
  1297.     qtab2 = jpeg_info->quant_tables[jpeg_info->jpg_comps[2].qtbl_num];
  1298.  
  1299.     mcu_cols = (jpeg_width + 15) / 16;
  1300.     mcu_rows = (jpeg_height + 15) / 16;
  1301.     jpeg_info->marker = 0x00;
  1302.  
  1303.     rst_count = jpeg_info->jpg_rst_interval;
  1304.     output_rows += row_offset;
  1305.     while(mcu_rows--)
  1306.     {
  1307.         Ybuf = jpeg_info->yuvbufs.ybuf; 
  1308.         Ubuf = jpeg_info->yuvbufs.ubuf; 
  1309.         Vbuf = jpeg_info->yuvbufs.vbuf;
  1310.         x = mcu_cols; 
  1311.         while(x--)
  1312.         {
  1313.             if(rst_skip)
  1314.             {
  1315.                 rst_skip--;
  1316.                 memset(Ybuf, 0, (DCTSIZE2 << 2));
  1317.                 memset(Ubuf, 0x80, DCTSIZE2);
  1318.                 memset(Vbuf, 0x80, DCTSIZE2);
  1319.                 Ybuf += (DCTSIZE2 << 2);
  1320.                 Ubuf += DCTSIZE2;
  1321.                 Vbuf += DCTSIZE2;
  1322.             }
  1323.             else
  1324.             {
  1325.                 QUICKTIME_FASTJPG_HANDLE_RST(jpeg_info->jpg_rst_interval, rst_count);
  1326.  
  1327. /* Y0 Y1 Y2 Y3 U V */
  1328.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1329.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1330.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1331.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1332.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[1]), jpeg_info->jpg_dct_buf, qtab1, Ubuf); Ubuf += DCTSIZE2;
  1333.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[2]), jpeg_info->jpg_dct_buf, qtab2, Vbuf); Vbuf += DCTSIZE2;
  1334.  
  1335.                 if(jpeg_info->marker == 0)
  1336.                     jpeg_info->marker = quicktime_fastjpg_check_for_marker(jpeg_info);
  1337.                 QUICKTIME_FASTJPG_TEST_MARKER;
  1338.             }
  1339.         } /* end of mcu_cols */
  1340.  
  1341.         quicktime_fastjpg_MCU221111_to_RGB(jpeg_info, 
  1342.                 output_rows,
  1343.                 frame_width,
  1344.                 (frame_height < 16 ? frame_height : 16),
  1345.                 (mcu_cols * DCTSIZE2),
  1346.                 orow_size,
  1347.                 &(jpeg_info->yuvbufs),
  1348.                 interlaced);
  1349.         frame_height -= 16;
  1350.         output_rows += interlaced ? 32 : 16;
  1351.     } /* end of mcu_rows */
  1352.  
  1353.     if(jpeg_info->marker) 
  1354.     { 
  1355.         jpeg_info->jpg_h_bbuf = 0; 
  1356.         jpeg_info->jpg_h_bnum = 0; 
  1357.     }
  1358.     return 0;
  1359. }
  1360.  
  1361. int quicktime_fastjpg_double_mcu(unsigned char *ptr, int mcus)
  1362. {
  1363.     unsigned char *sblk, *dblk;
  1364.       int blks = mcus * 8;
  1365.       int flag = 0;
  1366.  
  1367.       sblk = ptr + (blks * 8) - 8;
  1368.       dblk = ptr + (blks * 16) - 8;
  1369.       while(blks--)
  1370.       { 
  1371.         dblk[7] = dblk[6] = sblk[7];
  1372.         dblk[5] = dblk[4] = sblk[6];
  1373.         dblk[3] = dblk[2] = sblk[5];
  1374.         dblk[1] = dblk[0] = sblk[4];
  1375.         dblk -= 64;
  1376.         dblk[7] = dblk[6] = sblk[3];
  1377.         dblk[5] = dblk[4] = sblk[2];
  1378.         dblk[3] = dblk[2] = sblk[1];
  1379.         dblk[1] = dblk[0] = sblk[0];
  1380.         flag++;
  1381.         if(flag >= 8)
  1382.         {
  1383.             flag = 0;
  1384.             dblk -= 8;
  1385.         }
  1386.         else
  1387.         {
  1388.             dblk += 56;
  1389.         }
  1390.         sblk -= 8;
  1391.       }
  1392. }
  1393.  
  1394. int quicktime_fastjpg_MCU211111_to_RGB(QUICKTIME_MCU_ARGS)
  1395. {
  1396.     QUICKTIME_MCU_VARS
  1397.     QUICKTIME_MCU111111_MID_VARS
  1398.     QUICKTIME_MCU_INNER_VARS
  1399.     
  1400.     while(frame_height > 0)
  1401.     { 
  1402.           yptr = ybuf; 
  1403.         uptr = ubuf; 
  1404.         vptr = vbuf;
  1405.         for(yi = 0; yi < 8; yi++)
  1406.         { 
  1407.             QUICKTIME_MCU111111_MID_DECL;
  1408.             if(frame_height <= 0) return;
  1409.               while(xi--)
  1410.             { 
  1411.                 QUICKTIME_MCU_INNER_INIT;
  1412.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip);
  1413.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip);
  1414.                 QUICKTIME_MCU2H_INNER_TAIL(56, 56);
  1415.             }
  1416.             yptr += 8; 
  1417.             uptr += 8; 
  1418.             vptr += 8; 
  1419.             frame_height -= 2;
  1420.             row_pointers += interlaced ? 2 : 1;
  1421.         }
  1422.         ybuf += mcu_row_size << 1; 
  1423.         ubuf += mcu_row_size; 
  1424.         vbuf += mcu_row_size;
  1425.     }
  1426. }
  1427.  
  1428. int quicktime_fastjpg_decode_211111(quicktime_jpeg_t *jpeg_info, 
  1429.                                 unsigned char **output_rows,
  1430.                                 int jpeg_width,
  1431.                                 int jpeg_height,
  1432.                                 int interlaced,
  1433.                                 int row_offset,
  1434.                                 int frame_width,
  1435.                                 int frame_height)
  1436. {
  1437.     long x, mcu_cols, mcu_rows;
  1438.     long *qtab0, *qtab1, *qtab2;
  1439.     unsigned char *Ybuf, *Ubuf, *Vbuf;
  1440.     unsigned long rst_count;
  1441.     unsigned long rst_skip = 0;
  1442.     unsigned long orow_size = frame_width * 3 * (interlaced ? 2 : 1);
  1443.  
  1444.     if(interlaced) frame_height >>= 1;
  1445.     frame_width += 1; 
  1446.     frame_width >>= 1; /* 2h */
  1447.     qtab0 = jpeg_info->quant_tables[jpeg_info->jpg_comps[0].qtbl_num];
  1448.     qtab1 = jpeg_info->quant_tables[jpeg_info->jpg_comps[1].qtbl_num];
  1449.     qtab2 = jpeg_info->quant_tables[jpeg_info->jpg_comps[2].qtbl_num];
  1450.  
  1451.     mcu_cols = (jpeg_width + 15) / 16;
  1452.     mcu_rows = (jpeg_height + 7) / 8;
  1453.     jpeg_info->marker = 0x00;
  1454.  
  1455.     rst_count = jpeg_info->jpg_rst_interval;
  1456.     output_rows += row_offset;
  1457.     while(mcu_rows--)
  1458.     { 
  1459.         Ybuf = jpeg_info->yuvbufs.ybuf; 
  1460.         Ubuf = jpeg_info->yuvbufs.ubuf; 
  1461.         Vbuf = jpeg_info->yuvbufs.vbuf;
  1462.         x = mcu_cols; 
  1463.         while(x--)
  1464.         {
  1465.             if(rst_skip)
  1466.             {
  1467.                 rst_skip--;
  1468.                 memset(Ybuf, 0, (DCTSIZE2 << 1));
  1469.                 memset(Ubuf, 0x80, DCTSIZE2);
  1470.                 memset(Vbuf, 0x80, DCTSIZE2);
  1471.                 Ybuf += (DCTSIZE2 << 1);
  1472.                 Ubuf += DCTSIZE2;
  1473.                 Vbuf += DCTSIZE2;
  1474.             }
  1475.             else
  1476.             {
  1477.                 QUICKTIME_FASTJPG_HANDLE_RST(jpeg_info->jpg_rst_interval, rst_count);
  1478.  
  1479.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1480.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1481.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[1]), jpeg_info->jpg_dct_buf, qtab1, Ubuf); Ubuf += DCTSIZE2;
  1482.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[2]), jpeg_info->jpg_dct_buf, qtab2, Vbuf); Vbuf += DCTSIZE2;
  1483.  
  1484.                 if(jpeg_info->marker == 0)
  1485.                     jpeg_info->marker = quicktime_fastjpg_check_for_marker(jpeg_info);
  1486.                 QUICKTIME_FASTJPG_TEST_MARKER;
  1487.             }
  1488.         } /* end of mcu_cols */
  1489.  
  1490. /* NOTE: imagex already >> 1 above */
  1491.         if(jpeg_width <= frame_width)
  1492.         {
  1493.             quicktime_fastjpg_double_mcu(jpeg_info->yuvbufs.ybuf, (mcu_cols << 1));
  1494.             quicktime_fastjpg_double_mcu(jpeg_info->yuvbufs.ubuf, mcu_cols);
  1495.             quicktime_fastjpg_double_mcu(jpeg_info->yuvbufs.vbuf, mcu_cols);
  1496.         }
  1497.  
  1498.         quicktime_fastjpg_MCU211111_to_RGB(jpeg_info, 
  1499.                 output_rows,
  1500.                 frame_width,
  1501.                 (frame_height < 8 ? frame_height : 8),
  1502.                 ((mcu_cols << 1) * DCTSIZE2),
  1503.                 orow_size,
  1504.                 &(jpeg_info->yuvbufs),
  1505.                 interlaced);
  1506.  
  1507.         frame_height -= 8;
  1508.         output_rows += interlaced ? 16 : 8;
  1509.     } /* end of mcu_rows */
  1510.  
  1511.     if(jpeg_info->marker) 
  1512.     { 
  1513.         jpeg_info->jpg_h_bbuf = 0; 
  1514.         jpeg_info->jpg_h_bnum = 0; 
  1515.     }
  1516.     return 0;
  1517. }
  1518.  
  1519. int quicktime_fastjpg_MCU111111_to_RGB(QUICKTIME_MCU_ARGS)
  1520. {
  1521.     QUICKTIME_MCU_VARS
  1522.     QUICKTIME_MCU111111_MID_VARS
  1523.     QUICKTIME_MCU_INNER_VARS
  1524.     
  1525.     while(frame_height > 0)
  1526.     { 
  1527.           yptr = ybuf; 
  1528.         uptr = ubuf; 
  1529.         vptr = vbuf;
  1530.         for(yi = 0; yi < 8; yi++)
  1531.         { 
  1532.             QUICKTIME_MCU111111_MID_DECL;
  1533.             if(frame_height <= 0) return;
  1534.               while(xi--)
  1535.             { 
  1536.                 QUICKTIME_MCU_INNER_INIT;
  1537.                 QUICKTIME_MCU_YUV_TO_RGB(YTab[*yp++], cr, cg, cb, ip);
  1538.                 QUICKTIME_MCU1H_INNER_TAIL(56);
  1539.             }
  1540.             yptr += 8; 
  1541.             uptr += 8; 
  1542.             vptr += 8; 
  1543.             frame_height--;  
  1544.             row_pointers += interlaced ? 2 : 1;
  1545.         }
  1546.         ybuf += mcu_row_size; 
  1547.         ubuf += mcu_row_size; 
  1548.         vbuf += mcu_row_size;
  1549.     }
  1550. }
  1551.  
  1552. int quicktime_fastjpg_decode_111111(quicktime_jpeg_t *jpeg_info, 
  1553.                                 unsigned char **output_rows,
  1554.                                 int jpeg_width,
  1555.                                 int jpeg_height,
  1556.                                 int interlaced,
  1557.                                 int row_offset,
  1558.                                 int frame_width,
  1559.                                 int frame_height, 
  1560.                                 int grey)
  1561. {
  1562.     long x, mcu_cols, mcu_rows;
  1563.     long *qtab0, *qtab1, *qtab2;
  1564.     unsigned char *Ybuf, *Ubuf, *Vbuf;
  1565.     unsigned long rst_count;
  1566.     unsigned long rst_skip = 0;
  1567.     unsigned long orow_size = frame_width * 3 * (interlaced ? 2 : 1);
  1568.  
  1569.     if(interlaced) frame_height >>= 1;
  1570.     qtab0 = jpeg_info->quant_tables[jpeg_info->jpg_comps[0].qtbl_num];
  1571.     qtab1 = jpeg_info->quant_tables[jpeg_info->jpg_comps[1].qtbl_num];
  1572.     qtab2 = jpeg_info->quant_tables[jpeg_info->jpg_comps[2].qtbl_num];
  1573.  
  1574.     mcu_cols = (jpeg_width + 7) / 8;
  1575.     mcu_rows = (jpeg_height + 7) / 8;
  1576.     jpeg_info->marker = 0x00;
  1577.  
  1578.     rst_count = jpeg_info->jpg_rst_interval;
  1579.     output_rows += row_offset;
  1580.     while(mcu_rows--)
  1581.     { 
  1582.         Ybuf = jpeg_info->yuvbufs.ybuf; 
  1583.         Ubuf = jpeg_info->yuvbufs.ubuf; 
  1584.         Vbuf = jpeg_info->yuvbufs.vbuf;
  1585.         x = mcu_cols; 
  1586.         while(x--)
  1587.         {
  1588.             if(rst_skip)
  1589.             {
  1590.                 rst_skip--;
  1591.                 
  1592.                 if(Ybuf != jpeg_info->yuvbufs.ybuf)
  1593.                 {
  1594.                     unsigned char *prev;
  1595.                     prev = Ybuf - DCTSIZE2;
  1596.                     memcpy(Ybuf, prev, DCTSIZE2);
  1597.                     Ybuf += DCTSIZE2;
  1598.                       prev = Ubuf - DCTSIZE2; 
  1599.                     memcpy(Ubuf, prev, DCTSIZE2);
  1600.                     prev = Vbuf - DCTSIZE2; 
  1601.                     memcpy(Vbuf, prev, DCTSIZE2);
  1602.                     Ubuf += DCTSIZE2;
  1603.                     Vbuf += DCTSIZE2;
  1604.                 }
  1605.                 else
  1606.                 {
  1607.                     memset(Ybuf, 0, DCTSIZE2);
  1608.                     Ybuf += DCTSIZE2;
  1609.                     memset(Ubuf, 0x80, DCTSIZE2);
  1610.                     memset(Vbuf, 0x80, DCTSIZE2);
  1611.                     Ubuf += DCTSIZE2;
  1612.                     Vbuf += DCTSIZE2;
  1613.                 }
  1614.             }
  1615.             else
  1616.             {
  1617.                 QUICKTIME_FASTJPG_HANDLE_RST(jpeg_info->jpg_rst_interval, rst_count);
  1618.  
  1619.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[0]), jpeg_info->jpg_dct_buf, qtab0, Ybuf); Ybuf += DCTSIZE2;
  1620.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[1]), jpeg_info->jpg_dct_buf, qtab1, Ubuf); Ubuf += DCTSIZE2;
  1621.                 quicktime_fastjpg_huffparse(jpeg_info, &(jpeg_info->jpg_comps[2]), jpeg_info->jpg_dct_buf, qtab2, Vbuf); Vbuf += DCTSIZE2;
  1622.  
  1623.                 if(jpeg_info->marker == 0)
  1624.                     jpeg_info->marker = quicktime_fastjpg_check_for_marker(jpeg_info);
  1625.                 QUICKTIME_FASTJPG_TEST_MARKER;
  1626.             }
  1627.         } /* end of mcu_cols */
  1628.  
  1629. /* NOTE: imagex already >> 1 above */
  1630.         quicktime_fastjpg_MCU111111_to_RGB(jpeg_info, 
  1631.                 output_rows,
  1632.                 frame_width,
  1633.                 (frame_height < 8 ? frame_height : 8),
  1634.                 (mcu_cols * DCTSIZE2),
  1635.                 orow_size,
  1636.                 &(jpeg_info->yuvbufs),
  1637.                 interlaced);
  1638.  
  1639.         frame_height -= 8;
  1640.         output_rows += interlaced ? 16 : 8;
  1641.     } /* end of mcu_rows */
  1642.  
  1643.     if(jpeg_info->marker) 
  1644.     { 
  1645.         jpeg_info->jpg_h_bbuf = 0; 
  1646.         jpeg_info->jpg_h_bnum = 0; 
  1647.     }
  1648.     return 0;
  1649. }
  1650.  
  1651. int quicktime_fastjpg_decode(unsigned char *chunk, 
  1652.                         long chunk_size, 
  1653.                         unsigned char **output_rows, 
  1654.                         quicktime_jpeg_t *jpeg_info,
  1655.                         int frame_width,
  1656.                         int frame_height,
  1657.                         int interlaced)
  1658. {
  1659.     int base_y, row_offset;
  1660.     int ijpeg = 0;
  1661.     int result = 0;
  1662.     jpeg_info->mjpa_info.valid = 0;
  1663.  
  1664.     jpeg_info->chunk = chunk;
  1665.     jpeg_info->chunk_size = chunk_size;
  1666.  
  1667.     for(base_y = 0; base_y < (interlaced ? 2 : 1); base_y++)
  1668.     {
  1669. /* Reset structures */
  1670.         jpeg_info->jpg_saw_EOI = 0;
  1671.         jpeg_info->jpg_saw_SOI = jpeg_info->jpg_saw_SOF = jpeg_info->jpg_saw_SOS = jpeg_info->jpg_saw_DHT = jpeg_info->jpg_saw_DQT = 0;
  1672.  
  1673.         if(quicktime_fastjpg_read_markers(jpeg_info))
  1674.         {
  1675.             printf("quicktime_fastjpg_decode read markers failed\n");
  1676.         }
  1677.  
  1678.         quicktime_fastjpg_resethuffman(jpeg_info);
  1679.         if(interlaced)
  1680.         {
  1681.             row_offset = (base_y == 0) ? 0 : 1;
  1682.         }
  1683.         else
  1684.             row_offset = 0;
  1685.         
  1686.         if((!jpeg_info->jpg_saw_DHT) && (!jpeg_info->jpg_std_DHT_flag))
  1687.         {
  1688.               quicktime_fastjpg_buildstdhuffman(jpeg_info);
  1689.         }
  1690.  
  1691.         if(!jpeg_info->jpg_saw_DQT)
  1692.         { 
  1693.             quicktime_fastjpg_buildstdDQT(jpeg_info, 100);
  1694.         }
  1695.  
  1696.         jpeg_info->marker = 0x00;
  1697.            /*if(jpeg_info->jpg_width > frame_width) */
  1698.             quicktime_fastjpg_initMCU(jpeg_info, jpeg_info->jpg_width, 0, 0);
  1699.  
  1700. /* Perform the decompression */
  1701.         if((jpeg_info->jpg_num_comps == 3) && (jpeg_info->jpg_comps_in_scan == 3) &&
  1702.             (jpeg_info->jpg_comps[1].hvsample == 0x11) && (jpeg_info->jpg_comps[2].hvsample== 0x11))
  1703.         {
  1704.             if(jpeg_info->jpg_comps[0].hvsample == 0x41) /* 411 */
  1705.             { 
  1706.                 quicktime_fastjpg_decode_411111(jpeg_info, 
  1707.                                 output_rows,
  1708.                                 jpeg_info->jpg_width,
  1709.                                 jpeg_info->jpg_height,
  1710.                                 interlaced,
  1711.                                 row_offset,
  1712.                                 frame_width,
  1713.                                 frame_height); 
  1714.             }
  1715.             else 
  1716.             if(jpeg_info->jpg_comps[0].hvsample == 0x22) /* 411 */
  1717.             { 
  1718.                 quicktime_fastjpg_decode_221111(jpeg_info,
  1719.                                 output_rows, 
  1720.                                 jpeg_info->jpg_width,
  1721.                                 jpeg_info->jpg_height,
  1722.                                 interlaced,
  1723.                                 row_offset,
  1724.                                 frame_width,
  1725.                                 frame_height); 
  1726.             }
  1727.             else 
  1728.             if(jpeg_info->jpg_comps[0].hvsample == 0x21) /* 211 */
  1729.             {
  1730.                 quicktime_fastjpg_decode_211111(jpeg_info,
  1731.                                 output_rows, 
  1732.                                 jpeg_info->jpg_width,
  1733.                                 jpeg_info->jpg_height,
  1734.                                 interlaced,
  1735.                                 row_offset,
  1736.                                 frame_width,
  1737.                                 frame_height); 
  1738.             }
  1739.             else if(jpeg_info->jpg_comps[0].hvsample == 0x11) /* 111 */
  1740.             { 
  1741.                 quicktime_fastjpg_decode_111111(jpeg_info,
  1742.                                 output_rows, 
  1743.                                 jpeg_info->jpg_width,
  1744.                                 jpeg_info->jpg_height,
  1745.                                 interlaced,
  1746.                                 row_offset,
  1747.                                 frame_width,
  1748.                                 frame_height,
  1749.                                 0); 
  1750.             }
  1751.             else 
  1752.             {
  1753.                 printf("quicktime_fastjpg_decode: cmps %d %d mcu %04x %04x %04x unsupported\n",
  1754.                             jpeg_info->jpg_num_comps,
  1755.                             jpeg_info->jpg_comps_in_scan,
  1756.                             jpeg_info->jpg_comps[0].hvsample,
  1757.                             jpeg_info->jpg_comps[1].hvsample,
  1758.                             jpeg_info->jpg_comps[2].hvsample); 
  1759.                 break;
  1760.             }
  1761.         }
  1762.         else 
  1763.         if((jpeg_info->jpg_num_comps == 1) || (jpeg_info->jpg_comps_in_scan == 1))
  1764.         {
  1765. /* Grayscale not supported */
  1766.             quicktime_fastjpg_decode_111111(jpeg_info,
  1767.                                 output_rows, 
  1768.                                 jpeg_info->jpg_width,
  1769.                                 jpeg_info->jpg_height,
  1770.                                 interlaced,
  1771.                                 row_offset,
  1772.                                 frame_width,
  1773.                                 frame_height,
  1774.                                 1);
  1775.         }
  1776.         else
  1777.         {
  1778.             printf("quicktime_fastjpg_decode: cmps %d %d mcu %04x %04x %04x unsupported.\n",
  1779.                 jpeg_info->jpg_num_comps,
  1780.                 jpeg_info->jpg_comps_in_scan,
  1781.                 jpeg_info->jpg_comps[0].hvsample,
  1782.                 jpeg_info->jpg_comps[1].hvsample,
  1783.                 jpeg_info->jpg_comps[2].hvsample);
  1784.             break;
  1785.         }
  1786.  
  1787.         if(jpeg_info->marker == M_EOI) 
  1788.         { 
  1789.             jpeg_info->jpg_saw_EOI = 1; 
  1790.             jpeg_info->marker = 0x00; 
  1791.         }
  1792.         else 
  1793.         if(!jpeg_info->jpg_saw_EOI) 
  1794.             if(quicktime_fastjpg_readEOI(jpeg_info)) 
  1795.                 break;
  1796.  
  1797.     }
  1798.     return result;
  1799. }
  1800.