jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
JDIMENSION max_lines)
{
JDIMENSION row_ctr;
__boundcheck_metadata_store((void *)(&row_ctr),(void *)((size_t)(&row_ctr)+sizeof(row_ctr)*8-1));
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;
(*(void (*)(j_common_ptr))(__boundcheck_ptr_reference(168,24,"jpeg_read_scanlines",(void *)(cinfo->progress->progress_monitor),(void *)cinfo->progress->progress_monitor))) ((j_common_ptr) cinfo);
}
/* Process some data */
row_ctr = 0;
(*(void (*)(j_decompress_ptr, JSAMPARRAY, JDIMENSION *, JDIMENSION))(__boundcheck_ptr_reference(173,18,"jpeg_read_scanlines",(void *)(cinfo->main->process_data),(void *)cinfo->main->process_data))) (cinfo, scanlines, &row_ctr, max_lines);
cinfo->output_scanline += row_ctr;
return row_ctr;
}
jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
JSAMPARRAY output_array, int dest_row,
int num_rows, JDIMENSION num_cols)
/* Copy some rows of samples from one place to another.
* num_rows rows are copied from input_array[source_row++]
* to output_array[dest_row++]; these areas may overlap for duplication.
* The source and destination arrays must be at least as wide as num_cols.
*/
{
register JSAMPROW inptr, outptr;
#ifdef FMEMCOPY
register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
#else
register JDIMENSION count;
#endif
register int row;
input_array += source_row;
output_array += dest_row;
for (row = num_rows; row > 0; row--) {
inptr = *(JSAMPARRAY)(__boundcheck_ptr_reference(132,25,"jcopy_sample_rows",(void *)(input_array),(void *)(input_array++)));
outptr = *(JSAMPARRAY)(__boundcheck_ptr_reference(133,27,"jcopy_sample_rows",(void *)(output_array),(void *)(output_array++)));
#ifdef FMEMCOPY
FMEMCOPY(outptr, inptr, count);
#else
for (count = num_cols; count > 0; count--)
*outptr++ = *inptr++; /* needn't bother with GETJSAMPLE() here */
#endif
}
}
jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
JDIMENSION max_lines)
{
JDIMENSION lines_per_iMCU_row;
__boundcheck_metadata_store((void *)(&lines_per_iMCU_row),(void *)((size_t)(&lines_per_iMCU_row)+sizeof(lines_per_iMCU_row)*8-1));
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;
(*(void (*)(j_common_ptr))(__boundcheck_ptr_reference(201,24,"jpeg_read_raw_data",(void *)(cinfo->progress->progress_monitor),(void *)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 (! (*(int (*)(j_decompress_ptr, JSAMPIMAGE))(__boundcheck_ptr_reference(210,24,"jpeg_read_raw_data",(void *)(cinfo->coef->decompress_data),(void *)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;
}
Boolean_T crc32file(char *name, DWORD *crc, long *charcnt)
{
register FILE *fin;
register DWORD oldcrc32;
register int c;
oldcrc32 = 0xFFFFFFFF; *(long *)(__boundcheck_ptr_reference(131,31,"crc32file",(void *)(charcnt),(void *)(charcnt))) = 0;
#ifdef MSDOS
if ((fin=fopen(name, "rb"))==NULL)
#else
if ((fin=fopen(name, "r"))==NULL)
#endif
{
perror(name);
return Error_;
}
while ((c=getc(fin))!=EOF)
{
++*(long *)(__boundcheck_ptr_reference(143,16,"crc32file",(void *)(charcnt),(void *)(charcnt)));
oldcrc32 = UPDC32(c, oldcrc32);
}
if (ferror(fin))
{
perror(name);
*(long *)(__boundcheck_ptr_reference(150,14,"crc32file",(void *)(charcnt),(void *)(charcnt))) = -1;
}
fclose(fin);
*(DWORD *)(__boundcheck_ptr_reference(154,8,"crc32file",(void *)(crc),(void *)(crc))) = oldcrc32 = ~oldcrc32;
return Success_;
}
read_text_integer (FILE * file, long * result, int * termchar)
/* Read an unsigned decimal integer from a file, store it in result */
/* Reads one trailing character after the integer; returns it in termchar */
{
register int ch;
register long val;
/* Skip any leading whitespace, detect EOF */
do {
ch = text_getc(file);
if (ch == EOF) {
*(int *)(__boundcheck_ptr_reference(49,8,"read_text_integer",(void *)(termchar),(void *)(termchar))) = ch;
return FALSE;
}
} while (isspace(ch));
if (! isdigit(ch)) {
*(int *)(__boundcheck_ptr_reference(55,6,"read_text_integer",(void *)(termchar),(void *)(termchar))) = ch;
return FALSE;
}
val = ch - '0';
while ((ch = text_getc(file)) != EOF) {
if (! isdigit(ch))
break;
val *= 10;
val += ch - '0';
}
*(long *)(__boundcheck_ptr_reference(66,4,"read_text_integer",(void *)(result),(void *)(result))) = val;
*(int *)(__boundcheck_ptr_reference(67,4,"read_text_integer",(void *)(termchar),(void *)(termchar))) = ch;
return TRUE;
}
read_scan_integer (FILE * file, long * result, int * termchar)
/* Variant of read_text_integer that always looks for a non-space termchar;
* this simplifies parsing of punctuation in scan scripts.
*/
{
register int ch;
if (! read_text_integer(file, result, termchar))
return FALSE;
ch = *(int *)(__boundcheck_ptr_reference(138,9,"read_scan_integer",(void *)(termchar),(void *)(termchar)));
while (ch != EOF && isspace(ch))
ch = text_getc(file);
if (isdigit(ch)) { /* oops, put it back */
if (ungetc(ch, file) == EOF)
return FALSE;
ch = ' ';
} else {
/* Any separators other than ';' and ':' are ignored;
* this allows user to insert commas, etc, if desired.
*/
if (ch != EOF && ch != ';' && ch != ':')
ch = ' ';
}
*(int *)(__boundcheck_ptr_reference(152,4,"read_scan_integer",(void *)(termchar),(void *)(termchar))) = ch;
return TRUE;
}
make_funny_pointers (j_decompress_ptr cinfo)
/* Create the funny pointer lists discussed in the comments above.
* The actual workspace is already allocated (in main->buffer),
* and the space for the pointer lists is allocated too.
* This routine just fills in the curiously ordered lists.
* This will be repeated at the beginning of each pass.
*/
{
my_main_ptr main = (my_main_ptr) cinfo->main;
__boundcheck_metadata_store((void *)(&main),(void *)((size_t)(&main)+sizeof(main)*8-1));
int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
int i;
__boundcheck_metadata_store((void *)(&i),(void *)((size_t)(&i)+sizeof(i)*8-1));
int rgroup;
__boundcheck_metadata_store((void *)(&rgroup),(void *)((size_t)(&rgroup)+sizeof(rgroup)*8-1));
int M = cinfo->min_DCT_scaled_size;
__boundcheck_metadata_store((void *)(&M),(void *)((size_t)(&M)+sizeof(M)*8-1));
jpeg_component_info *compptr;
__boundcheck_metadata_store((void *)(&compptr),(void *)((size_t)(&compptr)+sizeof(compptr)*8-1));
JSAMPARRAY buf;
__boundcheck_metadata_store((void *)(&buf),(void *)((size_t)(&buf)+sizeof(buf)*8-1));
JSAMPARRAY xbuf0;
__boundcheck_metadata_store((void *)(&xbuf0),(void *)((size_t)(&xbuf0)+sizeof(xbuf0)*8-1));
JSAMPARRAY xbuf1;
__boundcheck_metadata_store((void *)(&xbuf1),(void *)((size_t)(&xbuf1)+sizeof(xbuf1)*8-1));
for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
ci++, compptr++) {
rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
cinfo->min_DCT_scaled_size; /* height of a row group of component */
xbuf0 = main->xbuffer[_RV_insert_check(0,2,213,13,"make_funny_pointers",0)][_RV_insert_check(0,2,213,13,"make_funny_pointers",ci)];
xbuf1 = main->xbuffer[_RV_insert_check(0,2,214,13,"make_funny_pointers",1)][_RV_insert_check(0,2,214,13,"make_funny_pointers",ci)];
/* First copy the workspace pointers as-is */
buf = main->buffer[_RV_insert_check(0,10,216,11,"make_funny_pointers",ci)];
for (i = 0; i < rgroup * (M + 2); i++) {
(*(JSAMPROW *)(__boundcheck_ptr_reference(218,7,"make_funny_pointers",(void *)(&xbuf0[0]),(void *)(&xbuf0[i])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(218,18,"make_funny_pointers",(void *)(&xbuf1[0]),(void *)(&xbuf1[i])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(218,29,"make_funny_pointers",(void *)(&buf[0]),(void *)(&buf[i]))));
}
/* In the second list, put the last four row groups in swapped order */
for (i = 0; i < rgroup * 2; i++) {
(*(JSAMPROW *)(__boundcheck_ptr_reference(222,7,"make_funny_pointers",(void *)(&xbuf1[0]),(void *)(&xbuf1[rgroup * (M - 2) + i])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(222,33,"make_funny_pointers",(void *)(&buf[0]),(void *)(&buf[rgroup * M + i]))));
(*(JSAMPROW *)(__boundcheck_ptr_reference(223,7,"make_funny_pointers",(void *)(&xbuf1[0]),(void *)(&xbuf1[rgroup * M + i])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(223,29,"make_funny_pointers",(void *)(&buf[0]),(void *)(&buf[rgroup * (M - 2) + i]))));
}
/* The wraparound pointers at top and bottom will be filled later
* (see set_wraparound_pointers, below). Initially we want the "above"
* pointers to duplicate the first actual data line. This only needs
* to happen in xbuffer[0].
*/
for (i = 0; i < rgroup; i++) {
(*(JSAMPROW *)(__boundcheck_ptr_reference(231,7,"make_funny_pointers",(void *)(&xbuf0[0]),(void *)(&xbuf0[i - rgroup])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(231,27,"make_funny_pointers",(void *)(&xbuf0[0]),(void *)(&xbuf0[0]))));
}
}
}
jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
{
my_coef_ptr coef;
__boundcheck_metadata_store((void *)(&coef),(void *)((size_t)(&coef)+sizeof(coef)*8-1));
coef = (my_coef_ptr)
(*(void *(*)(j_common_ptr, int, size_t))(__boundcheck_ptr_reference(409,19,"jinit_c_coef_controller",(void *)(cinfo->mem->alloc_small),(void *)cinfo->mem->alloc_small))) ((j_common_ptr) cinfo, JPOOL_IMAGE,
SIZEOF(my_coef_controller));
cinfo->coef = (struct jpeg_c_coef_controller *) coef;
coef->pub.start_pass = start_pass_coef;
/* Create the coefficient buffer. */
if (need_full_buffer) {
#ifdef FULL_COEF_BUFFER_SUPPORTED
/* Allocate a full-image virtual array for each component, */
/* padded to a multiple of samp_factor DCT blocks in each direction. */
int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
jpeg_component_info *compptr;
__boundcheck_metadata_store((void *)(&compptr),(void *)((size_t)(&compptr)+sizeof(compptr)*8-1));
for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
ci++, compptr++) {
coef->whole_image[_RV_insert_check(0,10,424,7,"jinit_c_coef_controller",ci)] = (*(jvirt_barray_ptr (*)(j_common_ptr, int, boolean, JDIMENSION, JDIMENSION, JDIMENSION))(__boundcheck_ptr_reference(424,45,"jinit_c_coef_controller",(void *)(cinfo->mem->request_virt_barray),(void *)cinfo->mem->request_virt_barray)))
((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
(JDIMENSION) jround_up((long) compptr->width_in_blocks,
(long) compptr->h_samp_factor),
(JDIMENSION) jround_up((long) compptr->height_in_blocks,
(long) compptr->v_samp_factor),
(JDIMENSION) compptr->v_samp_factor);
}
#else
ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
#endif
} else {
/* We only need a single-MCU buffer. */
JBLOCKROW buffer;
__boundcheck_metadata_store((void *)(&buffer),(void *)((size_t)(&buffer)+sizeof(buffer)*8-1));
int i;
__boundcheck_metadata_store((void *)(&i),(void *)((size_t)(&i)+sizeof(i)*8-1));
buffer = (JBLOCKROW)
(*(void *(*)(j_common_ptr, int, size_t))(__boundcheck_ptr_reference(441,21,"jinit_c_coef_controller",(void *)(cinfo->mem->alloc_large),(void *)cinfo->mem->alloc_large))) ((j_common_ptr) cinfo, JPOOL_IMAGE,
C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
coef->MCU_buffer[_RV_insert_check(0,10,444,7,"jinit_c_coef_controller",i)] = buffer + i;
}
coef->whole_image[_RV_insert_check(0,10,446,5,"jinit_c_coef_controller",0)] = NULL; /* flag for no virtual arrays */
}
}
void show_2d_array(int array[][10], int rows)
{
int i, j;
for (i = 0; i < rows; i++)
for (j = 0; j < 10; j++)
{
// printf("array[%d][%d] = %d\n", i, j, *(*(array+i+1)+j));
printf("array[%d][%d] = %d\n", i, j, *(int *)(__boundcheck_ptr_reference(9,46,"show_2d_array",(void *)(&array[i]),(void *)(&array[i][j]))));
printf("array[%d][%d] = %d\n", i, j, *(int *)(__boundcheck_ptr_reference(9,46,"show_2d_array",(void *)(*(array + i)),(void *)(*(array+i)+j))));
}
//printf("array[%d][%d] = %d\n", i, j, *(*(int **)(__boundcheck_ptr_reference(10,41,"main",(void *)(array),(void *)(array+1)))));
}
add_huff_table (j_compress_ptr cinfo,
JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
/* Define a Huffman table */
{
if (*(JHUFF_TBL **)(__boundcheck_ptr_reference(151,8,"add_huff_table",(void *)(htblptr),(void *)(htblptr))) == NULL)
*(JHUFF_TBL **)(__boundcheck_ptr_reference(152,6,"add_huff_table",(void *)(htblptr),(void *)(htblptr))) = jpeg_alloc_huff_table((j_common_ptr) cinfo);
MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
MEMCOPY((*htblptr)->huffval, val, SIZEOF((*htblptr)->huffval));
/* Initialize sent_table FALSE so table will be written to JPEG file. */
(*(JHUFF_TBL **)(__boundcheck_ptr_reference(158,5,"add_huff_table",(void *)(htblptr),(void *)(htblptr))))->sent_table = FALSE;
}
jpeg_start_decompress (j_decompress_ptr cinfo)
{
if (cinfo->global_state == DSTATE_READY) {
/* First call: initialize master control, select active modules */
jinit_master_decompress(cinfo);
if (cinfo->buffered_image) {
/* No more work here; expecting jpeg_start_output next */
cinfo->global_state = DSTATE_BUFIMAGE;
return TRUE;
}
cinfo->global_state = DSTATE_PRELOAD;
}
if (cinfo->global_state == DSTATE_PRELOAD) {
/* If file has multiple scans, absorb them all into the coef buffer */
if (cinfo->inputctl->has_multiple_scans) {
#ifdef D_MULTISCAN_FILES_SUPPORTED
for (;;) {
int retcode;
__boundcheck_metadata_store((void *)(&retcode),(void *)((size_t)(&retcode)+sizeof(retcode)*8-1));
/* Call progress monitor hook if present */
if (cinfo->progress != NULL)
(*(void (*)(j_common_ptr))(__boundcheck_ptr_reference(58,23,"jpeg_start_decompress",(void *)(cinfo->progress->progress_monitor),(void *)cinfo->progress->progress_monitor))) ((j_common_ptr) cinfo);
/* Absorb some more input */
retcode = (*(int (*)(j_decompress_ptr))(__boundcheck_ptr_reference(60,31,"jpeg_start_decompress",(void *)(cinfo->inputctl->consume_input),(void *)cinfo->inputctl->consume_input))) (cinfo);
if (retcode == JPEG_SUSPENDED)
return FALSE;
if (retcode == JPEG_REACHED_EOI)
break;
/* Advance progress counter if appropriate */
if (cinfo->progress != NULL &&
(retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
/* jdmaster underestimated number of scans; ratchet up one scan */
cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
}
}
}
#else
ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif /* D_MULTISCAN_FILES_SUPPORTED */
}
cinfo->output_scan_number = cinfo->input_scan_number;
} else if (cinfo->global_state != DSTATE_PRESCAN)
ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
/* Perform any dummy output passes, and set up for the final pass */
return output_pass_setup(cinfo);
}
int main()
{
int a=5;
__boundcheck_metadata_store((void *)(&a),(void *)((size_t)(&a)+sizeof(a)*8-1));
int *b=&a;
__boundcheck_metadata_store((void *)(&b),(void *)((size_t)(&b)+sizeof(b)*8-1));
int ** c = &b;
__boundcheck_metadata_store((void *)(&c),(void *)((size_t)(&c)+sizeof(c)*8-1));
printf("%d\n",*(int *)(__boundcheck_ptr_reference(7,19,"main",(void *)(*c),(void *)*c)));
*(int *)(__boundcheck_ptr_reference(8,5,"main",(void *)(*c),(void *)*c)) =10;
printf("a=**c=%d\n",*(int *)(__boundcheck_ptr_reference(9,25,"main",(void *)(*c),(void *)*c)));
return 1;
}
process_restart (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));
/* Throw away any unused bits remaining in bit buffer; */
/* include any full bytes in next_marker's count of discarded bytes */
cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
entropy->bitstate.bits_left = 0;
/* Advance past the RSTn marker */
if (! (*(jpeg_marker_parser_method)(__boundcheck_ptr_reference(404,26,"process_restart",(void *)(cinfo->marker->read_restart_marker),(void *)cinfo->marker->read_restart_marker))) (cinfo))
return FALSE;
/* Re-initialize DC predictions to 0 */
for (ci = 0; ci < cinfo->comps_in_scan; ci++)
entropy->saved.last_dc_val[_RV_insert_check(0,4,409,5,"process_restart",ci)] = 0;
/* Reset restart counter */
entropy->restarts_to_go = cinfo->restart_interval;
/* Next segment can get another out-of-data warning */
entropy->bitstate.printed_eod = FALSE;
return TRUE;
}
alloc_funny_pointers (j_decompress_ptr cinfo)
/* Allocate space for the funny pointer lists.
* This is done only once, not once per pass.
*/
{
my_main_ptr main = (my_main_ptr) cinfo->main;
__boundcheck_metadata_store((void *)(&main),(void *)((size_t)(&main)+sizeof(main)*8-1));
int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
int rgroup;
__boundcheck_metadata_store((void *)(&rgroup),(void *)((size_t)(&rgroup)+sizeof(rgroup)*8-1));
int M = cinfo->min_DCT_scaled_size;
__boundcheck_metadata_store((void *)(&M),(void *)((size_t)(&M)+sizeof(M)*8-1));
jpeg_component_info *compptr;
__boundcheck_metadata_store((void *)(&compptr),(void *)((size_t)(&compptr)+sizeof(compptr)*8-1));
JSAMPARRAY xbuf;
__boundcheck_metadata_store((void *)(&xbuf),(void *)((size_t)(&xbuf)+sizeof(xbuf)*8-1));
/* Get top-level space for component array pointers.
* We alloc both arrays with one call to save a few cycles.
*/
main->xbuffer[_RV_insert_check(0,2,171,3,"alloc_funny_pointers",0)] = (JSAMPIMAGE)
(*(void *(*)(j_common_ptr, int, size_t))(__boundcheck_ptr_reference(172,19,"alloc_funny_pointers",(void *)(cinfo->mem->alloc_small),(void *)cinfo->mem->alloc_small))) ((j_common_ptr) cinfo, JPOOL_IMAGE,
cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
main->xbuffer[_RV_insert_check(0,2,174,3,"alloc_funny_pointers",1)] = main->xbuffer[_RV_insert_check(0,2,174,22,"alloc_funny_pointers",0)] + cinfo->num_components;
for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
ci++, compptr++) {
rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
cinfo->min_DCT_scaled_size; /* height of a row group of component */
/* Get space for pointer lists --- M+4 row groups in each list.
* We alloc both pointer lists with one call to save a few cycles.
*/
xbuf = (JSAMPARRAY)
(*(void *(*)(j_common_ptr, int, size_t))(__boundcheck_ptr_reference(184,21,"alloc_funny_pointers",(void *)(cinfo->mem->alloc_small),(void *)cinfo->mem->alloc_small))) ((j_common_ptr) cinfo, JPOOL_IMAGE,
2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
xbuf += rgroup; /* want one row group at negative offsets */
main->xbuffer[_RV_insert_check(0,2,187,5,"alloc_funny_pointers",0)][_RV_insert_check(0,2,187,5,"alloc_funny_pointers",ci)] = xbuf;
xbuf += rgroup * (M + 4);
main->xbuffer[_RV_insert_check(0,2,189,5,"alloc_funny_pointers",1)][_RV_insert_check(0,2,189,5,"alloc_funny_pointers",ci)] = xbuf;
}
}
bool conver(int d[],int b[])
{
int i;
__boundcheck_metadata_store((void *)(&i),(void *)((size_t)(&i)+sizeof(i)*8-1));
int *p;
__boundcheck_metadata_store((void *)(&p),(void *)((size_t)(&p)+sizeof(p)*8-1));
int *q;
__boundcheck_metadata_store((void *)(&q),(void *)((size_t)(&q)+sizeof(q)*8-1));
p=b;
__boundcheck_metadata_trans_check((void *)(p),(void *)(b),(void *)(b));
printf("%d\n",*(int *)(__boundcheck_ptr_reference(8,23,"conver",(void *)(p),(void *)(p+2))));
for(i=0;i<5;i++)
(*(int *)(__boundcheck_ptr_reference(10,7,"conver",(void *)(&d[0]),(void *)(&d[i]))))=(*(int *)(__boundcheck_ptr_reference(10,12,"conver",(void *)(&b[0]),(void *)(&b[i]))));
return 1;
}
jinit_compress_master (j_compress_ptr cinfo)
{
/* Initialize master control (includes parameter checking/processing) */
jinit_c_master_control(cinfo, FALSE /* full compression */);
/* Preprocessing */
if (! cinfo->raw_data_in) {
jinit_color_converter(cinfo);
jinit_downsampler(cinfo);
jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
}
/* Forward DCT */
jinit_forward_dct(cinfo);
/* Entropy encoding: either Huffman or arithmetic coding. */
if (cinfo->arith_code) {
ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
} else {
if (cinfo->progressive_mode) {
#ifdef C_PROGRESSIVE_SUPPORTED
jinit_phuff_encoder(cinfo);
#else
ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif
} else
jinit_huff_encoder(cinfo);
}
/* Need a full-image coefficient buffer in any multi-pass mode. */
jinit_c_coef_controller(cinfo,
(cinfo->num_scans > 1 || cinfo->optimize_coding));
jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);
jinit_marker_writer(cinfo);
/* We can now tell the memory manager to allocate virtual arrays. */
(*(void (*)(j_common_ptr))(__boundcheck_ptr_reference(65,17,"jinit_compress_master",(void *)(cinfo->mem->realize_virt_arrays),(void *)cinfo->mem->realize_virt_arrays))) ((j_common_ptr) cinfo);
/* Write the datastream header (SOI) immediately.
* Frame and scan headers are postponed till later.
* This lets application insert special markers after the SOI.
*/
(*(void (*)(j_compress_ptr))(__boundcheck_ptr_reference(71,20,"jinit_compress_master",(void *)(cinfo->marker->write_file_header),(void *)cinfo->marker->write_file_header))) (cinfo);
}
output_pass_setup (j_decompress_ptr cinfo)
{
if (cinfo->global_state != DSTATE_PRESCAN) {
/* First call: do pass setup */
(*(void (*)(j_decompress_ptr))(__boundcheck_ptr_reference(99,22,"output_pass_setup",(void *)(cinfo->master->prepare_for_output_pass),(void *)cinfo->master->prepare_for_output_pass))) (cinfo);
cinfo->output_scanline = 0;
cinfo->global_state = DSTATE_PRESCAN;
}
/* Loop over any required dummy passes */
while (cinfo->master->is_dummy_pass) {
#ifdef QUANT_2PASS_SUPPORTED
/* Crank through the dummy pass */
while (cinfo->output_scanline < cinfo->output_height) {
JDIMENSION last_scanline;
__boundcheck_metadata_store((void *)(&last_scanline),(void *)((size_t)(&last_scanline)+sizeof(last_scanline)*8-1));
/* 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;
(*(void (*)(j_common_ptr))(__boundcheck_ptr_reference(113,21,"output_pass_setup",(void *)(cinfo->progress->progress_monitor),(void *)cinfo->progress->progress_monitor))) ((j_common_ptr) cinfo);
}
/* Process some data */
last_scanline = cinfo->output_scanline;
(*(void (*)(j_decompress_ptr, JSAMPARRAY, JDIMENSION *, JDIMENSION))(__boundcheck_ptr_reference(117,22,"output_pass_setup",(void *)(cinfo->main->process_data),(void *)cinfo->main->process_data))) (cinfo, (JSAMPARRAY) NULL,
&cinfo->output_scanline, (JDIMENSION) 0);
if (cinfo->output_scanline == last_scanline)
return FALSE; /* No progress made, must suspend */
}
/* Finish up dummy pass, and set up for another one */
(*(void (*)(j_decompress_ptr))(__boundcheck_ptr_reference(123,22,"output_pass_setup",(void *)(cinfo->master->finish_output_pass),(void *)cinfo->master->finish_output_pass))) (cinfo);
(*(void (*)(j_decompress_ptr))(__boundcheck_ptr_reference(124,22,"output_pass_setup",(void *)(cinfo->master->prepare_for_output_pass),(void *)cinfo->master->prepare_for_output_pass))) (cinfo);
cinfo->output_scanline = 0;
#else
ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif /* QUANT_2PASS_SUPPORTED */
}
/* Ready for application to drive output pass through
* jpeg_read_scanlines or jpeg_read_raw_data.
*/
cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING;
return TRUE;
}
set_sample_factors (j_compress_ptr cinfo, char *arg)
/* Process a sample-factors parameter string, of the form
* HxV[,HxV,...]
* If there are more components than parameters, "1x1" is assumed for the rest.
*/
{
int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
int val1;
__boundcheck_metadata_store((void *)(&val1),(void *)((size_t)(&val1)+sizeof(val1)*8-1));
int val2;
__boundcheck_metadata_store((void *)(&val2),(void *)((size_t)(&val2)+sizeof(val2)*8-1));
char ch1;
__boundcheck_metadata_store((void *)(&ch1),(void *)((size_t)(&ch1)+sizeof(ch1)*8-1));
char ch2;
__boundcheck_metadata_store((void *)(&ch2),(void *)((size_t)(&ch2)+sizeof(ch2)*8-1));
for (ci = 0; ci < MAX_COMPONENTS; ci++) {
if (*(char *)(__boundcheck_ptr_reference(311,10,"set_sample_factors",(void *)(arg),(void *)(arg)))) {
ch2 = ','; /* if not set by sscanf, will be ',' */
if (sscanf(arg, "%d%c%d%c", &val1, &ch1, &val2, &ch2) < 3)
return FALSE;
if ((ch1 != 'x' && ch1 != 'X') || ch2 != ',') /* syntax check */
return FALSE;
if (val1 <= 0 || val1 > 4 || val2 <= 0 || val2 > 4) {
fprintf(stderr, "JPEG sampling factors must be 1..4\n");
return FALSE;
}
cinfo->comp_info[ci].h_samp_factor = val1;
cinfo->comp_info[ci].v_samp_factor = val2;
while (*(char *)(__boundcheck_ptr_reference(323,15,"set_sample_factors",(void *)(arg),(void *)(arg))) && *(char *)(__boundcheck_ptr_reference(323,26,"set_sample_factors",(void *)(arg),(void *)(arg++))) != ',') /* advance to next segment of arg string */
;
} else {
/* reached end of parameter, set remaining components to 1x1 sampling */
cinfo->comp_info[ci].h_samp_factor = 1;
cinfo->comp_info[ci].v_samp_factor = 1;
}
}
return TRUE;
}
set_wraparound_pointers (j_decompress_ptr cinfo)
/* Set up the "wraparound" pointers at top and bottom of the pointer lists.
* This changes the pointer list state from top-of-image to the normal state.
*/
{
my_main_ptr main = (my_main_ptr) cinfo->main;
__boundcheck_metadata_store((void *)(&main),(void *)((size_t)(&main)+sizeof(main)*8-1));
int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
int i;
__boundcheck_metadata_store((void *)(&i),(void *)((size_t)(&i)+sizeof(i)*8-1));
int rgroup;
__boundcheck_metadata_store((void *)(&rgroup),(void *)((size_t)(&rgroup)+sizeof(rgroup)*8-1));
int M = cinfo->min_DCT_scaled_size;
__boundcheck_metadata_store((void *)(&M),(void *)((size_t)(&M)+sizeof(M)*8-1));
jpeg_component_info *compptr;
__boundcheck_metadata_store((void *)(&compptr),(void *)((size_t)(&compptr)+sizeof(compptr)*8-1));
JSAMPARRAY xbuf0;
__boundcheck_metadata_store((void *)(&xbuf0),(void *)((size_t)(&xbuf0)+sizeof(xbuf0)*8-1));
JSAMPARRAY xbuf1;
__boundcheck_metadata_store((void *)(&xbuf1),(void *)((size_t)(&xbuf1)+sizeof(xbuf1)*8-1));
for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
ci++, compptr++) {
rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
cinfo->min_DCT_scaled_size; /* height of a row group of component */
xbuf0 = main->xbuffer[_RV_insert_check(0,2,253,13,"set_wraparound_pointers",0)][_RV_insert_check(0,2,253,13,"set_wraparound_pointers",ci)];
xbuf1 = main->xbuffer[_RV_insert_check(0,2,254,13,"set_wraparound_pointers",1)][_RV_insert_check(0,2,254,13,"set_wraparound_pointers",ci)];
for (i = 0; i < rgroup; i++) {
(*(JSAMPROW *)(__boundcheck_ptr_reference(256,7,"set_wraparound_pointers",(void *)(&xbuf0[0]),(void *)(&xbuf0[i - rgroup])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(256,27,"set_wraparound_pointers",(void *)(&xbuf0[0]),(void *)(&xbuf0[rgroup * (M + 1) + i]))));
(*(JSAMPROW *)(__boundcheck_ptr_reference(257,7,"set_wraparound_pointers",(void *)(&xbuf1[0]),(void *)(&xbuf1[i - rgroup])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(257,27,"set_wraparound_pointers",(void *)(&xbuf1[0]),(void *)(&xbuf1[rgroup * (M + 1) + i]))));
(*(JSAMPROW *)(__boundcheck_ptr_reference(258,7,"set_wraparound_pointers",(void *)(&xbuf0[0]),(void *)(&xbuf0[rgroup * (M + 2) + i])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(258,33,"set_wraparound_pointers",(void *)(&xbuf0[0]),(void *)(&xbuf0[i]))));
(*(JSAMPROW *)(__boundcheck_ptr_reference(259,7,"set_wraparound_pointers",(void *)(&xbuf1[0]),(void *)(&xbuf1[rgroup * (M + 2) + i])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(259,33,"set_wraparound_pointers",(void *)(&xbuf1[0]),(void *)(&xbuf1[i]))));
}
}
}
jpeg_finish_output (j_decompress_ptr cinfo)
{
if ((cinfo->global_state == DSTATE_SCANNING ||
cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
/* Terminate this pass. */
/* We do not require the whole pass to have been completed. */
(*(void (*)(j_decompress_ptr))(__boundcheck_ptr_reference(259,22,"jpeg_finish_output",(void *)(cinfo->master->finish_output_pass),(void *)cinfo->master->finish_output_pass))) (cinfo);
cinfo->global_state = DSTATE_BUFPOST;
} else if (cinfo->global_state != DSTATE_BUFPOST) {
/* BUFPOST = repeat call after a suspension, anything else is error */
ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
}
/* Read markers looking for SOS or EOI */
while (cinfo->input_scan_number <= cinfo->output_scan_number &&
! cinfo->inputctl->eoi_reached) {
if ((*(int (*)(j_decompress_ptr))(__boundcheck_ptr_reference(268,28,"jpeg_finish_output",(void *)(cinfo->inputctl->consume_input),(void *)cinfo->inputctl->consume_input))) (cinfo) == JPEG_SUSPENDED)
return FALSE; /* Suspend, come back later */
}
cinfo->global_state = DSTATE_BUFIMAGE;
return TRUE;
}
void show_2d_array(int array[][10], int rows)
{
int i;
__boundcheck_metadata_store((void *)(&i),(void *)((size_t)(&i)+sizeof(i)*8-1));
int j;
__boundcheck_metadata_store((void *)(&j),(void *)((size_t)(&j)+sizeof(j)*8-1));
for (i = 0; i < rows; i++)
for (j = 0; j < 10; j++)
printf("array[%d][%d] = %d\n", i, j, *(int *)(__boundcheck_ptr_reference(9,59,"show_2d_array",(void *)(*(array + i)),(void *)(*(array+i)+j))));
}
int main()
{
int i=0;
__boundcheck_metadata_store((void *)(&i),(void *)((size_t)(&i)+sizeof(i)*8-1));
char *__tmp_string_2="tytui";
__boundcheck_metadata_store((void *)(__tmp_string_2),(void *)(__tmp_string_2+5));
char *__tmp_string_1="rteyy";
__boundcheck_metadata_store((void *)(__tmp_string_1),(void *)(__tmp_string_1+5));
char *__tmp_string_0="qwee";
__boundcheck_metadata_store((void *)(__tmp_string_0),(void *)(__tmp_string_0+4));
char *a[3]={__tmp_string_0,__tmp_string_1,__tmp_string_2};__boundcheck_metadata_store(&a[0],&a[3-1]);
int j;
__boundcheck_metadata_store((void *)(&j),(void *)((size_t)(&j)+sizeof(j)*8-1));
char *string[10];__boundcheck_metadata_store(&string[0],&string[10-1]);
char **p;
__boundcheck_metadata_store((void *)(&p),(void *)((size_t)(&p)+sizeof(p)*8-1));
if(i)
{
for(j=0;j<10;j++)
{
string[_RV_insert_check(0,10,15,9,"main",j)]=(char *)__boundcheck_malloc(100*sizeof(char));
}
__boundcheck_strcpy(string[_RV_insert_check(0,10,17,14,"main",5)],"ASADAD");
p=&string[_RV_insert_check(0,10,18,10,"main",5)];
}
else
p=a;
__boundcheck_metadata_trans_check((void *)(p),(void *)(a),(void *)(a));
printf("%s\n",*(char **)(__boundcheck_ptr_reference(22,19,"main",(void *)(p),(void *)(p))));
printf("%c\n",*(char *)(__boundcheck_ptr_reference(23,20,"main",(void *)(*p),(void *)*p)));
printf("a=%p a[0]=%p\n",&a,&a[_RV_insert_check(0,3,24,32,"main",0)]);
printf("%p %p\n",&p,&(*(char **)(__boundcheck_ptr_reference(25,27,"main",(void *)(p),(void *)(p)))));
return 1;
}
jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
const unsigned int *basic_table,
int scale_factor, boolean force_baseline)
/* Define a quantization table equal to the basic_table times
* a scale factor (given as a percentage).
* If force_baseline is TRUE, the computed quantization table entries
* are limited to 1..255 for JPEG baseline compatibility.
*/
{
JQUANT_TBL ** qtblptr = & cinfo->quant_tbl_ptrs[_RV_insert_check(0,4,32,29,"jpeg_add_quant_table",which_tbl)];
__boundcheck_metadata_store((void *)(&qtblptr),(void *)((size_t)(&qtblptr)+sizeof(qtblptr)*8-1));
int i;
__boundcheck_metadata_store((void *)(&i),(void *)((size_t)(&i)+sizeof(i)*8-1));
long temp;
__boundcheck_metadata_store((void *)(&temp),(void *)((size_t)(&temp)+sizeof(temp)*8-1));
/* Safety check to ensure start_compress not called yet. */
if (cinfo->global_state != CSTATE_START)
ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
if (*(JQUANT_TBL **)(__boundcheck_ptr_reference(40,8,"jpeg_add_quant_table",(void *)(qtblptr),(void *)(qtblptr))) == NULL)
*(JQUANT_TBL **)(__boundcheck_ptr_reference(41,6,"jpeg_add_quant_table",(void *)(qtblptr),(void *)(qtblptr))) = jpeg_alloc_quant_table((j_common_ptr) cinfo);
for (i = 0; i < DCTSIZE2; i++) {
temp = ((long) (*(const unsigned int *)(__boundcheck_ptr_reference(44,20,"jpeg_add_quant_table",(void *)(&basic_table[0]),(void *)(&basic_table[i])))) * scale_factor + 50L) / 100L;
/* limit the values to the valid range */
if (temp <= 0L) temp = 1L;
if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
if (force_baseline && temp > 255L)
temp = 255L; /* limit to baseline range if requested */
(*(JQUANT_TBL **)(__boundcheck_ptr_reference(50,7,"jpeg_add_quant_table",(void *)(qtblptr),(void *)(qtblptr))))->quantval[_RV_insert_check(0,64,50,5,"jpeg_add_quant_table",i)] = (UINT16) temp;
}
/* Initialize sent_table FALSE so table will be written to JPEG file. */
(*(JQUANT_TBL **)(__boundcheck_ptr_reference(54,5,"jpeg_add_quant_table",(void *)(qtblptr),(void *)(qtblptr))))->sent_table = FALSE;
}
set_quant_slots (j_compress_ptr cinfo, char *arg)
/* Process a quantization-table-selectors parameter string, of the form
* N[,N,...]
* If there are more components than parameters, the last value is replicated.
*/
{
int val = 0;
__boundcheck_metadata_store((void *)(&val),(void *)((size_t)(&val)+sizeof(val)*8-1));
/* default table # */
int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
char ch;
__boundcheck_metadata_store((void *)(&ch),(void *)((size_t)(&ch)+sizeof(ch)*8-1));
for (ci = 0; ci < MAX_COMPONENTS; ci++) {
if (*(char *)(__boundcheck_ptr_reference(277,10,"set_quant_slots",(void *)(arg),(void *)(arg)))) {
ch = ','; /* if not set by sscanf, will be ',' */
if (sscanf(arg, "%d%c", &val, &ch) < 1)
return FALSE;
if (ch != ',') /* syntax check */
return FALSE;
if (val < 0 || val >= NUM_QUANT_TBLS) {
fprintf(stderr, "JPEG quantization tables are numbered 0..%d\n",
NUM_QUANT_TBLS-1);
return FALSE;
}
cinfo->comp_info[ci].quant_tbl_no = val;
while (*(char *)(__boundcheck_ptr_reference(289,15,"set_quant_slots",(void *)(arg),(void *)(arg))) && *(char *)(__boundcheck_ptr_reference(289,26,"set_quant_slots",(void *)(arg),(void *)(arg++))) != ',') /* advance to next segment of arg string */
;
} else {
/* reached end of parameter, set remaining components to last table */
cinfo->comp_info[ci].quant_tbl_no = val;
}
}
return TRUE;
}
set_bottom_pointers (j_decompress_ptr cinfo)
/* Change the pointer lists to duplicate the last sample row at the bottom
* of the image. whichptr indicates which xbuffer holds the final iMCU row.
* Also sets rowgroups_avail to indicate number of nondummy row groups in row.
*/
{
my_main_ptr main = (my_main_ptr) cinfo->main;
__boundcheck_metadata_store((void *)(&main),(void *)((size_t)(&main)+sizeof(main)*8-1));
int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
int i;
__boundcheck_metadata_store((void *)(&i),(void *)((size_t)(&i)+sizeof(i)*8-1));
int rgroup;
__boundcheck_metadata_store((void *)(&rgroup),(void *)((size_t)(&rgroup)+sizeof(rgroup)*8-1));
int iMCUheight;
__boundcheck_metadata_store((void *)(&iMCUheight),(void *)((size_t)(&iMCUheight)+sizeof(iMCUheight)*8-1));
int rows_left;
__boundcheck_metadata_store((void *)(&rows_left),(void *)((size_t)(&rows_left)+sizeof(rows_left)*8-1));
jpeg_component_info *compptr;
__boundcheck_metadata_store((void *)(&compptr),(void *)((size_t)(&compptr)+sizeof(compptr)*8-1));
JSAMPARRAY xbuf;
__boundcheck_metadata_store((void *)(&xbuf),(void *)((size_t)(&xbuf)+sizeof(xbuf)*8-1));
for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
ci++, compptr++) {
/* Count sample rows in one iMCU row and in one row group */
iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;
rgroup = iMCUheight / cinfo->min_DCT_scaled_size;
/* Count nondummy sample rows remaining for this component */
rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
if (rows_left == 0) rows_left = iMCUheight;
/* Count nondummy row groups. Should get same answer for each component,
* so we need only do it once.
*/
if (ci == 0) {
main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
}
/* Duplicate the last real sample row rgroup*2 times; this pads out the
* last partial rowgroup and ensures at least one full rowgroup of context.
*/
xbuf = main->xbuffer[_RV_insert_check(0,2,294,12,"set_bottom_pointers",main->whichptr)][_RV_insert_check(0,2,294,12,"set_bottom_pointers",ci)];
for (i = 0; i < rgroup * 2; i++) {
(*(JSAMPROW *)(__boundcheck_ptr_reference(296,7,"set_bottom_pointers",(void *)(&xbuf[0]),(void *)(&xbuf[rows_left + i])))) = (*(JSAMPROW *)(__boundcheck_ptr_reference(296,29,"set_bottom_pointers",(void *)(&xbuf[0]),(void *)(&xbuf[rows_left - 1]))));
}
}
}
void show_3d_array(int values[][3][4],int rows)
{
int row;
//__boundcheck_metadata_store(&(row),&(row));
int column;
//__boundcheck_metadata_store(&(column),&(column));
int table;
//__boundcheck_metadata_store(&(table),&(table));
for (row = 0; row < 2; row++)
for (column = 0; column < 3; column++)
for (table = 0; table < rows; table++)
printf("values[%d][%d][%d] = %d\n", row,column,table,*(int *)(__boundcheck_ptr_reference(9,46,"show_2d_array",(void *)(&values[row][column]),(void *)(&values[row][column][table]))));
}
void show_3d_array(int values[][3][4],int rows)
{
int row;
__boundcheck_metadata_store((void *)(&row),(void *)((size_t)(&row)+sizeof(row)*8-1));
int column;
__boundcheck_metadata_store((void *)(&column),(void *)((size_t)(&column)+sizeof(column)*8-1));
int table;
__boundcheck_metadata_store((void *)(&table),(void *)((size_t)(&table)+sizeof(table)*8-1));
for (row = 0; row < 2; row++)
for (column = 0; column < 3; column++)
for (table = 0; table < rows; table++)
printf("values[%d][%d][%d] = %d\n", row,column,table,(*(int *)(__boundcheck_ptr_reference(18,58,"show_3d_array",(void *)(&values[row][column][0]),(void *)(&values[row][column][table])))));
}
add_map_entry (j_decompress_ptr cinfo, int R, int G, int B)
{
JSAMPROW colormap0 = cinfo->colormap[0];
__boundcheck_metadata_store((void *)(&colormap0),(void *)((size_t)(&colormap0)+sizeof(colormap0)*8-1));
JSAMPROW colormap1 = cinfo->colormap[1];
__boundcheck_metadata_store((void *)(&colormap1),(void *)((size_t)(&colormap1)+sizeof(colormap1)*8-1));
JSAMPROW colormap2 = cinfo->colormap[2];
__boundcheck_metadata_store((void *)(&colormap2),(void *)((size_t)(&colormap2)+sizeof(colormap2)*8-1));
int ncolors = cinfo->actual_number_of_colors;
__boundcheck_metadata_store((void *)(&ncolors),(void *)((size_t)(&ncolors)+sizeof(ncolors)*8-1));
int index;
__boundcheck_metadata_store((void *)(&index),(void *)((size_t)(&index)+sizeof(index)*8-1));
/* Check for duplicate color. */
for (index = 0; index < ncolors; index++) {
if (GETJSAMPLE(colormap0[index]) == R &&
GETJSAMPLE(colormap1[index]) == G &&
GETJSAMPLE(colormap2[index]) == B)
return; /* color is already in map */
}
/* Check for map overflow. */
if (ncolors >= (MAXJSAMPLE+1))
ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, (MAXJSAMPLE+1));
/* OK, add color to map. */
(*(JSAMPLE *)(__boundcheck_ptr_reference(67,3,"add_map_entry",(void *)(&colormap0[0]),(void *)(&colormap0[ncolors])))) = (JSAMPLE) R;
(*(JSAMPLE *)(__boundcheck_ptr_reference(68,3,"add_map_entry",(void *)(&colormap1[0]),(void *)(&colormap1[ncolors])))) = (JSAMPLE) G;
(*(JSAMPLE *)(__boundcheck_ptr_reference(69,3,"add_map_entry",(void *)(&colormap2[0]),(void *)(&colormap2[ncolors])))) = (JSAMPLE) B;
cinfo->actual_number_of_colors++;
}
jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
{
my_main_ptr main;
__boundcheck_metadata_store((void *)(&main),(void *)((size_t)(&main)+sizeof(main)*8-1));
int ci;
__boundcheck_metadata_store((void *)(&ci),(void *)((size_t)(&ci)+sizeof(ci)*8-1));
int rgroup;
__boundcheck_metadata_store((void *)(&rgroup),(void *)((size_t)(&rgroup)+sizeof(rgroup)*8-1));
int ngroups;
__boundcheck_metadata_store((void *)(&ngroups),(void *)((size_t)(&ngroups)+sizeof(ngroups)*8-1));
jpeg_component_info *compptr;
__boundcheck_metadata_store((void *)(&compptr),(void *)((size_t)(&compptr)+sizeof(compptr)*8-1));
main = (my_main_ptr)
(*(void *(*)(j_common_ptr, int, size_t))(__boundcheck_ptr_reference(483,19,"jinit_d_main_controller",(void *)(cinfo->mem->alloc_small),(void *)cinfo->mem->alloc_small))) ((j_common_ptr) cinfo, JPOOL_IMAGE,
SIZEOF(my_main_controller));
cinfo->main = (struct jpeg_d_main_controller *) main;
main->pub.start_pass = start_pass_main;
if (need_full_buffer) /* shouldn't happen */
ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
/* Allocate the workspace.
* ngroups is the number of row groups we need.
*/
if (cinfo->upsample->need_context_rows) {
if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */
ERREXIT(cinfo, JERR_NOTIMPL);
alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
ngroups = cinfo->min_DCT_scaled_size + 2;
} else {
ngroups = cinfo->min_DCT_scaled_size;
}
for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
ci++, compptr++) {
rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
cinfo->min_DCT_scaled_size; /* height of a row group of component */
main->buffer[_RV_insert_check(0,10,507,5,"jinit_d_main_controller",ci)] = (*(JSAMPARRAY (*)(j_common_ptr, int, JDIMENSION, JDIMENSION))(__boundcheck_ptr_reference(507,38,"jinit_d_main_controller",(void *)(cinfo->mem->alloc_sarray),(void *)cinfo->mem->alloc_sarray)))
((j_common_ptr) cinfo, JPOOL_IMAGE,
compptr->width_in_blocks * compptr->DCT_scaled_size,
(JDIMENSION) (rgroup * ngroups));
}
}
read_color_map (j_decompress_ptr cinfo, FILE * infile)
{
/* Allocate space for a color map of maximum supported size. */
cinfo->colormap = (*(JSAMPARRAY (*)(j_common_ptr, int, JDIMENSION, JDIMENSION))(__boundcheck_ptr_reference(234,35,"read_color_map",(void *)(cinfo->mem->alloc_sarray),(void *)cinfo->mem->alloc_sarray)))
((j_common_ptr) cinfo, JPOOL_IMAGE,
(JDIMENSION) (MAXJSAMPLE+1), (JDIMENSION) 3);
cinfo->actual_number_of_colors = 0; /* initialize map to empty */
/* Read first byte to determine file format */
switch (getc(infile)) {
case 'G':
read_gif_map(cinfo, infile);
break;
case 'P':
read_ppm_map(cinfo, infile);
break;
default:
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
break;
}
}