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