Panda3D
Loading...
Searching...
No Matches
pnmFileTypeJPGReader.cxx
Go to the documentation of this file.
1/**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file pnmFileTypeJPGReader.cxx
10 * @author mike
11 * @date 2000-06-19
12 */
13
14#include "pnmFileTypeJPG.h"
15
16#ifdef HAVE_JPEG
17
19#include "thread.h"
20
21// The following bit of code, for setting up jpeg_istream_src(), was lifted
22// from jpeglib, and modified to work with istream instead of stdio.
23
24/*
25 * jdatasrc.c
26 *
27 * Copyright (C) 1994-1996, Thomas G. Lane.
28 * This file is part of the Independent JPEG Group's software.
29 * For conditions of distribution and use, see the accompanying README file.
30 *
31 * This file contains decompression data source routines for the case of
32 * reading JPEG data from a file (or any stdio stream). While these routines
33 * are sufficient for most applications, some will want to use a different
34 * source manager.
35 * IMPORTANT: we assume that fread() will correctly transcribe an array of
36 * JOCTETs from 8-bit-wide elements on external storage. If char is wider
37 * than 8 bits on your machine, you may need to do some tweaking.
38 */
39
40/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
41extern "C" {
42#include <jpeglib.h>
43#include <jerror.h>
44}
45
46
47/* Expanded data source object for stdio input */
48
49typedef struct {
50 struct jpeg_source_mgr pub; /* public fields */
51
52 std::istream * infile; /* source stream */
53 JOCTET * buffer; /* start of buffer */
54 boolean start_of_file; /* have we gotten any data yet? */
55} my_source_mgr;
56
57typedef my_source_mgr * my_src_ptr;
58
59#define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */
60
61
62/*
63 * Initialize source --- called by jpeg_read_header
64 * before any data is actually read.
65 */
66
67METHODDEF(void)
68init_source (j_decompress_ptr cinfo)
69{
70 my_src_ptr src = (my_src_ptr) cinfo->src;
71
72 /* We reset the empty-input-file flag for each image,
73 * but we don't clear the input buffer.
74 * This is correct behavior for reading a series of images from one source.
75 */
76 src->start_of_file = TRUE;
77}
78
79
80/*
81 * Fill the input buffer --- called whenever buffer is emptied.
82 *
83 * In typical applications, this should read fresh data into the buffer
84 * (ignoring the current state of next_input_byte & bytes_in_buffer),
85 * reset the pointer & count to the start of the buffer, and return TRUE
86 * indicating that the buffer has been reloaded. It is not necessary to
87 * fill the buffer entirely, only to obtain at least one more byte.
88 *
89 * There is no such thing as an EOF return. If the end of the file has been
90 * reached, the routine has a choice of ERREXIT() or inserting fake data into
91 * the buffer. In most cases, generating a warning message and inserting a
92 * fake EOI marker is the best course of action --- this will allow the
93 * decompressor to output however much of the image is there. However,
94 * the resulting error message is misleading if the real problem is an empty
95 * input file, so we handle that case specially.
96 *
97 * In applications that need to be able to suspend compression due to input
98 * not being available yet, a FALSE return indicates that no more data can be
99 * obtained right now, but more may be forthcoming later. In this situation,
100 * the decompressor will return to its caller (with an indication of the
101 * number of scanlines it has read, if any). The application should resume
102 * decompression after it has loaded more data into the input buffer. Note
103 * that there are substantial restrictions on the use of suspension --- see
104 * the documentation.
105 *
106 * When suspending, the decompressor will back up to a convenient restart point
107 * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
108 * indicate where the restart point will be if the current call returns FALSE.
109 * Data beyond this point must be rescanned after resumption, so move it to
110 * the front of the buffer rather than discarding it.
111 */
112
113METHODDEF(boolean)
114fill_input_buffer (j_decompress_ptr cinfo)
115{
116 my_src_ptr src = (my_src_ptr) cinfo->src;
117 size_t nbytes;
118
119 src->infile->read((char *)src->buffer, INPUT_BUF_SIZE);
120 nbytes = src->infile->gcount();
122
123 if (nbytes <= 0) {
124 if (src->start_of_file) /* Treat empty input file as fatal error */
125 ERREXIT(cinfo, JERR_INPUT_EMPTY);
126 WARNMS(cinfo, JWRN_JPEG_EOF);
127 /* Insert a fake EOI marker */
128 src->buffer[0] = (JOCTET) 0xFF;
129 src->buffer[1] = (JOCTET) JPEG_EOI;
130 nbytes = 2;
131 }
132
133 src->pub.next_input_byte = src->buffer;
134 src->pub.bytes_in_buffer = nbytes;
135 src->start_of_file = FALSE;
136
137 return TRUE;
138}
139
140
141/*
142 * Skip data --- used to skip over a potentially large amount of
143 * uninteresting data (such as an APPn marker).
144 *
145 * Writers of suspendable-input applications must note that skip_input_data
146 * is not granted the right to give a suspension return. If the skip extends
147 * beyond the data currently in the buffer, the buffer can be marked empty so
148 * that the next read will cause a fill_input_buffer call that can suspend.
149 * Arranging for additional bytes to be discarded before reloading the input
150 * buffer is the application writer's problem.
151 */
152
153METHODDEF(void)
154skip_input_data (j_decompress_ptr cinfo, long num_bytes)
155{
156 my_src_ptr src = (my_src_ptr) cinfo->src;
157
158 /* Just a dumb implementation for now. Could use fseek() except
159 * it doesn't work on pipes. Not clear that being smart is worth
160 * any trouble anyway --- large skips are infrequent.
161 */
162 if (num_bytes > 0) {
163 while (num_bytes > (long) src->pub.bytes_in_buffer) {
164 num_bytes -= (long) src->pub.bytes_in_buffer;
165 (void) fill_input_buffer(cinfo);
166 /* note we assume that fill_input_buffer will never return FALSE,
167 * so suspension need not be handled.
168 */
169 }
170 src->pub.next_input_byte += (size_t) num_bytes;
171 src->pub.bytes_in_buffer -= (size_t) num_bytes;
172 }
173}
174
175
176/*
177 * An additional method that can be provided by data source modules is the
178 * resync_to_restart method for error recovery in the presence of RST markers.
179 * For the moment, this source module just uses the default resync method
180 * provided by the JPEG library. That method assumes that no backtracking
181 * is possible.
182 */
183
184
185/*
186 * Terminate source --- called by jpeg_finish_decompress
187 * after all data has been read. Often a no-op.
188 *
189 * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
190 * application must deal with any cleanup that should happen even
191 * for error exit.
192 */
193
194METHODDEF(void)
195term_source (j_decompress_ptr cinfo)
196{
197 /* no work necessary here */
198}
199
200
201/*
202 * Prepare for input from a stdio stream.
203 * The caller must have already opened the stream, and is responsible
204 * for closing it after finishing decompression.
205 */
206
207GLOBAL(void)
208jpeg_istream_src (j_decompress_ptr cinfo, std::istream * infile)
209{
210 my_src_ptr src;
211
212 /* The source object and input buffer are made permanent so that a series
213 * of JPEG images can be read from the same file by calling jpeg_stdio_src
214 * only before the first one. (If we discarded the buffer at the end of
215 * one image, we'd likely lose the start of the next one.)
216 * This makes it unsafe to use this manager and a different source
217 * manager serially with the same JPEG object. Caveat programmer.
218 */
219 if (cinfo->src == nullptr) { /* first time for this JPEG object? */
220 cinfo->src = (struct jpeg_source_mgr *)
221 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
222 sizeof(my_source_mgr));
223 src = (my_src_ptr) cinfo->src;
224 src->buffer = (JOCTET *)
225 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
226 INPUT_BUF_SIZE * sizeof(JOCTET));
227 }
228
229 src = (my_src_ptr) cinfo->src;
230 src->pub.init_source = init_source;
231 src->pub.fill_input_buffer = fill_input_buffer;
232 src->pub.skip_input_data = skip_input_data;
233 src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
234 src->pub.term_source = term_source;
235 src->infile = infile;
236 src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
237 src->pub.next_input_byte = nullptr; /* until buffer loaded */
238}
239
240
241
242// The rest of the code in this file is new to Panda.
243
244/**
245 *
246 */
247PNMFileTypeJPG::Reader::
248Reader(PNMFileType *type, std::istream *file, bool owns_file, std::string magic_number) :
249 PNMReader(type, file, owns_file)
250{
251 // Hope we can putback() more than one character.
252 for (std::string::reverse_iterator mi = magic_number.rbegin();
253 mi != magic_number.rend();
254 ++mi) {
255 _file->putback(*mi);
256 }
257 if (_file->fail()) {
258 pnmimage_jpg_cat.error()
259 << "Unable to put back magic number.\n";
260 _is_valid = false;
261 return;
262 }
263 _is_valid = true;
264
265 /* Step 1: allocate and initialize JPEG decompression object */
266
267 /* We set up the normal JPEG error routines, then override error_exit. */
268 _cinfo.err = jpeg_std_error(&_jerr.pub);
269
270 /* Now we can initialize the JPEG decompression object. */
271 jpeg_create_decompress(&_cinfo);
272
273 /* Step 2: specify data source (eg, a file) */
274 jpeg_istream_src(&_cinfo, file);
275
276 /* Step 3: let lib jpeg know that we want to read the comment field */
277 jpeg_save_markers(&_cinfo, JPEG_COM, 0xffff);
278
279 /* Step 4: read file parameters with jpeg_read_header() */
280 jpeg_read_header(&_cinfo, TRUE);
281 /* We can ignore the return value from jpeg_read_header since
282 * (a) suspension is not possible with the stdio data source, and
283 * (b) we passed TRUE to reject a tables-only JPEG file as an error.
284 * See libjpeg.doc for more info.
285 */
286
287 _num_channels = _cinfo.num_components;
288 _x_size = (int)_cinfo.image_width;
289 _y_size = (int)_cinfo.image_height;
290 _maxval = MAXJSAMPLE;
291
292 /* Step 6: set parameters for decompression */
293 _cinfo.scale_num = 1;
294 _cinfo.scale_denom = 1;
295}
296
297/**
298 * This method will be called before read_data() or read_row() is called. It
299 * instructs the reader to initialize its data structures as necessary to
300 * actually perform the read operation.
301 *
302 * After this call, _x_size and _y_size should reflect the actual size that
303 * will be filled by read_data() (as possibly modified by set_read_size()).
304 */
305void PNMFileTypeJPG::Reader::
306prepare_read() {
307 if (_has_read_size && _read_x_size != 0 && _read_y_size != 0) {
308 // Attempt to get the scale close to our target scale.
309 int x_reduction = _cinfo.image_width / _read_x_size;
310 int y_reduction = _cinfo.image_height / _read_y_size;
311 _cinfo.scale_denom = std::max(std::min(x_reduction, y_reduction), 1);
312 }
313
314 /* Step 7: Start decompressor */
315
316 jpeg_start_decompress(&_cinfo);
317 /* We can ignore the return value since suspension is not possible
318 * with the stdio data source.
319 */
320
321 _num_channels = _cinfo.output_components;
322 _x_size = (int)_cinfo.output_width;
323 _y_size = (int)_cinfo.output_height;
324}
325
326/**
327 *
328 */
329PNMFileTypeJPG::Reader::
330~Reader() {
331 if (_is_valid) {
332 jpeg_destroy_decompress(&_cinfo);
333 _is_valid = false;
334 }
335}
336
337/**
338 * Reads in an entire image all at once, storing it in the pre-allocated
339 * _x_size * _y_size array and alpha pointers. (If the image type has no
340 * alpha channel, alpha is ignored.) Returns the number of rows correctly
341 * read.
342 *
343 * Derived classes need not override this if they instead provide
344 * supports_read_row() and read_row(), below.
345 */
346int PNMFileTypeJPG::Reader::
347read_data(xel *array, xelval *) {
348 if (!_is_valid) {
349 return 0;
350 }
351 JSAMPARRAY buffer; /* Output row buffer */
352 int row_stride; /* physical row width in output buffer */
353
354 nassertr(_cinfo.output_components == 1 || _cinfo.output_components == 3, 0);
355
356 /* We may need to do some setup of our own at this point before reading
357 * the data. After jpeg_start_decompress() we have the correct scaled
358 * output image dimensions available, as well as the output colormap
359 * if we asked for color quantization.
360 * In this example, we need to make an output work buffer of the right size.
361 */
362 /* JSAMPLEs per row in output buffer */
363 row_stride = _cinfo.output_width * _cinfo.output_components;
364 /* Make a one-row-high sample array that will go away when done with image */
365
366 buffer = (*_cinfo.mem->alloc_sarray)
367 ((j_common_ptr) &_cinfo, JPOOL_IMAGE, row_stride, 1);
368
369 /* Step 6: while (scan lines remain to be read) */
370 /* jpeg_read_scanlines(...); */
371
372 /* Here we use the library's state variable cinfo.output_scanline as the
373 * loop counter, so that we don't have to keep track ourselves.
374 */
375 int x = 0;
376 while (_cinfo.output_scanline < _cinfo.output_height) {
377 /* jpeg_read_scanlines expects an array of pointers to scanlines.
378 * Here the array is only one element long, but you could ask for
379 * more than one scanline at a time if that's more convenient.
380 */
381 jpeg_read_scanlines(&_cinfo, buffer, 1);
382 /* Assume put_scanline_someplace wants a pointer and sample count. */
383 // put_scanline_someplace(buffer[0], row_stride);
384 JSAMPROW bufptr = buffer[0];
385 for (int i = 0; i < row_stride; i += _cinfo.output_components) {
386 if (_cinfo.output_components == 1) {
387 xelval val = (xelval)bufptr[i];
388 nassertr(x < _x_size * _y_size, 0);
389 PNM_ASSIGN1(array[x], val);
390 } else {
391 xelval red, grn, blu;
392 red = (xelval)bufptr[i];
393 grn = (xelval)bufptr[i+1];
394 blu = (xelval)bufptr[i+2];
395 nassertr(x < _x_size * _y_size, 0);
396 PPM_ASSIGN(array[x], red, grn, blu);
397 }
398 x++;
399 }
401 }
402
403 /* Step 7: Finish decompression */
404
405 jpeg_finish_decompress(&_cinfo);
406
407 /* We can ignore the return value since suspension is not possible
408 * with the stdio data source.
409 */
410
411 /* At this point you may want to check to see whether any corrupt-data
412 * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
413 */
414 if (_jerr.pub.num_warnings) {
415 pnmimage_jpg_cat.warning()
416 << "Jpeg data may be corrupt" << std::endl;
417 }
418
419 return _y_size;
420}
421
422#endif // HAVE_JPEG
This is the base class of a family of classes that represent particular image file types that PNMImag...
Definition pnmFileType.h:32
This is an abstract base class that defines the interface for reading image files of various types.
Definition pnmReader.h:27
static void consider_yield()
Possibly suspends the current thread for the rest of the current epoch, if it has run for enough this...
Definition thread.I:212
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.