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