decode.cpp

AVS是中国自己推出的视频图像音频编解码标准。包中是AVS 源代码

/*************************************************************************
 AVS1-P2视频解码器源码
 版权所有：联合信源数字音视频技术（北京）有限公司, (c) 2005-2006 

 AVS1-P2 Video Decoder Source Code
 (c) Copyright, NSCC All Rights Reserved, 2005-2006
 *************************************************************************
 Distributed under the terms of the GNU General Public License as
 published by the Free Software Foundation; either version 2 of the
 License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*************************************************************************/
/*************************************************************************
  本代码为AVS1-P2标准视频解码器的源代码，实现了AVS1-P2标准文本中所规定的
  绝大部分功能，但不包括：
  1) 多Slice结构
  2) 加权预测
  3) 去伪起始码
 *************************************************************************/
/*************************************************************************
  Revision History
  data          Modification                                    Author
  2005-2-8      Created                                          jthou
 *************************************************************************/

/*************************************************************************
  文件名称:	decode.cpp
  描    述: 包含main函数，
*************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include "define.h"
#include "global.h"
#include "decode.h"
#include "stream.h"
#include "memory.h"
#include "malloc.h"
#include "vlc.h"
#include "block.h"
#include "macroblock.h"
#include "loopfilter.h"
#include "image.h"
#include <time.h>
#include <sys/timeb.h>

/************************************************************************/
/* main函数                                                                     */
/*		argv[1] 被解码压缩流路径                                        */
/*		argv[2] 解后YUV数据存放路径                                     */
/*		argv[3] 要解码的帧数                                            */
/*		argv[4] WriteFlag,是否将解码结果写入文件                        */
/************************************************************************/


AVS_HRESULT DecodeOneFrame(AVS_BYTE* pbData,
                     AVS_DWORD dwFrameLen,
                     STREAMINFO* StrmInfo, 
                     VIDEODATA** ppRefFrame,
                     VIDEODATA** pCurrFrame, 
                     MBINFO* pMbInfo,
                     BWREFINFO* pBwRefInfo)
{
  AVS_BYTE* pbCurrent = pbData; 
  AVS_DWORD dwCode = *(AVS_DWORD*)pbCurrent;
  AVS_DWORD dwBitOffset = 0;

  if(DWORD_SWAP(dwCode)!=I_FRAME_START_CODE && DWORD_SWAP(dwCode)!=PB_FRAME_START_CODE)
    return AVS_NOT_VALID_PIC_DATA;

  GetImgHeaderInfo(pbCurrent, dwFrameLen, &dwBitOffset, StrmInfo);

  AVS_DWORD imgWid = StrmInfo->SeqInfo.dwWidth;
  AVS_DWORD imgHei = StrmInfo->SeqInfo.dwHeight;

  StrmInfo->ImgInfo.dwImageType1 = StrmInfo->ImgInfo.dwImageType;

  if(StrmInfo->ImgInfo.bPictureStructure)
  {
    // frame type decoding...
    (*pCurrFrame)->dwDistanceIndex = StrmInfo->ImgInfo.dwPictureDistance * 2;
    PictureData(pbCurrent, 
      dwFrameLen,
      &dwBitOffset,
      StrmInfo, 
      ppRefFrame,
      *pCurrFrame, 
      pMbInfo, 
      pBwRefInfo);
  }
  else
  {
    return THIS_VERSION_NOT_SUPPORT;
  }
  
  if(StrmInfo->ImgInfo.dwImageType != B_IMG)
  {
    UpdateRefBuffer(&ppRefFrame, &pCurrFrame, 2);
  }

  return AVS_NOERROR;   
}

/************************************************************************/
/* 函数功能：初始化解码器                                               */
/*         - 初始化VLC表                                                */
/*         - 初始化Clip表                                               */
/*         - 初始化TabBuf(替代解码过程中的取绝对值)                     */ 
/*         - 分析序列头                                                 */
/************************************************************************/
AVS_HRESULT InitDecode(const AVS_BYTE* pbData, AVS_DWORD dwDataLen, STREAMINFO* strmInfo)
{
  const AVS_BYTE* pbCurrent = pbData;
  AVS_DWORD dwLeft = dwDataLen;

  MakeVlcTable();
  MakeClipTable();
  MakeTabNoBuf();

  while(dwLeft > 18)
  {
    AVS_DWORD dwCode = *(AVS_DWORD*)pbCurrent;
    if((dwCode & 0x00FFFFFF) == 0x00010000)
    {
      dwCode = DWORD_SWAP(dwCode);  
      if(dwCode == SEQENCE_START_CODE)
      {
        AVS_DWORD dwHeadLen = SeqenceHeader(pbCurrent, dwLeft, &(strmInfo->SeqInfo));
        pbCurrent += dwHeadLen;
        dwLeft -= dwHeadLen;
        break;
      }
    }
    pbCurrent++;
    dwLeft--;
  }
  return dwLeft;
}

AVS_DWORD PictureData(AVS_BYTE*   pbData,
                  AVS_DWORD         dwFrameLen,
                  AVS_DWORD*        pdwBitOffset,
                  STREAMINFO*   StrmInfo,
                  VIDEODATA**   ppRefFrame, 
                  VIDEODATA*    pCurrFrame, 
                  MBINFO*       pMbInfo,
                  BWREFINFO*    pBwRefInfo)
{
  AVS_BYTE* pbCurrent = pbData;
  AVS_DWORD dwLeft = dwFrameLen;
  AVS_DWORD MbIndex = 0;
  AVS_DWORD MbWidth = StrmInfo->SeqInfo.dwMbWidth;
  AVS_DWORD MbHeight = StrmInfo->SeqInfo.dwMbHeight;
  AVS_DWORD MbNum = MbHeight * MbWidth;
  AVS_INT   cod_counter = -1;

  AVS_DWORD dwImgWidth = StrmInfo->SeqInfo.dwWidth;
  AVS_SHORT LumaCoef[256];
  AVS_SHORT ChromaCoef[256];

  AVS_DWORD dwCurrDistanceIndex = pCurrFrame->dwDistanceIndex;

  for(MbIndex=0; MbIndex<MbNum; MbIndex++)
  { 
    memset(&pMbInfo[MbIndex], 0, sizeof(MBINFO));
    memset(LumaCoef, 0, sizeof(AVS_SHORT)*256);
    memset(ChromaCoef, 0, sizeof(AVS_SHORT)*256);
 
    if(MbIndex%MbWidth == 0)
    {
      int offset = (((*pdwBitOffset+7)>>3)<<3);
      while(!IsSliceHeader(pbCurrent, offset))
      {
        offset += 8;
        if(offset > 20*8)
          break;
      }
      if(IsSliceHeader(pbCurrent, offset))
      { 
        *pdwBitOffset = offset;                          
        *pdwBitOffset += 32;
        SliceHeader(pbCurrent, dwLeft, MbIndex, pdwBitOffset, StrmInfo);
      }
    }

    ParseOneMacroBlock(
      &pbCurrent, 
      dwLeft, 
      pdwBitOffset,
      StrmInfo, 
      pMbInfo, 
      MbIndex,
      &cod_counter,
      LumaCoef,
      ChromaCoef);  


    McIdctRecOneMarcroBlock(
      pMbInfo, 
      MbIndex, 
      StrmInfo, 
      (const VIDEODATA**)ppRefFrame, 
      pCurrFrame, 
      2,
      MbWidth,
      MbHeight,
      dwCurrDistanceIndex,
      pBwRefInfo,
      LumaCoef,
      ChromaCoef);  
  }
  for(MbIndex=0; MbIndex<MbNum; MbIndex++)
    {
      DeblockOneMacroBlock(pMbInfo, 
        MbIndex,
        dwImgWidth>>4,
        StrmInfo,
        pCurrFrame
        );
    }   
    
  return AVS_NOERROR;
}