umc_avi_types.h

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2003-2005 Intel Corporation. All Rights Reserved.
//
*/

#ifndef __UMC_AVI_TYPES_H__
#define __UMC_AVI_TYPES_H__

#include "vm_types.h"
#include "umc_structures.h"
///////////////////////////////////////
//  Macros for AVI chunk names building
typedef vm_var32 tFOURCC;

#define uimcFOURCC DO_FOURCC

///////////////////////////////////////
#define AVI_FOURCC_WRONG        uimcFOURCC( 0,   0,   0,   0 )
#define AVI_FOURCC_ANY_         uimcFOURCC(0xFF,0xFF,0xFF,0xFF)
#define AVI_FOURCC_RIFF         uimcFOURCC('R', 'I', 'F', 'F')
#define AVI_FOURCC_AVI_         uimcFOURCC('A', 'V', 'I', ' ')
#define AVI_FOURCC_AVIX         uimcFOURCC('A', 'V', 'I', 'X')
#define AVI_FOURCC_LIST         uimcFOURCC('L', 'I', 'S', 'T')
#define AVI_FOURCC_JUNK         uimcFOURCC('J', 'U', 'N', 'K')
#define AVI_FOURCC_MOVI         uimcFOURCC('m', 'o', 'v', 'i')
#define AVI_FOURCC_STRMHDR      uimcFOURCC('s', 't', 'r', 'h')
#define AVI_FOURCC_VIDEOSTRM    uimcFOURCC('v', 'i', 'd', 's')
#define AVI_FOURCC_DVSD         uimcFOURCC('d', 'v', 's', 'd')
#define AVI_FOURCC_DSVD         uimcFOURCC('d', 's', 'v', 'd')
#define AVI_FOURCC_dv50         uimcFOURCC('d', 'v', '5', '0')
#define AVI_FOURCC_DV50         uimcFOURCC('D', 'V', '5', '0')
#define AVI_FOURCC_DVHD         uimcFOURCC('d', 'v', 'h', 'd')
#define AVI_FOURCC_DVSL         uimcFOURCC('d', 'v', 's', 'l')
#define AVI_FOURCC_SLDV         uimcFOURCC('S', 'L', 'D', 'V')
#define AVI_FOURCC_DSVD         uimcFOURCC('d', 's', 'v', 'd')
#define AVI_FOURCC_VIDV         uimcFOURCC('v', 'i', 'd', 'v')
#define AVI_FOURCC_STRMFMT      uimcFOURCC('s', 't', 'r', 'f')
#define AVI_FOURCC_IAVS         uimcFOURCC('i', 'a', 'v', 's')
#define AVI_FOURCC_AUDIOSTRM    uimcFOURCC('a', 'u', 'd', 's')
#define AVI_FOURCC_00DB         uimcFOURCC('0', '0', 'd', 'b')
#define AVI_FOURCC_00DC         uimcFOURCC('0', '0', 'd', 'c')
#define AVI_FOURCC_00WB         uimcFOURCC('0', '0', 'w', 'b')
#define AVI_FOURCC_DB           uimcFOURCC( 0,   0,  'd', 'b')
#define AVI_FOURCC_DC           uimcFOURCC( 0,   0,  'd', 'c')
#define AVI_FOURCC_WB           uimcFOURCC( 0,   0,  'w', 'b')
#define AVI_FOURCC_IDX1         uimcFOURCC('i', 'd', 'x', '1')
#define AVI_FOURCC_HDRL         uimcFOURCC('h', 'd', 'r', 'l')
#define AVI_FOURCC_AVIH         uimcFOURCC('a', 'v', 'i', 'h')
#define AVI_FOURCC_STRL         uimcFOURCC('s', 't', 'r', 'l')
#define AVI_FOURCC_STRH         uimcFOURCC('s', 't', 'r', 'h')
#define AVI_FOURCC_STRF         uimcFOURCC('s', 't', 'r', 'f')
#define AVI_FOURCC_IAVS         uimcFOURCC('i', 'a', 'v', 's')
#define AVI_FOURCC_REC_         uimcFOURCC('r', 'e', 'c', ' ')
#define AVI_FOURCC_ILV4         uimcFOURCC('I', 'L', 'V', '4')
#define AVI_FOURCC_VSSH         uimcFOURCC('V', 'S', 'S', 'H')
#define AVI_FOURCC_vssh         uimcFOURCC('v', 's', 's', 'h')
#define AVI_FOURCC_WMV3         uimcFOURCC('W', 'M', 'V', '3')

#define AVI_FOURCC_divx         uimcFOURCC('d', 'i', 'v', 'x')
#define AVI_FOURCC_DIVX         uimcFOURCC('D', 'I', 'V', 'X')
#define AVI_FOURCC_DX50         uimcFOURCC('D', 'X', '5', '0')

#define AVI_FOURCC_dx50         uimcFOURCC('d', 'x', '5', '0')
#define AVI_FOURCC_DIV4         uimcFOURCC('D', 'I', 'V', '4')
#define AVI_FOURCC_div4         uimcFOURCC('d', 'i', 'v', 'X')
#define AVI_FOURCC_XVID         uimcFOURCC('X', 'V', 'I', 'D')
#define AVI_FOURCC_xvid         uimcFOURCC('x', 'v', 'i', 'd')

#define AVI_FOURCC_MP4V         uimcFOURCC('M', 'P', '4', 'V')
#define AVI_FOURCC_mp4v         uimcFOURCC('m', 'p', '4', 'v')

#define AVI_FOURCC_MJPX         uimcFOURCC('M', 'J', 'P', 'X')
#define AVI_FOURCC_mjpx         uimcFOURCC('m', 'j', 'p', 'x')
#define AVI_FOURCC_MJPG         uimcFOURCC('M', 'J', 'P', 'G')
#define AVI_FOURCC_mjpg         uimcFOURCC('m', 'j', 'p', 'g')
#define AVI_FOURCC_dmb1         uimcFOURCC('d', 'm', 'b', '1')

#define AVI_FOURCC_H263         uimcFOURCC('H', '2', '6', '3')
#define AVI_FOURCC_h263         uimcFOURCC('h', '2', '6', '3')
#define AVI_FOURCC_I263         uimcFOURCC('I', '2', '6', '3')
#define AVI_FOURCC_i263         uimcFOURCC('i', '2', '6', '3')
#define AVI_FOURCC_M263         uimcFOURCC('M', '2', '6', '3')
#define AVI_FOURCC_m263         uimcFOURCC('m', '2', '6', '3')
#define AVI_FOURCC_VIVO         uimcFOURCC('V', 'I', 'V', 'O')
#define AVI_FOURCC_vivo         uimcFOURCC('v', 'i', 'v', 'o')

///////////////////////////////////////
#define  WAVE_FORMAT_MPEGLAYER3 0x0055  /*  ISO/MPEG Layer3 Format Tag */

#define WAVE_FORMAT_AAC         (0x5473)
#ifndef WAVE_FORMAT_PCM
#define WAVE_FORMAT_PCM     1
#endif  //  WAVE_FORMAT_PCM

///////////////////////////////////////
namespace UMC
{
    struct MainAVIHeader
    {
        vm_var32 uiMicroSecPerFrame;
        vm_var32 uiMaxBytesPerSec;
        vm_var32 uiReserved1;
        vm_var32 uiFlags;
        vm_var32 uiTotalFrames;
        vm_var32 uiInitialFrames;
        vm_var32 uiStreams;
        vm_var32 uiSuggestedBufferSize;
        vm_var32 uiWidth;
        vm_var32 uiHeight;
        vm_var32 uiReserved[4];
        inline void SwapBigEndian()
        {
            uiMicroSecPerFrame  = BIG_ENDIAN_SWAP32(uiMicroSecPerFrame);
            uiMaxBytesPerSec    = BIG_ENDIAN_SWAP32(uiMaxBytesPerSec);
            uiReserved1         = BIG_ENDIAN_SWAP32(uiReserved1);
            uiFlags             = BIG_ENDIAN_SWAP32(uiFlags);
            uiTotalFrames       = BIG_ENDIAN_SWAP32(uiTotalFrames);
            uiInitialFrames     = BIG_ENDIAN_SWAP32(uiInitialFrames);
            uiStreams           = BIG_ENDIAN_SWAP32(uiStreams);
            uiSuggestedBufferSize = BIG_ENDIAN_SWAP32(uiSuggestedBufferSize);
            uiWidth             = BIG_ENDIAN_SWAP32(uiWidth);
            uiHeight            = BIG_ENDIAN_SWAP32(uiHeight);
        }
    };

    struct AVIStreamHeader
    {
        vm_var32 fccType;
        vm_var32 fccHandler;
        vm_var32 uiFlags;
        vm_var32 uiPriority;
        vm_var32 uiInitialFrames;
        vm_var32 uiScale;
        vm_var32 uiRate;
        vm_var32 uiStart;
        vm_var32 uiLength;
        vm_var32 uiSuggestedBufferSize;
        vm_var32 uiQuality;
        vm_var32 uiSampleSize;
        UMC::RECT rcFrame;
        inline void SwapBigEndian()
        {
            fccType             = BIG_ENDIAN_SWAP32(fccType);
            fccHandler          = BIG_ENDIAN_SWAP32(fccHandler);
            uiFlags             = BIG_ENDIAN_SWAP32(uiFlags);
            uiPriority          = BIG_ENDIAN_SWAP32(uiPriority);
            uiInitialFrames     = BIG_ENDIAN_SWAP32(uiInitialFrames);
            uiScale             = BIG_ENDIAN_SWAP32(uiScale);
            uiRate              = BIG_ENDIAN_SWAP32(uiRate);
            uiStart             = BIG_ENDIAN_SWAP32(uiStart);
            uiLength            = BIG_ENDIAN_SWAP32(uiLength);
            uiSuggestedBufferSize = BIG_ENDIAN_SWAP32(uiSuggestedBufferSize);
            uiQuality           = BIG_ENDIAN_SWAP32(uiQuality);
            uiSampleSize        = BIG_ENDIAN_SWAP32(uiSampleSize);
            rcFrame.SwapBigEndian();
        }
    };

    struct BITMAPINFOHEADER
    {
        vm_var32    biSize;
        vm_var32    biWidth;
        vm_var32    biHeight;
        unsigned short  biPlanes;
        unsigned short  biBitCount;
        vm_var32    biCompression;
        vm_var32    biSizeImage;
        int         biXPelsPerMeter;
        int         biYPelsPerMeter;
        vm_var32    biClrUsed;
        vm_var32    biClrImportant;
        inline void SwapBigEndian()
        {
            biSize          = BIG_ENDIAN_SWAP32(biSize);
            biWidth         = BIG_ENDIAN_SWAP32(biWidth);
            biHeight        = BIG_ENDIAN_SWAP32(biHeight);
            biPlanes        = BIG_ENDIAN_SWAP16(biPlanes);
            biBitCount      = BIG_ENDIAN_SWAP16(biBitCount);
            biCompression   = BIG_ENDIAN_SWAP32(biCompression);
            biSizeImage     = BIG_ENDIAN_SWAP32(biSizeImage);
            biXPelsPerMeter = BIG_ENDIAN_SWAP32(biXPelsPerMeter);
            biYPelsPerMeter = BIG_ENDIAN_SWAP32(biYPelsPerMeter);
            biClrUsed       = BIG_ENDIAN_SWAP32(biClrUsed);
            biClrImportant  = BIG_ENDIAN_SWAP32(biClrImportant);
        }
    };

    struct WAVEFORMATEX
    {
        unsigned short  wFormatTag;
        unsigned short  nChannels;
        vm_var32 nSamplesPerSec;
        vm_var32 nAvgBytesPerSec;
        unsigned short  nBlockAlign;
        unsigned short  wBitsPerSample;
        unsigned short  cbSize;
        inline void SwapBigEndian()
        {
            wFormatTag      = BIG_ENDIAN_SWAP16(wFormatTag);
            nChannels       = BIG_ENDIAN_SWAP16(nChannels);
            nSamplesPerSec  = BIG_ENDIAN_SWAP32(nSamplesPerSec);
            nAvgBytesPerSec = BIG_ENDIAN_SWAP32(nAvgBytesPerSec);
            nBlockAlign     = BIG_ENDIAN_SWAP16(nBlockAlign);
            wBitsPerSample  = BIG_ENDIAN_SWAP16(wBitsPerSample);
            cbSize          = BIG_ENDIAN_SWAP16(cbSize);
        }
    };

    struct DVINFO {
        vm_var32 uiDVAAuxSrc;
        vm_var32 uiDVAAuxCtl;
        vm_var32 uiDVAAuxSrc1;
        vm_var32 uiDVAAuxCtl1;
        vm_var32 uiDVVAuxSrc;
        vm_var32 uiDVVAuxCtl;
        vm_var32 uiDVReserved[2];
    };
}  //  namespace UMC

#endif  //  __UMC_AVI_TYPES_H__