/src/jpegoptim/jpegsrc.c

Source (jump to first uncovered line)
/*
 * jpegsrc.c
 *
 * Copyright (C) 2022-2025 Timo Kokkonen
 * All Rights Reserved.
 *
 * Custom libjpeg "Source Manager" for reading from a file handle
 * and optionally saving the input also into a memory buffer.
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of JPEGoptim.
 *
 * JPEGoptim is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * JPEGoptim is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JPEGoptim. If not, see <https://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <jpeglib.h>
#include <jerror.h>

#include "jpegoptim.h"

#define STDIO_BUFFER_SIZE 4096


/* Custom jpeg source manager object */

typedef struct {
  struct jpeg_source_mgr pub; /* public fields */

  unsigned char **buf_ptr;
  size_t *bufsize_ptr;
  size_t *bufused_ptr;
  size_t incsize;
  unsigned char *buf;
  size_t bufsize;
  size_t bufused;

  FILE *infile;
  JOCTET *stdio_buffer;
  boolean start_of_file;
} jpeg_custom_source_mgr;

typedef jpeg_custom_source_mgr* jpeg_custom_source_mgr_ptr;



static void custom_init_source (j_decompress_ptr dinfo)
{
  jpeg_custom_source_mgr_ptr src = (jpeg_custom_source_mgr_ptr) dinfo->src;

  src->bufused = 0;
  if (src->bufused_ptr)
    *src->bufused_ptr = 0;
  src->start_of_file = TRUE;
}

static void custom_init_mem_source (j_decompress_ptr dinfo)
{
  /* nothing to do */
}


static boolean custom_fill_input_buffer (j_decompress_ptr dinfo)
{
  jpeg_custom_source_mgr_ptr src = (jpeg_custom_source_mgr_ptr) dinfo->src;
  size_t bytes_read;
  unsigned char *newbuf;

  bytes_read = fread(src->stdio_buffer, 1, STDIO_BUFFER_SIZE, src->infile);
  if (bytes_read <= 0) {
    if (src->start_of_file)
      ERREXIT(dinfo, JERR_INPUT_EMPTY);
    WARNMS(dinfo, JWRN_JPEG_EOF);
    /* Insert fake EOI marker if read failed */
    src->stdio_buffer[0] = (JOCTET) 0xff;
    src->stdio_buffer[1] = (JOCTET) JPEG_EOI;
    bytes_read = 2;
  } else if (src->buf_ptr && src->buf) {
    if (bytes_read > (src->bufsize - src->bufused)) {
      /* Need to allocate more memory for the buffer. */
      src->bufsize += src->incsize;
      newbuf = realloc(src->buf, src->bufsize);
      if (!newbuf) ERREXIT1(dinfo, JERR_OUT_OF_MEMORY, 42);
      src->buf = newbuf;
      *src->buf_ptr = newbuf;
      src->incsize *= 2;
    }
    memcpy(&src->buf[src->bufused], src->stdio_buffer, bytes_read);
    src->bufused += bytes_read;
    if (src->bufused_ptr)
      *src->bufused_ptr = src->bufused;
  }

  src->pub.next_input_byte = src->stdio_buffer;
  src->pub.bytes_in_buffer = bytes_read;
  src->start_of_file = FALSE;

  return TRUE;
}

static boolean custom_fill_mem_input_buffer (j_decompress_ptr dinfo)
{
  jpeg_custom_source_mgr_ptr src = (jpeg_custom_source_mgr_ptr) dinfo->src;

  WARNMS(dinfo, JWRN_JPEG_EOF);

  /* Insert fake EOI marker as there is no more data... */
  src->stdio_buffer[0] = (JOCTET) 0xff;
  src->stdio_buffer[1] = (JOCTET) JPEG_EOI;

  src->pub.next_input_byte = src->stdio_buffer;
  src->pub.bytes_in_buffer = 2;

  return TRUE;
}


static void custom_skip_input_data (j_decompress_ptr dinfo, long num_bytes)
{
  jpeg_custom_source_mgr_ptr src = (jpeg_custom_source_mgr_ptr) dinfo->src;

  if (num_bytes <= 0)
    return;

  /* skip "num_bytes" bytes of data from input... */
  while (num_bytes > (long) src->pub.bytes_in_buffer) {
    num_bytes -= src->pub.bytes_in_buffer;
    (void)(src->pub.fill_input_buffer)(dinfo);
  }
  src->pub.next_input_byte += (size_t) num_bytes;
  src->pub.bytes_in_buffer -= (size_t) num_bytes;
}


static void custom_term_source (j_decompress_ptr dinfo)
{
  jpeg_custom_source_mgr_ptr src = (jpeg_custom_source_mgr_ptr) dinfo->src;

  if (src->bufused_ptr)
    *src->bufused_ptr = src->bufused;
}


void jpeg_custom_src(j_decompress_ptr dinfo, FILE *infile,
    unsigned char **bufptr, size_t *bufsizeptr, size_t *bufusedptr, size_t incsize)
{
  jpeg_custom_source_mgr_ptr src;

  if (!dinfo->src) {
    /* Allocate source manager object if needed */
    dinfo->src = (struct jpeg_source_mgr *)
      (*dinfo->mem->alloc_small) ((j_common_ptr) dinfo, JPOOL_PERMANENT,
            sizeof(jpeg_custom_source_mgr));
    src = (jpeg_custom_source_mgr_ptr) dinfo->src;
    src->stdio_buffer = (JOCTET *)
      (*dinfo->mem->alloc_small) ((j_common_ptr) dinfo, JPOOL_PERMANENT,
            STDIO_BUFFER_SIZE * sizeof(JOCTET));
  } else {
    src = (jpeg_custom_source_mgr_ptr) dinfo->src;
  }

  src->pub.init_source = custom_init_source;
  src->pub.fill_input_buffer = custom_fill_input_buffer;
  src->pub.resync_to_restart = jpeg_resync_to_restart;
  src->pub.skip_input_data = custom_skip_input_data;
  src->pub.term_source = custom_term_source;
  src->infile = infile;
  src->pub.bytes_in_buffer = 0;
  src->pub.next_input_byte = NULL;

  src->buf_ptr = bufptr;
  src->buf = (bufptr ? *bufptr : NULL);
  src->bufsize_ptr = bufsizeptr;
  src->bufused_ptr = bufusedptr;
  src->bufsize = (bufsizeptr ? *bufsizeptr : 0);
  src->incsize = incsize;
}



void jpeg_custom_mem_src(j_decompress_ptr dinfo, unsigned char *buf, size_t bufsize)
{
  jpeg_custom_source_mgr_ptr src;

  if (!dinfo->src) {
    /* Allocate source manager object if needed */
    dinfo->src = (struct jpeg_source_mgr *)
      (*dinfo->mem->alloc_small) ((j_common_ptr) dinfo, JPOOL_PERMANENT,
            sizeof(jpeg_custom_source_mgr));
    src = (jpeg_custom_source_mgr_ptr) dinfo->src;
    src->stdio_buffer = (JOCTET *)
      (*dinfo->mem->alloc_small) ((j_common_ptr) dinfo, JPOOL_PERMANENT,
            STDIO_BUFFER_SIZE * sizeof(JOCTET));
  } else {
    src = (jpeg_custom_source_mgr_ptr) dinfo->src;
  }

  src->pub.init_source = custom_init_mem_source;
  src->pub.fill_input_buffer = custom_fill_mem_input_buffer;
  src->pub.resync_to_restart = jpeg_resync_to_restart;
  src->pub.skip_input_data = custom_skip_input_data;
  src->pub.term_source = custom_term_source;
  src->infile = NULL;
  src->pub.bytes_in_buffer = bufsize;
  src->pub.next_input_byte = (JOCTET*) buf;

  src->buf_ptr = NULL;
  src->buf = NULL;
  src->bufsize_ptr = NULL;
  src->bufused_ptr = NULL;
  src->bufsize = bufsize;
  src->incsize = 0;
}


/* eof :-) */

Coverage Report

Created: 2025-07-18 07:12