开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
PEZW_utils.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：28k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

PEZW_utils.cpp：源码内容
  1. /****************************************************************************/
  2. /*   MPEG4 Visual Texture Coding (VTC) Mode Software                        */
  3. /*                                                                          */
  4. /*   This software was jointly developed by the following participants:     */
  5. /*                                                                          */
  6. /*   Single-quant,  multi-quant and flow control                            */
  7. /*   are provided by  Sarnoff Corporation                                   */
  8. /*     Iraj Sodagar   (iraj@sarnoff.com)                                    */
  9. /*     Hung-Ju Lee    (hjlee@sarnoff.com)                                   */
  10. /*     Paul Hatrack   (hatrack@sarnoff.com)                                 */
  11. /*     Shipeng Li     (shipeng@sarnoff.com)                                 */
  12. /*     Bing-Bing Chai (bchai@sarnoff.com)                                   */
  13. /*     B.S. Srinivas  (bsrinivas@sarnoff.com)                               */
  14. /*                                                                          */
  15. /*   Bi-level is provided by Texas Instruments                              */
  16. /*     Jie Liang      (liang@ti.com)                                        */
  17. /*                                                                          */
  18. /*   Shape Coding is provided by  OKI Electric Industry Co., Ltd.           */
  19. /*     Zhixiong Wu    (sgo@hlabs.oki.co.jp)                                 */
  20. /*     Yoshihiro Ueda (yueda@hlabs.oki.co.jp)                               */
  21. /*     Toshifumi Kanamaru (kanamaru@hlabs.oki.co.jp)                        */
  22. /*                                                                          */
  23. /*   OKI, Sharp, Sarnoff, TI and Microsoft contributed to bitstream         */
  24. /*   exchange and bug fixing.                                               */
  25. /*                                                                          */
  26. /*                                                                          */
  27. /* In the course of development of the MPEG-4 standard, this software       */
  28. /* module is an implementation of a part of one or more MPEG-4 tools as     */
  29. /* specified by the MPEG-4 standard.                                        */
  30. /*                                                                          */
  31. /* The copyright of this software belongs to ISO/IEC. ISO/IEC gives use     */
  32. /* of the MPEG-4 standard free license to use this  software module or      */
  33. /* modifications thereof for hardware or software products claiming         */
  34. /* conformance to the MPEG-4 standard.                                      */
  35. /*                                                                          */
  36. /* Those intending to use this software module in hardware or software      */
  37. /* products are advised that use may infringe existing  patents. The        */
  38. /* original developers of this software module and their companies, the     */
  39. /* subsequent editors and their companies, and ISO/IEC have no liability    */
  40. /* and ISO/IEC have no liability for use of this software module or         */
  41. /* modification thereof in an implementation.                               */
  42. /*                                                                          */
  43. /* Permission is granted to MPEG members to use, copy, modify,              */
  44. /* and distribute the software modules ( or portions thereof )              */
  45. /* for standardization activity within ISO/IEC JTC1/SC29/WG11.              */
  46. /*                                                                          */
  47. /* Copyright 1995, 1996, 1997, 1998 ISO/IEC                                 */
  48. /****************************************************************************/
  50. /****************************************************************************/
  51. /*     Texas Instruments Predictive Embedded Zerotree (PEZW) Image Codec    */
  52. /*    Developed by Jie Liang (liang@ti.com)                                */
  53. /*                         */ 
  54. /*     Copyright 1996, 1997, 1998 Texas Instruments                    */
  55. /****************************************************************************/
  57. /****************************************************************************
  58.    File name:         PEZW_utils.c
  59.    Author:            Jie Liang  (liang@ti.com)
  60.    Functions:         utility functions for PEZW coder such as bitstream 
  61.                       parsing and formating.
  62.    Revisions:         v1.0 (10/04/98)
  63. *****************************************************************************/
  65. #include <stdio.h>
  66. #include <stdlib.h>
  67. #include <math.h>
  68. #include <memory.h>
  70. #include "globals.hpp"
  71. #include "msg.hpp"
  72. #include "bitpack.hpp"
  73. #include "startcode.hpp"
  75. #include "wvtPEZW.hpp"
  76. #include "PEZW_zerotree.hpp"
  77. #include "PEZW_mpeg4.hpp"
  79. extern int PEZW_target_spatial_levels;
  80. #define    MAXSNRLAYERS  20
  82. /* this funciton is to create and initiate the data structure
  83.    used for bilevel image coding */
  85. PEZW_SPATIAL_LAYER * CVTCCommon::Init_PEZWdata (int color, int levels, int w, int h)
  86. {
  87.   PEZW_SPATIAL_LAYER *SPlayer;
  88.   int x,y;
  89.   int i;
  91.   /* generate the Spatial Layer Structure */
  92.   SPlayer = (PEZW_SPATIAL_LAYER *)calloc (levels, sizeof(PEZW_SPATIAL_LAYER));
  93.   for (i=0; i<levels; i++)
  94.      SPlayer[i].SNRlayer = (PEZW_SNR_LAYER *)calloc(MAXSNRLAYERS, sizeof(PEZW_SNR_LAYER));
  95.      
  96.   mzte_codec.m_iScanOrder = mzte_codec.m_iScanDirection;
  98.   /* the original wavelet coefficients are in 
  99.      SPlayer[0].SNRlayer[0].snr_image   */
  100.   SPlayer[0].SNRlayer[0].snr_image.height = h;
  101.   SPlayer[0].SNRlayer[0].snr_image.width = w;
  102.   if ((SPlayer[0].SNRlayer[0].snr_image.data = calloc(h*w, sizeof(WINT)))
  103.       == NULL){
  104.     printf ("Can not allocate memory in Init_PEZWdata()");
  105.     exit(-1);
  106.   }
  108.   /* copy the wavelet coefficients into SPlayer structure */
  109.   for (y=0;y<h;y++)
  110.     for (x=0;x<w;x++)
  111.       ((WINT *)(SPlayer[0].SNRlayer[0].snr_image.data))[y*w+x] = (WINT) 
  112.   (mzte_codec.m_SPlayer[color].coeffinfo[y][x].wvt_coeff);
  114.   return (SPlayer);  
  116. }
  118. /* put the restored wavelet coefficients back to the data structure */
  119. void CVTCCommon::restore_PEZWdata (PEZW_SPATIAL_LAYER **SPlayer)
  120. {
  121.   int x,y;
  122.   int col;
  123.   int h,w;
  124.   int dch, dcw;
  125.   int levels;
  127.   for(col=0;col<mzte_codec.m_iColors;col++){
  128.     h = SPlayer[col][0].SNRlayer[0].snr_image.height;
  129.     w = SPlayer[col][0].SNRlayer[0].snr_image.width;    
  130.     
  131.     if(col==0)
  132.       levels=mzte_codec.m_iWvtDecmpLev;
  133.     else
  134.       levels=mzte_codec.m_iWvtDecmpLev-1;
  136.     dch = h/(1<<levels);
  137.     dcw = w/(1<<levels);
  139.     /* copy the wavelet coefficients into data structure */
  140.     for (y=0;y<h;y++)
  141.       for (x=0;x<w;x++){
  142. if((x>=dcw) || (y>=dch))
  143.   mzte_codec.m_SPlayer[col].coeffinfo[y][x].rec_coeff = 
  144.     ((WINT *)(SPlayer[col][0].SNRlayer[0].snr_image.data))[y*w+x]; 
  145.       }
  146.   }
  148.   return;
  150. }
  152. /* this function pack the bitstream and write to file */
  153. void CVTCEncoder::PEZW_bitpack (PEZW_SPATIAL_LAYER **SPlayer)
  154. {
  155.   int levels = mzte_codec.m_iWvtDecmpLev;
  156.   int levels_UV;
  157.   int Quant[NCOLOR], q;
  158.   int texture_spatial_layer_id;
  160.   int lev;
  161.   int col;
  162.   int snr_scalability_levels=0;
  163.   int snr_lev;
  165.   int all_zero=0, all_non_zero=0;
  166.   int LH_zero=0, HL_zero=0, HH_zero=0;
  167.   int i,n;
  169.   unsigned char *data;
  170.   long len;
  172.   int spalev;
  173.   int snroffset;
  174.   int flag;
  175.   int Bit, bits_to_go;
  177.   levels_UV = levels-1;  /* this should depend on the color format 
  178.                 mzte_codec.color_format */
  180.   /* get quantization information */
  181.   for (col=0;col<mzte_codec.m_iColors; col++)
  182.     Quant[col] = mzte_codec.m_Qinfo[col]->Quant[0];
  183.   
  184.   /* output quant for each color component */
  185.   emit_bits_checksc_init();
  186.   for (col=0;col<mzte_codec.m_iColors; col++){
  187.       q = Quant[col];
  188.       flag=0;
  189.       for(i=3;i>=0;i--)
  190. {
  191.   q = Quant[col] & (0x7F << (i*7));
  192.   q >>= 7*i;
  193.   if (q>0) flag = 1;
  194.   if (flag){
  195.     if (i>0) 
  196.       emit_bits_checksc(128+q,8);
  197.     else
  198.       emit_bits_checksc(q,8);
  199.   }
  200. }
  201.   }
  203.   /* figure out snr scalability levels */
  204.   snr_scalability_levels = 0;
  205.   for(lev=0;lev<mzte_codec.m_iWvtDecmpLev;lev++){
  206.       if(snr_scalability_levels < SPlayer[0][lev].SNR_scalability_levels)
  207.         snr_scalability_levels = SPlayer[0][lev].SNR_scalability_levels;
  208.       if (lev>0){
  209.         for (col=1;col<mzte_codec.m_iColors; col++){
  210.             if (snr_scalability_levels < SPlayer[col][lev-1].SNR_scalability_levels)
  211.             snr_scalability_levels = SPlayer[col][lev-1].SNR_scalability_levels;
  212.         }
  213.       }
  214.     }
  215.   emit_bits_checksc (snr_scalability_levels,5);
  217.   /* for bileve mode, start code is always enabled */
  218.   if (!mzte_codec.m_bStartCodeEnable)
  219.       {
  220.         fprintf(stdout,"nFor bilevel mode, SNR_start_code must be enabled!n");
  221.         exit(-1);
  222.       }
  224.   /* formatting the AC band bitstream */
  225.   if(mzte_codec.m_iScanOrder==1){
  227.     for (lev=0;lev<levels;lev++){   /* spatial scalability level */
  228.       /*------- AC: Write header info to bitstream file -------*/
  229.  if (mzte_codec.m_bStartCodeEnable)
  230. {
  231.         flush_bits();
  232.             emit_bits(TEXTURE_SPATIAL_LAYER_START_CODE >> 16, 16);
  233.             emit_bits(TEXTURE_SPATIAL_LAYER_START_CODE, 16);
  234.             texture_spatial_layer_id = lev;
  235.             emit_bits(texture_spatial_layer_id, 5);
  236. } 
  237.      
  238.     for (snr_lev=0;snr_lev<snr_scalability_levels;snr_lev++){
  239.     /* output the SNR_START_CODE if enabled */
  240.     if (mzte_codec.m_bStartCodeEnable)
  241.     {
  242.         flush_bits();
  243.         emit_bits(texture_snr_layer_start_code >> 16, 16);
  244.         emit_bits(texture_snr_layer_start_code, 16);
  245.         emit_bits(snr_lev,5);
  246.     emit_bits_checksc_init();
  247.     }
  249.     for (col=0;col<mzte_codec.m_iColors; col++){ /* for each color compoent */
  250.   
  251.         if(col>0)  
  252.             spalev = lev-1;
  253.         else    
  254.             spalev = lev;
  255.   
  256.         if((lev==0)&&(col>0))
  257.         snroffset = snr_scalability_levels-SPlayer[col][lev].SNR_scalability_levels;
  258.         else
  259.         snroffset = snr_scalability_levels-SPlayer[col][spalev].SNR_scalability_levels;
  261.         /* output SNR_ALL_ZERO flag */
  262.             if (snr_lev < snroffset){
  263.                 all_non_zero=0;
  264.             all_zero = 1;
  265.             }
  266.             else{
  267.                 all_non_zero=1;
  268.             all_zero = 0;
  269.             }
  271.             /* send all zero and subband skipping info */
  272.             if(lev==0){
  273.         emit_bits_checksc (all_non_zero,1); 
  274.                 if(!all_non_zero){
  275.                     emit_bits_checksc (all_zero,1); 
  276.                     if(!all_zero){
  277.                         emit_bits_checksc (LH_zero,1); 
  278.                         emit_bits_checksc (HL_zero,1); 
  279.                         emit_bits_checksc (HH_zero,1); 
  280.                     }
  281.                 }
  282.             }
  284.         if((lev==0)&&(col>0))
  285.       continue;
  286.   
  287.         /* send the bitstream for this snr layer if not all_zero */
  288.         if (!all_zero){
  289.             data = (unsigned char *)SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].snr_bitstream.data;
  290.             len = SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].snr_bitstream.length;
  291.             bits_to_go = SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].bits_to_go;
  292.     
  293.             /* output the bitstream */
  295.         /* the first bit of each bitplane is always 1
  296.                    to avoid start code emulation */
  297.         emit_bits_checksc(1,1);
  299.             for (n=0;n<len-1;n++){
  300.                 emit_bits_checksc (data[n],8);
  301.                 if (DEBUG_BS_DETAIL)
  302.                 fprintf(stdout,"%d ", data[n]);
  303.             }
  305.                 /* output bits in the last byte.
  306.                    if bits_to_go ==8, we output the whole byte.
  307.                    otherwise, we output only the bits that needed to be transmited. */
  308.         if(bits_to_go==8)
  309.         emit_bits_checksc (data[len-1],8);
  310.             else
  311.         emit_bits_checksc (data[len-1]>>bits_to_go,8-bits_to_go);
  312.   
  313.         /* if last bit is 1, output 1, otherwise, skip. */
  314.         if(bits_to_go==8)
  315.         bits_to_go = 0;
  316.         Bit = (data[len-1]>>bits_to_go)&0x01;
  317.         if(!Bit)
  318.         emit_bits_checksc(1,1);
  320.             if(DEBUG_BS)
  321.                 fprintf(stdout, "color %d spa_lev %d snr_lev %d: %ldn",
  322.                 col, spalev, snr_lev-snroffset, len);
  323.     
  324.         } /* end of !all_zero */
  325.       } /* end of color plane */      
  326.       } /* end of snr_scalability */
  327.     }  /* end of spatial scalability */
  328.   }
  329.   else  /* scan_order == 0 */
  330.   {    
  331.     /* package the bitstream */
  332.     for (snr_lev=0;snr_lev<snr_scalability_levels;snr_lev++)
  333.       {
  334.     /* output the SNR_START_CODE if enabled */
  335.     if (mzte_codec.m_bStartCodeEnable)
  336.     {
  337.         flush_bits();
  338.         emit_bits(texture_snr_layer_start_code >> 16, 16);
  339.         emit_bits(texture_snr_layer_start_code, 16);
  340.         emit_bits(snr_lev,5);
  341.     }
  343.     /* output the spatial levels */
  344.     for (lev=0;lev<levels;lev++){   /* spatial scalability level */
  345.     if (mzte_codec.m_bStartCodeEnable)
  346.         {
  347.             flush_bits();
  348.             emit_bits(TEXTURE_SPATIAL_LAYER_START_CODE >> 16, 16);
  349.             emit_bits(TEXTURE_SPATIAL_LAYER_START_CODE, 16);
  350.             texture_spatial_layer_id = lev;
  351.             emit_bits(texture_spatial_layer_id, 5);
  352.       
  353.             emit_bits_checksc_init(); 
  354.         }
  356.         /* for each color compoent */
  357.         for (col=0;col<mzte_codec.m_iColors; col++){
  358.             if(col>0)  
  359.                 spalev = lev-1;
  360.              else
  361.                 spalev = lev;
  362.     
  363.         if((lev==0)&&(col>0))
  364.             snroffset = snr_scalability_levels-SPlayer[col][lev].SNR_scalability_levels;
  365.         else
  366.             snroffset = snr_scalability_levels-SPlayer[col][spalev].SNR_scalability_levels;
  367.     
  368.         /* output SNR_ALL_ZERO flag */
  369.             if (snr_lev < snroffset){
  370.                 all_non_zero=0;
  371.             all_zero = 1;
  372.             }
  373.             else{
  374.                 all_non_zero=1;
  375.             all_zero = 0;
  376.             }
  378.             /* send all zero and subband skipping info */
  379.             if(lev==0){
  380.          emit_bits_checksc (all_non_zero,1); 
  381.                  if(!all_non_zero){
  382.                     emit_bits_checksc (all_zero,1); 
  383.                     if(!all_zero){
  384.                         emit_bits_checksc (LH_zero,1); 
  385.                         emit_bits_checksc (HL_zero,1); 
  386.                         emit_bits_checksc (HH_zero,1); 
  387.                     }
  388.                 }
  389.             }
  391.     if((lev==0)&&(col>0))
  392.     continue;
  393.     
  394.         /* send the bitstream for this snr layer if not all_zero */
  395.         if (!all_zero){
  396.             data = (unsigned char *)SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].snr_bitstream.data;
  397.             len = SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].snr_bitstream.length;
  398.             bits_to_go = SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].bits_to_go;
  400.             /* output the bitstream */
  402.         /* the first bit is 1 */
  403.             emit_bits_checksc(1,1);
  405.         /* output bitstream until second to last byte */
  406.             for (n=0;n<len-1;n++){
  407.         emit_bits_checksc (data[n],8);
  408.         if (DEBUG_BS_DETAIL)
  409.          fprintf(stdout,"%d ", data[n]);
  410.             }
  412.         if(bits_to_go==8)
  413.     emit_bits_checksc (data[len-1],8);
  414.             else
  415.     emit_bits_checksc (data[len-1]>>bits_to_go,8-bits_to_go);
  417.         /* if last bit is 1, output 1 */
  418.         if(bits_to_go==8)
  419.         bits_to_go = 0;
  420.         Bit = (data[len-1]>>bits_to_go)&0x01;
  421.             if(!Bit)
  422.     emit_bits_checksc(1,1);
  424.             if(DEBUG_BS)
  425.             fprintf(stdout, "color %d spa_lev %d snr_lev %d: %ldn",
  426.             col, spalev, snr_lev-snroffset, len);
  427.       
  428.     } /* end of !all_zero */
  429.   } /* end of color plane */     
  430. } /* end of spatial level */
  431.    }
  432.   }  /* end of else scan_order */
  433. }
  435. /* unpacke the bitstream into Spatial and SNR layer bitstreams 
  436.    SPlayer data structure will be created here  */
  438. void CVTCDecoder::PEZW_bit_unpack (PEZW_SPATIAL_LAYER **SPlayer)
  439. {
  440.    int splev, snrlev;
  441.    int spatial_id, snr_id;
  442.    int color;
  443.    int Quant[3]={0,0,0}, q;
  444.    int snr_scalability_levels;
  445.    int texture_spatial_layer_start_code;
  446.    int snr_layer_start_code;
  447.    unsigned char buffer[MAXSIZE];
  448.    long len;
  449.    int h,w;
  450.    int n;
  451.    int Snrlevels;
  452. //   int i, j;
  454.    /* initialize data structure */
  455.    h=mzte_codec.m_iHeight;
  456.    w=mzte_codec.m_iWidth;
  457.    for (color=0;color<mzte_codec.m_iColors;color++)
  458.      SPlayer[color] = (PEZW_SPATIAL_LAYER *)calloc (mzte_codec.m_iWvtDecmpLev,
  459.     sizeof(PEZW_SPATIAL_LAYER));
  460.    
  461.      
  462.    /* get the quantization step sizes */
  463.    get_X_bits_checksc_init();
  464.    for (color=0;color<mzte_codec.m_iColors;color++){
  465.    do {
  466.      q = get_X_bits_checksc(8);
  467.      Quant[color] <<= 7;
  468.      Quant[color] += q%128;
  469.    } while (q>=128);
  470. }
  472.    /* get the snr scalability levels 
  473.     this is the maximum level for all three color components,
  474.     it will be adjusted later on according to all_zero flag */
  475.    snr_scalability_levels = get_X_bits(5);
  476.    
  477.      
  478.    /* get the snr layer */
  479.    if (mzte_codec.m_bStartCodeEnable)
  480.  Snrlevels=snr_scalability_levels;
  481.    else
  482.  Snrlevels=1;
  483.        
  484.    for (color=0;color<mzte_codec.m_iColors;color++){
  485.  /* allocate SNR data structure */
  486.  for (splev=0;splev<mzte_codec.m_iWvtDecmpLev;splev++)
  487.    {
  488.      SPlayer[color][splev].SNR_scalability_levels = snr_scalability_levels;
  489.      
  490.      SPlayer[color][splev].SNRlayer = (PEZW_SNR_LAYER *)
  491.        calloc(snr_scalability_levels, sizeof(PEZW_SNR_LAYER));
  492.      SPlayer[color][splev].SNRlayer[0].Quant = Quant[color];
  493.      
  494.      if (color==0){
  495.        SPlayer[color][0].SNRlayer[0].snr_image.height = h;
  496.        SPlayer[color][0].SNRlayer[0].snr_image.width =  w;
  497.      }
  498.      else{
  499.        SPlayer[color][0].SNRlayer[0].snr_image.height = h/2;
  500.        SPlayer[color][0].SNRlayer[0].snr_image.width =  w/2;
  501.      }
  502.    }
  503.   } /* end of color */
  505.   /* for bileve mode, start code is always enabled */
  506.   if (!mzte_codec.m_bStartCodeEnable)
  507.       {
  508.         fprintf(stdout,"nFor bilevel mode, SNR_start_code must be enabled!n");
  509.         exit(-1);
  510.       }
  511.         
  512.   /* parse the bitstream */
  513.   if (mzte_codec.m_bStartCodeEnable){
  514.  /* align byte. Note the difference between
  515.       align_byte and align_byte1. */
  516.  align_byte();
  518.     if(mzte_codec.m_iScanOrder==1){
  519.      for (splev=0;splev<mzte_codec.m_iWvtDecmpLev;splev++)
  520.        {
  521.      /* check start code */
  522.     if (mzte_codec.m_bStartCodeEnable){
  523.      align_byte1();
  524.      texture_spatial_layer_start_code = get_X_bits(32);
  525.      if (texture_spatial_layer_start_code != 
  526.     TEXTURE_SPATIAL_LAYER_START_CODE)
  527.         printf("Wrong texture_spatial_layer_start_code.");
  528.      spatial_id = get_X_bits(5);
  529. } 
  531.       for (snrlev=0;snrlev<Snrlevels;snrlev++)
  532.     {
  533.     if (mzte_codec.m_bStartCodeEnable)
  534.      {
  535.        align_byte1();
  536.        snr_layer_start_code = get_X_bits(32);
  537.        if (snr_layer_start_code != texture_snr_layer_start_code)
  538.         printf("Wrong texture_snr_layer_start_code.");
  539.        snr_id = get_X_bits(5);
  541.    get_X_bits_checksc_init();
  542.      }
  543.    
  544.     len=0;
  545.       
  546.    /* first put all the data in SPlayer[0] */
  547.    /* the separation of the color components bitstreams will
  548.       be done by the decoding process */
  549.    
  550.    if ((splev==mzte_codec.m_iWvtDecmpLev-1)&&
  551.        (snrlev == Snrlevels-1))
  552.      len=get_allbits_checksc(buffer);
  553.    
  554.    else{
  555.      if ((!mzte_codec.m_bStartCodeEnable) /* only one bitstream */
  556.  || (snrlev==Snrlevels-1))
  557.        {
  558.  /* look for the next spatial layer start code */
  559.  while(1){
  560.    /* chekc for the next start code*/
  561.    if(!Is_startcode(TEXTURE_SPATIAL_LAYER_START_CODE)){
  562.      buffer[len] = get_X_bits_checksc(8);
  563.      len++;
  564.    }
  565.    else{
  566.      buffer[len++]=align_byte_checksc();
  567.      break; /* start code found */
  568.    }
  569.  } /* end of while */
  570.        }
  571.      else{
  572.        while(1){
  573.  /* chekc for the next start code*/
  574.  if(!Is_startcode(texture_snr_layer_start_code)){
  575.    buffer[len] = get_X_bits_checksc(8);
  576.    len++;
  577.  }
  578.  else{
  579.    buffer[len++]=align_byte_checksc();
  580.    break; /* start code found */
  581.  }
  582.        } /* end of while(1) */
  583.      } /* end of if(!mzte_...) */
  584.    } /* end of if(splev== ...) */
  585.    
  586.    SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.length = len;
  587.    SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data =
  588.      (char *)calloc(len+2,sizeof(char));
  589.    
  590.    memcpy(SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data,
  591.   buffer,len);
  592.    
  593.    if(DEBUG_BS_DETAIL)
  594.      for(n=0;n<len;n++)
  595.        fprintf(stdout,"%d ", 
  596.        ((unsigned char *)SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data)[n]);
  597.    
  598.    if (DEBUG_BS)
  599.      fprintf(stdout,"spa_lev %d snr_lev %d: %ldn", splev, snrlev, len);
  600.    
  601.     }  /* snr levels */       
  602.      }  /* spatial levels */
  603.    }
  604.    else /* scan_order == 0 */
  605.      { 
  606.        for (snrlev=0;snrlev<Snrlevels;snrlev++) 
  607.     {
  608.      /* check start code */      
  609.     if (mzte_codec.m_bStartCodeEnable){
  610.     align_byte1();
  611.     snr_layer_start_code = get_X_bits(32);
  612.     if (snr_layer_start_code != texture_snr_layer_start_code)
  613.  printf("Wrong texture_snr_layer_start_code.");
  614.     snr_id = get_X_bits(5);
  615. }
  616.    
  617.    for (splev=0;splev<mzte_codec.m_iWvtDecmpLev;splev++)
  618.      {
  619.        if (mzte_codec.m_bStartCodeEnable)
  620.     {
  621.      align_byte1();
  622.      texture_spatial_layer_start_code = get_X_bits(32);
  623.      if (texture_spatial_layer_start_code != 
  624.        TEXTURE_SPATIAL_LAYER_START_CODE)
  625.         printf("Wrong texture_spatial_layer_start_code.");
  626.      spatial_id = get_X_bits(5);
  628.      get_X_bits_checksc_init();
  629.     }
  630.         len=0;
  631.        
  632.        /* first put all the data in SPlayer[0] */
  633.        /* the separation of the color components bitstreams will
  634.       be done by the decoding process */
  635.        
  636.        if ((splev==mzte_codec.m_iWvtDecmpLev-1)&&
  637.         (snrlev == Snrlevels-1))
  638.             len=get_allbits_checksc(buffer);
  639.        else{
  640.         if ((!mzte_codec.m_bStartCodeEnable) /* only one bitstream */
  641.             || (splev==mzte_codec.m_iWvtDecmpLev-1))
  642.         {
  643.              /* look for the next spatial layer start code */
  644.              while(1){
  645.                 /* chekc for the next start code*/
  646.                 if(!Is_startcode(texture_snr_layer_start_code)){
  647.                 buffer[len] = get_X_bits_checksc(8);
  648.                 len++;
  649.                 }
  650.                 else{
  651.                 buffer[len++]=align_byte_checksc();
  652.                 break; /* start code found */
  653.                 }
  654.             } /* end of while */
  655.         }
  656.         else{
  657.             while(1){
  658.                 /* chekc for the next start code*/
  659.                 if(!Is_startcode(TEXTURE_SPATIAL_LAYER_START_CODE)){
  660.                     buffer[len] = get_X_bits_checksc(8);
  661.                     len++;
  662.                 }
  663.                 else{
  664.                     buffer[len++]=align_byte_checksc();
  665.                     break; /* start code found */
  666.                 }
  667.             } /* end of while(1) */
  668.         } /* end of if(!mzte_...) */
  669.        } /* end of if(splev== ...) */
  670.        
  671.        SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.length = len;
  672.        
  673.        SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data =
  674.         (char *)calloc(len+2,sizeof(char));
  675.        
  676.        memcpy(SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data,
  677.       buffer,len);
  678.        
  679.        if(DEBUG_BS_DETAIL)
  680.         for(n=0;n<len;n++)
  681.             fprintf(stdout,"%d ", 
  682.              ((unsigned char *)SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data)[n]);
  683.        
  684.        if (DEBUG_BS)
  685.         fprintf(stdout,"spa_lev %d snr_lev %d: %ldn", splev, snrlev, len);
  686.      }  /* spatial levels */       
  687.  }  /* snr levels */
  688.     } /* end of else scan_order */
  689.    }
  690.    else { /* no start code enabled */
  691.         fprintf(stdout,"nFor bilevel mode, SNR_start_code must be enabled!n");
  692.         exit(-1);
  693. }
  695.     for(color=0;color<mzte_codec.m_iColors;color++) {
  696.        h = SPlayer[color][0].SNRlayer[0].snr_image.height;
  697.        w = SPlayer[color][0].SNRlayer[0].snr_image.width;    
  698.        
  699.        if ((SPlayer[color][0].SNRlayer[0].snr_image.data = calloc(h*w, sizeof(WINT)))
  700.       == NULL){
  701.         printf ("Can not allocate memory in Init_PEZWdata()");
  702.         exit(-1);
  703.         }
  704.     }
  705. }
  707. /* left shift a stream by N<8 bits */
  709. int CVTCCommon::lshift_by_NBit (unsigned char *data, int len, int N)
  710. {
  711.   int n;
  712.   char mask=0;
  713.   int output;
  714.   
  715.   if(len==0)
  716.     return 1;
  717.   
  718.   output = data[0]>>(8-N);
  719.   
  720.   for(n=0;n<N;n++)
  721.     mask = (mask<<1) | 0x01;
  722.   
  723.   for (n=0;n<len-1;n++)
  724.     data[n] = (data[n]<<N) | ((data[n+1]>>(8-N)) & mask);
  725.   
  726.   data[len-1] <<= N;
  727.   
  728.   return output;
  729. }
  732. /* free up memory at the encoder */
  733. void CVTCEncoder::PEZW_freeEnc (PEZW_SPATIAL_LAYER **SPlayer)
  734. {
  735.   int levels;
  736.   int col, l;
  737.   int snrlev;
  738.   
  739.   for (col=0; col<mzte_codec.m_iColors; col++)
  740.     {
  741.       /* free the image buffer */
  742.       free(SPlayer[col][0].SNRlayer[0].snr_image.data);
  743.       
  744.       /* free the mask buffer */
  745.       free(SPlayer[col]->SNRlayer[0].snr_image.mask);
  746.       
  747.       if (col ==0) 
  748. levels = mzte_codec.m_iWvtDecmpLev;
  749.       else
  750. levels = mzte_codec.m_iWvtDecmpLev-1;
  751.       
  752.       /* free the SNR layer */
  753.       for(l=0;l<levels;l++){
  754. for (snrlev=0;snrlev<SPlayer[col][l].SNR_scalability_levels;
  755.      snrlev++)
  756.   if(SPlayer[col][l].SNRlayer[snrlev].snr_bitstream.data!=NULL)
  757.     free(SPlayer[col][l].SNRlayer[snrlev].snr_bitstream.data);
  759. free(SPlayer[col][l].SNRlayer);
  760.       }
  761.       
  762.       /* free SPlayer */
  763.       free(SPlayer[col]);
  764.     }
  765.   
  766.   /* parameters for inverse wvt */
  767.   mzte_codec.m_iSpatialLev = mzte_codec.m_iTargetSpatialLev;
  768.   mzte_codec.m_iTargetSpatialLev = PEZW_target_spatial_levels;
  769. }
  773. void CVTCDecoder::PEZW_freeDec (PEZW_SPATIAL_LAYER **SPlayer)
  774. {
  775.   int levels;
  776.   int col, l;
  777.   int snrlev;
  778.   
  779.   for (col=0; col<mzte_codec.m_iColors; col++)
  780.     {
  781.       /* free the image buffer */
  782.       free(SPlayer[col][0].SNRlayer[0].snr_image.data);
  783.       
  784.       /* free the mask buffer */
  785.   free(SPlayer[col][0].SNRlayer[0].snr_image.mask );
  786.   
  787.   if (col ==0) 
  788.     levels = mzte_codec.m_iWvtDecmpLev;
  789.   else
  790.     levels = mzte_codec.m_iWvtDecmpLev-1;
  791.       
  792.   /* free the SNR layer */
  793.   for(l=0;l<levels;l++){
  794.     if (!mzte_codec.m_bStartCodeEnable)
  795.       free(SPlayer[col][l].SNRlayer[0].snr_bitstream.data);
  796.     else {
  797.       if (col==0){
  798. for (snrlev=0;snrlev<SPlayer[col][l].SNR_scalability_levels;
  799.      snrlev++)
  800.   if(SPlayer[col][l].SNRlayer[snrlev].snr_bitstream.data!=NULL)
  801.     free(SPlayer[col][l].SNRlayer[snrlev].snr_bitstream.data);
  802.       }
  803.     }
  804.   }
  805.     }
  806.   
  807.   
  808.   /* free SNRlayer */
  809.   levels = mzte_codec.m_iWvtDecmpLev;
  810.   for (col=0; col<mzte_codec.m_iColors; col++)
  811.     for(l=0;l<levels;l++)
  812.       free(SPlayer[col][l].SNRlayer);
  813.   
  814.   /* free SPlayer */
  815.   for (col=0; col<mzte_codec.m_iColors; col++)
  816.     free(SPlayer[col]);
  818.   /* parameters for inverse wvt */
  819.   if(PEZW_target_spatial_levels>mzte_codec.m_iWvtDecmpLev)
  820.     PEZW_target_spatial_levels=mzte_codec.m_iWvtDecmpLev;
  821.   mzte_codec.m_iSpatialLev = PEZW_target_spatial_levels;
  822.   mzte_codec.m_iTargetSpatialLev = PEZW_target_spatial_levels;
  823. }