Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2001-2002, David Janssens
  3.  * Copyright (c) 2003, Yannick Verschueren
  4.  * Copyright (c) 2003,  Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
  5.  * All rights reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  * 1. Redistributions of source code must retain the above copyright
  11.  *    notice, this list of conditions and the following disclaimer.
  12.  * 2. Redistributions in binary form must reproduce the above copyright
  13.  *    notice, this list of conditions and the following disclaimer in the
  14.  *    documentation and/or other materials provided with the distribution.
  15.  *
  16.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  17.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  20.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26.  * POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. #include "t2.h"
  30. #include "tcd.h"
  31. #include "bio.h"
  32. #include "j2k.h"
  33. #include "pi.h"
  34. #include "tgt.h"
  35. #include "int.h"
  36. #include "cio.h"
  37. #include <stdio.h>
  38. #include <setjmp.h>
  39. #include <string.h>
  40. #include <stdlib.h>
  41.  
  42. #define RESTART 0x04
  43.  
  44. extern jmp_buf j2k_error;
  45.  
  46. int t2_getcommacode() {
  47.     int n;
  48.     for (n=0; bio_read(1); n++) {}
  49.     return n;
  50. }
  51.  
  52. int t2_getnumpasses()
  53. {
  54.     int n;
  55.     if (!bio_read(1)) return 1;
  56.     if (!bio_read(1)) return 2;
  57.     if ((n=bio_read(2))!=3) return 3+n;
  58.     if ((n=bio_read(5))!=31) return 6+n;
  59.     return 37+bio_read(7);
  60. }
  61.  
  62. void t2_init_seg(tcd_seg_t *seg, int cblksty) {
  63.     seg->numpasses=0;
  64.     seg->len=0;
  65.     seg->maxpasses=cblksty&J2K_CCP_CBLKSTY_TERMALL?1:100;
  66. }
  67.  
  68. 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) {
  69.     int bandno, cblkno;
  70.     tcd_tilecomp_t *tilec = &tile->comps[compno];
  71.     tcd_resolution_t *res = &tilec->resolutions[resno];
  72.     unsigned char *c = src;
  73.     unsigned char *d = c;
  74.     int e;
  75.     int present;
  76.  
  77.     if (layno == 0) {
  78.         for (bandno = 0; bandno < res->numbands; bandno++) {
  79.             tcd_band_t *band = &res->bands[bandno];
  80.             tcd_precinct_t *prc = &band->precincts[precno];
  81.             tgt_reset(prc->incltree);
  82.             tgt_reset(prc->imsbtree);
  83.             for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
  84.                 tcd_cblk_t *cblk = &prc->cblks[cblkno];
  85.                 cblk->numsegs = 0;
  86.             }
  87.         }  
  88.     }
  89.     /* INDEX */
  90.     layer_Idx->len_header = 0;
  91.  
  92.     /* When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
  93.        This part deal with this caracteristic
  94.        step 1: Read packet header in the saved structure
  95.        step 2: (futher) return to codestream for decoding */
  96.     if (cp->ppm == 1) /* PPM */
  97.       {    
  98.         c = cp->ppm_data;
  99.         d = c;
  100.         bio_init_dec(c, 1000);
  101.       } else
  102.         {
  103.           if (tcp->ppt == 1) /* PPT */
  104.             {
  105.               c = tcp->ppt_data;
  106.               d = c;
  107.               bio_init_dec(c, 1000);
  108.             } else /* Normal Case */
  109.               {
  110.                 if (tcp->csty & J2K_CP_CSTY_SOP)
  111.                   {
  112.                     if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [1]!!!\n");}
  113.                     c += 6;
  114.                   }
  115.                 bio_init_dec(c, src + len - c);
  116.                 layer_Idx->len_header = -6;
  117.               }
  118.         }
  119.    
  120.     present = bio_read(1);
  121.    
  122.     if (!present)
  123.       {
  124.         bio_inalign();
  125.         /* Normal case */
  126.         c += bio_numbytes();
  127.         if (tcp->csty & J2K_CP_CSTY_EPH)
  128.           {
  129.             if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [1]!!!\n");}
  130.             c += 2;
  131.           }
  132.         /* INDEX */
  133.         layer_Idx->len_header += (c-d);
  134.  
  135.         /* PPT and PPM dealing */
  136.         if (cp->ppm == 1) /* PPM */
  137.           {    
  138.             cp->ppm_data = c;      
  139.             return 0;
  140.           }
  141.         if (tcp->ppt == 1) /* PPT */
  142.           {
  143.             tcp->ppt_data = c;
  144.             return 0;
  145.           }
  146.         return c - src;
  147.       }
  148.    
  149.     for (bandno=0; bandno<res->numbands; bandno++) {
  150.         tcd_band_t *band = &res->bands[bandno];
  151.         tcd_precinct_t *prc = &band->precincts[precno];
  152.         for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
  153.             int included, increment, n;
  154.             tcd_cblk_t *cblk = &prc->cblks[cblkno];
  155.             tcd_seg_t *seg;
  156.             if (!cblk->numsegs) {
  157.                 included = tgt_decode(prc->incltree, cblkno, layno+1);
  158.             } else {
  159.                 included = bio_read(1);
  160.             }
  161.             if (!included) {
  162.                 cblk->numnewpasses = 0;
  163.                 continue;
  164.             }
  165.             if (!cblk->numsegs) {
  166.                 int i, numimsbs;
  167.                 for (i = 0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {}
  168.                 numimsbs = i-1;
  169.                 cblk->numbps = band->numbps - numimsbs;
  170.                 cblk->numlenbits = 3;
  171.             }
  172.             cblk->numnewpasses = t2_getnumpasses();
  173.             increment = t2_getcommacode();
  174.             cblk->numlenbits += increment;
  175.             if (!cblk->numsegs) {
  176.                 seg = &cblk->segs[0];
  177.                 t2_init_seg(seg, tcp->tccps[compno].cblksty);
  178.             } else {
  179.                 seg = &cblk->segs[cblk->numsegs - 1];
  180.                 if (seg->numpasses == seg->maxpasses) {
  181.                     t2_init_seg(++seg, tcp->tccps[compno].cblksty);
  182.                 }
  183.             }
  184.             n = cblk->numnewpasses;
  185.             do {
  186.                 seg->numnewpasses = int_min(seg->maxpasses-seg->numpasses, n);
  187.                 seg->newlen = bio_read(cblk->numlenbits + int_floorlog2(seg->numnewpasses));
  188.                 n -= seg->numnewpasses;
  189.                 if (n > 0) {
  190.                     t2_init_seg(++seg, tcp->tccps[compno].cblksty);
  191.                 }
  192.             } while (n > 0);
  193.         }
  194.     }
  195.     if(bio_inalign()) return -999;
  196.     c += bio_numbytes();
  197.  
  198.     if (tcp->csty & J2K_CP_CSTY_EPH) { /* EPH marker */
  199.       if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [2]!!!\n"); }
  200.       c += 2;
  201.     }
  202.    
  203.     /* INDEX */
  204.     layer_Idx->len_header += (c-d);
  205.  
  206.     /* PPT Step 2 : see above for details */
  207.     if (cp->ppm == 1)
  208.       {
  209.         cp->ppm_data = c; /* Update pointer */
  210.  
  211.         /* INDEX */
  212.         layer_Idx->len_header = c-d;
  213.  
  214.         c = src;
  215.         d = c;
  216.         if (tcp->csty & J2K_CP_CSTY_SOP)
  217.           {
  218.             if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); }
  219.             c += 6;
  220.           }
  221.         bio_init_dec(c, src + len - c);
  222.       } else
  223.         {
  224.           if (tcp->ppt == 1)
  225.             {
  226.               tcp->ppt_data = c; /* Update pointer */
  227.               /* INDEX */
  228.               layer_Idx->len_header = c-d;
  229.  
  230.               c = src;
  231.               d = c;
  232.               if (tcp->csty & J2K_CP_CSTY_SOP) /* SOP marker */
  233.                 {
  234.                   if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); }
  235.                   c += 6;
  236.                 }
  237.               bio_init_dec(c, src + len - c);
  238.              
  239.             }
  240.         }
  241.  
  242.     for (bandno = 0; bandno < res->numbands; bandno++) {
  243.         tcd_band_t *band = &res->bands[bandno];
  244.         tcd_precinct_t *prc = &band->precincts[precno];
  245.         for (cblkno = 0; cblkno < prc->cw*prc->ch; cblkno++) {
  246.             tcd_cblk_t *cblk = &prc->cblks[cblkno];
  247.             tcd_seg_t *seg;
  248.             if (!cblk->numnewpasses) continue;
  249.             if (!cblk->numsegs) {
  250.                 seg = &cblk->segs[cblk->numsegs++];
  251.                 cblk->len = 0;
  252.             } else {
  253.                 seg = &cblk->segs[cblk->numsegs-1];
  254.                 if (seg->numpasses == seg->maxpasses) {
  255.                     seg++;
  256.                     cblk->numsegs++;
  257.                 }
  258.             }
  259.             do {
  260.               if (c + seg->newlen > src + len) return -999;
  261.                 memcpy(cblk->data + cblk->len, c, seg->newlen);
  262.                 if (seg->numpasses == 0) {
  263.                     seg->data = cblk->data + cblk->len;
  264.                 }
  265.                 c += seg->newlen;
  266.                 cblk->len += seg->newlen;
  267.                 seg->len += seg->newlen;
  268.                 seg->numpasses += seg->numnewpasses;
  269.                 cblk->numnewpasses -= seg->numnewpasses;
  270.                 if (cblk->numnewpasses > 0) {
  271.                     seg++;
  272.                     cblk->numsegs++;
  273.                 }
  274.             } while (cblk->numnewpasses > 0);
  275.         }
  276.     }
  277.     /* <INDEX> */
  278.     e = c-d;
  279.     layer_Idx->len = e;
  280.     /* </INDEX> */
  281.  
  282.     return c-src;
  283. }
  284.  
  285. void t2_init_info_packets(info_image_t *img, j2k_cp_t *cp)
  286. {
  287.   int compno, tileno, resno, precno, layno;
  288.  
  289.   for(compno = 0; compno < img->Comp; compno++)
  290.     {
  291.       for(tileno = 0; tileno < img->tw*img->th; tileno++)
  292.         {
  293.           info_tile_t *tile_Idx = &img->tile[tileno];
  294.           info_compo_t *compo_Idx = &tile_Idx->compo[compno];
  295.           for(resno = 0; resno < img->Decomposition + 1 ; resno++)
  296.             {
  297.               info_reso_t *reso_Idx = &compo_Idx->reso[resno];
  298.               for (precno = 0; precno < img->tile[tileno].pw * img->tile[tileno].ph; precno++)
  299.                 {
  300.                   info_prec_t *prec_Idx = &reso_Idx->prec[precno];
  301.                   for(layno = 0; layno < img->Layer ; layno++)
  302.                     {
  303.                       info_layer_t *layer_Idx = &prec_Idx->layer[layno];
  304.                       layer_Idx->offset = 0;        /* start position */
  305.                       layer_Idx->len_header = 0;    /* length         */
  306.                     }
  307.                 }
  308.             }
  309.         }
  310.     }
  311. }
  312.  
  313. 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) {
  314.     unsigned char *c = src;
  315.     pi_iterator_t *pi;
  316.     int pino, compno,e;
  317.     int partno;
  318.     info_tile_part_t *tile_part;
  319.     int position;
  320.     int length_read;
  321.     info_tile_t *tile_Idx;
  322.     info_compo_t *compo_Idx;
  323.     info_reso_t *reso_Idx;
  324.     info_prec_t *prec_Idx;
  325.     info_layer_t *layer_Idx;
  326.  
  327.     t2_init_info_packets(imgg, cp); /* Initialize the packets information : LEN and OFFSET to 0 */
  328.  
  329.     tile_Idx = &imgg->tile[tileno];
  330.     tile_Idx->num_packet = 0;
  331.     pi = pi_create(img, cp, tileno);
  332.     partno = 0;
  333.     tile_part = &tile_Idx->tile_parts[partno];
  334.     position = tile_part->end_header + 1;
  335.     length_read = 0;
  336.  
  337.     for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++)
  338.       {
  339.         while (pi_next(&pi[pino]))
  340.           {  
  341.             compo_Idx = &tile_Idx->compo[pi[pino].compno];
  342.             reso_Idx = &compo_Idx->reso[pi[pino].resno];
  343.             prec_Idx = &reso_Idx->prec[pi[pino].precno];
  344.             layer_Idx = &prec_Idx->layer[pi[pino].layno];
  345.            
  346.             layer_Idx->offset = position;
  347.             layer_Idx->offset_header = position;
  348.            
  349.             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);
  350.             if (e == -999)
  351.               {
  352.                 break;
  353.               } else
  354.                 c += e;
  355.             position += e;
  356.            
  357.             /* Update position in case of multiple tile-parts for a tile >> */
  358.             length_read += e;
  359.             if (length_read >= (tile_part->end_pos - tile_part->end_header))
  360.               {
  361.                 partno++;
  362.                 tile_part = &tile_Idx->tile_parts[partno];
  363.                 position = tile_part->end_header + 1;
  364.                 length_read = 0;
  365.               }
  366.             /* << end_update */
  367.            
  368.             tile_Idx->num_packet++;
  369.           }
  370.        
  371.         // FREE space memory taken by pi
  372.         for (compno = 0; compno < pi[pino].numcomps; compno++)
  373.           {
  374.             free(pi[pino].comps[compno].resolutions);
  375.           }
  376.         free(pi[pino].comps);
  377.       }
  378.    
  379.     free(pi[0].include);
  380.     free(pi);
  381.  
  382.     if (e==-999)
  383.       return e;
  384.     else
  385.       {
  386.         imgg->num_packet_max=int_max(imgg->num_packet_max,tile_Idx->num_packet);
  387.         return c-src;
  388.       }
  389. }
  390.