硬核音频系列（二）—— 音频文件编解码格式 ADPCM

static inline int16_t adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
{
    int predictor;

    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
    predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;

    c->sample2 = c->sample1;
    c->sample1 = av_clip_int16(predictor);
    c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
    if (c->idelta < 16) c->idelta = 16;
    if (c->idelta > INT_MAX/768) {
        av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");
        c->idelta = INT_MAX/768;
    }

    return c->sample1;
}

static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt) 
{
    AVFrame *frame     = data;  
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
    ADPCMDecodeContext *c = avctx->priv_data;
    ADPCMChannelStatus *cs;
    int n, m, channel, i;
    int16_t *samples;
    int16_t **samples_p;
    int st; /* stereo */
    int count1, count2;
    int nb_samples, coded_samples, approx_nb_samples, ret;
    GetByteContext gb;

    bytestream2_init(&gb, buf, buf_size);
    nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);
    if (nb_samples <= 0) {
        av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
        return AVERROR_INVALIDDATA;
    }

    /* get output buffer */
    frame->nb_samples = nb_samples;
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)  
        return ret;
    samples = (int16_t *)frame->data[0];
    samples_p = (int16_t **)frame->extended_data;

    /* use coded_samples when applicable */
    /* it is always <= nb_samples, so the output buffer will be large enough */
    if (coded_samples) {
        if (!approx_nb_samples && coded_samples != nb_samples)
            av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
        frame->nb_samples = nb_samples = coded_samples;
    }

    st = avctx->channels == 2 ? 1 : 0;

    int block_predictor;

    block_predictor = bytestream2_get_byteu(&gb);
    if (block_predictor > 6) {
        av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
                block_predictor);
        return AVERROR_INVALIDDATA;
    }
    c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor]; 
    c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor]; 
    if (st) {
        block_predictor = bytestream2_get_byteu(&gb);
        if (block_predictor > 6) {
            av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
                    block_predictor);
            return AVERROR_INVALIDDATA;
        }
        c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
        c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
    }
    c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16); 
    if (st){
        c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);
    }

    c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
    if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);
    c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);
    if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);

    *samples++ = c->status[0].sample2;
    if (st) *samples++ = c->status[1].sample2;
    *samples++ = c->status[0].sample1;
    if (st) *samples++ = c->status[1].sample1;
    for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
        int byte = bytestream2_get_byteu(&gb);
        *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4  );
        *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);
    }

    if (avpkt->size && bytestream2_tell(&gb) == 0) {
        av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");
        return AVERROR_INVALIDDATA;
    }

    *got_frame_ptr = 1;

    if (avpkt->size < bytestream2_tell(&gb)) {
        av_log(avctx, AV_LOG_ERROR, "Overread of %d < %d\n", avpkt->size, bytestream2_tell(&gb));
        return avpkt->size;
    }

    return bytestream2_tell(&gb);
}

#include <stdint.h>
#include <string.h>
#include <limits.h>

#include "lib_adpcm.h"

/* These are for MS-ADPCM */
/* ff_adpcm_AdaptationTable[], ff_adpcm_AdaptCoeff1[], and
   ff_adpcm_AdaptCoeff2[] are from libsndfile */
const int16_t adpcm_AdaptationTable[] = {
    230, 230, 230, 230, 307, 409, 512, 614,
    768, 614, 512, 409, 307, 230, 230, 230
};

/** Divided by 4 to fit in 8-bit integers */
const uint8_t adpcm_AdaptCoeff1[] = {
    64, 128, 0, 48, 60, 115, 98
};

/** Divided by 4 to fit in 8-bit integers */
const int8_t adpcm_AdaptCoeff2[] = {
    0, -64, 0, 16, 0, -52, -58
};

static const int av_clip_int16(int a)
{
    if (a > 32767)
    {
        a = 32767;
    }
    else if (a < -32768)
    {
        a = -32768;
    }

    return a;
}

static int16_t adpcm_ms_expand_nibble(adpcm_block_info *block_info, int nibble)
{
    int predictor;

    predictor = (((block_info->sample1) * (block_info->coeff1)) + ((block_info->sample2) * (block_info->coeff2))) / 64;
    predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * block_info->delta;

    block_info->sample2 = block_info->sample1;
    block_info->sample1 = av_clip_int16(predictor);
    block_info->delta = (adpcm_AdaptationTable[(int)nibble] * block_info->delta) >> 8;
    if (block_info->delta < 16) block_info->delta = 16;
    if (block_info->delta > INT_MAX/768) {
        printf("[adpcm]%s:%d idelta overflow\n", __FUNCTION__, __LINE__);
        block_info->delta = INT_MAX/768;
    }

    return block_info->sample1;
}

int adpcm_decode_block(int16_t *output, uint8_t *input, adpcm_block_info *block_info)
{
    uint8_t *read_ptr = RT_NULL;
    uint32_t nb_samples = 0;
    int n;

    block_info->block_predictor = *input;
    block_info->delta = (int16_t)input[2] << 8 | input[1] ;
    block_info->sample1 = (int16_t)input[4] << 8 | input[3];
    block_info->sample2 = (int16_t)input[6] << 8 | input[5];
    block_info->nibbles_prt = &input[7];

    read_ptr = block_info->nibbles_prt;
    nb_samples = (ADPCM_BLOCK_SIZE-6)*2;
    if (block_info->block_predictor > 6) {
        printf("[adpcm]%s:%d ERROR: block_info->block_predictor = %d\n", __FUNCTION__, __LINE__,
                block_info->block_predictor);
        return -1;
    }

    block_info->coeff1 = adpcm_AdaptCoeff1[block_info->block_predictor];
    block_info->coeff2 = adpcm_AdaptCoeff2[block_info->block_predictor];

    *output++ = block_info->sample2;
    *output++ = block_info->sample1;

    for(n = (nb_samples - 2) / 2; n > 0; n--) 
    {
        int byte = *read_ptr;
        *output++ = adpcm_ms_expand_nibble(block_info, byte >> 4  );
        *output++ = adpcm_ms_expand_nibble(block_info, byte & 0x0F);
        read_ptr++;
    }

    return nb_samples*sizeof(int16_t);
}

#define ADPCM_BLOCK_SIZE        1024
#define PLAY_ADPCM_READ_SIZE    ADPCM_BLOCK_SIZE
#define PLAY_BUFFER_SIZE        PLAY_ADPCM_READ_SIZE*4

int main()
{
    ...
    // 打开文件、解析 WAV 容器
    while (1)
    {
        memset(read_buffer, 0, PLAY_ADPCM_READ_SIZE);
        memset(write_buffer, 0, PLAY_BUFFER_SIZE);
        read_size = fread(read_buffer, 1, PLAY_ADPCM_READ_SIZE, fp);
        if (read_size == 0)
            break;
        decode_byte = adpcm_decode_block((int16_t*)write_buffer, (uint8_t*)read_buffer, &b_info);
        sound_device_write(dev, 0, write_buffer, decode_byte); // 解码后的 PCM 数据写入声卡设备播放
    }
    // 关闭文件、释放资源
    ...
}