开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
MPGUTIL.CPP
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：21k
源码类别：

VC书籍

开发平台：

Visual C++

MPGUTIL.CPP：源码内容
  1. //==========================================================================;
  2. //
  3. //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4. //  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5. //  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6. //  PURPOSE.
  7. //
  8. //  Copyright (c) 1996 - 1997  Microsoft Corporation.  All Rights Reserved.
  9. //
  10. //--------------------------------------------------------------------------;
  11. /*  MPEG 1 & 2 parsing routines */
  13. #include "stdafx.h"
  14. #include <streams.h>
  15. #include "mpegdef.h"
  16. #include <mmreg.h>
  17. #include "mpgutil.h"
  19. //#ifdef DEBUG
  20. LPCTSTR PictureTypes[8]   = { TEXT("forbidden frame type"),
  21.                               TEXT("I-Frame"),
  22.                               TEXT("P-Frame"),
  23.                               TEXT("B-Frame"),
  24.                               TEXT("D-Frame"),
  25.                               TEXT("Reserved frame type"),
  26.                               TEXT("Reserved frame type"),
  27.                               TEXT("Reserved frame type")
  28.                             };
  29. LPCTSTR PelAspectRatios[16] = { TEXT("Forbidden"),
  30.                                 TEXT("1.0000 - VGA etc"),
  31.                                 TEXT("0.6735"),
  32.                                 TEXT("0.7031 - 16:9, 625 line"),
  33.                                 TEXT("0.7615"),
  34.                                 TEXT("0.8055"),
  35.                                 TEXT("0.8437 - 16:9, 525 line"),
  36.                                 TEXT("0.8935"),
  37.                                 TEXT("0.9375 - CCIR601, 625 line"),
  38.                                 TEXT("0.9815"),
  39.                                 TEXT("1.0255"),
  40.                                 TEXT("1.0695"),
  41.                                 TEXT("1.1250 - CCIR601, 525 line"),
  42.                                 TEXT("1.1575"),
  43.                                 TEXT("1.2015"),
  44.                                 TEXT("Reserved") };
  45. LPCTSTR PictureRates[16] = { TEXT("Forbidden"),
  46.                              TEXT("23.976"),
  47.                              TEXT("24"),
  48.                              TEXT("25"),
  49.                              TEXT("29.97"),
  50.                              TEXT("30"),
  51.                              TEXT("50"),
  52.                              TEXT("59.94"),
  53.                              TEXT("60"),
  54.                              TEXT("Reserved"),
  55.                              TEXT("Reserved"),
  56.                              TEXT("Reserved"),
  57.                              TEXT("Reserved"),
  58.                              TEXT("Reserved"),
  59.                              TEXT("Reserved"),
  60.                              TEXT("Reserved") };
  61. //#endif // DBG
  63. const LONG PictureTimes[16] = { 0,
  64.                                 (LONG)((double)10000000 / 23.976),
  65.                                 (LONG)((double)10000000 / 24),
  66.                                 (LONG)((double)10000000 / 25),
  67.                                 (LONG)((double)10000000 / 29.97),
  68.                                 (LONG)((double)10000000 / 30),
  69.                                 (LONG)((double)10000000 / 50),
  70.                                 (LONG)((double)10000000 / 59.94),
  71.                                 (LONG)((double)10000000 / 60)
  72.                               };
  74. const float fPictureRates[] =
  75.    {
  76.      (float)0,
  77.      (float)23.976,
  78.      (float)24,
  79.      (float)25,
  80.      (float)29.97,
  81.      (float)30,
  82.      (float)50,
  83.      (float)59.94,
  84.      (float)60.0
  85.    };
  87. const LONG AspectRatios[16] = { 0,
  88.                                 393700,
  89.                                 (LONG)(393700.0 * 0.6735),
  90.                                 (LONG)(393700.0 * 0.7031),
  91.                                 (LONG)(393700.0 * 0.7615),
  92.                                 (LONG)(393700.0 * 0.8055),
  93.                                 (LONG)(393700.0 * 0.8437),
  94.                                 (LONG)(393700.0 * 0.8935),
  95.                                 (LONG)(393700.0 * 0.9375),
  96.                                 (LONG)(393700.0 * 0.9815),
  97.                                 (LONG)(393700.0 * 1.0255),
  98.                                 (LONG)(393700.0 * 1.0695),
  99.                                 (LONG)(393700.0 * 1.1250),
  100.                                 (LONG)(393700.0 * 1.1575),
  101.                                 (LONG)(393700.0 * 1.2015),
  102.                                 0
  103.                               };
  105. /*  Bit rate tables */
  106. const WORD BitRates[3][16] =
  107. {{  0, 32,  64,  96,  128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0 },
  108.  {  0, 32,  48,  56,   64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384, 0 },
  109.  {  0, 32,  40,  48,   56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 0 }
  110. };
  112. BOOL inline TESTBIT(const BYTE * pbData, int n)
  113. {
  114.     return 0 != (pbData[n >> 3] & (0x80 >> (n & 7)));
  115. }
  119. /*  Parse system header
  121.     Parameters :
  122.         pbData - pointer to data containing the system header
  123.         cbData - length of data
  125.     Returns :
  126.         Number of bytes processed (0 if the header doesn't fit
  127.         in the data or 4 if the header is invalid)
  128. */
  130. LONG ParseSystemHeader(const BYTE * pbData, DWORD cbData)
  131. {
  132.     BOOL bHasAudio = FALSE;
  133.     BOOL bHasVideo = FALSE;
  135.     ASSERT(cbData >= 4);
  136.     ASSERT(*(UNALIGNED DWORD *)pbData == DWORD_SWAP(SYSTEM_HEADER_START_CODE));
  138.     /*  Checkt the length */
  139.     if (cbData < 6) {
  140.         return 0;
  141.     }
  143.     DWORD dwLen = 6 + pbData[5] + (pbData[4] << 8);
  144.     if (dwLen < SYSTEM_HEADER_BASIC_LENGTH) {
  145.         DbgLog((LOG_ERROR, 1, TEXT("Invalid System Header length")));
  146.         return 4;
  147.     }
  149.     if (cbData < dwLen) {
  150.         return 0;
  151.     }
  152.     /*  Check the marker bits */
  153.     if (0 == (pbData[6] & 0x80) ||
  154.         0 == (pbData[8] & 0x01) ||
  155.         0 == (pbData[10] & 0x20)) {
  156.         DbgLog((LOG_ERROR, 1, TEXT("Invalid System Header Marker bits")));
  157.         return 4;
  158.     }
  160.     /*  Parse the 'buffer bounds and scale' list */
  161.     const BYTE * pbNext = pbData + SYSTEM_HEADER_BASIC_LENGTH;
  162.     DWORD cbLeft = dwLen - SYSTEM_HEADER_BASIC_LENGTH;
  163.     for ( ; cbLeft >= 3; cbLeft -= 3, pbNext += 3) {
  164.         if (pbNext[0] == AUDIO_GLOBAL) {
  165.             bHasAudio = TRUE;
  166.         } else
  167.         if (pbNext[0] == VIDEO_GLOBAL) {
  168.             bHasVideo = TRUE;
  169.         } else {
  170.             if (pbNext[0] < PROGRAM_STREAM_MAP) {
  171.                 DbgLog((LOG_ERROR, 1, TEXT("Invalid stream id in system header")));
  172.                 return 4;
  173.             }
  174.             if (IsVideoStreamId(pbNext[0])) {
  175.                 bHasVideo = TRUE;
  176.             } else
  177.             if (IsAudioStreamId(pbNext[0])) {
  178.                 bHasAudio = TRUE;
  179.             }
  180.         }
  181.     }
  182.     if (cbLeft != 0) {
  183.         DbgLog((LOG_ERROR, 1, TEXT("Invalid system header length")));
  184.         return 4;
  185.     }
  186.     DbgLog((LOG_TRACE, 4, TEXT("System Header %s, %s"),
  187.             bHasAudio ? TEXT("audio") : TEXT("No audio"),
  188.             bHasVideo ? TEXT("video") : TEXT("No video")));
  189.     return dwLen;
  190. }
  192. /*  Parse an MPEG-1 packet */
  193. DWORD ParseMPEG1Packet(
  194.     const BYTE * pbData,
  195.     DWORD cbData,
  196.     MPEG_PACKET_DATA *pPacketData,
  197. DWORD * Pts
  198. )
  199. {
  200.     ZeroMemory((PVOID)pPacketData, sizeof(*pPacketData));
  201.     DWORD dwStartCode = DWORD_SWAP(*(UNALIGNED DWORD *)pbData);
  202.     DbgLog((LOG_TRACE, 4, TEXT("Parse packet %d bytes"), cbData));
  203.     /*  Send it to the right stream */
  204.     if (cbData < 6) {
  205.         return 0;
  206.     }
  208.     /*  Find the length */
  209.     DWORD dwLen = ((LONG)pbData[4] << 8) + (LONG)pbData[5] + 6;
  210.     DbgLog((LOG_TRACE, 4, TEXT("Packet length %d bytes"), dwLen));
  211.     if (dwLen > cbData) {
  212.         return 0;
  213.     }
  214.     pPacketData->dwPacketLen = dwLen;
  216.     /*  Pull out PTS if any */
  217.     DWORD dwHeaderSize = 6;
  219.     if (dwStartCode != PRIVATE_STREAM_2) {
  220.         DWORD dwPts = 6;
  221.         for (;;) {
  222.             if (dwPts >= dwLen) {
  223.                 return 4;
  224.             }
  226.             if (pbData[dwPts] & 0x80) {
  227.                 /*  Stuffing byte */
  228.                 if (pbData[dwPts] != 0xFF) {
  229.                     return 4;
  230.                 }
  231.                 dwPts++;
  232.                 continue;
  233.             }
  235.             /*  Check for STD (nextbits == '01') -
  236.                 we know the next bit is 0 so check the next one after that
  237.             */
  238.             if (pbData[dwPts] & 0x40) { // STD stuff
  239.                 dwPts += 2;
  240.                 continue;
  241.             }
  243.             /*  No PTS - normal case */
  244.             if (pbData[dwPts] == 0x0F) {
  245.                 dwHeaderSize = dwPts + 1;
  246.                 break;
  247.             }
  249.             if ((pbData[dwPts] & 0xF0) == 0x20 ||
  250.                 (pbData[dwPts] & 0xF0) == 0x30) {
  253.                 /*  PTS or PTS and DTS */
  254.                 dwHeaderSize = (pbData[dwPts] & 0xF0) == 0x20 ? dwPts + 5 :
  255.                                                              dwPts + 10;
  256.                 if (dwHeaderSize > dwLen) {
  257.                     return 4;
  258.                 }
  259.                 if (!GetClock(pbData + dwPts, &pPacketData->llPts)) {
  260. *Pts = dwPts;
  261.                     return 4;
  262.                 }
  263.                 pPacketData->bHasPts = TRUE;
  264.                 break;
  265.             } else {
  266.                 return 4;
  267.                 break;
  268.             }
  269.         }
  270.     }
  271.     pPacketData->dwHeaderLen = dwHeaderSize;
  272.     return dwLen;
  273. }
  276. BOOL ParseSequenceHeader(const BYTE *pbData, LONG lData, SEQHDR_INFO *pInfo)
  277. {
  278.     ASSERT(*(UNALIGNED DWORD *)pbData == DWORD_SWAP(SEQUENCE_HEADER_CODE));
  280.     /*  Check random marker bit */
  281.     if (!(pbData[10] & 0x20)) {
  282.         DbgLog((LOG_ERROR, 2, TEXT("Sequence header invalid marker bit")));
  283.         return FALSE;
  284.     }
  286.     DWORD dwWidthAndHeight = ((DWORD)pbData[4] << 16) +
  287.                              ((DWORD)pbData[5] << 8) +
  288.                              ((DWORD)pbData[6]);
  290.     pInfo->lWidth = dwWidthAndHeight >> 12;
  291.     pInfo->lHeight = dwWidthAndHeight & 0xFFF;
  292.     DbgLog((LOG_TRACE, 2, TEXT("Width = %d, Height = %d"),
  293.         pInfo->lWidth,
  294.         pInfo->lHeight));
  296.     /* the '8' bit is the scramble flag used by sigma designs - ignore */
  297.     BYTE PelAspectRatioAndPictureRate = pbData[7];
  298.     if ((PelAspectRatioAndPictureRate & 0x0F) > 8) {
  299.         PelAspectRatioAndPictureRate &= 0xF7;
  300.     }
  301.     DbgLog((LOG_TRACE, 2, TEXT("Pel Aspect Ratio = %s"),
  302.         PelAspectRatios[PelAspectRatioAndPictureRate >> 4]));
  303.     DbgLog((LOG_TRACE, 2, TEXT("Picture Rate = %s"),
  304.         PictureRates[PelAspectRatioAndPictureRate & 0x0F]));
  306.     if ((PelAspectRatioAndPictureRate & 0xF0) == 0 ||
  307.         (PelAspectRatioAndPictureRate & 0x0F) == 0) {
  308.         DbgLog((LOG_ERROR, 2, TEXT("Sequence header invalid ratio/rate")));
  309.         return FALSE;
  310.     }
  312.     pInfo->tPictureTime = (LONGLONG)PictureTimes[PelAspectRatioAndPictureRate & 0x0F];
  313.     pInfo->fPictureRate = fPictureRates[PelAspectRatioAndPictureRate & 0x0F];
  314.     pInfo->lTimePerFrame = MulDiv((LONG)pInfo->tPictureTime, 9, 1000);
  316.     /*  Pull out the bit rate and aspect ratio for the type */
  317.     pInfo->dwBitRate = ((((DWORD)pbData[8] << 16) +
  318.                    ((DWORD)pbData[9] << 8) +
  319.                    (DWORD)pbData[10]) >> 6);
  320.     if (pInfo->dwBitRate == 0x3FFFF) {
  321.         DbgLog((LOG_TRACE, 2, TEXT("Variable video bit rate")));
  322.         pInfo->dwBitRate = 0;
  323.     } else {
  324.         pInfo->dwBitRate *= 400;
  325.         DbgLog((LOG_TRACE, 2, TEXT("Video bit rate is %d bits per second"),
  326.                pInfo->dwBitRate));
  327.     }
  329. #if 0
  330. #pragma message (REMIND("Get pel aspect ratio right don't call GDI - it will create a thread!"))
  331.     /*  Get a DC */
  332.     HDC hdc = GetDC(GetDesktopWindow());
  334.     ASSERT(hdc != NULL);
  335.     /*  Guess (randomly) 39.37 inches per meter */
  336.     LONG lNotionalPelsPerMeter = MulDiv((LONG)GetDeviceCaps(hdc, LOGICALPELSX),
  337.                                         3937, 100);
  338. #else
  339.     LONG lNotionalPelsPerMeter = 2000;
  340. #endif
  342.     pInfo->lXPelsPerMeter = lNotionalPelsPerMeter;
  344.     pInfo->lYPelsPerMeter = MulDiv(
  345.                               lNotionalPelsPerMeter,
  346.                               AspectRatios[PelAspectRatioAndPictureRate >> 4],
  347.                               10000);
  348.     /*  Pull out the vbv */
  349.     pInfo->lvbv = ((((LONG)pbData[10] & 0x1F) << 5) |
  350.              ((LONG)pbData[11] >> 3)) * 2048;
  352.     DbgLog((LOG_TRACE, 2, TEXT("vbv size is %d bytes"), pInfo->lvbv));
  354.     /*  Check constrained parameter stuff */
  355.     if (pbData[11] & 0x04) {
  356.         DbgLog((LOG_TRACE, 2, TEXT("Constrained parameter video stream")));
  358.         if (pInfo->lvbv > 40960) {
  359.             DbgLog((LOG_ERROR, 1, TEXT("Invalid vbv (%d) for Constrained stream"),
  360.                     pInfo->lvbv));
  362.             /*  Have to let this through too!  bisp.mpg has this */
  363.             /*  But constrain it since it might be random        */
  364.             pInfo->lvbv = 40960;
  365.         }
  366.     } else {
  367.         DbgLog((LOG_TRACE, 2, TEXT("Non-Constrained parameter video stream")));
  368.     }
  370.     /*  tp_orig has a vbv of 2048 (!) */
  371.     if (pInfo->lvbv < 20000) {
  372.         DbgLog((LOG_TRACE, 2, TEXT("Small vbv (%d) - setting to 40960"),
  373.                pInfo->lvbv));
  374.         pInfo->lvbv = 40960;
  375.     }
  377.     pInfo->lActualHeaderLen = SequenceHeaderSize(pbData);
  378.     CopyMemory((PVOID)pInfo->RawHeader, (PVOID)pbData, pInfo->lActualHeaderLen);
  379.     return TRUE;
  380. }
  382. HRESULT GetVideoMediaType(CMediaType *cmt, BOOL bPayload, const SEQHDR_INFO *pInfo)
  383. {
  384.     cmt->majortype = MEDIATYPE_Video;
  385.     cmt->subtype = bPayload ? MEDIASUBTYPE_MPEG1Payload :
  386.                               MEDIASUBTYPE_MPEG1Packet;
  387.     VIDEOINFO *videoInfo =
  388.         (VIDEOINFO *)cmt->AllocFormatBuffer(FIELD_OFFSET(MPEG1VIDEOINFO, bSequenceHeader[pInfo->lActualHeaderLen]));
  389.     if (videoInfo == NULL) {
  390.         return E_OUTOFMEMORY;
  391.     }
  392.     RESET_HEADER(videoInfo);
  394.     videoInfo->dwBitRate          = pInfo->dwBitRate;
  395.     videoInfo->rcSource.right     = pInfo->lWidth;
  396.     videoInfo->bmiHeader.biWidth  = pInfo->lWidth;
  397.     videoInfo->rcSource.bottom    = pInfo->lHeight;
  398.     videoInfo->bmiHeader.biHeight = pInfo->lHeight;
  399.     videoInfo->bmiHeader.biXPelsPerMeter = pInfo->lXPelsPerMeter;
  400.     videoInfo->bmiHeader.biYPelsPerMeter = pInfo->lYPelsPerMeter;
  401.     videoInfo->bmiHeader.biSize   = sizeof(BITMAPINFOHEADER);
  403.     videoInfo->AvgTimePerFrame = pInfo->tPictureTime;
  404.     MPEG1VIDEOINFO *mpgvideoInfo = (MPEG1VIDEOINFO *)videoInfo;
  405.     mpgvideoInfo->cbSequenceHeader = pInfo->lActualHeaderLen;
  406.     CopyMemory((PVOID)mpgvideoInfo->bSequenceHeader,
  407.                (PVOID)pInfo->RawHeader,
  408.                pInfo->lActualHeaderLen);
  409.     mpgvideoInfo->dwStartTimeCode = pInfo->dwStartTimeCode;
  412.     cmt->SetFormatType(&FORMAT_MPEGVideo);
  413.     return S_OK;
  414. }
  416. BOOL CheckAudioHeader(const BYTE * pbData)
  417. {
  418.     /*  Just check it's valid */
  419. #pragma message (REMIND("Check audio header"))
  420.     if ((pbData[2] & 0x0C) == 0x0C) {
  421.         DbgLog((LOG_ERROR, 2, TEXT("Invalid audio sampling frequency")));
  422.         return FALSE;
  423.     }
  424.     if ((pbData[1] & 0x08) != 0x08) {
  425.         DbgLog((LOG_ERROR, 2, TEXT("Invalid audio ID bit = 0")));
  426.         return FALSE;
  427.     }
  428.     if (((pbData[1] >> 1) & 3) == 0x00) {
  429.         DbgLog((LOG_ERROR, 2, TEXT("Invalid audio Layer")));
  430.         return FALSE;
  431.     }
  433.     if (((pbData[2] >> 2) & 3) == 3) {
  434.         DbgLog((LOG_ERROR, 2, TEXT("Invalid sample rate")));
  435.         return FALSE;
  436.     }
  437.     if ((pbData[2] >> 4) == 0x0F) {
  438.         DbgLog((LOG_ERROR, 2, TEXT("Invalid bit rate")));
  439.         return FALSE;
  440.     }
  442.     return TRUE;
  443. }
  445. LONG SampleRate(const BYTE * pbData)
  446. {
  447.     switch ((pbData[2] >> 2) & 3) {
  448.         case 0:
  449.             return 44100;
  451.         case 1:
  452.             return 48000;
  454.         case 2:
  455.             return 32000;
  457.         default:
  458.             DbgBreak("Unexpected Sample Rate");
  459.             return 44100;
  460.     }
  461. }
  463. BOOL ParseAudioHeader(const BYTE * pbData, MPEG1WAVEFORMAT *pFormat)
  464. {
  465.     if (!CheckAudioHeader(pbData)) {
  466.         return FALSE;
  467.     }
  468.     pFormat->wfx.wFormatTag = WAVE_FORMAT_MPEG;
  470.     /*  Get number of channels from Mode */
  471.     switch (pbData[3] >> 6) {
  472.     case 0x00:
  473.         pFormat->fwHeadMode = ACM_MPEG_STEREO;
  474.         break;
  475.     case 0x01:
  476.         pFormat->fwHeadMode = ACM_MPEG_JOINTSTEREO;
  477.         break;
  478.     case 0x02:
  479.         pFormat->fwHeadMode = ACM_MPEG_DUALCHANNEL;
  480.         break;
  481.     case 0x03:
  482.         pFormat->fwHeadMode = ACM_MPEG_SINGLECHANNEL;
  483.         break;
  484.     }
  485.     pFormat->wfx.nChannels =
  486.         (WORD)(pFormat->fwHeadMode == ACM_MPEG_SINGLECHANNEL ? 1 : 2);
  487.     pFormat->fwHeadModeExt = (WORD)(1 << (pbData[3] >> 4));
  488.     pFormat->wHeadEmphasis = (WORD)((pbData[3] & 0x03) + 1);
  489.     pFormat->fwHeadFlags   = (WORD)(((pbData[2] & 1) ? ACM_MPEG_PRIVATEBIT : 0) +
  490.                            ((pbData[3] & 8) ? ACM_MPEG_COPYRIGHT : 0) +
  491.                            ((pbData[3] & 4) ? ACM_MPEG_ORIGINALHOME : 0) +
  492.                            ((pbData[1] & 1) ? ACM_MPEG_PROTECTIONBIT : 0) +
  493.                            ((pbData[1] & 0x08) ? ACM_MPEG_ID_MPEG1 : 0));
  495.     int Layer;
  497.     /*  Get the layer so we can work out the bit rate */
  498.     switch ((pbData[1] >> 1) & 3) {
  499.         case 3:
  500.             pFormat->fwHeadLayer = ACM_MPEG_LAYER1;
  501.             Layer = 1;
  502.             break;
  503.         case 2:
  504.             pFormat->fwHeadLayer = ACM_MPEG_LAYER2;
  505.             Layer = 2;
  506.             break;
  507.         case 1:
  508.             pFormat->fwHeadLayer = ACM_MPEG_LAYER3;
  509.             Layer = 3;
  510.             break;
  511.         case 0:
  512.             return (FALSE);
  513.     }
  515.     /*  Get samples per second from sampling frequency */
  516.     pFormat->wfx.nSamplesPerSec = SampleRate(pbData);
  517.     pFormat->dwHeadBitrate =
  518.         (DWORD)BitRates[Layer - 1][pbData[2] >> 4] * 1000;
  519.     pFormat->wfx.nAvgBytesPerSec = pFormat->dwHeadBitrate / 8;
  521.     /*  Deal with free format (!) */
  522. #pragma message (REMIND("Handle variable bit rate (index 0)"))
  524.     if (pFormat->wfx.nSamplesPerSec != 44100 &&
  525.         /*  Layer 3 can sometimes switch bitrates */
  526.         !(Layer == 3 && /* !m_pStreamList->AudioLock() && */
  527.             (pbData[2] >> 4) == 0)) {
  529.         if (Layer == 1) {
  530.             pFormat->wfx.nBlockAlign = (WORD)
  531.                 (4 * ((pFormat->dwHeadBitrate * 12) / pFormat->wfx.nSamplesPerSec));
  532.         } else {
  533.             pFormat->wfx.nBlockAlign = (WORD)
  534.                 ((144 * pFormat->dwHeadBitrate) / pFormat->wfx.nSamplesPerSec);
  535.         }
  536.     } else {
  537.         pFormat->wfx.nBlockAlign = 1;
  538.     }
  541.     pFormat->wfx.wBitsPerSample = 0;
  542.     pFormat->wfx.cbSize = sizeof(MPEG1WAVEFORMAT) - sizeof(WAVEFORMATEX);
  544.     pFormat->dwPTSLow  = 0;
  545.     pFormat->dwPTSHigh = 0;
  547.     return TRUE;
  548. }
  550. BOOL GetClock(const BYTE * pData, LONGLONG *Clock)
  551. {
  552.     BYTE  Byte1 = pData[0];
  553.     DWORD Word2 = ((DWORD)pData[1] << 8) + (DWORD)pData[2];
  554.     DWORD Word3 = ((DWORD)pData[3] << 8) + (DWORD)pData[4];
  556.     /*  Do checks */
  557.     if ((Byte1 & 0xE0) != 0x20 ||
  558.         (Word2 & 1) != 1 ||
  559.         (Word3 & 1) != 1) {
  560.         DbgLog((LOG_TRACE, 2, TEXT("Invalid clock field - 0x%2.2X 0x%4.4X 0x%4.4X"),
  561.             Byte1, Word2, Word3));
  562.         return FALSE;
  563.     }
  565.     LARGE_INTEGER liClock;
  566.     liClock.HighPart = (Byte1 & 8) != 0;
  567.     liClock.LowPart  = (DWORD)((((DWORD)Byte1 & 0x6) << 29) +
  568.                        (((DWORD)Word2 & 0xFFFE) << 14) +
  569.                        ((DWORD)Word3 >> 1));
  571.     *Clock = liClock.QuadPart;
  573.     return TRUE;
  574. }
  576. BOOL SetClock(BYTE * pData, LONGLONG *Clock)
  577. {
  578.     LARGE_INTEGER liClock;
  579.     liClock.QuadPart = *Clock;
  581. BYTE Byte = ((BYTE)(liClock.HighPart & 1) << 3) + 
  582.  ((BYTE)(liClock.LowPart >> 29) & 0x06);
  583. pData[0] = (pData[0] & 0xf1 ) | Byte;
  585. Byte = (BYTE)(liClock.LowPart >> 22);
  586. pData[1] = Byte;
  588. Byte = (BYTE)(liClock.LowPart >> 14) & 0xfe;
  589. pData[2] = (pData[2] & 0x01) | Byte;
  591. Byte = (BYTE)(liClock.LowPart >> 7);
  592. pData[3] = Byte;
  594. Byte = (BYTE)(liClock.LowPart << 1) & 0xfe;
  595. pData[4] = (pData[4] &0x01) | Byte;
  597. /*
  598.     BYTE  Byte1 = pData[0];
  599.     DWORD Word2 = ((DWORD)pData[1] << 8) + (DWORD)pData[2];
  600.     DWORD Word3 = ((DWORD)pData[3] << 8) + (DWORD)pData[4];
  601. */
  602.     /*  Do checks */
  603. /*
  604.     if ((Byte1 & 0xE0) != 0x20 ||
  605.         (Word2 & 1) != 1 ||
  606.         (Word3 & 1) != 1) {
  607.         DbgLog((LOG_TRACE, 2, TEXT("Invalid clock field - 0x%2.2X 0x%4.4X 0x%4.4X"),
  608.             Byte1, Word2, Word3));
  609.         return FALSE;
  610.     }
  612.     liClock.HighPart = (Byte1 & 8) != 0;
  613.     liClock.LowPart  = (DWORD)((((DWORD)Byte1 & 0x6) << 29) +
  614.                        (((DWORD)Word2 & 0xFFFE) << 14) +
  615.                        ((DWORD)Word3 >> 1));
  617. */
  618.     return TRUE;
  619. }
  620. /*  Find the next start code */
  621. BOOL NextStartCode(const BYTE * *ppbData, DWORD *pdwLeft)
  622. {
  623.     const BYTE * pbData = *ppbData;
  624.     DWORD dwLeft = *pdwLeft;
  626.     while (dwLeft > 4 &&
  627.            (*(UNALIGNED DWORD *)pbData & 0x00FFFFFF) != 0x00010000) {
  628.         dwLeft--;
  629.         pbData++;
  630.     }
  631.     *ppbData = pbData;
  632.     *pdwLeft = dwLeft;
  633.     return dwLeft >= 4;
  634. }