pezw_texturelayerbq.cpp

网络MPEG4IP流媒体开发源代码

/****************************************************************************/
/*   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_textureLayerBQ.c
   Author:            Jie Liang  ([e-mail])
   Functions:         main control module for PEZW coding. Functions in this
                      file are the only interface with other parts of MPEG4 
                      code along with the global variables in wvtPEZW.h.
   Revisions:         v1.0 (10/04/98)
*****************************************************************************/

#include "wvtPEZW.hpp"
#include "PEZW_mpeg4.hpp"
#include "PEZW_zerotree.hpp"
#include "wvtpezw_tree_codec.hpp"
#include <PEZW_functions.hpp>

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

/* decoding parameters imported form main.c.
   they should be defined before calling PEZW decoder. */
int PEZW_target_spatial_levels=10;
int PEZW_target_snr_levels=20;
int PEZW_target_bitrate=0;

void CVTCEncoder::textureLayerBQ_Enc(FILE *bitfile)
{
  PEZW_SPATIAL_LAYER *SPlayer[3];
  int h,w;
  int Quant[3];
  int levels, col;
  static short **wvt_coeffs;
  int snrlev,splev;
  int dc_w, dc_h;
  int temp;
  int i,j,bplane;
   
  /*------- AC: encode all color components -------*/
  for (col=0; col<mzte_codec.m_iColors; col++)
    { 
      printf("Bilevel-Quant Mode - Color %d\n",col);
      
      if (col ==0)  /* Lum */
	    {
	        h = mzte_codec.m_iHeight;
	        w = mzte_codec.m_iWidth;
	        levels = mzte_codec.m_iWvtDecmpLev;
	    }
      else { /* should depend on mzte_codec.color_format;
		not implemented yet, only support 4:2:0  */
	    h = mzte_codec.m_iHeight/2;
	    w = mzte_codec.m_iWidth/2;
	    levels = mzte_codec.m_iWvtDecmpLev-1;
      }
      
      /* initialize data */
      SPlayer[col] = Init_PEZWdata (col,levels,w,h);
      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;

      /* quantization */
      Quant[col] = mzte_codec.m_Qinfo[col]->Quant[0];
      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;
                temp = abs(wvt_coeffs[i][j])/Quant[col];
                wvt_coeffs[i][j] = (wvt_coeffs[i][j]>0)?temp:-temp;
              }
      
      /* encode this color componenet */

      /* initialize the PEZW codec */
      PEZW_encode_init (levels, w, h);
      setbuffer_PEZW_encode ();

      /* encode the AC bands */
      PEZW_encode_block (wvt_coeffs,w,h);

      /* done coding */ 
      PEZW_encode_done ();

      /* copy bitstream to data structure */
      for (splev=0;splev<levels;splev++)   /* from coarse scale to fine scale */
          {
          SPlayer[col][splev].SNR_scalability_levels = Max_Bitplane;
          for(snrlev=SPlayer[col][splev].SNR_scalability_levels-1;snrlev>=0;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;

                SPlayer[col][splev].SNRlayer[bplane].Quant = Quant[col];
                SPlayer[col][splev].SNRlayer[bplane].snr_bitstream.data = PEZW_bitstream[splev][snrlev];
                SPlayer[col][splev].SNRlayer[bplane].snr_bitstream.length = Init_Bufsize[splev][snrlev];
                SPlayer[col][splev].SNRlayer[bplane].bits_to_go = bits_to_go_inBuffer[splev][snrlev];
              }
          }

      /* free memory */
      free (wvt_coeffs);      
      /* free memory */
      free (wvt_coeffs);      
      for (i=0;i<levels;i++)
          free(Init_Bufsize[i]);
      free(Init_Bufsize);
      for (i=0;i<levels;i++)
          free(PEZW_bitstream[i]);
      free(PEZW_bitstream);
      for (i=0;i<levels;i++)
          free(bits_to_go_inBuffer[i]);
      free(bits_to_go_inBuffer);
    }        
  
  /* package the bitstream and write to bitfile */
  PEZW_bitpack (SPlayer);
  flush_bits();
  flush_bytes();
  fclose(bitfile);

  /* free memory */
  PEZW_freeEnc (SPlayer);  
}


void CVTCDecoder::textureLayerBQ_Dec(FILE *bitfile)
{
   PEZW_SPATIAL_LAYER **SPlayer;
   int col,snrlev,splev;
   static short **wvt_coeffs;
   int levels = 0,h,w;
   int i,j,bplane;
   int Quant[3];
   int dc_w, dc_h, temp;
   int all_zero[3]={0,0,0};
   int all_non_zero[3]={1,1,1};
   int LH_zero[3]={0,0,0}, HL_zero[3]={0,0,0}, HH_zero[3]={0,0,0};
   int splev_start;
   unsigned char **splev0_bitstream = NULL;
   int *splev0_bitstream_len = NULL;
   long total_decoded_bytes=0, bytes_decoded=0;

   SPlayer = (PEZW_SPATIAL_LAYER **)calloc(mzte_codec.m_iColors, sizeof(void *))
;
   mzte_codec.m_iScanOrder = mzte_codec.m_iScanDirection;
   
   /* bytes already decoded for DC and header */
   bytes_decoded = decoded_bytes_from_bitstream ();

   /* parse the bitstreams into spatial and snr layers */
   PEZW_bit_unpack (SPlayer);

   /* rate control according to target_bit_rate */
   PEZW_decode_ratecontrol (SPlayer, bytes_decoded);

   /* decode each color component */
   for (col=0; col<mzte_codec.m_iColors; col++)
    { 
      printf("Bilevel-Quant Mode - Color %d\n",col);
      
      if (col ==0)  /* Lum */
	    {
	        h = mzte_codec.m_iHeight;
	        w = mzte_codec.m_iWidth;
	        levels = mzte_codec.m_iWvtDecmpLev;
	    }
      else { /* should depend on mzte_codec.color_format;
		not implemented yet, only support 4:2:0  */
	    h = mzte_codec.m_iHeight/2;
	    w = mzte_codec.m_iWidth/2;
	    levels = mzte_codec.m_iWvtDecmpLev-1;
      }
      
      /* decode the bitstream */
      /* initialize the PEZW codec */
      Max_Bitplane = SPlayer[col][0].SNR_scalability_levels;
      PEZW_decode_init (levels, w, h);

      if(col==0)    /* the bitplane level of Y is assumed to be larger than U,V */
          {
            PEZW_bitstream = (unsigned char ***) calloc(levels,sizeof(int **));
            for(i=0;i<levels;i++)
                PEZW_bitstream[i]= (unsigned char **)calloc(Max_Bitplane,sizeof(int *));

            splev0_bitstream = (unsigned char **)calloc(Max_Bitplane,sizeof(char *));
            splev0_bitstream_len = (int *)calloc(Max_Bitplane,sizeof(int));

            Init_Bufsize = (int **) calloc(levels,sizeof(int *));
            for(i=0;i<levels;i++)
                Init_Bufsize[i]= (int *)calloc(Max_Bitplane,sizeof(int));

            /* decoded bytes */
            decoded_bytes = (int **)calloc(tree_depth,sizeof(int *));
            for (i=0;i<tree_depth;i++)
 		        decoded_bytes[i]=(int *)calloc(Max_Bitplane,sizeof(int));

            /* bits_to_go structure */
            bits_to_go_inBuffer = (unsigned char **)calloc(tree_depth,sizeof(char *));
            for (i=0;i<tree_depth;i++)
 		        bits_to_go_inBuffer[i]=(unsigned char *)calloc(Max_Bitplane,sizeof(char));