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

       1                 : /*
       2                 :  * jdatasrc.c
       3                 :  *
       4                 :  * Copyright (C) 1994-1996, Thomas G. Lane.
       5                 :  * Modified 2009-2010 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 decompression data source routines for the case of
      10                 :  * reading JPEG data from memory or from a file (or any stdio stream).
      11                 :  * While these routines are sufficient for most applications,
      12                 :  * some will want to use a different source manager.
      13                 :  * IMPORTANT: we assume that fread() will correctly transcribe an array of
      14                 :  * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
      15                 :  * than 8 bits on your machine, you may need to do some tweaking.
      16                 :  */
      17                 : 
      18                 : /* this is not a core library module, so it doesn't define JPEG_INTERNALS */
      19                 : #include "jinclude.h"
      20                 : #include "jpeglib.h"
      21                 : #include "jerror.h"
      22                 : 
      23                 : 
      24                 : /* Expanded data source object for stdio input */
      25                 : 
      26                 : typedef struct {
      27                 :   struct jpeg_source_mgr pub;   /* public fields */
      28                 : 
      29                 :   FILE * infile;                /* source stream */
      30                 :   JOCTET * buffer;              /* start of buffer */
      31                 :   boolean start_of_file;        /* have we gotten any data yet? */
      32                 : } my_source_mgr;
      33                 : 
      34                 : typedef my_source_mgr * my_src_ptr;
      35                 : 
      36                 : #define INPUT_BUF_SIZE  4096    /* choose an efficiently fread'able size */
      37                 : 
      38                 : 
      39                 : /*
      40                 :  * Initialize source --- called by jpeg_read_header
      41                 :  * before any data is actually read.
      42                 :  */
      43                 : 
      44                 : METHODDEF(void)
      45               0 : init_source (j_decompress_ptr cinfo)
      46                 : {
      47               0 :   my_src_ptr src = (my_src_ptr) cinfo->src;
      48                 : 
      49                 :   /* We reset the empty-input-file flag for each image,
      50                 :    * but we don't clear the input buffer.
      51                 :    * This is correct behavior for reading a series of images from one source.
      52                 :    */
      53               0 :   src->start_of_file = TRUE;
      54               0 : }
      55                 : 
      56                 : #if JPEG_LIB_VERSION >= 80
      57                 : METHODDEF(void)
      58                 : init_mem_source (j_decompress_ptr cinfo)
      59                 : {
      60                 :   /* no work necessary here */
      61                 : }
      62                 : #endif
      63                 : 
      64                 : 
      65                 : /*
      66                 :  * Fill the input buffer --- called whenever buffer is emptied.
      67                 :  *
      68                 :  * In typical applications, this should read fresh data into the buffer
      69                 :  * (ignoring the current state of next_input_byte & bytes_in_buffer),
      70                 :  * reset the pointer & count to the start of the buffer, and return TRUE
      71                 :  * indicating that the buffer has been reloaded.  It is not necessary to
      72                 :  * fill the buffer entirely, only to obtain at least one more byte.
      73                 :  *
      74                 :  * There is no such thing as an EOF return.  If the end of the file has been
      75                 :  * reached, the routine has a choice of ERREXIT() or inserting fake data into
      76                 :  * the buffer.  In most cases, generating a warning message and inserting a
      77                 :  * fake EOI marker is the best course of action --- this will allow the
      78                 :  * decompressor to output however much of the image is there.  However,
      79                 :  * the resulting error message is misleading if the real problem is an empty
      80                 :  * input file, so we handle that case specially.
      81                 :  *
      82                 :  * In applications that need to be able to suspend compression due to input
      83                 :  * not being available yet, a FALSE return indicates that no more data can be
      84                 :  * obtained right now, but more may be forthcoming later.  In this situation,
      85                 :  * the decompressor will return to its caller (with an indication of the
      86                 :  * number of scanlines it has read, if any).  The application should resume
      87                 :  * decompression after it has loaded more data into the input buffer.  Note
      88                 :  * that there are substantial restrictions on the use of suspension --- see
      89                 :  * the documentation.
      90                 :  *
      91                 :  * When suspending, the decompressor will back up to a convenient restart point
      92                 :  * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
      93                 :  * indicate where the restart point will be if the current call returns FALSE.
      94                 :  * Data beyond this point must be rescanned after resumption, so move it to
      95                 :  * the front of the buffer rather than discarding it.
      96                 :  */
      97                 : 
      98                 : METHODDEF(boolean)
      99               0 : fill_input_buffer (j_decompress_ptr cinfo)
     100                 : {
     101               0 :   my_src_ptr src = (my_src_ptr) cinfo->src;
     102                 :   size_t nbytes;
     103                 : 
     104               0 :   nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);
     105                 : 
     106               0 :   if (nbytes <= 0) {
     107               0 :     if (src->start_of_file)  /* Treat empty input file as fatal error */
     108               0 :       ERREXIT(cinfo, JERR_INPUT_EMPTY);
     109               0 :     WARNMS(cinfo, JWRN_JPEG_EOF);
     110                 :     /* Insert a fake EOI marker */
     111               0 :     src->buffer[0] = (JOCTET) 0xFF;
     112               0 :     src->buffer[1] = (JOCTET) JPEG_EOI;
     113               0 :     nbytes = 2;
     114                 :   }
     115                 : 
     116               0 :   src->pub.next_input_byte = src->buffer;
     117               0 :   src->pub.bytes_in_buffer = nbytes;
     118               0 :   src->start_of_file = FALSE;
     119                 : 
     120               0 :   return TRUE;
     121                 : }
     122                 : 
     123                 : #if JPEG_LIB_VERSION >= 80
     124                 : METHODDEF(boolean)
     125                 : fill_mem_input_buffer (j_decompress_ptr cinfo)
     126                 : {
     127                 :   static JOCTET mybuffer[4];
     128                 : 
     129                 :   /* The whole JPEG data is expected to reside in the supplied memory
     130                 :    * buffer, so any request for more data beyond the given buffer size
     131                 :    * is treated as an error.
     132                 :    */
     133                 :   WARNMS(cinfo, JWRN_JPEG_EOF);
     134                 :   /* Insert a fake EOI marker */
     135                 :   mybuffer[0] = (JOCTET) 0xFF;
     136                 :   mybuffer[1] = (JOCTET) JPEG_EOI;
     137                 : 
     138                 :   cinfo->src->next_input_byte = mybuffer;
     139                 :   cinfo->src->bytes_in_buffer = 2;
     140                 : 
     141                 :   return TRUE;
     142                 : }
     143                 : #endif
     144                 : 
     145                 : 
     146                 : /*
     147                 :  * Skip data --- used to skip over a potentially large amount of
     148                 :  * uninteresting data (such as an APPn marker).
     149                 :  *
     150                 :  * Writers of suspendable-input applications must note that skip_input_data
     151                 :  * is not granted the right to give a suspension return.  If the skip extends
     152                 :  * beyond the data currently in the buffer, the buffer can be marked empty so
     153                 :  * that the next read will cause a fill_input_buffer call that can suspend.
     154                 :  * Arranging for additional bytes to be discarded before reloading the input
     155                 :  * buffer is the application writer's problem.
     156                 :  */
     157                 : 
     158                 : METHODDEF(void)
     159               0 : skip_input_data (j_decompress_ptr cinfo, long num_bytes)
     160                 : {
     161               0 :   struct jpeg_source_mgr * src = cinfo->src;
     162                 : 
     163                 :   /* Just a dumb implementation for now.  Could use fseek() except
     164                 :    * it doesn't work on pipes.  Not clear that being smart is worth
     165                 :    * any trouble anyway --- large skips are infrequent.
     166                 :    */
     167               0 :   if (num_bytes > 0) {
     168               0 :     while (num_bytes > (long) src->bytes_in_buffer) {
     169               0 :       num_bytes -= (long) src->bytes_in_buffer;
     170               0 :       (void) (*src->fill_input_buffer) (cinfo);
     171                 :       /* note we assume that fill_input_buffer will never return FALSE,
     172                 :        * so suspension need not be handled.
     173                 :        */
     174                 :     }
     175               0 :     src->next_input_byte += (size_t) num_bytes;
     176               0 :     src->bytes_in_buffer -= (size_t) num_bytes;
     177                 :   }
     178               0 : }
     179                 : 
     180                 : 
     181                 : /*
     182                 :  * An additional method that can be provided by data source modules is the
     183                 :  * resync_to_restart method for error recovery in the presence of RST markers.
     184                 :  * For the moment, this source module just uses the default resync method
     185                 :  * provided by the JPEG library.  That method assumes that no backtracking
     186                 :  * is possible.
     187                 :  */
     188                 : 
     189                 : 
     190                 : /*
     191                 :  * Terminate source --- called by jpeg_finish_decompress
     192                 :  * after all data has been read.  Often a no-op.
     193                 :  *
     194                 :  * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
     195                 :  * application must deal with any cleanup that should happen even
     196                 :  * for error exit.
     197                 :  */
     198                 : 
     199                 : METHODDEF(void)
     200               0 : term_source (j_decompress_ptr cinfo)
     201                 : {
     202                 :   /* no work necessary here */
     203               0 : }
     204                 : 
     205                 : 
     206                 : /*
     207                 :  * Prepare for input from a stdio stream.
     208                 :  * The caller must have already opened the stream, and is responsible
     209                 :  * for closing it after finishing decompression.
     210                 :  */
     211                 : 
     212                 : GLOBAL(void)
     213               0 : jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
     214                 : {
     215                 :   my_src_ptr src;
     216                 : 
     217                 :   /* The source object and input buffer are made permanent so that a series
     218                 :    * of JPEG images can be read from the same file by calling jpeg_stdio_src
     219                 :    * only before the first one.  (If we discarded the buffer at the end of
     220                 :    * one image, we'd likely lose the start of the next one.)
     221                 :    * This makes it unsafe to use this manager and a different source
     222                 :    * manager serially with the same JPEG object.  Caveat programmer.
     223                 :    */
     224               0 :   if (cinfo->src == NULL) {  /* first time for this JPEG object? */
     225               0 :     cinfo->src = (struct jpeg_source_mgr *)
     226               0 :       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
     227                 :                                   SIZEOF(my_source_mgr));
     228               0 :     src = (my_src_ptr) cinfo->src;
     229               0 :     src->buffer = (JOCTET *)
     230               0 :       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
     231                 :                                   INPUT_BUF_SIZE * SIZEOF(JOCTET));
     232                 :   }
     233                 : 
     234               0 :   src = (my_src_ptr) cinfo->src;
     235               0 :   src->pub.init_source = init_source;
     236               0 :   src->pub.fill_input_buffer = fill_input_buffer;
     237               0 :   src->pub.skip_input_data = skip_input_data;
     238               0 :   src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
     239               0 :   src->pub.term_source = term_source;
     240               0 :   src->infile = infile;
     241               0 :   src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
     242               0 :   src->pub.next_input_byte = NULL; /* until buffer loaded */
     243               0 : }
     244                 : 
     245                 : 
     246                 : #if JPEG_LIB_VERSION >= 80
     247                 : /*
     248                 :  * Prepare for input from a supplied memory buffer.
     249                 :  * The buffer must contain the whole JPEG data.
     250                 :  */
     251                 : 
     252                 : GLOBAL(void)
     253                 : jpeg_mem_src (j_decompress_ptr cinfo,
     254                 :               unsigned char * inbuffer, unsigned long insize)
     255                 : {
     256                 :   struct jpeg_source_mgr * src;
     257                 : 
     258                 :   if (inbuffer == NULL || insize == 0)  /* Treat empty input as fatal error */
     259                 :     ERREXIT(cinfo, JERR_INPUT_EMPTY);
     260                 : 
     261                 :   /* The source object is made permanent so that a series of JPEG images
     262                 :    * can be read from the same buffer by calling jpeg_mem_src only before
     263                 :    * the first one.
     264                 :    */
     265                 :   if (cinfo->src == NULL) {  /* first time for this JPEG object? */
     266                 :     cinfo->src = (struct jpeg_source_mgr *)
     267                 :       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
     268                 :                                   SIZEOF(struct jpeg_source_mgr));
     269                 :   }
     270                 : 
     271                 :   src = cinfo->src;
     272                 :   src->init_source = init_mem_source;
     273                 :   src->fill_input_buffer = fill_mem_input_buffer;
     274                 :   src->skip_input_data = skip_input_data;
     275                 :   src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
     276                 :   src->term_source = term_source;
     277                 :   src->bytes_in_buffer = (size_t) insize;
     278                 :   src->next_input_byte = (JOCTET *) inbuffer;
     279                 : }
     280                 : #endif

Generated by: LCOV version 1.7