mpgutil.h

VC++视频开发实例集锦(包括“远程视频监控”"语音识别系统"等13个经典例子)

//==========================================================================;
//
//  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-2 utility functions */
#include <streams.h>
#include "mmreg.h"


/*  Packet header info */
typedef struct tag_MPEG_PACKET_DATA {
    DWORD    dwHeaderLen;
    DWORD    dwPacketLen;
    BOOL     bHasPts;
    LONGLONG llPts;
} MPEG_PACKET_DATA;

/*  Read an normal MPEG-1 style clock */
BOOL GetClock(const BYTE * pData, LONGLONG *Clock);
BOOL SetClock(BYTE * pData, LONGLONG *Clock);

/*  Read an extended clock */
BOOL GetExtendedClock(const BYTE * pbData, LONGLONG *pllClock);
//BOOL GetMPEG1ExtendedClock(const BYTE * pbData, LONGLONG *pllClock);
//BOOL PutMPEG1ExtendedClock( BYTE * pbData, LONGLONG pllClock);
//BOOL GetMPEG1TimeCode(const BYTE * pbData,  MMTIME * pllTimeCode);
//BOOL PutMPEG1TimeCode(BYTE * pbData,  MMTIME pllTimeCode);

inline GetStartCode(const BYTE * pbData)
{
    return DWORD_SWAP(*(UNALIGNED DWORD *)pbData);
}


/*  Since dwCode is normally a constant just swap that instead */
inline BOOL IsStartCode(const BYTE * pbData, DWORD dwCode)
{
    return DWORD_SWAP(dwCode) == *(UNALIGNED DWORD *)pbData;
}

/*  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);

/*  Length of pack header - returns 0 if < cbData */
/*
inline DWORD MPEG2PackHeaderLength(const BYTE * pbData, DWORD cbData)
{
    //  Need more data 
    if (cbData < 14) {
        return 0;
    } else {
        DWORD dwLen = 14 + (pbData[13] & 0x07);
        if (dwLen > cbData) {
            return 0;
        } else {
            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);


/*  Parse an MPEG2 packet and extract information */
/*
DWORD ParseMPEG2Packet(
    const BYTE * pbData,
    DWORD cbData,
    MPEG_PACKET_DATA *pPacketData
);
*/
/*  Parse an MPEG1 packet and extract information */
DWORD ParseMPEG1Packet(
    const BYTE * pbData,
    DWORD cbData,
    MPEG_PACKET_DATA *pPacketData,
	DWORD *Pts
);
/*
BOOL ParseMPEG2PacketHeader(
    const BYTE * pbData,
    DWORD dwLen,
    MPEG_PACKET_DATA *pPacketData
);
*/
/*  Inlines to get PTSs from MPEG2 packets */
/*
inline BOOL MPEG2PacketHasPTS(const BYTE * pbPacket)
{
    //  Just check if the PTS_DTS_flags are 10 or 11 (ie the first
    //  bit is one
    
    return 0 != (pbPacket[7] & 0x80);
}
*/
/*  Get the PTS from an MPEG2 packet */
//LONGLONG MPEG2PacketPTS(const BYTE * pbPacket);


typedef struct {
    DWORD          dwProfile;          //  Profile - MPEG2 only
    DWORD          dwLevel;            //  Level - MPEG2 only
    LONG           lWidth;             //  Native Width in pixels
    LONG           lHeight;            //  Native Height in pixels
    LONG           lvbv;               //  vbv
    REFERENCE_TIME  tPictureTime;      //  Time per picture in 100ns units
    float          fPictureRate;       //  In frames per second
    LONG           lTimePerFrame;      //  Time per picture in MPEG units
    LONG           dwBitRate;          //  Bits per second
    LONG           lXPelsPerMeter;     //  Pel aspect ratio
    LONG           lYPelsPerMeter;     //  Pel aspect ratio
    DWORD          dwStartTimeCode;    //  First GOP time code (or -1)
    LONG           lActualHeaderLen;   //  Length of valid bytes in raw seq hdr
    BYTE           RawHeader[140];     //  The real sequence header
} SEQHDR_INFO;

/*  MPEG2 stuff */
typedef struct {
    BOOL           bExtensionPresent;
    BOOL           bDisplayExtensionPresent;
    BOOL           bScalableExtensionPresent;
    SEQHDR_INFO    seqhdrInfo;

} MPEG2_SEQHDR_INFO;

/*  Helper */
int inline SequenceHeaderSize(const BYTE *pb)
{
    /*  No quantization matrices ? */
    if ((pb[11] & 0x03) == 0x00) {
        return 12;
    }
    /*  Just non-intra quantization matrix ? */
    if ((pb[11] & 0x03) == 0x01) {
        return 12 + 64;
    }
    /*  Intra found - is there a non-intra ? */
    if (pb[11 + 64] & 0x01) {
        return 12 + 64 + 64;
    } else {
        return 12 + 64;
    }
}

/*  Extract info from video sequence header

    Returns FALSE if the sequence header is invalid
*/

BOOL ParseSequenceHeader(const BYTE *pbData, LONG lData, SEQHDR_INFO *hdrInfo);

BOOL ParseAudioHeader(const BYTE * pbData, MPEG1WAVEFORMAT *pFormat);

/*  Construct a media type from the video info */
HRESULT GetVideoMediaType(CMediaType *cmt, BOOL bPayload, const SEQHDR_INFO *pInfo);

/*  Find the next start code */
BOOL NextStartCode(const BYTE * *ppbData, DWORD *pdwLeft);

/*  Parse AC3 header */
//BOOL ParseAC3Header(const BYTE * pbData, DOLBYAC3WAVEFORMAT *pwf);