1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "media/mp4/aac.h"
6
7 #include <algorithm>
8
9 #include "base/logging.h"
10 #include "media/base/bit_reader.h"
11 #include "media/mp4/rcheck.h"
12
13 // The following conversion table is extracted from ISO 14496 Part 3 -
14 // Table 1.16 - Sampling Frequency Index.
15 static const int kFrequencyMap[] = {
16 96000, 88200, 64000, 48000, 44100, 32000, 24000,
17 22050, 16000, 12000, 11025, 8000, 7350
18 };
19
20 namespace media {
21
ConvertChannelConfigToLayout(uint8 channel_config)22 static ChannelLayout ConvertChannelConfigToLayout(uint8 channel_config) {
23 switch (channel_config) {
24 case 1:
25 return CHANNEL_LAYOUT_MONO;
26 case 2:
27 return CHANNEL_LAYOUT_STEREO;
28 case 3:
29 return CHANNEL_LAYOUT_SURROUND;
30 case 4:
31 return CHANNEL_LAYOUT_4_0;
32 case 5:
33 return CHANNEL_LAYOUT_5_0;
34 case 6:
35 return CHANNEL_LAYOUT_5_1;
36 case 8:
37 return CHANNEL_LAYOUT_7_1;
38 default:
39 break;
40 }
41
42 return CHANNEL_LAYOUT_UNSUPPORTED;
43 }
44
45 namespace mp4 {
46
AAC()47 AAC::AAC()
48 : profile_(0), frequency_index_(0), channel_config_(0), frequency_(0),
49 extension_frequency_(0), channel_layout_(CHANNEL_LAYOUT_UNSUPPORTED) {
50 }
51
~AAC()52 AAC::~AAC() {
53 }
54
Parse(const std::vector<uint8> & data)55 bool AAC::Parse(const std::vector<uint8>& data) {
56 #if defined(OS_ANDROID)
57 codec_specific_data_ = data;
58 #endif
59 if (data.empty())
60 return false;
61
62 BitReader reader(&data[0], data.size());
63 uint8 extension_type = 0;
64 bool ps_present = false;
65 uint8 extension_frequency_index = 0xff;
66
67 frequency_ = 0;
68 extension_frequency_ = 0;
69
70 // The following code is written according to ISO 14496 Part 3 Table 1.13 -
71 // Syntax of AudioSpecificConfig.
72
73 // Read base configuration
74 RCHECK(reader.ReadBits(5, &profile_));
75 RCHECK(reader.ReadBits(4, &frequency_index_));
76 if (frequency_index_ == 0xf)
77 RCHECK(reader.ReadBits(24, &frequency_));
78 RCHECK(reader.ReadBits(4, &channel_config_));
79
80 // Read extension configuration.
81 if (profile_ == 5 || profile_ == 29) {
82 ps_present = (profile_ == 29);
83 extension_type = 5;
84 RCHECK(reader.ReadBits(4, &extension_frequency_index));
85 if (extension_frequency_index == 0xf)
86 RCHECK(reader.ReadBits(24, &extension_frequency_));
87 RCHECK(reader.ReadBits(5, &profile_));
88 }
89
90 RCHECK(SkipDecoderGASpecificConfig(&reader));
91 RCHECK(SkipErrorSpecificConfig());
92
93 // Read extension configuration again
94 // Note: The check for 16 available bits comes from the AAC spec.
95 if (extension_type != 5 && reader.bits_available() >= 16) {
96 uint16 sync_extension_type;
97 uint8 sbr_present_flag;
98 uint8 ps_present_flag;
99
100 if (reader.ReadBits(11, &sync_extension_type) &&
101 sync_extension_type == 0x2b7) {
102 if (reader.ReadBits(5, &extension_type) && extension_type == 5) {
103 RCHECK(reader.ReadBits(1, &sbr_present_flag));
104
105 if (sbr_present_flag) {
106 RCHECK(reader.ReadBits(4, &extension_frequency_index));
107
108 if (extension_frequency_index == 0xf)
109 RCHECK(reader.ReadBits(24, &extension_frequency_));
110
111 // Note: The check for 12 available bits comes from the AAC spec.
112 if (reader.bits_available() >= 12) {
113 RCHECK(reader.ReadBits(11, &sync_extension_type));
114 if (sync_extension_type == 0x548) {
115 RCHECK(reader.ReadBits(1, &ps_present_flag));
116 ps_present = ps_present_flag != 0;
117 }
118 }
119 }
120 }
121 }
122 }
123
124 if (frequency_ == 0) {
125 RCHECK(frequency_index_ < arraysize(kFrequencyMap));
126 frequency_ = kFrequencyMap[frequency_index_];
127 }
128
129 if (extension_frequency_ == 0 && extension_frequency_index != 0xff) {
130 RCHECK(extension_frequency_index < arraysize(kFrequencyMap));
131 extension_frequency_ = kFrequencyMap[extension_frequency_index];
132 }
133
134 // When Parametric Stereo is on, mono will be played as stereo.
135 if (ps_present && channel_config_ == 1)
136 channel_layout_ = CHANNEL_LAYOUT_STEREO;
137 else
138 channel_layout_ = ConvertChannelConfigToLayout(channel_config_);
139
140 return frequency_ != 0 && channel_layout_ != CHANNEL_LAYOUT_UNSUPPORTED &&
141 profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf &&
142 channel_config_ <= 7;
143 }
144
GetOutputSamplesPerSecond(bool sbr_in_mimetype) const145 int AAC::GetOutputSamplesPerSecond(bool sbr_in_mimetype) const {
146 if (extension_frequency_ > 0)
147 return extension_frequency_;
148
149 if (!sbr_in_mimetype)
150 return frequency_;
151
152 // The following code is written according to ISO 14496 Part 3 Table 1.11 and
153 // Table 1.22. (Table 1.11 refers to the capping to 48000, Table 1.22 refers
154 // to SBR doubling the AAC sample rate.)
155 // TODO(acolwell) : Extend sample rate cap to 96kHz for Level 5 content.
156 DCHECK_GT(frequency_, 0);
157 return std::min(2 * frequency_, 48000);
158 }
159
GetChannelLayout(bool sbr_in_mimetype) const160 ChannelLayout AAC::GetChannelLayout(bool sbr_in_mimetype) const {
161 // Check for implicit signalling of HE-AAC and indicate stereo output
162 // if the mono channel configuration is signalled.
163 // See ISO-14496-3 Section 1.6.6.1.2 for details about this special casing.
164 if (sbr_in_mimetype && channel_config_ == 1)
165 return CHANNEL_LAYOUT_STEREO;
166
167 return channel_layout_;
168 }
169
ConvertEsdsToADTS(std::vector<uint8> * buffer) const170 bool AAC::ConvertEsdsToADTS(std::vector<uint8>* buffer) const {
171 size_t size = buffer->size() + kADTSHeaderSize;
172
173 DCHECK(profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf &&
174 channel_config_ <= 7);
175
176 // ADTS header uses 13 bits for packet size.
177 if (size >= (1 << 13))
178 return false;
179
180 std::vector<uint8>& adts = *buffer;
181
182 adts.insert(buffer->begin(), kADTSHeaderSize, 0);
183 adts[0] = 0xff;
184 adts[1] = 0xf1;
185 adts[2] = ((profile_ - 1) << 6) + (frequency_index_ << 2) +
186 (channel_config_ >> 2);
187 adts[3] = ((channel_config_ & 0x3) << 6) + (size >> 11);
188 adts[4] = (size & 0x7ff) >> 3;
189 adts[5] = ((size & 7) << 5) + 0x1f;
190 adts[6] = 0xfc;
191
192 return true;
193 }
194
195 // Currently this function only support GASpecificConfig defined in
196 // ISO 14496 Part 3 Table 4.1 - Syntax of GASpecificConfig()
SkipDecoderGASpecificConfig(BitReader * bit_reader) const197 bool AAC::SkipDecoderGASpecificConfig(BitReader* bit_reader) const {
198 switch (profile_) {
199 case 1:
200 case 2:
201 case 3:
202 case 4:
203 case 6:
204 case 7:
205 case 17:
206 case 19:
207 case 20:
208 case 21:
209 case 22:
210 case 23:
211 return SkipGASpecificConfig(bit_reader);
212 default:
213 break;
214 }
215
216 return false;
217 }
218
SkipErrorSpecificConfig() const219 bool AAC::SkipErrorSpecificConfig() const {
220 switch (profile_) {
221 case 17:
222 case 19:
223 case 20:
224 case 21:
225 case 22:
226 case 23:
227 case 24:
228 case 25:
229 case 26:
230 case 27:
231 return false;
232 default:
233 break;
234 }
235
236 return true;
237 }
238
239 // The following code is written according to ISO 14496 part 3 Table 4.1 -
240 // GASpecificConfig.
SkipGASpecificConfig(BitReader * bit_reader) const241 bool AAC::SkipGASpecificConfig(BitReader* bit_reader) const {
242 uint8 extension_flag = 0;
243 uint8 depends_on_core_coder;
244 uint16 dummy;
245
246 RCHECK(bit_reader->ReadBits(1, &dummy)); // frameLengthFlag
247 RCHECK(bit_reader->ReadBits(1, &depends_on_core_coder));
248 if (depends_on_core_coder == 1)
249 RCHECK(bit_reader->ReadBits(14, &dummy)); // coreCoderDelay
250
251 RCHECK(bit_reader->ReadBits(1, &extension_flag));
252 RCHECK(channel_config_ != 0);
253
254 if (profile_ == 6 || profile_ == 20)
255 RCHECK(bit_reader->ReadBits(3, &dummy)); // layerNr
256
257 if (extension_flag) {
258 if (profile_ == 22) {
259 RCHECK(bit_reader->ReadBits(5, &dummy)); // numOfSubFrame
260 RCHECK(bit_reader->ReadBits(11, &dummy)); // layer_length
261 }
262
263 if (profile_ == 17 || profile_ == 19 || profile_ == 20 || profile_ == 23) {
264 RCHECK(bit_reader->ReadBits(3, &dummy)); // resilience flags
265 }
266
267 RCHECK(bit_reader->ReadBits(1, &dummy)); // extensionFlag3
268 }
269
270 return true;
271 }
272
273 } // namespace mp4
274
275 } // namespace media
276