fdk-aac 采用aac-ld解码

AAC-LD RAW 格式，配置参数为0xBC, 0x0D, 0x00, 0x00

#include "Audio_AAC.h"
#include "aacenc_lib.h"
#include "aacdecoder_lib.h"

struct Audio_AAC_Ptr
{
    unsigned char channels;
    unsigned char encode_type;
    unsigned char decode_type;
    unsigned short sampleRate;
    HANDLE_AACDECODER decoder;
    HANDLE_AACENCODER encoder;
};

struct Audio_AAC_Ptr aac_handle = {0};

int Audio_AAC_Init(unsigned short sampleRate, unsigned char channels, unsigned char encode_type, unsigned char decode_type)
{
    aac_handle.decoder = aacDecoder_Open(TT_MP4_RAW, 1);
    int conceal_method = 2;                     // 0 muting 1 noise 2 interpolation
    UCHAR ld_conf[] = {0xBC, 0x0D, 0x00, 0x00}; // mono ld 32k
    // 10111 1000 0001 2:LC 8:16khz 1:1channel
    UCHAR *conf[] = {ld_conf};
    static UINT conf_len = sizeof(ld_conf);
    AAC_DECODER_ERROR err = aacDecoder_ConfigRaw(aac_handle.decoder, conf, &conf_len);
    if (err > 0)
        printf("conf err: %d \n", err);
    aacDecoder_SetParam(aac_handle.decoder, AAC_CONCEAL_METHOD, conceal_method);
    aacDecoder_SetParam(aac_handle.decoder, AAC_PCM_MAX_OUTPUT_CHANNELS, 1); // MONO:1
    aacDecoder_SetParam(aac_handle.decoder, AAC_PCM_MIN_OUTPUT_CHANNELS, 1); // MONO:1

#if 1
    int bitrate = 64000;
    int aot = 2;
    int afterburner = 1;
    int eld_sbr = 0;
    int vbr = 0;
    CHANNEL_MODE mode;
    AACENC_InfoStruct info = {0};
    switch (channels)
    {
    case 1:
        mode = MODE_1;
        break;
    case 2:
        mode = MODE_2;
        break;
    case 3:
        mode = MODE_1_2;
        break;
    case 4:
        mode = MODE_1_2_1;
        break;
    case 5:
        mode = MODE_1_2_2;
        break;
    case 6:
        mode = MODE_1_2_2_1;
        break;
    default:
        printf("Unsupported WAV channels %d\n", channels);
        return 1;
    }
    if (aacEncOpen(&aac_handle.encoder, 0, channels) != AACENC_OK)
    {
        printf("Unable to open encoder\n");
        return 1;
    }
    if (aacEncoder_SetParam(aac_handle.encoder, AACENC_AOT, aot) != AACENC_OK)
    {
        printf("Unable to set the AOT\n");
        return 1;
    }
    if (aot == 39 && eld_sbr)
    {
        if (aacEncoder_SetParam(aac_handle.encoder, AACENC_SBR_MODE, 1) != AACENC_OK)
        {
            printf("Unable to set SBR mode for ELD\n");
            return 1;
        }
    }
    // if (aacEncoder_SetParam(aac_handle.encoder, AACENC_GRANULE_LENGTH, 480) != AACENC_OK)
    //{
    //     printf("Unable to set the bitrate\n");
    //     return 1;
    // }
    if (aacEncoder_SetParam(aac_handle.encoder, AACENC_SAMPLERATE, sampleRate) !=
        AACENC_OK)
    {
        printf("Unable to set the AOT\n");
        return 1;
    }
    if (aacEncoder_SetParam(aac_handle.encoder, AACENC_CHANNELMODE, mode) != AACENC_OK)
    {
        printf("Unable to set the channel mode\n");
        return 1;
    }
    if (aacEncoder_SetParam(aac_handle.encoder, AACENC_CHANNELORDER, 1) != AACENC_OK)
    {
        printf("Unable to set the wav channel order\n");
        return 1;
    }
    if (vbr)
    {
        if (aacEncoder_SetParam(aac_handle.encoder, AACENC_BITRATEMODE, vbr) != AACENC_OK)
        {
            printf("Unable to set the VBR bitrate mode\n");
            return 1;
        }
    }
    else
    {
        if (aacEncoder_SetParam(aac_handle.encoder, AACENC_BITRATE, bitrate) != AACENC_OK)
        {
            printf("Unable to set the bitrate\n");
            return 1;
        }
    }
    if (aacEncoder_SetParam(aac_handle.encoder, AACENC_TRANSMUX, TT_MP4_ADTS) != AACENC_OK)
    {
        printf("Unable to set the ADTS transmux\n");
        return 1;
    }
    if (aacEncoder_SetParam(aac_handle.encoder, AACENC_AFTERBURNER, afterburner) !=
        AACENC_OK)
    {
        printf("Unable to set the afterburner mode\n");
        return 1;
    }
    if (aacEncEncode(aac_handle.encoder, NULL, NULL, NULL, NULL) != AACENC_OK)
    {
        printf("Unable to initialize the encoder\n");
        return 1;
    }
    if (aacEncInfo(aac_handle.encoder, &info) != AACENC_OK)
    {
        printf("Unable to get the encoder info\n");
        return 1;
    }

#endif
}

int Audio_AAC_Deinit(void)
{
}

int Audio_AAC_EncodeFrame(char *pcmdata, int len, char *outbuf_aac, int *maxlen)
{
    AACENC_BufDesc in_buf = {0}, out_buf = {0};
    AACENC_InArgs in_args = {0};
    AACENC_OutArgs out_args = {0};
    int in_identifier = IN_AUDIO_DATA;
    int in_size, in_elem_size;
    int out_identifier = OUT_BITSTREAM_DATA;
    int out_size, out_elem_size;
    int read, i;
    void *in_ptr, *out_ptr;
    unsigned char outbuf[20480];
    AACENC_ERROR err;

    in_ptr = pcmdata;
    in_size = len;
    in_elem_size = 2;

    in_args.numInSamples = len <= 0 ? -1 : len / 2;

    in_buf.numBufs = 1;
    in_buf.bufs = &in_ptr;
    in_buf.bufferIdentifiers = &in_identifier;
    in_buf.bufSizes = &in_size;
    in_buf.bufElSizes = &in_elem_size;

    out_ptr = outbuf_aac;
    out_size = *maxlen;
    out_elem_size = 1;

    out_buf.numBufs = 1;
    out_buf.bufs = &out_ptr;
    out_buf.bufferIdentifiers = &out_identifier;
    out_buf.bufSizes = &out_size;
    out_buf.bufElSizes = &out_elem_size;

    if ((err = aacEncEncode(aac_handle.encoder, &in_buf, &out_buf, &in_args, &out_args)) != AACENC_OK)
    {
        if (err == AACENC_ENCODE_EOF)
        {
            printf("Encoding failed\n");
            return 1;
        }
    }
    *maxlen = out_args.numOutBytes;
    //printf("%d %d %d\n", out_args.numOutBytes, out_args.numInSamples, err);
}

int Audio_AAC_DecodeFrame(char *aacdata, int len, char *outbuf, int *maxlen)
{
    AAC_DECODER_ERROR err = aacDecoder_Fill(aac_handle.decoder, &aacdata, &len, &len);
    if (err > 0)
        printf("fill err: %d \n", err);
    err = aacDecoder_DecodeFrame(aac_handle.decoder, (INT_PCM *)outbuf, *maxlen / sizeof(INT_PCM), 0);
    if (err > 0)
        printf("dec err: %d \n", err);
    if (err != 0)
        return -1;
    CStreamInfo *info = aacDecoder_GetStreamInfo(aac_handle.decoder);
    // printf("%d %d\n",__LINE__,info->frameSize);
    *maxlen = info->frameSize * 2;
}