| /* |
| * jdatasrc-tj.c |
| * |
| * This file was part of the Independent JPEG Group's software: |
| * Copyright (C) 1994-1996, Thomas G. Lane. |
| * Modified 2009-2011 by Guido Vollbeding. |
| * libjpeg-turbo Modifications: |
| * Copyright (C) 2011, 2016, 2019, 2023, D. R. Commander. |
| * For conditions of distribution and use, see the accompanying README.ijg |
| * file. |
| * |
| * This file contains decompression data source routines for the case of |
| * reading JPEG data from memory or from a file (or any stdio stream). |
| * While these routines are sufficient for most applications, |
| * some will want to use a different source manager. |
| * IMPORTANT: we assume that fread() will correctly transcribe an array of |
| * JOCTETs from 8-bit-wide elements on external storage. If char is wider |
| * than 8 bits on your machine, you may need to do some tweaking. |
| */ |
| |
| /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ |
| #include "jinclude.h" |
| #include "jpeglib.h" |
| #include "jerror.h" |
| |
| void jpeg_mem_src_tj(j_decompress_ptr cinfo, const unsigned char *inbuffer, |
| size_t insize); |
| |
| |
| /* |
| * Initialize source --- called by jpeg_read_header |
| * before any data is actually read. |
| */ |
| |
| METHODDEF(void) |
| init_mem_source(j_decompress_ptr cinfo) |
| { |
| /* no work necessary here */ |
| } |
| |
| |
| /* |
| * Fill the input buffer --- called whenever buffer is emptied. |
| * |
| * In typical applications, this should read fresh data into the buffer |
| * (ignoring the current state of next_input_byte & bytes_in_buffer), |
| * reset the pointer & count to the start of the buffer, and return TRUE |
| * indicating that the buffer has been reloaded. It is not necessary to |
| * fill the buffer entirely, only to obtain at least one more byte. |
| * |
| * There is no such thing as an EOF return. If the end of the file has been |
| * reached, the routine has a choice of ERREXIT() or inserting fake data into |
| * the buffer. In most cases, generating a warning message and inserting a |
| * fake EOI marker is the best course of action --- this will allow the |
| * decompressor to output however much of the image is there. However, |
| * the resulting error message is misleading if the real problem is an empty |
| * input file, so we handle that case specially. |
| * |
| * In applications that need to be able to suspend compression due to input |
| * not being available yet, a FALSE return indicates that no more data can be |
| * obtained right now, but more may be forthcoming later. In this situation, |
| * the decompressor will return to its caller (with an indication of the |
| * number of scanlines it has read, if any). The application should resume |
| * decompression after it has loaded more data into the input buffer. Note |
| * that there are substantial restrictions on the use of suspension --- see |
| * the documentation. |
| * |
| * When suspending, the decompressor will back up to a convenient restart point |
| * (typically the start of the current MCU). next_input_byte & bytes_in_buffer |
| * indicate where the restart point will be if the current call returns FALSE. |
| * Data beyond this point must be rescanned after resumption, so move it to |
| * the front of the buffer rather than discarding it. |
| */ |
| |
| METHODDEF(boolean) |
| fill_mem_input_buffer(j_decompress_ptr cinfo) |
| { |
| static const JOCTET mybuffer[4] = { |
| (JOCTET)0xFF, (JOCTET)JPEG_EOI, 0, 0 |
| }; |
| |
| /* The whole JPEG data is expected to reside in the supplied memory |
| * buffer, so any request for more data beyond the given buffer size |
| * is treated as an error. |
| */ |
| WARNMS(cinfo, JWRN_JPEG_EOF); |
| |
| /* Insert a fake EOI marker */ |
| |
| cinfo->src->next_input_byte = mybuffer; |
| cinfo->src->bytes_in_buffer = 2; |
| |
| return TRUE; |
| } |
| |
| |
| /* |
| * Skip data --- used to skip over a potentially large amount of |
| * uninteresting data (such as an APPn marker). |
| * |
| * Writers of suspendable-input applications must note that skip_input_data |
| * is not granted the right to give a suspension return. If the skip extends |
| * beyond the data currently in the buffer, the buffer can be marked empty so |
| * that the next read will cause a fill_input_buffer call that can suspend. |
| * Arranging for additional bytes to be discarded before reloading the input |
| * buffer is the application writer's problem. |
| */ |
| |
| METHODDEF(void) |
| skip_input_data(j_decompress_ptr cinfo, long num_bytes) |
| { |
| struct jpeg_source_mgr *src = cinfo->src; |
| |
| /* Just a dumb implementation for now. Could use fseek() except |
| * it doesn't work on pipes. Not clear that being smart is worth |
| * any trouble anyway --- large skips are infrequent. |
| */ |
| if (num_bytes > 0) { |
| while (num_bytes > (long)src->bytes_in_buffer) { |
| num_bytes -= (long)src->bytes_in_buffer; |
| (void)(*src->fill_input_buffer) (cinfo); |
| /* note we assume that fill_input_buffer will never return FALSE, |
| * so suspension need not be handled. |
| */ |
| } |
| src->next_input_byte += (size_t)num_bytes; |
| src->bytes_in_buffer -= (size_t)num_bytes; |
| } |
| } |
| |
| |
| /* |
| * An additional method that can be provided by data source modules is the |
| * resync_to_restart method for error recovery in the presence of RST markers. |
| * For the moment, this source module just uses the default resync method |
| * provided by the JPEG library. That method assumes that no backtracking |
| * is possible. |
| */ |
| |
| |
| /* |
| * Terminate source --- called by jpeg_finish_decompress |
| * after all data has been read. Often a no-op. |
| * |
| * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding |
| * application must deal with any cleanup that should happen even |
| * for error exit. |
| */ |
| |
| METHODDEF(void) |
| term_source(j_decompress_ptr cinfo) |
| { |
| /* no work necessary here */ |
| } |
| |
| |
| /* |
| * Prepare for input from a supplied memory buffer. |
| * The buffer must contain the whole JPEG data. |
| */ |
| |
| GLOBAL(void) |
| jpeg_mem_src_tj(j_decompress_ptr cinfo, const unsigned char *inbuffer, |
| size_t insize) |
| { |
| struct jpeg_source_mgr *src; |
| |
| if (inbuffer == NULL || insize == 0) /* Treat empty input as fatal error */ |
| ERREXIT(cinfo, JERR_INPUT_EMPTY); |
| |
| /* The source object is made permanent so that a series of JPEG images |
| * can be read from the same buffer by calling jpeg_mem_src only before |
| * the first one. |
| */ |
| if (cinfo->src == NULL) { /* first time for this JPEG object? */ |
| cinfo->src = (struct jpeg_source_mgr *) |
| (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT, |
| sizeof(struct jpeg_source_mgr)); |
| } else if (cinfo->src->init_source != init_mem_source) { |
| /* It is unsafe to reuse the existing source manager unless it was created |
| * by this function. |
| */ |
| ERREXIT(cinfo, JERR_BUFFER_SIZE); |
| } |
| |
| src = cinfo->src; |
| src->init_source = init_mem_source; |
| src->fill_input_buffer = fill_mem_input_buffer; |
| src->skip_input_data = skip_input_data; |
| src->resync_to_restart = jpeg_resync_to_restart; /* use default method */ |
| src->term_source = term_source; |
| src->bytes_in_buffer = insize; |
| src->next_input_byte = (const JOCTET *)inbuffer; |
| } |