static opj_bool jp2_read_cdef(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_box_t *box, opj_jp2_color_t *color) { opj_jp2_cdef_info_t *info; unsigned short i, n; OPJ_ARG_NOT_USED(box); OPJ_ARG_NOT_USED(jp2); /* Part 1, I.5.3.6: 'The shall be at most one Channel Definition box * inside a JP2 Header box.' */ if(color->jp2_cdef) return OPJ_FALSE; if((n = (unsigned short)cio_read(cio, 2)) == 0) return OPJ_FALSE; /* szukw000: FIXME */ info = (opj_jp2_cdef_info_t*) opj_malloc(n * sizeof(opj_jp2_cdef_info_t)); color->jp2_cdef = (opj_jp2_cdef_t*)opj_malloc(sizeof(opj_jp2_cdef_t)); color->jp2_cdef->info = info; color->jp2_cdef->n = n; for(i = 0; i < n; ++i) { info[i].cn = (unsigned short)cio_read(cio, 2); info[i].typ = (unsigned short)cio_read(cio, 2); info[i].asoc = (unsigned short)cio_read(cio, 2); } return OPJ_TRUE; }/* jp2_read_cdef() */
static opj_bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_box_t *box, opj_jp2_color_t *color) { opj_jp2_cmap_comp_t *cmap; unsigned short i, nr_channels; OPJ_ARG_NOT_USED(box); OPJ_ARG_NOT_USED(jp2); /* Need nr_channels: */ if(color->jp2_pclr == NULL) return OPJ_FALSE; /* Part 1, I.5.3.5: 'There shall be at most one Component Mapping box * inside a JP2 Header box' : */ if(color->jp2_pclr->cmap) return OPJ_FALSE; nr_channels = color->jp2_pclr->nr_channels; cmap = (opj_jp2_cmap_comp_t*) opj_malloc(nr_channels * sizeof(opj_jp2_cmap_comp_t)); for(i = 0; i < nr_channels; ++i) { cmap[i].cmp = (unsigned short)cio_read(cio, 2); cmap[i].mtyp = cio_read(cio, 1); cmap[i].pcol = cio_read(cio, 1); } color->jp2_pclr->cmap = cmap; return OPJ_TRUE; }/* jp2_read_cmap() */
static opj_bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box) { box->init_pos = cio_tell(cio); box->length = cio_read(cio, 4); box->type = cio_read(cio, 4); if (box->length == 1) { if (cio_read(cio, 4) != 0) { opj_event_msg(cinfo, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n"); return OPJ_FALSE; } box->length = cio_read(cio, 4); if (box->length == 0) { box->length = cio_numbytesleft(cio) + 12; } } else if (box->length == 0) { box->length = cio_numbytesleft(cio) + 8; } if (box->length < 0) { opj_event_msg(cinfo, EVT_ERROR, "Integer overflow in box->length\n"); return OPJ_FALSE; /* TODO: actually check jp2_read_boxhdr's return value */ } return OPJ_TRUE; }
int jp2_read_colr(jp2_struct_t * jp2_struct) { jp2_box_t box; jp2_read_boxhdr(&box); if (JP2_COLR != box.type) { fprintf(stderr, "Error: Expected COLR Marker\n"); return 1; } jp2_struct->meth = cio_read(1); // METH jp2_struct->precedence = cio_read(1); // PRECEDENCE jp2_struct->approx = cio_read(1); // APPROX if (jp2_struct->meth == 1) jp2_struct->enumcs = cio_read(4); // EnumCS else cio_read(1); // PROFILE if (cio_tell() - box.init_pos != box.length) { fprintf(stderr, "Error with BPCC Box\n"); return 1; } return 0; }
static opj_bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) { int i; opj_jp2_box_t box; opj_common_ptr cinfo = jp2->cinfo; if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) { opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n"); return OPJ_FALSE; } if (JP2_FTYP != box.type) { opj_event_msg(cinfo, EVT_ERROR, "Expected FTYP Marker\n"); return OPJ_FALSE; } jp2->brand = cio_read(cio, 4); /* BR */ jp2->minversion = cio_read(cio, 4); /* MinV */ jp2->numcl = (box.length - 16) / 4; jp2->cl = (unsigned int *) opj_malloc(jp2->numcl * sizeof(unsigned int)); for (i = 0; i < (int)jp2->numcl; i++) { jp2->cl[i] = cio_read(cio, 4); /* CLi */ } if (cio_tell(cio) - box.init_pos != box.length) { opj_event_msg(cinfo, EVT_ERROR, "Error with FTYP Box\n"); return OPJ_FALSE; } return OPJ_TRUE; }
/* * Read the FTYP box * * File type box * */ int jp2_read_ftyp(jp2_struct_t * jp2_struct) { int i; jp2_box_t box; jp2_read_boxhdr(&box); if (JP2_FTYP != box.type) { fprintf(stderr, "Error: Excpected FTYP Marker\n"); return 1; } jp2_struct->brand = cio_read(4); /* BR */ jp2_struct->minversion = cio_read(4); /* MinV */ jp2_struct->numcl = (box.length - 16) / 4; jp2_struct->cl = (unsigned int *) malloc(jp2_struct->numcl * sizeof(unsigned int)); for (i = jp2_struct->numcl; i > 0; i--) jp2_struct->cl[i] = cio_read(4); /* CLi */ if (cio_tell() - box.init_pos != box.length) { fprintf(stderr, "Error with FTYP Box\n"); return 1; } return 0; }
/* void j2k_write_coc(int compno) { j2k_tcp_t *tcp; int lenp, len; log_print(LOG_TRACE, "%.8x: COC\n", cio_tell()); cio_write(J2K_MS_COC, 2); lenp=cio_tell(); cio_skip(2); tcp=&j2k_cp->tcps[j2k_curtileno]; cio_write(compno, j2k_img->numcomps<=256?1:2); cio_write(tcp->tccps[compno].csty, 1); j2k_write_cox(compno); len=cio_tell()-lenp; cio_seek(lenp); cio_write(len, 2); cio_seek(lenp+len); } */ void j2k_read_coc() { int len, compno; j2k_tcp_t *tcp; // log_print(LOG_TRACE, "%.8x: COC\n", cio_tell()-2); tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp; len=cio_read(2); compno=cio_read(j2k_img->numcomps<=256?1:2); tcp->tccps[compno].csty=cio_read(1); j2k_read_cox(compno); }
static opj_bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_box_t *box, opj_jp2_color_t *color) { int skip_len; opj_common_ptr cinfo; /* Part 1, I.5.3.3 : 'A conforming JP2 reader shall ignore all Colour * Specification boxes after the first.' */ if(color->jp2_has_colr) return OPJ_FALSE; cinfo = jp2->cinfo; jp2->meth = cio_read(cio, 1); /* METH */ jp2->precedence = cio_read(cio, 1); /* PRECEDENCE */ jp2->approx = cio_read(cio, 1); /* APPROX */ if (jp2->meth == 1) { jp2->enumcs = cio_read(cio, 4); /* EnumCS */ } else if (jp2->meth == 2) { /* skip PROFILE */ skip_len = box->init_pos + box->length - cio_tell(cio); if (skip_len < 0) { opj_event_msg(cinfo, EVT_ERROR, "Error with COLR box size\n"); return OPJ_FALSE; } if(skip_len > 0) { unsigned char *start; start = cio_getbp(cio); color->icc_profile_buf = (unsigned char*)opj_malloc(skip_len); color->icc_profile_len = skip_len; cio_skip(cio, box->init_pos + box->length - cio_tell(cio)); memcpy(color->icc_profile_buf, start, skip_len); } } if (cio_tell(cio) - box->init_pos != box->length) { opj_event_msg(cinfo, EVT_ERROR, "Error with COLR Box\n"); return OPJ_FALSE; } color->jp2_has_colr = 1; return OPJ_TRUE; }/* jp2_read_colr() */
static opj_bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_box_t *box, opj_jp2_color_t *color) { opj_jp2_pclr_t *jp2_pclr; unsigned char *channel_size, *channel_sign; unsigned int *entries; unsigned short nr_entries, nr_channels; unsigned short i, j; unsigned char uc; OPJ_ARG_NOT_USED(box); OPJ_ARG_NOT_USED(jp2); /* Part 1, I.5.3.4: 'There shall be at most one Palette box inside * a JP2 Header box' : */ if(color->jp2_pclr) return OPJ_FALSE; nr_entries = (unsigned short)cio_read(cio, 2); /* NE */ nr_channels = (unsigned short)cio_read(cio, 1);/* NPC */ entries = (unsigned int*) opj_malloc(nr_channels * nr_entries * sizeof(unsigned int)); channel_size = (unsigned char*)opj_malloc(nr_channels); channel_sign = (unsigned char*)opj_malloc(nr_channels); jp2_pclr = (opj_jp2_pclr_t*)opj_malloc(sizeof(opj_jp2_pclr_t)); jp2_pclr->channel_sign = channel_sign; jp2_pclr->channel_size = channel_size; jp2_pclr->entries = entries; jp2_pclr->nr_entries = nr_entries; jp2_pclr->nr_channels = nr_channels; jp2_pclr->cmap = NULL; color->jp2_pclr = jp2_pclr; for(i = 0; i < nr_channels; ++i) { uc = cio_read(cio, 1); /* Bi */ channel_size[i] = (uc & 0x7f) + 1; channel_sign[i] = (uc & 0x80)?1:0; } for(j = 0; j < nr_entries; ++j) { for(i = 0; i < nr_channels; ++i) { /* Cji */ *entries++ = cio_read(cio, (channel_size[i]+7)>>3); } } return OPJ_TRUE; }/* jp2_read_pclr() */
void j2k_read_coc() { int len, compno; j2k_tcp_t *tcp; tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp; len = cio_read(2); /* Lcoc */ compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2); /* Ccoc */ tcp->tccps[compno].csty = cio_read(1); /* Scoc */ j2k_read_cox(compno); }
void j2k_read_coc() { int len, compno; j2k_tcp_t *tcp; info_tile_t *tile; info_marker_t *tmp; tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp; len = cio_read(2); /* <INDEX> [MHIX BOX] */ if (j2k_state == J2K_STATE_MH) { if (!img.marker_mul.num_COC) img.marker_mul.COC = (info_marker_t*)malloc(img.marker_mul.CzCOC * sizeof(info_marker_t)); if (img.marker_mul.num_COC >= img.marker_mul.CzCOC) { tmp = (info_marker_t*)malloc((INCREMENT + img.marker_mul.CzCOC) * sizeof(info_marker_t)); memcpy(tmp,img.marker_mul.COC,img.marker_mul.CzCOC); img.marker_mul.CzCOC += INCREMENT; free(img.marker_mul.COC); img.marker_mul.COC = tmp; } img.marker_mul.COC[img.marker_mul.num_COC].type = J2K_MS_COC; img.marker_mul.COC[img.marker_mul.num_COC].start_pos = cio_tell()-2; img.marker_mul.COC[img.marker_mul.num_COC].len = len; img.marker_mul.num_COC++; } else { tile = &img.tile[j2k_curtileno]; if (!tile->marker_mul.num_COC) tile->marker_mul.COC = (info_marker_t*)malloc(tile->marker_mul.CzCOC * sizeof(info_marker_t)); if (tile->marker_mul.num_COC >= tile->marker_mul.CzCOC) { tmp = (info_marker_t*)malloc((INCREMENT + tile->marker_mul.CzCOC) * sizeof(info_marker_t)); memcpy(tmp,tile->marker_mul.COC,tile->marker_mul.CzCOC); tile->marker_mul.CzCOC += INCREMENT; free(tile->marker_mul.COC); tile->marker_mul.COC = tmp; } tile->marker_mul.COC[tile->marker_mul.num_COC].type = J2K_MS_COC; tile->marker_mul.COC[tile->marker_mul.num_COC].start_pos = cio_tell() - 2; tile->marker_mul.COC[tile->marker_mul.num_COC].len = len; tile->marker_mul.num_COC++; } /* </INDEX> [MHIX BOX] */ compno =cio_read(j2k_img->numcomps <= 256 ? 1 : 2); tcp->tccps[compno].csty = cio_read(1); j2k_read_cox(compno); }
int jp2_read_boxhdr(jp2_box_t * box) { box->init_pos = cio_tell(); box->length = cio_read(4); box->type = cio_read(4); if (box->length == 1) { if (cio_read(4) != 0) { fprintf(stderr, "Error: Cannot handle box sizes higher than 2^32\n"); return 1; }; box->length = cio_read(4); } return 0; }
static void receiver(void *data) { struct args *args = data; char buf; size_t len = 0; ssize_t ret; printf("receiver\n"); while (true) { ret = cio_read(args->fd, &buf, 1); assert(ret >= 0); if (ret == 0) break; len += ret; } assert(len == args->size); close(args->fd); printf("receiver done\n"); exit(0); }
static opj_bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio) { opj_jp2_box_t box; opj_common_ptr cinfo = jp2->cinfo; if (jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE) { opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n"); return OPJ_FALSE; } if (JP2_JP != box.type) { opj_event_msg(cinfo, EVT_ERROR, "Expected JP Marker\n"); return OPJ_FALSE; } if (0x0d0a870a != cio_read(cio, 4)) { opj_event_msg(cinfo, EVT_ERROR, "Error with JP Marker\n"); return OPJ_FALSE; } if (cio_tell(cio) - box.init_pos != box.length) { opj_event_msg(cinfo, EVT_ERROR, "Error with JP Box size\n"); return OPJ_FALSE; } return OPJ_TRUE; }
static void routine(void *arg) { struct cio_channel *chan = *(void **) arg; FILE *file; int fd; file = popen("while true; do sleep 0.1; echo; done", "r"); assert(file); fd = fileno(file); assert(fd >= 0); assert(cio_nonblock(fd) >= 0); while (true) { unsigned char buf; assert(cio_read(fd, &buf, 1) == 1); assert(cio_channel_write(chan, &fd, sizeof (fd)) == 1); } /* don't pclose file */ cio_channel_unref(chan); }
static opj_bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) { unsigned int i; opj_jp2_box_t box; opj_common_ptr cinfo = jp2->cinfo; if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) { opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n"); return OPJ_FALSE; } if (JP2_BPCC != box.type) { opj_event_msg(cinfo, EVT_ERROR, "Expected BPCC Marker\n"); return OPJ_FALSE; } for (i = 0; i < jp2->numcomps; i++) { jp2->comps[i].bpcc = cio_read(cio, 1); } if (cio_tell(cio) - box.init_pos != box.length) { opj_event_msg(cinfo, EVT_ERROR, "Error with BPCC Box\n"); return OPJ_FALSE; } return OPJ_TRUE; }
void j2k_read_com() { int len; len = cio_read(2); cio_skip(len - 2); }
/* void j2k_write_cod() { j2k_tcp_t *tcp; int lenp, len; log_print(LOG_TRACE, "%.8x: COD\n", cio_tell()); cio_write(J2K_MS_COD, 2); lenp=cio_tell(); cio_skip(2); tcp=&j2k_cp->tcps[j2k_curtileno]; cio_write(tcp->csty, 1); cio_write(tcp->prg, 1); cio_write(tcp->numlayers, 2); cio_write(tcp->mct, 1); j2k_write_cox(0); len=cio_tell()-lenp; cio_seek(lenp); cio_write(len, 2); cio_seek(lenp+len); } */ void j2k_read_cod() { int len, i, pos; j2k_tcp_t *tcp; // log_print(LOG_TRACE, "%.8x: COD\n", cio_tell()-2); tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp; len=cio_read(2); tcp->csty=cio_read(1); tcp->prg=cio_read(1); tcp->numlayers=cio_read(2); tcp->mct=cio_read(1); pos=cio_tell(); for (i=0; i<j2k_img->numcomps; i++) { tcp->tccps[i].csty=tcp->csty&J2K_CP_CSTY_PRT; cio_seek(pos); j2k_read_cox(i); } }
static opj_bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) { opj_jp2_box_t box; opj_common_ptr cinfo = jp2->cinfo; if(jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) { opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n"); return OPJ_FALSE; } if (JP2_IHDR != box.type) { opj_event_msg(cinfo, EVT_ERROR, "Expected IHDR Marker\n"); return OPJ_FALSE; } jp2->h = cio_read(cio, 4); /* HEIGHT */ jp2->w = cio_read(cio, 4); /* WIDTH */ jp2->numcomps = cio_read(cio, 2); /* NC */ jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t)); jp2->bpc = cio_read(cio, 1); /* BPC */ jp2->C = cio_read(cio, 1); /* C */ jp2->UnkC = cio_read(cio, 1); /* UnkC */ jp2->IPR = cio_read(cio, 1); /* IPR */ if (cio_tell(cio) - box.init_pos != box.length) { opj_event_msg(cinfo, EVT_ERROR, "Error with IHDR Box\n"); return OPJ_FALSE; } return OPJ_TRUE; }
/* * Read the IHDR box * * Image Header box * */ int jp2_read_ihdr(jp2_struct_t * jp2_struct) { jp2_box_t box; jp2_read_boxhdr(&box); if (JP2_IHDR != box.type) { fprintf(stderr, "Error: Expected IHDR Marker\n"); return 1; } jp2_struct->h = cio_read(4); // HEIGHT jp2_struct->w = cio_read(4); // WIDTH jp2_struct->numcomps = cio_read(2); // NC jp2_struct->bpc = cio_read(1); // BPC jp2_struct->C = cio_read(1); // C jp2_struct->UnkC = cio_read(1); // UnkC jp2_struct->IPR = cio_read(1); // IPR if (cio_tell() - box.init_pos != box.length) { fprintf(stderr, "Error with IHDR Box\n"); return 1; } return 0; }
void j2k_read_cod() { int len, i, pos; j2k_tcp_t *tcp; info_tile_t *tile; tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp; len = cio_read(2); /* <INDEX> [MHIX BOX] */ if (j2k_state == J2K_STATE_MH) { img.marker[img.num_marker].type = J2K_MS_SIZ; img.marker[img.num_marker].start_pos = cio_tell()-2; img.marker[img.num_marker].len = len; img.num_marker++; } else { tile = &img.tile[j2k_curtileno]; tile->marker[tile->num_marker].type = J2K_MS_SIZ; tile->marker[tile->num_marker].start_pos = cio_tell()-2; tile->marker[tile->num_marker].len = len; tile->num_marker++; } /* </INDEX> [MHIX BOX] */ tcp->csty = cio_read(1); tcp->prg = cio_read(1); tcp->numlayers = cio_read(2); tcp->mct = cio_read(1); pos = cio_tell(); for (i = 0; i < j2k_img->numcomps; i++) { tcp->tccps[i].csty = tcp->csty&J2K_CP_CSTY_PRT; cio_seek(pos); j2k_read_cox(i); } /* <INDEX> */ img.Prog = tcp->prg; img.Layer = tcp->numlayers; /* </INDEX> */ }
static bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box) { box->init_pos = cio_tell(cio); box->length = cio_read(cio, 4); box->type = cio_read(cio, 4); if (box->length == 1) { if (cio_read(cio, 4) != 0) { opj_event_msg(cinfo, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n"); return false; } box->length = cio_read(cio, 4); if (box->length == 0) box->length = cio_numbytesleft(cio) + 12; } else if (box->length == 0) { box->length = cio_numbytesleft(cio) + 8; } return true; }
static void read_siz_marker(FILE *file, opj_image_t *image) { int len,i; char buf, buf2[2]; unsigned char *siz_buffer; opj_cio_t *cio; fseek(file, 0, SEEK_SET); do { fread(&buf,1,1, file); if (buf==(char)0xff) fread(&buf,1,1, file); } while (!(buf==(char)0x51)); fread(buf2,2,1,file); /* Lsiz */ len = ((buf2[0])<<8) + buf2[1]; siz_buffer = (unsigned char*) malloc(len * sizeof(unsigned char)); fread(siz_buffer,len, 1, file); cio = opj_cio_open(NULL, siz_buffer, len); cio_read(cio, 2); /* Rsiz (capabilities) */ image->x1 = cio_read(cio, 4); /* Xsiz */ image->y1 = cio_read(cio, 4); /* Ysiz */ image->x0 = cio_read(cio, 4); /* X0siz */ image->y0 = cio_read(cio, 4); /* Y0siz */ cio_skip(cio, 16); /* XTsiz, YTsiz, XT0siz, YT0siz */ image->numcomps = cio_read(cio,2); /* Csiz */ image->comps = (opj_image_comp_t *) malloc(image->numcomps * sizeof(opj_image_comp_t)); for (i = 0; i < image->numcomps; i++) { int tmp; tmp = cio_read(cio,1); /* Ssiz_i */ image->comps[i].prec = (tmp & 0x7f) + 1; image->comps[i].sgnd = tmp >> 7; image->comps[i].dx = cio_read(cio,1); /* XRsiz_i */ image->comps[i].dy = cio_read(cio,1); /* YRsiz_i */ image->comps[i].resno_decoded = 0; /* number of resolution decoded */ image->comps[i].factor = 0; /* reducing factor by component */ } fseek(file, 0, SEEK_SET); opj_cio_close(cio); free(siz_buffer); }
void j2k_read_cod() { int len, i, pos; j2k_tcp_t *tcp; tcp = j2k_state == J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp; len = cio_read(2); /* Lcod */ tcp->csty = cio_read(1); /* Scod */ tcp->prg = cio_read(1); /* SGcod (A) */ tcp->numlayers = cio_read(2); /* SGcod (B) */ tcp->mct = cio_read(1); /* SGcod (C) */ pos = cio_tell(); for (i = 0; i < j2k_img->numcomps; i++) { tcp->tccps[i].csty = tcp->csty & J2K_CP_CSTY_PRT; cio_seek(pos); j2k_read_cox(i); } }
static PyObject *py_cio_io(enum cio_io_type type, PyObject *args, const char *format) { int fd; Py_buffer buf; Py_ssize_t size; int flags; ssize_t len; int err; if (!PyArg_ParseTuple(args, format, &fd, &buf, &size, &flags)) return NULL; py_cio_thread_save(); if (size > buf.len) size = buf.len; switch (type) { case CIO_IO_READ: len = cio_read(fd, buf.buf, size); break; case CIO_IO_WRITE: len = cio_write(fd, buf.buf, size); break; case CIO_IO_RECV: len = cio_recv(fd, buf.buf, size, flags); break; case CIO_IO_SEND: len = cio_send(fd, buf.buf, size, flags); break; } err = errno; if (len < 0 && errno == EINTR) PyErr_SetInterrupt(); py_cio_thread_restore(); PyBuffer_Release(&buf); if (len < 0) { errno = err; return PyErr_SetFromErrno(PyExc_IOError); } return PyLong_FromLong(len); }
static bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio) { opj_jp2_box_t box; int skip_len; opj_common_ptr cinfo = jp2->cinfo; jp2_read_boxhdr(cinfo, cio, &box); do { if (JP2_COLR != box.type) { cio_skip(cio, box.length - 8); jp2_read_boxhdr(cinfo, cio, &box); } } while(JP2_COLR != box.type); jp2->meth = cio_read(cio, 1); /* METH */ jp2->precedence = cio_read(cio, 1); /* PRECEDENCE */ jp2->approx = cio_read(cio, 1); /* APPROX */ if (jp2->meth == 1) { jp2->enumcs = cio_read(cio, 4); /* EnumCS */ } else { /* skip PROFILE */ skip_len = box.init_pos + box.length - cio_tell(cio); if (skip_len < 0) { opj_event_msg(cinfo, EVT_ERROR, "Error with JP2H box size\n"); return false; } cio_skip(cio, box.init_pos + box.length - cio_tell(cio)); } if (cio_tell(cio) - box.init_pos != box.length) { opj_event_msg(cinfo, EVT_ERROR, "Error with BPCC Box\n"); return false; } return true; }
static opj_bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box) { box->init_pos = cio_tell(cio); box->length = cio_read(cio, 4); box->type = cio_read(cio, 4); if (box->length == 1) { if (cio_read(cio, 4) != 0) { opj_event_msg(cinfo, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n"); return OPJ_FALSE; } box->length = cio_read(cio, 4); if (box->length == 0) box->length = cio_numbytesleft(cio) + 12; } else if (box->length == 0) { box->length = cio_numbytesleft(cio) + 8; } /* cf. http://code.google.com/p/openjpeg/issues/detail?id=155 */ if (box->length < 0) { opj_event_msg(cinfo, EVT_ERROR, "Integer overflow in box->length\n"); return OPJ_FALSE; // TODO: actually check jp2_read_boxhdr's return value } return OPJ_TRUE; }
void j2k_read_com() { int len; info_tile_t *tile; info_marker_t *tmp; len = cio_read(2); /* <INDEX> [MHIX BOX] */ if (j2k_state == J2K_STATE_MH) { if (!img.marker_mul.num_COM) img.marker_mul.COM = (info_marker_t*)malloc(img.marker_mul.CzCOM * sizeof(info_marker_t)); if (img.marker_mul.num_COM >= img.marker_mul.CzCOM) { tmp = (info_marker_t*)malloc(2 * img.marker_mul.CzCOM * sizeof(info_marker_t)); memcpy(tmp,img.marker_mul.COM,img.marker_mul.CzCOM); img.marker_mul.CzCOM *= 2; free(img.marker_mul.COM); img.marker_mul.COM = tmp; } img.marker_mul.COM[img.marker_mul.num_COM].type = J2K_MS_COM; img.marker_mul.COM[img.marker_mul.num_COM].start_pos = cio_tell()-2; img.marker_mul.COM[img.marker_mul.num_COM].len = len; img.marker_mul.num_COM++; } else { tile = &img.tile[j2k_curtileno]; if (!tile->marker_mul.num_COM) tile->marker_mul.COM = (info_marker_t*)calloc(START_NB, sizeof(info_marker_t)); if (tile->marker_mul.num_COM >= tile->marker_mul.CzCOM) { tmp = (info_marker_t*)malloc(2 * tile->marker_mul.CzCOM * sizeof(info_marker_t)); memcpy(tmp,tile->marker_mul.COM,tile->marker_mul.CzCOM); tile->marker_mul.CzCOM *= 2; free(tile->marker_mul.COM); tile->marker_mul.COM = tmp; } tile->marker_mul.COM[tile->marker_mul.num_COM].type = J2K_MS_COM; tile->marker_mul.COM[tile->marker_mul.num_COM].start_pos = cio_tell()-2; tile->marker_mul.COM[tile->marker_mul.num_COM].len = len; tile->marker_mul.num_COM++; } /* </INDEX> [MHIX BOX] */ cio_skip(len - 2); }
/* void j2k_write_qcx(int compno) { j2k_tcp_t *tcp; j2k_tccp_t *tccp; int bandno, numbands; tcp=&j2k_cp->tcps[j2k_curtileno]; tccp=&tcp->tccps[compno]; cio_write(tccp->qntsty+(tccp->numgbits<<5), 1); numbands=tccp->qntsty==J2K_CCP_QNTSTY_SIQNT?1:tccp->numresolutions*3-2; for (bandno=0; bandno<numbands; bandno++) { int expn, mant; expn=tccp->stepsizes[bandno].expn; mant=tccp->stepsizes[bandno].mant; if (tccp->qntsty==J2K_CCP_QNTSTY_NOQNT) { cio_write(expn<<3, 1); } else { cio_write((expn<<11)+mant, 2); } } } */ void j2k_read_qcx(int compno, int len) { int tmp; j2k_tcp_t *tcp; j2k_tccp_t *tccp; int bandno, numbands; tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp; tccp=&tcp->tccps[compno]; tmp=cio_read(1); tccp->qntsty=tmp&0x1f; tccp->numgbits=tmp>>5; numbands=tccp->qntsty==J2K_CCP_QNTSTY_SIQNT?1:(tccp->qntsty==J2K_CCP_QNTSTY_NOQNT?len-1:(len-1)/2); for (bandno=0; bandno<numbands; bandno++) { int expn, mant; if (tccp->qntsty==J2K_CCP_QNTSTY_NOQNT) { // WHY STEPSIZES WHEN NOQNT ? expn=cio_read(1)>>3; mant=0; } else {
/* * Read the JP box * * JPEG 2000 signature * * return 1 if error else 0 */ int jp2_read_jp() { jp2_box_t box; jp2_read_boxhdr(&box); if (JP2_JP != box.type) { fprintf(stderr, "Error: Expected JP Marker\n"); return 1; } if (0x0d0a870a != cio_read(4)) { fprintf(stderr, "Error with JP Marker\n"); return 1; } if (cio_tell() - box.init_pos != box.length) { fprintf(stderr, "Error with JP Box size\n"); return 1; } return 0; }