MPGUTIL.CPP
//==========================================================================;
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE.
//
// Copyright (c) 1996 - 1997 Microsoft Corporation. All Rights Reserved.
//
//--------------------------------------------------------------------------;
/* MPEG 1 & 2 parsing routines */
#include <streams.h>
#include <mpegdef.h>
#include <mmreg.h>
#include <mpeg2typ.h>
#include <mpgutil.h>
#ifdef DEBUG
LPCTSTR PictureTypes[8] = { TEXT("forbidden frame type"),
TEXT("I-Frame"),
TEXT("P-Frame"),
TEXT("B-Frame"),
TEXT("D-Frame"),
TEXT("Reserved frame type"),
TEXT("Reserved frame type"),
TEXT("Reserved frame type")
};
LPCTSTR PelAspectRatios[16] = { TEXT("Forbidden"),
TEXT("1.0000 - VGA etc"),
TEXT("0.6735"),
TEXT("0.7031 - 16:9, 625 line"),
TEXT("0.7615"),
TEXT("0.8055"),
TEXT("0.8437 - 16:9, 525 line"),
TEXT("0.8935"),
TEXT("0.9375 - CCIR601, 625 line"),
TEXT("0.9815"),
TEXT("1.0255"),
TEXT("1.0695"),
TEXT("1.1250 - CCIR601, 525 line"),
TEXT("1.1575"),
TEXT("1.2015"),
TEXT("Reserved") };
LPCTSTR PictureRates[16] = { TEXT("Forbidden"),
TEXT("23.976"),
TEXT("24"),
TEXT("25"),
TEXT("29.97"),
TEXT("30"),
TEXT("50"),
TEXT("59.94"),
TEXT("60"),
TEXT("Reserved"),
TEXT("Reserved"),
TEXT("Reserved"),
TEXT("Reserved"),
TEXT("Reserved"),
TEXT("Reserved"),
TEXT("Reserved") };
#endif // DBG
const LONG PictureTimes[16] = { 0,
(LONG)((double)10000000 / 23.976),
(LONG)((double)10000000 / 24),
(LONG)((double)10000000 / 25),
(LONG)((double)10000000 / 29.97),
(LONG)((double)10000000 / 30),
(LONG)((double)10000000 / 50),
(LONG)((double)10000000 / 59.94),
(LONG)((double)10000000 / 60)
};
const float fPictureRates[] =
{
(float)0,
(float)23.976,
(float)24,
(float)25,
(float)29.97,
(float)30,
(float)50,
(float)59.94,
(float)60.0
};
const LONG AspectRatios[16] = { 0,
393700,
(LONG)(393700.0 * 0.6735),
(LONG)(393700.0 * 0.7031),
(LONG)(393700.0 * 0.7615),
(LONG)(393700.0 * 0.8055),
(LONG)(393700.0 * 0.8437),
(LONG)(393700.0 * 0.8935),
(LONG)(393700.0 * 0.9375),
(LONG)(393700.0 * 0.9815),
(LONG)(393700.0 * 1.0255),
(LONG)(393700.0 * 1.0695),
(LONG)(393700.0 * 1.1250),
(LONG)(393700.0 * 1.1575),
(LONG)(393700.0 * 1.2015),
0
};
/* Bit rate tables */
const WORD BitRates[3][16] =
{{ 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0 },
{ 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0 },
{ 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0 }
};
BOOL inline TESTBIT(const BYTE * pbData, int n)
{
return 0 != (pbData[n >> 3] & (0x80 >> (n & 7)));
}
/* Read an extended clock */
BOOL GetExtendedClock(const BYTE * pbData, LONGLONG *pllClock)
{
/* Check marker bits
These occur at bit positions 5, 21, 37, 47 */
if (!TESTBIT(pbData, 5) ||
!TESTBIT(pbData, 21) ||
!TESTBIT(pbData, 37) ||
!TESTBIT(pbData, 47)) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid extended clock marker bits")));
return FALSE;
}
/* Compute the clock value
* = ignore
M = Marker
x = value
0 1 2 3 4
**xxxMxx xxxxxxxx xxxxxMxx xxxxxxxx xxxxxM**
*/
LARGE_INTEGER liClock;
liClock.HighPart = (pbData[0] & 0x20) != 0;
liClock.LowPart = ((pbData[0] & 0x18) << 27) +
((pbData[0] & 0x03) << 28) +
( pbData[1] << 20) +
((pbData[2] & 0xF8) << 12) +
((pbData[2] & 0x03) << 13) +
( pbData[3] << 5) +
( pbData[4] >> 3);
/* Now compute the residual */
LONG lCRE = ((pbData[4] & 3) << 7) + (pbData[5] >> 1);
if (lCRE >= 300) {
DbgLog((LOG_ERROR, 1, TEXT("Clock reference extension >= 300")));
return FALSE;
}
*pllClock = liClock.QuadPart * 300 + lCRE;
return TRUE;
}
/* Parse pack header
Parameters :
pbData - pointer to data containing the system header
cbData - length of data
Returns :
Number of bytes processed (0 if the header doesn't fit
in the data or 4 if the header is invalid)
We will return 0 if we can't see the next start code to
check whether it's a system header start code
*/
DWORD ParseMPEG2PackHeader(const BYTE * pbData, DWORD cbData)
{
ASSERT(cbData >= 4);
ASSERT(*(UNALIGNED DWORD *)pbData == DWORD_SWAP(PACK_START_CODE));
/* Is there enough for the basic length ? */
if (cbData < 18) {
return 0;
}
DWORD dwLen = 14 + (pbData[13] & 0x07);
if (cbData < dwLen + 4) {
return 0;
}
/* Check check bits '01' */
if (pbData[4] & 0xC0 != 0x40) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid bits at start of pack")));
return 4;
}
/* Get SCR */
LONGLONG llSCR;
if (!GetExtendedClock(pbData + 4, &llSCR)) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid pack header SCR field")));
return 4;
}
/* Get the mux rate */
DWORD dwMuxRate = (pbData[10] << (22 - 8)) +
(pbData[11] << (22 - 16)) +
(pbData[12] >> (24 - 22));
/* Check the marker bits */
if ((pbData[12] & 0x03) != 0x03) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid marker bits in pack header")));
return 4;
}
/* Check the stuffing bytes */
for (DWORD i = 14; i < dwLen; i++ ) {
if (pbData[i] != 0xFF) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid pack stuffing byte 0x%2.2X"),
pbData[i]));
return 4;
}
}
DbgLog((LOG_TRACE, 4, TEXT("Decoded pack - ESCR %s, Mux Rate %d bytes/sec"),
(LPCTSTR)CDisp(llSCR, CDISP_DEC),
dwMuxRate * 50));
return dwLen;
}
/* Parse system header
Parameters :
pbData - pointer to data containing the system header
cbData - length of data
Returns :
Number of bytes processed (0 if the header doesn't fit
in the data or 4 if the header is invalid)
*/
LONG ParseSystemHeader(const BYTE * pbData, DWORD cbData)
{
BOOL bHasAudio = FALSE;
BOOL bHasVideo = FALSE;
ASSERT(cbData >= 4);
ASSERT(*(UNALIGNED DWORD *)pbData == DWORD_SWAP(SYSTEM_HEADER_START_CODE));
/* Checkt the length */
if (cbData < 6) {
return 0;
}
DWORD dwLen = 6 + pbData[5] + (pbData[4] << 8);
if (dwLen < SYSTEM_HEADER_BASIC_LENGTH) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid System Header length")));
return 4;
}
if (cbData < dwLen) {
return 0;
}
/* Check the marker bits */
if (0 == (pbData[6] & 0x80) ||
0 == (pbData[8] & 0x01) ||
0 == (pbData[10] & 0x20)) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid System Header Marker bits")));
return 4;
}
/* Parse the 'buffer bounds and scale' list */
const BYTE * pbNext = pbData + SYSTEM_HEADER_BASIC_LENGTH;
DWORD cbLeft = dwLen - SYSTEM_HEADER_BASIC_LENGTH;
for ( ; cbLeft >= 3; cbLeft -= 3, pbNext += 3) {
if (pbNext[0] == AUDIO_GLOBAL) {
bHasAudio == TRUE;
} else
if (pbNext[0] == VIDEO_GLOBAL) {
bHasVideo = TRUE;
} else {
if (pbNext[0] < PROGRAM_STREAM_MAP) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid stream id in system header")));
return 4;
}
if (IsVideoStreamId(pbNext[0])) {
bHasVideo = TRUE;
} else
if (IsAudioStreamId(pbNext[0])) {
bHasAudio = TRUE;
}
}
}
if (cbLeft != 0) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid system header length")));
return 4;
}
DbgLog((LOG_TRACE, 4, TEXT("System Header %s, %s"),
bHasAudio ? TEXT("audio") : TEXT("No audio"),
bHasVideo ? TEXT("video") : TEXT("No video")));
return dwLen;
}
/* Parse an MPEG-1 packet */
DWORD ParseMPEG1Packet(
const BYTE * pbData,
DWORD cbData,
MPEG_PACKET_DATA *pPacketData
)
{
ZeroMemory((PVOID)pPacketData, sizeof(*pPacketData));
DWORD dwStartCode = DWORD_SWAP(*(UNALIGNED DWORD *)pbData);
DbgLog((LOG_TRACE, 4, TEXT("Parse packet %d bytes"), cbData));
/* Send it to the right stream */
if (cbData < 6) {
return 0;
}
/* Find the length */
DWORD dwLen = ((LONG)pbData[4] << 8) + (LONG)pbData[5] + 6;
DbgLog((LOG_TRACE, 4, TEXT("Packet length %d bytes"), dwLen));
if (dwLen > cbData) {
return 0;
}
pPacketData->dwPacketLen = dwLen;
/* Pull out PTS if any */
DWORD dwHeaderSize = 6;
if (dwStartCode != PRIVATE_STREAM_2) {
DWORD dwPts = 6;
for (;;) {
if (dwPts >= dwLen) {
return 4;
}
if (pbData[dwPts] & 0x80) {
/* Stuffing byte */
if (pbData[dwPts] != 0xFF) {
return 4;
}
dwPts++;
continue;
}
/* Check for STD (nextbits == '01') -
we know the next bit is 0 so check the next one after that
*/
if (pbData[dwPts] & 0x40) { // STD stuff
dwPts += 2;
continue;
}
/* No PTS - normal case */
if (pbData[dwPts] == 0x0F) {
dwHeaderSize = dwPts + 1;
break;
}
if ((pbData[dwPts] & 0xF0) == 0x20 ||
(pbData[dwPts] & 0xF0) == 0x30) {
/* PTS or PTS and DTS */
dwHeaderSize = (pbData[dwPts] & 0xF0) == 0x20 ? dwPts + 5 :
dwPts + 10;
if (dwHeaderSize > dwLen) {
return 4;
}
if (!GetClock(pbData + dwPts, &pPacketData->llPts)) {
return 4;
}
pPacketData->bHasPts = TRUE;
break;
} else {
return 4;
break;
}
}
}
pPacketData->dwHeaderLen = dwHeaderSize;
return dwLen;
}
/* Parse an MPEG-2 packet */
DWORD ParseMPEG2Packet(
const BYTE * pbData,
DWORD cbData,
MPEG_PACKET_DATA *pPacketData)
{
ASSERT(cbData >= 4);
ASSERT(pbData[3] >= PROGRAM_STREAM_MAP);
ZeroMemory((PVOID)pPacketData, sizeof(*pPacketData));
if (cbData < 6) {
return 0;
}
DWORD dwLen = 6 + pbData[5] + (pbData[4] << 8);
if (cbData < dwLen + 4) {
return 0;
}
/* Check for normal */
switch (pbData[3]) {
case PROGRAM_STREAM_MAP:
case PRIVATE_STREAM_2:
case ECM_STREAM:
case EMM_STREAM:
case PROGRAM_STREAM_DIRECTORY:
case 0xF2: // DSMCC_Stream
case 0xF8: // H.222 Type E
case PADDING_STREAM:
/* Just the bytes */
pPacketData->dwHeaderLen = 6;
pPacketData->dwPacketLen = dwLen;
pPacketData->bHasPts = FALSE;
pPacketData->llPts = 0;
break;
/* PES header */
default:
{
if (!ParseMPEG2PacketHeader(pbData, dwLen, pPacketData)) {
return 4;
}
}
break;
}
return dwLen;
}
/* Parse a packet header when present */
BOOL ParseMPEG2PacketHeader(
const BYTE * pbData,
DWORD dwLen,
MPEG_PACKET_DATA *pPacketData
)
{
/* Compute the length */
if (dwLen < 6 + 3) {
return FALSE;
}
pPacketData->dwHeaderLen = 6 + 3 + pbData[8];
pPacketData->dwPacketLen = dwLen;
/* Extract the PTS */
if (MPEG2PacketHasPTS(pbData)) {
pPacketData->bHasPts = TRUE;
pPacketData->llPts = MPEG2PacketPTS(pbData);
} else {
pPacketData->bHasPts = FALSE;
pPacketData->llPts = 0;
}
return TRUE;
}
BOOL ParseSequenceHeader(const BYTE *pbData, LONG lData, SEQHDR_INFO *pInfo)
{
ASSERT(*(UNALIGNED DWORD *)pbData == DWORD_SWAP(SEQUENCE_HEADER_CODE));
/* Check random marker bit */
if (!(pbData[10] & 0x20)) {
DbgLog((LOG_ERROR, 2, TEXT("Sequence header invalid marker bit")));
return FALSE;
}
DWORD dwWidthAndHeight = ((DWORD)pbData[4] << 16) +
((DWORD)pbData[5] << 8) +
((DWORD)pbData[6]);
pInfo->lWidth = dwWidthAndHeight >> 12;
pInfo->lHeight = dwWidthAndHeight & 0xFFF;
DbgLog((LOG_TRACE, 2, TEXT("Width = %d, Height = %d"),
pInfo->lWidth,
pInfo->lHeight));
/* the '8' bit is the scramble flag used by sigma designs - ignore */
BYTE PelAspectRatioAndPictureRate = pbData[7];
if ((PelAspectRatioAndPictureRate & 0x0F) > 8) {
PelAspectRatioAndPictureRate &= 0xF7;
}
DbgLog((LOG_TRACE, 2, TEXT("Pel Aspect Ratio = %s"),
PelAspectRatios[PelAspectRatioAndPictureRate >> 4]));
DbgLog((LOG_TRACE, 2, TEXT("Picture Rate = %s"),
PictureRates[PelAspectRatioAndPictureRate & 0x0F]));
if ((PelAspectRatioAndPictureRate & 0xF0) == 0 ||
(PelAspectRatioAndPictureRate & 0x0F) == 0) {
DbgLog((LOG_ERROR, 2, TEXT("Sequence header invalid ratio/rate")));
return FALSE;
}
pInfo->tPictureTime = (LONGLONG)PictureTimes[PelAspectRatioAndPictureRate & 0x0F];
pInfo->fPictureRate = fPictureRates[PelAspectRatioAndPictureRate & 0x0F];
pInfo->lTimePerFrame = MulDiv((LONG)pInfo->tPictureTime, 9, 1000);
/* Pull out the bit rate and aspect ratio for the type */
pInfo->dwBitRate = ((((DWORD)pbData[8] << 16) +
((DWORD)pbData[9] << 8) +
(DWORD)pbData[10]) >> 6);
if (pInfo->dwBitRate == 0x3FFFF) {
DbgLog((LOG_TRACE, 2, TEXT("Variable video bit rate")));
pInfo->dwBitRate = 0;
} else {
pInfo->dwBitRate *= 400;
DbgLog((LOG_TRACE, 2, TEXT("Video bit rate is %d bits per second"),
pInfo->dwBitRate));
}
#if 0
#pragma message (REMIND("Get pel aspect ratio right don't call GDI - it will create a thread!"))
/* Get a DC */
HDC hdc = GetDC(GetDesktopWindow());
ASSERT(hdc != NULL);
/* Guess (randomly) 39.37 inches per meter */
LONG lNotionalPelsPerMeter = MulDiv((LONG)GetDeviceCaps(hdc, LOGICALPELSX),
3937, 100);
#else
LONG lNotionalPelsPerMeter = 2000;
#endif
pInfo->lXPelsPerMeter = lNotionalPelsPerMeter;
pInfo->lYPelsPerMeter = MulDiv(
lNotionalPelsPerMeter,
AspectRatios[PelAspectRatioAndPictureRate >> 4],
10000);
/* Pull out the vbv */
pInfo->lvbv = ((((LONG)pbData[10] & 0x1F) << 5) |
((LONG)pbData[11] >> 3)) * 2048;
DbgLog((LOG_TRACE, 2, TEXT("vbv size is %d bytes"), pInfo->lvbv));
/* Check constrained parameter stuff */
if (pbData[11] & 0x04) {
DbgLog((LOG_TRACE, 2, TEXT("Constrained parameter video stream")));
if (pInfo->lvbv > 40960) {
DbgLog((LOG_ERROR, 1, TEXT("Invalid vbv (%d) for Constrained stream"),
pInfo->lvbv));
/* Have to let this through too! bisp.mpg has this */
/* But constrain it since it might be random */
pInfo->lvbv = 40960;
}
} else {
DbgLog((LOG_TRACE, 2, TEXT("Non-Constrained parameter video stream")));
}
/* tp_orig has a vbv of 2048 (!) */
if (pInfo->lvbv < 20000) {
DbgLog((LOG_TRACE, 2, TEXT("Small vbv (%d) - setting to 40960"),
pInfo->lvbv));
pInfo->lvbv = 40960;
}
pInfo->lActualHeaderLen = SequenceHeaderSize(pbData);
CopyMemory((PVOID)pInfo->RawHeader, (PVOID)pbData, pInfo->lActualHeaderLen);
return TRUE;
}
HRESULT GetVideoMediaType(CMediaType *cmt, BOOL bPayload, const SEQHDR_INFO *pInfo)
{
cmt->majortype = MEDIATYPE_Video;
cmt->subtype = bPayload ? MEDIASUBTYPE_MPEG1Payload :
MEDIASUBTYPE_MPEG1Packet;
VIDEOINFO *videoInfo =
(VIDEOINFO *)cmt->AllocFormatBuffer(FIELD_OFFSET(MPEG1VIDEOINFO, bSequenceHeader[pInfo->lActualHeaderLen]));
if (videoInfo == NULL) {
return E_OUTOFMEMORY;
}
RESET_HEADER(videoInfo);
videoInfo->dwBitRate = pInfo->dwBitRate;
videoInfo->rcSource.right = pInfo->lWidth;
videoInfo->bmiHeader.biWidth = pInfo->lWidth;
videoInfo->rcSource.bottom = pInfo->lHeight;
videoInfo->bmiHeader.biHeight = pInfo->lHeight;
videoInfo->bmiHeader.biXPelsPerMeter = pInfo->lXPelsPerMeter;
videoInfo->bmiHeader.biYPelsPerMeter = pInfo->lYPelsPerMeter;
videoInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
videoInfo->AvgTimePerFrame = pInfo->tPictureTime;
MPEG1VIDEOINFO *mpgvideoInfo = (MPEG1VIDEOINFO *)videoInfo;
mpgvideoInfo->cbSequenceHeader = pInfo->lActualHeaderLen;
CopyMemory((PVOID)mpgvideoInfo->bSequenceHeader,
(PVOID)pInfo->RawHeader,
pInfo->lActualHeaderLen);
mpgvideoInfo->dwStartTimeCode = pInfo->dwStartTimeCode;
cmt->SetFormatType(&FORMAT_MPEGVideo);
return S_OK;
}
BOOL CheckAudioHeader(const BYTE * pbData)
{
/* Just check it's valid */
#pragma message (REMIND("Check audio header"))
if ((pbData[2] & 0x0C) == 0x0C) {
DbgLog((LOG_ERROR, 2, TEXT("Invalid audio sampling frequency")));
return FALSE;
}
if ((pbData[1] & 0x08) != 0x08) {
DbgLog((LOG_ERROR, 2, TEXT("Invalid audio ID bit = 0")));
return FALSE;
}
if (((pbData[1] >> 1) & 3) == 0x00) {
DbgLog((LOG_ERROR, 2, TEXT("Invalid audio Layer")));
return FALSE;
}
if (((pbData[2] >> 2) & 3) == 3) {
DbgLog((LOG_ERROR, 2, TEXT("Invalid sample rate")));
return FALSE;
}
if ((pbData[2] >> 4) == 0x0F) {
DbgLog((LOG_ERROR, 2, TEXT("Invalid bit rate")));
return FALSE;
}
return TRUE;
}
LONG SampleRate(const BYTE * pbData)
{
switch ((pbData[2] >> 2) & 3) {
case 0:
return 44100;
case 1:
return 48000;
case 2:
return 32000;
default:
DbgBreak("Unexpected Sample Rate");
return 44100;
}
}
BOOL ParseAudioHeader(const BYTE * pbData, MPEG1WAVEFORMAT *pFormat)
{
if (!CheckAudioHeader(pbData)) {
return FALSE;
}
pFormat->wfx.wFormatTag = WAVE_FORMAT_MPEG;
/* Get number of channels from Mode */
switch (pbData[3] >> 6) {
case 0x00:
pFormat->fwHeadMode = ACM_MPEG_STEREO;
break;
case 0x01:
pFormat->fwHeadMode = ACM_MPEG_JOINTSTEREO;
break;
case 0x02:
pFormat->fwHeadMode = ACM_MPEG_DUALCHANNEL;
break;
case 0x03:
pFormat->fwHeadMode = ACM_MPEG_SINGLECHANNEL;
break;
}
pFormat->wfx.nChannels =
(WORD)(pFormat->fwHeadMode == ACM_MPEG_SINGLECHANNEL ? 1 : 2);
pFormat->fwHeadModeExt = (WORD)(1 << (pbData[3] >> 4));
pFormat->wHeadEmphasis = (WORD)((pbData[3] & 0x03) + 1);
pFormat->fwHeadFlags = (WORD)(((pbData[2] & 1) ? ACM_MPEG_PRIVATEBIT : 0) +
((pbData[3] & 8) ? ACM_MPEG_COPYRIGHT : 0) +
((pbData[3] & 4) ? ACM_MPEG_ORIGINALHOME : 0) +
((pbData[1] & 1) ? ACM_MPEG_PROTECTIONBIT : 0) +
((pbData[1] & 0x08) ? ACM_MPEG_ID_MPEG1 : 0));
int Layer;
/* Get the layer so we can work out the bit rate */
switch ((pbData[1] >> 1) & 3) {
case 3:
pFormat->fwHeadLayer = ACM_MPEG_LAYER1;
Layer = 1;
break;
case 2:
pFormat->fwHeadLayer = ACM_MPEG_LAYER2;
Layer = 2;
break;
case 1:
pFormat->fwHeadLayer = ACM_MPEG_LAYER3;
Layer = 3;
break;
case 0:
return (FALSE);
}
/* Get samples per second from sampling frequency */
pFormat->wfx.nSamplesPerSec = SampleRate(pbData);
pFormat->dwHeadBitrate =
(DWORD)BitRates[Layer - 1][pbData[2] >> 4] * 1000;
pFormat->wfx.nAvgBytesPerSec = pFormat->dwHeadBitrate / 8;
/* Deal with free format (!) */
#pragma message (REMIND("Handle variable bit rate (index 0)"))
if (pFormat->wfx.nSamplesPerSec != 44100 &&
/* Layer 3 can sometimes switch bitrates */
!(Layer == 3 && /* !m_pStreamList->AudioLock() && */
(pbData[2] >> 4) == 0)) {
if (Layer == 1) {
pFormat->wfx.nBlockAlign = (WORD)
(4 * ((pFormat->dwHeadBitrate * 12) / pFormat->wfx.nSamplesPerSec));
} else {
pFormat->wfx.nBlockAlign = (WORD)
((144 * pFormat->dwHeadBitrate) / pFormat->wfx.nSamplesPerSec);
}
} else {
pFormat->wfx.nBlockAlign = 1;
}
pFormat->wfx.wBitsPerSample = 0;
pFormat->wfx.cbSize = sizeof(MPEG1WAVEFORMAT) - sizeof(WAVEFORMATEX);
pFormat->dwPTSLow = 0;
pFormat->dwPTSHigh = 0;
return TRUE;
}
BOOL GetClock(const BYTE * pData, LONGLONG *Clock)
{
BYTE Byte1 = pData[0];
DWORD Word2 = ((DWORD)pData[1] << 8) + (DWORD)pData[2];
DWORD Word3 = ((DWORD)pData[3] << 8) + (DWORD)pData[4];
/* Do checks */
if ((Byte1 & 0xE0) != 0x20 ||
(Word2 & 1) != 1 ||
(Word3 & 1) != 1) {
DbgLog((LOG_TRACE, 2, TEXT("Invalid clock field - 0x%2.2X 0x%4.4X 0x%4.4X"),
Byte1, Word2, Word3));
return FALSE;
}
LARGE_INTEGER liClock;
liClock.HighPart = (Byte1 & 8) != 0;
liClock.LowPart = (DWORD)((((DWORD)Byte1 & 0x6) << 29) +
(((DWORD)Word2 & 0xFFFE) << 14) +
((DWORD)Word3 >> 1));
*Clock = liClock.QuadPart;
return TRUE;
}
/* Find the next start code */
BOOL NextStartCode(const BYTE * *ppbData, DWORD *pdwLeft)
{
const BYTE * pbData = *ppbData;
DWORD dwLeft = *pdwLeft;
while (dwLeft > 4 &&
(*(UNALIGNED DWORD *)pbData & 0x00FFFFFF) != 0x00010000) {
dwLeft--;
pbData++;
}
*ppbData = pbData;
*pdwLeft = dwLeft;
return dwLeft >= 4;
}
/* Parse AC3 header */
BOOL ParseAC3Header(const BYTE * pbData, DOLBYAC3WAVEFORMAT *pwf)
{
ZeroMemory((PVOID)pwf, sizeof(*pwf));
pwf->wfx.cbSize = sizeof(DOLBYAC3WAVEFORMAT) - sizeof(WAVEFORMATEX);
/* First check it IS AC3 */
if (pbData[0] == 0x77 && pbData[1] == 0x0B) {
} else
if (pbData[0] == 0x0B && pbData[1] == 0x77) {
pwf->bBigEndian = TRUE;
} else {
return FALSE;
}
/* Get the sampling rate */
BYTE bData = pwf->bBigEndian ? pbData[4] : pbData[5];
int SampleRateCode = bData >> 6;
int BitRateCode = bData & 0x3F;
switch (SampleRateCode) {
case 1:
pwf->wfx.nSamplesPerSec = 44100;
break;
case 2:
pwf->wfx.nSamplesPerSec = 32000;
break;
default: // Isn't one illegal?
pwf->wfx.nSamplesPerSec = 48000;
break;
}
if (BitRateCode >= 38) {
return FALSE;
}
/* Get the bit rate */
int BitRates[] =
{
32, 32, 40, 40, 48, 48, 56, 56, 64, 64,
80, 80, 96, 96, 112, 112, 128, 128, 160, 160,
192, 192, 224, 224, 256, 256, 320, 320, 384, 384,
448, 448, 512, 512, 576, 576, 640, 640
};
pwf->wfx.nAvgBytesPerSec = BitRates[BitRateCode] * (1000 / 8);
/* Get the frame size
Since every frame contains 1536 samples we can compute it as
Bypes per frame = Samples per frame (1536) * Bytes per second
--------------------------------------------
Samples per second
*/
pwf->wfx.nBlockAlign = MulDiv(1536,
pwf->wfx.nAvgBytesPerSec,
pwf->wfx.nSamplesPerSec);
pwf->wfx.nChannels = 6; // Hack!
pwf->wfx.wFormatTag = WAVE_FORMAT_DOLBY_AC3;
DbgLog((LOG_TRACE, 3, TEXT("Wave Format Dolby AC3")));
DbgLog((LOG_TRACE, 3, TEXT("%d bytes per sec, %d samples per sec, align %d"),
pwf->wfx.nAvgBytesPerSec,
pwf->wfx.nSamplesPerSec,
pwf->wfx.nBlockAlign));
return TRUE;
}
/* Return the PTS clock value as a 33 bit number
Returns LONGLONG(-1) if the clock is invalid
*/
LONGLONG MPEG2PacketPTS(const BYTE * pbPacket)
{
ASSERT(MPEG2PacketHasPTS(pbPacket));
LONGLONG llClock;
if (!GetClock(pbPacket + 9, &llClock)) {
return (LONGLONG)-1;
}
return llClock;
}