音频demo：使用faad2将AAC数据解码出PCM数据_aac解码成pcm faad库

1、README

前言

本demo是使用的开源项目faad2将aac数据解码成pcm数据。

a. 编译使用

faad2的编译：(faad2下载地址：https://sourceforge.net/projects/faac/files/faad2-src/faad2-2.8.0/)

tar xzf faad2-2.8.8.tar.gz
cd faad2-2.8.8/
./configure --prefix=$PWD/_install
make
make install
1
2
3
4
5

demo的编译使用：

$ make clean && make
$ 
$ ./aac2pcm 
Usage:
    ./aac2pcm <in aac file> <out pcm file>
Examples:
    ./aac2pcm ./audio/test1_44100_stereo.aac  out1_44100_16bit_stereo.pcm
    ./aac2pcm ./audio/test2_8000_mono.aac     out2_16000_16bit_stereo.pcm  # output [samplerate] and [channels] will be auto configured.
1
2
3
4
5
6
7
8

b. 参考文章

• 用faad解码AAC(ADTS封装)_gavinr的博客-CSDN博客_faad解码aac

c. demo目录架构

$ tree
.
├── aac_adts.c
├── aac_adts.h
├── audio
│   ├── out1_44100_16bit_stereo.pcm
│   ├── out2_16000_16bit_stereo.pcm
│   ├── test1_44100_stereo.aac
│   └── test2_8000_mono.aac
├── docs
│   └── 用faad解码AAC(ADTS封装)_gavinr的博客-CSDN博客_faad解码aac.mhtml
├── include
│   ├── faad.h
│   └── neaacdec.h
├── lib
│   └── libfaad.a
├── main.c
├── Makefile
└── README.md
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2、主要代码片段

aac_adts.c

#include "aac_adts.h"


int getAdtsFrame(FILE *fp, uint8_t *pAdtsFrameData, T_AdtsHeader *ptAdtsHeaderInfo)
{
	uint32_t readBytes = 0;

	if(!fp || !pAdtsFrameData || !ptAdtsHeaderInfo)
		return -1;

	// ADTS header size is AAC_ADTS_HEADER_SIZE(=7) bytes
	readBytes = fread(pAdtsFrameData, 1, AAC_ADTS_HEADER_SIZE, fp);
	if(readBytes <= 0)
		return -2;

	ptAdtsHeaderInfo->syncword              = (pAdtsFrameData[0] << 4 ) | (pAdtsFrameData[1]  >> 4);
	ptAdtsHeaderInfo->id                    = (pAdtsFrameData[1] & 0x08) >> 3;
	ptAdtsHeaderInfo->layer                 = (pAdtsFrameData[1] & 0x06) >> 1;
	ptAdtsHeaderInfo->protection_absent     =  pAdtsFrameData[1] & 0x01;
	ptAdtsHeaderInfo->profile               = (pAdtsFrameData[2] & 0xc0) >> 6;
	ptAdtsHeaderInfo->sampling_freq_index   = (pAdtsFrameData[2] & 0x3c) >> 2;
	ptAdtsHeaderInfo->private_bit           = (pAdtsFrameData[2] & 0x02) >> 1;
	ptAdtsHeaderInfo->channel_configuration = (((pAdtsFrameData[2] & 0x01) << 2) | ((pAdtsFrameData[3] & 0xc0) >> 6));
	ptAdtsHeaderInfo->original_copy         = (pAdtsFrameData[3] & 0x20) >> 5;
	ptAdtsHeaderInfo->home                  = (pAdtsFrameData[3] & 0x10) >> 4;
	ptAdtsHeaderInfo->copyright_identification_bit   = (pAdtsFrameData[3] & 0x08) >> 3;
	ptAdtsHeaderInfo->copyright_identification_start = (pAdtsFrameData[3] & 0x04) >> 2;
	ptAdtsHeaderInfo->aac_frame_length = ((pAdtsFrameData[3] & 0x03) << 11) |
										 ((pAdtsFrameData[4] & 0xFF) << 3) |
										 ((pAdtsFrameData[5] & 0xE0) >> 5);
	ptAdtsHeaderInfo->adts_buffer_fullness = ((pAdtsFrameData[5] & 0x1f) << 6 | (pAdtsFrameData[6] & 0xfc) >> 2);
	ptAdtsHeaderInfo->number_of_raw_data_blocks_in_frame = (pAdtsFrameData[6] & 0x03);

	if (ptAdtsHeaderInfo->syncword != 0xFFF)
		return -3;

	/* read the remaining frame of ADTS data outside the AAC_ADTS_HEADER_SIZE(=7) bytes header,
	 * and it should be written after offsetting the header by AAC_ADTS_HEADER_SIZE(=7) bytes
	 */
	readBytes = fread(pAdtsFrameData + AAC_ADTS_HEADER_SIZE, 1, ptAdtsHeaderInfo->aac_frame_length - AAC_ADTS_HEADER_SIZE, fp);
	if(readBytes <= 0)
		return -4;

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

aac_adts.h

#ifndef __AAC_ADTS_H__
#define __AAC_ADTS_H__

#include <stdio.h>
#include <stdint.h>


#define AAC_ADTS_HEADER_SIZE 	(7)

#define MAX_ADTS_SIZE 			(1024) /* 1K Bytes */


typedef enum{
    MPEG_4 = 0x0,
    MPEG_2 = 0x1,
}aac_id_t;


typedef enum{
    SFI_96000 = 0x0,
    SFI_88200 = 0x1,
    SFI_64000 = 0x2,
    SFI_48000 = 0x3,
    SFI_44100 = 0x4,
    SFI_32000 = 0x5,
    SFI_24000 = 0x6,
    SFI_22050 = 0x7,
    SFI_16000 = 0x8,
    SFI_12000 = 0x9,
    SFI_11025 = 0xa,
    SFI_8000  = 0xb,
    SFI_7350  = 0xc,
    SFI_ERROR = 0xd,
}sampling_freq_index_t;


/* AAC(ADTS) Header element member.
 * [Note: It is not stored as defined type size!!!]
 */
typedef struct{
	/* fixed header */
    uint32_t syncword;              // 12bit  '1111 1111 1111' is stand by ADTS frame
    uint32_t id;                    // 1 bit  0 for MPEG-4, 1 for MPEG-2
    uint32_t layer;                 // 2 bit  always '00'
    uint32_t protection_absent;     // 1 bit  1 not crc, 0 have crc 1
    uint32_t profile;               // 2 bit  AAC profile, '01' for AAC-LC
    uint32_t sampling_freq_index;   // 4 bit  reference to 'sampling_freq_index_t'
    uint32_t private_bit;           // 1 bit  always '0'
    uint32_t channel_configuration; // 3 bit  channels count
    uint32_t original_copy;         // 1 bit  always '0'
    uint32_t home;                  // 1 bit

    /* varible header */
    uint32_t copyright_identification_bit;   // 1 bit  always '0'
    uint32_t copyright_identification_start; // 1 bit  always '0'
    uint32_t aac_frame_length;               // 13bit  length of [adts header] + [adts data]
    uint32_t adts_buffer_fullness;           // 11bit  0x7FF stand by varible bit rate
    uint32_t number_of_raw_data_blocks_in_frame;  // 2 bit  always '00', number of AAC Frames(RDBs) in ADTS frame minus 1
}T_AdtsHeader, *PT_AdtsHeader;



/************************************************************************
 * function describe: get one frame aac(adts, include adts header) from
 *                    aac file.
 * params:
 *   [fp]: aac file handler.(in)
 *   [pAdtsFrameData]: the function will fill the aac data in it, must be
 *                     alloced memory before call this function.(out)
 *   [ptAdtsHeaderInfo]: AAC-ADTS header information in this frame.(out)
 * return: 0-success  other-error
 ************************************************************************/
int getAdtsFrame(FILE *fp, uint8_t *pAdtsFrameData, T_AdtsHeader *ptAdtsHeaderInfo);


#endif /*  __AAC_ADTS_H__ */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

main.c

#include <stdio.h>
#include <stdlib.h>

#include "aac_adts.h"
#include "faad.h"


#define MAX_DEC_SIZE   (128 * 1024)


int main(int argc, char *argv[])
{
	int ret = -1;
	FILE *fpAAC = NULL;
	FILE *fpPCM = NULL;
	unsigned char *aacBuf = NULL;
	unsigned char *pcmPtr = NULL;
	unsigned char channels = 0;
	unsigned long sampleRate = 0;
	T_AdtsHeader adtsHeader = {};
	NeAACDecHandle aacDecHandler = 0;
	NeAACDecFrameInfo aacDecFrameInfo = {};
	uint32_t audioSampleRate = -1;

	if(argc != 3)
	{
		printf("Usage:\n"
			   "    %s <in aac file> <out pcm file>\n"
			   "Examples:\n"
			   "    %s ./audio/test1_44100_stereo.aac  out1_44100_16bit_stereo.pcm\n"
			   "    %s ./audio/test2_8000_mono.aac     out2_16000_16bit_stereo.pcm  # output [samplerate] and [channels] will be auto configured.\n",
			   argv[0], argv[0], argv[0]);
		return -1;
	}

	/* open file */
	fpAAC = fopen(argv[1], "rb");
	fpPCM = fopen(argv[2], "wb");
	if(!fpAAC || !fpPCM)
	{
		printf("[%s:%d] open <%s> or <%s> file failed!\n", __FUNCTION__, __LINE__, argv[1], argv[2]);
		goto exit;
	}

	/* alloc memory */
	aacBuf = (unsigned char *)malloc(MAX_DEC_SIZE);
	if(!aacBuf)
	{
		printf("[%s:%d] alloc memory for aacBuf failed!\n", __FUNCTION__, __LINE__);
		goto exit;
	}

	/* aac decode 1/4: open aac decoder */
	aacDecHandler = NeAACDecOpen();

	/* use to configure decoder params */
	ret = getAdtsFrame(fpAAC, aacBuf, &adtsHeader);
	if(ret < 0)
	{
		if(ret == -2)
		{
			printf("aac file end!\n");
			goto exit;
		}
		else
		{
			printf("[%s:%d] get adts frame failed with %d!\n", __FUNCTION__, __LINE__, ret);
			goto exit;
		}
	}
	else
	{
		fseek(fpAAC, 0, SEEK_SET); // reset

		/* aac decode 2/4: init aac decoder params */
		NeAACDecInit(aacDecHandler, aacBuf, adtsHeader.aac_frame_length, &sampleRate, &channels);
		printf("\e[32m>>> will be decoded output with [samplerate: %lu], [channels: %d]<<<\e[0m\n", sampleRate, channels);
	}

	while(1)
	{
		ret = getAdtsFrame(fpAAC, aacBuf, &adtsHeader);
		if(ret < 0)
		{
			if(ret == -2)
			{
				printf("aac file end!\n");
				break;
			}
			else
			{
				printf("[%s:%d] get adts frame failed with %d!\n", __FUNCTION__, __LINE__, ret);
				goto exit;
			}
		}
		//printf("get one adts frame with size: %d\n", adtsHeader.aac_frame_length);

		/* aac decode 3/4: decode */
		pcmPtr = (unsigned char*)NeAACDecDecode(aacDecHandler, &aacDecFrameInfo, aacBuf, adtsHeader.aac_frame_length/* include header */);
		if(aacDecFrameInfo.error > 0)
		{
			printf("[%s:%d] %s\n", __FUNCTION__, __LINE__, NeAACDecGetErrorMessage(aacDecFrameInfo.error));
			goto exit;
		}
		else if(pcmPtr && aacDecFrameInfo.samples > 0)
		{
			printf("<in> [aac frame size: %lu] [header type: %s] "
                "[profile: %s]    |    <out> [samplerate: %lu] [samples cnt: %lu] [channels: %d] \n",
				aacDecFrameInfo.bytesconsumed, 
				aacDecFrameInfo.header_type == 2 ? "ADTS" : "Other", 
				aacDecFrameInfo.object_type == 2 ? "LC" : "Other", 
				aacDecFrameInfo.samplerate,
				aacDecFrameInfo.samples,
				aacDecFrameInfo.channels);

			fwrite(pcmPtr, 1, aacDecFrameInfo.samples * aacDecFrameInfo.channels, fpPCM);
		}
		else
		{
			printf("[%s:%d] Unknown decode error!\n", __FUNCTION__, __LINE__);
		}
	}

	/* aac decode 1/4: close aac decoder */
	NeAACDecClose(aacDecHandler);

	printf("\e[32mSuccess!\e[0m\n");

exit:
	if(fpAAC) fclose(fpAAC);
	if(fpPCM) {fflush(fpPCM); fclose(fpPCM);}
	if(aacBuf) free(aacBuf);

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

3、demo下载地址（任选一个）

• https://download.csdn.net/download/weixin_44498318/89525143

• https://gitee.com/linriming/audio_aac2pcm_with_faad2

• https://github.com/linriming20/audio_aac2pcm_with_faad2.git