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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
#include "AVIAACDecoder.h"
#include <math.h>
#include "../nsutil/pcm.h"
int AVIDecoder::CreateAudioDecoder(const nsavi::AVIH *avi_header,
const nsavi::STRH *stream_header, const nsavi::STRF *stream_format, const nsavi::STRD *stream_data,
unsigned int preferred_bits, unsigned int max_channels, bool floating_point,
ifc_aviaudiodecoder **decoder)
{
nsavi::audio_format *waveformat = (nsavi::audio_format *)stream_format;
if (waveformat->format == nsavi::audio_format_aac)
{
AVIAACDecoder *aac_decoder = AVIAACDecoder::Create(waveformat, preferred_bits, max_channels, floating_point);
if (aac_decoder)
{
*decoder = aac_decoder;
return CREATEDECODER_SUCCESS;
}
return CREATEDECODER_SUCCESS;
}
return CREATEDECODER_NOT_MINE;
}
#define CBCLASS AVIDecoder
START_DISPATCH;
CB(CREATE_AUDIO_DECODER, CreateAudioDecoder)
END_DISPATCH;
#undef CBCLASS
AVIAACDecoder *AVIAACDecoder::Create(const nsavi::audio_format *waveformat, unsigned int preferred_bits, unsigned int max_channels, bool floating_point)
{
if (!floating_point)
{
if (preferred_bits >= 24)
preferred_bits=24;
else
preferred_bits=16;
}
/*if (!max_channels)
max_channels = 8;*/
if (waveformat->extra_size_bytes)
{
CSAudioSpecificConfig asc;
memset(&asc, 0, sizeof(asc));
if (mp4AudioDecoder_ascParse((const unsigned char *)(waveformat + 1), waveformat->extra_size_bytes, &asc) == MP4AUDIODEC_OK)
{
CSAudioSpecificConfig *asc_array = &asc;;
mp4AudioDecoderHandle decoder = mp4AudioDecoder_Create(&asc_array, 1);
if (decoder)
{
mp4AudioDecoder_SetParam(decoder, TDL_MODE, SWITCH_OFF);
mp4AudioDecoder_SetParam(decoder, CONCEALMENT_ENERGYINTERPOLATION, SWITCH_OFF);
CCompositionUnitPtr composition_unit = CCompositionUnit_Create(max(asc.m_channels, 8), asc.m_samplesPerFrame * 2, asc.m_samplingFrequency, 6144, CUBUFFER_PCMTYPE_FLOAT);
if (composition_unit)
{
CAccessUnitPtr access_unit = CAccessUnit_Create(0, 0);
if (access_unit)
{
return new AVIAACDecoder(decoder, access_unit, composition_unit, preferred_bits, floating_point);
}
CCompositionUnit_Destroy(&composition_unit);
}
mp4AudioDecoder_Destroy(&decoder);
}
}
}
return 0;
}
AVIAACDecoder::AVIAACDecoder(mp4AudioDecoderHandle decoder, CAccessUnitPtr access_unit, CCompositionUnitPtr composition_unit, unsigned int bps, bool floating_point)
: decoder(decoder), access_unit(access_unit), composition_unit(composition_unit), bps(bps), floating_point(floating_point)
{
}
int AVIAACDecoder::OutputFrameSize(size_t *frame_size)
{
if (!decoder)
return AVI_FAILURE;
unsigned int samples_per_channel;
unsigned int channels;
if (CCompositionUnit_GetSamplesPerChannel(composition_unit, &samples_per_channel) != MP4AUDIODEC_OK
|| CCompositionUnit_GetChannels(composition_unit, &channels) != MP4AUDIODEC_OK)
return AVI_FAILURE;
*frame_size = samples_per_channel*channels;
return AVI_SUCCESS;
}
int AVIAACDecoder::GetOutputProperties(unsigned int *sampleRate, unsigned int *channels, unsigned int *bitsPerSample, bool *isFloat)
{
/* TODO: verify that it's safe to call these, e.g. one frame has been decoded successfully */
CCompositionUnit_GetSamplingRate(composition_unit, sampleRate);
CCompositionUnit_GetChannels(composition_unit, channels);
*bitsPerSample = bps;
*isFloat = floating_point;
return AVI_SUCCESS;
}
int AVIAACDecoder::DecodeChunk(uint16_t type, void **inputBuffer, size_t *inputBufferBytes, void *outputBuffer, size_t *outputBufferBytes)
{
CAccessUnit_Reset(access_unit);
CAccessUnit_Assign(access_unit, (const unsigned char *)*inputBuffer, *inputBufferBytes);
CCompositionUnit_Reset(composition_unit);
MP4_RESULT result = mp4AudioDecoder_DecodeFrame(decoder, &access_unit, composition_unit);
if (result == MP4AUDIODEC_OK)
{
unsigned int bits_remaining;
unsigned int bits_read;
CAccessUnit_GetBitCount(access_unit, &bits_read);
CAccessUnit_GetValidBits(access_unit, &bits_remaining);
*inputBuffer = (uint8_t *)(*inputBuffer) + bits_read/8;
*inputBufferBytes = bits_remaining/8;
unsigned int channels;
unsigned int samples_per_channel;
CCompositionUnit_GetSamplesPerChannel(composition_unit, &samples_per_channel);
CCompositionUnit_GetChannels(composition_unit, &channels);
const float *audio_output = 0;
size_t num_samples = samples_per_channel * channels;
size_t output_size = num_samples * (bps/8);
if (output_size > *outputBufferBytes)
return AVI_FAILURE;
*outputBufferBytes = output_size;
CCompositionUnit_GetPcmPtr(composition_unit, &audio_output);
if (!floating_point)
{
nsutil_pcm_FloatToInt_Interleaved_Gain(outputBuffer, audio_output, bps, num_samples, 1.0f/32768.0f);
}
else
{
for (size_t i = 0;i != num_samples;i++)
((float *)outputBuffer)[i] = audio_output[i] / 32768.0f;
}
return AVI_SUCCESS;
}
else
return AVI_FAILURE;
}
void AVIAACDecoder::Flush()
{
mp4AudioDecoder_Reset(decoder, MP4AUDIODECPARAM_DEFAULT, 0);
}
void AVIAACDecoder::Close()
{
mp4AudioDecoder_Destroy(&decoder);
CAccessUnit_Destroy(&access_unit);
CCompositionUnit_Destroy(&composition_unit);
delete this;
}
#define CBCLASS AVIAACDecoder
START_DISPATCH;
CB(OUTPUT_FRAME_SIZE, OutputFrameSize)
CB(GET_OUTPUT_PROPERTIES, GetOutputProperties)
CB(DECODE_CHUNK, DecodeChunk)
VCB(FLUSH, Flush)
VCB(CLOSE, Close)
END_DISPATCH;
#undef CBCLASS
|
