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->height_in_blocks,        (long) compptr->v_samp_factor),   (JDIMENSION) jround_up((long) compptr->width_in_blocks,        (long) compptr->h_samp_factor),   (JDIMENSION) compptr->h_samp_factor);    }    break;  }  info->workspace_coef_arrays = coef_arrays;}/* Transpose destination image parameters */LOCAL(void)transpose_critical_parameters (j_compress_ptr dstinfo){  int tblno, i, j, ci, itemp;  jpeg_component_info *compptr;  JQUANT_TBL *qtblptr;  JDIMENSION dtemp;  UINT16 qtemp;  /* Transpose basic image dimensions */  dtemp = dstinfo->image_width;  dstinfo->image_width = dstinfo->image_height;  dstinfo->image_height = dtemp;  /* Transpose sampling factors */  for (ci = 0; ci < dstinfo->num_components; ci++) {    compptr = dstinfo->comp_info + ci;    itemp = compptr->h_samp_factor;    compptr->h_samp_factor = compptr->v_samp_factor;    compptr->v_samp_factor = itemp;  }  /* Transpose quantization tables */  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {    qtblptr = dstinfo->quant_tbl_ptrs[tblno];    if (qtblptr != NULL) {      for (i = 0; i < DCTSIZE; i++) {  for (j = 0; j < i; j++) {    qtemp = qtblptr->quantval[i*DCTSIZE+j];    qtblptr->quantval[i*DCTSIZE+j] = qtblptr->quantval[j*DCTSIZE+i];    qtblptr->quantval[j*DCTSIZE+i] = qtemp;  }      }    }  }}/* Trim off any partial iMCUs on the indicated destination edge */LOCAL(void)trim_right_edge (j_compress_ptr dstinfo){  int ci, max_h_samp_factor;  JDIMENSION MCU_cols;  /* We have to compute max_h_samp_factor ourselves,   * because it hasn't been set yet in the destination   * (and we don't want to use the source's value).   */  max_h_samp_factor = 1;  for (ci = 0; ci < dstinfo->num_components; ci++) {    int h_samp_factor = dstinfo->comp_info[ci].h_samp_factor;    max_h_samp_factor = MAX(max_h_samp_factor, h_samp_factor);  }  MCU_cols = dstinfo->image_width / (max_h_samp_factor * DCTSIZE);  if (MCU_cols > 0)   /* can't trim to 0 pixels */    dstinfo->image_width = MCU_cols * (max_h_samp_factor * DCTSIZE);}LOCAL(void)trim_bottom_edge (j_compress_ptr dstinfo){  int ci, max_v_samp_factor;  JDIMENSION MCU_rows;  /* We have to compute max_v_samp_factor ourselves,   * because it hasn't been set yet in the destination   * (and we don't want to use the source's value).   */  max_v_samp_factor = 1;  for (ci = 0; ci < dstinfo->num_components; ci++) {    int v_samp_factor = dstinfo->comp_info[ci].v_samp_factor;    max_v_samp_factor = MAX(max_v_samp_factor, v_samp_factor);  }  MCU_rows = dstinfo->image_height / (max_v_samp_factor * DCTSIZE);  if (MCU_rows > 0)   /* can't trim to 0 pixels */    dstinfo->image_height = MCU_rows * (max_v_samp_factor * DCTSIZE);}/* Adjust output image parameters as needed. * * This must be called after jpeg_copy_critical_parameters() * and before jpeg_write_coefficients(). * * The return value is the set of virtual coefficient arrays to be written * (either the ones allocated by jtransform_request_workspace, or the * original source data arrays).  The caller will need to pass this value * to jpeg_write_coefficients(). */GLOBAL(jvirt_barray_ptr *)jtransform_adjust_parameters (j_decompress_ptr srcinfo,            j_compress_ptr dstinfo,            jvirt_barray_ptr *src_coef_arrays,            jpeg_transform_info *info){  /* If force-to-grayscale is requested, adjust destination parameters */  if (info->force_grayscale) {    /* We use jpeg_set_colorspace to make sure subsidiary settings get fixed     * properly.  Among other things, the target h_samp_factor & v_samp_factor     * will get set to 1, which typically won't match the source.     * In fact we do this even if the source is already grayscale; that     * provides an easy way of coercing a grayscale JPEG with funny sampling     * factors to the customary 1,1.  (Some decoders fail on other factors.)     */    if ((dstinfo->jpeg_color_space == JCS_YCbCr &&   dstinfo->num_components == 3) ||  (dstinfo->jpeg_color_space == JCS_GRAYSCALE &&   dstinfo->num_components == 1)) {      /* We have to preserve the source's quantization table number. */      int sv_quant_tbl_no = dstinfo->comp_info[0].quant_tbl_no;      jpeg_set_colorspace(dstinfo, JCS_GRAYSCALE);      dstinfo->comp_info[0].quant_tbl_no = sv_quant_tbl_no;    } else {      /* Sorry, can't do it */      ERREXIT(dstinfo, JERR_CONVERSION_NOTIMPL);    }  }  /* Correct the destination's image dimensions etc if necessary */  switch (info->transform) {  case JXFORM_NONE:    /* Nothing to do */    break;  case JXFORM_FLIP_H:    if (info->trim)      trim_right_edge(dstinfo);    break;  case JXFORM_FLIP_V:    if (info->trim)      trim_bottom_edge(dstinfo);    break;  case JXFORM_TRANSPOSE:    transpose_critical_parameters(dstinfo);    /* transpose does NOT have to trim anything */    break;  case JXFORM_TRANSVERSE:    transpose_critical_parameters(dstinfo);    if (info->trim) {      trim_right_edge(dstinfo);      trim_bottom_edge(dstinfo);    }    break;  case JXFORM_ROT_90:    transpose_critical_parameters(dstinfo);    if (info->trim)      trim_right_edge(dstinfo);    break;  case JXFORM_ROT_180:    if (info->trim) {      trim_right_edge(dstinfo);      trim_bottom_edge(dstinfo);    }    break;  case JXFORM_ROT_270:    transpose_critical_parameters(dstinfo);    if (info->trim)      trim_bottom_edge(dstinfo);    break;  }  /* Return the appropriate output data set */  if (info->workspace_coef_arrays != NULL)    return info->workspace_coef_arrays;  return src_coef_arrays;}/* Execute the actual transformation, if any. * * This must be called *after* jpeg_write_coefficients, because it depends * on jpeg_write_coefficients to have computed subsidiary values such as * the per-component width and height fields in the destination object. * * Note that some transformations will modify the source data arrays! */GLOBAL(void)jtransform_execute_transformation (j_decompress_ptr srcinfo,           j_compress_ptr dstinfo,           jvirt_barray_ptr *src_coef_arrays,           jpeg_transform_info *info){  jvirt_barray_ptr *dst_coef_arrays = info->workspace_coef_arrays;  switch (info->transform) {  case JXFORM_NONE:    break;  case JXFORM_FLIP_H:    do_flip_h(srcinfo, dstinfo, src_coef_arrays);    break;  case JXFORM_FLIP_V:    do_flip_v(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);    break;  case JXFORM_TRANSPOSE:    do_transpose(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);    break;  case JXFORM_TRANSVERSE:    do_transverse(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);    break;  case JXFORM_ROT_90:    do_rot_90(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);    break;  case JXFORM_ROT_180:    do_rot_180(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);    break;  case JXFORM_ROT_270:    do_rot_270(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);    break;  }}#endif /* TRANSFORMS_SUPPORTED *//* Setup decompression object to save desired markers in memory. * This must be called before jpeg_read_header() to have the desired effect. */GLOBAL(void)jcopy_markers_setup (j_decompress_ptr srcinfo, JCOPY_OPTION option){#ifdef SAVE_MARKERS_SUPPORTED  int m;  /* Save comments except under NONE option */  if (option != JCOPYOPT_NONE) {    jpeg_save_markers(srcinfo, JPEG_COM, 0xFFFF);  }  /* Save all types of APPn markers iff ALL option */  if (option == JCOPYOPT_ALL) {    for (m = 0; m < 16; m++)      jpeg_save_markers(srcinfo, JPEG_APP0 + m, 0xFFFF);  }#endif /* SAVE_MARKERS_SUPPORTED */}/* Copy markers saved in the given source object to the destination object. * This should be called just after jpeg_start_compress() or * jpeg_write_coefficients(). * Note that those routines will have written the SOI, and also the * JFIF APP0 or Adobe APP14 markers if selected. */GLOBAL(void)jcopy_markers_execute (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,           JCOPY_OPTION option){  jpeg_saved_marker_ptr marker;  /* In the current implementation, we don't actually need to examine the   * option flag here; we just copy everything that got saved.   * But to avoid confusion, we do not output JFIF and Adobe APP14 markers   * if the encoder library already wrote one.   */  for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) {    if (dstinfo->write_JFIF_header &&  marker->marker == JPEG_APP0 &&  marker->data_length >= 5 &&  GETJOCTET(marker->data[0]) == 0x4A &&  GETJOCTET(marker->data[1]) == 0x46 &&  GETJOCTET(marker->data[2]) == 0x49 &&  GETJOCTET(marker->data[3]) == 0x46 &&  GETJOCTET(marker->data[4]) == 0)      continue;     /* reject duplicate JFIF */    if (dstinfo->write_Adobe_marker &&  marker->marker == JPEG_APP0+14 &&  marker->data_length >= 5 &&  GETJOCTET(marker->data[0]) == 0x41 &&  GETJOCTET(marker->data[1]) == 0x64 &&  GETJOCTET(marker->data[2]) == 0x6F &&  GETJOCTET(marker->data[3]) == 0x62 &&  GETJOCTET(marker->data[4]) == 0x65)      continue;     /* reject duplicate Adobe */#ifdef NEED_FAR_POINTERS    /* We could use jpeg_write_marker if the data weren't FAR... */    {      unsigned int i;      jpeg_write_m_header(dstinfo, marker->marker, marker->data_length);      for (i = 0; i < marker->data_length; i++)  jpeg_write_m_byte(dstinfo, marker->data[i]);    }#else    jpeg_write_marker(dstinfo, marker->marker,          marker->data, marker->data_length);#endif  }}