C++ WARNMS函数代码示例

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

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

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

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

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

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

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

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

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

_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;
}

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

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

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

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