/*
********************************************************************************
********************************************************************************

This software module was originally developed by

CHEN Ying (ying.chen@tut.fi, Nokia & Tempere University of Technology )

********************************************************************************
********************************************************************************
*/



#include "AssemblerParameter.h"
#include "Assembler.h"
#include "ReadBitstreamFile.h"
#include "MVCScalableModifyCode.h"
#include "MVCScalableTestCode.h"
#include <math.h>



Assembler::Assembler()
: m_ppcReadBitstream      (  0   )
, pcTmpViewScalInfoSei	  (  0   ) //SEI LSJ
, m_pcWriteBitstream      (  0   )
, m_pcAssemblerParameter  (  0   )
, m_pcTraceFile           (  0   )
, m_pcAssemblerTraceFile  (  0   )
, m_uiNumViews            (  0   )
, m_uiTempViewDecOrder    (  0   )
, m_bSuffix               ( true )
{
}



Assembler::~Assembler()
{
}



ErrVal
Assembler::create( Assembler*& rpcAssembler )
{
  rpcAssembler = new Assembler;
  ROT( NULL == rpcAssembler );
  return Err::m_nOK;
}

ErrVal
Assembler::init( AssemblerParameter *pcAssemblerParameter )
{
  
  ROT( NULL == pcAssemblerParameter );

  m_pcAssemblerParameter  = pcAssemblerParameter;
  m_pcAssemblerParameter->setResult( -1 );

  m_uiNumViews        = m_pcAssemblerParameter->getNumViews(); 
  m_ppcReadBitstream  = new ReadBitstreamIf * [m_uiNumViews]; 
  pcTmpViewScalInfoSei = new h264::SEI::ViewScalabilityInfoSei * [m_uiNumViews]; //SEI 
//  m_bSuffix           = m_pcAssemblerParameter->getSuffix() > 0; 
  m_bSuffix           = true; // it is mandatory to be true;
  for( UInt uiV=0; uiV <m_uiNumViews ; uiV++)
  {
    ReadBitstreamFile*  pcReadBitstreamFile;
    RNOKS( ReadBitstreamFile::create( pcReadBitstreamFile ) );
    RNOKS( pcReadBitstreamFile->init( m_pcAssemblerParameter->getInFile(uiV) ) );
    m_ppcReadBitstream [uiV] = (ReadBitstreamIf*)pcReadBitstreamFile;
  }

  WriteBitstreamToFile*  pcWriteBitstreamFile;
  RNOKS( WriteBitstreamToFile::create( pcWriteBitstreamFile ) );
  RNOKS( pcWriteBitstreamFile->init( m_pcAssemblerParameter->getOutFile() ) );
  m_pcWriteBitstream = (WriteBitstreamIf*)pcWriteBitstreamFile;
  RNOK( h264::H264AVCPacketAnalyzer::create( m_pcH264AVCPacketAnalyzer ) );      //SEI 
  m_aucStartCodeBuffer[0] = 0;
  m_aucStartCodeBuffer[1] = 0;
  m_aucStartCodeBuffer[2] = 0;
  m_aucStartCodeBuffer[3] = 1;
  m_cBinDataStartCode.reset();
  m_cBinDataStartCode.set( m_aucStartCodeBuffer, 4 );

  return Err::m_nOK;
}

ErrVal
Assembler::destroy()
{
  m_cBinDataStartCode.reset();


  if( NULL != m_ppcReadBitstream )
  {
    for( UInt uiV=0; uiV <m_uiNumViews ; uiV++)
    {
      RNOK( m_ppcReadBitstream[uiV]->uninit() );
      RNOK( m_ppcReadBitstream[uiV]->destroy() );
    }
    m_ppcReadBitstream = NULL;
  }

  if( NULL != m_pcH264AVCPacketAnalyzer )
  {
    RNOK( m_pcH264AVCPacketAnalyzer->destroy() );
  } //SEI 


  delete this;

  return Err::m_nOK;
}

ErrVal
Assembler::xPreAnalyse ()
{
  UInt uiNumVCLUnits=0;
  BinData*                pcBinData     = 0;
  for (UInt i=0; i< m_uiNumViews; i++)
  {
    Bool bEOS = false;
    printf("view %d\n",i);
    while( ! bEOS )
    {
    
    //===== get packet =====
    RNOK( m_ppcReadBitstream[i]->extractPacket( pcBinData, bEOS ) );
    if( bEOS )
    {
      RNOK( m_ppcReadBitstream[i]->releasePacket( pcBinData ) );
      pcBinData = NULL;
      continue;
    }

    //===== get NAL Unit type only =====
    //----------------------------assembling ----------------------------------------------
    UChar       ucByte        = (pcBinData->data())[0];
    NalUnitType eNalUnitType  = NalUnitType ( ucByte  & 0x1F );
    
    if ( NAL_UNIT_CODED_SLICE == eNalUnitType          || NAL_UNIT_CODED_SLICE_IDR == eNalUnitType 
       ||NAL_UNIT_CODED_SLICE_SCALABLE == eNalUnitType || NAL_UNIT_CODED_SLICE_IDR_SCALABLE  == eNalUnitType )
    {
      uiNumVCLUnits++;
      printf("%d\n", eNalUnitType);
    }
    if(pcBinData)
    {
      RNOK( m_ppcReadBitstream[i]->releasePacket( pcBinData ) );
      pcBinData = NULL;
    }
   }
  }
  printf("Number of total VCL NAL Units: %d\n", uiNumVCLUnits);
  
  return Err::m_nOK;
}

//SEI {
ErrVal 
Assembler::xWriteViewScalSEIToBuffer(h264::SEI::ViewScalabilityInfoSei *pcViewScalSei, BinData *pcBinData)
{
	const UInt uiSEILength = 1000;
	UChar		pulStreamPacket[uiSEILength];
	pcBinData->reset();
	pcBinData->set( new UChar[uiSEILength], uiSEILength );

	UChar *m_pucBuffer = pcBinData->data();

	MVCScalableModifyCode cMVCScalableModifyCode;
	MVCScalableTestCode cMVCScalableTestCode;
	RNOK( cMVCScalableTestCode.init() );
	RNOK( cMVCScalableModifyCode.init( (ULong*) pulStreamPacket ) );
	RNOK( cMVCScalableTestCode.SEICode( pcViewScalSei, &cMVCScalableTestCode ) );
	UInt uiBits = cMVCScalableTestCode.getNumberOfWrittenBits();
	UInt uiSize = (uiBits+7)/8;
	RNOK( cMVCScalableModifyCode.WriteFlag( 0 ) );
	RNOK( cMVCScalableModifyCode.WriteCode( 0 ,2 ) );
	RNOK( cMVCScalableModifyCode.WriteCode( NAL_UNIT_SEI, 5 ) );
	RNOK( cMVCScalableModifyCode.WritePayloadHeader( pcViewScalSei->getMessageType(), uiSize ) );
	RNOK( cMVCScalableModifyCode.SEICode( pcViewScalSei, &cMVCScalableModifyCode ) );
	uiBits = cMVCScalableModifyCode.getNumberOfWrittenBits();
	uiSize = (uiBits+7)/8;
	UInt uiAlignedBits = 8 - (uiBits&7);
	if( uiAlignedBits != 0 && uiAlignedBits != 8 )
	{
		RNOK( cMVCScalableModifyCode.WriteCode( 1 << (uiAlignedBits-1), uiAlignedBits ) );
	}
	RNOK ( cMVCScalableModifyCode.WriteTrailingBits() );
	RNOK ( cMVCScalableModifyCode.flushBuffer() );
	uiBits = cMVCScalableModifyCode.getNumberOfWrittenBits();
	uiBits              = ( uiBits >> 3 ) + ( 0 != ( uiBits & 0x07 ) );
	uiSize = uiBits;
	RNOK( cMVCScalableModifyCode.ConvertRBSPToPayload( m_pucBuffer, pulStreamPacket, uiSize, 2 ) );
	pcBinData->decreaseEndPos( uiSEILength - uiSize );
	return Err::m_nOK;
}
//SEI }

ErrVal
Assembler::xAnalyse()
{
//  Bool                    bNewPicture   = false;
//Bool                    bApplyToNext  = false;
  Bool                    bEOS          = false;
  Bool                    bNewAUStart   = true;
  BinData*                pcBinData     = 0;

  m_uiTempViewDecOrder                  = 0; 
  UInt                    uiFrames      = 0; 
  UInt                    uiNumVCLUnits = 0;
  UInt                    uiNumOtherNalU= 0;

//SEI { 
  h264::SEI::ViewScalabilityInfoSei*  pcViewScalInfoSei = 0;
  Bool					  bViewScalSei = false;
  Bool					  bFinalViewScalSei = false;
  Bool					  bScanViewScalSei = false;
  h264::SEI::ViewScalabilityInfoSei*  pcFinalViewScalSei;
  RNOK( h264::SEI::ViewScalabilityInfoSei::create(pcFinalViewScalSei) );
//SEI }
  UInt                    uiPosSPS = 0; 
  Int64                   i64Start;
//  UInt                    uiEnd;
// Dec. 1
  while( ! bEOS )
  {
    Bool bKeep       = false;

    UInt uiProcessingView = m_uiTempViewDecOrder;
//SEI { 
   uiProcessingView = 0;
   while(uiProcessingView < m_uiNumViews && !bScanViewScalSei)
   {
     RNOK( m_pcH264AVCPacketAnalyzer->init() );
     //--- get first packet ---
	 Int iPos;
	 m_ppcReadBitstream[uiProcessingView]->getPosition( iPos );
     RNOK( m_ppcReadBitstream[uiProcessingView]->extractPacket( pcBinData, bEOS ) );
   
     //--- analyse packet ---
     RNOK( m_pcH264AVCPacketAnalyzer ->processSEIAndMVC( pcBinData, pcViewScalInfoSei) );
	 
	 if( uiProcessingView == m_uiNumViews-1)
		bScanViewScalSei = true;