Coverage Report

Created: 2024-06-18 06:05

/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
}