1/*
2 * Copyright (C) 2009 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//#define LOG_NDEBUG 0
18#define LOG_TAG "Utils"
19#include <utils/Log.h>
20#include <ctype.h>
21
22#include "include/ESDS.h"
23
24#include <arpa/inet.h>
25#include <cutils/properties.h>
26#include <media/openmax/OMX_Audio.h>
27#include <media/stagefright/foundation/ABuffer.h>
28#include <media/stagefright/foundation/ADebug.h>
29#include <media/stagefright/foundation/AMessage.h>
30#include <media/stagefright/MetaData.h>
31#include <media/stagefright/MediaDefs.h>
32#include <media/AudioSystem.h>
33#include <media/MediaPlayerInterface.h>
34#include <hardware/audio.h>
35#include <media/stagefright/Utils.h>
36#include <media/AudioParameter.h>
37
38namespace android {
39
40uint16_t U16_AT(const uint8_t *ptr) {
41    return ptr[0] << 8 | ptr[1];
42}
43
44uint32_t U32_AT(const uint8_t *ptr) {
45    return ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
46}
47
48uint64_t U64_AT(const uint8_t *ptr) {
49    return ((uint64_t)U32_AT(ptr)) << 32 | U32_AT(ptr + 4);
50}
51
52uint16_t U16LE_AT(const uint8_t *ptr) {
53    return ptr[0] | (ptr[1] << 8);
54}
55
56uint32_t U32LE_AT(const uint8_t *ptr) {
57    return ptr[3] << 24 | ptr[2] << 16 | ptr[1] << 8 | ptr[0];
58}
59
60uint64_t U64LE_AT(const uint8_t *ptr) {
61    return ((uint64_t)U32LE_AT(ptr + 4)) << 32 | U32LE_AT(ptr);
62}
63
64// XXX warning: these won't work on big-endian host.
65uint64_t ntoh64(uint64_t x) {
66    return ((uint64_t)ntohl(x & 0xffffffff) << 32) | ntohl(x >> 32);
67}
68
69uint64_t hton64(uint64_t x) {
70    return ((uint64_t)htonl(x & 0xffffffff) << 32) | htonl(x >> 32);
71}
72
73status_t convertMetaDataToMessage(
74        const sp<MetaData> &meta, sp<AMessage> *format) {
75    format->clear();
76
77    const char *mime;
78    CHECK(meta->findCString(kKeyMIMEType, &mime));
79
80    sp<AMessage> msg = new AMessage;
81    msg->setString("mime", mime);
82
83    int64_t durationUs;
84    if (meta->findInt64(kKeyDuration, &durationUs)) {
85        msg->setInt64("durationUs", durationUs);
86    }
87
88    int avgBitRate;
89    if (meta->findInt32(kKeyBitRate, &avgBitRate)) {
90        msg->setInt32("bit-rate", avgBitRate);
91    }
92
93    int32_t isSync;
94    if (meta->findInt32(kKeyIsSyncFrame, &isSync) && isSync != 0) {
95        msg->setInt32("is-sync-frame", 1);
96    }
97
98    if (!strncasecmp("video/", mime, 6)) {
99        int32_t width, height;
100        CHECK(meta->findInt32(kKeyWidth, &width));
101        CHECK(meta->findInt32(kKeyHeight, &height));
102
103        msg->setInt32("width", width);
104        msg->setInt32("height", height);
105
106        int32_t sarWidth, sarHeight;
107        if (meta->findInt32(kKeySARWidth, &sarWidth)
108                && meta->findInt32(kKeySARHeight, &sarHeight)) {
109            msg->setInt32("sar-width", sarWidth);
110            msg->setInt32("sar-height", sarHeight);
111        }
112
113        int32_t colorFormat;
114        if (meta->findInt32(kKeyColorFormat, &colorFormat)) {
115            msg->setInt32("color-format", colorFormat);
116        }
117
118        int32_t cropLeft, cropTop, cropRight, cropBottom;
119        if (meta->findRect(kKeyCropRect,
120                           &cropLeft,
121                           &cropTop,
122                           &cropRight,
123                           &cropBottom)) {
124            msg->setRect("crop", cropLeft, cropTop, cropRight, cropBottom);
125        }
126
127        int32_t rotationDegrees;
128        if (meta->findInt32(kKeyRotation, &rotationDegrees)) {
129            msg->setInt32("rotation-degrees", rotationDegrees);
130        }
131    } else if (!strncasecmp("audio/", mime, 6)) {
132        int32_t numChannels, sampleRate;
133        CHECK(meta->findInt32(kKeyChannelCount, &numChannels));
134        CHECK(meta->findInt32(kKeySampleRate, &sampleRate));
135
136        msg->setInt32("channel-count", numChannels);
137        msg->setInt32("sample-rate", sampleRate);
138
139        int32_t channelMask;
140        if (meta->findInt32(kKeyChannelMask, &channelMask)) {
141            msg->setInt32("channel-mask", channelMask);
142        }
143
144        int32_t delay = 0;
145        if (meta->findInt32(kKeyEncoderDelay, &delay)) {
146            msg->setInt32("encoder-delay", delay);
147        }
148        int32_t padding = 0;
149        if (meta->findInt32(kKeyEncoderPadding, &padding)) {
150            msg->setInt32("encoder-padding", padding);
151        }
152
153        int32_t isADTS;
154        if (meta->findInt32(kKeyIsADTS, &isADTS)) {
155            msg->setInt32("is-adts", true);
156        }
157
158        int32_t aacProfile = -1;
159        if (meta->findInt32(kKeyAACAOT, &aacProfile)) {
160            msg->setInt32("aac-profile", aacProfile);
161        }
162    }
163
164    int32_t maxInputSize;
165    if (meta->findInt32(kKeyMaxInputSize, &maxInputSize)) {
166        msg->setInt32("max-input-size", maxInputSize);
167    }
168
169    int32_t rotationDegrees;
170    if (meta->findInt32(kKeyRotation, &rotationDegrees)) {
171        msg->setInt32("rotation-degrees", rotationDegrees);
172    }
173
174    uint32_t type;
175    const void *data;
176    size_t size;
177    if (meta->findData(kKeyAVCC, &type, &data, &size)) {
178        // Parse the AVCDecoderConfigurationRecord
179
180        const uint8_t *ptr = (const uint8_t *)data;
181
182        CHECK(size >= 7);
183        CHECK_EQ((unsigned)ptr[0], 1u);  // configurationVersion == 1
184        uint8_t profile = ptr[1];
185        uint8_t level = ptr[3];
186
187        // There is decodable content out there that fails the following
188        // assertion, let's be lenient for now...
189        // CHECK((ptr[4] >> 2) == 0x3f);  // reserved
190
191        size_t lengthSize = 1 + (ptr[4] & 3);
192
193        // commented out check below as H264_QVGA_500_NO_AUDIO.3gp
194        // violates it...
195        // CHECK((ptr[5] >> 5) == 7);  // reserved
196
197        size_t numSeqParameterSets = ptr[5] & 31;
198
199        ptr += 6;
200        size -= 6;
201
202        sp<ABuffer> buffer = new ABuffer(1024);
203        buffer->setRange(0, 0);
204
205        for (size_t i = 0; i < numSeqParameterSets; ++i) {
206            CHECK(size >= 2);
207            size_t length = U16_AT(ptr);
208
209            ptr += 2;
210            size -= 2;
211
212            CHECK(size >= length);
213
214            memcpy(buffer->data() + buffer->size(), "\x00\x00\x00\x01", 4);
215            memcpy(buffer->data() + buffer->size() + 4, ptr, length);
216            buffer->setRange(0, buffer->size() + 4 + length);
217
218            ptr += length;
219            size -= length;
220        }
221
222        buffer->meta()->setInt32("csd", true);
223        buffer->meta()->setInt64("timeUs", 0);
224
225        msg->setBuffer("csd-0", buffer);
226
227        buffer = new ABuffer(1024);
228        buffer->setRange(0, 0);
229
230        CHECK(size >= 1);
231        size_t numPictureParameterSets = *ptr;
232        ++ptr;
233        --size;
234
235        for (size_t i = 0; i < numPictureParameterSets; ++i) {
236            CHECK(size >= 2);
237            size_t length = U16_AT(ptr);
238
239            ptr += 2;
240            size -= 2;
241
242            CHECK(size >= length);
243
244            memcpy(buffer->data() + buffer->size(), "\x00\x00\x00\x01", 4);
245            memcpy(buffer->data() + buffer->size() + 4, ptr, length);
246            buffer->setRange(0, buffer->size() + 4 + length);
247
248            ptr += length;
249            size -= length;
250        }
251
252        buffer->meta()->setInt32("csd", true);
253        buffer->meta()->setInt64("timeUs", 0);
254        msg->setBuffer("csd-1", buffer);
255    } else if (meta->findData(kKeyHVCC, &type, &data, &size)) {
256        const uint8_t *ptr = (const uint8_t *)data;
257
258        CHECK(size >= 7);
259        CHECK_EQ((unsigned)ptr[0], 1u);  // configurationVersion == 1
260        uint8_t profile = ptr[1] & 31;
261        uint8_t level = ptr[12];
262        ptr += 22;
263        size -= 22;
264
265
266        size_t numofArrays = (char)ptr[0];
267        ptr += 1;
268        size -= 1;
269        size_t j = 0, i = 0;
270
271        sp<ABuffer> buffer = new ABuffer(1024);
272        buffer->setRange(0, 0);
273
274        for (i = 0; i < numofArrays; i++) {
275            ptr += 1;
276            size -= 1;
277
278            //Num of nals
279            size_t numofNals = U16_AT(ptr);
280
281            ptr += 2;
282            size -= 2;
283
284            for (j = 0; j < numofNals; j++) {
285                CHECK(size >= 2);
286                size_t length = U16_AT(ptr);
287
288                ptr += 2;
289                size -= 2;
290
291                CHECK(size >= length);
292
293                memcpy(buffer->data() + buffer->size(), "\x00\x00\x00\x01", 4);
294                memcpy(buffer->data() + buffer->size() + 4, ptr, length);
295                buffer->setRange(0, buffer->size() + 4 + length);
296
297                ptr += length;
298                size -= length;
299            }
300        }
301        buffer->meta()->setInt32("csd", true);
302        buffer->meta()->setInt64("timeUs", 0);
303        msg->setBuffer("csd-0", buffer);
304
305    } else if (meta->findData(kKeyESDS, &type, &data, &size)) {
306        ESDS esds((const char *)data, size);
307        CHECK_EQ(esds.InitCheck(), (status_t)OK);
308
309        const void *codec_specific_data;
310        size_t codec_specific_data_size;
311        esds.getCodecSpecificInfo(
312                &codec_specific_data, &codec_specific_data_size);
313
314        sp<ABuffer> buffer = new ABuffer(codec_specific_data_size);
315
316        memcpy(buffer->data(), codec_specific_data,
317               codec_specific_data_size);
318
319        buffer->meta()->setInt32("csd", true);
320        buffer->meta()->setInt64("timeUs", 0);
321        msg->setBuffer("csd-0", buffer);
322    } else if (meta->findData(kKeyVorbisInfo, &type, &data, &size)) {
323        sp<ABuffer> buffer = new ABuffer(size);
324        memcpy(buffer->data(), data, size);
325
326        buffer->meta()->setInt32("csd", true);
327        buffer->meta()->setInt64("timeUs", 0);
328        msg->setBuffer("csd-0", buffer);
329
330        if (!meta->findData(kKeyVorbisBooks, &type, &data, &size)) {
331            return -EINVAL;
332        }
333
334        buffer = new ABuffer(size);
335        memcpy(buffer->data(), data, size);
336
337        buffer->meta()->setInt32("csd", true);
338        buffer->meta()->setInt64("timeUs", 0);
339        msg->setBuffer("csd-1", buffer);
340    } else if (meta->findData(kKeyOpusHeader, &type, &data, &size)) {
341        sp<ABuffer> buffer = new ABuffer(size);
342        memcpy(buffer->data(), data, size);
343
344        buffer->meta()->setInt32("csd", true);
345        buffer->meta()->setInt64("timeUs", 0);
346        msg->setBuffer("csd-0", buffer);
347    }
348
349    *format = msg;
350
351    return OK;
352}
353
354static size_t reassembleAVCC(const sp<ABuffer> &csd0, const sp<ABuffer> csd1, char *avcc) {
355
356    avcc[0] = 1;        // version
357    avcc[1] = 0x64;     // profile
358    avcc[2] = 0;        // unused (?)
359    avcc[3] = 0xd;      // level
360    avcc[4] = 0xff;     // reserved+size
361
362    size_t i = 0;
363    int numparams = 0;
364    int lastparamoffset = 0;
365    int avccidx = 6;
366    do {
367        if (i >= csd0->size() - 4 ||
368                memcmp(csd0->data() + i, "\x00\x00\x00\x01", 4) == 0) {
369            if (i >= csd0->size() - 4) {
370                // there can't be another param here, so use all the rest
371                i = csd0->size();
372            }
373            ALOGV("block at %zu, last was %d", i, lastparamoffset);
374            if (lastparamoffset > 0) {
375                int size = i - lastparamoffset;
376                avcc[avccidx++] = size >> 8;
377                avcc[avccidx++] = size & 0xff;
378                memcpy(avcc+avccidx, csd0->data() + lastparamoffset, size);
379                avccidx += size;
380                numparams++;
381            }
382            i += 4;
383            lastparamoffset = i;
384        } else {
385            i++;
386        }
387    } while(i < csd0->size());
388    ALOGV("csd0 contains %d params", numparams);
389
390    avcc[5] = 0xe0 | numparams;
391    //and now csd-1
392    i = 0;
393    numparams = 0;
394    lastparamoffset = 0;
395    int numpicparamsoffset = avccidx;
396    avccidx++;
397    do {
398        if (i >= csd1->size() - 4 ||
399                memcmp(csd1->data() + i, "\x00\x00\x00\x01", 4) == 0) {
400            if (i >= csd1->size() - 4) {
401                // there can't be another param here, so use all the rest
402                i = csd1->size();
403            }
404            ALOGV("block at %zu, last was %d", i, lastparamoffset);
405            if (lastparamoffset > 0) {
406                int size = i - lastparamoffset;
407                avcc[avccidx++] = size >> 8;
408                avcc[avccidx++] = size & 0xff;
409                memcpy(avcc+avccidx, csd1->data() + lastparamoffset, size);
410                avccidx += size;
411                numparams++;
412            }
413            i += 4;
414            lastparamoffset = i;
415        } else {
416            i++;
417        }
418    } while(i < csd1->size());
419    avcc[numpicparamsoffset] = numparams;
420    return avccidx;
421}
422
423static void reassembleESDS(const sp<ABuffer> &csd0, char *esds) {
424    int csd0size = csd0->size();
425    esds[0] = 3; // kTag_ESDescriptor;
426    int esdescriptorsize = 26 + csd0size;
427    CHECK(esdescriptorsize < 268435456); // 7 bits per byte, so max is 2^28-1
428    esds[1] = 0x80 | (esdescriptorsize >> 21);
429    esds[2] = 0x80 | ((esdescriptorsize >> 14) & 0x7f);
430    esds[3] = 0x80 | ((esdescriptorsize >> 7) & 0x7f);
431    esds[4] = (esdescriptorsize & 0x7f);
432    esds[5] = esds[6] = 0; // es id
433    esds[7] = 0; // flags
434    esds[8] = 4; // kTag_DecoderConfigDescriptor
435    int configdescriptorsize = 18 + csd0size;
436    esds[9] = 0x80 | (configdescriptorsize >> 21);
437    esds[10] = 0x80 | ((configdescriptorsize >> 14) & 0x7f);
438    esds[11] = 0x80 | ((configdescriptorsize >> 7) & 0x7f);
439    esds[12] = (configdescriptorsize & 0x7f);
440    esds[13] = 0x40; // objectTypeIndication
441    esds[14] = 0x15; // not sure what 14-25 mean, they are ignored by ESDS.cpp,
442    esds[15] = 0x00; // but the actual values here were taken from a real file.
443    esds[16] = 0x18;
444    esds[17] = 0x00;
445    esds[18] = 0x00;
446    esds[19] = 0x00;
447    esds[20] = 0xfa;
448    esds[21] = 0x00;
449    esds[22] = 0x00;
450    esds[23] = 0x00;
451    esds[24] = 0xfa;
452    esds[25] = 0x00;
453    esds[26] = 5; // kTag_DecoderSpecificInfo;
454    esds[27] = 0x80 | (csd0size >> 21);
455    esds[28] = 0x80 | ((csd0size >> 14) & 0x7f);
456    esds[29] = 0x80 | ((csd0size >> 7) & 0x7f);
457    esds[30] = (csd0size & 0x7f);
458    memcpy((void*)&esds[31], csd0->data(), csd0size);
459    // data following this is ignored, so don't bother appending it
460
461}
462
463void convertMessageToMetaData(const sp<AMessage> &msg, sp<MetaData> &meta) {
464    AString mime;
465    if (msg->findString("mime", &mime)) {
466        meta->setCString(kKeyMIMEType, mime.c_str());
467    } else {
468        ALOGW("did not find mime type");
469    }
470
471    int64_t durationUs;
472    if (msg->findInt64("durationUs", &durationUs)) {
473        meta->setInt64(kKeyDuration, durationUs);
474    }
475
476    int32_t isSync;
477    if (msg->findInt32("is-sync-frame", &isSync) && isSync != 0) {
478        meta->setInt32(kKeyIsSyncFrame, 1);
479    }
480
481    if (mime.startsWith("video/")) {
482        int32_t width;
483        int32_t height;
484        if (msg->findInt32("width", &width) && msg->findInt32("height", &height)) {
485            meta->setInt32(kKeyWidth, width);
486            meta->setInt32(kKeyHeight, height);
487        } else {
488            ALOGW("did not find width and/or height");
489        }
490
491        int32_t sarWidth, sarHeight;
492        if (msg->findInt32("sar-width", &sarWidth)
493                && msg->findInt32("sar-height", &sarHeight)) {
494            meta->setInt32(kKeySARWidth, sarWidth);
495            meta->setInt32(kKeySARHeight, sarHeight);
496        }
497
498        int32_t colorFormat;
499        if (msg->findInt32("color-format", &colorFormat)) {
500            meta->setInt32(kKeyColorFormat, colorFormat);
501        }
502
503        int32_t cropLeft, cropTop, cropRight, cropBottom;
504        if (msg->findRect("crop",
505                          &cropLeft,
506                          &cropTop,
507                          &cropRight,
508                          &cropBottom)) {
509            meta->setRect(kKeyCropRect, cropLeft, cropTop, cropRight, cropBottom);
510        }
511
512        int32_t rotationDegrees;
513        if (msg->findInt32("rotation-degrees", &rotationDegrees)) {
514            meta->setInt32(kKeyRotation, rotationDegrees);
515        }
516    } else if (mime.startsWith("audio/")) {
517        int32_t numChannels;
518        if (msg->findInt32("channel-count", &numChannels)) {
519            meta->setInt32(kKeyChannelCount, numChannels);
520        }
521        int32_t sampleRate;
522        if (msg->findInt32("sample-rate", &sampleRate)) {
523            meta->setInt32(kKeySampleRate, sampleRate);
524        }
525        int32_t channelMask;
526        if (msg->findInt32("channel-mask", &channelMask)) {
527            meta->setInt32(kKeyChannelMask, channelMask);
528        }
529        int32_t delay = 0;
530        if (msg->findInt32("encoder-delay", &delay)) {
531            meta->setInt32(kKeyEncoderDelay, delay);
532        }
533        int32_t padding = 0;
534        if (msg->findInt32("encoder-padding", &padding)) {
535            meta->setInt32(kKeyEncoderPadding, padding);
536        }
537
538        int32_t isADTS;
539        if (msg->findInt32("is-adts", &isADTS)) {
540            meta->setInt32(kKeyIsADTS, isADTS);
541        }
542    }
543
544    int32_t maxInputSize;
545    if (msg->findInt32("max-input-size", &maxInputSize)) {
546        meta->setInt32(kKeyMaxInputSize, maxInputSize);
547    }
548
549    // reassemble the csd data into its original form
550    sp<ABuffer> csd0;
551    if (msg->findBuffer("csd-0", &csd0)) {
552        if (mime.startsWith("video/")) { // do we need to be stricter than this?
553            sp<ABuffer> csd1;
554            if (msg->findBuffer("csd-1", &csd1)) {
555                char avcc[1024]; // that oughta be enough, right?
556                size_t outsize = reassembleAVCC(csd0, csd1, avcc);
557                meta->setData(kKeyAVCC, kKeyAVCC, avcc, outsize);
558            }
559        } else if (mime.startsWith("audio/")) {
560            int csd0size = csd0->size();
561            char esds[csd0size + 31];
562            reassembleESDS(csd0, esds);
563            meta->setData(kKeyESDS, kKeyESDS, esds, sizeof(esds));
564        }
565    }
566
567    int32_t timeScale;
568    if (msg->findInt32("time-scale", &timeScale)) {
569        meta->setInt32(kKeyTimeScale, timeScale);
570    }
571
572    // XXX TODO add whatever other keys there are
573
574#if 0
575    ALOGI("converted %s to:", msg->debugString(0).c_str());
576    meta->dumpToLog();
577#endif
578}
579
580AString MakeUserAgent() {
581    AString ua;
582    ua.append("stagefright/1.2 (Linux;Android ");
583
584#if (PROPERTY_VALUE_MAX < 8)
585#error "PROPERTY_VALUE_MAX must be at least 8"
586#endif
587
588    char value[PROPERTY_VALUE_MAX];
589    property_get("ro.build.version.release", value, "Unknown");
590    ua.append(value);
591    ua.append(")");
592
593    return ua;
594}
595
596status_t sendMetaDataToHal(sp<MediaPlayerBase::AudioSink>& sink,
597                           const sp<MetaData>& meta)
598{
599    int32_t sampleRate = 0;
600    int32_t bitRate = 0;
601    int32_t channelMask = 0;
602    int32_t delaySamples = 0;
603    int32_t paddingSamples = 0;
604
605    AudioParameter param = AudioParameter();
606
607    if (meta->findInt32(kKeySampleRate, &sampleRate)) {
608        param.addInt(String8(AUDIO_OFFLOAD_CODEC_SAMPLE_RATE), sampleRate);
609    }
610    if (meta->findInt32(kKeyChannelMask, &channelMask)) {
611        param.addInt(String8(AUDIO_OFFLOAD_CODEC_NUM_CHANNEL), channelMask);
612    }
613    if (meta->findInt32(kKeyBitRate, &bitRate)) {
614        param.addInt(String8(AUDIO_OFFLOAD_CODEC_AVG_BIT_RATE), bitRate);
615    }
616    if (meta->findInt32(kKeyEncoderDelay, &delaySamples)) {
617        param.addInt(String8(AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES), delaySamples);
618    }
619    if (meta->findInt32(kKeyEncoderPadding, &paddingSamples)) {
620        param.addInt(String8(AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES), paddingSamples);
621    }
622
623    ALOGV("sendMetaDataToHal: bitRate %d, sampleRate %d, chanMask %d,"
624          "delaySample %d, paddingSample %d", bitRate, sampleRate,
625          channelMask, delaySamples, paddingSamples);
626
627    sink->setParameters(param.toString());
628    return OK;
629}
630
631struct mime_conv_t {
632    const char* mime;
633    audio_format_t format;
634};
635
636static const struct mime_conv_t mimeLookup[] = {
637    { MEDIA_MIMETYPE_AUDIO_MPEG,        AUDIO_FORMAT_MP3 },
638    { MEDIA_MIMETYPE_AUDIO_RAW,         AUDIO_FORMAT_PCM_16_BIT },
639    { MEDIA_MIMETYPE_AUDIO_AMR_NB,      AUDIO_FORMAT_AMR_NB },
640    { MEDIA_MIMETYPE_AUDIO_AMR_WB,      AUDIO_FORMAT_AMR_WB },
641    { MEDIA_MIMETYPE_AUDIO_AAC,         AUDIO_FORMAT_AAC },
642    { MEDIA_MIMETYPE_AUDIO_VORBIS,      AUDIO_FORMAT_VORBIS },
643    { MEDIA_MIMETYPE_AUDIO_OPUS,        AUDIO_FORMAT_OPUS},
644    { 0, AUDIO_FORMAT_INVALID }
645};
646
647status_t mapMimeToAudioFormat( audio_format_t& format, const char* mime )
648{
649const struct mime_conv_t* p = &mimeLookup[0];
650    while (p->mime != NULL) {
651        if (0 == strcasecmp(mime, p->mime)) {
652            format = p->format;
653            return OK;
654        }
655        ++p;
656    }
657
658    return BAD_VALUE;
659}
660
661struct aac_format_conv_t {
662    OMX_AUDIO_AACPROFILETYPE eAacProfileType;
663    audio_format_t format;
664};
665
666static const struct aac_format_conv_t profileLookup[] = {
667    { OMX_AUDIO_AACObjectMain,        AUDIO_FORMAT_AAC_MAIN},
668    { OMX_AUDIO_AACObjectLC,          AUDIO_FORMAT_AAC_LC},
669    { OMX_AUDIO_AACObjectSSR,         AUDIO_FORMAT_AAC_SSR},
670    { OMX_AUDIO_AACObjectLTP,         AUDIO_FORMAT_AAC_LTP},
671    { OMX_AUDIO_AACObjectHE,          AUDIO_FORMAT_AAC_HE_V1},
672    { OMX_AUDIO_AACObjectScalable,    AUDIO_FORMAT_AAC_SCALABLE},
673    { OMX_AUDIO_AACObjectERLC,        AUDIO_FORMAT_AAC_ERLC},
674    { OMX_AUDIO_AACObjectLD,          AUDIO_FORMAT_AAC_LD},
675    { OMX_AUDIO_AACObjectHE_PS,       AUDIO_FORMAT_AAC_HE_V2},
676    { OMX_AUDIO_AACObjectELD,         AUDIO_FORMAT_AAC_ELD},
677    { OMX_AUDIO_AACObjectNull,        AUDIO_FORMAT_AAC},
678};
679
680void mapAACProfileToAudioFormat( audio_format_t& format, uint64_t eAacProfile)
681{
682const struct aac_format_conv_t* p = &profileLookup[0];
683    while (p->eAacProfileType != OMX_AUDIO_AACObjectNull) {
684        if (eAacProfile == p->eAacProfileType) {
685            format = p->format;
686            return;
687        }
688        ++p;
689    }
690    format = AUDIO_FORMAT_AAC;
691    return;
692}
693
694bool canOffloadStream(const sp<MetaData>& meta, bool hasVideo,
695                      bool isStreaming, audio_stream_type_t streamType)
696{
697    const char *mime;
698    if (meta == NULL) {
699        return false;
700    }
701    CHECK(meta->findCString(kKeyMIMEType, &mime));
702
703    audio_offload_info_t info = AUDIO_INFO_INITIALIZER;
704
705    info.format = AUDIO_FORMAT_INVALID;
706    if (mapMimeToAudioFormat(info.format, mime) != OK) {
707        ALOGE(" Couldn't map mime type \"%s\" to a valid AudioSystem::audio_format !", mime);
708        return false;
709    } else {
710        ALOGV("Mime type \"%s\" mapped to audio_format %d", mime, info.format);
711    }
712
713    if (AUDIO_FORMAT_INVALID == info.format) {
714        // can't offload if we don't know what the source format is
715        ALOGE("mime type \"%s\" not a known audio format", mime);
716        return false;
717    }
718
719    // Redefine aac format according to its profile
720    // Offloading depends on audio DSP capabilities.
721    int32_t aacaot = -1;
722    if (meta->findInt32(kKeyAACAOT, &aacaot)) {
723        mapAACProfileToAudioFormat(info.format,(OMX_AUDIO_AACPROFILETYPE) aacaot);
724    }
725
726    int32_t srate = -1;
727    if (!meta->findInt32(kKeySampleRate, &srate)) {
728        ALOGV("track of type '%s' does not publish sample rate", mime);
729    }
730    info.sample_rate = srate;
731
732    int32_t cmask = 0;
733    if (!meta->findInt32(kKeyChannelMask, &cmask)) {
734        ALOGV("track of type '%s' does not publish channel mask", mime);
735
736        // Try a channel count instead
737        int32_t channelCount;
738        if (!meta->findInt32(kKeyChannelCount, &channelCount)) {
739            ALOGV("track of type '%s' does not publish channel count", mime);
740        } else {
741            cmask = audio_channel_out_mask_from_count(channelCount);
742        }
743    }
744    info.channel_mask = cmask;
745
746    int64_t duration = 0;
747    if (!meta->findInt64(kKeyDuration, &duration)) {
748        ALOGV("track of type '%s' does not publish duration", mime);
749    }
750    info.duration_us = duration;
751
752    int32_t brate = -1;
753    if (!meta->findInt32(kKeyBitRate, &brate)) {
754        ALOGV("track of type '%s' does not publish bitrate", mime);
755     }
756    info.bit_rate = brate;
757
758
759    info.stream_type = streamType;
760    info.has_video = hasVideo;
761    info.is_streaming = isStreaming;
762
763    // Check if offload is possible for given format, stream type, sample rate,
764    // bit rate, duration, video and streaming
765    return AudioSystem::isOffloadSupported(info);
766}
767
768AString uriDebugString(const AString &uri, bool incognito) {
769    if (incognito) {
770        return AString("<URI suppressed>");
771    }
772
773    char prop[PROPERTY_VALUE_MAX];
774    if (property_get("media.stagefright.log-uri", prop, "false") &&
775        (!strcmp(prop, "1") || !strcmp(prop, "true"))) {
776        return uri;
777    }
778
779    // find scheme
780    AString scheme;
781    const char *chars = uri.c_str();
782    for (size_t i = 0; i < uri.size(); i++) {
783        const char c = chars[i];
784        if (!isascii(c)) {
785            break;
786        } else if (isalpha(c)) {
787            continue;
788        } else if (i == 0) {
789            // first character must be a letter
790            break;
791        } else if (isdigit(c) || c == '+' || c == '.' || c =='-') {
792            continue;
793        } else if (c != ':') {
794            break;
795        }
796        scheme = AString(uri, 0, i);
797        scheme.append("://<suppressed>");
798        return scheme;
799    }
800    return AString("<no-scheme URI suppressed>");
801}
802
803}  // namespace android
804
805