void Mgr_skip_input_data_fcn(j_decompress_ptr cinfo, long num_bytes) {
    // Cannot skip negative or 0 bytes.
    if (num_bytes <= 0) {
        LOGW("skipping 0 bytes in InputStream");
        return;
    }
    SourceManager *src = reinterpret_cast<SourceManager*>(cinfo->src);
    if (src->mgr.bytes_in_buffer >= num_bytes) {
        src->mgr.bytes_in_buffer -= num_bytes;
        src->mgr.next_input_byte += num_bytes;
    } else {
        // if skipping more bytes than remain in buffer, set skip_bytes
        int64_t skip = num_bytes - src->mgr.bytes_in_buffer;
        src->mgr.next_input_byte += src->mgr.bytes_in_buffer;
        src->mgr.bytes_in_buffer = 0;
        int64_t actual = src->inStream->skip(skip);
        if (actual < 0) {
            ERREXIT(cinfo, JERR_FILE_READ);
        }
        skip -= actual;
        while (skip > 0) {
            actual = src->inStream->skip(skip);
            if (actual < 0) {
                ERREXIT(cinfo, JERR_FILE_READ);
            }
            skip -= actual;
            if (actual == 0) {
                // Multiple zero byte skips, likely EOF
                WARNMS(cinfo, JWRN_JPEG_EOF);
                return;
            }
        }
    }
}
Exemple #2
0
static boolean my_fill_input_buffer (j_decompress_ptr cinfo)
{
  my_src_ptr src = (my_src_ptr) cinfo->src;
  size_t nbytes;

  if (src->src_size > INPUT_BUF_SIZE)
    nbytes = INPUT_BUF_SIZE;
  else
    nbytes = src->src_size;

  memcpy (src->buffer, src->src_buffer, nbytes);
  src->src_buffer += nbytes;
  src->src_size -= nbytes;

  if (nbytes <= 0) {
    if (src->start_of_file)	/* Treat empty input file as fatal error */
      ERREXIT(cinfo, JERR_INPUT_EMPTY);
    WARNMS(cinfo, JWRN_JPEG_EOF);
    /* Insert a fake EOI marker */
    src->buffer[0] = (JOCTET) 0xFF;
    src->buffer[1] = (JOCTET) JPEG_EOI;
    nbytes = 2;
  }

  src->pub.next_input_byte = src->buffer;
  src->pub.bytes_in_buffer = nbytes;
  src->start_of_file = FALSE;

  return TRUE;
}
static boolean
stdio_fill_input_buffer (j_decompress_ptr cinfo)
{
  stdio_src_ptr src = (stdio_src_ptr) cinfo->src;
  size_t nbytes;

  nbytes = fread (src->buffer, 1, JPEG_PROG_BUF_SIZE, src->infile);

  if (nbytes <= 0) {
#if 0
    if (src->start_of_file)	/* Treat empty input file as fatal error */
      ERREXIT(cinfo, JERR_INPUT_EMPTY);
    WARNMS(cinfo, JWRN_JPEG_EOF);
#endif
    /* Insert a fake EOI marker */
    src->buffer[0] = (JOCTET) 0xFF;
    src->buffer[1] = (JOCTET) JPEG_EOI;
    nbytes = 2;
  }

  src->pub.next_input_byte = src->buffer;
  src->pub.bytes_in_buffer = nbytes;
  src->start_of_file = FALSE;

  return TRUE;
}
Exemple #4
0
fill_input_buffer (j_decompress_ptr cinfo)
{
#ifndef USE_SYMBIAN
	my_src_ptr src = (my_src_ptr) cinfo->src;
	int nbytes;

	nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);

	if (nbytes <= 0) {
		if (src->start_of_file)	/* Treat empty input file as fatal error */
			ERREXIT(cinfo, JERR_INPUT_EMPTY);
		WARNMS(cinfo, JWRN_JPEG_EOF);
		/* Insert a fake EOI marker */
		src->buffer[0] = (JOCTET) 0xFF;
		src->buffer[1] = (JOCTET) JPEG_EOI;
		nbytes = 2;
	}

	src->pub.next_input_byte = src->buffer;
	src->pub.bytes_in_buffer = nbytes;
	src->start_of_file = FALSE;
#endif

  return TRUE;
}
Exemple #5
0
fill_input_buffer (j_decompress_ptr cinfo) {
	freeimage_src_ptr src = (freeimage_src_ptr) cinfo->src;

	size_t nbytes = src->m_io->read_proc(src->buffer, 1, INPUT_BUF_SIZE, src->infile);

	if (nbytes <= 0) {
		if (src->start_of_file)	/* Treat empty input file as fatal error */
			throw(cinfo, JERR_INPUT_EMPTY);

		WARNMS(cinfo, JWRN_JPEG_EOF);

		/* Insert a fake EOI marker */

		src->buffer[0] = (JOCTET) 0xFF;
		src->buffer[1] = (JOCTET) JPEG_EOI;

		nbytes = 2;
	}

	src->pub.next_input_byte = src->buffer;
	src->pub.bytes_in_buffer = nbytes;
	src->start_of_file = FALSE;

	return TRUE;
}
Exemple #6
0
jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
		    JDIMENSION max_lines)
{
  JDIMENSION lines_per_iMCU_row;

  if (cinfo->global_state != DSTATE_RAW_OK)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  if (cinfo->output_scanline >= cinfo->output_height) {
    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
    return 0;
  }

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
    cinfo->progress->pass_limit = (long) cinfo->output_height;
    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Verify that at least one iMCU row can be returned. */
  lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size;
  if (max_lines < lines_per_iMCU_row)
    ERREXIT(cinfo, JERR_BUFFER_SIZE);

  /* Decompress directly into user's buffer. */
  if (! (*cinfo->coef->decompress_data) (cinfo, data))
    return 0;			/* suspension forced, can do nothing more */

  /* OK, we processed one iMCU row. */
  cinfo->output_scanline += lines_per_iMCU_row;
  return lines_per_iMCU_row;
}
Exemple #7
0
static boolean bmJpegFillInputBuffer(	j_decompress_ptr	cinfo )
    {
    BmJpegInputSource *		bjis= (BmJpegInputSource *)cinfo->src;
    size_t			nbytes;

    nbytes= sioInReadBytes( bjis->bjisSis,
				bjis->bjisReadBuffer, INPUT_BUF_SIZE );

    if  ( nbytes <= 0 )
	{
	if  ( bjis->bjisAtBeginOfInput )	/* Treat empty input	*/
						/* file as fatal error	*/
	    { ERREXIT( cinfo, JERR_INPUT_EMPTY );	}

	WARNMS(cinfo, JWRN_JPEG_EOF);

	/* Insert a fake EOI marker */
	bjis->bjisReadBuffer[0] = (JOCTET) 0xFF;
	bjis->bjisReadBuffer[1] = (JOCTET) JPEG_EOI;
	nbytes = 2;
	}

    bjis->pub.next_input_byte= bjis->bjisReadBuffer;
    bjis->pub.bytes_in_buffer= nbytes;
    bjis->bjisAtBeginOfInput= FALSE;

    return TRUE;
    }
Exemple #8
0
jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
		      JDIMENSION num_lines)
{
  JDIMENSION row_ctr, rows_left;

  if (cinfo->global_state != CSTATE_SCANNING)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  if (cinfo->next_scanline >= cinfo->image_height)
    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
    cinfo->progress->pass_limit = (long) cinfo->image_height;
    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Give master control module another chance if this is first call to
   * jpeg_write_scanlines.  This lets output of the frame/scan headers be
   * delayed so that application can write COM, etc, markers between
   * jpeg_start_compress and jpeg_write_scanlines.
   */
  if (cinfo->master->call_pass_startup)
    (*cinfo->master->pass_startup) (cinfo);

  /* Ignore any extra scanlines at bottom of image. */
  rows_left = cinfo->image_height - cinfo->next_scanline;
  if (num_lines > rows_left)
    num_lines = rows_left;

  row_ctr = 0;
  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines);
  cinfo->next_scanline += row_ctr;
  return row_ctr;
}
fill_input_buffer (j_decompress_ptr cinfo)
{
    stream_source_mgr* src = (stream_source_mgr*) cinfo->src;
    size_t nbytes;

    nbytes = stream_get_callbacks(src->stream)
      ->read(src->buffer, 1, INPUT_BUF_SIZE, src->stream);

    if (nbytes <= 0) {
	/* original: Treat empty input file as fatal error
	if (src->start_of_file_p)
	    ERREXIT(cinfo, JERR_INPUT_EMPTY);
	*/
	ERREXIT(cinfo, JERR_INPUT_EOF);
	WARNMS(cinfo, JWRN_JPEG_EOF);
	/* Insert a fake EOI marker */
	src->buffer[0] = (JOCTET) 0xFF;
	src->buffer[1] = (JOCTET) JPEG_EOI;
	nbytes = 2;
    }

    src->pub.next_input_byte = src->buffer;
    src->pub.bytes_in_buffer = nbytes;
    src->start_of_file_p     = FALSE;

    return TRUE;
}
Exemple #10
0
jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
		     JDIMENSION max_lines)
{
  JDIMENSION row_ctr;

  if (cinfo->global_state != DSTATE_SCANNING)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  if (cinfo->output_scanline >= cinfo->output_height) {
    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
    return 0;
  }

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
    cinfo->progress->pass_limit = (long) cinfo->output_height;
    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Process some data */
  row_ctr = 0;
  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
  cinfo->output_scanline += row_ctr;
  return row_ctr;
}
Exemple #11
0
sun_jpeg_fill_input_buffer(j_decompress_ptr cinfo)
{
    sun_jpeg_source_ptr src = (sun_jpeg_source_ptr) cinfo->src;
    JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    int ret, buflen;

    if (src->suspendable) {
        return FALSE;
    }
    if (src->remaining_skip) {
        src->pub.skip_input_data(cinfo, 0);
    }
    RELEASE_ARRAYS(env, src);
    buflen = (*env)->GetArrayLength(env, src->hInputBuffer);
    ret = (*env)->CallIntMethod(env, src->hInputStream, InputStream_readID,
                                src->hInputBuffer, 0, buflen);
    if ((*env)->ExceptionOccurred(env) || !GET_ARRAYS(env, src)) {
        cinfo->err->error_exit((struct jpeg_common_struct *) cinfo);
    }
    if (ret <= 0) {
        /* Silently accept truncated JPEG files */
        WARNMS(cinfo, JWRN_JPEG_EOF);
        src->inbuf[0] = (JOCTET) 0xFF;
        src->inbuf[1] = (JOCTET) JPEG_EOI;
        ret = 2;
    }

    src->pub.next_input_byte = src->inbuf;
    src->pub.bytes_in_buffer = ret;

    return TRUE;
}
Exemple #12
0
_jpeg_fill_input_buffer(j_decompress_ptr cinfo) {
    WARNMS(cinfo, JWRN_JPEG_EOF);

    /* Insert a fake EOI marker */
    cinfo->src->next_input_byte = fake_EOI;
    cinfo->src->bytes_in_buffer = sizeof(fake_EOI);
    return TRUE;
}
Exemple #13
0
boolean pgui_jpeg_fill_input_buffer (j_decompress_ptr cinfo)
{
  pgui_jpeg_src_ptr src = (pgui_jpeg_src_ptr) cinfo->src;
  size_t nbytes;
  int size=INPUT_BUF_SIZE;

  // make sure we don't read past "size".. since we kept that in the jpeg_data structure,
  // artifically increment nbytes to look like it incremented the right size. (BUF_SIZE,
  // or remaining bytes left from jpeg_data->size
  size = ((g_jpeg_data.size-g_jpeg_data.copied_size) > INPUT_BUF_SIZE) ?  
    INPUT_BUF_SIZE : 
    (g_jpeg_data.size - g_jpeg_data.copied_size);

  memcpy(src->buffer, g_jpeg_data.lastptr, size);
  if(g_jpeg_data.copied_size < (g_jpeg_data.size - INPUT_BUF_SIZE)) { 
    nbytes=INPUT_BUF_SIZE;
    g_jpeg_data.lastptr+=nbytes;
  } else {
    nbytes=(g_jpeg_data.size - g_jpeg_data.copied_size);
  }

  g_jpeg_data.copied_size+=nbytes;
 
  // if there is no data, and we have just started, mark an exit
  if (nbytes <= 0) {
    if (src->start_of_file){	/* Treat empty input file as fatal error */
      printf("error: no data!\n");
      WARNMS(cinfo, JERR_INPUT_EMPTY); 
      return FALSE;

    }
    WARNMS(cinfo, JWRN_JPEG_EOF);
    /* Insert a fake EOI marker */
    src->buffer[0] = (JOCTET) 0xFF;
    src->buffer[1] = (JOCTET) JPEG_EOI;
    nbytes = 2;
  }

  src->pub.next_input_byte = src->buffer;
  src->pub.bytes_in_buffer = nbytes;
  src->start_of_file = FALSE;

  return TRUE;
}
Exemple #14
0
safeboolean
fill_input_buffer (j_decompress_ptr cinfo)
{
  my_src_ptr src = (my_src_ptr) cinfo->src;
  /* 2.0.12: signed size. Thanks to Geert Jansen */
  /* 2.0.14: some platforms (mingw-msys) don't have ssize_t. Call 
     an int an int. */
  int nbytes = 0;
  memset (src->buffer, 0, INPUT_BUF_SIZE);

  while (nbytes < INPUT_BUF_SIZE)
    {

      int got = gdGetBuf (src->buffer + nbytes,
			  INPUT_BUF_SIZE - nbytes,
			  src->infile);

      if ((got == EOF) || (got == 0))
	{

	  /* EOF or error. If we got any data, don't worry about it.
	     If we didn't, then this is unexpected. */
	  if (!nbytes)
	    {

	      nbytes = -1;

	    }

	  break;

	}

      nbytes += got;

    }

  if (nbytes <= 0)
    {
      if (src->start_of_file)	/* Treat empty input file as fatal error */
	ERREXIT (cinfo, JERR_INPUT_EMPTY);
      WARNMS (cinfo, JWRN_JPEG_EOF);
      /* Insert a fake EOI marker */
      src->buffer[0] = (unsigned char) 0xFF;
      src->buffer[1] = (unsigned char) JPEG_EOI;
      nbytes = 2;
    }

  src->pub.next_input_byte = src->buffer;
  src->pub.bytes_in_buffer = nbytes;
  src->start_of_file = FALSE;

  return TRUE;
}
Exemple #15
0
METHODDEF void
start_pass_huff_decoder(j_decompress_ptr cinfo)
{
	huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
	int ci, dctbl, actbl;
	jpeg_component_info *compptr;

	/* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
	 * This ought to be an error condition, but we make it a warning because
	 * there are some baseline files out there with all zeroes in these bytes.
	 */
	if(cinfo->Ss != 0 || cinfo->Se != DCTSIZE2 - 1 ||
	        cinfo->Ah != 0 || cinfo->Al != 0)
	{
		WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
	}

	for(ci = 0; ci < cinfo->comps_in_scan; ci++)
	{
		compptr = cinfo->cur_comp_info[ci];
		dctbl = compptr->dc_tbl_no;
		actbl = compptr->ac_tbl_no;

		/* Make sure requested tables are present */
		if(dctbl < 0 || dctbl >= NUM_HUFF_TBLS ||
		        cinfo->dc_huff_tbl_ptrs[dctbl] == NULL)
		{
			ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
		}

		if(actbl < 0 || actbl >= NUM_HUFF_TBLS ||
		        cinfo->ac_huff_tbl_ptrs[actbl] == NULL)
		{
			ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
		}

		/* Compute derived values for Huffman tables */
		/* We may do this more than once for a table, but it's not expensive */
		jpeg_make_d_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[dctbl],
		                        &entropy->dc_derived_tbls[dctbl]);
		jpeg_make_d_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[actbl],
		                        &entropy->ac_derived_tbls[actbl]);
		/* Initialize DC predictions to 0 */
		entropy->saved.last_dc_val[ci] = 0;
	}

	/* Initialize bitread state variables */
	entropy->bitstate.bits_left = 0;
	entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
	entropy->bitstate.printed_eod = FALSE;

	/* Initialize restart counter */
	entropy->restarts_to_go = cinfo->restart_interval;
}
Exemple #16
0
start_pass_huff_decoder (j_decompress_ptr cinfo)
{
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  int ci, blkn, dctbl, actbl;
  d_derived_tbl **pdtbl;
  jpeg_component_info * compptr;

  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
   * This ought to be an error condition, but we make it a warning because
   * there are some baseline files out there with all zeroes in these bytes.
   */
  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
      cinfo->Ah != 0 || cinfo->Al != 0)
    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);

  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    dctbl = compptr->dc_tbl_no;
    actbl = compptr->ac_tbl_no;
    /* Compute derived values for Huffman tables */
    /* We may do this more than once for a table, but it's not expensive */
    pdtbl = entropy->dc_derived_tbls + dctbl;
    jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl, pdtbl);
    pdtbl = entropy->ac_derived_tbls + actbl;
    jpeg_make_d_derived_tbl(cinfo, FALSE, actbl, pdtbl);
    /* Initialize DC predictions to 0 */
    entropy->saved.last_dc_val[ci] = 0;
  }

  /* Precalculate decoding info for each block in an MCU of this scan */
  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
    ci = cinfo->MCU_membership[blkn];
    compptr = cinfo->cur_comp_info[ci];
    /* Precalculate which table to use for each block */
    entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
    entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
    /* Decide whether we really care about the coefficient values */
    if (compptr->component_needed) {
      entropy->dc_needed[blkn] = TRUE;
      /* we don't need the ACs if producing a 1/8th-size image */
      entropy->ac_needed[blkn] = (compptr->_DCT_scaled_size > 1);
    } else {
      entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
    }
  }

  /* Initialize bitread state variables */
  entropy->bitstate.bits_left = 0;
  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
  entropy->pub.insufficient_data = FALSE;

  /* Initialize restart counter */
  entropy->restarts_to_go = cinfo->restart_interval;
}
Exemple #17
0
start_pass_huff_decoder (j_decompress_ptr cinfo)
{
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
__boundcheck_metadata_store((void *)(&entropy),(void *)((size_t)(&entropy)+sizeof(entropy)*8-1));

  int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
int  dctbl;
__boundcheck_metadata_store((void *)(&dctbl),(void *)((size_t)(&dctbl)+sizeof(dctbl)*8-1));
int  actbl;
__boundcheck_metadata_store((void *)(&actbl),(void *)((size_t)(&actbl)+sizeof(actbl)*8-1));

  jpeg_component_info * compptr;
__boundcheck_metadata_store((void *)(&compptr),(void *)((size_t)(&compptr)+sizeof(compptr)*8-1));


  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
   * This ought to be an error condition, but we make it a warning because
   * there are some baseline files out there with all zeroes in these bytes.
   */
  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
      cinfo->Ah != 0 || cinfo->Al != 0)
    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);

  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[_RV_insert_check(0,4,92,15,"start_pass_huff_decoder",ci)];
    dctbl = compptr->dc_tbl_no;
    actbl = compptr->ac_tbl_no;
    /* Make sure requested tables are present */
    if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS ||
	cinfo->dc_huff_tbl_ptrs[_RV_insert_check(0,4,97,2,"start_pass_huff_decoder",dctbl)] == NULL)
      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
    if (actbl < 0 || actbl >= NUM_HUFF_TBLS ||
	cinfo->ac_huff_tbl_ptrs[_RV_insert_check(0,4,100,2,"start_pass_huff_decoder",actbl)] == NULL)
      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
    /* Compute derived values for Huffman tables */
    /* We may do this more than once for a table, but it's not expensive */
    jpeg_make_d_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[_RV_insert_check(0,4,104,36,"start_pass_huff_decoder",dctbl)],
			    & entropy->dc_derived_tbls[_RV_insert_check(0,4,105,10,"start_pass_huff_decoder",dctbl)]);
    jpeg_make_d_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[_RV_insert_check(0,4,106,36,"start_pass_huff_decoder",actbl)],
			    & entropy->ac_derived_tbls[_RV_insert_check(0,4,107,10,"start_pass_huff_decoder",actbl)]);
    /* Initialize DC predictions to 0 */
    entropy->saved.last_dc_val[_RV_insert_check(0,4,109,5,"start_pass_huff_decoder",ci)] = 0;
  }

  /* Initialize bitread state variables */
  entropy->bitstate.bits_left = 0;
  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
  entropy->bitstate.printed_eod = FALSE;

  /* Initialize restart counter */
  entropy->restarts_to_go = cinfo->restart_interval;
}
Exemple #18
0
sun_jpeg_fill_suspended_buffer(j_decompress_ptr cinfo)
{
    sun_jpeg_source_ptr src = (sun_jpeg_source_ptr) cinfo->src;
    JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    size_t offset, buflen;
    int ret;

    RELEASE_ARRAYS(env, src);
    ret = (*env)->CallIntMethod(env, src->hInputStream,
                                InputStream_availableID);
    if ((*env)->ExceptionOccurred(env) || !GET_ARRAYS(env, src)) {
        cinfo->err->error_exit((struct jpeg_common_struct *) cinfo);
    }
    if (ret < 0 || (unsigned int)ret <= src->remaining_skip) {
        return;
    }
    if (src->remaining_skip) {
        src->pub.skip_input_data(cinfo, 0);
    }
    /* Save the data currently in the buffer */
    offset = src->pub.bytes_in_buffer;
    if (src->pub.next_input_byte > src->inbuf) {
        memmove(src->inbuf, src->pub.next_input_byte, offset);
    }
    RELEASE_ARRAYS(env, src);
    buflen = (*env)->GetArrayLength(env, src->hInputBuffer) - offset;
    if (buflen <= 0) {
        if (!GET_ARRAYS(env, src)) {
            cinfo->err->error_exit((struct jpeg_common_struct *) cinfo);
        }
        return;
    }
    ret = (*env)->CallIntMethod(env, src->hInputStream, InputStream_readID,
                                src->hInputBuffer, offset, buflen);
    if ((ret > 0) && ((unsigned int)ret > buflen)) ret = (int)buflen;
    if ((*env)->ExceptionOccurred(env) || !GET_ARRAYS(env, src)) {
        cinfo->err->error_exit((struct jpeg_common_struct *) cinfo);
    }
    if (ret <= 0) {
        /* Silently accept truncated JPEG files */
        WARNMS(cinfo, JWRN_JPEG_EOF);
        src->inbuf[offset] = (JOCTET) 0xFF;
        src->inbuf[offset + 1] = (JOCTET) JPEG_EOI;
        ret = 2;
    }

    src->pub.next_input_byte = src->inbuf;
    src->pub.bytes_in_buffer = ret + offset;

    return;
}
Exemple #19
0
jpeg_write_raw_data( j_compress_ptr cinfo, JSAMPIMAGE data,
					 JDIMENSION num_lines )
{
	JDIMENSION lines_per_iMCU_row;
	
	if( cinfo->global_state != CSTATE_RAW_OK )
	{
		ERREXIT1( cinfo, JERR_BAD_STATE, cinfo->global_state );
	}
	if( cinfo->next_scanline >= cinfo->image_height )
	{
		WARNMS( cinfo, JWRN_TOO_MUCH_DATA );
		return 0;
	}
	
	/* Call progress monitor hook if present */
	if( cinfo->progress != NULL )
	{
		cinfo->progress->pass_counter = ( long ) cinfo->next_scanline;
		cinfo->progress->pass_limit = ( long ) cinfo->image_height;
		( *cinfo->progress->progress_monitor )( ( j_common_ptr ) cinfo );
	}
	
	/* Give master control module another chance if this is first call to
	 * jpeg_write_raw_data.  This lets output of the frame/scan headers be
	 * delayed so that application can write COM, etc, markers between
	 * jpeg_start_compress and jpeg_write_raw_data.
	 */
	if( cinfo->master->call_pass_startup )
	{
		( *cinfo->master->pass_startup )( cinfo );
	}
	
	/* Verify that at least one iMCU row has been passed. */
	lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_v_scaled_size;
	if( num_lines < lines_per_iMCU_row )
	{
		ERREXIT( cinfo, JERR_BUFFER_SIZE );
	}
	
	/* Directly compress the row. */
	if( !( *cinfo->coef->compress_data )( cinfo, data ) )
	{
		/* If compressor did not consume the whole row, suspend processing. */
		return 0;
	}
	
	/* OK, we processed one iMCU row. */
	cinfo->next_scanline += lines_per_iMCU_row;
	return lines_per_iMCU_row;
}
Exemple #20
0
boolean ImageFormatJPG::file_fill_input_buffer(j_decompress_ptr decompress) {
	FileSource *source = (FileSource*)decompress->src;
	size_t bytes = fread(source->buffer,sizeof(char),sizeof(source->buffer),source->file);
	if(bytes <= 0) {
		if(ftell(source->file) == 0) ERREXIT(decompress,JERR_INPUT_EMPTY);
		WARNMS(decompress,JWRN_JPEG_EOF);
		source->buffer[0] = (JOCTET)0xff;
		source->buffer[1] = (JOCTET)JPEG_EOI;
		bytes = 2;
	}
	source->pub.next_input_byte = source->buffer;
	source->pub.bytes_in_buffer = bytes;
	return true;
}
Exemple #21
0
static boolean jpegmemsrcmgr_fill_input_buffer(j_decompress_ptr dinfo) {
	unsigned char *buf= (unsigned char*) dinfo->src->next_input_byte-2;
	
		/* if we get called, must have run out of data */
	WARNMS(dinfo, JWRN_JPEG_EOF);
	
	buf[0]= (JOCTET) 0xFF;
	buf[1]= (JOCTET) JPEG_EOI;
	
	dinfo->src->next_input_byte= buf;
	dinfo->src->bytes_in_buffer= 2;
	
	return TRUE;
}
Exemple #22
0
fill_input_buffer (j_decompress_ptr cinfo)
{
	my_src_ptr src = (my_src_ptr) cinfo->src;

	WARNMS(cinfo, JWRN_JPEG_EOF);

	/* Create a fake EOI marker */
	src->eoi_buffer[0] = (JOCTET) 0xFF;
	src->eoi_buffer[1] = (JOCTET) JPEG_EOI;
	src->pub.next_input_byte = src->eoi_buffer;
	src->pub.bytes_in_buffer = 2;

	return TRUE;
}
Exemple #23
0
fill_input_buffer_ipp (j_decompress_ptr cinfo)
{
  my_src_ptr src = (my_src_ptr) cinfo->src;
  size_t bytes_left = src->pub.bytes_in_buffer;
  size_t bytes_to_read = INPUT_BUF_SIZE - bytes_left;

  if(src->start_of_file || cinfo->progressive_mode)
  {
    return fill_input_buffer(cinfo);
  }

  memmove(src->buffer,src->pub.next_input_byte,bytes_left);

  size_t nbytes
      = VSIFReadL(src->buffer + bytes_left, 1, bytes_to_read, src->infile);

  if(nbytes <= 0)
  {
    if(src->start_of_file)
    {
      /* Treat empty input file as fatal error */
      ERREXIT(cinfo, JERR_INPUT_EMPTY);
    }

    if(src->pub.bytes_in_buffer == 0 && cinfo->unread_marker == 0)
    {
      WARNMS(cinfo, JWRN_JPEG_EOF);

      /* Insert a fake EOI marker */
      src->buffer[0] = (JOCTET)0xFF;
      src->buffer[1] = (JOCTET)JPEG_EOI;
      nbytes = 2;
    }

    src->pub.next_input_byte = src->buffer;
    src->pub.bytes_in_buffer = bytes_left + nbytes;
    src->start_of_file = FALSE;

    return TRUE;
  }

  src->pub.next_input_byte = src->buffer;
  src->pub.bytes_in_buffer = bytes_left + nbytes;
  src->start_of_file = FALSE;

  return TRUE;
}
Exemple #24
0
jpeg_undifference6(j_decompress_ptr cinfo, int comp_index,
       JDIFFROW diff_buf, JDIFFROW prev_row,
       JDIFFROW undiff_buf, JDIMENSION width)
{
#ifdef SUPPORT_DICOMOBJECTS_BUG
  unsigned int xindex;
  int Ra, Rb, Rc;
  int min, max, temp;
  SHIFT_TEMPS
  if( dicomobjectsbug == -1 )
    {
    dicomobjectsbug = 0; /* no bug by default */

    Rb = GETJSAMPLE(prev_row[0]);
    Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF;
    undiff_buf[0] = Ra;
    temp = min = max = undiff_buf[0];

    for (xindex = 1; xindex < width; xindex++) {
      Rc = Rb;
      Rb = GETJSAMPLE(prev_row[xindex]);
      Ra = (diff_buf[xindex] + PREDICTOR6) & 0xFFFF;
      temp = Ra;
      min = temp < min ? temp : min;
      max = temp > max ? temp : max;
    }
    if( (max - min) > 50000) /* magic number */
      {
      dicomobjectsbug = 1;
      WARNMS(cinfo, JWRN_SIGNED_ARITH);
      }
    }
  if(dicomobjectsbug)
    {
    UNDIFFERENCE_2D_BUG(PREDICTOR6_BUG);
    }
  else
    {
    UNDIFFERENCE_2D_BUG(PREDICTOR6);
    }
#else
  SHIFT_TEMPS
  UNDIFFERENCE_2D(PREDICTOR6);
#endif
  (void)comp_index;(void)cinfo;
}
Exemple #25
0
METHODDEF(boolean) src_fill_buffer(j_decompress_ptr cinfo)
{
	SrcPtr src = (SrcPtr)cinfo->src;
	static const JOCTET eoi[2] = { 0xFF, JPEG_EOI };

	/*
	* since jpeg_mem_src fills the buffer with everything we've got,
	* jpeg is trying to read beyond end of buffer. return a fake EOI marker.
	* note: don't modify input buffer: it might be read-only.
	*/

	WARNMS(cinfo, JWRN_JPEG_EOF);

	src->pub.next_input_byte = eoi;
	src->pub.bytes_in_buffer = 2;
	return TRUE;
}
Exemple #26
0
static boolean
dctd_fill_input_buffer(j_decompress_ptr dinfo)
{
    jpeg_decompress_data *jddp =
    (jpeg_decompress_data *) ((char *)dinfo -
			      offset_of(jpeg_decompress_data, dinfo));

    if (!jddp->input_eod)
	return FALSE;		/* normal case: suspend processing */
    /* Reached end of source data without finding EOI */
    WARNMS(dinfo, JWRN_JPEG_EOF);
    /* Insert a fake EOI marker */
    dinfo->src->next_input_byte = fake_eoi;
    dinfo->src->bytes_in_buffer = 2;
    jddp->faked_eoi = true;	/* so process routine doesn't use next_input_byte */
    return TRUE;
}
fill_input_buffer (j_decompress_ptr cinfo)
{
    // since the initial buffer contains all the data that we have, 
    // if this method is called, it means we're out of data already
    // so we make up fake data to keep the decoder alive

    my_src_ptr src = (my_src_ptr) cinfo->src;

    WARNMS(cinfo, JWRN_JPEG_EOF);

    // Insert a fake EOI marker
    src->buffer[0] = (JOCTET) 0xFF;
    src->buffer[1] = (JOCTET) JPEG_EOI;

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

    return TRUE;
}
Exemple #28
0
static 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;
}
Exemple #29
0
//-------------------------------------------------------------------------
boolean CFKFileJpg::FillInputBuffer( j_decompress_ptr p_pInfo )
{
	size_t nBytes = 0;
	CFKFileJpg* pSource = (CFKFileJpg*)p_pInfo->src;
	nBytes = pSource->m_pFile->Read( pSource->m_pBuffer, 1, JEPG_FILE_BUF_SIZE );
	if( nBytes <= 0 )
	{
		if( pSource->m_bIsStartOfFile )
			ERREXIT( p_pInfo, JERR_INPUT_EMPTY );
		WARNMS( p_pInfo, JWRN_JPEG_EOF );

		pSource->m_pBuffer[0] = (JOCTET)0xFF;
		pSource->m_pBuffer[1] = (JOCTET)JPEG_EOI;
		nBytes = 2;
	}
	pSource->next_input_byte		= pSource->m_pBuffer;
	pSource->bytes_in_buffer		= nBytes;
	pSource->m_bIsStartOfFile		= false;
	return true;
}
Exemple #30
0
/******************************************************************************
 *
 * Function fill_input_buffer
 *
 * This is the custom source manager's fill input buffer routine, called by
 * the JPEG library whenever it has finished processing the data in the 
 * source buffer and needs it to be refilled with the next chunk of data.
 *
 *****************************************************************************/
static boolean fill_input_buffer (
    j_decompress_ptr cinfo)
{
    stream_src_ptr src = (stream_src_ptr) cinfo->src;
    size_t nbytes;

    /*
    ** Since we always process buffer-based streams in a single chunk, the
    ** only reason read_input_buffer should be called for one is if the data
    ** in the buffer was truncated or otherwise bogus.  If this is the case
    ** we set nbytes to zero, allocate a new buffer to hold a fake EOI marker
    ** so the stream buffer isn't overwritten, and let the error-handling 
    ** code below take care of things.
    */
    if (src->stream->type == _DtGrBUFFER)
    {
        nbytes = 0;
        src->buffer = (JOCTET *) (*cinfo->mem->alloc_small) (
                                          (j_common_ptr) cinfo, JPOOL_IMAGE,
				          2 * SIZEOF(JOCTET));
    }
    else /* _DtGrFILE, read the next chunk of data */
        nbytes = _DtGrRead (src->buffer, 1, src->input_buf_size, src->stream);
 
    if (nbytes <= 0) 
    {
        if (src->start_of_file)	/* Treat empty input file as fatal error */
            ERREXIT(cinfo, JERR_INPUT_EMPTY);
        WARNMS(cinfo, JWRN_JPEG_EOF);
        /* Insert a fake EOI marker */
        src->buffer[0] = (JOCTET) 0xFF;
        src->buffer[1] = (JOCTET) JPEG_EOI;
        nbytes = 2;
    }

    src->pub.next_input_byte = src->buffer;
    src->pub.bytes_in_buffer = nbytes;
    src->start_of_file = FALSE;

    return TRUE;
}