dv_il_audio.cpp

这是在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.
//
*/

#include "vm_debug.h"
#include "dv_il_audio.h"
#include "umc_structures.h"

using namespace UMC;

const vm_var32 cDifBlockSize = 80;
const vm_var32 cDifSeqSize = 150 * cDifBlockSize;

UMC::Status
FindAAUXInFrame(unsigned char* pucDVFrame, NDVAudioIL::DV_AAUX*& rpPACK)
{
    UMC::Status umcRes = UMC_OK;
    rpPACK = (NDVAudioIL::DV_AAUX*)(pucDVFrame + cDifBlockSize * 6);

    if (0x60 != (rpPACK->uiID & 0xE0))
    {    umcRes = UMC_BAD_STREAM;    }

    if (UMC_OK == umcRes && 0x50000000 != (rpPACK->uiID & 0xFF000000))
    {    rpPACK = (NDVAudioIL::DV_AAUX*)(pucDVFrame + cDifBlockSize * 54);    }

    if (UMC_OK == umcRes && 0x50000060 != (rpPACK->uiID & 0xFF0000E0))
    {    umcRes = UMC_BAD_STREAM;    }

    return umcRes;
}

UMC::Status
NDVAudioIL::GetDVAudioSize(unsigned char* pucDVFrame,
                             vm_var32 uiDVFrameSize,
                             vm_var32& ruiFrameAudioDataSize,
                             vm_var32& ruiBitsPerSample,
                             bool& rb625)
{
    assert(NULL != pucDVFrame);

    //    Refer pointer to the first Audio DIF block in first DIF seq
    DV_AAUX* pPACK = NULL;
    UMC::Status umcRes = FindAAUXInFrame(pucDVFrame, pPACK);

    if (UMC_OK == umcRes) {
        rb625 = (1 == pPACK->pack.Fmt_50_60);

        switch (pPACK->pack.SamplingFreq) {
        case 0:
            ruiFrameAudioDataSize = 1580 + pPACK->pack.AFrameSize;
            if ( rb625 && ruiFrameAudioDataSize > 1944 )
            {    ruiFrameAudioDataSize = 1944;    }
            else if (!rb625 && ruiFrameAudioDataSize > 1620)
            {    ruiFrameAudioDataSize = 1620;    }
            break;
        case 1:
            ruiFrameAudioDataSize = 1452 + pPACK->pack.AFrameSize;
            if (rb625 && ruiFrameAudioDataSize > 1786)
            {    ruiFrameAudioDataSize = 1786;    }
            else if (!rb625 && ruiFrameAudioDataSize > 1498)
            {    ruiFrameAudioDataSize = 1498;    }
            break;
        case 2:
            ruiFrameAudioDataSize = 1053 + pPACK->pack.AFrameSize;
            if (rb625 && ruiFrameAudioDataSize > 1296)
            {    ruiFrameAudioDataSize = 1296;    }
            else if (!rb625 && ruiFrameAudioDataSize > 1080)
            {    ruiFrameAudioDataSize = 1080;    }
            break;
        default: umcRes = UMC_BAD_STREAM;
        }

        ruiFrameAudioDataSize *= 2/*bytes ter sample*/;
        if (1 == pPACK->pack.Channels) {
            ruiFrameAudioDataSize *= 2/*stereo*/;
        }

        switch (pPACK->pack.QU) {
        case 0: ruiBitsPerSample = 16; break;
        case 1: ruiBitsPerSample = 12; break;
        default:  umcRes = UMC_BAD_STREAM;
        }

        //    Check if Video type (625/525) corresponds with frame size
        assert(UMC_OK != umcRes || (rb625 && 144000 == uiDVFrameSize ||
                                            !rb625 && 120000 == uiDVFrameSize));
    }

    return umcRes;
}

UMC::Status
NDVAudioIL::GetDVAudioFormat(unsigned char* pucDVFrame,
                             vm_var32 /*uiDVFrameSize*/,
                             sAudioStreamInfo& rAudioInfo)
{
    //    Refer pointer to the first Audio DIF block in first DIF seq
    DV_AAUX* pPACK = NULL;
    UMC::Status umcRes = FindAAUXInFrame(pucDVFrame, pPACK);

    if (UMC_OK == umcRes) {
        switch (pPACK->pack.SamplingFreq) {
        case 0:    rAudioInfo.sample_frequency = 48000;    break;
        case 1:    rAudioInfo.sample_frequency = 44100;    break;
        case 2:    rAudioInfo.sample_frequency = 32000;    break;
        default: umcRes = UMC_BAD_STREAM;
        }

        switch (pPACK->pack.Channels) {
        case 0: rAudioInfo.channels = 1; break;
        case 1: rAudioInfo.channels = 2; break;
        default: umcRes = UMC_BAD_STREAM;
        }

        rAudioInfo.bitPerSample = 16;          // 0 if compressed
        rAudioInfo.bitrate =
            rAudioInfo.bitPerSample * rAudioInfo.sample_frequency;
        rAudioInfo.stream_type = PCM_AUDIO;
    }

    return umcRes;
}

inline vm_var32
DVAudioByteOffset(vm_var32 uiDifSeqNum, vm_var32 uiABlockNum, vm_var32 uiBytePos)
{
    return uiDifSeqNum * cDifSeqSize +
            (6 + uiABlockNum * 16) * cDifBlockSize + uiBytePos;
}

inline vm_var32
BytePos_CH1_525_16(vm_var32 uiNum)
{
    vm_var32 uiTrackNum = ((uiNum/3) + 2 * (uiNum % 3)) % 5;
    vm_var32 uiABlockNum = 3 * (uiNum % 3) + (uiNum % 45) / 15;
    vm_var32 uiBytePos = 8 + 2 * (uiNum / 45);
    return DVAudioByteOffset(uiTrackNum, uiABlockNum, uiBytePos);
}

inline vm_var32
BytePos_CH1_625_16(vm_var32 uiNum)
{
    vm_var32 uiTrackNum = ((uiNum/3) + 2 * (uiNum % 3)) % 6;
    vm_var32 uiABlockNum = 3 * (uiNum % 3) + (uiNum % 54) / 18;
    vm_var32 uiBytePos = 8 + 2 * (uiNum / 54);
    return DVAudioByteOffset(uiTrackNum, uiABlockNum, uiBytePos);
}

inline vm_var32
BytePos_CH1_525_12(vm_var32 uiNum)
{
    vm_var32 uiTrackNum = ((uiNum/3) + 2 * (uiNum % 3)) % 5;
    vm_var32 uiABlockNum = 3 * (uiNum % 3) + (uiNum % 45) / 15;
    vm_var32 uiBytePos = 8 + 3 * (uiNum / 45);
    return DVAudioByteOffset(uiTrackNum, uiABlockNum, uiBytePos);
}

inline vm_var32
BytePos_CH1_625_12(vm_var32 uiNum)
{
    vm_var32 uiTrackNum = ((uiNum/3) + 2 * (uiNum % 3)) % 6;
    vm_var32 uiABlockNum = 3 * (uiNum % 3) + (uiNum % 54) / 18;
    vm_var32 uiBytePos = 8 + 3 * (uiNum / 54);
    return DVAudioByteOffset(uiTrackNum, uiABlockNum, uiBytePos);
}

short
Convert12to16(short Y)
{
    short X = static_cast<short>((Y << 4) >> 4);    //    extend sign
    if (511 >= X && -512 <= X) return X;
    else if (  767 >= X &&   512 <= X)
    {   return static_cast<short>((X -  256) << 1); }
    else if ( -513 >= X &&  -768 <= X)
    {   return static_cast<short>((X +  257) << 1); }
    else if ( 1024 >= X &&   768 <= X)
    {   return static_cast<short>((X -  512) << 2); }
    else if ( -769 >= X && -1024 <= X)
    {   return static_cast<short>((X +  513) << 2); }
    else if ( 1279 >= X &&  1024 <= X)
    {   return static_cast<short>((X -  768) << 3); }
    else if (-1025 >= X && -1280 <= X)
    {   return static_cast<short>((X +  769) << 3); }
    else if ( 1535 >= X &&  1280 <= X)
    {   return static_cast<short>((X - 1024) << 4); }
    else if (-1281 >= X && -1536 <= X)
    {   return static_cast<short>((X + 1025) << 4); }
    else if ( 1791 >= X &&  1536 <= X)
    {   return static_cast<short>((X - 1280) << 5); }
    else if (-1537 >= X && -1792 <= X)
    {   return static_cast<short>((X + 1281) << 5); }
    else if ( 2047 >= X &&  1792 <= X)
    {   return static_cast<short>((X - 1536) << 6); }
    else if (-1793 >= X && -2048 <= X)
    {   return static_cast<short>((X + 1537) << 6); }
    else {    assert(false); return -1;    }
}

typedef void (*tExtractProc)(unsigned char* pucDVFrame,
                            unsigned char* pucAudioBuf,
                            vm_var32 uiAudiioBufSize);

void
ExtractAudio625_16(unsigned char* pucDVFrame,
                   unsigned char* pucAudioBuf,
                   vm_var32 uiAudiioBufSize)
{
    for (vm_var32 i = 0; i < uiAudiioBufSize; i++)
    {
        unsigned short usSrc =
                    *(unsigned short*)(pucDVFrame + BytePos_CH1_625_16(i));
        ((unsigned short*)pucAudioBuf)[i] =
                    static_cast<unsigned short>((usSrc >> 8) | (usSrc << 8));
    }
}

void
ExtractAudio525_16(unsigned char* pucDVFrame,
                   unsigned char* pucAudioBuf,
                   vm_var32 uiAudioBufSize)
{
    for (vm_var32 i = 0; i < uiAudioBufSize; i++) {
        unsigned short usSrc =
                    *(unsigned short*)(pucDVFrame + BytePos_CH1_525_16(i));
        ((unsigned short*)pucAudioBuf)[i] =
                    static_cast<unsigned short>((usSrc >> 8) | (usSrc << 8));
    }
}

void
ExtractAudio625_12(unsigned char* pucDVFrame,
                   unsigned char* pucAudioBuf,
                   vm_var32 uiAudioBufSize)
{
    for (vm_var32 i = 0; i < uiAudioBufSize; i += 2) {
        int X = *(int*)(pucDVFrame + BytePos_CH1_625_12(i/2));
        int Y = (X << 4) & 0xFF0 | (X >> 20) & 0xF;
        int Z = (X >> 4) & 0xFF0 | (X >> 16) & 0xF;
        ((short*)pucAudioBuf)[i] =
            Convert12to16(static_cast<unsigned short>((Y << 20) >> 20));
        ((short*)pucAudioBuf)[i+1] =
            Convert12to16(static_cast<unsigned short>((Z << 20) >> 20));
    }
}

void
ExtractAudio525_12(unsigned char* pucDVFrame,
                   unsigned char* pucAudioBuf,
                   vm_var32 uiAudioBufSize)
{
    for (vm_var32 i = 0; i < uiAudioBufSize; i += 2) {
        int X = *(int*)(pucDVFrame + BytePos_CH1_525_12(i/2));
        int Y = (X << 4) & 0xFF0 | (X >> 20) & 0xF;
        int Z = (X >> 4) & 0xFF0 | (X >> 16) & 0xF;
        ((short*)pucAudioBuf)[i] =
            Convert12to16(static_cast<unsigned short>((Y << 20) >> 20));
        ((short*)pucAudioBuf)[i+1] =
            Convert12to16(static_cast<unsigned short>((Z << 20) >> 20));
    }
}

UMC::Status
NDVAudioIL::ExtractDVAudio(unsigned char* pucDVFrame,
                            vm_var32 uiFrameSize,
                            unsigned char* pucAudioBuf,
                            vm_var32 uiAudioBufSize,
                            vm_var32& ruiReturnSize)
{
    assert(NULL != pucDVFrame);
    assert(0 != uiFrameSize);
    assert(NULL != pucAudioBuf);
    assert(0 != uiAudioBufSize);

    vm_var32 uiBitsPerSample = 0;
    bool b625 = false;

    UMC::Status umcRes = GetDVAudioSize(pucDVFrame, uiFrameSize,
                                        ruiReturnSize, uiBitsPerSample, b625);
    tExtractProc ExtractProc = NULL;
    if (UMC_OK == umcRes) {
        if (b625) {
            if (16 == uiBitsPerSample) ExtractProc = ExtractAudio625_16;
            else if (12 == uiBitsPerSample) ExtractProc = ExtractAudio625_12;
        } else {
            if (16 == uiBitsPerSample) ExtractProc = ExtractAudio525_16;
            else if (12 == uiBitsPerSample) ExtractProc = ExtractAudio525_12;
        }

        if (NULL != ExtractProc)
        {    ExtractProc(pucDVFrame, pucAudioBuf, ruiReturnSize / sizeof(short));    }
    }
    return umcRes;
}