00001 /* 00002 * jdatasrc.cxx 00003 * 00004 * Copyright (C) 1994-1996, Thomas G. Lane. 00005 * This file is part of the Independent JPEG Group's software. 00006 * For conditions of distribution and use, see the accompanying README file. 00007 * 00008 * This file contains decompression data source routines for the case of 00009 * reading JPEG data from a file (or any stdio stream). While these routines 00010 * are sufficient for most applications, some will want to use a different 00011 * source manager. 00012 * IMPORTANT: we assume that fread() will correctly transcribe an array of 00013 * JOCTETs from 8-bit-wide elements on external storage. If char is wider 00014 * than 8 bits on your machine, you may need to do some tweaking. 00015 */ 00016 00017 /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ 00018 00019 /* Expanded data source object for stdio input */ 00020 00021 extern "C" { 00022 typedef boolean(*boolean_jpeg_decompress_struct)(jpeg_decompress_struct*); 00023 typedef void(*void_jpeg_decompress_struct)(jpeg_decompress_struct*); 00024 typedef void(*void_jpeg_decompress_struct_long)(jpeg_decompress_struct*,long); 00025 } 00026 00027 typedef struct { 00028 struct jpeg_source_mgr pub; /* public fields */ 00029 00030 std::ifstream *infile; /* source stream */ 00031 JOCTET * buffer; /* start of buffer */ 00032 boolean start_of_file; /* have we gotten any data yet? */ 00033 00034 gdcm::JPEGFragment *frag; 00035 size_t bytes_read; 00036 } my_source_mgr; 00037 00038 typedef my_source_mgr * my_src_ptr; 00039 00040 #define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ 00041 00042 00043 /* 00044 * Initialize source --- called by jpeg_read_header 00045 * before any data is actually read. 00046 */ 00047 00048 METHODDEF(void) 00049 init_source (j_decompress_ptr cinfo) 00050 { 00051 my_src_ptr src = (my_src_ptr) cinfo->src; 00052 00053 /* We reset the empty-input-file flag for each image, 00054 * but we don't clear the input buffer. 00055 * This is correct behavior for reading a series of images from one source. 00056 */ 00057 src->start_of_file = TRUE; 00058 } 00059 00060 00061 /* 00062 * Fill the input buffer --- called whenever buffer is emptied. 00063 * 00064 * In typical applications, this should read fresh data into the buffer 00065 * (ignoring the current state of next_input_byte & bytes_in_buffer), 00066 * reset the pointer & count to the start of the buffer, and return TRUE 00067 * indicating that the buffer has been reloaded. It is not necessary to 00068 * fill the buffer entirely, only to obtain at least one more byte. 00069 * 00070 * There is no such thing as an EOF return. If the end of the file has been 00071 * reached, the routine has a choice of ERREXIT() or inserting fake data into 00072 * the buffer. In most cases, generating a warning message and inserting a 00073 * fake EOI marker is the best course of action --- this will allow the 00074 * decompressor to output however much of the image is there. However, 00075 * the resulting error message is misleading if the real problem is an empty 00076 * input file, so we handle that case specially. 00077 * 00078 * In applications that need to be able to suspend compression due to input 00079 * not being available yet, a FALSE return indicates that no more data can be 00080 * obtained right now, but more may be forthcoming later. In this situation, 00081 * the decompressor will return to its caller (with an indication of the 00082 * number of scanlines it has read, if any). The application should resume 00083 * decompression after it has loaded more data into the input buffer. Note 00084 * that there are substantial restrictions on the use of suspension --- see 00085 * the documentation. 00086 * 00087 * When suspending, the decompressor will back up to a convenient restart point 00088 * (typically the start of the current MCU). next_input_byte & bytes_in_buffer 00089 * indicate where the restart point will be if the current call returns FALSE. 00090 * Data beyond this point must be rescanned after resumption, so move it to 00091 * the front of the buffer rather than discarding it. 00092 */ 00093 00094 METHODDEF(boolean) 00095 fill_input_buffer (j_decompress_ptr cinfo) 00096 { 00097 my_src_ptr src = (my_src_ptr) cinfo->src; 00098 00099 if( src->bytes_read == src->frag->GetLength() ) 00100 { 00101 // Start the I/O suspension simply by returning false here: 00102 return FALSE; 00103 } 00104 00105 size_t input_buf_size = INPUT_BUF_SIZE; 00106 if( (src->bytes_read + INPUT_BUF_SIZE) > src->frag->GetLength() ) 00107 { 00108 input_buf_size = src->frag->GetLength() - src->bytes_read; 00109 } 00110 00111 src->infile->read( (char*)src->buffer, input_buf_size); 00112 size_t nbytes = src->infile->gcount(); 00113 00114 if (nbytes <= 0) { 00115 if (src->start_of_file) /* Treat empty input file as fatal error */ 00116 ERREXIT(cinfo, JERR_INPUT_EMPTY); 00117 WARNMS(cinfo, JWRN_JPEG_EOF); 00118 /* Insert a fake EOI marker */ 00119 src->buffer[0] = (JOCTET) 0xFF; 00120 src->buffer[1] = (JOCTET) JPEG_EOI; 00121 nbytes = 2; 00122 } 00123 00124 src->pub.next_input_byte = src->buffer; 00125 src->pub.bytes_in_buffer = nbytes; 00126 src->start_of_file = FALSE; 00127 src->bytes_read += nbytes; 00128 00129 return TRUE; 00130 } 00131 00132 00133 /* 00134 * Skip data --- used to skip over a potentially large amount of 00135 * uninteresting data (such as an APPn marker). 00136 * 00137 * Writers of suspendable-input applications must note that skip_input_data 00138 * is not granted the right to give a suspension return. If the skip extends 00139 * beyond the data currently in the buffer, the buffer can be marked empty so 00140 * that the next read will cause a fill_input_buffer call that can suspend. 00141 * Arranging for additional bytes to be discarded before reloading the input 00142 * buffer is the application writer's problem. 00143 */ 00144 00145 METHODDEF(void) 00146 skip_input_data (j_decompress_ptr cinfo, long num_bytes) 00147 { 00148 my_src_ptr src = (my_src_ptr) cinfo->src; 00149 00150 /* Just a dumb implementation for now. Could use fseek() except 00151 * it doesn't work on pipes. Not clear that being smart is worth 00152 * any trouble anyway --- large skips are infrequent. 00153 */ 00154 if (num_bytes > 0) { 00155 while (num_bytes > (long) src->pub.bytes_in_buffer) { 00156 num_bytes -= (long) src->pub.bytes_in_buffer; 00157 (void) fill_input_buffer(cinfo); 00158 /* note we assume that fill_input_buffer will never return FALSE, 00159 * so suspension need not be handled. 00160 */ 00161 } 00162 src->pub.next_input_byte += (size_t) num_bytes; 00163 src->pub.bytes_in_buffer -= (size_t) num_bytes; 00164 } 00165 } 00166 00167 00168 /* 00169 * An additional method that can be provided by data source modules is the 00170 * resync_to_restart method for error recovery in the presence of RST markers. 00171 * For the moment, this source module just uses the default resync method 00172 * provided by the JPEG library. That method assumes that no backtracking 00173 * is possible. 00174 */ 00175 00176 00177 /* 00178 * Terminate source --- called by jpeg_finish_decompress 00179 * after all data has been read. Often a no-op. 00180 * 00181 * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding 00182 * application must deal with any cleanup that should happen even 00183 * for error exit. 00184 */ 00185 00186 METHODDEF(void) 00187 term_source (j_decompress_ptr cinfo) 00188 { 00189 cinfo=cinfo; 00190 /* no work necessary here */ 00191 } 00192 00193 00194 /* 00195 * Prepare for input from a stdio stream. 00196 * The caller must have already opened the stream, and is responsible 00197 * for closing it after finishing decompression. 00198 */ 00199 00200 GLOBAL(void) 00201 jpeg_stdio_src (j_decompress_ptr cinfo, std::ifstream * infile, gdcm::JPEGFragment *frag, int flag) 00202 { 00203 my_src_ptr src; 00204 00205 /* The source object and input buffer are made permanent so that a series 00206 * of JPEG images can be read from the same file by calling jpeg_stdio_src 00207 * only before the first one. (If we discarded the buffer at the end of 00208 * one image, we'd likely lose the start of the next one.) 00209 * This makes it unsafe to use this manager and a different source 00210 * manager serially with the same JPEG object. Caveat programmer. 00211 */ 00212 if (cinfo->src == NULL) { /* first time for this JPEG object? */ 00213 cinfo->src = (struct jpeg_source_mgr *) 00214 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 00215 SIZEOF(my_source_mgr)); 00216 src = (my_src_ptr) cinfo->src; 00217 src->buffer = (JOCTET *) 00218 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 00219 INPUT_BUF_SIZE * SIZEOF(JOCTET)); 00220 } 00221 00222 src = (my_src_ptr) cinfo->src; 00223 src->pub.init_source = reinterpret_cast<void_jpeg_decompress_struct>(init_source); 00224 src->pub.fill_input_buffer = reinterpret_cast<boolean_jpeg_decompress_struct>(fill_input_buffer); 00225 src->pub.skip_input_data = reinterpret_cast<void_jpeg_decompress_struct_long>(skip_input_data); 00226 src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ 00227 src->pub.term_source = reinterpret_cast<void_jpeg_decompress_struct>(term_source); 00228 src->infile = infile; 00229 00230 // Need to setup a new buffer, clean bytes_in_buffer and next_input_byte 00231 if( flag ) 00232 { 00233 src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ 00234 src->pub.next_input_byte = NULL; /* until buffer loaded */ 00235 } 00236 //only upate the new fragment, valid for both 'flag' value 00237 src->frag = frag; 00238 src->bytes_read = 0; 00239 }