ADPCM编解码的使用

确实可以

已于 2023-06-30 10:40:38 修改

阅读量1.3k

点赞数

文章标签： adpcm 音视频 Powered by 金山文档

于 2023-06-30 10:35:36 首次发布

本文链接：https://blog.csdn.net/m0_57408211/article/details/129792066

版权

网上有很多讲解Adpcm编解码的，但是就没有详细说明其是需要如何使用的。

这里就记录下是如何使用代码的，即是函数的参数需要填写什么，要注意的要点。

ADPCM(Adaptive Differential Pulse Code Modulation)，是一种针对 16bits( 或8bits或者更高) 声音波形数据的一种有损压缩算法,它将声音流中每次采样的 16bit 数据以 4bit 存储,所以压缩比 1:4.

ADPCM数据存放形式

ADPCM的音频数据则是以块的形式保存，并且有固定的格式。每一个block包含header和data两部分。它在单声道下的定义如下:

typedef struct{ 
         short  sample0;    //block中第一个采样值（未压缩） 2个字节
         char  index;     //上一个block最后一个index，第一个block的index=0;
         char  reserved;   //尚未使用的
}MonoBlockHeader // 块的头部

前2个字节的为未压缩的原始16bit数据，第3个字节为上一个块的index,第4个字节为保留位(没有使用）。ADPCM每个数据块的解压需要前三个字节的数据作为解压函数的dec_state结构体参数输入到解压函数中。

对于双声道，它的blockheader应该包含两个MonoBlockHeader其定义如下：

typedef struct
{
    MonoBlockHeader leftbher;
    MonoBlockHeader rightbher;
}StereoBlockHeader;

对于双通道来说，在解压缩时，其是分开处理的，所以必须有两个MonoBlockHeader。

那么经过adpcm编码之后，其音频数据是按照一块一块数据存放的，一块的数据，其结构是

struct ADPCMBlock
{
    short sample0; //原始PCM采样数据
    char index;
    char RESERVED;
    char sampledata[252];    //这个就是进行adpcm编码之后的音频数据
};

这里的整个数据块大小是256字节，但这不是规定一定要这个值的，可以由自己来定的。

很多文章只是给了编码和解码函数，没有完整的调用过程，这里面还是有点细节要注意，要注意每个块的index 和 sample0的填充。

adpcm的编解码文件

adpcm.h文件

/*
** adpcm.h - include file for adpcm coder.
**
** Version 1.0, 7-Jul-92.
*/

#ifndef ADPCM_H
#define ADPCM_H

#ifdef __cplusplus
extern "C" {
#endif

    struct adpcm_state {
        short    valprev;    /* Previous output value */
        char    index;        /* Index into stepsize table */
    };

    //len 是采样点的个数，不是字节大小
    int adpcm_coder(short* indata, char* outdata, int len, struct adpcm_state* state);
    int adpcm_decoder(char* indata, short* outdata, int len, struct adpcm_state* state);

#ifdef __cplusplus
}  /* extern "C" */
#endif

#endif /* ADPCM_H*/

adpcm.c文件

/*
** Intel/DVI ADPCM coder/decoder.
**
** The algorithm for this coder was taken from the IMA Compatability Project
** proceedings, Vol 2, Number 2; May 1992.
**
** Version 1.2, 18-Dec-92.
**
** Change log:
** - Fixed a stupid bug, where the delta was computed as
**   stepsize*code/4 in stead of stepsize*(code+0.5)/4.
** - There was an off-by-one error causing it to pick
**   an incorrect delta once in a blue moon.
** - The NODIVMUL define has been removed. Computations are now always done
**   using shifts, adds and subtracts. It turned out that, because the standard
**   is defined using shift/add/subtract, you needed bits of fixup code
**   (because the div/mul simulation using shift/add/sub made some rounding
**   errors that real div/mul don't make) and all together the resultant code
**   ran slower than just using the shifts all the time.
** - Changed some of the variable names to be more meaningful.
*/

#include "adpcm.h"

/* Intel ADPCM step variation table */
static int indexTable[16] = {
    -1, -1, -1, -1, 2, 4, 6, 8,
    -1, -1, -1, -1, 2, 4, 6, 8,
};

static int stepsizeTable[89] = {
    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
};


int adpcm_coder(short* indata, char* outdata, int len, struct adpcm_state* state)
{
    int val;   /* Current input sample value */
    unsigned int delta; /* Current adpcm output value */
    int diff;   /* Difference between val and valprev */
    int step;         /* Stepsize */
    int valpred;  /* Predicted output value */
    int vpdiff;         /* Current change to valpred */
    int index;   /* Current step change index */
    unsigned int outputbuffer = 0;/* place to keep previous 4-bit value */
    int count = 0;      /* the number of bytes encoded */

    valpred = state->valprev;
    index = (int)state->index;
    step = stepsizeTable[index];

    while (len > 0) {
        /* Step 1 - compute difference with previous value */
        val = *indata++;
        diff = val - valpred;
        if (diff < 0)
        {
            delta = 8;
            diff = (-diff);
        }
        else
        {
            delta = 0;
        }

        /* Step 2 - Divide and clamp */
        /* Note:
        ** This code *approximately* computes:
        **    delta = diff*4/step;
        **    vpdiff = (delta+0.5)*step/4;
        ** but in shift step bits are dropped. The net result of this is
        ** that even if you have fast mul/div hardware you cannot put it to
        ** good use since the fixup would be too expensive.
        */
        vpdiff = (step >> 3);

        if (diff >= step) {
            delta |= 4;
            diff -= step;
            vpdiff += step;
        }
        step >>= 1;
        if (diff >= step) {
            delta |= 2;
            diff -= step;
            vpdiff += step;
        }
        step >>= 1;
        if (diff >= step) {
            delta |= 1;
            vpdiff += step;
        }

        /* Phil Frisbie combined steps 3 and 4 */
        /* Step 3 - Update previous value */
        /* Step 4 - Clamp previous value to 16 bits */
        if ((delta & 8) != 0)
        {
            valpred -= vpdiff;
            if (valpred < -32768)
                valpred = -32768;
        }
        else
        {
            valpred += vpdiff;
            if (valpred > 32767)
                valpred = 32767;
        }

        /* Step 5 - Assemble value, update index and step values */
        index += indexTable[delta];
        if (index < 0) index = 0;
        else if (index > 88) index = 88;
        step = stepsizeTable[index];

        /* Step 6 - Output value */
        outputbuffer = (delta << 4);

        /* Step 1 - compute difference with previous value */
        val = *indata++;
        diff = val - valpred;
        if (diff < 0)
        {
            delta = 8;
            diff = (-diff);
        }
        else
        {
            delta = 0;
        }

        /* Step 2 - Divide and clamp */
        /* Note:
        ** This code *approximately* computes:
        **    delta = diff*4/step;
        **    vpdiff = (delta+0.5)*step/4;
        ** but in shift step bits are dropped. The net result of this is
        ** that even if you have fast mul/div hardware you cannot put it to
        ** good use since the fixup would be too expensive.
        */
        vpdiff = (step >> 3);

        if (diff >= step) {
            delta |= 4;
            diff -= step;
            vpdiff += step;
        }
        step >>= 1;
        if (diff >= step) {
            delta |= 2;
            diff -= step;
            vpdiff += step;
        }
        step >>= 1;
        if (diff >= step) {
            delta |= 1;
            vpdiff += step;
        }

        /* Phil Frisbie combined steps 3 and 4 */
        /* Step 3 - Update previous value */
        /* Step 4 - Clamp previous value to 16 bits */
        if ((delta & 8) != 0)
        {
            valpred -= vpdiff;
            if (valpred < -32768)
                valpred = -32768;
        }
        else
        {
            valpred += vpdiff;
            if (valpred > 32767)
                valpred = 32767;
        }

        /* Step 5 - Assemble value, update index and step values */
        index += indexTable[delta];
        if (index < 0) index = 0;
        else if (index > 88) index = 88;
        step = stepsizeTable[index];

        /* Step 6 - Output value */
        *outdata++ = (unsigned char)(delta | outputbuffer);
        count++;
        len -= 2;
    }

    state->valprev = (short)valpred;
    state->index = (char)index;

    return count;
}

// 解码
int adpcm_decoder(char* indata, short* outdata, int len, struct adpcm_state* state)
{
    unsigned int delta; /* Current adpcm output value */
    int step;         /* Stepsize */
    int valpred;  /* Predicted value */
    int vpdiff;         /* Current change to valpred */
    int index;   /* Current step change index */
    unsigned int inputbuffer = 0;/* place to keep next 4-bit value */
    int count = 0;

    valpred = state->valprev;
    index = (int)state->index;
    step = stepsizeTable[index];

    /* Loop unrolling by Phil Frisbie */
    /* This assumes there are ALWAYS an even number of samples */
    while (len-- > 0) {
 
        /* Step 1 - get the delta value */
        inputbuffer = (unsigned int)*indata++;
        delta = (inputbuffer >> 4) & 0xf;// &0xf 防止溢出
      
        /* Step 2 - Find new index value (for later) */
  
        index += indexTable[delta];
        if (index < 0) index = 0;
        else if (index > 88) index = 88;
     


        /* Phil Frisbie combined steps 3, 4, and 5 */
        /* Step 3 - Separate sign and magnitude */
        /* Step 4 - Compute difference and new predicted value */
        /* Step 5 - clamp output value */
        /*
        ** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
        ** in adpcm_coder.
        */
        vpdiff = step >> 3;
        if ((delta & 4) != 0) vpdiff += step;
        if ((delta & 2) != 0) vpdiff += step >> 1;
        if ((delta & 1) != 0) vpdiff += step >> 2;

        if ((delta & 8) != 0)
        {
            valpred -= vpdiff;
            if (valpred < -32768)
                valpred = -32768;
        }
        else
        {
            valpred += vpdiff;
            if (valpred > 32767)
                valpred = 32767;
        }

        /* Step 6 - Update step value */
        step = stepsizeTable[index];

        /* Step 7 - Output value */
        *outdata++ = (short)valpred;

        /* Step 1 - get the delta value */
        delta = inputbuffer & 0xf;

        /* Step 2 - Find new index value (for later) */
        index += indexTable[delta];
        if (index < 0) index = 0;
        else if (index > 88) index = 88;

        /* Phil Frisbie combined steps 3, 4, and 5 */
        /* Step 3 - Separate sign and magnitude */
        /* Step 4 - Compute difference and new predicted value */
        /* Step 5 - clamp output value */
        /*
        ** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
        ** in adpcm_coder.
        */
        vpdiff = step >> 3;
        if ((delta & 4) != 0) vpdiff += step;
        if ((delta & 2) != 0) vpdiff += step >> 1;
        if ((delta & 1) != 0) vpdiff += step >> 2;

        if ((delta & 8) != 0)
        {
            valpred -= vpdiff;
            if (valpred < -32768)
                valpred = -32768;
        }
        else
        {
            valpred += vpdiff;
            if (valpred > 32767)
                valpred = 32767;
        }

        /* Step 6 - Update step value */
        step = stepsizeTable[index];

        /* Step 7 - Output value */
        *outdata++ = (short)valpred;
        count += 2;
    }

    state->valprev = (short)valpred;
    state->index = (char)index;

    return count;
}

使用编解码的方式

场景：现在有一pcm音频文件，需要把这个整段pcm音频进行adpcm编码，而每个adpcm块的大小是256字节。这里说的都是单通道的。双通道可能会有其他的不同。（主要是我做的是单通道的。。）

struct ADPCMBlock
{
    short sample0;
    char index;
    char RESERVED;
    char sampledata[252];
};

进行apdcm编码

那么需要从pcm文件中读取数据，那是应该读取多少呢，是一次性读取完还是分次读取呢。

是需要分次读取，因为需要把pcm数据刚好可以编码成一个个adpcm块(或者就一个adpcm块）。这里我们定下来adpcm块大小是256字节，一个块中的压缩后的adpcm音频数据是252字节，压缩比是1:4，所以原始pcm数据大小是252*4=1008.

而块头部还有2字节的原始pcm数据，所以需要每次从文件读取1008+2=1010字节来进行编码。

函数：int adpcm_coder(short* indata, char* outdata, int len, struct adpcm_state* state)

我们是需要直接保存首两个字节的原始pcm数据的，所以而在使用adpcm_coder函数时候，第一个参数那里就需要从第三个字节开始进行编码的。又因为是short*类型，所以是第一个参数写reinterpret_cast<short*>(&buf[2])。

第三个参数len不是进行编码的数据长度，是需要编码的采集点个数，因为每个采集点是short类型的，所以其个数是总长度/2，而又需要去掉首两个字节的原始pcm数据，所以其是(readdatasize - 2) / 2。

可以看出，这进行编解码的数据长度大小要一定是偶数的才行。

第四个参数是adpcm_state*类型state，该函数内部会更新参数state，其主要就是更新其成员valprev和index。

要是最后的要进行编码的数据编码后不够一个块大小，也要按照一个块大小编码，保存长度为1block。

int pcmToAdpcm(const char* PcmFileName,const char* outFileName)
{
    FILE* inFile = fopen(PcmFileName, "rb");
    if (!inFile) {
        return 0;
    }
    fseek(inFile, 0L, SEEK_END);  //到达文件的末尾
    int pcmSize = ftell(inFile);//返回给定流 stream 的当前文件位置，这样pcmSize就是文件的大小

    fseek(inFile, 0L, SEEK_SET);

    int totalblocks = 0;    //总的adpcm块的个数
    int curBlockNum = 0;    //已编码的adpcm块的个数
    int readUnitSize = 1010;    //每次从文件读取的字节大小，
    //为什么是1010呢，因为之前定了adpcm块是256字节的，一个块中的压缩后的adpcm音频数据是252字节，压缩比是1:4，所以原始pcm数据大小是252*4=1008.
    //而块头部还有2字节的原始pcm数据，所以需要每次从文件读取1008+2=1010字节来进行编码

    //计算出中的block的个数
    if (pcmSize % readUnitSize == 0)
        totalblocks = pcmSize / readUnitSize;
    else
        totalblocks = pcmSize / readUnitSize + 1;

    FILE* outFile = fopen(outFileName, "wb");
    char buf[1024];

    adpcm_state adpcmState;
    ADPCMBlock block;
    
    //下面的while循环内部的是adpcm编码操作的重点
    while (curBlockNum < totalblocks) {
        if (curBlockNum == 0)
            block.index = 0;
        else
            block.index = adpcmState.index;

        int readdatasize = fread(buf, 1, readUnitSize, inFile);   //从input_fd文件读取readUnitSize字节

        block.sample0 = (static_cast<short>(buf[1]) << 8) | buf[0];       //获取原始的2字节pcm数据
        block.RESERVED = 0;
        state.valprev = block.sample0;
        adpcm_coder(reinterpret_cast<short*>(&buf[2]), block.sampledata, (readdatasize - 2) / 2, &adpcmState);//convert the remain 504 sample points;

        fwrite(&block, 1, sizeof(block), outFile);

       ++curBlockNum;
    }

    fclose(inFile);
    fclose(outFile);
}

进行adpcm解码

int adpcm_decoder(char* indata, short* outdata, int len, struct adpcm_state* state)。

第一个参数事adpcm块数据，前四个字节是头部，所以第一个参数写buf+4,从第五字节开始解码。

第二个参数是解码后的pcm数据。

第三个参数是adpcm块数据的长度，这个就真的是长度的。使用的时候需要减去头部4字节，所以使用方式是readdatasize - 4。

第四个参数是adpcm_state*类型state，该函数内部会更新参数state，其主要就是更新state.index。

其函数的返回值是解码后的pcm数据点的个数，即是有多少个short数据点。所以最终解码后的pcm数据长度是count*2。

int AdpcmToPcm(const char* adpcmFileName, const char* outFileName)
{
    FILE* inFile = fopen(adpcmFileName, "rb");
    if (!inFile) {
        std::cout << " open input file failed\n";
        return 0;
    }
    fseek(inFile, 0L, SEEK_END);  //到达文件的末尾
    int pcmSize = ftell(inFile);//返回给定流 stream 的当前文件位置，这样pcmSize就是文件的大小

    fseek(inFile, 0L, SEEK_SET);

    int totalblocks = 0;    //总的adpcm块的个数
    int curBlockNum = 0;    //已解码的adpcm块的个数
    int blockSize = sizeof(ADPCMBlock);

    //计算出中的block的个数
    if (pcmSize % readUnitSize == 0)
        totalblocks = pcmSize / blockSize;
    else
        totalblocks = pcmSize / blockSize + 1;

    FILE* outFile = fopen(outFileName, "wb");

    short pcmBuf[1024];
    char buf[1024];
    adpcm_state adpcmState;

    //下面的while循环内部的是adpcm编码操作的重点
    while (curBlockNum < totalblocks)
    {
        if (blockcnt == 0) 
            adpcmState.index = 0;
        else 
            adpcmState.index = buf[2];

        memset(buf, 0, sizeof(buf));
        int readdatasize = fread(buf, 1, blockSize, inFile);//从文件读取adpcm块数据

        pcmBuf[0] = static_cast<short>(buf[1]) << 8 | buf[0];   //得到原始的2字节pcm数据
        
        state.valprev = pcmBuf[0];
        int count = adpcm_decoder(&buf[4], &pcmBuf[1], readdatasize - 4, &adpcmState);//返回值是采集点的个数

        fwrite(pcmBuf, 1,count * 2 , outFile);  //每个采集点是short类型的，总长度就是count*2
        ++curBlockNum;
    }

    fclose(inFile);
    fclose(outFile);
}