vtc_pezw_pezw_utils.cpp

完整的RTP RTSP代码库

	            else
				    emit_bits_checksc (data[len-1]>>bits_to_go,8-bits_to_go);

		        /* if last bit is 1, output 1 */
		        if(bits_to_go==8)
			        bits_to_go = 0;
		        Bit = (data[len-1]>>bits_to_go)&0x01;
		            if(!Bit)
			    emit_bits_checksc(1,1);

	            if(DEBUG_BS)
		            fprintf(stdout, "color %d spa_lev %d snr_lev %d: %ld\n",
			            col, spalev, snr_lev-snroffset, len);
	      
	    } /* end of !all_zero */
	  } /* end of color plane */     
	} /* end of spatial level */
   }
  }  /* end of else scan_order */
}

/* unpacke the bitstream into Spatial and SNR layer bitstreams 
   SPlayer data structure will be created here  */

void CVTCDecoder::PEZW_bit_unpack (PEZW_SPATIAL_LAYER **SPlayer)
{
   int splev, snrlev;
   int spatial_id, snr_id;
   int color;
   int Quant[3]={0,0,0}, q;
   int snr_scalability_levels;
   int texture_spatial_layer_start_code;
   int snr_layer_start_code;
   unsigned char buffer[MAXSIZE];
   long len;
   int h,w;
   int n;
   int Snrlevels;
//   int i, j;

   /* initialize data structure */
   h=mzte_codec.m_iHeight;
   w=mzte_codec.m_iWidth;
   for (color=0;color<mzte_codec.m_iColors;color++)
     SPlayer[color] = (PEZW_SPATIAL_LAYER *)calloc (mzte_codec.m_iWvtDecmpLev,
						    sizeof(PEZW_SPATIAL_LAYER));
   
   	 
   /* get the quantization step sizes */
   get_X_bits_checksc_init();
   for (color=0;color<mzte_codec.m_iColors;color++){
	   do {
	     q = get_X_bits_checksc(8);
	     Quant[color] <<= 7;
	     Quant[color] += q%128;
	   } while (q>=128);
	}

   /* get the snr scalability levels 
	    this is the maximum level for all three color components,
	    it will be adjusted later on according to all_zero flag */
   snr_scalability_levels = get_X_bits(5);
   
   	 
   /* get the snr layer */
   if (mzte_codec.m_bStartCodeEnable)
	 Snrlevels=snr_scalability_levels;
   else
	 Snrlevels=1;
       
   for (color=0;color<mzte_codec.m_iColors;color++){
	 /* allocate SNR data structure */
	 for (splev=0;splev<mzte_codec.m_iWvtDecmpLev;splev++)
	   {
	     SPlayer[color][splev].SNR_scalability_levels = snr_scalability_levels;
	     
	     SPlayer[color][splev].SNRlayer = (PEZW_SNR_LAYER *)
	       calloc(snr_scalability_levels, sizeof(PEZW_SNR_LAYER));
	     SPlayer[color][splev].SNRlayer[0].Quant = Quant[color];
	     
	     if (color==0){
	       SPlayer[color][0].SNRlayer[0].snr_image.height = h;
	       SPlayer[color][0].SNRlayer[0].snr_image.width =  w;
	     }
	     else{
	       SPlayer[color][0].SNRlayer[0].snr_image.height = h/2;
	       SPlayer[color][0].SNRlayer[0].snr_image.width =  w/2;
	     }
	   }
  } /* end of color */

  /* for bileve mode, start code is always enabled */
  if (!mzte_codec.m_bStartCodeEnable)
      {
        fprintf(stdout,"\nFor bilevel mode, SNR_start_code must be enabled!\n");
        exit(-1);
      }
        
  /* parse the bitstream */
  if (mzte_codec.m_bStartCodeEnable){
	 /* align byte. Note the difference between
      align_byte and align_byte1. */
	 align_byte();

    if(mzte_codec.m_iScanOrder==1){
     for (splev=0;splev<mzte_codec.m_iWvtDecmpLev;splev++)
       {
	     /* check start code */
	    if (mzte_codec.m_bStartCodeEnable){
		     align_byte1();
		     texture_spatial_layer_start_code = get_X_bits(32);
		     if (texture_spatial_layer_start_code != 
			    TEXTURE_SPATIAL_LAYER_START_CODE)
		        printf("Wrong texture_spatial_layer_start_code.");
		     spatial_id = get_X_bits(5);
		} 

 	    for (snrlev=0;snrlev<Snrlevels;snrlev++)
	    {
	    if (mzte_codec.m_bStartCodeEnable)
	     {
	       align_byte1();
	       snr_layer_start_code = get_X_bits(32);
	       if (snr_layer_start_code != texture_snr_layer_start_code)
		        printf("Wrong texture_snr_layer_start_code.");
	       snr_id = get_X_bits(5);

		   get_X_bits_checksc_init();
	     }
	   
	    len=0;
	      
	   /* first put all the data in SPlayer[0] */
	   /* the separation of the color components bitstreams will
	      be done by the decoding process */
	   
	   if ((splev==mzte_codec.m_iWvtDecmpLev-1)&&
	       (snrlev == Snrlevels-1))
	     len=get_allbits_checksc(buffer);
	   
	   else{
	     if ((!mzte_codec.m_bStartCodeEnable) /* only one bitstream */
		 || (snrlev==Snrlevels-1))
	       {
		 /* look for the next spatial layer start code */
		 while(1){
		   /* chekc for the next start code*/
		   if(!Is_startcode(TEXTURE_SPATIAL_LAYER_START_CODE)){
		     buffer[len] = get_X_bits_checksc(8);
		     len++;
		   }
		   else{
		     buffer[len++]=align_byte_checksc();
		     break; /* start code found */
		   }
		 } /* end of while */
	       }
	     else{
	       while(1){
		 /* chekc for the next start code*/
		 if(!Is_startcode(texture_snr_layer_start_code)){
		   buffer[len] = get_X_bits_checksc(8);
		   len++;
		 }
		 else{
		   buffer[len++]=align_byte_checksc();
		   break; /* start code found */
		 }
	       } /* end of while(1) */
	     } /* end of if(!mzte_...) */
	   } /* end of if(splev== ...) */
	   
	   SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.length = len;
	   SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data =
	     (char *)calloc(len+2,sizeof(char));
	   
	   memcpy(SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data,
		  buffer,len);
	   
	   if(DEBUG_BS_DETAIL)
	     for(n=0;n<len;n++)
	       fprintf(stdout,"%d ", 
		       ((unsigned char *)SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data)[n]);
	   
	   if (DEBUG_BS)
	     fprintf(stdout,"spa_lev %d snr_lev %d: %ld\n", splev, snrlev, len);
	   
	    }  /* snr levels */       
     }  /* spatial levels */
   }
   else /* scan_order == 0 */
     { 
       for (snrlev=0;snrlev<Snrlevels;snrlev++) 
	    {
	     /* check start code */      
	    if (mzte_codec.m_bStartCodeEnable){
		    align_byte1();
		    snr_layer_start_code = get_X_bits(32);
		    if (snr_layer_start_code != texture_snr_layer_start_code)
			 printf("Wrong texture_snr_layer_start_code.");
		    snr_id = get_X_bits(5);
		}
	   
	   for (splev=0;splev<mzte_codec.m_iWvtDecmpLev;splev++)
	     {
	       if (mzte_codec.m_bStartCodeEnable)
		    {
		     align_byte1();
		     texture_spatial_layer_start_code = get_X_bits(32);
		     if (texture_spatial_layer_start_code != 
		       TEXTURE_SPATIAL_LAYER_START_CODE)
		        printf("Wrong texture_spatial_layer_start_code.");
		     spatial_id = get_X_bits(5);

		     get_X_bits_checksc_init();
		    }
	        len=0;
	       
	       /* first put all the data in SPlayer[0] */
	       /* the separation of the color components bitstreams will
		      be done by the decoding process */
	       
	       if ((splev==mzte_codec.m_iWvtDecmpLev-1)&&
		        (snrlev == Snrlevels-1))
		            len=get_allbits_checksc(buffer);
	       else{
		        if ((!mzte_codec.m_bStartCodeEnable) /* only one bitstream */
		            || (splev==mzte_codec.m_iWvtDecmpLev-1))
		        {
		             /* look for the next spatial layer start code */
		             while(1){
		                /* chekc for the next start code*/
		                if(!Is_startcode(texture_snr_layer_start_code)){
			                buffer[len] = get_X_bits_checksc(8);
			                len++;
		                }
		                else{
			                buffer[len++]=align_byte_checksc();
			                break; /* start code found */
		                }
		            } /* end of while */
		        }
		        else{
		            while(1){
		                /* chekc for the next start code*/
		                if(!Is_startcode(TEXTURE_SPATIAL_LAYER_START_CODE)){
		                    buffer[len] = get_X_bits_checksc(8);
		                    len++;
		                }
		                else{
		                    buffer[len++]=align_byte_checksc();
		                    break; /* start code found */
		                }
		            } /* end of while(1) */
		        } /* end of if(!mzte_...) */
	       } /* end of if(splev== ...) */
	       
	       SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.length = len;
	       
	       SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data =
		        (char *)calloc(len+2,sizeof(char));
	       
	       memcpy(SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data,
		      buffer,len);
	       
	       if(DEBUG_BS_DETAIL)
		        for(n=0;n<len;n++)
		            fprintf(stdout,"%d ", 
			             ((unsigned char *)SPlayer[0][splev].SNRlayer[snrlev].snr_bitstream.data)[n]);
	       
	       if (DEBUG_BS)
		        fprintf(stdout,"spa_lev %d snr_lev %d: %ld\n", splev, snrlev, len);
	     }  /* spatial levels */       
	 }  /* snr levels */
    } /* end of else scan_order */
   }
   else { /* no start code enabled */
        fprintf(stdout,"\nFor bilevel mode, SNR_start_code must be enabled!\n");
        exit(-1);
	}

    for(color=0;color<mzte_codec.m_iColors;color++) {
       h = SPlayer[color][0].SNRlayer[0].snr_image.height;
       w = SPlayer[color][0].SNRlayer[0].snr_image.width;    
       
       if ((SPlayer[color][0].SNRlayer[0].snr_image.data = calloc(h*w, sizeof(WINT)))
	      == NULL){
	        printf ("Can not allocate memory in Init_PEZWdata()");
	        exit(-1);
        }
    }
}

/* left shift a stream by N<8 bits */

int CVTCCommon::lshift_by_NBit (unsigned char *data, int len, int N)
{
  int n;
  char mask=0;
  int output;
  
  if(len==0)
    return 1;
  
  output = data[0]>>(8-N);
  
  for(n=0;n<N;n++)
    mask = (mask<<1) | 0x01;
  
  for (n=0;n<len-1;n++)
    data[n] = (data[n]<<N) | ((data[n+1]>>(8-N)) & mask);
  
  data[len-1] <<= N;
  
  return output;
}


/* free up memory at the encoder */
void CVTCEncoder::PEZW_freeEnc (PEZW_SPATIAL_LAYER **SPlayer)
{
  int levels;
  int col, l;
  int snrlev;
  
  for (col=0; col<mzte_codec.m_iColors; col++)
    {
      /* free the image buffer */
      free(SPlayer[col][0].SNRlayer[0].snr_image.data);
      
      /* free the mask buffer */
      free(SPlayer[col]->SNRlayer[0].snr_image.mask);	
      
      if (col ==0) 
	levels = mzte_codec.m_iWvtDecmpLev;
      else
	levels = mzte_codec.m_iWvtDecmpLev-1;
      
      /* free the SNR layer */
      for(l=0;l<levels;l++){
	for (snrlev=0;snrlev<SPlayer[col][l].SNR_scalability_levels;
	     snrlev++)
	  if(SPlayer[col][l].SNRlayer[snrlev].snr_bitstream.data!=NULL)
	    free(SPlayer[col][l].SNRlayer[snrlev].snr_bitstream.data);
	
	free(SPlayer[col][l].SNRlayer);
      }
      
      /* free SPlayer */
      free(SPlayer[col]);
    }
  
  /* parameters for inverse wvt */
  mzte_codec.m_iSpatialLev = mzte_codec.m_iTargetSpatialLev;
  mzte_codec.m_iTargetSpatialLev = PEZW_target_spatial_levels;
}



void CVTCDecoder::PEZW_freeDec (PEZW_SPATIAL_LAYER **SPlayer)
{
  int levels;
  int col, l;
  int snrlev;
  
  for (col=0; col<mzte_codec.m_iColors; col++)
    {
      /* free the image buffer */
      free(SPlayer[col][0].SNRlayer[0].snr_image.data);
      
      /* free the mask buffer */
	  free(SPlayer[col][0].SNRlayer[0].snr_image.mask );
	  
	  if (col ==0) 
	    levels = mzte_codec.m_iWvtDecmpLev;
	  else
	    levels = mzte_codec.m_iWvtDecmpLev-1;
      
	  /* free the SNR layer */
	  for(l=0;l<levels;l++){
	    if (!mzte_codec.m_bStartCodeEnable)
	      free(SPlayer[col][l].SNRlayer[0].snr_bitstream.data);
	    else {
	      if (col==0){
		for (snrlev=0;snrlev<SPlayer[col][l].SNR_scalability_levels;
		     snrlev++)
		  if(SPlayer[col][l].SNRlayer[snrlev].snr_bitstream.data!=NULL)
		    free(SPlayer[col][l].SNRlayer[snrlev].snr_bitstream.data);
	      }
	    }
	  }
    }
  
  
  /* free SNRlayer */
  levels = mzte_codec.m_iWvtDecmpLev;
  for (col=0; col<mzte_codec.m_iColors; col++)
    for(l=0;l<levels;l++)
      free(SPlayer[col][l].SNRlayer);
  
  /* free SPlayer */
  for (col=0; col<mzte_codec.m_iColors; col++)
    free(SPlayer[col]);

  /* parameters for inverse wvt */
  if(PEZW_target_spatial_levels>mzte_codec.m_iWvtDecmpLev)
    PEZW_target_spatial_levels=mzte_codec.m_iWvtDecmpLev;
  mzte_codec.m_iSpatialLev = PEZW_target_spatial_levels;
  mzte_codec.m_iTargetSpatialLev = PEZW_target_spatial_levels;
}