JDMERGE.c
上传用户:cjw5120
上传日期:2022-05-11
资源大小:5032k
文件大小:15k
源码类别:

网络截获/分析

开发平台:

Visual C++

  1. ////////////////////////////////////////////////////////////////////////
  2. //
  3. // Note : this file is included as part of the Smaller Animals Software
  4. // JpegFile package. Though this file has not been modified from it's 
  5. // original IJG 6a form, it is not the responsibility on the Independent
  6. // JPEG Group to answer questions regarding this code.
  7. //
  8. // Any questions you have about this code should be addressed to :
  9. //
  10. // CHRISDL@PAGESZ.NET - the distributor of this package.
  11. //
  12. // Remember, by including this code in the JpegFile package, Smaller 
  13. // Animals Software assumes all responsibilities for answering questions
  14. // about it. If we (SA Software) can't answer your questions ourselves, we 
  15. // will direct you to people who can.
  16. //
  17. // Thanks, CDL.
  18. //
  19. ////////////////////////////////////////////////////////////////////////
  20. /*
  21.  * jdmerge.c
  22.  *
  23.  * Copyright (C) 1994-1996, Thomas G. Lane.
  24.  * This file is part of the Independent JPEG Group's software.
  25.  * For conditions of distribution and use, see the accompanying README file.
  26.  *
  27.  * This file contains code for merged upsampling/color conversion.
  28.  *
  29.  * This file combines functions from jdsample.c and jdcolor.c;
  30.  * read those files first to understand what's going on.
  31.  *
  32.  * When the chroma components are to be upsampled by simple replication
  33.  * (ie, box filtering), we can save some work in color conversion by
  34.  * calculating all the output pixels corresponding to a pair of chroma
  35.  * samples at one time.  In the conversion equations
  36.  * R = Y           + K1 * Cr
  37.  * G = Y + K2 * Cb + K3 * Cr
  38.  * B = Y + K4 * Cb
  39.  * only the Y term varies among the group of pixels corresponding to a pair
  40.  * of chroma samples, so the rest of the terms can be calculated just once.
  41.  * At typical sampling ratios, this eliminates half or three-quarters of the
  42.  * multiplications needed for color conversion.
  43.  *
  44.  * This file currently provides implementations for the following cases:
  45.  * YCbCr => RGB color conversion only.
  46.  * Sampling ratios of 2h1v or 2h2v.
  47.  * No scaling needed at upsample time.
  48.  * Corner-aligned (non-CCIR601) sampling alignment.
  49.  * Other special cases could be added, but in most applications these are
  50.  * the only common cases.  (For uncommon cases we fall back on the more
  51.  * general code in jdsample.c and jdcolor.c.)
  52.  */
  53. #define JPEG_INTERNALS
  54. #include "jinclude.h"
  55. #include "jpeglib.h"
  56. #ifdef UPSAMPLE_MERGING_SUPPORTED
  57. /* Private subobject */
  58. typedef struct {
  59.   struct jpeg_upsampler pub; /* public fields */
  60.   /* Pointer to routine to do actual upsampling/conversion of one row group */
  61.   JMETHOD(void, upmethod, (j_decompress_ptr cinfo,
  62.    JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
  63.    JSAMPARRAY output_buf));
  64.   /* Private state for YCC->RGB conversion */
  65.   int * Cr_r_tab; /* => table for Cr to R conversion */
  66.   int * Cb_b_tab; /* => table for Cb to B conversion */
  67.   long * Cr_g_tab; /* => table for Cr to G conversion */
  68.   long * Cb_g_tab; /* => table for Cb to G conversion */
  69.   /* For 2:1 vertical sampling, we produce two output rows at a time.
  70.    * We need a "spare" row buffer to hold the second output row if the
  71.    * application provides just a one-row buffer; we also use the spare
  72.    * to discard the dummy last row if the image height is odd.
  73.    */
  74.   JSAMPROW spare_row;
  75.   unsigned int spare_full; /* T if spare buffer is occupied */
  76.   JDIMENSION out_row_width; /* samples per output row */
  77.   JDIMENSION rows_to_go; /* counts rows remaining in image */
  78. } my_upsampler;
  79. typedef my_upsampler * my_upsample_ptr;
  80. #define SCALEBITS 16 /* speediest right-shift on some machines */
  81. #define ONE_HALF ((long) 1 << (SCALEBITS-1))
  82. #define FIX(x) ((long) ((x) * (1L<<SCALEBITS) + 0.5))
  83. /*
  84.  * Initialize tables for YCC->RGB colorspace conversion.
  85.  * This is taken directly from jdcolor.c; see that file for more info.
  86.  */
  87. LOCAL(void)
  88. build_ycc_rgb_table (j_decompress_ptr cinfo)
  89. {
  90.   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  91.   int i;
  92.   long x;
  93.   SHIFT_TEMPS
  94.   upsample->Cr_r_tab = (int *)
  95.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  96. (MAXJSAMPLE+1) * SIZEOF(int));
  97.   upsample->Cb_b_tab = (int *)
  98.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  99. (MAXJSAMPLE+1) * SIZEOF(int));
  100.   upsample->Cr_g_tab = (long *)
  101.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  102. (MAXJSAMPLE+1) * SIZEOF(long));
  103.   upsample->Cb_g_tab = (long *)
  104.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  105. (MAXJSAMPLE+1) * SIZEOF(long));
  106.   for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
  107.     /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
  108.     /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
  109.     /* Cr=>R value is nearest int to 1.40200 * x */
  110.     upsample->Cr_r_tab[i] = (int)
  111.     RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
  112.     /* Cb=>B value is nearest int to 1.77200 * x */
  113.     upsample->Cb_b_tab[i] = (int)
  114.     RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
  115.     /* Cr=>G value is scaled-up -0.71414 * x */
  116.     upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
  117.     /* Cb=>G value is scaled-up -0.34414 * x */
  118.     /* We also add in ONE_HALF so that need not do it in inner loop */
  119.     upsample->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
  120.   }
  121. }
  122. /*
  123.  * Initialize for an upsampling pass.
  124.  */
  125. METHODDEF(void)
  126. start_pass_merged_upsample (j_decompress_ptr cinfo)
  127. {
  128.   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  129.   /* Mark the spare buffer empty */
  130.   upsample->spare_full = FALSE;
  131.   /* Initialize total-height counter for detecting bottom of image */
  132.   upsample->rows_to_go = cinfo->output_height;
  133. }
  134. /*
  135.  * Control routine to do upsampling (and color conversion).
  136.  *
  137.  * The control routine just handles the row buffering considerations.
  138.  */
  139. METHODDEF(void)
  140. merged_2v_upsample (j_decompress_ptr cinfo,
  141.     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
  142.     JDIMENSION in_row_groups_avail,
  143.     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
  144.     JDIMENSION out_rows_avail)
  145. /* 2:1 vertical sampling case: may need a spare row. */
  146. {
  147.   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  148.   JSAMPROW work_ptrs[2];
  149.   JDIMENSION num_rows; /* number of rows returned to caller */
  150.   if (upsample->spare_full) {
  151.     /* If we have a spare row saved from a previous cycle, just return it. */
  152.     jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
  153.       1, upsample->out_row_width);
  154.     num_rows = 1;
  155.     upsample->spare_full = FALSE;
  156.   } else {
  157.     /* Figure number of rows to return to caller. */
  158.     num_rows = 2;
  159.     /* Not more than the distance to the end of the image. */
  160.     if (num_rows > upsample->rows_to_go)
  161.       num_rows = upsample->rows_to_go;
  162.     /* And not more than what the client can accept: */
  163.     out_rows_avail -= *out_row_ctr;
  164.     if (num_rows > out_rows_avail)
  165.       num_rows = out_rows_avail;
  166.     /* Create output pointer array for upsampler. */
  167.     work_ptrs[0] = output_buf[*out_row_ctr];
  168.     if (num_rows > 1) {
  169.       work_ptrs[1] = output_buf[*out_row_ctr + 1];
  170.     } else {
  171.       work_ptrs[1] = upsample->spare_row;
  172.       upsample->spare_full = TRUE;
  173.     }
  174.     /* Now do the upsampling. */
  175.     (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
  176.   }
  177.   /* Adjust counts */
  178.   *out_row_ctr += num_rows;
  179.   upsample->rows_to_go -= num_rows;
  180.   /* When the buffer is emptied, declare this input row group consumed */
  181.   if (! upsample->spare_full)
  182.     (*in_row_group_ctr)++;
  183. }
  184. METHODDEF(void)
  185. merged_1v_upsample (j_decompress_ptr cinfo,
  186.     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
  187.     JDIMENSION in_row_groups_avail,
  188.     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
  189.     JDIMENSION out_rows_avail)
  190. /* 1:1 vertical sampling case: much easier, never need a spare row. */
  191. {
  192.   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  193.   /* Just do the upsampling. */
  194.   (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
  195.  output_buf + *out_row_ctr);
  196.   /* Adjust counts */
  197.   (*out_row_ctr)++;
  198.   (*in_row_group_ctr)++;
  199. }
  200. /*
  201.  * These are the routines invoked by the control routines to do
  202.  * the actual upsampling/conversion.  One row group is processed per call.
  203.  *
  204.  * Note: since we may be writing directly into application-supplied buffers,
  205.  * we have to be honest about the output width; we can't assume the buffer
  206.  * has been rounded up to an even width.
  207.  */
  208. /*
  209.  * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
  210.  */
  211. METHODDEF(void)
  212. h2v1_merged_upsample (j_decompress_ptr cinfo,
  213.       JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
  214.       JSAMPARRAY output_buf)
  215. {
  216.   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  217.   register int y, cred, cgreen, cblue;
  218.   int cb, cr;
  219.   register JSAMPROW outptr;
  220.   JSAMPROW inptr0, inptr1, inptr2;
  221.   JDIMENSION col;
  222.   /* copy these pointers into registers if possible */
  223.   register JSAMPLE * range_limit = cinfo->sample_range_limit;
  224.   int * Crrtab = upsample->Cr_r_tab;
  225.   int * Cbbtab = upsample->Cb_b_tab;
  226.   long * Crgtab = upsample->Cr_g_tab;
  227.   long * Cbgtab = upsample->Cb_g_tab;
  228.   SHIFT_TEMPS
  229.   inptr0 = input_buf[0][in_row_group_ctr];
  230.   inptr1 = input_buf[1][in_row_group_ctr];
  231.   inptr2 = input_buf[2][in_row_group_ctr];
  232.   outptr = output_buf[0];
  233.   /* Loop for each pair of output pixels */
  234.   for (col = cinfo->output_width >> 1; col > 0; col--) {
  235.     /* Do the chroma part of the calculation */
  236.     cb = GETJSAMPLE(*inptr1++);
  237.     cr = GETJSAMPLE(*inptr2++);
  238.     cred = Crrtab[cr];
  239.     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
  240.     cblue = Cbbtab[cb];
  241.     /* Fetch 2 Y values and emit 2 pixels */
  242.     y  = GETJSAMPLE(*inptr0++);
  243.     outptr[RGB_RED] =   range_limit[y + cred];
  244.     outptr[RGB_GREEN] = range_limit[y + cgreen];
  245.     outptr[RGB_BLUE] =  range_limit[y + cblue];
  246.     outptr += RGB_PIXELSIZE;
  247.     y  = GETJSAMPLE(*inptr0++);
  248.     outptr[RGB_RED] =   range_limit[y + cred];
  249.     outptr[RGB_GREEN] = range_limit[y + cgreen];
  250.     outptr[RGB_BLUE] =  range_limit[y + cblue];
  251.     outptr += RGB_PIXELSIZE;
  252.   }
  253.   /* If image width is odd, do the last output column separately */
  254.   if (cinfo->output_width & 1) {
  255.     cb = GETJSAMPLE(*inptr1);
  256.     cr = GETJSAMPLE(*inptr2);
  257.     cred = Crrtab[cr];
  258.     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
  259.     cblue = Cbbtab[cb];
  260.     y  = GETJSAMPLE(*inptr0);
  261.     outptr[RGB_RED] =   range_limit[y + cred];
  262.     outptr[RGB_GREEN] = range_limit[y + cgreen];
  263.     outptr[RGB_BLUE] =  range_limit[y + cblue];
  264.   }
  265. }
  266. /*
  267.  * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
  268.  */
  269. METHODDEF(void)
  270. h2v2_merged_upsample (j_decompress_ptr cinfo,
  271.       JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
  272.       JSAMPARRAY output_buf)
  273. {
  274.   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  275.   register int y, cred, cgreen, cblue;
  276.   int cb, cr;
  277.   register JSAMPROW outptr0, outptr1;
  278.   JSAMPROW inptr00, inptr01, inptr1, inptr2;
  279.   JDIMENSION col;
  280.   /* copy these pointers into registers if possible */
  281.   register JSAMPLE * range_limit = cinfo->sample_range_limit;
  282.   int * Crrtab = upsample->Cr_r_tab;
  283.   int * Cbbtab = upsample->Cb_b_tab;
  284.   long * Crgtab = upsample->Cr_g_tab;
  285.   long * Cbgtab = upsample->Cb_g_tab;
  286.   SHIFT_TEMPS
  287.   inptr00 = input_buf[0][in_row_group_ctr*2];
  288.   inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
  289.   inptr1 = input_buf[1][in_row_group_ctr];
  290.   inptr2 = input_buf[2][in_row_group_ctr];
  291.   outptr0 = output_buf[0];
  292.   outptr1 = output_buf[1];
  293.   /* Loop for each group of output pixels */
  294.   for (col = cinfo->output_width >> 1; col > 0; col--) {
  295.     /* Do the chroma part of the calculation */
  296.     cb = GETJSAMPLE(*inptr1++);
  297.     cr = GETJSAMPLE(*inptr2++);
  298.     cred = Crrtab[cr];
  299.     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
  300.     cblue = Cbbtab[cb];
  301.     /* Fetch 4 Y values and emit 4 pixels */
  302.     y  = GETJSAMPLE(*inptr00++);
  303.     outptr0[RGB_RED] =   range_limit[y + cred];
  304.     outptr0[RGB_GREEN] = range_limit[y + cgreen];
  305.     outptr0[RGB_BLUE] =  range_limit[y + cblue];
  306.     outptr0 += RGB_PIXELSIZE;
  307.     y  = GETJSAMPLE(*inptr00++);
  308.     outptr0[RGB_RED] =   range_limit[y + cred];
  309.     outptr0[RGB_GREEN] = range_limit[y + cgreen];
  310.     outptr0[RGB_BLUE] =  range_limit[y + cblue];
  311.     outptr0 += RGB_PIXELSIZE;
  312.     y  = GETJSAMPLE(*inptr01++);
  313.     outptr1[RGB_RED] =   range_limit[y + cred];
  314.     outptr1[RGB_GREEN] = range_limit[y + cgreen];
  315.     outptr1[RGB_BLUE] =  range_limit[y + cblue];
  316.     outptr1 += RGB_PIXELSIZE;
  317.     y  = GETJSAMPLE(*inptr01++);
  318.     outptr1[RGB_RED] =   range_limit[y + cred];
  319.     outptr1[RGB_GREEN] = range_limit[y + cgreen];
  320.     outptr1[RGB_BLUE] =  range_limit[y + cblue];
  321.     outptr1 += RGB_PIXELSIZE;
  322.   }
  323.   /* If image width is odd, do the last output column separately */
  324.   if (cinfo->output_width & 1) {
  325.     cb = GETJSAMPLE(*inptr1);
  326.     cr = GETJSAMPLE(*inptr2);
  327.     cred = Crrtab[cr];
  328.     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
  329.     cblue = Cbbtab[cb];
  330.     y  = GETJSAMPLE(*inptr00);
  331.     outptr0[RGB_RED] =   range_limit[y + cred];
  332.     outptr0[RGB_GREEN] = range_limit[y + cgreen];
  333.     outptr0[RGB_BLUE] =  range_limit[y + cblue];
  334.     y  = GETJSAMPLE(*inptr01);
  335.     outptr1[RGB_RED] =   range_limit[y + cred];
  336.     outptr1[RGB_GREEN] = range_limit[y + cgreen];
  337.     outptr1[RGB_BLUE] =  range_limit[y + cblue];
  338.   }
  339. }
  340. /*
  341.  * Module initialization routine for merged upsampling/color conversion.
  342.  *
  343.  * NB: this is called under the conditions determined by use_merged_upsample()
  344.  * in jdmaster.c.  That routine MUST correspond to the actual capabilities
  345.  * of this module; no safety checks are made here.
  346.  */
  347. GLOBAL(void)
  348. jinit_merged_upsampler (j_decompress_ptr cinfo)
  349. {
  350.   my_upsample_ptr upsample;
  351.   upsample = (my_upsample_ptr)
  352.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  353. SIZEOF(my_upsampler));
  354.   cinfo->upsample = (struct jpeg_upsampler *) upsample;
  355.   upsample->pub.start_pass = start_pass_merged_upsample;
  356.   upsample->pub.need_context_rows = FALSE;
  357.   upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
  358.   if (cinfo->max_v_samp_factor == 2) {
  359.     upsample->pub.upsample = merged_2v_upsample;
  360.     upsample->upmethod = h2v2_merged_upsample;
  361.     /* Allocate a spare row buffer */
  362.     upsample->spare_row = (JSAMPROW)
  363.       (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  364. (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
  365.   } else {
  366.     upsample->pub.upsample = merged_1v_upsample;
  367.     upsample->upmethod = h2v1_merged_upsample;
  368.     /* No spare row needed */
  369.     upsample->spare_row = NULL;
  370.   }
  371.   build_ycc_rgb_table(cinfo);
  372. }
  373. #endif /* UPSAMPLE_MERGING_SUPPORTED */