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

       1                 : /*
       2                 :  * jdtrans.c
       3                 :  *
       4                 :  * Copyright (C) 1995-1997, Thomas G. Lane.
       5                 :  * This file is part of the Independent JPEG Group's software.
       6                 :  * For conditions of distribution and use, see the accompanying README file.
       7                 :  *
       8                 :  * This file contains library routines for transcoding decompression,
       9                 :  * that is, reading raw DCT coefficient arrays from an input JPEG file.
      10                 :  * The routines in jdapimin.c will also be needed by a transcoder.
      11                 :  */
      12                 : 
      13                 : #define JPEG_INTERNALS
      14                 : #include "jinclude.h"
      15                 : #include "jpeglib.h"
      16                 : 
      17                 : 
      18                 : /* Forward declarations */
      19                 : LOCAL(void) transdecode_master_selection JPP((j_decompress_ptr cinfo));
      20                 : 
      21                 : 
      22                 : /*
      23                 :  * Read the coefficient arrays from a JPEG file.
      24                 :  * jpeg_read_header must be completed before calling this.
      25                 :  *
      26                 :  * The entire image is read into a set of virtual coefficient-block arrays,
      27                 :  * one per component.  The return value is a pointer to the array of
      28                 :  * virtual-array descriptors.  These can be manipulated directly via the
      29                 :  * JPEG memory manager, or handed off to jpeg_write_coefficients().
      30                 :  * To release the memory occupied by the virtual arrays, call
      31                 :  * jpeg_finish_decompress() when done with the data.
      32                 :  *
      33                 :  * An alternative usage is to simply obtain access to the coefficient arrays
      34                 :  * during a buffered-image-mode decompression operation.  This is allowed
      35                 :  * after any jpeg_finish_output() call.  The arrays can be accessed until
      36                 :  * jpeg_finish_decompress() is called.  (Note that any call to the library
      37                 :  * may reposition the arrays, so don't rely on access_virt_barray() results
      38                 :  * to stay valid across library calls.)
      39                 :  *
      40                 :  * Returns NULL if suspended.  This case need be checked only if
      41                 :  * a suspending data source is used.
      42                 :  */
      43                 : 
      44                 : GLOBAL(jvirt_barray_ptr *)
      45               0 : jpeg_read_coefficients (j_decompress_ptr cinfo)
      46                 : {
      47               0 :   if (cinfo->global_state == DSTATE_READY) {
      48                 :     /* First call: initialize active modules */
      49               0 :     transdecode_master_selection(cinfo);
      50               0 :     cinfo->global_state = DSTATE_RDCOEFS;
      51                 :   }
      52               0 :   if (cinfo->global_state == DSTATE_RDCOEFS) {
      53                 :     /* Absorb whole file into the coef buffer */
      54                 :     for (;;) {
      55                 :       int retcode;
      56                 :       /* Call progress monitor hook if present */
      57               0 :       if (cinfo->progress != NULL)
      58               0 :         (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
      59                 :       /* Absorb some more input */
      60               0 :       retcode = (*cinfo->inputctl->consume_input) (cinfo);
      61               0 :       if (retcode == JPEG_SUSPENDED)
      62               0 :         return NULL;
      63               0 :       if (retcode == JPEG_REACHED_EOI)
      64                 :         break;
      65                 :       /* Advance progress counter if appropriate */
      66               0 :       if (cinfo->progress != NULL &&
      67               0 :           (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
      68               0 :         if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
      69                 :           /* startup underestimated number of scans; ratchet up one scan */
      70               0 :           cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
      71                 :         }
      72                 :       }
      73               0 :     }
      74                 :     /* Set state so that jpeg_finish_decompress does the right thing */
      75               0 :     cinfo->global_state = DSTATE_STOPPING;
      76                 :   }
      77                 :   /* At this point we should be in state DSTATE_STOPPING if being used
      78                 :    * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access
      79                 :    * to the coefficients during a full buffered-image-mode decompression.
      80                 :    */
      81               0 :   if ((cinfo->global_state == DSTATE_STOPPING ||
      82               0 :        cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) {
      83               0 :     return cinfo->coef->coef_arrays;
      84                 :   }
      85                 :   /* Oops, improper usage */
      86               0 :   ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
      87               0 :   return NULL;                  /* keep compiler happy */
      88                 : }
      89                 : 
      90                 : 
      91                 : /*
      92                 :  * Master selection of decompression modules for transcoding.
      93                 :  * This substitutes for jdmaster.c's initialization of the full decompressor.
      94                 :  */
      95                 : 
      96                 : LOCAL(void)
      97               0 : transdecode_master_selection (j_decompress_ptr cinfo)
      98                 : {
      99                 :   /* This is effectively a buffered-image operation. */
     100               0 :   cinfo->buffered_image = TRUE;
     101                 : 
     102                 : #if JPEG_LIB_VERSION >= 80
     103                 :   /* Compute output image dimensions and related values. */
     104                 :   jpeg_core_output_dimensions(cinfo);
     105                 : #endif
     106                 : 
     107                 :   /* Entropy decoding: either Huffman or arithmetic coding. */
     108               0 :   if (cinfo->arith_code) {
     109                 : #ifdef D_ARITH_CODING_SUPPORTED
     110                 :     jinit_arith_decoder(cinfo);
     111                 : #else
     112               0 :     ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
     113                 : #endif
     114                 :   } else {
     115               0 :     if (cinfo->progressive_mode) {
     116                 : #ifdef D_PROGRESSIVE_SUPPORTED
     117               0 :       jinit_phuff_decoder(cinfo);
     118                 : #else
     119                 :       ERREXIT(cinfo, JERR_NOT_COMPILED);
     120                 : #endif
     121                 :     } else
     122               0 :       jinit_huff_decoder(cinfo);
     123                 :   }
     124                 : 
     125                 :   /* Always get a full-image coefficient buffer. */
     126               0 :   jinit_d_coef_controller(cinfo, TRUE);
     127                 : 
     128                 :   /* We can now tell the memory manager to allocate virtual arrays. */
     129               0 :   (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
     130                 : 
     131                 :   /* Initialize input side of decompressor to consume first scan. */
     132               0 :   (*cinfo->inputctl->start_input_pass) (cinfo);
     133                 : 
     134                 :   /* Initialize progress monitoring. */
     135               0 :   if (cinfo->progress != NULL) {
     136                 :     int nscans;
     137                 :     /* Estimate number of scans to set pass_limit. */
     138               0 :     if (cinfo->progressive_mode) {
     139                 :       /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
     140               0 :       nscans = 2 + 3 * cinfo->num_components;
     141               0 :     } else if (cinfo->inputctl->has_multiple_scans) {
     142                 :       /* For a nonprogressive multiscan file, estimate 1 scan per component. */
     143               0 :       nscans = cinfo->num_components;
     144                 :     } else {
     145               0 :       nscans = 1;
     146                 :     }
     147               0 :     cinfo->progress->pass_counter = 0L;
     148               0 :     cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
     149               0 :     cinfo->progress->completed_passes = 0;
     150               0 :     cinfo->progress->total_passes = 1;
     151                 :   }
     152               0 : }

Generated by: LCOV version 1.7