bitparser.cpp

神龙卡 SDK_84xx_DShow_145_02.zip 这个是 windows 上二个是linux

/***********************************************************************/
/* bitparser.cpp : Implementation of bit parser
*  REALmagic Quasar Hardware Library
*  Created by Kevin Vo
*  Copyright 2000 Sigma Designs Inc. 
*  355 Fairview Way, Milpitas, CA 95035-3024 USA. All Rights Reserved.  
*  Sigma Designs Proprietary and Confidential
*  Created on 3/20/01
*  Description: Contains util functions to parse bit of the payload
/************************************************************************/

#include "pch.h"
#include "manager.h"
#include "splitter.h"	// for SendToHardware function
#include "bitparser.h"


// Set this to save the video/audio payloads to files.
//#define _RECORD_AUDIO_
//#define _RECORD_VIDEO_

///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////

void CMpegProperties::SetPlayAudioChannel(WORD wAudio)
{
	m_wAudioChannelPlay = wAudio;
}

///////////////////////////////////////////////////////////////////

void CMpegProperties::SetPlayVideoChannel(WORD wVideo)
{
	m_wVideoChannelPlay = wVideo;
}

///////////////////////////////////////////////////////////////////

void CMpegProperties::SetAudioType(BYTE bAudioType)
{
	m_bAudioType = bAudioType;
}

///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////

CBitParser::CBitParser(MemManager *pMemManager)
{
#ifdef _RECORD_VIDEO_
	m_pVideoFile = fopen("mmvideo.mpg", "wb");
#endif
#ifdef _RECORD_AUDIO_
	m_pAudioFile = fopen("mmaudio.mpg", "wb");
#endif

	m_pMemManager = pMemManager;
	m_bStopDemux = FALSE;
	// For transport stream
	m_bIsTransport = FALSE;
	m_bProcess = FALSE;

	// Use these parameters to process the buffer
	m_pCBuffer = NULL;
	m_pBuffer = 0;
	m_dwBufferSize = 0;
	m_dwBufferIndex = 0;

	// MediaSample parameters	
	m_bPayloadPtr = 0;
	m_dwPayloadLength = 0;
	m_llPts = m_llDts = 0;
	m_bPtsDtsFlag = 0;
	m_bStreamType = MM_AUDIO;	// Default
	m_ullScr = 0;
	m_lSampleRate = 0;

	m_pPreviousCBuffer = 0;
	m_dwPreviousPacketIndex = 0;
	m_dwRightPayloadLength = 0;
	m_bPacketBetween2Buffers = FALSE;
	m_bPayloadBetween2Buffers = FALSE;
	m_bEndOfBuffer = FALSE;

	m_bAudioType = MM_AUDIO_FORMAT_MPEG1;   // Normal audio type, no AC3/DTS
	m_bSubstreamId = 0;
	m_bNFrameHeaders = 0;
	m_iFirstAccessUnit = 0;

	m_AVId.dwAudioStreamId = 0;
	m_AVId.dwVideoStreamId = 0;
	m_dwAStreamId = 0;
	m_dwVStreamId = 0;
	m_wAudioChannelCount = 0;
	m_wVideoChannelCount = 0;
	m_wAudioChannelPlay = 1;
	m_wVideoChannelPlay = 1;
	m_dwAudioMask = 0x0000;
	m_dwVideoMask = 0x0000;

	// Transport stream
	m_llPcr = 0;
	m_bPcrFlag = FALSE;
	m_wPid = 0;
	m_bContCounter = 0;
	m_bDiscIndicator = 0;
	m_wPrivateStreamPid = 0;
	m_llVideoPts = 0;
	m_llAudioPts = 0;
	m_bVideoPtsFlag = FALSE;
	m_bAudioPtsFlag = FALSE;
	m_wProgramNumber = 1;
	m_bPesPayload = FALSE;

	// Transport stream with more than one program.
	m_wProgramPlay = 1;
	m_wProgramCounter = 0;
	m_ProgDef.iAudioElemStreamId = -1;
	m_ProgDef.iVideoElemStreamId = -1;
	m_ProgDef.iProgramNum = -1;

	// Transport stream buffers
	m_pVideoCBuffer = 0;
	m_pAudioCBuffer = 0;
	m_pVideoBuffer = 0;
	m_pAudioBuffer = 0;
	m_dwVideoBufferLen = 0;
	m_dwAudioBufferLen = 0;
	m_bVideoPesHeader = FALSE;
	m_bAudioPesHeader = FALSE;

	m_bFastForward = FALSE;
	m_pIFrame = new CIFrame();
}

/////////////////////////////////////////////////////////////////////

CBitParser::~CBitParser()
{
#ifdef _RECORD_VIDEO_
	if (m_pVideoFile != NULL)
		fclose(m_pVideoFile);
#endif
#ifdef _RECORD_AUDIO_
	if (m_pAudioFile != NULL)
		fclose(m_pAudioFile);
#endif

	delete m_pIFrame;
}

///////////////////////////////////////////////////////////////////

void CBitParser::StopDemux()
{
	if (m_bStopDemux != TRUE)
	{
		m_bStopDemux = TRUE;
		m_bFastForward = FALSE;
		m_bIsTransport = FALSE;
		m_pIFrame->StopDemux();

		if (m_pCBuffer)   m_pCBuffer->Release();
		if ((m_pPreviousCBuffer != m_pCBuffer) && (m_pPreviousCBuffer != NULL))
			m_pPreviousCBuffer->Release();
		// Transport stream buffers
		if (m_pVideoCBuffer)   m_pVideoCBuffer->Release();
		if (m_pAudioCBuffer)   m_pAudioCBuffer->Release();
	}
}

///////////////////////////////////////////////////////////////////

void CBitParser::ResetDemux()
{
	m_bStopDemux = FALSE;
	m_bProcess = FALSE;
	m_bEndOfBuffer = FALSE;
	m_bPayloadBetween2Buffers = FALSE;
	if (m_bPacketBetween2Buffers)
		m_pPreviousCBuffer->Release();
	m_bPacketBetween2Buffers = FALSE;
	// Transport stream buffers
	m_dwVideoBufferLen = 0;
	m_dwAudioBufferLen = 0;
	m_bVideoPesHeader = FALSE;
	m_bAudioPesHeader = FALSE;
	if (m_pVideoCBuffer)   m_pVideoCBuffer->Release();
	if (m_pAudioCBuffer)   m_pAudioCBuffer->Release();

	m_pIFrame->RestartDemux();
}

/////////////////////////////////////////////////////////////////////////////

void CBitParser::SetFastForward(BOOL bVal)
{
	m_bFastForward = bVal;
	if (!m_bFastForward)
		m_pIFrame->StopDemux();
}

/////////////////////////////////////////////////////////////////////////////

int CBitParser::Process(CBuffer* pCBuffer)
{
	return 0;
}

/////////////////////////////////////////////////////////////////////////////
// Transport stream sample

//#define NO_BUFFER_VIDEO
//#define NO_BUFFER_AUDIO

void CBitParser::TransportSample()
{
	CIMediaSample *pMedia = 0;

	if (!m_bPesPayload)
		return;
	else if ((m_wPid != m_ProgDef.iVideoElemStreamId) && (m_wPid != m_ProgDef.iAudioElemStreamId))
		 return;

	if ((m_dwPayloadLength > 0) && (m_dwPayloadLength <= 184))
	{
		switch (m_bStreamType)
		{
			case MM_VIDEO:
#ifdef _RECORD_VIDEO_
				SavePayload();
#endif
#ifdef NO_BUFFER_VIDEO
				m_pMemManager->GetMediaSample(m_pCBuffer, &pMedia);
				pMedia->SetPayload(m_bPayloadPtr);
				pMedia->SetActualDataLength(m_dwPayloadLength);
				pMedia->SetPts(m_llPts, m_bPtsDtsFlag);
				pMedia->SetMediaType(m_bStreamType);
				pMedia->SetScr(m_llPcr);

				m_llPcr = 0;
				m_bPtsDtsFlag = FALSE;
				SendToHardware (pMedia);
				pMedia->Release();
#else   // BUFFER_VIDEO
				if (m_bVideoPesHeader)
				{
					// New PES packet. Send payload of previous packet. This payload won't
					// contain info about PTS, DTS, Pes header and Pes length.
					if (m_dwVideoBufferLen > 0)
					{
						m_pMemManager->GetMediaSample(m_pVideoCBuffer, &pMedia);
						pMedia->SetPayload(m_pVideoBuffer);
						pMedia->SetActualDataLength(m_dwVideoBufferLen);
						pMedia->SetPts(0, FALSE);
						pMedia->SetMediaType(m_bStreamType);
						pMedia->SetScr(m_llPcr);
						m_llPcr = 0;

						SendToHardware (pMedia);
						pMedia->Release();

						m_pVideoCBuffer->Release();
						m_pVideoCBuffer = m_pMemManager->GetTSBuffer();
						m_pVideoBuffer = (BYTE*)m_pVideoCBuffer->GetBuffer();
						m_dwVideoBufferLen = 0;
					}
					// Completely new PES payload. This one usually has a length of < 184. Send
					// it rightaway to avoid overwritten of PTS, DTS, Pes header and Pes length.
					// No need to copy to temporary transport buffer!
					m_pMemManager->GetMediaSample(m_pCBuffer, &pMedia);
					pMedia->SetPayload(m_bPayloadPtr);
					pMedia->SetActualDataLength(m_dwPayloadLength);
					pMedia->SetPts(m_llVideoPts, m_bVideoPtsFlag);
					pMedia->SetMediaType(m_bStreamType);
					pMedia->SetScr(m_llPcr);
					m_llPcr = 0;

					SendToHardware (pMedia);
					pMedia->Release();

					m_bVideoPesHeader = FALSE;
					m_bVideoPtsFlag = FALSE;

					m_pVideoCBuffer->Release();
					m_pVideoCBuffer = m_pMemManager->GetTSBuffer();
					m_pVideoBuffer = (BYTE*)m_pVideoCBuffer->GetBuffer();
					m_dwVideoBufferLen = 0;
				}
				else
				{
					memcpy (m_pVideoBuffer + m_dwVideoBufferLen, m_bPayloadPtr, m_dwPayloadLength);
					m_dwVideoBufferLen += m_dwPayloadLength;
					if ((m_dwVideoBufferLen + 184) >= m_pVideoCBuffer->GetActualSize())
					{
						m_pMemManager->GetMediaSample(m_pVideoCBuffer, &pMedia);
						pMedia->SetPayload(m_pVideoBuffer);
						pMedia->SetActualDataLength(m_dwVideoBufferLen);
						pMedia->SetPts(m_llVideoPts, m_bVideoPtsFlag);
						pMedia->SetMediaType(m_bStreamType);
						pMedia->SetScr(m_llPcr);
						m_llPcr = 0;

						SendToHardware (pMedia);
						pMedia->Release();
						
						m_pVideoCBuffer->Release();
						m_pVideoCBuffer = m_pMemManager->GetTSBuffer();
						m_pVideoBuffer = (BYTE*)m_pVideoCBuffer->GetBuffer();
						m_dwVideoBufferLen = 0;
					}
				}
#endif
				break;
			case MM_AUDIO:
#ifdef _RECORD_AUDIO_
				SavePayload();
#endif
#ifdef NO_BUFFER_AUDIO
				m_pMemManager->GetMediaSample(m_pCBuffer, &pMedia);
				pMedia->SetPayload(m_bPayloadPtr);
				pMedia->SetActualDataLength(m_dwPayloadLength);
				pMedia->SetPts(m_llPts, m_bPtsDtsFlag);
				pMedia->SetMediaType(m_bStreamType);
				pMedia->SetScr(m_llPcr);
				m_llPcr = 0;
				m_bPtsDtsFlag = FALSE;

				pMedia->SetNFrameHeaders(0);
				pMedia->SetFirstAccessUnit(0);
				if (m_bAudioType == MM_AUDIO_FORMAT_AC3)
				{
					if (SetFirstAccessUnitPtr(m_bPayloadPtr, m_dwPayloadLength, &m_iFirstAccessUnit))
						pMedia->SetPtsDtsFlag(TRUE);