home *** CD-ROM | disk | FTP | other *** search
/ High Voltage Shareware / high1.zip / high1 / DIR2 / DVPG30FS.ZIP / JDCOLOR.C < prev    next >
C/C++ Source or Header  |  1993-12-01  |  25KB  |  838 lines
  1. /*
  2.  * jdcolor.c
  3.  *
  4.  * Copyright (C) 1991, 1992, 1993, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file contains output colorspace conversion routines.
  9.  * These routines are invoked via the methods color_convert
  10.  * and colorout_init/term.
  11.  */
  12.  
  13. /*#include "jinclude.h"*/
  14. #include "viewdef.h"
  15. #include "extern.h"
  16.  
  17. #include <dos.h>
  18.  
  19. /* added stuff from DVPEG */
  20. extern unsigned char red, green, blue;        /* colors for saving full 24 bit resolution */
  21.  
  22. unsigned int FAR * int_ptr;
  23. unsigned int FAR * tmp_ptr;        /* point to an integer to read the structure faster ie words not bytes */
  24. unsigned int FAR * int_ptr2;
  25. unsigned int FAR * tmp_ptr2;        /* point to an integer to read the structure faster ie words not bytes */
  26.  
  27.  
  28.  
  29. /**************** YCbCr -> RGB conversion: most common case **************/
  30.  
  31. /*
  32.  * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
  33.  * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
  34.  * The conversion equations to be implemented are therefore
  35.  *    R = Y                + 1.40200 * Cr
  36.  *    G = Y - 0.34414 * Cb - 0.71414 * Cr
  37.  *    B = Y + 1.77200 * Cb
  38.  * where Cb and Cr represent the incoming values less MAXJSAMPLE/2.
  39.  * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
  40.  *
  41.  * To avoid floating-point arithmetic, we represent the fractional constants
  42.  * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
  43.  * the products by 2^16, with appropriate rounding, to get the correct answer.
  44.  * Notice that Y, being an integral input, does not contribute any fraction
  45.  * so it need not participate in the rounding.
  46.  *
  47.  * For even more speed, we avoid doing any multiplications in the inner loop
  48.  * by precalculating the constants times Cb and Cr for all possible values.
  49.  * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
  50.  * for 12-bit samples it is still acceptable.  It's not very reasonable for
  51.  * 16-bit samples, but if you want lossless storage you shouldn't be changing
  52.  * colorspace anyway.
  53.  * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
  54.  * values for the G calculation are left scaled up, since we must add them
  55.  * together before rounding.
  56.  */
  57.  
  58. #ifdef SIXTEEN_BIT_SAMPLES
  59. #define SCALEBITS    14    /* avoid overflow */
  60. #else
  61. #define SCALEBITS    16    /* speedier right-shift on some machines */
  62. #endif
  63. #define ONE_HALF    ((INT32) 1 << (SCALEBITS-1))
  64. #define FIX(x)        ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
  65.  
  66. static int * Cr_r_tab;        /* => table for Cr to R conversion */
  67. static int * Cb_b_tab;        /* => table for Cb to B conversion */
  68. static int * Cb_tab;
  69. /*        static INT32 * Cr_g_tab;    /* => table for Cr to G conversion */
  70. /*        static INT32 * Cb_g_tab;    /* => table for Cb to G conversion */
  71.  
  72.  
  73.  
  74. /*
  75.  * do tinting if the option is turned on
  76.  */
  77.  
  78. void near tint_graphics(void)
  79. {
  80. int red_new, green_new, blue_new;    /* for color tinting */
  81.  
  82. red_new = new_tint(red, tint_factor_red) + red;
  83. green_new = new_tint(green, tint_factor_green) + green;
  84. blue_new = new_tint(blue, tint_factor_blue) + blue;
  85.  
  86. if (((red_new | green_new | blue_new) & 0xff00) == 0){
  87.     blue = blue_new;
  88.     green = green_new;
  89.     red = red_new;
  90.     }
  91. }
  92.  
  93.  
  94. /*
  95.  * Initialize for colorspace conversion.
  96.  */
  97.  
  98. METHODDEF void
  99. ycc_rgb_init (decompress_info_ptr cinfo)
  100. {
  101.   INT32 i, x2;
  102.   SHIFT_TEMPS
  103.  
  104.   Cr_r_tab = (int *) (*cinfo->emethods->alloc_small)
  105.                 ((MAXJSAMPLE+1) * SIZEOF(int));
  106.   Cb_b_tab = (int *) (*cinfo->emethods->alloc_small)
  107.                 ((MAXJSAMPLE+1) * SIZEOF(int));
  108. /*  Cr_g_tab = (INT32 *) (*cinfo->emethods->alloc_small)
  109.                 ((MAXJSAMPLE+1) * SIZEOF(INT32));
  110.   Cb_g_tab = (INT32 *) (*cinfo->emethods->alloc_small)
  111.                 ((MAXJSAMPLE+1) * SIZEOF(INT32));*/
  112.  
  113.   Cb_tab = (int *) (*cinfo->emethods->alloc_small)
  114.                 ((385) * SIZEOF(int));
  115.  
  116.   for (i = 0; i <= MAXJSAMPLE; i++) {
  117.      /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
  118.      /* The Cb or Cr value we are thinking of is x = i - MAXJSAMPLE/2 */
  119.      x2 = 2*i - MAXJSAMPLE;    /* twice x */
  120.      /* Cr=>R value is nearest int to 1.40200 * x */
  121.      Cr_r_tab[i] = (int)
  122.              RIGHT_SHIFT(FIX(1.40200/2) * x2 + ONE_HALF, SCALEBITS);
  123.      /* Cb=>B value is nearest int to 1.77200 * x */
  124.      Cb_b_tab[i] = (int)
  125.              RIGHT_SHIFT(FIX(1.77200/2) * x2 + ONE_HALF, SCALEBITS);
  126.      /* Cr=>G value is scaled-up -0.71414 * x */
  127. /*     Cr_g_tab[i] = (- FIX(0.71414/2)) * x2;
  128.      /* Cb=>G value is scaled-up -0.34414 * x */
  129.      /* We also add in ONE_HALF so that need not do it in inner loop */
  130. /*     Cb_g_tab[i] = (- FIX(0.34414/2)) * x2 + ONE_HALF;*/
  131.   }
  132. for (i=0; i < 385; i++){
  133.     Cb_tab[i] = (int)RIGHT_SHIFT((-FIX(0.71414)) * (i-192) + ONE_HALF, SCALEBITS);
  134.     }
  135. }
  136.  
  137. #ifndef small_viewer
  138.  
  139. /*
  140.  * Convert some rows of samples to the output colorspace. ==> 15 bit
  141.  */
  142.  
  143. METHODDEF void
  144. ycc_rgb_15_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  145.          JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  146. {
  147. #ifdef SIXTEEN_BIT_SAMPLES
  148.   register INT32 y;
  149.   register UINT16 cb, cr;
  150. #else
  151.   register int cg, cb, cr;
  152. #endif
  153.   register JSAMPROW inptr0, inptr1, inptr2;
  154.   register int col, cols;
  155.   /* copy these pointers into registers if possible */
  156.   register JSAMPLE * range_limit;
  157.   register int * Crrtab = Cr_r_tab;
  158.   register int * Cbbtab = Cb_b_tab;
  159. /*
  160.   register INT32 * Crgtab = Cr_g_tab;
  161.   register INT32 * Cbgtab = Cb_g_tab;
  162. */
  163.   register int * cbtab = Cb_tab;
  164.   int row;
  165.   SHIFT_TEMPS
  166.  
  167. cols = num_cols;
  168.  
  169. for (row = 0; row < num_rows; row++) {
  170.     if (!enable_pan)
  171.         read_row = 0;
  172.     tmp_ptr = int_ptr = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  173.             (raw_pic_ptr, read_row++, TRUE));
  174.     inptr2 = input_data[2][row];
  175.     inptr1 = input_data[1][row];
  176.     inptr0 = input_data[0][row];
  177.     for (col = 0; col < cols; col++) {
  178.         cb = GETJSAMPLE(inptr1[col]);
  179.         cr = GETJSAMPLE(inptr2[col]);
  180.         cg = cbtab[cr + (cb >> 1)];
  181.         cb = Cbbtab[cb];
  182.         cr = Crrtab[cr];
  183.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col]);
  184.         red = range_limit[cb];
  185.         green = range_limit[cg];
  186.         blue = range_limit[cr];
  187.         if (tint_loaded) tint_graphics();
  188.         * int_ptr++ = (red >> 3) + ((green << 2) & 0x3e0) + ((blue << 7) & 0xfc00);
  189.         }
  190.     draw_line(gr_row, (unsigned char FAR *)tmp_ptr, line_buffer_ptr);
  191.     gr_row++;
  192.     }
  193. }
  194.  
  195.  
  196.  
  197. /*
  198.  * Convert some rows of samples to the output colorspace. ==> 15 bit
  199.  * assume un-upsampled data!
  200.  *
  201.  * more speedup is possible if I duplicate for the row below at the same time
  202.  */
  203.  
  204. METHODDEF void
  205. ycc_rgb_fst_15_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  206.          JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  207. {
  208.   register int cb, cr, cg;
  209.   register JSAMPROW inptr0, inptr1, inptr2, inptr00;
  210.   register int col, cols;
  211.   register JSAMPLE * range_limit;
  212.   int * Crrtab = Cr_r_tab;
  213.   int * Cbbtab = Cb_b_tab;
  214.   int * cbtab = Cb_tab;
  215.   int row;
  216.  
  217. cols = num_cols >> 1;
  218.  
  219.  
  220. for (row = 0; row < num_rows; row += 1) {
  221.     if (!enable_pan)
  222.         read_row = 0;
  223.     tmp_ptr = int_ptr = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  224.             (raw_pic_ptr, read_row++, TRUE));
  225. /*
  226.     tmp_ptr2 = int_ptr2 = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  227.             (raw_pic_ptr, read_row++, TRUE));
  228. */
  229.     inptr0 = input_data[0][row];
  230.     inptr00 = input_data[0][row+1];
  231.     inptr2 = input_data[2][row & 0xfffe];
  232.     inptr1 = input_data[1][row & 0xfffe];
  233.     for (col = 0; col < cols; col++) {
  234. /* do row #1 */
  235.         cb = GETJSAMPLE(inptr1[col]);
  236.         cr = GETJSAMPLE(inptr2[col]);
  237.         cg = cbtab[cr + (cb >> 1)];
  238.         cb = Cbbtab[cb];
  239.         cr = Crrtab[cr];
  240.  
  241.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col*2]);
  242.         red = range_limit[cb];
  243.         green = range_limit[cg];
  244.         blue = range_limit[cr];
  245.         if (tint_loaded) tint_graphics();
  246.         * int_ptr++ = (red >> 3) + ((green << 2) & 0x3e0) + ((blue << 7) & 0xfc00);
  247.  
  248.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col*2+1]);
  249.         red = range_limit[cb];
  250.         green = range_limit[cg];
  251.         blue = range_limit[cr];
  252.         if (tint_loaded) tint_graphics();
  253.         * int_ptr++ = (red >> 3) + ((green << 2) & 0x3e0) + ((blue << 7) & 0xfc00);
  254.  
  255. /* row #2
  256.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr00[col*2]);
  257.         red = range_limit[cb];
  258.         green = range_limit[cg];
  259.         blue = range_limit[cr];
  260.         if (tint_loaded) tint_graphics();
  261.         * int_ptr2++ = (red >> 3) + ((green << 2) & 0x3e0) + ((blue << 7) & 0xfc00);
  262.  
  263.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr00[col*2+1]);
  264.         red = range_limit[cb];
  265.         green = range_limit[cg];
  266.         blue = range_limit[cr];
  267.         if (tint_loaded) tint_graphics();
  268.         * int_ptr2++ = (red >> 3) + ((green << 2) & 0x3e0) + ((blue << 7) & 0xfc00);
  269. */
  270.         }
  271.     draw_line(gr_row++, (unsigned char FAR *)tmp_ptr, line_buffer_ptr);
  272. /*
  273.     draw_line(gr_row++, (unsigned char FAR *)tmp_ptr2, line_buffer_ptr);
  274. */
  275.     }
  276. }
  277.  
  278.  
  279.  
  280.  
  281. /*
  282.  * Convert some rows of samples to the output colorspace.  ==> 16 bit
  283.  */
  284.  
  285. METHODDEF void
  286. ycc_rgb_16_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  287.          JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  288. {
  289.   register int cg, cb, cr;
  290.   register JSAMPROW inptr0, inptr1, inptr2;
  291.   register int col;
  292.   register JSAMPLE * range_limit;
  293.   register int * Crrtab = Cr_r_tab;
  294.   register int * Cbbtab = Cb_b_tab;
  295.   register int * cbtab = Cb_tab;
  296.   int row;
  297.  
  298.  
  299. for (row = 0; row < num_rows; row++) {
  300.     if (!enable_pan)
  301.         read_row = 0;
  302.     tmp_ptr = int_ptr = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  303.             (raw_pic_ptr, read_row++, TRUE));
  304.     inptr2 = input_data[2][row];
  305.     inptr1 = input_data[1][row];
  306.     inptr0 = input_data[0][row];
  307.     for (col = 0; col < num_cols; col++) {
  308.         cb = GETJSAMPLE(inptr1[col]);
  309.         cr = GETJSAMPLE(inptr2[col]);
  310.         cg = cbtab[cr + (cb >> 1)];
  311.         cb = Cbbtab[cb];
  312.         cr = Crrtab[cr];
  313.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col]);
  314.         red = range_limit[cb];
  315.         green = range_limit[cg];
  316.         blue = range_limit[cr];
  317.         if (tint_loaded) tint_graphics();
  318.         * int_ptr++ = (red >> 3) + ((green << 3) & 0x7e0) + ((blue << 8) & 0xf800);
  319.         }
  320.     draw_line(gr_row, (unsigned char FAR *)tmp_ptr, line_buffer_ptr);
  321.     gr_row++;
  322.     }
  323. }
  324.  
  325.  
  326. METHODDEF void
  327. ycc_rgb_fst_16_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  328.          JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  329. {
  330.   register int cb, cr, cg;
  331.   register JSAMPROW inptr0, inptr1, inptr2, inptr00;
  332.   register int col, cols;
  333.   register JSAMPLE * range_limit;
  334.   int * Crrtab = Cr_r_tab;
  335.   int * Cbbtab = Cb_b_tab;
  336.   int * cbtab = Cb_tab;
  337.   int row;
  338.  
  339. cols = num_cols >> 1;
  340.  
  341. for (row = 0; row < num_rows; row += 1) {
  342.     if (!enable_pan)
  343.         read_row = 0;
  344.     tmp_ptr = int_ptr = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  345.             (raw_pic_ptr, read_row++, TRUE));
  346. /*    tmp_ptr2 = int_ptr2 = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  347.             (raw_pic_ptr, read_row++, TRUE));
  348. */
  349.     inptr0 = input_data[0][row];
  350.     inptr00 = input_data[0][row+1];
  351.     inptr2 = input_data[2][row & 0xfffe];
  352.     inptr1 = input_data[1][row & 0xfffe];
  353.     for (col = 0; col < cols; col++) {
  354. /* do row #1 */
  355.         cb = GETJSAMPLE(inptr1[col]);
  356.         cr = GETJSAMPLE(inptr2[col]);
  357.         cg = cbtab[cr + (cb >> 1)];
  358.         cb = Cbbtab[cb];
  359.         cr = Crrtab[cr];
  360.  
  361.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col*2]);
  362.         red = range_limit[cb];
  363.         green = range_limit[cg];
  364.         blue = range_limit[cr];
  365.         if (tint_loaded) tint_graphics();
  366.         * int_ptr++ = (red >> 3) + ((green << 3) & 0x7e0) + ((blue << 8) & 0xf800);
  367.  
  368.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col*2+1]);
  369.         red = range_limit[cb];
  370.         green = range_limit[cg];
  371.         blue = range_limit[cr];
  372.         if (tint_loaded) tint_graphics();
  373.         * int_ptr++ = (red >> 3) + ((green << 3) & 0x7e0) + ((blue << 8) & 0xf800);
  374.  
  375. /* row #2
  376.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr00[col*2]);
  377.         red = range_limit[cb];
  378.         green = range_limit[cg];
  379.         blue = range_limit[cr];
  380.         if (tint_loaded) tint_graphics();
  381.         * int_ptr2++ = (red >> 3) + ((green << 3) & 0x7e0) + ((blue << 8) & 0xf800);
  382.  
  383.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr00[col*2+1]);
  384.         red = range_limit[cb];
  385.         green = range_limit[cg];
  386.         blue = range_limit[cr];
  387.         if (tint_loaded) tint_graphics();
  388.         * int_ptr2++ = (red >> 3) + ((green << 3) & 0x7e0) + ((blue << 8) & 0xf800);
  389. */
  390.         }
  391.     draw_line(gr_row++, (unsigned char FAR *)tmp_ptr, line_buffer_ptr);
  392. /*
  393.     draw_line(gr_row++, (unsigned char FAR *)tmp_ptr2, line_buffer_ptr);
  394. */
  395.     }
  396. }
  397.  
  398.  
  399. METHODDEF void
  400. ycc_rgb_24_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  401.          JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  402. {
  403.   register int y, cb, cr, temp;
  404.   register JSAMPROW inptr0, inptr1, inptr2;
  405.   register JSAMPROW outptr;
  406.   register int col;
  407.   register JSAMPLE * range_limit;
  408.   register int * Crrtab = Cr_r_tab;
  409.   register int * Cbbtab = Cb_b_tab;
  410.   register int * cbtab = Cb_tab;
  411.   int row, flip;
  412.  
  413. flip = defaults & rgb_flip;
  414.  
  415. for (row = 0; row < num_rows; row++) {
  416.     if (!enable_pan)
  417.         read_row = 0;
  418.     tmp_ptr = outptr = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  419.             (raw_pic_ptr, read_row++, TRUE));
  420.     inptr2 = input_data[2][row];
  421.     inptr1 = input_data[1][row];
  422.     inptr0 = input_data[0][row];
  423.     for (col = 0; col < num_cols; col++) {
  424.         cb = GETJSAMPLE(inptr1[col]);
  425.         cr = GETJSAMPLE(inptr2[col]);
  426.         y = cbtab[cr + (cb >> 1)];
  427.         cr = Crrtab[cr];
  428.         cb = Cbbtab[cb];
  429.         if (!flip){
  430.             temp = cb;
  431.             cb = cr;
  432.             cr = temp;
  433.             }
  434.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col]);
  435.         red = range_limit[cb];
  436.         green = range_limit[y];
  437.         blue = range_limit[cr];
  438.         if (tint_loaded) tint_graphics();
  439.         outptr[0] = blue;
  440.         outptr[1] = green;
  441.         outptr[2] = red;
  442.         outptr += 3;
  443.         }
  444.     draw_line(gr_row, (unsigned char FAR *) tmp_ptr, line_buffer_ptr);
  445.     gr_row++;
  446.     }
  447. }
  448.  
  449.  
  450.  
  451. METHODDEF void
  452. ycc_rgb_fst_24_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  453.          JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  454. {
  455.   register int y, cb, cr, temp;
  456.   register JSAMPROW inptr0, inptr1, inptr2, inptr00;
  457.   register JSAMPROW outptr, outptr2;
  458.   register int col, cols;
  459.   register JSAMPLE * range_limit;
  460.   register int * Crrtab = Cr_r_tab;
  461.   register int * Cbbtab = Cb_b_tab;
  462.   register int * cbtab = Cb_tab;
  463.   int row, flip;
  464.  
  465. flip = defaults & rgb_flip;
  466. cols = num_cols >> 1;
  467.  
  468. for (row = 0; row < num_rows; row +=1) {
  469.     if (!enable_pan)
  470.         read_row = 0;
  471.     tmp_ptr = outptr = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  472.             (raw_pic_ptr, read_row++, TRUE));
  473. /*
  474.     tmp_ptr2 = outptr2 = (unsigned int FAR *) *((*cinfo->emethods->access_big_sarray)
  475.             (raw_pic_ptr, read_row++, TRUE));
  476. if (tmp_ptr2 == NULL){
  477.     sound(500);
  478.     delay(100);
  479.     sound(1000);
  480.     delay(200);
  481.     nosound();
  482.     }
  483. */
  484.     inptr2 = input_data[2][row & 0xfffe];
  485.     inptr1 = input_data[1][row & 0xfffe];
  486.     inptr0 = input_data[0][row];
  487.     inptr00 = input_data[0][row+1];
  488.     for (col = 0; col < cols; col++){
  489.         cb = GETJSAMPLE(inptr1[col]);
  490.         cr = GETJSAMPLE(inptr2[col]);
  491.         y = cbtab[cr + (cb >> 1)];
  492.         cr = Crrtab[cr];
  493.         cb = Cbbtab[cb];
  494.         if (!flip){
  495.             temp = cb;
  496.             cb = cr;
  497.             cr = temp;
  498.             }
  499.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col << 1]);
  500.         red = range_limit[cb];
  501.         green = range_limit[y];
  502.         blue = range_limit[cr];
  503.         if (tint_loaded) tint_graphics();
  504.         outptr[0] = blue;
  505.         outptr[1] = green;
  506.         outptr[2] = red;
  507.  
  508.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[(col << 1)+1]);
  509.         red = range_limit[cb];
  510.         green = range_limit[y];
  511.         blue = range_limit[cr];
  512.         if (tint_loaded) tint_graphics();
  513.         outptr[3] = blue;
  514.         outptr[4] = green;
  515.         outptr[5] = red;
  516.         outptr += 6;
  517.  
  518. /* row #2
  519.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr00[col << 1]);
  520.         red = range_limit[cb];
  521.         green = range_limit[y];
  522.         blue = range_limit[cr];
  523.         if (tint_loaded) tint_graphics();
  524.         outptr2[0] = blue;
  525.         outptr2[1] = green;
  526.         outptr2[2] = red;
  527.  
  528.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr00[(col << 1)+1]);
  529.         red = range_limit[cb];
  530.         green = range_limit[y];
  531.         blue = range_limit[cr];
  532.         if (tint_loaded) tint_graphics();
  533.         outptr2[3] = blue;
  534.         outptr2[4] = green;
  535.         outptr2[5] = red;
  536.         outptr2 += 6;
  537. */
  538.         }
  539.     draw_line(gr_row++, (unsigned char FAR *) tmp_ptr, line_buffer_ptr);
  540. /*
  541.     draw_line(gr_row++, (unsigned char FAR *)tmp_ptr2, line_buffer_ptr);
  542. */
  543.     }
  544. }
  545.  
  546. #endif /* small_viewer */
  547.  
  548.  
  549. /*
  550.  * Convert some rows of samples to the output colorspace.
  551.  */
  552.  
  553. METHODDEF void
  554. ycc_rgb_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  555.          JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  556. {
  557. #ifdef SIXTEEN_BIT_SAMPLES
  558.   register INT32 y;
  559.   register UINT16 cb, cr;
  560. #else
  561.   register int cg, cb, cr;
  562. #endif
  563.   register JSAMPROW inptr0, inptr1, inptr2;
  564.   register JSAMPROW outptr0, outptr1, outptr2;
  565.   register int col;
  566.   /* copy these pointers into registers if possible */
  567.   register JSAMPLE * range_limit;
  568.   register int * Crrtab = Cr_r_tab;
  569.   register int * Cbbtab = Cb_b_tab;
  570.   register int * cbtab = Cb_tab;
  571. /*
  572.   register INT32 * Crgtab = Cr_g_tab;
  573.   register INT32 * Cbgtab = Cb_g_tab;
  574. */
  575.   int row;
  576.   SHIFT_TEMPS
  577.  
  578.   for (row = 0; row < num_rows; row++) {
  579.      inptr0 = input_data[0][row];
  580.      inptr1 = input_data[1][row];
  581.     inptr2 = input_data[2][row];
  582.      outptr0 = output_data[0][row];
  583.      outptr1 = output_data[1][row];
  584.     outptr2 = output_data[2][row];
  585.      for (col = 0; col < num_cols; col++) {
  586.         cb = GETJSAMPLE(inptr1[col]);
  587.         cr = GETJSAMPLE(inptr2[col]);
  588.         cg = cbtab[cr + (cb >> 1)];
  589.         cb = Cbbtab[cb];
  590.         cr = Crrtab[cr];
  591.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col]);
  592.         outptr0[col] = range_limit[cr];    /* red */
  593.         outptr1[col] = range_limit[cg];
  594.         outptr2[col] = range_limit[cb];    /* blue */
  595.      }
  596.   }
  597. }
  598.  
  599.  
  600.  
  601.  
  602. /*
  603.  * Convert some rows of samples to the output colorspace.
  604.  *
  605.  * use faster output routines assuming non-upsampled data
  606.  */
  607.  
  608. METHODDEF void
  609. ycc_rgb_fst_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  610.          JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  611. {
  612.   register int y, cb, cr;
  613.   register JSAMPROW inptr0, inptr1, inptr2;
  614.   register JSAMPROW outptr0, outptr1, outptr2;
  615.   register int col;
  616.   register JSAMPLE * range_limit;
  617.   register int * Crrtab = Cr_r_tab;
  618.   register int * Cbbtab = Cb_b_tab;
  619.   register int * cbtab = Cb_tab;
  620.   int row;
  621.  
  622.   for (row = 0; row < num_rows; row++) {
  623.      inptr0 = input_data[0][row];
  624.      inptr1 = input_data[1][row & 0xfffe];
  625.      inptr2 = input_data[2][row & 0xfffe];
  626.      outptr0 = output_data[0][row];
  627.      outptr1 = output_data[1][row];
  628.      outptr2 = output_data[2][row];
  629.      for (col = num_cols-1; col >= 0; col--) {
  630.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col]);
  631.         cb = GETJSAMPLE(inptr1[col >> 1]);
  632.         cr = GETJSAMPLE(inptr2[col >> 1]);
  633.         y = cbtab[cr + (cb >> 1)];
  634.         cr = Crrtab[cr];
  635.         cb = Cbbtab[cb];
  636.         outptr0[col] = range_limit[cr];
  637.         outptr1[col] = range_limit[y];
  638.         outptr2[col] = range_limit[cb];
  639.  
  640.         col--;
  641.         range_limit = cinfo->sample_range_limit + GETJSAMPLE(inptr0[col]);
  642.         outptr0[col] = range_limit[cr];
  643.         outptr1[col] = range_limit[y];
  644.         outptr2[col] = range_limit[cb];
  645.      }
  646.   }
  647. }
  648.  
  649.  
  650.  
  651.  
  652.  
  653. /*
  654.  * Finish up at the end of the file.
  655.  */
  656.  
  657. METHODDEF void
  658. ycc_rgb_term (decompress_info_ptr cinfo)
  659. {
  660.   /* no work (we let free_all release the workspace) */
  661. }
  662.  
  663.  
  664. /**************** Cases other than YCbCr -> RGB **************/
  665.  
  666.  
  667. /*
  668.  * Initialize for colorspace conversion.
  669.  */
  670.  
  671. METHODDEF void
  672. null_init (decompress_info_ptr cinfo)
  673. /* colorout_init for cases where no setup is needed */
  674. {
  675.   /* no work needed */
  676. }
  677.  
  678.  
  679. /*
  680.  * Color conversion for no colorspace change: just copy the data.
  681.  */
  682.  
  683. METHODDEF void
  684. null_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  685.             JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  686. {
  687. ERREXIT(cinfo->emethods, "Unsupported viewer colorspace");
  688.  
  689. /* short ci;
  690.   for (ci = 0; ci < cinfo->num_components; ci++) {
  691.      jcopy_sample_rows(input_data[ci], 0, output_data[ci], 0,
  692.                 num_rows, num_cols);
  693.   }*/
  694. }
  695.  
  696.  
  697. /*
  698.  * Color conversion for grayscale: just copy the data.
  699.  * This also works for YCbCr/YIQ -> grayscale conversion, in which
  700.  * we just copy the Y (luminance) component and ignore chrominance.
  701.  */
  702.  
  703. METHODDEF void
  704. grayscale_convert (decompress_info_ptr cinfo, int num_rows, long num_cols,
  705.            JSAMPIMAGE input_data, JSAMPIMAGE output_data)
  706. {
  707.   jcopy_sample_rows(input_data[0], 0, output_data[0], 0,
  708.              num_rows, num_cols);
  709. }
  710.  
  711.  
  712. /*
  713.  * Finish up at the end of the file.
  714.  */
  715.  
  716. METHODDEF void
  717. null_term (decompress_info_ptr cinfo)
  718. /* colorout_term for cases where no teardown is needed */
  719. {
  720.   /* no work needed */
  721. }
  722.  
  723.  
  724.  
  725. /*
  726.  * The method selection routine for output colorspace conversion.
  727.  */
  728.  
  729. GLOBAL void
  730. jseldcolor (decompress_info_ptr cinfo)
  731. {
  732. int ci, video_card_type;
  733.  
  734. video_card_type = video_cards[video_mode_used].resolution;
  735.  
  736.   /* Make sure num_components agrees with jpeg_color_space */
  737.   switch (cinfo->jpeg_color_space) {
  738.   case CS_GRAYSCALE:
  739.     if (cinfo->num_components != 1)
  740.         ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
  741.     break;
  742.  
  743.   case CS_RGB:
  744.   case CS_YCbCr:
  745.   case CS_YIQ:
  746.     if (cinfo->num_components != 3)
  747.       ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
  748.     break;
  749.  
  750.   case CS_CMYK:
  751.     if (cinfo->num_components != 4)
  752.       ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
  753.      break;
  754.  
  755.   default:
  756.      ERREXIT(cinfo->emethods, "Unsupported JPEG colorspace");
  757.      break;
  758.   }
  759.  
  760.   /* Set color_out_comps and conversion method based on requested space. */
  761.   /* Also clear the component_needed flags for any unused components, */
  762.   /* so that earlier pipeline stages can avoid useless computation. */
  763.  
  764.   switch (cinfo->out_color_space) {
  765.   case CS_GRAYSCALE:
  766.      cinfo->color_out_comps = 1;
  767.      if (cinfo->jpeg_color_space == CS_GRAYSCALE ||
  768.     cinfo->jpeg_color_space == CS_YCbCr ||
  769.     cinfo->jpeg_color_space == CS_YIQ) {
  770.         cinfo->methods->color_convert = grayscale_convert;
  771.         cinfo->methods->colorout_init = null_init;
  772.         cinfo->methods->colorout_term = null_term;
  773.         /* For color->grayscale conversion, only the Y (0) component is needed */
  774.         for (ci = 1; ci < cinfo->num_components; ci++)
  775.     cinfo->cur_comp_info[ci]->component_needed = FALSE;
  776.      } else
  777.         ERREXIT(cinfo->emethods, "Unsupported color conversion request");
  778.      break;
  779.   case CS_RGB:
  780.      cinfo->color_out_comps = 3;
  781.      if (cinfo->jpeg_color_space == CS_YCbCr) {
  782. #ifndef small_viewer
  783.         switch (video_card_type){
  784.             case SVGA_16_bit:
  785.                 if ((more_defaults & high_jpeg_quality) || (jpeg_type != H2V2))
  786.                     cinfo->methods->color_convert = ycc_rgb_16_convert;
  787.                 else
  788.                     cinfo->methods->color_convert = ycc_rgb_fst_16_convert;
  789.                 break;
  790.             case SVGA_15_bit:
  791.                 if ((more_defaults & high_jpeg_quality) || (jpeg_type != H2V2))
  792.                     cinfo->methods->color_convert = ycc_rgb_15_convert;
  793.                 else
  794.                     cinfo->methods->color_convert = ycc_rgb_fst_15_convert;
  795.                 break;
  796.             case SVGA_24_bit:
  797.                 if ((more_defaults & high_jpeg_quality) || (jpeg_type != H2V2))
  798.                     cinfo->methods->color_convert = ycc_rgb_24_convert;
  799.                 else
  800.                     cinfo->methods->color_convert = ycc_rgb_fst_24_convert;
  801.                 break;
  802.             default:
  803.                 if ((more_defaults & high_jpeg_quality) || (cinfo->two_pass_quantize) || (jpeg_type != H2V2))
  804.                     cinfo->methods->color_convert = ycc_rgb_convert;
  805.                 else
  806.                     cinfo->methods->color_convert = ycc_rgb_fst_convert;
  807.             }
  808. #else
  809.         cinfo->methods->color_convert = ycc_rgb_convert;
  810. #endif
  811.         cinfo->methods->colorout_init = ycc_rgb_init;
  812.         cinfo->methods->colorout_term = ycc_rgb_term;
  813.      } else if (cinfo->jpeg_color_space == CS_RGB) {
  814.         cinfo->methods->color_convert = null_convert;
  815.         cinfo->methods->colorout_init = null_init;
  816.         cinfo->methods->colorout_term = null_term;
  817.      } else
  818.         ERREXIT(cinfo->emethods, "Unsupported color conversion request");
  819.      break;
  820.  
  821.   default:
  822.      /* Permit null conversion from CMYK or YCbCr to same output space */
  823.      if (cinfo->out_color_space == cinfo->jpeg_color_space) {
  824.         cinfo->color_out_comps = cinfo->num_components;
  825.         cinfo->methods->color_convert = null_convert;
  826.         cinfo->methods->colorout_init = null_init;
  827.       cinfo->methods->colorout_term = null_term;
  828.     } else            /* unsupported non-null conversion */
  829.       ERREXIT(cinfo->emethods, "Unsupported color conversion request");
  830.     break;
  831.   }
  832.  
  833.   if (cinfo->quantize_colors)
  834.     cinfo->final_out_comps = 1;    /* single colormapped output component */
  835.   else
  836.     cinfo->final_out_comps = cinfo->color_out_comps;
  837. }
  838.