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 58 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 blkn, bi, ci, yindex, yoffset, blockcnt;
  JDIMENSION ypos, 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; we rely on having allocated the MCU_buffer[] blocks
       * sequentially.  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.)
       */
      blkn = 0;
      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    forward_DCT = cinfo->fdct->forward_DCT[compptr->component_index];
    blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
                        : compptr->last_col_width;
    xpos = MCU_col_num * compptr->MCU_sample_width;
    ypos = yoffset * compptr->DCT_v_scaled_size;
    /* ypos == (yoffset+yindex) * DCTSIZE */
    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_buf[compptr->component_index],
                coef->MCU_buffer[blkn],
                ypos, xpos, (JDIMENSION) blockcnt);
        if (blockcnt < compptr->MCU_width) {
          /* Create some dummy blocks at the right edge of the image. */
          FMEMZERO((void FAR *) coef->MCU_buffer[blkn + blockcnt],
               (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
          for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
        coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
          }
        }
      } else {
        /* Create a row of dummy blocks at the bottom of the image. */
        FMEMZERO((void FAR *) coef->MCU_buffer[blkn],
             compptr->MCU_width * SIZEOF(JBLOCK));
        for (bi = 0; bi < compptr->MCU_width; bi++) {
          coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
        }
      }
      blkn += compptr->MCU_width;
      ypos += compptr->DCT_v_scaled_size;
    }
      }
      /* 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;
 
  coef = (my_coef_ptr)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                SIZEOF(my_coef_controller));
  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
  coef->pub.start_pass = start_pass_coef;
 
  /* Create the coefficient buffer. */
  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;
 
    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. */
    JBLOCKROW buffer;
    int i;
 
    buffer = (JBLOCKROW)
      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
      coef->MCU_buffer[i] = buffer + i;
    }
    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
  }
}

Referenced by jinit_compress_master().

METHODDEF()

METHODDEF

(

boolean

)

Definition at line 62 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 101 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);
    break;
  }
}

Referenced by jinit_c_coef_controller().