pezw_texturelayerbq.cpp

网络MPEG4IP流媒体开发源代码

          }
       
     /* get the bitstreams for each color */
     /* for YUV420, the U,V color component has one less level */
     if(col==1)
         splev_start=1;
     else
         splev_start=0;

     for (splev=0;splev<levels-spatial_leveloff;splev++)   /* from coarse scale to fine scale */
          {
          for(snrlev=SPlayer[0][splev].SNR_scalability_levels-1;snrlev>=Min_Bitplane;snrlev--) /* from msb to lsb */
              {
                /* for SPlayer, snrlayer 0 means msb bits, need to invert order */
                bplane = SPlayer[col][splev].SNR_scalability_levels-snrlev-1;

                if(col==0)
                    {
                        Init_Bufsize[splev][snrlev] = SPlayer[0][splev].SNRlayer[bplane].snr_bitstream.length;  
                        PEZW_bitstream[splev][snrlev] = (unsigned char *) SPlayer[0][splev].SNRlayer[bplane].snr_bitstream.data;
                        if(splev==0){
                            splev0_bitstream[snrlev] = PEZW_bitstream[0][snrlev];
                            splev0_bitstream_len[snrlev] = Init_Bufsize[0][snrlev];
                        }
                    }
                else{
                        Init_Bufsize[splev][snrlev] = Init_Bufsize[splev+splev_start][snrlev];
                        PEZW_bitstream[splev][snrlev] = PEZW_bitstream[splev+splev_start][snrlev];
                        reach_budget[splev][snrlev] = reach_budget[splev+splev_start][snrlev];
                    }  
                
                /* get all zero and subband skipping info. */
                if(splev==0){
                    all_non_zero[col] = lshift_by_NBit (splev0_bitstream[snrlev], splev0_bitstream_len[snrlev], 1);
                    if(!all_non_zero[col]){
                        all_zero[col] = lshift_by_NBit (splev0_bitstream[snrlev], splev0_bitstream_len[snrlev], 1);
                        if(!all_zero[col]){
                            LH_zero[col] = lshift_by_NBit (splev0_bitstream[snrlev], splev0_bitstream_len[snrlev], 1);
                            HL_zero[col] = lshift_by_NBit (splev0_bitstream[snrlev], splev0_bitstream_len[snrlev], 1);
                            HH_zero[col] = lshift_by_NBit (splev0_bitstream[snrlev], splev0_bitstream_len[snrlev], 1);
                        }
                     }
                    else
                        all_zero[col]=0;
                 }

                if(all_zero[col] && (splev==0))
                    Max_Bitplane--;
                if(all_zero[col]){
                    decoded_bytes[splev][snrlev] = 0;
                    continue;
                    }
                else    /* skip the leading '1' */
                    lshift_by_NBit (PEZW_bitstream[splev][snrlev], Init_Bufsize[splev][snrlev], 1);                                     

              }  /* end of snrlev */
         }  /* end of splev */

      /* allocate wvt_coeffs */
      wvt_coeffs = (WINT **)calloc(h,sizeof(WINT *));
      wvt_coeffs[0] = (WINT *)(SPlayer[col][0].SNRlayer[0].snr_image.data);
      for(i=1;i<h;i++)
        wvt_coeffs[i] = wvt_coeffs[0]+i*w;

      if(Max_Bitplane>0){
         /* this step must follow the previous step */
         setbuffer_PEZW_decode ();

        /* decode the bitstream for this color component */
        PEZW_decode_block (wvt_coeffs,w,h);

        /* finish PEZW coding for this color component
            retrun the number of bytes decoded in Init_Bufsize */
        PEZW_decode_done ( );

        for(splev=0;splev<levels-spatial_leveloff;splev++)
            for(snrlev=Min_Bitplane;snrlev<Max_Bitplane;snrlev++)
                {
                total_decoded_bytes += decoded_bytes[splev][snrlev];

                if(col<2){
        		            /* adjust for residue bits in last byte */
                        unsigned char Bit;
                        //unsigned char *data;

                        PEZW_bitstream[splev][snrlev] += decoded_bytes[splev][snrlev];
                        Init_Bufsize[splev][snrlev] -= decoded_bytes[splev][snrlev];
                        
                        Bit = (*(PEZW_bitstream[splev][snrlev]-1)>>bits_to_go_inBuffer[splev][snrlev])&0x01;
		                if(bits_to_go_inBuffer[splev][snrlev]>0){
		                    PEZW_bitstream[splev][snrlev]--;
		                    Init_Bufsize[splev][snrlev]++;
		                    lshift_by_NBit(PEZW_bitstream[splev][snrlev],Init_Bufsize[splev][snrlev],
                                8-bits_to_go_inBuffer[splev][snrlev]);
		                }
		                /* check last bit */
		                if(!Bit)
		                    lshift_by_NBit(PEZW_bitstream[splev][snrlev],Init_Bufsize[splev][snrlev],1);

                        if((splev==0)&&(col==0)){
                            splev0_bitstream[snrlev] = PEZW_bitstream[0][snrlev];
                            splev0_bitstream_len[snrlev] = Init_Bufsize[0][snrlev];
                        }
                }
              }
      }

     /* dequantize */
     Quant[col] = SPlayer[col][0].SNRlayer[0].Quant;
     dc_w = w>>levels;
     dc_h = h>>levels;
     for(i=0;i<h;i++)
          for(j=0;j<w;j++)
              {
                if((i<dc_h) && (j<dc_w))
                    continue;

                if(wvt_coeffs[i][j]==0)
                    temp = 0;
                else
                    temp = (int)((abs(wvt_coeffs[i][j])+0.5)*Quant[col]);
                wvt_coeffs[i][j] =  (wvt_coeffs[i][j]>0)?temp:-temp;
             }

    /* copy data to structure */
    (SPlayer[col][0].SNRlayer[0].snr_image.data) = (WINT *) wvt_coeffs[0];


     /* free memory */
     free(wvt_coeffs);
    }
   
    printf("total actually decoded bits:          %ld\n", (total_decoded_bytes+bytes_decoded)*8);
    printf("total actually decoded AC band bits:  %ld", total_decoded_bytes*8);

    /* put the decoded wavelet coefficients back into the data structure */
    restore_PEZWdata (SPlayer);
   
    /* free memory */
    PEZW_freeDec (SPlayer);
    free(SPlayer);
    for(i=0;i<levels;i++)
         free(PEZW_bitstream[i]);
    free(PEZW_bitstream);
    for (i=0;i<levels;i++)
         free(Init_Bufsize[i]);
    free(Init_Bufsize);
    for (i=0;i<levels;i++)
       free(reach_budget[i]);
    free(reach_budget);
    for (i=0;i<levels+1;i++)
       free(bits_to_go_inBuffer[i]);
    free(bits_to_go_inBuffer);
    for (i=0;i<levels+1;i++)
       free(decoded_bytes[i]);
    free(decoded_bytes);
    free(splev0_bitstream);
    free(splev0_bitstream_len); 
}

/* rate control at decoding */
void CVTCDecoder::PEZW_decode_ratecontrol (PEZW_SPATIAL_LAYER **SPlayer, int bytes_decoded)
{
    int i, levels;
    long decoded_bits=bytes_decoded;
    int splayer, snrlev, bplane;
    int MaxBitplanes;
    int last_bplane = 0, last_splayer = 0, adjusted_rate=0;
    int diffrate;
    int min_snrlev;

    levels = mzte_codec.m_iWvtDecmpLev;

    /* allocate rate control structure */
    reach_budget = (unsigned char **) calloc(levels,sizeof(char *));
    for(i=0;i<levels;i++)
        reach_budget[i]= (unsigned char *)calloc(Max_Bitplane,sizeof(char));

	/* target bitplane */
	Min_Bitplane  = SPlayer[0][0].SNR_scalability_levels-PEZW_target_snr_levels;
	if ( Min_Bitplane < 0)
	    Min_Bitplane  = 0;

	/* target spatial level */
	spatial_leveloff = mzte_codec.m_iWvtDecmpLev-PEZW_target_spatial_levels;
	if (spatial_leveloff <0)
        spatial_leveloff=0;

    /* figure out the target snr and spatial layer
       and the length for the last layer for target_bitrate options */
    MaxBitplanes = SPlayer[0][0].SNR_scalability_levels;
    if ((decoded_bits < PEZW_target_bitrate/8) && (PEZW_target_bitrate >0)){
        if(mzte_codec.m_iScanOrder==1)
            {
                for (splayer=0;splayer<mzte_codec.m_iWvtDecmpLev-spatial_leveloff ;splayer++)
                    for (snrlev=MaxBitplanes-1;snrlev>=Min_Bitplane;snrlev--)              
                            {
                                /* for SPlayer, snrlayer 0 means msb bits, need to invert order */
                                bplane = SPlayer[0][splayer].SNR_scalability_levels
                                            -snrlev-1;

                                decoded_bits += SPlayer[0][splayer].SNRlayer[bplane].snr_bitstream.length;
                                if ( decoded_bits >= mzte_codec.m_iTargetBitrate/8){
                                       adjusted_rate = 1;
                                       last_bplane = bplane;
                                       last_splayer = splayer;
                                       goto outside;
                                     }
                            }
            }
        else if (mzte_codec.m_iScanOrder==0)
            {
               for (snrlev=MaxBitplanes-1;snrlev>=Min_Bitplane;snrlev--)              
                 for (splayer=0;splayer<mzte_codec.m_iWvtDecmpLev-spatial_leveloff ;splayer++)
                     {
                       /* for SPlayer, snrlayer 0 means msb bits, need to invert order */
                       bplane = SPlayer[0][splayer].SNR_scalability_levels
                                  -snrlev-1;

                       decoded_bits += SPlayer[0][splayer].SNRlayer[bplane].snr_bitstream.length;
                       if ( decoded_bits >= PEZW_target_bitrate/8){
                            adjusted_rate = 1;
                            last_bplane = bplane;
                            last_splayer = splayer;
                            goto outside;
                           }
                     }
            }
     }

outside:
     if(adjusted_rate){
        diffrate = decoded_bits - PEZW_target_bitrate/8;
        SPlayer[0][last_splayer].SNRlayer[last_bplane].snr_bitstream.length
            -= diffrate;

        /* set up target snr and spatial levels, as well as
           the rate control matrix */

        if (mzte_codec.m_iScanOrder==0){
            min_snrlev = MaxBitplanes-1-last_bplane;
            for (splayer=last_splayer;splayer<mzte_codec.m_iWvtDecmpLev-spatial_leveloff;splayer++)                
                        reach_budget[splayer][min_snrlev] = 1;
            reach_budget[last_splayer][min_snrlev]=0;
            Min_Bitplane = min_snrlev;
        }
        else if (mzte_codec.m_iScanOrder==1){
            min_snrlev = MaxBitplanes-1-last_bplane;
            for (bplane=min_snrlev;bplane>=Min_Bitplane;bplane--)               
                     reach_budget[last_splayer][bplane] = 1;
            reach_budget[last_splayer][min_snrlev]=0;
            spatial_leveloff = mzte_codec.m_iWvtDecmpLev-1-last_splayer;
        }

        decoded_bits = PEZW_target_bitrate;
     }

    return;
}