/src/libjpeg-turbo/jdatasrc.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * jdatasrc.c |
3 | | * |
4 | | * This file was part of the Independent JPEG Group's software: |
5 | | * Copyright (C) 1994-1996, Thomas G. Lane. |
6 | | * Modified 2009-2011 by Guido Vollbeding. |
7 | | * libjpeg-turbo Modifications: |
8 | | * Copyright (C) 2013, 2016, 2022, D. R. Commander. |
9 | | * For conditions of distribution and use, see the accompanying README.ijg |
10 | | * file. |
11 | | * |
12 | | * This file contains decompression data source routines for the case of |
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. |
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 { |
30 | | struct jpeg_source_mgr pub; /* public fields */ |
31 | | |
32 | | FILE *infile; /* source stream */ |
33 | | JOCTET *buffer; /* start of buffer */ |
34 | | boolean start_of_file; /* have we gotten any data yet? */ |
35 | | } my_source_mgr; |
36 | | |
37 | | typedef my_source_mgr *my_src_ptr; |
38 | | |
39 | 0 | #define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ |
40 | | |
41 | | |
42 | | /* |
43 | | * Initialize source --- called by jpeg_read_header |
44 | | * before any data is actually read. |
45 | | */ |
46 | | |
47 | | METHODDEF(void) |
48 | | init_source(j_decompress_ptr cinfo) |
49 | 0 | { |
50 | 0 | my_src_ptr src = (my_src_ptr)cinfo->src; |
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 | 0 | src->start_of_file = TRUE; |
57 | 0 | } |
58 | | |
59 | | METHODDEF(void) |
60 | | init_mem_source(j_decompress_ptr cinfo) |
61 | 0 | { |
62 | | /* no work necessary here */ |
63 | 0 | } |
64 | | |
65 | | |
66 | | /* |
67 | | * Fill the input buffer --- called whenever buffer is emptied. |
68 | | * |
69 | | * In typical applications, this should read fresh data into the buffer |
70 | | * (ignoring the current state of next_input_byte & bytes_in_buffer), |
71 | | * reset the pointer & count to the start of the buffer, and return TRUE |
72 | | * indicating that the buffer has been reloaded. It is not necessary to |
73 | | * fill the buffer entirely, only to obtain at least one more byte. |
74 | | * |
75 | | * There is no such thing as an EOF return. If the end of the file has been |
76 | | * reached, the routine has a choice of ERREXIT() or inserting fake data into |
77 | | * the buffer. In most cases, generating a warning message and inserting a |
78 | | * fake EOI marker is the best course of action --- this will allow the |
79 | | * decompressor to output however much of the image is there. However, |
80 | | * the resulting error message is misleading if the real problem is an empty |
81 | | * input file, so we handle that case specially. |
82 | | * |
83 | | * In applications that need to be able to suspend compression due to input |
84 | | * not being available yet, a FALSE return indicates that no more data can be |
85 | | * obtained right now, but more may be forthcoming later. In this situation, |
86 | | * the decompressor will return to its caller (with an indication of the |
87 | | * number of scanlines it has read, if any). The application should resume |
88 | | * decompression after it has loaded more data into the input buffer. Note |
89 | | * that there are substantial restrictions on the use of suspension --- see |
90 | | * the documentation. |
91 | | * |
92 | | * When suspending, the decompressor will back up to a convenient restart point |
93 | | * (typically the start of the current MCU). next_input_byte & bytes_in_buffer |
94 | | * indicate where the restart point will be if the current call returns FALSE. |
95 | | * Data beyond this point must be rescanned after resumption, so move it to |
96 | | * the front of the buffer rather than discarding it. |
97 | | */ |
98 | | |
99 | | METHODDEF(boolean) |
100 | | fill_input_buffer(j_decompress_ptr cinfo) |
101 | 0 | { |
102 | 0 | my_src_ptr src = (my_src_ptr)cinfo->src; |
103 | 0 | size_t nbytes; |
104 | |
|
105 | 0 | nbytes = fread(src->buffer, 1, INPUT_BUF_SIZE, src->infile); |
106 | |
|
107 | 0 | if (nbytes <= 0) { |
108 | 0 | if (src->start_of_file) /* Treat empty input file as fatal error */ |
109 | 0 | ERREXIT(cinfo, JERR_INPUT_EMPTY); |
110 | 0 | WARNMS(cinfo, JWRN_JPEG_EOF); |
111 | | /* Insert a fake EOI marker */ |
112 | 0 | src->buffer[0] = (JOCTET)0xFF; |
113 | 0 | src->buffer[1] = (JOCTET)JPEG_EOI; |
114 | 0 | nbytes = 2; |
115 | 0 | } |
116 | |
|
117 | 0 | src->pub.next_input_byte = src->buffer; |
118 | 0 | src->pub.bytes_in_buffer = nbytes; |
119 | 0 | src->start_of_file = FALSE; |
120 | |
|
121 | 0 | return TRUE; |
122 | 0 | } |
123 | | |
124 | | METHODDEF(boolean) |
125 | | fill_mem_input_buffer(j_decompress_ptr cinfo) |
126 | 0 | { |
127 | 0 | static const JOCTET mybuffer[4] = { |
128 | 0 | (JOCTET)0xFF, (JOCTET)JPEG_EOI, 0, 0 |
129 | 0 | }; |
130 | | |
131 | | /* The whole JPEG data is expected to reside in the supplied memory |
132 | | * buffer, so any request for more data beyond the given buffer size |
133 | | * is treated as an error. |
134 | | */ |
135 | 0 | WARNMS(cinfo, JWRN_JPEG_EOF); |
136 | | |
137 | | /* Insert a fake EOI marker */ |
138 | |
|
139 | 0 | cinfo->src->next_input_byte = mybuffer; |
140 | 0 | cinfo->src->bytes_in_buffer = 2; |
141 | |
|
142 | 0 | return TRUE; |
143 | 0 | } |
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 | | skip_input_data(j_decompress_ptr cinfo, long num_bytes) |
160 | 0 | { |
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 | 0 | } |
175 | 0 | src->next_input_byte += (size_t)num_bytes; |
176 | 0 | src->bytes_in_buffer -= (size_t)num_bytes; |
177 | 0 | } |
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 | | term_source(j_decompress_ptr cinfo) |
201 | 0 | { |
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 | | jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile) |
214 | 0 | { |
215 | 0 | 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 | | */ |
222 | 0 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ |
223 | 0 | cinfo->src = (struct jpeg_source_mgr *) |
224 | 0 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT, |
225 | 0 | sizeof(my_source_mgr)); |
226 | 0 | src = (my_src_ptr)cinfo->src; |
227 | 0 | src->buffer = (JOCTET *) |
228 | 0 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT, |
229 | 0 | INPUT_BUF_SIZE * sizeof(JOCTET)); |
230 | 0 | } else if (cinfo->src->init_source != init_source) { |
231 | | /* It is unsafe to reuse the existing source manager unless it was created |
232 | | * by this function. Otherwise, there is no guarantee that the opaque |
233 | | * structure is the right size. Note that we could just create a new |
234 | | * structure, but the old structure would not be freed until |
235 | | * jpeg_destroy_decompress() was called. |
236 | | */ |
237 | 0 | ERREXIT(cinfo, JERR_BUFFER_SIZE); |
238 | 0 | } |
239 | |
|
240 | 0 | src = (my_src_ptr)cinfo->src; |
241 | 0 | src->pub.init_source = init_source; |
242 | 0 | src->pub.fill_input_buffer = fill_input_buffer; |
243 | 0 | src->pub.skip_input_data = skip_input_data; |
244 | 0 | src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ |
245 | 0 | src->pub.term_source = term_source; |
246 | 0 | src->infile = infile; |
247 | 0 | src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ |
248 | 0 | src->pub.next_input_byte = NULL; /* until buffer loaded */ |
249 | 0 | } |
250 | | |
251 | | |
252 | | /* |
253 | | * Prepare for input from a supplied memory buffer. |
254 | | * The buffer must contain the whole JPEG data. |
255 | | */ |
256 | | |
257 | | GLOBAL(void) |
258 | | jpeg_mem_src(j_decompress_ptr cinfo, const unsigned char *inbuffer, |
259 | | unsigned long insize) |
260 | 0 | { |
261 | 0 | struct jpeg_source_mgr *src; |
262 | |
|
263 | 0 | if (inbuffer == NULL || insize == 0) /* Treat empty input as fatal error */ |
264 | 0 | ERREXIT(cinfo, JERR_INPUT_EMPTY); |
265 | | |
266 | | /* The source object is made permanent so that a series of JPEG images |
267 | | * can be read from the same buffer by calling jpeg_mem_src only before |
268 | | * the first one. |
269 | | */ |
270 | 0 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ |
271 | 0 | cinfo->src = (struct jpeg_source_mgr *) |
272 | 0 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT, |
273 | 0 | sizeof(struct jpeg_source_mgr)); |
274 | 0 | } else if (cinfo->src->init_source != init_mem_source) { |
275 | | /* It is unsafe to reuse the existing source manager unless it was created |
276 | | * by this function. |
277 | | */ |
278 | 0 | ERREXIT(cinfo, JERR_BUFFER_SIZE); |
279 | 0 | } |
280 | |
|
281 | 0 | src = cinfo->src; |
282 | 0 | src->init_source = init_mem_source; |
283 | 0 | src->fill_input_buffer = fill_mem_input_buffer; |
284 | 0 | src->skip_input_data = skip_input_data; |
285 | 0 | src->resync_to_restart = jpeg_resync_to_restart; /* use default method */ |
286 | 0 | src->term_source = term_source; |
287 | 0 | src->bytes_in_buffer = (size_t)insize; |
288 | 0 | src->next_input_byte = (const JOCTET *)inbuffer; |
289 | 0 | } |