| /* |
| * Copyright (c) 2001-2002, David Janssens |
| * Copyright (c) 2003, Yannick Verschueren |
| * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "t2.h" |
| #include "tcd.h" |
| #include "bio.h" |
| #include "j2k.h" |
| #include "pi.h" |
| #include "tgt.h" |
| #include "int.h" |
| #include "cio.h" |
| #include <stdio.h> |
| #include <setjmp.h> |
| #include <string.h> |
| #include <stdlib.h> |
| |
| #define RESTART 0x04 |
| |
| extern jmp_buf j2k_error; |
| |
| int t2_getcommacode() { |
| int n; |
| for (n=0; bio_read(1); n++) {} |
| return n; |
| } |
| |
| int t2_getnumpasses() |
| { |
| int n; |
| if (!bio_read(1)) return 1; |
| if (!bio_read(1)) return 2; |
| if ((n=bio_read(2))!=3) return 3+n; |
| if ((n=bio_read(5))!=31) return 6+n; |
| return 37+bio_read(7); |
| } |
| |
| void t2_init_seg(tcd_seg_t *seg, int cblksty) { |
| seg->numpasses=0; |
| seg->len=0; |
| seg->maxpasses=cblksty&J2K_CCP_CBLKSTY_TERMALL?1:100; |
| } |
| |
| int t2_decode_packet(unsigned char *src, int len, tcd_tile_t *tile, j2k_cp_t * cp, j2k_tcp_t *tcp, int compno, int resno, int precno, int layno, info_layer_t *layer_Idx) { |
| int bandno, cblkno; |
| tcd_tilecomp_t *tilec = &tile->comps[compno]; |
| tcd_resolution_t *res = &tilec->resolutions[resno]; |
| unsigned char *c = src; |
| unsigned char *d = c; |
| int e; |
| int present; |
| |
| if (layno == 0) { |
| for (bandno = 0; bandno < res->numbands; bandno++) { |
| tcd_band_t *band = &res->bands[bandno]; |
| tcd_precinct_t *prc = &band->precincts[precno]; |
| tgt_reset(prc->incltree); |
| tgt_reset(prc->imsbtree); |
| for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) { |
| tcd_cblk_t *cblk = &prc->cblks[cblkno]; |
| cblk->numsegs = 0; |
| } |
| } |
| } |
| /* INDEX */ |
| layer_Idx->len_header = 0; |
| |
| /* When the marker PPT/PPM is used the packet header are store in PPT/PPM marker |
| This part deal with this caracteristic |
| step 1: Read packet header in the saved structure |
| step 2: (futher) return to codestream for decoding */ |
| if (cp->ppm == 1) /* PPM */ |
| { |
| c = cp->ppm_data; |
| d = c; |
| bio_init_dec(c, 1000); |
| } else |
| { |
| if (tcp->ppt == 1) /* PPT */ |
| { |
| c = tcp->ppt_data; |
| d = c; |
| bio_init_dec(c, 1000); |
| } else /* Normal Case */ |
| { |
| if (tcp->csty & J2K_CP_CSTY_SOP) |
| { |
| if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [1]!!!\n");} |
| c += 6; |
| } |
| bio_init_dec(c, src + len - c); |
| layer_Idx->len_header = -6; |
| } |
| } |
| |
| present = bio_read(1); |
| |
| if (!present) |
| { |
| bio_inalign(); |
| /* Normal case */ |
| c += bio_numbytes(); |
| if (tcp->csty & J2K_CP_CSTY_EPH) |
| { |
| if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [1]!!!\n");} |
| c += 2; |
| } |
| /* INDEX */ |
| layer_Idx->len_header += (c-d); |
| |
| /* PPT and PPM dealing */ |
| if (cp->ppm == 1) /* PPM */ |
| { |
| cp->ppm_data = c; |
| return 0; |
| } |
| if (tcp->ppt == 1) /* PPT */ |
| { |
| tcp->ppt_data = c; |
| return 0; |
| } |
| return c - src; |
| } |
| |
| for (bandno=0; bandno<res->numbands; bandno++) { |
| tcd_band_t *band = &res->bands[bandno]; |
| tcd_precinct_t *prc = &band->precincts[precno]; |
| for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) { |
| int included, increment, n; |
| tcd_cblk_t *cblk = &prc->cblks[cblkno]; |
| tcd_seg_t *seg; |
| if (!cblk->numsegs) { |
| included = tgt_decode(prc->incltree, cblkno, layno+1); |
| } else { |
| included = bio_read(1); |
| } |
| if (!included) { |
| cblk->numnewpasses = 0; |
| continue; |
| } |
| if (!cblk->numsegs) { |
| int i, numimsbs; |
| for (i = 0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {} |
| numimsbs = i-1; |
| cblk->numbps = band->numbps - numimsbs; |
| cblk->numlenbits = 3; |
| } |
| cblk->numnewpasses = t2_getnumpasses(); |
| increment = t2_getcommacode(); |
| cblk->numlenbits += increment; |
| if (!cblk->numsegs) { |
| seg = &cblk->segs[0]; |
| t2_init_seg(seg, tcp->tccps[compno].cblksty); |
| } else { |
| seg = &cblk->segs[cblk->numsegs - 1]; |
| if (seg->numpasses == seg->maxpasses) { |
| t2_init_seg(++seg, tcp->tccps[compno].cblksty); |
| } |
| } |
| n = cblk->numnewpasses; |
| do { |
| seg->numnewpasses = int_min(seg->maxpasses-seg->numpasses, n); |
| seg->newlen = bio_read(cblk->numlenbits + int_floorlog2(seg->numnewpasses)); |
| n -= seg->numnewpasses; |
| if (n > 0) { |
| t2_init_seg(++seg, tcp->tccps[compno].cblksty); |
| } |
| } while (n > 0); |
| } |
| } |
| if(bio_inalign()) return -999; |
| c += bio_numbytes(); |
| |
| if (tcp->csty & J2K_CP_CSTY_EPH) { /* EPH marker */ |
| if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [2]!!!\n"); } |
| c += 2; |
| } |
| |
| /* INDEX */ |
| layer_Idx->len_header += (c-d); |
| |
| /* PPT Step 2 : see above for details */ |
| if (cp->ppm == 1) |
| { |
| cp->ppm_data = c; /* Update pointer */ |
| |
| /* INDEX */ |
| layer_Idx->len_header = c-d; |
| |
| c = src; |
| d = c; |
| if (tcp->csty & J2K_CP_CSTY_SOP) |
| { |
| if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); } |
| c += 6; |
| } |
| bio_init_dec(c, src + len - c); |
| } else |
| { |
| if (tcp->ppt == 1) |
| { |
| tcp->ppt_data = c; /* Update pointer */ |
| /* INDEX */ |
| layer_Idx->len_header = c-d; |
| |
| c = src; |
| d = c; |
| if (tcp->csty & J2K_CP_CSTY_SOP) /* SOP marker */ |
| { |
| if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); } |
| c += 6; |
| } |
| bio_init_dec(c, src + len - c); |
| |
| } |
| } |
| |
| for (bandno = 0; bandno < res->numbands; bandno++) { |
| tcd_band_t *band = &res->bands[bandno]; |
| tcd_precinct_t *prc = &band->precincts[precno]; |
| for (cblkno = 0; cblkno < prc->cw*prc->ch; cblkno++) { |
| tcd_cblk_t *cblk = &prc->cblks[cblkno]; |
| tcd_seg_t *seg; |
| if (!cblk->numnewpasses) continue; |
| if (!cblk->numsegs) { |
| seg = &cblk->segs[cblk->numsegs++]; |
| cblk->len = 0; |
| } else { |
| seg = &cblk->segs[cblk->numsegs-1]; |
| if (seg->numpasses == seg->maxpasses) { |
| seg++; |
| cblk->numsegs++; |
| } |
| } |
| do { |
| if (c + seg->newlen > src + len) return -999; |
| memcpy(cblk->data + cblk->len, c, seg->newlen); |
| if (seg->numpasses == 0) { |
| seg->data = cblk->data + cblk->len; |
| } |
| c += seg->newlen; |
| cblk->len += seg->newlen; |
| seg->len += seg->newlen; |
| seg->numpasses += seg->numnewpasses; |
| cblk->numnewpasses -= seg->numnewpasses; |
| if (cblk->numnewpasses > 0) { |
| seg++; |
| cblk->numsegs++; |
| } |
| } while (cblk->numnewpasses > 0); |
| } |
| } |
| /* <INDEX> */ |
| e = c-d; |
| layer_Idx->len = e; |
| /* </INDEX> */ |
| |
| return c-src; |
| } |
| |
| void t2_init_info_packets(info_image_t *img, j2k_cp_t *cp) |
| { |
| int compno, tileno, resno, precno, layno; |
| |
| for(compno = 0; compno < img->Comp; compno++) |
| { |
| for(tileno = 0; tileno < img->tw*img->th; tileno++) |
| { |
| info_tile_t *tile_Idx = &img->tile[tileno]; |
| info_compo_t *compo_Idx = &tile_Idx->compo[compno]; |
| for(resno = 0; resno < img->Decomposition + 1 ; resno++) |
| { |
| info_reso_t *reso_Idx = &compo_Idx->reso[resno]; |
| for (precno = 0; precno < img->tile[tileno].pw * img->tile[tileno].ph; precno++) |
| { |
| info_prec_t *prec_Idx = &reso_Idx->prec[precno]; |
| for(layno = 0; layno < img->Layer ; layno++) |
| { |
| info_layer_t *layer_Idx = &prec_Idx->layer[layno]; |
| layer_Idx->offset = 0; /* start position */ |
| layer_Idx->len_header = 0; /* length */ |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| int t2_decode_packets(unsigned char *src, int len, j2k_image_t *img, j2k_cp_t *cp, int tileno, tcd_tile_t *tile, info_image_t *imgg) { |
| unsigned char *c = src; |
| pi_iterator_t *pi; |
| int pino, compno,e; |
| int partno; |
| info_tile_part_t *tile_part; |
| int position; |
| int length_read; |
| info_tile_t *tile_Idx; |
| info_compo_t *compo_Idx; |
| info_reso_t *reso_Idx; |
| info_prec_t *prec_Idx; |
| info_layer_t *layer_Idx; |
| |
| t2_init_info_packets(imgg, cp); /* Initialize the packets information : LEN and OFFSET to 0 */ |
| |
| tile_Idx = &imgg->tile[tileno]; |
| tile_Idx->num_packet = 0; |
| pi = pi_create(img, cp, tileno); |
| partno = 0; |
| tile_part = &tile_Idx->tile_parts[partno]; |
| position = tile_part->end_header + 1; |
| length_read = 0; |
| |
| for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) |
| { |
| while (pi_next(&pi[pino])) |
| { |
| compo_Idx = &tile_Idx->compo[pi[pino].compno]; |
| reso_Idx = &compo_Idx->reso[pi[pino].resno]; |
| prec_Idx = &reso_Idx->prec[pi[pino].precno]; |
| layer_Idx = &prec_Idx->layer[pi[pino].layno]; |
| |
| layer_Idx->offset = position; |
| layer_Idx->offset_header = position; |
| |
| e = t2_decode_packet(c, src+len-c, tile, cp, &cp->tcps[tileno], pi[pino].compno, pi[pino].resno, pi[pino].precno, pi[pino].layno,layer_Idx); |
| if (e == -999) |
| { |
| break; |
| } else |
| c += e; |
| position += e; |
| |
| /* Update position in case of multiple tile-parts for a tile >> */ |
| length_read += e; |
| if (length_read >= (tile_part->end_pos - tile_part->end_header)) |
| { |
| partno++; |
| tile_part = &tile_Idx->tile_parts[partno]; |
| position = tile_part->end_header + 1; |
| length_read = 0; |
| } |
| /* << end_update */ |
| |
| tile_Idx->num_packet++; |
| } |
| |
| // FREE space memory taken by pi |
| for (compno = 0; compno < pi[pino].numcomps; compno++) |
| { |
| free(pi[pino].comps[compno].resolutions); |
| } |
| free(pi[pino].comps); |
| } |
| |
| free(pi[0].include); |
| free(pi); |
| |
| if (e==-999) |
| return e; |
| else |
| { |
| imgg->num_packet_max=int_max(imgg->num_packet_max,tile_Idx->num_packet); |
| return c-src; |
| } |
| } |
