LCOV - code coverage report
Current view: directory - media/libjpeg - jctrans.c (source / functions) Found Hit Coverage
Test: app.info Lines: 137 0 0.0 %
Date: 2012-06-02 Functions: 7 0 0.0 %

       1                 : /*
       2                 :  * jctrans.c
       3                 :  *
       4                 :  * Copyright (C) 1995-1998, Thomas G. Lane.
       5                 :  * Modified 2000-2009 by Guido Vollbeding.
       6                 :  * This file is part of the Independent JPEG Group's software.
       7                 :  * For conditions of distribution and use, see the accompanying README file.
       8                 :  *
       9                 :  * This file contains library routines for transcoding compression,
      10                 :  * that is, writing raw DCT coefficient arrays to an output JPEG file.
      11                 :  * The routines in jcapimin.c will also be needed by a transcoder.
      12                 :  */
      13                 : 
      14                 : #define JPEG_INTERNALS
      15                 : #include "jinclude.h"
      16                 : #include "jpeglib.h"
      17                 : 
      18                 : 
      19                 : /* Forward declarations */
      20                 : LOCAL(void) transencode_master_selection
      21                 :         JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
      22                 : LOCAL(void) transencode_coef_controller
      23                 :         JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
      24                 : 
      25                 : 
      26                 : /*
      27                 :  * Compression initialization for writing raw-coefficient data.
      28                 :  * Before calling this, all parameters and a data destination must be set up.
      29                 :  * Call jpeg_finish_compress() to actually write the data.
      30                 :  *
      31                 :  * The number of passed virtual arrays must match cinfo->num_components.
      32                 :  * Note that the virtual arrays need not be filled or even realized at
      33                 :  * the time write_coefficients is called; indeed, if the virtual arrays
      34                 :  * were requested from this compression object's memory manager, they
      35                 :  * typically will be realized during this routine and filled afterwards.
      36                 :  */
      37                 : 
      38                 : GLOBAL(void)
      39               0 : jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
      40                 : {
      41               0 :   if (cinfo->global_state != CSTATE_START)
      42               0 :     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
      43                 :   /* Mark all tables to be written */
      44               0 :   jpeg_suppress_tables(cinfo, FALSE);
      45                 :   /* (Re)initialize error mgr and destination modules */
      46               0 :   (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
      47               0 :   (*cinfo->dest->init_destination) (cinfo);
      48                 :   /* Perform master selection of active modules */
      49               0 :   transencode_master_selection(cinfo, coef_arrays);
      50                 :   /* Wait for jpeg_finish_compress() call */
      51               0 :   cinfo->next_scanline = 0;  /* so jpeg_write_marker works */
      52               0 :   cinfo->global_state = CSTATE_WRCOEFS;
      53               0 : }
      54                 : 
      55                 : 
      56                 : /*
      57                 :  * Initialize the compression object with default parameters,
      58                 :  * then copy from the source object all parameters needed for lossless
      59                 :  * transcoding.  Parameters that can be varied without loss (such as
      60                 :  * scan script and Huffman optimization) are left in their default states.
      61                 :  */
      62                 : 
      63                 : GLOBAL(void)
      64               0 : jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
      65                 :                                j_compress_ptr dstinfo)
      66                 : {
      67                 :   JQUANT_TBL ** qtblptr;
      68                 :   jpeg_component_info *incomp, *outcomp;
      69                 :   JQUANT_TBL *c_quant, *slot_quant;
      70                 :   int tblno, ci, coefi;
      71                 : 
      72                 :   /* Safety check to ensure start_compress not called yet. */
      73               0 :   if (dstinfo->global_state != CSTATE_START)
      74               0 :     ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
      75                 :   /* Copy fundamental image dimensions */
      76               0 :   dstinfo->image_width = srcinfo->image_width;
      77               0 :   dstinfo->image_height = srcinfo->image_height;
      78               0 :   dstinfo->input_components = srcinfo->num_components;
      79               0 :   dstinfo->in_color_space = srcinfo->jpeg_color_space;
      80                 : #if JPEG_LIB_VERSION >= 70
      81                 :   dstinfo->jpeg_width = srcinfo->output_width;
      82                 :   dstinfo->jpeg_height = srcinfo->output_height;
      83                 :   dstinfo->min_DCT_h_scaled_size = srcinfo->min_DCT_h_scaled_size;
      84                 :   dstinfo->min_DCT_v_scaled_size = srcinfo->min_DCT_v_scaled_size;
      85                 : #endif
      86                 :   /* Initialize all parameters to default values */
      87               0 :   jpeg_set_defaults(dstinfo);
      88                 :   /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
      89                 :    * Fix it to get the right header markers for the image colorspace.
      90                 :    */
      91               0 :   jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
      92               0 :   dstinfo->data_precision = srcinfo->data_precision;
      93               0 :   dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
      94                 :   /* Copy the source's quantization tables. */
      95               0 :   for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
      96               0 :     if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
      97               0 :       qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
      98               0 :       if (*qtblptr == NULL)
      99               0 :         *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
     100               0 :       MEMCOPY((*qtblptr)->quantval,
     101                 :               srcinfo->quant_tbl_ptrs[tblno]->quantval,
     102                 :               SIZEOF((*qtblptr)->quantval));
     103               0 :       (*qtblptr)->sent_table = FALSE;
     104                 :     }
     105                 :   }
     106                 :   /* Copy the source's per-component info.
     107                 :    * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
     108                 :    */
     109               0 :   dstinfo->num_components = srcinfo->num_components;
     110               0 :   if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
     111               0 :     ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
     112                 :              MAX_COMPONENTS);
     113               0 :   for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
     114               0 :        ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
     115               0 :     outcomp->component_id = incomp->component_id;
     116               0 :     outcomp->h_samp_factor = incomp->h_samp_factor;
     117               0 :     outcomp->v_samp_factor = incomp->v_samp_factor;
     118               0 :     outcomp->quant_tbl_no = incomp->quant_tbl_no;
     119                 :     /* Make sure saved quantization table for component matches the qtable
     120                 :      * slot.  If not, the input file re-used this qtable slot.
     121                 :      * IJG encoder currently cannot duplicate this.
     122                 :      */
     123               0 :     tblno = outcomp->quant_tbl_no;
     124               0 :     if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
     125               0 :         srcinfo->quant_tbl_ptrs[tblno] == NULL)
     126               0 :       ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
     127               0 :     slot_quant = srcinfo->quant_tbl_ptrs[tblno];
     128               0 :     c_quant = incomp->quant_table;
     129               0 :     if (c_quant != NULL) {
     130               0 :       for (coefi = 0; coefi < DCTSIZE2; coefi++) {
     131               0 :         if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
     132               0 :           ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
     133                 :       }
     134                 :     }
     135                 :     /* Note: we do not copy the source's Huffman table assignments;
     136                 :      * instead we rely on jpeg_set_colorspace to have made a suitable choice.
     137                 :      */
     138                 :   }
     139                 :   /* Also copy JFIF version and resolution information, if available.
     140                 :    * Strictly speaking this isn't "critical" info, but it's nearly
     141                 :    * always appropriate to copy it if available.  In particular,
     142                 :    * if the application chooses to copy JFIF 1.02 extension markers from
     143                 :    * the source file, we need to copy the version to make sure we don't
     144                 :    * emit a file that has 1.02 extensions but a claimed version of 1.01.
     145                 :    * We will *not*, however, copy version info from mislabeled "2.01" files.
     146                 :    */
     147               0 :   if (srcinfo->saw_JFIF_marker) {
     148               0 :     if (srcinfo->JFIF_major_version == 1) {
     149               0 :       dstinfo->JFIF_major_version = srcinfo->JFIF_major_version;
     150               0 :       dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version;
     151                 :     }
     152               0 :     dstinfo->density_unit = srcinfo->density_unit;
     153               0 :     dstinfo->X_density = srcinfo->X_density;
     154               0 :     dstinfo->Y_density = srcinfo->Y_density;
     155                 :   }
     156               0 : }
     157                 : 
     158                 : 
     159                 : /*
     160                 :  * Master selection of compression modules for transcoding.
     161                 :  * This substitutes for jcinit.c's initialization of the full compressor.
     162                 :  */
     163                 : 
     164                 : LOCAL(void)
     165               0 : transencode_master_selection (j_compress_ptr cinfo,
     166                 :                               jvirt_barray_ptr * coef_arrays)
     167                 : {
     168                 :   /* Although we don't actually use input_components for transcoding,
     169                 :    * jcmaster.c's initial_setup will complain if input_components is 0.
     170                 :    */
     171               0 :   cinfo->input_components = 1;
     172                 :   /* Initialize master control (includes parameter checking/processing) */
     173               0 :   jinit_c_master_control(cinfo, TRUE /* transcode only */);
     174                 : 
     175                 :   /* Entropy encoding: either Huffman or arithmetic coding. */
     176               0 :   if (cinfo->arith_code) {
     177                 : #ifdef C_ARITH_CODING_SUPPORTED
     178                 :     jinit_arith_encoder(cinfo);
     179                 : #else
     180               0 :     ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
     181                 : #endif
     182                 :   } else {
     183               0 :     if (cinfo->progressive_mode) {
     184                 : #ifdef C_PROGRESSIVE_SUPPORTED
     185               0 :       jinit_phuff_encoder(cinfo);
     186                 : #else
     187                 :       ERREXIT(cinfo, JERR_NOT_COMPILED);
     188                 : #endif
     189                 :     } else
     190               0 :       jinit_huff_encoder(cinfo);
     191                 :   }
     192                 : 
     193                 :   /* We need a special coefficient buffer controller. */
     194               0 :   transencode_coef_controller(cinfo, coef_arrays);
     195                 : 
     196               0 :   jinit_marker_writer(cinfo);
     197                 : 
     198                 :   /* We can now tell the memory manager to allocate virtual arrays. */
     199               0 :   (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
     200                 : 
     201                 :   /* Write the datastream header (SOI, JFIF) immediately.
     202                 :    * Frame and scan headers are postponed till later.
     203                 :    * This lets application insert special markers after the SOI.
     204                 :    */
     205               0 :   (*cinfo->marker->write_file_header) (cinfo);
     206               0 : }
     207                 : 
     208                 : 
     209                 : /*
     210                 :  * The rest of this file is a special implementation of the coefficient
     211                 :  * buffer controller.  This is similar to jccoefct.c, but it handles only
     212                 :  * output from presupplied virtual arrays.  Furthermore, we generate any
     213                 :  * dummy padding blocks on-the-fly rather than expecting them to be present
     214                 :  * in the arrays.
     215                 :  */
     216                 : 
     217                 : /* Private buffer controller object */
     218                 : 
     219                 : typedef struct {
     220                 :   struct jpeg_c_coef_controller pub; /* public fields */
     221                 : 
     222                 :   JDIMENSION iMCU_row_num;      /* iMCU row # within image */
     223                 :   JDIMENSION mcu_ctr;           /* counts MCUs processed in current row */
     224                 :   int MCU_vert_offset;          /* counts MCU rows within iMCU row */
     225                 :   int MCU_rows_per_iMCU_row;    /* number of such rows needed */
     226                 : 
     227                 :   /* Virtual block array for each component. */
     228                 :   jvirt_barray_ptr * whole_image;
     229                 : 
     230                 :   /* Workspace for constructing dummy blocks at right/bottom edges. */
     231                 :   JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
     232                 : } my_coef_controller;
     233                 : 
     234                 : typedef my_coef_controller * my_coef_ptr;
     235                 : 
     236                 : 
     237                 : LOCAL(void)
     238               0 : start_iMCU_row (j_compress_ptr cinfo)
     239                 : /* Reset within-iMCU-row counters for a new row */
     240                 : {
     241               0 :   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
     242                 : 
     243                 :   /* In an interleaved scan, an MCU row is the same as an iMCU row.
     244                 :    * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
     245                 :    * But at the bottom of the image, process only what's left.
     246                 :    */
     247               0 :   if (cinfo->comps_in_scan > 1) {
     248               0 :     coef->MCU_rows_per_iMCU_row = 1;
     249                 :   } else {
     250               0 :     if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
     251               0 :       coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
     252                 :     else
     253               0 :       coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
     254                 :   }
     255                 : 
     256               0 :   coef->mcu_ctr = 0;
     257               0 :   coef->MCU_vert_offset = 0;
     258               0 : }
     259                 : 
     260                 : 
     261                 : /*
     262                 :  * Initialize for a processing pass.
     263                 :  */
     264                 : 
     265                 : METHODDEF(void)
     266               0 : start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
     267                 : {
     268               0 :   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
     269                 : 
     270               0 :   if (pass_mode != JBUF_CRANK_DEST)
     271               0 :     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
     272                 : 
     273               0 :   coef->iMCU_row_num = 0;
     274               0 :   start_iMCU_row(cinfo);
     275               0 : }
     276                 : 
     277                 : 
     278                 : /*
     279                 :  * Process some data.
     280                 :  * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
     281                 :  * per call, ie, v_samp_factor block rows for each component in the scan.
     282                 :  * The data is obtained from the virtual arrays and fed to the entropy coder.
     283                 :  * Returns TRUE if the iMCU row is completed, FALSE if suspended.
     284                 :  *
     285                 :  * NB: input_buf is ignored; it is likely to be a NULL pointer.
     286                 :  */
     287                 : 
     288                 : METHODDEF(boolean)
     289               0 : compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
     290                 : {
     291               0 :   my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
     292                 :   JDIMENSION MCU_col_num;       /* index of current MCU within row */
     293               0 :   JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
     294               0 :   JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
     295                 :   int blkn, ci, xindex, yindex, yoffset, blockcnt;
     296                 :   JDIMENSION start_col;
     297                 :   JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
     298                 :   JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
     299                 :   JBLOCKROW buffer_ptr;
     300                 :   jpeg_component_info *compptr;
     301                 : 
     302                 :   /* Align the virtual buffers for the components used in this scan. */
     303               0 :   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
     304               0 :     compptr = cinfo->cur_comp_info[ci];
     305               0 :     buffer[ci] = (*cinfo->mem->access_virt_barray)
     306               0 :       ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
     307               0 :        coef->iMCU_row_num * compptr->v_samp_factor,
     308               0 :        (JDIMENSION) compptr->v_samp_factor, FALSE);
     309                 :   }
     310                 : 
     311                 :   /* Loop to process one whole iMCU row */
     312               0 :   for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
     313               0 :        yoffset++) {
     314               0 :     for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
     315               0 :          MCU_col_num++) {
     316                 :       /* Construct list of pointers to DCT blocks belonging to this MCU */
     317               0 :       blkn = 0;                 /* index of current DCT block within MCU */
     318               0 :       for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
     319               0 :         compptr = cinfo->cur_comp_info[ci];
     320               0 :         start_col = MCU_col_num * compptr->MCU_width;
     321               0 :         blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
     322               0 :                                                 : compptr->last_col_width;
     323               0 :         for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
     324               0 :           if (coef->iMCU_row_num < last_iMCU_row ||
     325               0 :               yindex+yoffset < compptr->last_row_height) {
     326                 :             /* Fill in pointers to real blocks in this row */
     327               0 :             buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
     328               0 :             for (xindex = 0; xindex < blockcnt; xindex++)
     329               0 :               MCU_buffer[blkn++] = buffer_ptr++;
     330                 :           } else {
     331                 :             /* At bottom of image, need a whole row of dummy blocks */
     332               0 :             xindex = 0;
     333                 :           }
     334                 :           /* Fill in any dummy blocks needed in this row.
     335                 :            * Dummy blocks are filled in the same way as in jccoefct.c:
     336                 :            * all zeroes in the AC entries, DC entries equal to previous
     337                 :            * block's DC value.  The init routine has already zeroed the
     338                 :            * AC entries, so we need only set the DC entries correctly.
     339                 :            */
     340               0 :           for (; xindex < compptr->MCU_width; xindex++) {
     341               0 :             MCU_buffer[blkn] = coef->dummy_buffer[blkn];
     342               0 :             MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
     343               0 :             blkn++;
     344                 :           }
     345                 :         }
     346                 :       }
     347                 :       /* Try to write the MCU. */
     348               0 :       if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
     349                 :         /* Suspension forced; update state counters and exit */
     350               0 :         coef->MCU_vert_offset = yoffset;
     351               0 :         coef->mcu_ctr = MCU_col_num;
     352               0 :         return FALSE;
     353                 :       }
     354                 :     }
     355                 :     /* Completed an MCU row, but perhaps not an iMCU row */
     356               0 :     coef->mcu_ctr = 0;
     357                 :   }
     358                 :   /* Completed the iMCU row, advance counters for next one */
     359               0 :   coef->iMCU_row_num++;
     360               0 :   start_iMCU_row(cinfo);
     361               0 :   return TRUE;
     362                 : }
     363                 : 
     364                 : 
     365                 : /*
     366                 :  * Initialize coefficient buffer controller.
     367                 :  *
     368                 :  * Each passed coefficient array must be the right size for that
     369                 :  * coefficient: width_in_blocks wide and height_in_blocks high,
     370                 :  * with unitheight at least v_samp_factor.
     371                 :  */
     372                 : 
     373                 : LOCAL(void)
     374               0 : transencode_coef_controller (j_compress_ptr cinfo,
     375                 :                              jvirt_barray_ptr * coef_arrays)
     376                 : {
     377                 :   my_coef_ptr coef;
     378                 :   JBLOCKROW buffer;
     379                 :   int i;
     380                 : 
     381               0 :   coef = (my_coef_ptr)
     382               0 :     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
     383                 :                                 SIZEOF(my_coef_controller));
     384               0 :   cinfo->coef = (struct jpeg_c_coef_controller *) coef;
     385               0 :   coef->pub.start_pass = start_pass_coef;
     386               0 :   coef->pub.compress_data = compress_output;
     387                 : 
     388                 :   /* Save pointer to virtual arrays */
     389               0 :   coef->whole_image = coef_arrays;
     390                 : 
     391                 :   /* Allocate and pre-zero space for dummy DCT blocks. */
     392               0 :   buffer = (JBLOCKROW)
     393               0 :     (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
     394                 :                                 C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
     395               0 :   jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
     396               0 :   for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
     397               0 :     coef->dummy_buffer[i] = buffer + i;
     398                 :   }
     399               0 : }

Generated by: LCOV version 1.7