ps2ts.cpp

可用该程序将avi的电影文件转化为TS流

/*******************************************************************************
* ps2ts.cpp: MPEG1 and MPEG2 PS to MPEG2 TS converter
*-------------------------------------------------------------------------------
* (c)1999-2001 VideoLAN
* $Id: ps2ts.cpp,v 1.4 2002/05/14 22:10:08 bozo Exp $
*
* Authors: Benoit Steiner <[e-mail]>
*          Arnaud de Bossoreille de Ribou <[e-mail]>
*
* This program is free software; you can redistribute it and/or
* modify it 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.
*
*-------------------------------------------------------------------------------
* TO DO: Fonction de lecture d'un TS -> Si erreur, alors le flag bEror est mis
*
*******************************************************************************/

//------------------------------------------------------------------------------
// Preamble
//------------------------------------------------------------------------------
// There is no preamble since this file is to be included in the files which
// use the template: look at vector.h for further explanation



//------------------------------------------------------------------------------
// Local definitions
//------------------------------------------------------------------------------

// Status
#define SKIPPED_DATA            -97
#define UNKNOWN_DATA            -98
#define END_OF_STREAM           -99


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
template <class Reader, class TsProvider>
 C_Ps2Ts<Reader, TsProvider>::C_Ps2Ts(Reader* pReader, TsProvider* pTsProvider,
                                      unsigned int iMaxBufferedTs,
                                      unsigned int iMpegVersion) :
                             m_cPgrmDescriptor(iMpegVersion),
                             m_cPat(0, 0, 0), m_cPmt(0, 0, 0, 0, 0x50),
                             m_cPendingTS(NO)
{
  ASSERT(pReader);
  ASSERT(pTsProvider);
  ASSERT(iMaxBufferedTs > 1);
  ASSERT(iMpegVersion == 1 || iMpegVersion == 2);

  m_pReader = pReader;
  m_pTsProvider = pTsProvider;
  m_iMaxBufferedTs = iMaxBufferedTs;

  m_iDataType = UNKNOWN_DATA;
  m_iStatus = NO_ERR;
  m_pDelayedPacket = NULL;
  m_bDiscontinuity = false;

  ZERO(m_pCurrentData);

  m_bSendPSI = m_bGenPat = m_bGenPmt = m_bResetPSI = true;
  m_iTSCounter = 0;

  if(iMpegVersion == 1)
    m_iPackHeaderLen = MPEG1_PACK_HEADER_LEN;
  else
    m_iPackHeaderLen = MPEG2_PACK_HEADER_LEN;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
template <class Reader, class TsProvider>
 C_Ps2Ts<Reader, TsProvider>::~C_Ps2Ts()
{
  // The packets belong to the netlist, so don't delete them twice
  for(unsigned int i = 0; i < m_cPendingTS.Size(); i++)
  {
    C_TsPacket* pPacket = m_cPendingTS.Remove(0);
    ASSERT(pPacket);
    m_pTsProvider->ReleasePacket(pPacket);
  }
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
// The data in the buffer can be anything: only rely on DataType and DataLen
//------------------------------------------------------------------------------
template <class Reader, class TsProvider>
   int C_Ps2Ts<Reader, TsProvider>::Synch()
{
  int iRc = m_pReader->Read(m_bBuff, START_CODE_LEN);
  ASSERT(iRc >= 0);
  m_iStatus = (iRc != START_CODE_LEN);

  unsigned int iPos = START_CODE_LEN;

  // Check the last bytes read to look for a start code
  while((U32_AT(m_bBuff[iPos-START_CODE_LEN]) != PES_H_PACK_HEADER) &&
        !m_iStatus)
  {
    iRc = m_pReader->Read(m_bBuff+iPos, 1);
    ASSERT(iRc >= 0);
    m_iStatus = (iRc != 1);

    iPos++;
    if(iPos >= sizeof(m_bBuff))
    {
      printf("Looping in Synch !!!!!!!!! (buffer size=%d)\n", sizeof(m_bBuff));
      memcpy(m_bBuff, &m_bBuff[sizeof(m_bBuff)-(START_CODE_LEN-1)],
             (START_CODE_LEN-1));
      iPos = START_CODE_LEN-1;
    }
  }

  // Check the last bytes read to detect why we left the loop
  if(U32_AT(m_bBuff[iPos-START_CODE_LEN]) != PES_H_PACK_HEADER)
  {
    // We left the while loop because of a read error
    m_iStatus = GEN_ERR;
  }
  else
  {
    printf("Synchronised with PS stream\n");
    m_iDataType = PES_H_PACK_HEADER;
    iRc =  m_pReader->Read(m_bBuff+iPos, PES_SIZE_LEN);
    ASSERT(iRc >= 0);
    m_iStatus = (iRc != PES_SIZE_LEN);
    m_pCurrentData = m_cPgrmDescriptor.GetDescriptor(m_iDataType & 0xFF);
    m_iDataLen = U16_AT(m_bBuff[iPos]);
  }

  return m_iStatus;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
template <class Reader, class TsProvider>
   C_TsPacket* C_Ps2Ts<Reader, TsProvider>::GetPacket()
{
  if(m_cPendingTS.Size() == 0)
  {
    if(!m_bSendPSI)
    {
      if(m_pDelayedPacket)
      {
        m_cPendingTS.PushEnd(m_pDelayedPacket);
        m_pDelayedPacket = NULL;
      }
      else
      {
        int iRc = FetchPackets();
        if(iRc && !m_bSendPSI)
        {
          do
          {
            if(iRc == UNKNOWN_DATA)
            {
              iRc = Synch();
              if(!iRc)
                iRc = FetchPackets();
            }
            else if(iRc == SKIPPED_DATA)
              iRc = FetchPackets();
          }
          while((iRc == SKIPPED_DATA || iRc == UNKNOWN_DATA) && !m_bSendPSI);
        }
        else if(!m_bSendPSI)
        {
          // Check if we will have to insert PSI on the next iteration: we
          // add the PSI in the stream every half second
          // (For 1.5 Mbps streams, about 1000 TS packets are sent every second)
          m_bSendPSI = m_bResetPSI = (m_iTSCounter % 500 <= m_iMaxBufferedTs);
//          printf("mitscounter: %d\n", m_iTSCounter);
        }
      }
    }

    if(m_bSendPSI)
    {
      if(m_bGenPat)
      {
        *m_cPat.GetLowLevelPat() = m_cPgrmDescriptor.m_sPat;
        m_cPat.Generate();
        m_cPat.GetLowLevelPat()->p_first_program = NULL;
        m_bGenPat = false;
      }

      if(m_bGenPmt)
      {
        m_cPgrmDescriptor.m_sPmt.i_version =
                        (m_cPgrmDescriptor.m_sPmt.i_version + 1) & 0x1f;
        *m_cPmt.GetLowLevelPmt() = m_cPgrmDescriptor.m_sPmt;
        m_cPmt.Generate();
        m_cPmt.GetLowLevelPmt()->p_first_es = NULL;
        m_cPmt.GetLowLevelPmt()->p_first_descriptor = NULL;
        m_bGenPmt = false;
      }

      if(m_bResetPSI)
      {
        m_cPat.TsReset();
        m_cPmt.TsReset();
        m_bResetPSI = false;
      }

      for(unsigned int i = m_cPendingTS.Size(); i < m_iMaxBufferedTs; i++)
      {
        C_TsPacket* pPacket = m_pTsProvider->GetPacket();
        ASSERT(pPacket);

        if(m_cPat.TsHasNext())
        {
          m_cPat.TsWrite(pPacket);
          m_cPendingTS.PushEnd(pPacket);
          m_iTSCounter++;
        }
        else if(m_cPmt.TsHasNext())
        {
          m_cPmt.TsWrite(pPacket);
          m_cPendingTS.PushEnd(pPacket);
          m_iTSCounter++;
        }
        else
        {
          m_bSendPSI = false;
          m_pTsProvider->ReleasePacket(pPacket);
          if(m_pDelayedPacket)
          {
            m_cPendingTS.PushEnd(m_pDelayedPacket);
            m_pDelayedPacket = NULL;
          }
        }
        if(!m_cPat.TsHasNext() && !m_cPmt.TsHasNext())
          m_bSendPSI = false;
      }
    }
  }

  ASSERT(m_cPendingTS.Size() > 0);
  ASSERT(m_cPendingTS.Size() <= m_iMaxBufferedTs);

  // Return the first packet
  if(m_cPendingTS.Size() > 0)
    return m_cPendingTS.Remove(0);
  else
    return NULL;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
template <class Reader, class TsProvider>
   int C_Ps2Ts<Reader, TsProvider>::FetchPackets()
{
  ASSERT(!m_iStatus || m_iStatus == SKIPPED_DATA || m_iStatus == UNKNOWN_DATA);

  u8 iPosInTs = 0;
  C_TsPacket* pPacket = m_pTsProvider->GetPacket();
  ASSERT(pPacket);

  // Handle the pack header if any at the current position in the stream
  if(m_iDataType == PES_H_PACK_HEADER)
  {
    m_iStatus = ParsePackHeader(pPacket, &iPosInTs);

    // There also can be a system header following the pack header
    if(m_iDataType == PES_H_SYSTEM_HEADER && !m_iStatus)
    {
      m_iStatus = ParseSystemHeader(pPacket, &iPosInTs);
    }

    // Leave now if something wrong occured
    if(m_iStatus != NO_ERR)
      return GEN_ERR;
  }

  // No we must have reached the beginning of a PES packet or the end of
  // the stream
  if(IsDataPesHeader(m_iDataType))
  {
    // This is a data PES
    m_iStatus = ParsePES(pPacket, &iPosInTs);
  }
  else
  {
    // This is a control PES
    switch(m_iDataType)
    {
      case PES_H_PADDING:
      {
//        printf("Padding pes encountered\n");
        //m_iStatus = ParsePadding(pPacket, &iPosInTs);
        m_iStatus = ParsePES(pPacket, &iPosInTs);
        break;
      }
      case PES_H_PGRM_MAP:
      {
//        printf("Program map pes encountered\n");
        m_iStatus = ParsePgrmMap(pPacket, &iPosInTs);
        // A foutre dans parse pgrm_map_pes quand le pes est completement fini
        m_bSendPSI = m_bResetPSI = true;
        break;
      }
      case PES_H_PRIVATE_2:
      case PES_H_PGRM_DIR:
      {
        // Not interessting -> Trash
//        printf("not interesting pes encountered -> trash \n");
        m_iStatus = SkipPES(pPacket, &iPosInTs);
        break;
      }
      case PES_H_END_OF_PS:
      {
        // Just return NULL
        printf("end of ps encountered\n");
        m_pTsProvider->ReleasePacket(pPacket);
        m_iStatus = END_OF_STREAM;
        break;
      }
      default:
      {
        printf("unknown packet (%x) encoutered\n", m_iDataType);
        m_pTsProvider->ReleasePacket(pPacket);
        m_iStatus = UNKNOWN_DATA;
      }
    }
  }
  
  return m_iStatus;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
template <class Reader, class TsProvider>
   int C_Ps2Ts<Reader, TsProvider>::ParsePackHeader(C_TsPacket* pPacket, u8* pPosInTs)
{
  ASSERT(pPacket);

//  printf("Parsing PACK_HEADER\n");

  int iRc = m_pReader->Read(m_bBuff+LOOK_AHEAD_LEN, m_iPackHeaderLen);
  ASSERT(iRc >= 0);
  iRc = (iRc != m_iPackHeaderLen);

  // No stuffing by default
  u8 iStuffLen = 0;

  if(m_iPackHeaderLen == MPEG1_PACK_HEADER_LEN)
  {
    // Parse the SCR (MPEG1 format)
    u64 iHighBits = m_bBuff[START_CODE_LEN] & 0x0E;
    u64 iMiddleBits = U16_AT(m_bBuff[START_CODE_LEN+1]) & 0xFFFE;
    u64 iLowBits = U16_AT(m_bBuff[START_CODE_LEN+3]) & 0xFFFE;
    ASSERT((m_bBuff[START_CODE_LEN] & 0x01));
    ASSERT((m_bBuff[START_CODE_LEN+2] & 0x01));
    ASSERT((m_bBuff[START_CODE_LEN+4] & 0x01));
   
    u64 iSCR = iHighBits << 29 | iMiddleBits << 14 | iLowBits >> 1;
//    printf("Date mpeg1: %Ld\n", iSCR);