transupp.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

   * not mirrored.
   */
  MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_height = MCU_rows * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
   dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
   (JDIMENSION) compptr->v_samp_factor, TRUE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
       dst_blk_x += compptr->h_samp_factor) {
    src_buffer = (*srcinfo->mem->access_virt_barray)
      ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x,
       (JDIMENSION) compptr->h_samp_factor, FALSE);
    for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
      dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
      if (dst_blk_y < comp_height) {
        /* Block is within the mirrorable area. */
        src_ptr = src_buffer[offset_x]
    [comp_height - dst_blk_y - offset_y - 1];
        for (i = 0; i < DCTSIZE; i++) {
    for (j = 0; j < DCTSIZE; j++) {
      dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
      j++;
      dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
    }
        }
      } else {
        /* Edge blocks are transposed but not mirrored. */
        src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
        for (i = 0; i < DCTSIZE; i++)
    for (j = 0; j < DCTSIZE; j++)
      dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
      }
    }
  }
      }
    }
  }
}


LOCAL(void)
do_rot_180 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
      jvirt_barray_ptr *src_coef_arrays,
      jvirt_barray_ptr *dst_coef_arrays)
/* 180 degree rotation is equivalent to
 *   1. Vertical mirroring;
 *   2. Horizontal mirroring.
 * These two steps are merged into a single processing routine.
 */
{
  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
  int ci, i, j, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JBLOCKROW src_row_ptr, dst_row_ptr;
  JCOEFPTR src_ptr, dst_ptr;
  jpeg_component_info *compptr;

  MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE);
  MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_width = MCU_cols * compptr->h_samp_factor;
    comp_height = MCU_rows * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
   dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
   (JDIMENSION) compptr->v_samp_factor, TRUE);
      if (dst_blk_y < comp_height) {
  /* Row is within the vertically mirrorable area. */
  src_buffer = (*srcinfo->mem->access_virt_barray)
    ((j_common_ptr) srcinfo, src_coef_arrays[ci],
     comp_height - dst_blk_y - (JDIMENSION) compptr->v_samp_factor,
     (JDIMENSION) compptr->v_samp_factor, FALSE);
      } else {
  /* Bottom-edge rows are only mirrored horizontally. */
  src_buffer = (*srcinfo->mem->access_virt_barray)
    ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_y,
     (JDIMENSION) compptr->v_samp_factor, FALSE);
      }
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  if (dst_blk_y < comp_height) {
    /* Row is within the mirrorable area. */
    dst_row_ptr = dst_buffer[offset_y];
    src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
    /* Process the blocks that can be mirrored both ways. */
    for (dst_blk_x = 0; dst_blk_x < comp_width; dst_blk_x++) {
      dst_ptr = dst_row_ptr[dst_blk_x];
      src_ptr = src_row_ptr[comp_width - dst_blk_x - 1];
      for (i = 0; i < DCTSIZE; i += 2) {
        /* For even row, negate every odd column. */
        for (j = 0; j < DCTSIZE; j += 2) {
    *dst_ptr++ = *src_ptr++;
    *dst_ptr++ = - *src_ptr++;
        }
        /* For odd row, negate every even column. */
        for (j = 0; j < DCTSIZE; j += 2) {
    *dst_ptr++ = - *src_ptr++;
    *dst_ptr++ = *src_ptr++;
        }
      }
    }
    /* Any remaining right-edge blocks are only mirrored vertically. */
    for (; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
      dst_ptr = dst_row_ptr[dst_blk_x];
      src_ptr = src_row_ptr[dst_blk_x];
      for (i = 0; i < DCTSIZE; i += 2) {
        for (j = 0; j < DCTSIZE; j++)
    *dst_ptr++ = *src_ptr++;
        for (j = 0; j < DCTSIZE; j++)
    *dst_ptr++ = - *src_ptr++;
      }
    }
  } else {
    /* Remaining rows are just mirrored horizontally. */
    dst_row_ptr = dst_buffer[offset_y];
    src_row_ptr = src_buffer[offset_y];
    /* Process the blocks that can be mirrored. */
    for (dst_blk_x = 0; dst_blk_x < comp_width; dst_blk_x++) {
      dst_ptr = dst_row_ptr[dst_blk_x];
      src_ptr = src_row_ptr[comp_width - dst_blk_x - 1];
      for (i = 0; i < DCTSIZE2; i += 2) {
        *dst_ptr++ = *src_ptr++;
        *dst_ptr++ = - *src_ptr++;
      }
    }
    /* Any remaining right-edge blocks are only copied. */
    for (; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
      dst_ptr = dst_row_ptr[dst_blk_x];
      src_ptr = src_row_ptr[dst_blk_x];
      for (i = 0; i < DCTSIZE2; i++)
        *dst_ptr++ = *src_ptr++;
    }
  }
      }
    }
  }
}


LOCAL(void)
do_transverse (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
         jvirt_barray_ptr *src_coef_arrays,
         jvirt_barray_ptr *dst_coef_arrays)
/* Transverse transpose is equivalent to
 *   1. 180 degree rotation;
 *   2. Transposition;
 * or
 *   1. Horizontal mirroring;
 *   2. Transposition;
 *   3. Horizontal mirroring.
 * These steps are merged into a single processing routine.
 */
{
  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
  int ci, i, j, offset_x, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JCOEFPTR src_ptr, dst_ptr;
  jpeg_component_info *compptr;

  MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE);
  MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_width = MCU_cols * compptr->h_samp_factor;
    comp_height = MCU_rows * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
   dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
   (JDIMENSION) compptr->v_samp_factor, TRUE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
       dst_blk_x += compptr->h_samp_factor) {
    src_buffer = (*srcinfo->mem->access_virt_barray)
      ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x,
       (JDIMENSION) compptr->h_samp_factor, FALSE);
    for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
      if (dst_blk_y < comp_height) {
        src_ptr = src_buffer[offset_x]
    [comp_height - dst_blk_y - offset_y - 1];
        if (dst_blk_x < comp_width) {
    /* Block is within the mirrorable area. */
    dst_ptr = dst_buffer[offset_y]
      [comp_width - dst_blk_x - offset_x - 1];
    for (i = 0; i < DCTSIZE; i++) {
      for (j = 0; j < DCTSIZE; j++) {
        dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
        j++;
        dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
      }
      i++;
      for (j = 0; j < DCTSIZE; j++) {
        dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
        j++;
        dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
      }
    }
        } else {
    /* Right-edge blocks are mirrored in y only */
    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
    for (i = 0; i < DCTSIZE; i++) {
      for (j = 0; j < DCTSIZE; j++) {
        dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
        j++;
        dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
      }
    }
        }
      } else {
        src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
        if (dst_blk_x < comp_width) {
    /* Bottom-edge blocks are mirrored in x only */
    dst_ptr = dst_buffer[offset_y]
      [comp_width - dst_blk_x - offset_x - 1];
    for (i = 0; i < DCTSIZE; i++) {
      for (j = 0; j < DCTSIZE; j++)
        dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
      i++;
      for (j = 0; j < DCTSIZE; j++)
        dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
    }
        } else {
    /* At lower right corner, just transpose, no mirroring */
    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
    for (i = 0; i < DCTSIZE; i++)
      for (j = 0; j < DCTSIZE; j++)
        dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
        }
      }
    }
  }
      }
    }
  }
}


/* Request any required workspace.
 *
 * We allocate the workspace virtual arrays from the source decompression
 * object, so that all the arrays (both the original data and the workspace)
 * will be taken into account while making memory management decisions.
 * Hence, this routine must be called after jpeg_read_header (which reads
 * the image dimensions) and before jpeg_read_coefficients (which realizes
 * the source's virtual arrays).
 */

GLOBAL(void)
jtransform_request_workspace (j_decompress_ptr srcinfo,
            jpeg_transform_info *info)
{
  jvirt_barray_ptr *coef_arrays = NULL;
  jpeg_component_info *compptr;
  int ci;

  if (info->force_grayscale &&
      srcinfo->jpeg_color_space == JCS_YCbCr &&
      srcinfo->num_components == 3) {
    /* We'll only process the first component */
    info->num_components = 1;
  } else {
    /* Process all the components */
    info->num_components = srcinfo->num_components;
  }

  switch (info->transform) {
  case JXFORM_NONE:
  case JXFORM_FLIP_H:
    /* Don't need a workspace array */
    break;
  case JXFORM_FLIP_V:
  case JXFORM_ROT_180:
    /* Need workspace arrays having same dimensions as source image.
     * Note that we allocate arrays padded out to the next iMCU boundary,
     * so that transform routines need not worry about missing edge blocks.
     */
    coef_arrays = (jvirt_barray_ptr *)
      (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
  SIZEOF(jvirt_barray_ptr) * info->num_components);
    for (ci = 0; ci < info->num_components; ci++) {
      compptr = srcinfo->comp_info + ci;
      coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
  ((j_common_ptr) srcinfo, 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);
    }
    break;
  case JXFORM_TRANSPOSE:
  case JXFORM_TRANSVERSE:
  case JXFORM_ROT_90:
  case JXFORM_ROT_270:
    /* Need workspace arrays having transposed dimensions.
     * Note that we allocate arrays padded out to the next iMCU boundary,
     * so that transform routines need not worry about missing edge blocks.
     */
    coef_arrays = (jvirt_barray_ptr *)
      (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
  SIZEOF(jvirt_barray_ptr) * info->num_components);