VFW 生成AVI 音視訊檔案

//.h
#include <windows.h>  
#include <vfw.h> 

class CAviFile  
{  
public:  
    CAviFile();  
    ~CAviFile(void);  

    HRESULT Open(LPCSTR lpszFileName, DWORD dwCodec, DWORD dwFPS, INT nWidth, INT nHeight, INT nQuality, INT nKeyFrame);  

    HRESULT Close(void);  

    HRESULT AppendNewFrame(int nWidth, int nHeight, LPVOID pBits, int nBitsPerPixel);  
    HRESULT AppendAudio(long pData,long pDataLen);

private:  
    HRESULT AppendFrame(int, int, LPVOID, int);

private:  
    LONG                m_lSample;
    LONG                m_audioSample;

    PAVIFILE            m_pAviFile;  
    PAVISTREAM          m_pAviStream;
    PAVISTREAM          m_pAviCompressedStream;
    PAVISTREAM          m_pAviAudioStream;

    BOOL                m_bStatus;  
}; 

//.cpp

#include "StdAfx.h"  
#include "avifile.h"  

#pragma comment( lib, "vfw32.lib" )  

CAviFile:: CAviFile()  
{  
    m_bStatus     = FALSE;  
    m_lSample     = ;  
    m_pAviFile    = NULL;  
    m_pAviStream  = NULL;  
}  
CAviFile::~CAviFile(void)  
{  
    Close();  
}  

HRESULT CAviFile::Open(LPCSTR lpszFileName, DWORD dwCodec, DWORD dwFPS, INT nWidth, INT nHeight, INT nQuality, INT nKeyFrame)  
{  
    if (m_bStatus)  
    {  
        return S_OK;  
    }

    AVIFileInit();  
    if(FAILED(AVIFileOpen(&m_pAviFile, lpszFileName, OF_CREATE | OF_WRITE, NULL)))  
    {  
        printf("file opened false");
        return E_FAIL;  
    } 

    AVISTREAMINFO AviStreamInfo;  
    ZeroMemory(&AviStreamInfo, sizeof(AVISTREAMINFO));  
    AviStreamInfo.fccType                 = streamtypeVIDEO;
    AviStreamInfo.fccHandler              = dwCodec;  
    AviStreamInfo.dwScale                 = ;  
    AviStreamInfo.dwRate                  = dwFPS;  
    //AviStreamInfo.dwQuality             = m_nQuality;  
    AviStreamInfo.dwSuggestedBufferSize = nWidth * nHeight * ;  
    SetRect(&AviStreamInfo.rcFrame, , , nWidth, nHeight);  
    lstrcpy(AviStreamInfo.szName, "VideoStream");  
    if(FAILED(AVIFileCreateStream(m_pAviFile, &m_pAviStream, &AviStreamInfo)))  
    {  
        return E_FAIL;  
    }  

    AVICOMPRESSOPTIONS  AviCompressOptions;  
    ZeroMemory(&AviCompressOptions, sizeof(AVICOMPRESSOPTIONS));  
    AviCompressOptions.fccType          = streamtypeVIDEO;  
    AviCompressOptions.fccHandler       = AviStreamInfo.fccHandler;  
    AviCompressOptions.dwFlags          = AVICOMPRESSF_KEYFRAMES | AVICOMPRESSF_VALID;//|AVICOMPRESSF_DATARATE;  
    AviCompressOptions.dwKeyFrameEvery  = nKeyFrame;  
    //AviCompressOptions.dwBytesPerSecond = 0;  
    AviCompressOptions.dwQuality        = nQuality;  
    if(FAILED(AVIMakeCompressedStream(&m_pAviCompressedStream, m_pAviStream, &AviCompressOptions, NULL)))  
    {  
        return E_FAIL;  
    }

    AVISTREAMINFO AviStreamAudioInfo;
    ZeroMemory(&AviStreamAudioInfo,sizeof(AVISTREAMINFO));
    AviStreamAudioInfo.fccType   = streamtypeAUDIO;
    AviStreamAudioInfo.dwScale   = ;
    AviStreamAudioInfo.dwSampleSize    = ;
    AviStreamAudioInfo.dwRate    = ;
    AviStreamAudioInfo.dwSuggestedBufferSize  = ;
    if(FAILED(AVIFileCreateStream(m_pAviFile, &m_pAviAudioStream, (AVISTREAMINFO*)&AviStreamAudioInfo)))  
    {  
        return E_FAIL;  
    } 

    m_bStatus = TRUE;  

    return S_OK;  
}  
HRESULT CAviFile::Close(void)  
{  
    if (!m_bStatus)  
    {  
        return S_OK;  
    }  

    m_bStatus = FALSE;  
    m_lSample = ;  

    if(m_pAviCompressedStream)  
    {  
        AVIStreamRelease(m_pAviCompressedStream);  
        m_pAviCompressedStream = NULL;  
    }  

    if(m_pAviStream)  
    {  
        AVIStreamRelease(m_pAviStream);  
        m_pAviStream = NULL;  
    }

    if(m_pAviAudioStream)
    {
        AVIStreamRelease(m_pAviAudioStream);
        m_pAviAudioStream = NULL;
    }

    if(m_pAviFile)  
    {  
        AVIFileRelease(m_pAviFile);  
        m_pAviFile = NULL;  
    }

    AVIFileExit();  
    return S_OK;  
}  
HRESULT CAviFile::AppendNewFrame(int nWidth, int nHeight, LPVOID pBits,int nBitsPerPixel)  
{  
    return AppendFrame(nWidth, nHeight, pBits, nBitsPerPixel);  
}  

HRESULT CAviFile::AppendFrame(int nWidth, int nHeight, LPVOID pBits,int nBitsPerPixel)  
{  
    if (!m_bStatus)  
    {  
        return E_FAIL;  
    } 

    BITMAPINFO bmpInfo;  
    ZeroMemory(&bmpInfo, sizeof(BITMAPINFO));  
    bmpInfo.bmiHeader.biPlanes      = ;  
    bmpInfo.bmiHeader.biWidth       = nWidth;  
    bmpInfo.bmiHeader.biHeight      = nHeight;  
    bmpInfo.bmiHeader.biCompression = BI_RGB;  
    bmpInfo.bmiHeader.biBitCount    = ;  
    bmpInfo.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);  
    bmpInfo.bmiHeader.biSizeImage   = bmpInfo.bmiHeader.biWidth * bmpInfo.bmiHeader.biHeight * bmpInfo.bmiHeader.biBitCount / ;  
    if(FAILED(AVIStreamSetFormat(m_pAviCompressedStream, m_lSample, (LPVOID)&bmpInfo, bmpInfo.bmiHeader.biSize)))  
    {  
        return E_FAIL;  
    }  

    return AVIStreamWrite(m_pAviCompressedStream, m_lSample++, , pBits, (nWidth * nHeight * nBitsPerPixel), , NULL, NULL);
}

HRESULT CAviFile::AppendAudio(long pData,long pDataLen)
{
    if (!m_bStatus)  
    {  
        return E_FAIL;  
    }

    WAVEFORMATEX waveInfo;
    ZeroMemory(&waveInfo, sizeof(WAVEFORMAT));
    waveInfo.wFormatTag = ;
    waveInfo.nChannels = ;
    waveInfo.nSamplesPerSec = ;
    waveInfo.nAvgBytesPerSec = ;
    waveInfo.nBlockAlign = ;
    waveInfo.wBitsPerSample = ;
    waveInfo.cbSize = sizeof(WAVEFORMATEX);

    if(FAILED(AVIStreamSetFormat(m_pAviAudioStream, m_audioSample, (LPVOID)&waveInfo, sizeof(WAVEFORMATEX))))  
    {  
        return E_FAIL;  
    }

    return AVIStreamWrite(m_pAviAudioStream,m_audioSample++,,(PBYTE)pData,pDataLen,,NULL,NULL);
}


//初始化
CAviFile m_videoRecord;
CString strFile =  _T("c:\\1.avi");  
if (FAILED(m_videoRecord.Open(strFile, mmioFOURCC('x','v','i','d'), , , ,  * , )))  
{  
    printf("false");
    return;  
}

//寫入
m_videoRecord.AppendNewFrame(, , (PBYTE*)pData, ); 

m_videoRecord.AppendAudio(pData,nDataLen);

//結束
m_videoRecord.Close();