vtc_pezw_pezw_utils.cpp

完整的RTP RTSP代码库

/****************************************************************************/
/*   MPEG4 Visual Texture Coding (VTC) Mode Software                        */
/*                                                                          */
/*   This software was jointly developed by the following participants:     */
/*                                                                          */
/*   Single-quant,  multi-quant and flow control                            */
/*   are provided by  Sarnoff Corporation                                   */
/*     Iraj Sodagar   ([e-mail])                                    */
/*     Hung-Ju Lee    ([e-mail])                                   */
/*     Paul Hatrack   ([e-mail])                                 */
/*     Shipeng Li     ([e-mail])                                 */
/*     Bing-Bing Chai ([e-mail])                                   */
/*     B.S. Srinivas  ([e-mail])                               */
/*                                                                          */
/*   Bi-level is provided by Texas Instruments                              */
/*     Jie Liang      ([e-mail])                                        */
/*                                                                          */
/*   Shape Coding is provided by  OKI Electric Industry Co., Ltd.           */
/*     Zhixiong Wu    ([e-mail])                                 */
/*     Yoshihiro Ueda ([e-mail])                               */
/*     Toshifumi Kanamaru ([e-mail])                        */
/*                                                                          */
/*   OKI, Sharp, Sarnoff, TI and Microsoft contributed to bitstream         */
/*   exchange and bug fixing.                                               */
/*                                                                          */
/*                                                                          */
/* In the course of development of the MPEG-4 standard, this software       */
/* module is an implementation of a part of one or more MPEG-4 tools as     */
/* specified by the MPEG-4 standard.                                        */
/*                                                                          */
/* The copyright of this software belongs to ISO/IEC. ISO/IEC gives use     */
/* of the MPEG-4 standard free license to use this  software module or      */
/* modifications thereof for hardware or software products claiming         */
/* conformance to the MPEG-4 standard.                                      */
/*                                                                          */
/* Those intending to use this software module in hardware or software      */
/* products are advised that use may infringe existing  patents. The        */
/* original developers of this software module and their companies, the     */
/* subsequent editors and their companies, and ISO/IEC have no liability    */
/* and ISO/IEC have no liability for use of this software module or         */
/* modification thereof in an implementation.                               */
/*                                                                          */
/* Permission is granted to MPEG members to use, copy, modify,              */
/* and distribute the software modules ( or portions thereof )              */
/* for standardization activity within ISO/IEC JTC1/SC29/WG11.              */
/*                                                                          */
/* Copyright 1995, 1996, 1997, 1998 ISO/IEC                                 */
/****************************************************************************/

/****************************************************************************/
/*     Texas Instruments Predictive Embedded Zerotree (PEZW) Image Codec    */
/*	   Developed by Jie Liang ([e-mail])                                */
/*													                        */ 
/*     Copyright 1996, 1997, 1998 Texas Instruments	      		            */
/****************************************************************************/

/****************************************************************************
   File name:         PEZW_utils.c
   Author:            Jie Liang  ([e-mail])
   Functions:         utility functions for PEZW coder such as bitstream 
                      parsing and formating.
   Revisions:         v1.0 (10/04/98)
*****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <memory.h>

#include "globals.hpp"
#include "msg.hpp"
#include "bitpack.hpp"
#include "startcode.hpp"

#include "wvtPEZW.hpp"
#include "PEZW_zerotree.hpp"
#include "PEZW_mpeg4.hpp"

extern int PEZW_target_spatial_levels;
#define    MAXSNRLAYERS  20

/* this funciton is to create and initiate the data structure
   used for bilevel image coding */

PEZW_SPATIAL_LAYER * CVTCCommon::Init_PEZWdata (int color, int levels, int w, int h)
{
  PEZW_SPATIAL_LAYER *SPlayer;
  int x,y;
  int i;

  /* generate the Spatial Layer Structure */
  SPlayer = (PEZW_SPATIAL_LAYER *)calloc (levels, sizeof(PEZW_SPATIAL_LAYER));
  for (i=0; i<levels; i++)
     SPlayer[i].SNRlayer = (PEZW_SNR_LAYER *)calloc(MAXSNRLAYERS, sizeof(PEZW_SNR_LAYER));
     
  mzte_codec.m_iScanOrder = mzte_codec.m_iScanDirection;

  /* the original wavelet coefficients are in 
     SPlayer[0].SNRlayer[0].snr_image   */
  SPlayer[0].SNRlayer[0].snr_image.height = h;
  SPlayer[0].SNRlayer[0].snr_image.width = w;
  if ((SPlayer[0].SNRlayer[0].snr_image.data = calloc(h*w, sizeof(WINT)))
      == NULL){
    printf ("Can not allocate memory in Init_PEZWdata()");
    exit(-1);
  }

  /* copy the wavelet coefficients into SPlayer structure */
  for (y=0;y<h;y++)
    for (x=0;x<w;x++)
      ((WINT *)(SPlayer[0].SNRlayer[0].snr_image.data))[y*w+x] = (WINT) 
	  (mzte_codec.m_SPlayer[color].coeffinfo[y][x].wvt_coeff);

  return (SPlayer);  

}

/* put the restored wavelet coefficients back to the data structure */
void CVTCCommon::restore_PEZWdata (PEZW_SPATIAL_LAYER **SPlayer)
{
  int x,y;
  int col;
  int h,w;
  int dch, dcw;
  int levels;

  for(col=0;col<mzte_codec.m_iColors;col++){
    h = SPlayer[col][0].SNRlayer[0].snr_image.height;
    w = SPlayer[col][0].SNRlayer[0].snr_image.width;    
    
    if(col==0)
      levels=mzte_codec.m_iWvtDecmpLev;
    else
      levels=mzte_codec.m_iWvtDecmpLev-1;

    dch = h/(1<<levels);
    dcw = w/(1<<levels);

    /* copy the wavelet coefficients into data structure */
    for (y=0;y<h;y++)
      for (x=0;x<w;x++){
	if((x>=dcw) || (y>=dch))
	  mzte_codec.m_SPlayer[col].coeffinfo[y][x].rec_coeff = 	
	    ((WINT *)(SPlayer[col][0].SNRlayer[0].snr_image.data))[y*w+x]; 
      }
  }

  return;

}

/* this function pack the bitstream and write to file */
void CVTCEncoder::PEZW_bitpack (PEZW_SPATIAL_LAYER **SPlayer)
{
  int levels = mzte_codec.m_iWvtDecmpLev;
  int levels_UV;
  int Quant[NCOLOR], q;
  int texture_spatial_layer_id;

  int lev;
  int col;
  int snr_scalability_levels=0;
  int snr_lev;

  int all_zero=0, all_non_zero=0;
  int LH_zero=0, HL_zero=0, HH_zero=0;
  int i,n;

  unsigned char *data;
  long len;

  int spalev;
  int snroffset;
  int flag;
  int Bit, bits_to_go;

  levels_UV = levels-1;  /* this should depend on the color format 
			                mzte_codec.color_format */

  /* get quantization information */
  for (col=0;col<mzte_codec.m_iColors; col++)
    Quant[col] = mzte_codec.m_Qinfo[col]->Quant[0];
  
  /* output quant for each color component */
  emit_bits_checksc_init();
  for (col=0;col<mzte_codec.m_iColors; col++){
      q = Quant[col];
      flag=0;
      for(i=3;i>=0;i--)
	{
	  q = Quant[col] & (0x7F << (i*7));
	  q >>= 7*i;
	  if (q>0) flag = 1;
	  if (flag){
	    if (i>0) 
	      emit_bits_checksc(128+q,8);
	    else
	      emit_bits_checksc(q,8);
	  }
	}
  }

  /* figure out snr scalability levels */
  snr_scalability_levels = 0;
  for(lev=0;lev<mzte_codec.m_iWvtDecmpLev;lev++){
      if(snr_scalability_levels < SPlayer[0][lev].SNR_scalability_levels)
        snr_scalability_levels = SPlayer[0][lev].SNR_scalability_levels;
      if (lev>0){
	        for (col=1;col<mzte_codec.m_iColors; col++){
	            if (snr_scalability_levels < SPlayer[col][lev-1].SNR_scalability_levels)
	            snr_scalability_levels = SPlayer[col][lev-1].SNR_scalability_levels;
	        }
      }
    }
  emit_bits_checksc (snr_scalability_levels,5);

  /* 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);
      }

  /* formatting the AC band bitstream */
  if(mzte_codec.m_iScanOrder==1){

    for (lev=0;lev<levels;lev++){   /* spatial scalability level */
      /*------- AC: Write header info to bitstream file -------*/
	 if (mzte_codec.m_bStartCodeEnable)	
		{
	        flush_bits();
            emit_bits(TEXTURE_SPATIAL_LAYER_START_CODE >> 16, 16);
            emit_bits(TEXTURE_SPATIAL_LAYER_START_CODE, 16);
            texture_spatial_layer_id = lev;
            emit_bits(texture_spatial_layer_id, 5);
		} 
     
    for (snr_lev=0;snr_lev<snr_scalability_levels;snr_lev++){
	    /* output the SNR_START_CODE if enabled */
	    if (mzte_codec.m_bStartCodeEnable)
	    {
	        flush_bits();
	        emit_bits(texture_snr_layer_start_code >> 16, 16);
	        emit_bits(texture_snr_layer_start_code, 16);
	        emit_bits(snr_lev,5);
		    emit_bits_checksc_init();
	    }
	
	    for (col=0;col<mzte_codec.m_iColors; col++){ /* for each color compoent */
	  
	        if(col>0)  
	            spalev = lev-1;
	        else	   
	            spalev = lev;
	  
	        if((lev==0)&&(col>0))
		        snroffset = snr_scalability_levels-SPlayer[col][lev].SNR_scalability_levels;
	        else
		        snroffset = snr_scalability_levels-SPlayer[col][spalev].SNR_scalability_levels;

	        /* output SNR_ALL_ZERO flag */
            if (snr_lev < snroffset){
                all_non_zero=0;
	            all_zero = 1;
            }
            else{
                all_non_zero=1;
	            all_zero = 0;
            }

            /* send all zero and subband skipping info */
            if(lev==0){
		        emit_bits_checksc (all_non_zero,1); 
                if(!all_non_zero){
                    emit_bits_checksc (all_zero,1); 
                    if(!all_zero){
                        emit_bits_checksc (LH_zero,1); 
                        emit_bits_checksc (HL_zero,1); 
                        emit_bits_checksc (HH_zero,1); 
                    }
                }
            }

	        if((lev==0)&&(col>0))
		      continue;
	  
	        /* send the bitstream for this snr layer if not all_zero */
	        if (!all_zero){
	            data = (unsigned char *)SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].snr_bitstream.data;
	            len = SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].snr_bitstream.length;
	            bits_to_go = SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].bits_to_go;
	    
	            /* output the bitstream */

		        /* the first bit of each bitplane is always 1
                   to avoid start code emulation */
		        emit_bits_checksc(1,1);

	            for (n=0;n<len-1;n++){
	                emit_bits_checksc (data[n],8);
	                if (DEBUG_BS_DETAIL)
		                fprintf(stdout,"%d ", data[n]);
	            }

                /* output bits in the last byte.
                   if bits_to_go ==8, we output the whole byte.
                   otherwise, we output only the bits that needed to be transmited. */
		        if(bits_to_go==8)
			        emit_bits_checksc (data[len-1],8);
	            else
			        emit_bits_checksc (data[len-1]>>bits_to_go,8-bits_to_go);
		  
		        /* if last bit is 1, output 1, otherwise, skip. */
		        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 snr_scalability */
    }  /* end of spatial scalability */
  }
  else  /* scan_order == 0 */
  {    
    /* package the bitstream */
    for (snr_lev=0;snr_lev<snr_scalability_levels;snr_lev++)
      {
	    /* output the SNR_START_CODE if enabled */
	    if (mzte_codec.m_bStartCodeEnable)
	    {
	        flush_bits();
	        emit_bits(texture_snr_layer_start_code >> 16, 16);
	        emit_bits(texture_snr_layer_start_code, 16);
	        emit_bits(snr_lev,5);
	    }	
	
	    /* output the spatial levels */
	    for (lev=0;lev<levels;lev++){   /* spatial scalability level */
		    if (mzte_codec.m_bStartCodeEnable)
	        {
	            flush_bits();
	            emit_bits(TEXTURE_SPATIAL_LAYER_START_CODE >> 16, 16);
	            emit_bits(TEXTURE_SPATIAL_LAYER_START_CODE, 16);
	            texture_spatial_layer_id = lev;
	            emit_bits(texture_spatial_layer_id, 5);
	      
	            emit_bits_checksc_init(); 
	        }
		
	        /* for each color compoent */
	        for (col=0;col<mzte_codec.m_iColors; col++){
	            if(col>0)  
	                spalev = lev-1;
	             else
	                spalev = lev;
	    
		        if((lev==0)&&(col>0))
		            snroffset = snr_scalability_levels-SPlayer[col][lev].SNR_scalability_levels;
		        else
		            snroffset = snr_scalability_levels-SPlayer[col][spalev].SNR_scalability_levels;
	    
	        /* output SNR_ALL_ZERO flag */
            if (snr_lev < snroffset){
                all_non_zero=0;
	            all_zero = 1;
            }
            else{
                all_non_zero=1;
	            all_zero = 0;
            }

            /* send all zero and subband skipping info */
            if(lev==0){
		         emit_bits_checksc (all_non_zero,1); 
                 if(!all_non_zero){
                    emit_bits_checksc (all_zero,1); 
                    if(!all_zero){
                        emit_bits_checksc (LH_zero,1); 
                        emit_bits_checksc (HL_zero,1); 
                        emit_bits_checksc (HH_zero,1); 
                    }
                }
            }

		    if((lev==0)&&(col>0))
			    continue;
	    
	        /* send the bitstream for this snr layer if not all_zero */
	        if (!all_zero){
	            data = (unsigned char *)SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].snr_bitstream.data;
	            len = SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].snr_bitstream.length;
	            bits_to_go = SPlayer[col][spalev].SNRlayer[snr_lev-snroffset].bits_to_go;

	            /* output the bitstream */

		        /* the first bit is 1 */
		            emit_bits_checksc(1,1);

		        /* output bitstream until second to last byte */
	            for (n=0;n<len-1;n++){
			        emit_bits_checksc (data[n],8);
			        if (DEBUG_BS_DETAIL)
			        	fprintf(stdout,"%d ", data[n]);
	            }

		        if(bits_to_go==8)
				    emit_bits_checksc (data[len-1],8);