dvbpsi.cpp

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

{
  m_hDvbPsi = dvbpsi_AttachPAT((dvbpsi_pat_callback)Callback, this);

  if(!m_hDvbPsi)
    throw E_Exception(GEN_ERR,
                      "libdvbpsi was unable to create the PAT decoder");
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPatDecoder::Detach()
{
  if(m_hDvbPsi)
  {
    dvbpsi_DetachPAT(m_hDvbPsi);
    m_hDvbPsi = NULL;
  }
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPatDecoder::Callback(C_DvbPsiPatDecoder *pThis,
                                  dvbpsi_pat_t* p_new_pat)
{
  ASSERT(pThis);

  C_DvbPsiPat *pPat = new C_DvbPsiPat(p_new_pat);
  ASSERT(pPat);
  dvbpsi_DeletePAT(p_new_pat);

  pThis->m_pHandler->HandlePat(pPat);
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPatDecoder::HandlePacket(C_TsPacket* pPacket)
{
  dvbpsi_PushPacket(m_hDvbPsi, (byte*)pPacket);

  m_pTsProvider->ReleasePacket(pPacket);
}


//******************************************************************************
// C_DvbPsiPmt class
//******************************************************************************
//
//******************************************************************************

//------------------------------------------------------------------------------
// Base constructor
//------------------------------------------------------------------------------
C_DvbPsiPmt::C_DvbPsiPmt(u16 iProgramNumber, u8 iVersion,
                         bool bCurrentNext, u16 iPcrPid, u16 iPid/* = 0*/)
{
  ASSERT(!(iPid & 0xe000))
  m_iPid = iPid;
  dvbpsi_InitPMT(&m_sPmt, iProgramNumber, iVersion, bCurrentNext, iPcrPid);
}


//------------------------------------------------------------------------------
// Low level constructor
//------------------------------------------------------------------------------
C_DvbPsiPmt::C_DvbPsiPmt(dvbpsi_pmt_t* pPmt)
{
  ASSERT(pPmt);
  m_sPmt = *pPmt;

  pPmt->p_first_descriptor = NULL;
  pPmt->p_first_es = NULL;

  m_iPid = 0;
}


//------------------------------------------------------------------------------
// Copy constructor
//------------------------------------------------------------------------------
C_DvbPsiPmt::C_DvbPsiPmt(const C_DvbPsiPmt& cPmt)
{
  m_iPid = cPmt.m_iPid;

  dvbpsi_InitPMT(&m_sPmt,
                 cPmt.m_sPmt.i_program_number,
                 cPmt.m_sPmt.i_version,
                 cPmt.m_sPmt.b_current_next,
                 cPmt.m_sPmt.i_pcr_pid);

  dvbpsi_descriptor_t *pDescriptor = cPmt.m_sPmt.p_first_descriptor;
  while(pDescriptor)
  {
    dvbpsi_PMTAddDescriptor(&m_sPmt, pDescriptor->i_tag,
                            pDescriptor->i_length, pDescriptor->p_data);
    pDescriptor = pDescriptor->p_next;
  }

  dvbpsi_pmt_es_t *pEs = cPmt.m_sPmt.p_first_es;
  while(pEs)
  {
    dvbpsi_pmt_es_t *pEs2 = dvbpsi_PMTAddES(&m_sPmt, pEs->i_type, pEs->i_pid);

    pDescriptor = pEs->p_first_descriptor;
    while(pDescriptor)
    {
      dvbpsi_PMTESAddDescriptor(pEs2, pDescriptor->i_tag,
                                pDescriptor->i_length, pDescriptor->p_data);
      pDescriptor = pDescriptor->p_next;
    }

    pEs = pEs->p_next;
  }
}


//------------------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------------------
C_DvbPsiPmt::~C_DvbPsiPmt()
{
  dvbpsi_EmptyPMT(&m_sPmt);
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPmt::BuildFromNext(C_DvbPsiPmt *pNextPmt)
{
  ASSERT(pNextPmt);

  if(    (m_sPmt.i_program_number == pNextPmt->m_sPmt.i_program_number)
      && (m_sPmt.i_version == pNextPmt->m_sPmt.i_version)
      && (m_sPmt.i_pcr_pid == pNextPmt->m_sPmt.i_pcr_pid)
      && (!pNextPmt->m_sPmt.b_current_next)
      && (m_sPmt.b_current_next)
      && (m_sPmt.p_first_descriptor == NULL)
      && (m_sPmt.p_first_es == NULL))
  {
    m_sPmt.p_first_descriptor = pNextPmt->m_sPmt.p_first_descriptor;
    pNextPmt->m_sPmt.p_first_descriptor = NULL;
    m_sPmt.p_first_es = pNextPmt->m_sPmt.p_first_es;
    pNextPmt->m_sPmt.p_first_es = NULL;
  }
  else
  {
    ASSERT(false);
  }
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
dvbpsi_pmt_es_t* C_DvbPsiPmt::GetEs(u16 iPid) const
{
  dvbpsi_pmt_es_t *pEs = m_sPmt.p_first_es;
  while((pEs != NULL) && (pEs->i_pid != iPid))
    pEs = pEs->p_next;

  return pEs;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_DvbPsiPmt& C_DvbPsiPmt::operator = (const C_DvbPsiPmt& cPmt)
{
  dvbpsi_InitPMT(&m_sPmt,
                 cPmt.m_sPmt.i_program_number,
                 cPmt.m_sPmt.i_version,
                 cPmt.m_sPmt.b_current_next,
                 cPmt.m_sPmt.i_pcr_pid);

  dvbpsi_descriptor_t *pDescriptor = cPmt.m_sPmt.p_first_descriptor;
  while(pDescriptor)
  {
    dvbpsi_PMTAddDescriptor(&m_sPmt, pDescriptor->i_tag,
                            pDescriptor->i_length, pDescriptor->p_data);
    pDescriptor = pDescriptor->p_next;
  }

  dvbpsi_pmt_es_t *pEs = cPmt.m_sPmt.p_first_es;
  while(pEs)
  {
    dvbpsi_pmt_es_t *pEs2 = dvbpsi_PMTAddES(&m_sPmt, pEs->i_type, pEs->i_pid);

    pDescriptor = pEs->p_first_descriptor;
    while(pDescriptor)
    {
      dvbpsi_PMTESAddDescriptor(pEs2, pDescriptor->i_tag,
                                pDescriptor->i_length, pDescriptor->p_data);
      pDescriptor = pDescriptor->p_next;
    }

    pEs = pEs->p_next;
  }

  return *this;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_DvbPsiPmt C_DvbPsiPmt::operator - (const C_DvbPsiPmt& cPmt) const
{
  C_DvbPsiPmt cResult(0, 0, false, 0);

  dvbpsi_pmt_es_t *pEs = m_sPmt.p_first_es;
  while(pEs != NULL)
  {
    dvbpsi_pmt_es_t *pEs2 = cPmt.GetEs(pEs->i_pid);
    if((!pEs2) || (pEs->i_type != pEs2->i_type))
      dvbpsi_PMTAddES(&cResult.m_sPmt, pEs->i_type, pEs->i_pid);
    pEs = pEs->p_next;
  }

  return cResult;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPmt::Generate()
{
  if(m_pSections)
    dvbpsi_DeletePSISections(m_pSections);

  m_pSections = dvbpsi_GenPMTSections(&m_sPmt);
}


//******************************************************************************
// I_DvbPsiPmtHandler class
//******************************************************************************
//
//******************************************************************************

//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
I_DvbPsiPmtHandler::I_DvbPsiPmtHandler()
{
  m_pPreviousPmt = m_pCurrentPmt = m_pNextPmt = NULL;
}


//------------------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------------------
I_DvbPsiPmtHandler::~I_DvbPsiPmtHandler()
{
  if(m_pPreviousPmt)
    delete m_pPreviousPmt;

  if(m_pCurrentPmt)
    delete m_pCurrentPmt;

  if(m_pNextPmt)
    delete m_pNextPmt;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void I_DvbPsiPmtHandler::HandlePmt(C_DvbPsiPmt* pPmt)
{
  ASSERT(pPmt);

  if(!pPmt->CurrentNext())
  {
    if(m_pNextPmt)
      delete m_pNextPmt;
    m_pNextPmt = pPmt;

    OnDvbPsiPmtEvent(DVBPSI_EVENT_NEXT);
  }
  else
  {
    if(m_pPreviousPmt)
      delete m_pPreviousPmt;
    m_pPreviousPmt = m_pCurrentPmt;
    if(m_pNextPmt)
    {
      pPmt->BuildFromNext(m_pNextPmt);
      m_pCurrentPmt = pPmt;
      delete m_pNextPmt;
      m_pNextPmt = NULL;
    }
    else
    {
      m_pCurrentPmt = pPmt;
    }

    OnDvbPsiPmtEvent(DVBPSI_EVENT_CURRENT);
  }
}


//******************************************************************************
// C_DvbPsiPmtDecoder class
//******************************************************************************
//
//******************************************************************************

//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
C_DvbPsiPmtDecoder::C_DvbPsiPmtDecoder(u16 iProgramNumber,
                                       C_NetList *pTsProvider,
                                       I_DvbPsiPmtHandler *pHandler)
{
  ASSERT(pTsProvider);

  m_hDvbPsi = NULL;
  m_iProgramNumber = iProgramNumber;
  m_pTsProvider = pTsProvider;
  m_pHandler = pHandler;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPmtDecoder::Attach()
{
  m_hDvbPsi = dvbpsi_AttachPMT(m_iProgramNumber,
                               (dvbpsi_pmt_callback)Callback, this);

  if(!m_hDvbPsi)
    throw E_Exception(GEN_ERR,
                      "libdvbpsi was unable to create the PMT decoder");
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPmtDecoder::Detach()
{
  if(m_hDvbPsi)
  {
    dvbpsi_DetachPMT(m_hDvbPsi);
    m_hDvbPsi = NULL;
  }
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPmtDecoder::Callback(C_DvbPsiPmtDecoder *pThis,
                                  dvbpsi_pmt_t* p_new_pmt)
{
  ASSERT(pThis);

  C_DvbPsiPmt *pPmt = new C_DvbPsiPmt(p_new_pmt);
  ASSERT(pPmt);
  dvbpsi_DeletePMT(p_new_pmt);

  pThis->m_pHandler->HandlePmt(pPmt);
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_DvbPsiPmtDecoder::HandlePacket(C_TsPacket* pPacket)
{
  dvbpsi_PushPacket(m_hDvbPsi, (byte*)pPacket);

  m_pTsProvider->ReleasePacket(pPacket);
}