使用libfdk-aac解码AAC-ELD格式的音频

最新推荐文章于 2024-05-25 16:03:14 发布

wuyu92877

最新推荐文章于 2024-05-25 16:03:14 发布

阅读量2.5k

点赞数

分类专栏：流媒体开发文章标签： AAC-ELD

流媒体开发专栏收录该内容

6 篇文章 2 订阅

订阅专栏

前段时间尝试在XBMC的框架中添加对Airplay Screen Mirror的功能，有关Airplay的协议可以参考（当然是第三方破解的）

http://nto.github.com/AirPlay.html

本文指针对AAC-ELD音频的解析做一定说明，对于Airplay Screen Mirror本身暂不扩展。

如果是普通的AAC音频，自然可以使用FAAD的库进行解码，或者直接使用ffmpeg，网上有很多的资料，不过FAAD解不了AAC-ELD等级的AAC音频。

但问题有两点，第一是流媒体的格式的音频，也就是没有文件封装格式，流媒体本身是通过RTSP来传递一些配置信息，再利用RTP来传输数据。

第二，AAC-ELD的编码格式，目前能参考的资料不多，不过最新版的ffmepg(>ffmpeg-1.0)或者libav，已经支持了AAC-ELD格式的编码，可以

查看libavcodec目录下是否有libfdk-aacenc.c文件，其实本质是添加了对libfdk-aac音频库的支持，不过遗憾的是没有提供解码的代码。

其实，有关libfdk-aac解码的代码是有的，只是ffmepg没有将其吸纳进来，可以参考github上第三方修改的libav库，地址是

https://github.com/Arcen/libav

同时fdk-aac的库地址是

https://github.com/Arcen/fdk-aac

可以看出libavcodec目录下已经有了libfdk-aacdec.c文件，网友可以自行下载编译，找一个音频文件，先将其转换成AAC-ELD格式的音频，然后在尝试解码。

编码的命令可以参考这种格式

ffmpeg -y -i test.wav -c libfdk_aac -profile:a aac_eld test.mp4

（注意：ffmpeg对于编码一般都采用第三方的库，例如x264等，但解码，ffmpeg本身会调用自己重写的解码代码，所以不一定就能够调用到libfdk-aac来解码

AAC-ELD格式的音频，我当时是修改了ffmpeg的注册模块，强制利用fdk-aac来解码aac的音频来验证的）

以上解决的是文件封装的AAC-ELD音频，可以很容易验证，但对于RTP过来的裸音频数据，就要了解一下AAC的知识了，其中最最重要的是MPEG标准中规定，AAC

格式的音频需要一个AudioSpecificConfig配置，如果你上面生成了mp4文件，就可以利用mp4info.exe这个工具查看esds字段（路径大概在trac->media->

->minf->stbl->stsd->m4a->esds），然后可以参照esds的语法查找相应的AudioSpecificConfig字段。

下面贴一段参考代码，直接利用的fdk-aac的库，在ubuntu上运行的代码

（大概的流程是，有个线程在往队列里面填充数据，然后通过SDL播放，SDL的回调函数会去队列中取音频数据，然后调用fdk-aac解码，然后播放）

[cpp] view plain copy print ?

/*
* decode AAC-ELD audio data from mac by XBMC, and play it by SDL
*
* modify:
* 2012-10-31 first version (ffmpeg tutorial03.c)
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <SDL/SDL_thread.h>
#include <fdk-aac/aacdecoder_lib.h>
#include "decodeAAC.h"
#ifdef __MINGW32__
#undef main /* Prevents SDL from overriding main() */
#endif
typedef unsigned char u8;
typedef unsigned short int u16;
typedef unsigned int u32;
/* ---------------------------------------------------------- */
/* enable file save, test pcm source */
/* ---------------------------------------------------------- */
//#define ENABLE_PCM_SAVE
#ifdef ENABLE_PCM_SAVE
FILE *pout = NULL;
#endif
/* ---------------------------------------------------------- */
/* next n lines is libfdk-aac config */
/* ---------------------------------------------------------- */
static int fdk_flags = 0;
/* period size 480 samples */
#define N_SAMPLE 480
/* ASC config binary data */
UCHAR eld_conf[] = { 0xF8, 0xE8, 0x50, 0x00 };
UCHAR *conf[] = { eld_conf }; //TODO just for aac eld config
static UINT conf_len = sizeof(eld_conf);
static HANDLE_AACDECODER phandle = NULL;
static TRANSPORT_TYPE transportFmt = 0; //raw data format
static UINT nrOfLayers = 1; //only one layer here
static CStreamInfo *aac_stream_info = NULL;
static int pcm_pkt_size = 4 * N_SAMPLE;
/* ---------------------------------------------------------- */
/* AAC data and queue list struct definition */
/* ---------------------------------------------------------- */
static int quit = 0;
#define FDK_MAX_AUDIO_FRAME_SIZE 192000 //1 second of 48khz 32bit audio
#define SDL_AUDIO_BUFFER_SIZE 4 * N_SAMPLE
#define PCM_RATE 44100
#define PCM_CHANNEL 2
typedef struct AACPacket {
unsigned char *data;
unsigned int size;
} AACPacket;
typedef struct AACPacketList {
AACPacket pkt;
struct AACPacketList *next;
} AACPacketList;
typedef struct PacketQueue {
AACPacketList *first_pkt, *last_pkt;
int nb_packets;
int size;
SDL_mutex *mutex;
SDL_cond *cond;
} PacketQueue;
static PacketQueue audioq;
/* ---------------------------------------------------------- */
/* local memcpy malloc */
/* ---------------------------------------------------------- */
/* for local memcpy malloc */
#define AAC_BUFFER_SIZE 1024 * 1024
#define THRESHOLD 1 * 1024
static u8 repo[AAC_BUFFER_SIZE] = {0};
static u8 *repo_ptr = NULL;
/*
* init mem repo
*/
static void init_mem_repo(void)
{
repo_ptr = repo;
}
/*
* alloc input pkt buffer from input_aac_data[]
*/
static void *alloc_pkt_buf(void)
{
int space;
space = AAC_BUFFER_SIZE - (repo_ptr - repo);
if (space < THRESHOLD) {
repo_ptr = repo;
return repo;
}
return repo_ptr;
}
static void set_pkt_size(int size)
{
repo_ptr += size;
}
/* ---------------------------------------------------------- */
static void packet_queue_init(PacketQueue *q)
{
memset(q, 0, sizeof(PacketQueue));
q->mutex = SDL_CreateMutex();
q->cond = SDL_CreateCond();
}
static int fdk_dup_packet(AACPacket *pkt)
{
u8 *repo_ptr;
repo_ptr = alloc_pkt_buf();
memcpy(repo_ptr, pkt->data, pkt->size);
pkt->data = repo_ptr;
set_pkt_size(pkt->size);
return 0;
}
static int packet_queue_put(PacketQueue *q, AACPacket *pkt)
{
//fprintf(stderr, "p");
AACPacketList *pkt1;
/* memcpy data from xbmc */
fdk_dup_packet(pkt);
pkt1 = malloc(sizeof(AACPacketList));
if (!pkt1)
return -1;
pkt1->pkt = *pkt;
pkt1->next = NULL;
SDL_LockMutex(q->mutex);
if (!q->last_pkt)
q->first_pkt = pkt1;
else
q->last_pkt->next = pkt1;
q->last_pkt = pkt1;
q->nb_packets++;
q->size += pkt1->pkt.size;
SDL_CondSignal(q->cond);
SDL_UnlockMutex(q->mutex);
return 0;
}
/*
* called by external, aac data input queue
*/
int decode_copy_aac_data(u8 *data, int size)
{
AACPacket pkt;
pkt.data = data;
pkt.size = size;
packet_queue_put(&audioq, &pkt);
return 0;
}
static int packet_queue_get(PacketQueue *q, AACPacket *pkt, int block)
{
//fprintf(stderr, "g");
AACPacketList *pkt1;
int ret;
SDL_LockMutex(q->mutex);
for (;;) {
if (quit) {
ret = -1;
break;
}
pkt1 = q->first_pkt;
if (pkt1) {
q->first_pkt = pkt1->next;
if (!q->first_pkt)
q->last_pkt = NULL;
q->nb_packets--;
q->size -= pkt1->pkt.size;
*pkt = pkt1->pkt;
free(pkt1);
ret = 1;
break;
} else if (!block) {
ret = 0;
break;
} else {
SDL_CondWait(q->cond, q->mutex);
}
}
SDL_UnlockMutex(q->mutex);
//fprintf(stderr, "o");
return ret;
}
/*
* decoding AAC format audio data by libfdk_aac
*/
int fdk_decode_audio(INT_PCM *output_buf, int *output_size, u8 *buffer, int size)
{
int ret = 0;
int pkt_size = size;
UINT valid_size = size;
UCHAR *input_buf[1] = {buffer};
/* step 1 -> fill aac_data_buf to decoder's internal buf */
ret = aacDecoder_Fill(phandle, input_buf, &pkt_size, &valid_size);
if (ret != AAC_DEC_OK) {
fprintf(stderr, "Fill failed: %x\n", ret);
*output_size = 0;
return 0;
}
/* step 2 -> call decoder function */
ret = aacDecoder_DecodeFrame(phandle, output_buf, pcm_pkt_size, fdk_flags);
if (ret == AAC_DEC_NOT_ENOUGH_BITS) {
fprintf(stderr, "not enough\n");
*output_size = 0;
/*
* TODO FIXME
* if not enough, get more data
*
*/
}
if (ret != AAC_DEC_OK) {
fprintf(stderr, "aacDecoder_DecodeFrame : 0x%x\n", ret);
*output_size = 0;
return 0;
}
*output_size = pcm_pkt_size;
#ifdef ENABLE_PCM_SAVE
fwrite((u8 *)output_buf, 1, pcm_pkt_size, pout);
#endif
/* return aac decode size */
return (size - valid_size);
}
int audio_decode_frame(uint8_t *audio_buf, int buf_size)
{
static AACPacket pkt;
static uint8_t *audio_pkt_data = NULL;
static int audio_pkt_size = 0;
int len1, data_size;
for (;;) {
while (audio_pkt_size > 0) {
data_size = buf_size;
len1 = fdk_decode_audio((INT_PCM *)audio_buf, &data_size,
audio_pkt_data, audio_pkt_size);
if (len1 < 0) {
/* if error, skip frame */
audio_pkt_size = 0;
break;
}
audio_pkt_data += len1;
audio_pkt_size -= len1;
if (data_size <= 0) {
/* No data yet, get more frames */
continue;
}
/* We have data, return it and come back for more later */
//fprintf(stderr, "\ndata size = %d\n", data_size);
return data_size;
}
/* FIXME
* add by juguofeng
* only no nead in this code, because we alloc a memcpy ourselves
*/
//if(pkt.data)
// free(pkt.data);
if (quit) {
return -1;
}
if (packet_queue_get(&audioq, &pkt, 1) < 0) {
return -1;
}
audio_pkt_data = pkt.data;
audio_pkt_size = pkt.size;
}
}
void audio_callback(void *userdata, Uint8 *stream, int len)
{
int len1, audio_size;
static uint8_t audio_buf[(FDK_MAX_AUDIO_FRAME_SIZE * 3) / 2];
static unsigned int audio_buf_size = 0;
static unsigned int audio_buf_index = 0;
//fprintf(stderr, "callback len = %d\n", len);
while (len > 0) {
if (audio_buf_index >= audio_buf_size) {
//fprintf(stderr, "c");
/* We have already sent all our data; get more */
audio_size = audio_decode_frame(audio_buf, sizeof(audio_buf));
if (audio_size < 0) {
/* If error, output silence */
audio_buf_size = pcm_pkt_size; // arbitrary?
memset(audio_buf, 0, audio_buf_size);
} else {
audio_buf_size = audio_size;
}
audio_buf_index = 0;
}
len1 = audio_buf_size - audio_buf_index;
if (len1 > len)
len1 = len;
memcpy(stream, (uint8_t *)audio_buf + audio_buf_index, len1);
len -= len1;
stream += len1;
audio_buf_index += len1;
}
}
/*
* init fdk decoder
*/
void init_fdk_decoder(void)
{
int ret = 0;
phandle = aacDecoder_Open(transportFmt, nrOfLayers);
if (phandle == NULL) {
printf("aacDecoder open faild!\n");
exit(0);
}
printf("conf_len = %d\n", conf_len);
ret = aacDecoder_ConfigRaw(phandle, conf, &conf_len);
if (ret != AAC_DEC_OK) {
fprintf(stderr, "Unable to set configRaw\n");
exit(0);
}
aac_stream_info = aacDecoder_GetStreamInfo(phandle);
if (aac_stream_info == NULL) {
printf("aacDecoder_GetStreamInfo failed!\n");
exit(0);
}
printf("> stream info: channel = %d\tsample_rate = %d\tframe_size = %d\taot = %d\tbitrate = %d\n", \
aac_stream_info->channelConfig, aac_stream_info->aacSampleRate,
aac_stream_info->aacSamplesPerFrame, aac_stream_info->aot, aac_stream_info->bitRate);
}
/*
* first init func, called by external
*/
void init_fdk_aac_decode(void)
{
SDL_Event event;
SDL_AudioSpec wanted_spec, spec;
/* init fdk decoder */
init_fdk_decoder();
init_mem_repo();
/* video have already inited in the video decoder */
//if (SDL_Init(SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
// fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
// exit(1);
//}
#ifdef ENABLE_PCM_SAVE
pout = fopen("/home/juguofeng/work/star.pcm", "wb");
if (pout == NULL) {
fprintf(stderr, "open star.pcm file failed!\n");
exit(1);
}
#endif
// Set audio settings from codec info
wanted_spec.freq = PCM_RATE;
wanted_spec.format = AUDIO_S16SYS;
wanted_spec.channels = PCM_CHANNEL;
wanted_spec.silence = 0;
wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
wanted_spec.callback = audio_callback;
wanted_spec.userdata = NULL;
if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
//return -1;
exit(1);
}
packet_queue_init(&audioq);
SDL_PauseAudio(0);
//packet_queue_put(&audioq, &packet);
#if 0
SDL_PollEvent(&event);
switch(event.type) {
case SDL_QUIT:
quit = 1;
SDL_Quit();
exit(0);
break;
default:
break;
}
#endif
//exit(1);
//return 0;
}

使用时，可以利用一下接口

void init_fdk_aac_decode(void);

int decode_copy_aac_data(unsigned char *inbuf, int size);

特别注意的是，RTP流中的AAC-ELD音频是裸数据，而解码器需要AudioSpecificConfig信息，这里我是自己事先知道了这个值。

由于离这个项目有段时间了，现在才将其罗列在这里，有些细节不是交代的很清楚，日后有空慢慢补充。

（当时由于对流媒体和mpeg4等标准不是很熟，走了很多的弯路，并且fdk-aac本身的教程只有文档说明，并没有一个

代码实例，同时我实现的又是流媒体音频，所以有些坎坷，知道看到了第三方的libav中有了对AAC-ELD的解码支持的代码，

在了解了AudioSpecificConfig的含义后，才成功解码了RTP中的AAC-ELD音频流）

wuyu92877

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
使用libfdk-aac解码AAC-ELD格式的音频

前段时间尝试在XBMC的框架中添加对Airplay Screen Mirror的功能，有关Airplay的协议可以参考（当然是第三方破解的）http://nto.github.com/AirPlay.html本文指针对AAC-ELD音频的解析做一定说明，对于Airplay Screen Mirror本身暂不扩展。如果是普通的AAC音频，自然可以使用FAAD的库进行解码，或者直接
复制链接

扫一扫

专栏目录