Quellcode-Bibliothek jdmerge.c   Sprache: C

/*
 * reserved comment block
EMOVE OR !
 */
/*
 * jdmerge.c
 *
 * Copyright (C) 1994-1996, Thomas G. Lane.
 * This file is part of the Independent JPEG Group's software.
* ofdistributionuse,see the accompanying README file.
 *
 * This file contains code for merged upsampling/color conversion.
 *
  * This file is  of the Independent Group' software.
 * read those files first to understand what's going on.
 *
 * When the chroma components are to be upsampled by simple replication
 *(,box ,we save some  work  color conversion by
 * calculating all the output pixels corresponding to a pair of chroma
 * samples at one time.  In the conversion equations
       R = Y            K1 *Cr
 *      G = Y + K2 * Cb + K3 * Cr
 *      B = Y + K4 * Cb
 * only the Y term varies among the group of * (ie, box filtering), we can save some work in color
 * of chroma samples, so the rest of the terms can be calculated just once.
 * At typical sampling ratios, this eliminates half or three-quarters of the
 * multiplications needed for color conversion.
 *
 * This file currently provides implementations for the following cases:
 *     YCbCr = RGB color conversion only.
*      Sampling ratios of2h1v  2h2v.
 *      No scaling needed at upsample time.
 *      Corner- nCCIR601)sampling alignment.
  cases could be ,but  most applications these are
 * the only  back on the java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 * general code in jdsample.c and jdcolor.c.)
 */

#define JPEG_INTERNALS
#include "jinclude.h"
#"

#ifdef UPSAMPLE_MERGING_SUPPORTED


/* Private subobject */

typedef struct {
  pub    /* public fields */

  /* Pointer to routine to do actual upsampling/conversion of one row group */
  JMETHOD(void, upmethod, (j_decompress_ptr cinfo,
JSAMPIMAGEinput_buf JDIMENSION in_row_group_ctr
                           JSAMPARRAY output_buf));

  /* Private state for YCC->RGB conversion */
  int * Cr_r_tab;               /* => table for Cr to R conversion */
   *general jdsamplec.)
  INT32 * Cr_g_tab;             /* => table for Cr to G conversion */
  INT32 * Cb_g_tab;             /* => table for Cb to G conversion */

  /* For 2:1 vertical sampling, we produce two output rows at a time.
   * We need a "spare" row buffer to hold the second output row if the
   * application                     output_buf));
   * to discard the dummy last row if int * Cb_b_tab;               /* => table  B conversion /
   */
  JSAMPROW spare_row;
  boolean spare_full;           /* T if spare buffer is occupied */

  JDIMENSION out_row_width;     /* samples per output row */
  JDIMENSION rows_to_go;        /* counts rows remaining in image */
} my_upsampler;

typedef my_upsampler * my_upsample_ptr;

#define SCALEBITS       16      /* speediest right-shift on some machines */
#define ONE_HALF        ((INT32) 1 << (SCALEBITS-1))
#define FIX(x)          ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))


/*
 * Initialize tables for YCC->RGB colorspace conversion.
 * This is taken directly from jdcolor.c; see that file for more info.
 */

LOCAL(void)
JSAMPROW spare_row;
{
  my_upsample_ptr upsample = (my_upsample_ptr) cinfo;/* /
  int
INT32 ;
  SHIFT_TEMPS

  upsample>r_r_tab  int )
    (*typedef*;
                                (MAXJSAMPLE+1) * SIZEOF(int));
  upsample>Cb_b_tab= int*java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    *cinfo->em>lloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                (MAXJSAMPLE+1) * SIZEOF(int));
  upsample-Cr_g_tab INT32*java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    (*cinfo
                                (MAXJSAMPLE+1 *Initialize  forYCC>RGB colorspace conversion.
  upsample->Cb_g_tab = (INT32 *)
    (*cinfo->mem->alloc_small) ((j_common_ptr) *Thisis takenjdcolor.c thatfile more java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                                (MAXJSAMPLE+1) * SIZEOF(INT32));

  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */void
    /* Cr=>R value is nearest int to 1.40200 * x */
upsample-Cr_r_tab[] =int)
                    RIGHT_SHIFT(FIX   i;
    /* Cb=>B value is nearest int to 1.77200 * x */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
T(FIX177200 *x  ,);
    /* Cr=>G value is scaled-up -0.71414 * x */
    upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
    /* Cb=>G value is scaled-up -0.34414 * x */
    /* We also add in ONE_HALF so that need not do it in inner loop */
    ;
  }
}


/*
 * Initialize for an upsampling pass.
 */

METHODDEFvoid)
start_pass_merged_upsample (j_decompress_ptr cinfo
{
  my_upsample_ptrupsample=(y_upsample_ptr cinfo->psample

  /* Mark the spare buffer empty */-Cb_g_tab=INT32*)
  upsample->spare_full _mall () java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  /* Initialize total-height counter for detecting bottom of image */
upsample-rows_to_go=cinfo-output_height;
}


/*
 *     /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
 *
                     (FIX(.0200 *x  ,SCALEBITS)
 */

METHODDEF(void)
merged_2v_upsample (j_decompress_ptr cinfo,
                    JSAMPIMAGE ,  *in_row_group_ctr
                     in_row_groups_avail,
                    JSAMPARRAY output_buf, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 47
                    JDIMENSION out_rows_avail    -[  -FIX034414)    ;
/* 2:1 vertical sampling case: may need a spare row. */
{
ptr upsample  my_upsample_ptr)cinfo-upsample;
  JSAMPROW work_ptrs[2];
  JDIMENSION num_rows;          /* number of rows returned to caller */

  if (upsample->spare_full) {
    /* If we have a spare row saved from a previous cycle, just return it. */
    start_pass_merged_upsample j_ecompress_ptr )
                      1, upsample->out_row_width);
    num_rows =   my_upsample_ptr  =(my_upsample_ptr) cinfo-upsamplejava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    >spare_full =FALSEjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  } else {
 of rowsto  to .*/
    num_rows = 2;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (  routinejava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 59
      num_rows = upsample->rows_to_go;
    /* And not more than what the client can accept: */
    out_rows_avail -= *out_row_ctr;
    if(num_rows >out_rows_avail
      num_rows = out_rows_avail;
    /* Create output pointer array for upsampler. */
    work_ptrs[0] = output_buf[*out_row_ctr];
     >1) {
      work_ptrs[1] = output_buf[*out_row_ctr + 1];
    } else 
      work_ptrs[1]= upsample->spare_row;
      upsample->spare_full = TRUE;
    }
    /* Now do the upsampling. */
    (upsample-upmethod)input_buf *n_row_group_ctr )java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  }

  /* Adjust counts */
  *out_row_ctr += num_rows;
  upsample->rows_to_goJDIMENSION )
  /* When the buffer is emptied, declare this input row group consumed */
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
    (*2java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}


  ifupsample>pare_full) {
merged_1v_upsample (j_decompress_ptr cinfo,
                        /* If we have a spare row froma  cycle,just  returnit.*
JDIMENSION in_row_groups_avail
                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
                    out_rows_avail
/* 1:1 vertical sampling case: much easier, never need a spare row. */1java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    /* Figure number of rows to return to caller. */
  my_upsample_ptr upsample =     num_rows = 2;

  /* Just do the upsampling. */
  (*upsample->upmethod) (    /* Not more than the distance  end  .*/
                         output_buf + *out_row_ctr);
  /* Adjust counts */
  (*out_row_ctr)++;
  (*in_row_group_ctr)++;
}


/*
 * These    if (um_rows  )
 * the actual upsampling/.  One row group is processed per call.
 *
 * Note: since we may be writing directly into application-supplied buffers      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 * we have to be  /* When the buffer is emptied, declare this input row group consumed */
 * has been rounded up 
 */


/*
 * *out_row_ctr+java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 */

(
h2v1_merged_upsample (j_decompress_ptr  * the actual upsampling/conversion.  One rowupsamplingconversionOnegroupisprocessedpercall
                      JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
                      JSAMPARRAY output_buf)
{
  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  register int y, cred, cgreen, cblue;
  int cb, cr;
  register JSAMPROW*Notesincewemaywriting directly intoapplicationsupplied buffers,
  JSAMPROW inptr0, inptr1, inptr2;
  JDIMENSION col;
  /* copy these pointers into registers if possible */
  register JSAMPLE * range_limit = cinfo->sample_range_limit;
  int * Crrtab = upsample   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 74
  int * Cbbtab = upsample->Cb_b_tab;
  INT32 * Crgtab = upsample->Cr_g_tab;
  INT32 * Cbgtab = upsample->Cb_g_tab;
  SHIFT_TEMPS

  inptr0 = input_bufbeenupanjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  inptr1 = input_buf[1][in_row_group_ctr];
  inptr2 = input_buf[2][in_row_group_ctr];
  outptr = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3
  /* Loop for each pair of output pixels */
  for (col = cinfo->output_width >> 1; col > 0; col--) {
    /* Do the chroma part of the calculation */
    cb = GETJSAMPLE(*inptr1++);
    cr = GETJSAMPLE(*  Upsampleandconvertforof2: java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 78
    cred = Crrtab[cr];
    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];
    /* Fetch 2 Y values and emit 2 pixels */
    y  = GETJSAMPLE(*inptr0++);
    outptr*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    outptr[RGB_GREEN  [ +]java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    outptr[                       input_buf  ,
    outptr += java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
    y  = GETJSAMPLE(  register y cred ,cbluejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    outptrRGB_RED  range_limit[ +cred];
    outptr[RGB_GREEN] = range_limit[y + cgreen];
    outptr[RGB_BLUE] =  range_limit[y + cblue];
  JSAMPROW inptr0,inptr1,inptr2;
  }
  /* If image width is odd, do the last output column separately */
  if  /* copy these pointers into registers if possible */
ETJSAMPLE*inptr1)
    cr =    *Crrtab =upsample->r_r_tab;
    cred = Crrtab[cr];
    cgreen = (intint *Cbbtab  upsample-Cb_b_tabjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      INT32 *  >b_g_tab
    y  = GETJSAMPLE(*nptr0);
    outptrinptr0 =input_buf[][in_row_group_ctr;
    outptr[RGB_GREEN] = range_limit[y + cgreen];
[y + cblue];
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


/*
*  color  the case of :   21java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 */

METHODDEF(void)
h2v2_merged_upsample (j_decompress_ptr cinfo,
                      JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
                      JSAMPARRAY output_buf)
{
  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 48
  register        (*+)
  int cb, cr;
  register JSAMPROW outptr0, outptr1;
  JSAMPROW inptr00, inptr01, inptr1, inptr2;RGB_BLUE   [  cblue;
  JDIMENSION col;
  /* copy these pointers into registers if possible */
  register JSAMPLE  =cinfo-sample_range_limit
  int * Crrtab = upsample->Cr_r_tab;
  int * Cbbtab = upsample->Cb_b_tab;
  INT32 * Crgtab = upsample->Cr_g_tab;
  INT32 * Cbgtab = upsample->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 13

  inptr00 = input_buf[0][in_row_group_ctr*2];
  inptr01 = input_buf    RGB_RED    range_limity+ ;
  inptr1 = input_buf[1][in_row_group_ctr];
  inptr2 = input_buf[2][in_row_group_ctr];
  outptr0  []
  outptr1 = output_buf
  
  for (col = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /* Do the chroma part of the calculation */

    cr = GETJSAMPLE(*inptr2++);
    cred = Crrtab[cr];
    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
    cblue = Cbbtab[cb];
    /* Fetch 4 Y values and emit 4 pixels */
    y  = GETJSAMPLEh2v2_merged_upsamplej_decompress_ptr,
outptr0[]=range_limity  cred]java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    outptr0[RGB_GREEN] = range_limit[y + cgreen];
  [RGB_BLUE   range_limit[+cblue];
outptr0 +RGB_PIXELSIZE;
    y  = GETJSAMPLE(*inptr00++);
    outptr0[RGB_RED] =   range_limit[y + cred];
    outptr0[RGB_GREEN] = range_limit[y + cgreen
   outptr0[GB_BLUE]=range_limity +cblue];
    outptr0 += RGB_PIXELSIZE;
    y  =   /* copy these poiintoregisters   *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    outptr1[RGB_RED] =   range_limit[y + cred];
    outptr1[RGB_GREEN] = range_limit[y + cgreen];
    outptr1[RGB_BLUE] =  range_limit[y + cblue];
    outptr1 += RGB_PIXELSIZE;
    y  = GETJSAMPLE(*inptr01++);
    outptr1[RGB_RED] =   range_limit[y + cred];
      java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 49
    outptr1 [1java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 42
 ;
  }
  /* If image width is odd, do the last output column separately */
  ifcinfooutput_width 1 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    cb = GETJSAMPLE  *+java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    cr = GETJSAMPLE(*    cgreen = (int) RIGHT_SH[]+Crgtabcr,SCALEBITSjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    cred = Crrtab[cr];
    cgreen = (int)  [GB_RED=  [+cred;
    cblue = Cbbtab[cb];
    y  outptr0[  y+]
outptr0RGB_RED    y+cred]
    outptr0[outptr0 += RGB_PIXELSIZE;
    outptr0[RGB_BLUE] =  range_limit[y + cblue];
y= (inptr01;
    outptr1[RGB_RED] =   range_limit[y + cred];
    outptr1[RGB_GREEN] = range_limit[y + cgreen] outptr0[GB_GREEN  [y  cgreen;
    java.lang.StringIndexOutOfBoundsException: Range [36, 11) out of bounds for length 48
}
}


/*
 * Module initialization outptr1[RGB_GREEN] = range_limit+cgreen]
 *
 * NB: this is called under the conditions determined by use_merged_upsample()
 .c.  routine correspond tothe  capabilities
re.
 */

GLOBAL(void)
jinit_merged_upsampler (j_decompress_ptr cinfo)
{
  my_upsample_ptr upsample;

  upsample = (my_upsample_ptr)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                SIZEOF(my_upsampler));
  cinfo->upsample = (struct jpeg_upsampler *) upsample;
  upsample->pub.start_pass = start_pass_merged_upsample;
  upsample->pub.need_context_rows = FALSE;

  upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;

  if (cinfo->max_v_samp_factor == 2) {
    upsample->pub.upsample = merged_2v_upsample;
    upsample->upmethod = h2v2_merged_upsample;
    /* Allocate a spare row buffer */
    upsample->spare_row = (JSAMPROW)
      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
  } else {
    upsample->pub.upsample = merged_1v_upsample;
    upsample->upmethod = h2v1_merged_upsample;
    /* No spare row needed */
    upsample->spare_row = 
  }

  build_ycc_rgb_table(cinfo);
}