jdcoefct.c File Reference

#include "jinclude.h"
#include "jpeglib.h"

Include dependency graph for jdcoefct.c:

Go to the source code of this file.

Classes
struct	my_coef_controller

Macros
#define	JPEG_INTERNALS

Typedefs
typedef my_coef_controller *	my_coef_ptr

Functions
	METHODDEF (int)
	start_input_pass (j_decompress_ptr cinfo)
	start_output_pass (j_decompress_ptr cinfo)
	decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
	dummy_consume_data (j_decompress_ptr cinfo)
	jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)

Macro Definition Documentation

JPEG_INTERNALS

#define JPEG_INTERNALS

Definition at line 18 of file jdcoefct.c.

Typedef Documentation

my_coef_ptr

typedef my_coef_controller* my_coef_ptr

Definition at line 65 of file jdcoefct.c.

Function Documentation

decompress_onepass()

decompress_onepass	(	j_decompress_ptr	cinfo,
		JSAMPIMAGE	output_buf
	)

Definition at line 151 of file jdcoefct.c.

{
  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION MCU_col_num;   /* index of current MCU within row */
  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  int ci, xindex, yindex, yoffset, useful_width;
  JBLOCKROW blkp;
  JSAMPARRAY output_ptr;
  JDIMENSION start_col, output_col;
  jpeg_component_info *compptr;
  inverse_DCT_method_ptr inverse_DCT;
 
  /* Loop to process as much as one whole iMCU row */
  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
       yoffset++) {
    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
     MCU_col_num++) {
      blkp = coef->blk_buffer;  /* pointer to current DCT block within MCU */
      /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
      if (cinfo->lim_Se)    /* can bypass in DC only case */
    MEMZERO(blkp, cinfo->blocks_in_MCU * SIZEOF(JBLOCK));
      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
    /* Suspension forced; update state counters and exit */
    coef->MCU_vert_offset = yoffset;
    coef->MCU_ctr = MCU_col_num;
    return JPEG_SUSPENDED;
      }
      /* Determine where data should go in output_buf and do the IDCT thing.
       * We skip dummy blocks at the right and bottom edges (but blkp gets
       * incremented past them!).
       */
      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    /* Don't bother to IDCT an uninteresting component. */
    if (! compptr->component_needed) {
      blkp += compptr->MCU_blocks;
      continue;
    }
    inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
    output_ptr = output_buf[compptr->component_index] +
      yoffset * compptr->DCT_v_scaled_size;
    useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
                            : compptr->last_col_width;
    start_col = MCU_col_num * compptr->MCU_sample_width;
    for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
      if (cinfo->input_iMCU_row < last_iMCU_row ||
          yoffset + yindex < compptr->last_row_height) {
        output_col = start_col;
        for (xindex = 0; xindex < useful_width; xindex++) {
          (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) (blkp + xindex),
                  output_ptr, output_col);
          output_col += compptr->DCT_h_scaled_size;
        }
        output_ptr += compptr->DCT_v_scaled_size;
      }
      blkp += compptr->MCU_width;
    }
      }
    }
    /* Completed an MCU row, but perhaps not an iMCU row */
    coef->MCU_ctr = 0;
  }
  /* Completed the iMCU row, advance counters for next one */
  cinfo->output_iMCU_row++;
  if (++(cinfo->input_iMCU_row) <= last_iMCU_row) {
    start_iMCU_row(cinfo);
    return JPEG_ROW_COMPLETED;
  }
  /* Completed the scan */
  (*cinfo->inputctl->finish_input_pass) (cinfo);
  return JPEG_SCAN_COMPLETED;
}

Referenced by jinit_d_coef_controller().

dummy_consume_data()

dummy_consume_data

(

j_decompress_ptr

cinfo

)

Definition at line 231 of file jdcoefct.c.

{
  return JPEG_SUSPENDED;    /* Always indicate nothing was done */
}

Referenced by jinit_d_coef_controller().

jinit_d_coef_controller()

jinit_d_coef_controller	(	j_decompress_ptr	cinfo,
		boolean	need_full_buffer
	)

Definition at line 680 of file jdcoefct.c.

{
  my_coef_ptr coef;
 
  if (need_full_buffer) {
#ifdef D_MULTISCAN_FILES_SUPPORTED
    /* Allocate a full-image virtual array for each component, */
    /* padded to a multiple of samp_factor DCT blocks in each direction. */
    /* Note we ask for a pre-zeroed array. */
    int ci, access_rows;
    jpeg_component_info *compptr;
 
    coef = (my_coef_ptr) (*cinfo->mem->alloc_small)
      ((j_common_ptr) cinfo, JPOOL_IMAGE,
       SIZEOF(my_coef_controller) - SIZEOF(coef->blk_buffer));
    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
     ci++, compptr++) {
      access_rows = compptr->v_samp_factor;
#ifdef BLOCK_SMOOTHING_SUPPORTED
      /* If block smoothing could be used, need a bigger window */
      if (cinfo->progressive_mode)
    access_rows *= 3;
#endif
      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
    ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
     (JDIMENSION) jround_up((long) compptr->width_in_blocks,
                (long) compptr->h_samp_factor),
     (JDIMENSION) jround_up((long) compptr->height_in_blocks,
                (long) compptr->v_samp_factor),
     (JDIMENSION) access_rows);
    }
    coef->pub.consume_data = consume_data;
    coef->pub.decompress_data = decompress_data;
    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
#else
    ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif
  } else {
    /* We only need a single-MCU buffer. */
    JBLOCKARRAY blkp;
    JBLOCKROW buffer_ptr;
    int bi;
 
    coef = (my_coef_ptr) (*cinfo->mem->alloc_small)
      ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_coef_controller));
    buffer_ptr = coef->blk_buffer;
    if (cinfo->lim_Se == 0) /* DC only case: want to bypass later */
      MEMZERO(buffer_ptr, SIZEOF(coef->blk_buffer));
    blkp = coef->MCU_buffer;
    bi = D_MAX_BLOCKS_IN_MCU;
    do {
      *blkp++ = buffer_ptr++;
    } while (--bi);
    coef->pub.consume_data = dummy_consume_data;
    coef->pub.decompress_data = decompress_onepass;
    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
  }
 
  coef->pub.start_input_pass = start_input_pass;
  coef->pub.start_output_pass = start_output_pass;
#ifdef BLOCK_SMOOTHING_SUPPORTED
  coef->coef_bits_latch = NULL;
#endif
  cinfo->coef = &coef->pub;
}

Referenced by master_selection(), and transdecode_master_selection().

METHODDEF()

METHODDEF

(

int

)

Definition at line 69 of file jdcoefct.c.

{
  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
 
  /* In an interleaved scan, an MCU row is the same as an iMCU row.
   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
   * But at the bottom of the image, process only what's left.
   */
  if (cinfo->comps_in_scan > 1) {
    coef->MCU_rows_per_iMCU_row = 1;
  } else {
    if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
    else
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
  }
 
  coef->MCU_ctr = 0;
  coef->MCU_vert_offset = 0;
}

start_input_pass()

start_input_pass

(

j_decompress_ptr

cinfo

)

Definition at line 111 of file jdcoefct.c.

{
  cinfo->input_iMCU_row = 0;
  start_iMCU_row(cinfo);
}

Referenced by jinit_d_coef_controller().

start_output_pass()

start_output_pass

(

j_decompress_ptr

cinfo

)

Definition at line 123 of file jdcoefct.c.

{
#ifdef BLOCK_SMOOTHING_SUPPORTED
  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
 
  /* If multipass, check to see whether to use block smoothing on this pass */
  if (coef->pub.coef_arrays != NULL) {
    if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
      coef->pub.decompress_data = decompress_smooth_data;
    else
      coef->pub.decompress_data = decompress_data;
  }
#endif
  cinfo->output_iMCU_row = 0;
}

Referenced by jinit_d_coef_controller().