1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "sllog.h"
18 #include <utils/Log.h>
19
20 #include "android/include/AacAdtsExtractor.h"
21 #include <avc_utils.h>
22
23
24 namespace android {
25
26 #define ADTS_HEADER_LENGTH 7
27 // ADTS header size is 7, but frame size information ends on byte 6 (when counting from byte 1)
28 #define ADTS_HEADER_SIZE_UP_TO_FRAMESIZE 6
29
30 ////////////////////////////////////////////////////////////////////////////////
31
32 // Returns the sample rate based on the sampling frequency index
get_sample_rate(const uint8_t sf_index)33 static uint32_t get_sample_rate(const uint8_t sf_index)
34 {
35 static const uint32_t sample_rates[] =
36 {
37 96000, 88200, 64000, 48000, 44100, 32000,
38 24000, 22050, 16000, 12000, 11025, 8000
39 };
40
41 if (sf_index < sizeof(sample_rates) / sizeof(sample_rates[0])) {
42 return sample_rates[sf_index];
43 }
44
45 return 0;
46 }
47
getFrameSize(const sp<DataSource> & source,off64_t offset)48 static size_t getFrameSize(const sp<DataSource> &source, off64_t offset) {
49 size_t frameSize = 0;
50
51 uint8_t syncHeader[ADTS_HEADER_SIZE_UP_TO_FRAMESIZE];
52 const uint8_t *syncword = syncHeader;
53 const uint8_t *header = syncHeader + 3;
54
55 ssize_t readSize = source->readAt(offset, &syncHeader, ADTS_HEADER_SIZE_UP_TO_FRAMESIZE);
56 if (readSize == 0) {
57 // EOS is normal, not an error
58 SL_LOGV("AacAdtsExtractor::getFrameSize EOS");
59 return 0;
60 }
61 if (readSize != ADTS_HEADER_SIZE_UP_TO_FRAMESIZE) {
62 SL_LOGE("AacAdtsExtractor:: getFrameSize() returns %d (syncword and header read error)",
63 (int) readSize);
64 return 0;
65 }
66
67 if ((syncword[0] != 0xff) || ((syncword[1] & 0xf6) != 0xf0)) {
68 SL_LOGE("AacAdtsExtractor:: getFrameSize() returns 0 (syncword pb)");
69 return 0;
70 }
71
72 const uint8_t protectionAbsent = syncword[1] & 0x1;
73
74 frameSize = (header[0] & 0x3) << 11 | header[1] << 3 | header[2] >> 5;
75 // the frame size read already contains the size of the ADTS header, so no need to add it here
76
77 // protectionAbsent is 0 if there is CRC
78 static const size_t kAdtsHeaderLengthNoCrc = 7;
79 static const size_t kAdtsHeaderLengthWithCrc = 9;
80 size_t headSize = protectionAbsent ? kAdtsHeaderLengthNoCrc : kAdtsHeaderLengthWithCrc;
81 if (headSize > frameSize) {
82 SL_LOGE("AacAdtsExtractor:: getFrameSize() returns 0 (frameSize %zu < headSize %zu)",
83 frameSize, headSize);
84 return 0;
85 }
86
87 //SL_LOGV("AacAdtsExtractor:: getFrameSize() returns %u", frameSize);
88
89 return frameSize;
90 }
91
92
AacAdtsExtractor(const sp<DataSource> & source)93 AacAdtsExtractor::AacAdtsExtractor(const sp<DataSource> &source)
94 : mDataSource(source),
95 mInitCheck(NO_INIT),
96 mFrameDurationUs(0) {
97
98 // difference with framework's AAC Extractor: we have already validated the data
99 // upon enqueueing, so no need to sniff the data:
100 // String8 mimeType;
101 // float confidence;
102 // if (!SniffAAC(mDataSource, &mimeType, &confidence, NULL)) {
103 // return;
104 // }
105
106 uint8_t profile, sf_index, channel, header[2];
107 ssize_t readSize = mDataSource->readAt(2, &header, 2);
108 if (readSize != 2) {
109 SL_LOGE("Unable to determine sample rate");
110 return;
111 }
112
113 profile = (header[0] >> 6) & 0x3;
114 sf_index = (header[0] >> 2) & 0xf;
115 uint32_t sr = get_sample_rate(sf_index);
116
117 if (sr == 0) {
118 SL_LOGE("Invalid sample rate");
119 return;
120 }
121 channel = (header[0] & 0x1) << 2 | (header[1] >> 6);
122
123 SL_LOGV("AacAdtsExtractor has found sr=%d channel=%d", sr, channel);
124
125 // Never fails
126 mMeta = MakeAACCodecSpecificData(profile, sf_index, channel);
127
128 // Round up and get the duration of each frame
129 mFrameDurationUs = (1024 * 1000000ll + (sr - 1)) / sr;
130
131 off64_t streamSize;
132 if (mDataSource->getSize(&streamSize) == OK) {
133 off64_t offset = 0, numFrames = 0;
134 while (offset < streamSize) {
135 size_t frameSize;
136 if ((frameSize = getFrameSize(mDataSource, offset)) == 0) {
137 // Usually frameSize == 0 due to EOS is benign (and getFrameSize() doesn't SL_LOGE),
138 // but in this case we were told the total size of the data source and so an EOS
139 // should not happen.
140 SL_LOGE("AacAdtsExtractor() failed querying framesize at offset=%lld",
141 (long long) offset);
142 return;
143 }
144
145 offset += frameSize;
146 if (offset > streamSize) {
147 SL_LOGE("AacAdtsExtractor() frame of size %zu at offset=%lld is beyond EOF %lld",
148 frameSize, (long long) offset, (long long) streamSize);
149 return;
150 }
151 numFrames ++;
152 }
153
154 // Compute total duration
155 int64_t duration = numFrames * mFrameDurationUs;
156 mMeta->setInt64(kKeyDuration, duration);
157 }
158
159 // Any earlier "return" would leave mInitCheck as NO_INIT, causing later methods to fail quickly
160 mInitCheck = OK;
161
162 }
163
164
~AacAdtsExtractor()165 AacAdtsExtractor::~AacAdtsExtractor() {
166 }
167
168
getMetaData()169 sp<MetaData> AacAdtsExtractor::getMetaData() {
170 sp<MetaData> meta = new MetaData;
171
172 if (mInitCheck != OK) {
173 return meta;
174 }
175
176 meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC_ADTS);
177
178 return meta;
179 }
180
181
countTracks()182 size_t AacAdtsExtractor::countTracks() {
183 return mInitCheck == OK ? 1 : 0;
184 }
185
186
getTrack(size_t index)187 sp<IMediaSource> AacAdtsExtractor::getTrack(size_t index) {
188 if (mInitCheck != OK || index != 0) {
189 return NULL;
190 }
191
192 return new AacAdtsSource(mDataSource, mMeta, mFrameDurationUs);
193 }
194
195
getTrackMetaData(size_t index,uint32_t flags)196 sp<MetaData> AacAdtsExtractor::getTrackMetaData(size_t index, uint32_t flags) {
197 if (mInitCheck != OK || index != 0) {
198 return NULL;
199 }
200
201 return mMeta;
202 }
203
204
205 ////////////////////////////////////////////////////////////////////////////////
206
207 // 8192 = 2^13, 13bit AAC frame size (in bytes)
208 const size_t AacAdtsSource::kMaxFrameSize = 8192;
209
AacAdtsSource(const sp<DataSource> & source,const sp<MetaData> & meta,int64_t frame_duration_us)210 AacAdtsSource::AacAdtsSource(
211 const sp<DataSource> &source, const sp<MetaData> &meta,
212 int64_t frame_duration_us)
213 : mDataSource(source),
214 mMeta(meta),
215 mOffset(0),
216 mCurrentTimeUs(0),
217 mStarted(false),
218 mGroup(NULL),
219 mFrameDurationUs(frame_duration_us) {
220 }
221
222
~AacAdtsSource()223 AacAdtsSource::~AacAdtsSource() {
224 if (mStarted) {
225 stop();
226 }
227 }
228
229
start(MetaData * params)230 status_t AacAdtsSource::start(MetaData *params) {
231 CHECK(!mStarted);
232
233 mOffset = 0;
234 mCurrentTimeUs = 0;
235 mGroup = new MediaBufferGroup;
236 mGroup->add_buffer(new MediaBuffer(kMaxFrameSize));
237 mStarted = true;
238
239 return OK;
240 }
241
242
stop()243 status_t AacAdtsSource::stop() {
244 CHECK(mStarted);
245
246 delete mGroup;
247 mGroup = NULL;
248
249 mStarted = false;
250 return OK;
251 }
252
253
getFormat()254 sp<MetaData> AacAdtsSource::getFormat() {
255 return mMeta;
256 }
257
258
read(MediaBuffer ** out,const ReadOptions * options)259 status_t AacAdtsSource::read(
260 MediaBuffer **out, const ReadOptions *options) {
261 *out = NULL;
262
263 int64_t seekTimeUs;
264 ReadOptions::SeekMode mode;
265 if (options && options->getSeekTo(&seekTimeUs, &mode)) {
266 // difference with framework's AAC Extractor: no seeking
267 SL_LOGE("Can't seek in AAC ADTS buffer queue");
268 }
269
270 size_t frameSize, frameSizeWithoutHeader;
271 SL_LOGV("AacAdtsSource::read() offset=%lld", mOffset);
272 if ((frameSize = getFrameSize(mDataSource, mOffset)) == 0) {
273 // EOS is normal, not an error
274 SL_LOGV("AacAdtsSource::read() returns EOS");
275 return ERROR_END_OF_STREAM;
276 }
277
278 MediaBuffer *buffer;
279 status_t err = mGroup->acquire_buffer(&buffer);
280 if (err != OK) {
281 return err;
282 }
283
284 frameSizeWithoutHeader = frameSize - ADTS_HEADER_LENGTH;
285 ssize_t readSize = mDataSource->readAt(mOffset + ADTS_HEADER_LENGTH, buffer->data(),
286 frameSizeWithoutHeader);
287 //SL_LOGV("AacAdtsSource::read() readAt returned %u bytes", readSize);
288 if (readSize != (ssize_t)frameSizeWithoutHeader) {
289 SL_LOGW("AacAdtsSource::read() readSize != frameSizeWithoutHeader");
290 buffer->release();
291 buffer = NULL;
292 return ERROR_IO;
293 }
294
295 buffer->set_range(0, frameSizeWithoutHeader);
296 buffer->meta_data()->setInt64(kKeyTime, mCurrentTimeUs);
297 buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1);
298
299 mOffset += frameSize;
300 mCurrentTimeUs += mFrameDurationUs;
301
302 *out = buffer;
303 return OK;
304 }
305
306 } // namespace android
307