jccoefct.c File Reference

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

Include dependency graph for jccoefct.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 (boolean)
	start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
	compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
	jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)

Macro Definition Documentation

JPEG_INTERNALS

#define JPEG_INTERNALS

Definition at line 14 of file jccoefct.c.

Typedef Documentation

my_coef_ptr

typedef my_coef_controller* my_coef_ptr

Definition at line 59 of file jccoefct.c.

Function Documentation

compress_data()

compress_data	(	j_compress_ptr	cinfo,
		JSAMPIMAGE	input_buf
	)

Definition at line 144 of file jccoefct.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, blockcnt;
  JBLOCKROW blkp;
  JSAMPARRAY input_ptr;
  JDIMENSION xpos;
  jpeg_component_info *compptr;
  forward_DCT_ptr forward_DCT;
 
  /* Loop to write 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++) {
      /* Determine where data comes from in input_buf and do the DCT thing.
       * Each call on forward_DCT processes a horizontal row of DCT blocks as
       * wide as an MCU.  Dummy blocks at the right or bottom edge are filled in
       * specially.  The data in them does not matter for image reconstruction,
       * so we fill them with values that will encode to the smallest amount of
       * data, viz: all zeroes in the AC entries, DC entries equal to previous
       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
       */
      blkp = coef->blk_buffer;  /* pointer to current DCT block within MCU */
      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    forward_DCT = cinfo->fdct->forward_DCT[compptr->component_index];
    input_ptr = input_buf[compptr->component_index] +
      yoffset * compptr->DCT_v_scaled_size;
    /* ypos == (yoffset + yindex) * compptr->DCT_v_scaled_size */
    blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
                        : compptr->last_col_width;
    xpos = MCU_col_num * compptr->MCU_sample_width;
    for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
      if (coef->iMCU_row_num < last_iMCU_row ||
          yoffset + yindex < compptr->last_row_height) {
        (*forward_DCT) (cinfo, compptr, input_ptr, blkp,
                xpos, (JDIMENSION) blockcnt);
        input_ptr += compptr->DCT_v_scaled_size;
        blkp += blockcnt;
        /* Dummy blocks at right edge */
        if ((xindex = compptr->MCU_width - blockcnt) == 0)
          continue;
      } else {
        /* At bottom of image, need a whole row of dummy blocks */
        xindex = compptr->MCU_width;
      }
      /* Fill in any dummy blocks needed in this row */
      MEMZERO(blkp, xindex * SIZEOF(JBLOCK));
      do {
        blkp[0][0] = blkp[-1][0];
        blkp++;
      } while (--xindex);
    }
      }
      /* Try to write the MCU.  In event of a suspension failure, we will
       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
       */
      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
    /* Suspension forced; update state counters and exit */
    coef->MCU_vert_offset = yoffset;
    coef->MCU_ctr = MCU_col_num;
    return FALSE;
      }
    }
    /* Completed an MCU row, but perhaps not an iMCU row */
    coef->MCU_ctr = 0;
  }
  /* Completed the iMCU row, advance counters for next one */
  coef->iMCU_row_num++;
  start_iMCU_row(cinfo);
  return TRUE;
}

Referenced by start_pass_coef().

jinit_c_coef_controller()

jinit_c_coef_controller	(	j_compress_ptr	cinfo,
		boolean	need_full_buffer
	)

Definition at line 410 of file jccoefct.c.

{
  my_coef_ptr coef;
 
  if (need_full_buffer) {
#ifdef FULL_COEF_BUFFER_SUPPORTED
    /* Allocate a full-image virtual array for each component, */
    /* padded to a multiple of samp_factor DCT blocks in each direction. */
    int ci;
    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++) {
      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
    ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
     (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) compptr->v_samp_factor);
    }
#else
    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
#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));
    blkp = coef->MCU_buffer;
    buffer_ptr = coef->blk_buffer;
    bi = C_MAX_BLOCKS_IN_MCU;
    do {
      *blkp++ = buffer_ptr++;
    } while (--bi);
    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
  }
 
  coef->pub.start_pass = start_pass_coef;
  cinfo->coef = &coef->pub;
}

Referenced by jinit_compress_master().

METHODDEF()

METHODDEF

(

boolean

)

Definition at line 63 of file jccoefct.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 (coef->iMCU_row_num < (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_pass_coef()

start_pass_coef	(	j_compress_ptr	cinfo,
		J_BUF_MODE	pass_mode
	)

Definition at line 102 of file jccoefct.c.

{
  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
 
  coef->iMCU_row_num = 0;
  start_iMCU_row(cinfo);
 
  switch (pass_mode) {
  case JBUF_PASS_THRU:
    if (coef->whole_image[0] != NULL)
      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
    coef->pub.compress_data = compress_data;
    break;
#ifdef FULL_COEF_BUFFER_SUPPORTED
  case JBUF_SAVE_AND_PASS:
    if (coef->whole_image[0] == NULL)
      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
    coef->pub.compress_data = compress_first_pass;
    break;
  case JBUF_CRANK_DEST:
    if (coef->whole_image[0] == NULL)
      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
    coef->pub.compress_data = compress_output;
    break;
#endif
  default:
    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
  }
}

Referenced by jinit_c_coef_controller().