OMXCodec.cpp revision 4937be23b485ce8edf180ff5e71ebf0884178f17 
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 "OMXCodec"
19#include <utils/Log.h>
20
21#include "include/AACDecoder.h"
22#include "include/AACEncoder.h"
23#include "include/AMRNBDecoder.h"
24#include "include/AMRNBEncoder.h"
25#include "include/AMRWBDecoder.h"
26#include "include/AMRWBEncoder.h"
27#include "include/AVCDecoder.h"
28#include "include/AVCEncoder.h"
29#include "include/G711Decoder.h"
30#include "include/M4vH263Decoder.h"
31#include "include/M4vH263Encoder.h"
32#include "include/MP3Decoder.h"
33#include "include/VorbisDecoder.h"
34#include "include/VPXDecoder.h"
35
36#include "include/ESDS.h"
37
38#include <binder/IServiceManager.h>
39#include <binder/MemoryDealer.h>
40#include <binder/ProcessState.h>
41#include <media/IMediaPlayerService.h>
42#include <media/stagefright/MediaBuffer.h>
43#include <media/stagefright/MediaBufferGroup.h>
44#include <media/stagefright/MediaDebug.h>
45#include <media/stagefright/MediaDefs.h>
46#include <media/stagefright/MediaExtractor.h>
47#include <media/stagefright/MetaData.h>
48#include <media/stagefright/OMXCodec.h>
49#include <media/stagefright/Utils.h>
50#include <utils/Vector.h>
51
52#include <OMX_Audio.h>
53#include <OMX_Component.h>
54
55namespace android {
56
57static const int OMX_QCOM_COLOR_FormatYVU420SemiPlanar = 0x7FA30C00;
58
59struct CodecInfo {
60    const char *mime;
61    const char *codec;
62};
63
64#define FACTORY_CREATE(name) \
65static sp<MediaSource> Make##name(const sp<MediaSource> &source) { \
66    return new name(source); \
67}
68
69#define FACTORY_CREATE_ENCODER(name) \
70static sp<MediaSource> Make##name(const sp<MediaSource> &source, const sp<MetaData> &meta) { \
71    return new name(source, meta); \
72}
73
74#define FACTORY_REF(name) { #name, Make##name },
75
76FACTORY_CREATE(MP3Decoder)
77FACTORY_CREATE(AMRNBDecoder)
78FACTORY_CREATE(AMRWBDecoder)
79FACTORY_CREATE(AACDecoder)
80FACTORY_CREATE(AVCDecoder)
81FACTORY_CREATE(G711Decoder)
82FACTORY_CREATE(M4vH263Decoder)
83FACTORY_CREATE(VorbisDecoder)
84FACTORY_CREATE(VPXDecoder)
85FACTORY_CREATE_ENCODER(AMRNBEncoder)
86FACTORY_CREATE_ENCODER(AMRWBEncoder)
87FACTORY_CREATE_ENCODER(AACEncoder)
88FACTORY_CREATE_ENCODER(AVCEncoder)
89FACTORY_CREATE_ENCODER(M4vH263Encoder)
90
91static sp<MediaSource> InstantiateSoftwareEncoder(
92        const char *name, const sp<MediaSource> &source,
93        const sp<MetaData> &meta) {
94    struct FactoryInfo {
95        const char *name;
96        sp<MediaSource> (*CreateFunc)(const sp<MediaSource> &, const sp<MetaData> &);
97    };
98
99    static const FactoryInfo kFactoryInfo[] = {
100        FACTORY_REF(AMRNBEncoder)
101        FACTORY_REF(AMRWBEncoder)
102        FACTORY_REF(AACEncoder)
103        FACTORY_REF(AVCEncoder)
104        FACTORY_REF(M4vH263Encoder)
105    };
106    for (size_t i = 0;
107         i < sizeof(kFactoryInfo) / sizeof(kFactoryInfo[0]); ++i) {
108        if (!strcmp(name, kFactoryInfo[i].name)) {
109            return (*kFactoryInfo[i].CreateFunc)(source, meta);
110        }
111    }
112
113    return NULL;
114}
115
116static sp<MediaSource> InstantiateSoftwareCodec(
117        const char *name, const sp<MediaSource> &source) {
118    struct FactoryInfo {
119        const char *name;
120        sp<MediaSource> (*CreateFunc)(const sp<MediaSource> &);
121    };
122
123    static const FactoryInfo kFactoryInfo[] = {
124        FACTORY_REF(MP3Decoder)
125        FACTORY_REF(AMRNBDecoder)
126        FACTORY_REF(AMRWBDecoder)
127        FACTORY_REF(AACDecoder)
128        FACTORY_REF(AVCDecoder)
129        FACTORY_REF(G711Decoder)
130        FACTORY_REF(M4vH263Decoder)
131        FACTORY_REF(VorbisDecoder)
132        FACTORY_REF(VPXDecoder)
133    };
134    for (size_t i = 0;
135         i < sizeof(kFactoryInfo) / sizeof(kFactoryInfo[0]); ++i) {
136        if (!strcmp(name, kFactoryInfo[i].name)) {
137            return (*kFactoryInfo[i].CreateFunc)(source);
138        }
139    }
140
141    return NULL;
142}
143
144#undef FACTORY_REF
145#undef FACTORY_CREATE
146
147static const CodecInfo kDecoderInfo[] = {
148    { MEDIA_MIMETYPE_IMAGE_JPEG, "OMX.TI.JPEG.decode" },
149//    { MEDIA_MIMETYPE_AUDIO_MPEG, "OMX.TI.MP3.decode" },
150    { MEDIA_MIMETYPE_AUDIO_MPEG, "MP3Decoder" },
151//    { MEDIA_MIMETYPE_AUDIO_MPEG, "OMX.PV.mp3dec" },
152//    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "OMX.TI.AMR.decode" },
153    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "AMRNBDecoder" },
154//    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "OMX.PV.amrdec" },
155    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "OMX.TI.WBAMR.decode" },
156    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "AMRWBDecoder" },
157//    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "OMX.PV.amrdec" },
158    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.TI.AAC.decode" },
159    { MEDIA_MIMETYPE_AUDIO_AAC, "AACDecoder" },
160//    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.PV.aacdec" },
161    { MEDIA_MIMETYPE_AUDIO_G711_ALAW, "G711Decoder" },
162    { MEDIA_MIMETYPE_AUDIO_G711_MLAW, "G711Decoder" },
163    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.qcom.7x30.video.decoder.mpeg4" },
164    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.qcom.video.decoder.mpeg4" },
165    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.Video.Decoder" },
166    { MEDIA_MIMETYPE_VIDEO_MPEG4, "M4vH263Decoder" },
167//    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.PV.mpeg4dec" },
168    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.qcom.7x30.video.decoder.h263" },
169    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.qcom.video.decoder.h263" },
170    { MEDIA_MIMETYPE_VIDEO_H263, "M4vH263Decoder" },
171//    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.PV.h263dec" },
172    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.qcom.7x30.video.decoder.avc" },
173    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.qcom.video.decoder.avc" },
174    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.TI.Video.Decoder" },
175    { MEDIA_MIMETYPE_VIDEO_AVC, "AVCDecoder" },
176//    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.PV.avcdec" },
177    { MEDIA_MIMETYPE_AUDIO_VORBIS, "VorbisDecoder" },
178    { MEDIA_MIMETYPE_VIDEO_VPX, "VPXDecoder" },
179};
180
181static const CodecInfo kEncoderInfo[] = {
182    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "OMX.TI.AMR.encode" },
183    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "AMRNBEncoder" },
184    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "OMX.TI.WBAMR.encode" },
185    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "AMRWBEncoder" },
186    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.TI.AAC.encode" },
187    { MEDIA_MIMETYPE_AUDIO_AAC, "AACEncoder" },
188//    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.PV.aacenc" },
189    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.qcom.7x30.video.encoder.mpeg4" },
190    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.qcom.video.encoder.mpeg4" },
191    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.Video.encoder" },
192    { MEDIA_MIMETYPE_VIDEO_MPEG4, "M4vH263Encoder" },
193//    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.PV.mpeg4enc" },
194    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.qcom.7x30.video.encoder.h263" },
195    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.qcom.video.encoder.h263" },
196    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.TI.Video.encoder" },
197    { MEDIA_MIMETYPE_VIDEO_H263, "M4vH263Encoder" },
198//    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.PV.h263enc" },
199    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.qcom.7x30.video.encoder.avc" },
200    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.qcom.video.encoder.avc" },
201    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.TI.Video.encoder" },
202    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.Nvidia.h264.encoder" },
203    { MEDIA_MIMETYPE_VIDEO_AVC, "AVCEncoder" },
204//    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.PV.avcenc" },
205};
206
207#undef OPTIONAL
208
209#define CODEC_LOGI(x, ...) LOGI("[%s] "x, mComponentName, ##__VA_ARGS__)
210#define CODEC_LOGV(x, ...) LOGV("[%s] "x, mComponentName, ##__VA_ARGS__)
211#define CODEC_LOGE(x, ...) LOGE("[%s] "x, mComponentName, ##__VA_ARGS__)
212
213struct OMXCodecObserver : public BnOMXObserver {
214    OMXCodecObserver() {
215    }
216
217    void setCodec(const sp<OMXCodec> &target) {
218        mTarget = target;
219    }
220
221    // from IOMXObserver
222    virtual void onMessage(const omx_message &msg) {
223        sp<OMXCodec> codec = mTarget.promote();
224
225        if (codec.get() != NULL) {
226            codec->on_message(msg);
227        }
228    }
229
230protected:
231    virtual ~OMXCodecObserver() {}
232
233private:
234    wp<OMXCodec> mTarget;
235
236    OMXCodecObserver(const OMXCodecObserver &);
237    OMXCodecObserver &operator=(const OMXCodecObserver &);
238};
239
240static const char *GetCodec(const CodecInfo *info, size_t numInfos,
241                            const char *mime, int index) {
242    CHECK(index >= 0);
243    for(size_t i = 0; i < numInfos; ++i) {
244        if (!strcasecmp(mime, info[i].mime)) {
245            if (index == 0) {
246                return info[i].codec;
247            }
248
249            --index;
250        }
251    }
252
253    return NULL;
254}
255
256enum {
257    kAVCProfileBaseline      = 0x42,
258    kAVCProfileMain          = 0x4d,
259    kAVCProfileExtended      = 0x58,
260    kAVCProfileHigh          = 0x64,
261    kAVCProfileHigh10        = 0x6e,
262    kAVCProfileHigh422       = 0x7a,
263    kAVCProfileHigh444       = 0xf4,
264    kAVCProfileCAVLC444Intra = 0x2c
265};
266
267static const char *AVCProfileToString(uint8_t profile) {
268    switch (profile) {
269        case kAVCProfileBaseline:
270            return "Baseline";
271        case kAVCProfileMain:
272            return "Main";
273        case kAVCProfileExtended:
274            return "Extended";
275        case kAVCProfileHigh:
276            return "High";
277        case kAVCProfileHigh10:
278            return "High 10";
279        case kAVCProfileHigh422:
280            return "High 422";
281        case kAVCProfileHigh444:
282            return "High 444";
283        case kAVCProfileCAVLC444Intra:
284            return "CAVLC 444 Intra";
285        default:   return "Unknown";
286    }
287}
288
289template<class T>
290static void InitOMXParams(T *params) {
291    params->nSize = sizeof(T);
292    params->nVersion.s.nVersionMajor = 1;
293    params->nVersion.s.nVersionMinor = 0;
294    params->nVersion.s.nRevision = 0;
295    params->nVersion.s.nStep = 0;
296}
297
298static bool IsSoftwareCodec(const char *componentName) {
299    if (!strncmp("OMX.PV.", componentName, 7)) {
300        return true;
301    }
302
303    return false;
304}
305
306// A sort order in which non-OMX components are first,
307// followed by software codecs, i.e. OMX.PV.*, followed
308// by all the others.
309static int CompareSoftwareCodecsFirst(
310        const String8 *elem1, const String8 *elem2) {
311    bool isNotOMX1 = strncmp(elem1->string(), "OMX.", 4);
312    bool isNotOMX2 = strncmp(elem2->string(), "OMX.", 4);
313
314    if (isNotOMX1) {
315        if (isNotOMX2) { return 0; }
316        return -1;
317    }
318    if (isNotOMX2) {
319        return 1;
320    }
321
322    bool isSoftwareCodec1 = IsSoftwareCodec(elem1->string());
323    bool isSoftwareCodec2 = IsSoftwareCodec(elem2->string());
324
325    if (isSoftwareCodec1) {
326        if (isSoftwareCodec2) { return 0; }
327        return -1;
328    }
329
330    if (isSoftwareCodec2) {
331        return 1;
332    }
333
334    return 0;
335}
336
337// static
338uint32_t OMXCodec::getComponentQuirks(const char *componentName) {
339    uint32_t quirks = 0;
340
341    if (!strcmp(componentName, "OMX.PV.avcdec")) {
342        quirks |= kWantsNALFragments;
343    }
344    if (!strcmp(componentName, "OMX.TI.MP3.decode")) {
345        quirks |= kNeedsFlushBeforeDisable;
346        quirks |= kDecoderLiesAboutNumberOfChannels;
347    }
348    if (!strcmp(componentName, "OMX.TI.AAC.decode")) {
349        quirks |= kNeedsFlushBeforeDisable;
350        quirks |= kRequiresFlushCompleteEmulation;
351        quirks |= kSupportsMultipleFramesPerInputBuffer;
352    }
353    if (!strncmp(componentName, "OMX.qcom.video.encoder.", 23)) {
354        quirks |= kRequiresLoadedToIdleAfterAllocation;
355        quirks |= kRequiresAllocateBufferOnInputPorts;
356        quirks |= kRequiresAllocateBufferOnOutputPorts;
357    }
358    if (!strncmp(componentName, "OMX.qcom.7x30.video.encoder.", 28)) {
359    }
360    if (!strncmp(componentName, "OMX.qcom.video.decoder.", 23)) {
361        quirks |= kRequiresAllocateBufferOnOutputPorts;
362        quirks |= kDefersOutputBufferAllocation;
363    }
364    if (!strncmp(componentName, "OMX.qcom.7x30.video.decoder.", 28)) {
365        quirks |= kRequiresAllocateBufferOnInputPorts;
366        quirks |= kRequiresAllocateBufferOnOutputPorts;
367        quirks |= kDefersOutputBufferAllocation;
368    }
369
370    if (!strncmp(componentName, "OMX.TI.", 7)) {
371        // Apparently I must not use OMX_UseBuffer on either input or
372        // output ports on any of the TI components or quote:
373        // "(I) may have unexpected problem (sic) which can be timing related
374        //  and hard to reproduce."
375
376        quirks |= kRequiresAllocateBufferOnInputPorts;
377        quirks |= kRequiresAllocateBufferOnOutputPorts;
378        if (!strncmp(componentName, "OMX.TI.Video.encoder", 20)) {
379            quirks |= kAvoidMemcopyInputRecordingFrames;
380        }
381    }
382
383    if (!strcmp(componentName, "OMX.TI.Video.Decoder")) {
384        quirks |= kInputBufferSizesAreBogus;
385    }
386
387    return quirks;
388}
389
390// static
391void OMXCodec::findMatchingCodecs(
392        const char *mime,
393        bool createEncoder, const char *matchComponentName,
394        uint32_t flags,
395        Vector<String8> *matchingCodecs) {
396    matchingCodecs->clear();
397
398    for (int index = 0;; ++index) {
399        const char *componentName;
400
401        if (createEncoder) {
402            componentName = GetCodec(
403                    kEncoderInfo,
404                    sizeof(kEncoderInfo) / sizeof(kEncoderInfo[0]),
405                    mime, index);
406        } else {
407            componentName = GetCodec(
408                    kDecoderInfo,
409                    sizeof(kDecoderInfo) / sizeof(kDecoderInfo[0]),
410                    mime, index);
411        }
412
413        if (!componentName) {
414            break;
415        }
416
417        // If a specific codec is requested, skip the non-matching ones.
418        if (matchComponentName && strcmp(componentName, matchComponentName)) {
419            continue;
420        }
421
422        matchingCodecs->push(String8(componentName));
423    }
424
425    if (flags & kPreferSoftwareCodecs) {
426        matchingCodecs->sort(CompareSoftwareCodecsFirst);
427    }
428}
429
430// static
431sp<MediaSource> OMXCodec::Create(
432        const sp<IOMX> &omx,
433        const sp<MetaData> &meta, bool createEncoder,
434        const sp<MediaSource> &source,
435        const char *matchComponentName,
436        uint32_t flags) {
437    const char *mime;
438    bool success = meta->findCString(kKeyMIMEType, &mime);
439    CHECK(success);
440
441    Vector<String8> matchingCodecs;
442    findMatchingCodecs(
443            mime, createEncoder, matchComponentName, flags, &matchingCodecs);
444
445    if (matchingCodecs.isEmpty()) {
446        return NULL;
447    }
448
449    sp<OMXCodecObserver> observer = new OMXCodecObserver;
450    IOMX::node_id node = 0;
451
452    const char *componentName;
453    for (size_t i = 0; i < matchingCodecs.size(); ++i) {
454        componentName = matchingCodecs[i].string();
455
456        sp<MediaSource> softwareCodec = createEncoder?
457            InstantiateSoftwareEncoder(componentName, source, meta):
458            InstantiateSoftwareCodec(componentName, source);
459
460        if (softwareCodec != NULL) {
461            LOGV("Successfully allocated software codec '%s'", componentName);
462
463            return softwareCodec;
464        }
465
466        LOGV("Attempting to allocate OMX node '%s'", componentName);
467
468        status_t err = omx->allocateNode(componentName, observer, &node);
469        if (err == OK) {
470            LOGV("Successfully allocated OMX node '%s'", componentName);
471
472            sp<OMXCodec> codec = new OMXCodec(
473                    omx, node, getComponentQuirks(componentName),
474                    createEncoder, mime, componentName,
475                    source);
476
477            observer->setCodec(codec);
478
479            err = codec->configureCodec(meta);
480
481            if (err == OK) {
482                return codec;
483            }
484
485            LOGV("Failed to configure codec '%s'", componentName);
486        }
487    }
488
489    return NULL;
490}
491
492status_t OMXCodec::configureCodec(const sp<MetaData> &meta) {
493    uint32_t type;
494    const void *data;
495    size_t size;
496    if (meta->findData(kKeyESDS, &type, &data, &size)) {
497        ESDS esds((const char *)data, size);
498        CHECK_EQ(esds.InitCheck(), OK);
499
500        const void *codec_specific_data;
501        size_t codec_specific_data_size;
502        esds.getCodecSpecificInfo(
503                &codec_specific_data, &codec_specific_data_size);
504
505        addCodecSpecificData(
506                codec_specific_data, codec_specific_data_size);
507    } else if (meta->findData(kKeyAVCC, &type, &data, &size)) {
508        // Parse the AVCDecoderConfigurationRecord
509
510        const uint8_t *ptr = (const uint8_t *)data;
511
512        CHECK(size >= 7);
513        CHECK_EQ(ptr[0], 1);  // configurationVersion == 1
514        uint8_t profile = ptr[1];
515        uint8_t level = ptr[3];
516
517        // There is decodable content out there that fails the following
518        // assertion, let's be lenient for now...
519        // CHECK((ptr[4] >> 2) == 0x3f);  // reserved
520
521        size_t lengthSize = 1 + (ptr[4] & 3);
522
523        // commented out check below as H264_QVGA_500_NO_AUDIO.3gp
524        // violates it...
525        // CHECK((ptr[5] >> 5) == 7);  // reserved
526
527        size_t numSeqParameterSets = ptr[5] & 31;
528
529        ptr += 6;
530        size -= 6;
531
532        for (size_t i = 0; i < numSeqParameterSets; ++i) {
533            CHECK(size >= 2);
534            size_t length = U16_AT(ptr);
535
536            ptr += 2;
537            size -= 2;
538
539            CHECK(size >= length);
540
541            addCodecSpecificData(ptr, length);
542
543            ptr += length;
544            size -= length;
545        }
546
547        CHECK(size >= 1);
548        size_t numPictureParameterSets = *ptr;
549        ++ptr;
550        --size;
551
552        for (size_t i = 0; i < numPictureParameterSets; ++i) {
553            CHECK(size >= 2);
554            size_t length = U16_AT(ptr);
555
556            ptr += 2;
557            size -= 2;
558
559            CHECK(size >= length);
560
561            addCodecSpecificData(ptr, length);
562
563            ptr += length;
564            size -= length;
565        }
566
567        CODEC_LOGV(
568                "AVC profile = %d (%s), level = %d",
569                (int)profile, AVCProfileToString(profile), level);
570
571        if (!strcmp(mComponentName, "OMX.TI.Video.Decoder")
572            && (profile != kAVCProfileBaseline || level > 30)) {
573            // This stream exceeds the decoder's capabilities. The decoder
574            // does not handle this gracefully and would clobber the heap
575            // and wreak havoc instead...
576
577            LOGE("Profile and/or level exceed the decoder's capabilities.");
578            return ERROR_UNSUPPORTED;
579        }
580    }
581
582    int32_t bitRate = 0;
583    if (mIsEncoder) {
584        CHECK(meta->findInt32(kKeyBitRate, &bitRate));
585    }
586    if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_NB, mMIME)) {
587        setAMRFormat(false /* isWAMR */, bitRate);
588    }
589    if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_WB, mMIME)) {
590        setAMRFormat(true /* isWAMR */, bitRate);
591    }
592    if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AAC, mMIME)) {
593        int32_t numChannels, sampleRate;
594        CHECK(meta->findInt32(kKeyChannelCount, &numChannels));
595        CHECK(meta->findInt32(kKeySampleRate, &sampleRate));
596
597        setAACFormat(numChannels, sampleRate, bitRate);
598    }
599
600    if (!strncasecmp(mMIME, "video/", 6)) {
601
602        if (mIsEncoder) {
603            setVideoInputFormat(mMIME, meta);
604        } else {
605            int32_t width, height;
606            bool success = meta->findInt32(kKeyWidth, &width);
607            success = success && meta->findInt32(kKeyHeight, &height);
608            CHECK(success);
609            status_t err = setVideoOutputFormat(
610                    mMIME, width, height);
611
612            if (err != OK) {
613                return err;
614            }
615        }
616    }
617
618    if (!strcasecmp(mMIME, MEDIA_MIMETYPE_IMAGE_JPEG)
619        && !strcmp(mComponentName, "OMX.TI.JPEG.decode")) {
620        OMX_COLOR_FORMATTYPE format =
621            OMX_COLOR_Format32bitARGB8888;
622            // OMX_COLOR_FormatYUV420PackedPlanar;
623            // OMX_COLOR_FormatCbYCrY;
624            // OMX_COLOR_FormatYUV411Planar;
625
626        int32_t width, height;
627        bool success = meta->findInt32(kKeyWidth, &width);
628        success = success && meta->findInt32(kKeyHeight, &height);
629
630        int32_t compressedSize;
631        success = success && meta->findInt32(
632                kKeyMaxInputSize, &compressedSize);
633
634        CHECK(success);
635        CHECK(compressedSize > 0);
636
637        setImageOutputFormat(format, width, height);
638        setJPEGInputFormat(width, height, (OMX_U32)compressedSize);
639    }
640
641    int32_t maxInputSize;
642    if (meta->findInt32(kKeyMaxInputSize, &maxInputSize)) {
643        setMinBufferSize(kPortIndexInput, (OMX_U32)maxInputSize);
644    }
645
646    if (!strcmp(mComponentName, "OMX.TI.AMR.encode")
647        || !strcmp(mComponentName, "OMX.TI.WBAMR.encode")
648        || !strcmp(mComponentName, "OMX.TI.AAC.encode")) {
649        setMinBufferSize(kPortIndexOutput, 8192);  // XXX
650    }
651
652    initOutputFormat(meta);
653
654    return OK;
655}
656
657void OMXCodec::setMinBufferSize(OMX_U32 portIndex, OMX_U32 size) {
658    OMX_PARAM_PORTDEFINITIONTYPE def;
659    InitOMXParams(&def);
660    def.nPortIndex = portIndex;
661
662    status_t err = mOMX->getParameter(
663            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
664    CHECK_EQ(err, OK);
665
666    if ((portIndex == kPortIndexInput && (mQuirks & kInputBufferSizesAreBogus))
667        || (def.nBufferSize < size)) {
668        def.nBufferSize = size;
669    }
670
671    err = mOMX->setParameter(
672            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
673    CHECK_EQ(err, OK);
674
675    err = mOMX->getParameter(
676            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
677    CHECK_EQ(err, OK);
678
679    // Make sure the setting actually stuck.
680    if (portIndex == kPortIndexInput
681            && (mQuirks & kInputBufferSizesAreBogus)) {
682        CHECK_EQ(def.nBufferSize, size);
683    } else {
684        CHECK(def.nBufferSize >= size);
685    }
686}
687
688status_t OMXCodec::setVideoPortFormatType(
689        OMX_U32 portIndex,
690        OMX_VIDEO_CODINGTYPE compressionFormat,
691        OMX_COLOR_FORMATTYPE colorFormat) {
692    OMX_VIDEO_PARAM_PORTFORMATTYPE format;
693    InitOMXParams(&format);
694    format.nPortIndex = portIndex;
695    format.nIndex = 0;
696    bool found = false;
697
698    OMX_U32 index = 0;
699    for (;;) {
700        format.nIndex = index;
701        status_t err = mOMX->getParameter(
702                mNode, OMX_IndexParamVideoPortFormat,
703                &format, sizeof(format));
704
705        if (err != OK) {
706            return err;
707        }
708
709        // The following assertion is violated by TI's video decoder.
710        // CHECK_EQ(format.nIndex, index);
711
712#if 1
713        CODEC_LOGV("portIndex: %ld, index: %ld, eCompressionFormat=%d eColorFormat=%d",
714             portIndex,
715             index, format.eCompressionFormat, format.eColorFormat);
716#endif
717
718        if (!strcmp("OMX.TI.Video.encoder", mComponentName)) {
719            if (portIndex == kPortIndexInput
720                    && colorFormat == format.eColorFormat) {
721                // eCompressionFormat does not seem right.
722                found = true;
723                break;
724            }
725            if (portIndex == kPortIndexOutput
726                    && compressionFormat == format.eCompressionFormat) {
727                // eColorFormat does not seem right.
728                found = true;
729                break;
730            }
731        }
732
733        if (format.eCompressionFormat == compressionFormat
734            && format.eColorFormat == colorFormat) {
735            found = true;
736            break;
737        }
738
739        ++index;
740    }
741
742    if (!found) {
743        return UNKNOWN_ERROR;
744    }
745
746    CODEC_LOGV("found a match.");
747    status_t err = mOMX->setParameter(
748            mNode, OMX_IndexParamVideoPortFormat,
749            &format, sizeof(format));
750
751    return err;
752}
753
754static size_t getFrameSize(
755        OMX_COLOR_FORMATTYPE colorFormat, int32_t width, int32_t height) {
756    switch (colorFormat) {
757        case OMX_COLOR_FormatYCbYCr:
758        case OMX_COLOR_FormatCbYCrY:
759            return width * height * 2;
760
761        case OMX_COLOR_FormatYUV420Planar:
762        case OMX_COLOR_FormatYUV420SemiPlanar:
763            return (width * height * 3) / 2;
764
765        default:
766            CHECK(!"Should not be here. Unsupported color format.");
767            break;
768    }
769}
770
771status_t OMXCodec::findTargetColorFormat(
772        const sp<MetaData>& meta, OMX_COLOR_FORMATTYPE *colorFormat) {
773    LOGV("findTargetColorFormat");
774    CHECK(mIsEncoder);
775
776    *colorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
777    int32_t targetColorFormat;
778    if (meta->findInt32(kKeyColorFormat, &targetColorFormat)) {
779        *colorFormat = (OMX_COLOR_FORMATTYPE) targetColorFormat;
780    } else {
781        if (!strcasecmp("OMX.TI.Video.encoder", mComponentName)) {
782            *colorFormat = OMX_COLOR_FormatYCbYCr;
783        }
784    }
785
786    // Check whether the target color format is supported.
787    return isColorFormatSupported(*colorFormat, kPortIndexInput);
788}
789
790status_t OMXCodec::isColorFormatSupported(
791        OMX_COLOR_FORMATTYPE colorFormat, int portIndex) {
792    LOGV("isColorFormatSupported: %d", static_cast<int>(colorFormat));
793
794    // Enumerate all the color formats supported by
795    // the omx component to see whether the given
796    // color format is supported.
797    OMX_VIDEO_PARAM_PORTFORMATTYPE portFormat;
798    InitOMXParams(&portFormat);
799    portFormat.nPortIndex = portIndex;
800    OMX_U32 index = 0;
801    portFormat.nIndex = index;
802    while (true) {
803        if (OMX_ErrorNone != mOMX->getParameter(
804                mNode, OMX_IndexParamVideoPortFormat,
805                &portFormat, sizeof(portFormat))) {
806
807            return UNKNOWN_ERROR;
808        }
809        // Make sure that omx component does not overwrite
810        // the incremented index (bug 2897413).
811        CHECK_EQ(index, portFormat.nIndex);
812        if ((portFormat.eColorFormat == colorFormat)) {
813            LOGV("Found supported color format: %d", portFormat.eColorFormat);
814            return OK;  // colorFormat is supported!
815        }
816        ++index;
817        portFormat.nIndex = index;
818
819        // OMX Spec defines less than 50 color formats
820        // 1000 is more than enough for us to tell whether the omx
821        // component in question is buggy or not.
822        if (index >= 1000) {
823            LOGE("More than %ld color formats are supported???", index);
824            break;
825        }
826    }
827    return UNKNOWN_ERROR;
828}
829
830void OMXCodec::setVideoInputFormat(
831        const char *mime, const sp<MetaData>& meta) {
832
833    int32_t width, height, frameRate, bitRate, stride, sliceHeight;
834    bool success = meta->findInt32(kKeyWidth, &width);
835    success = success && meta->findInt32(kKeyHeight, &height);
836    success = success && meta->findInt32(kKeySampleRate, &frameRate);
837    success = success && meta->findInt32(kKeyBitRate, &bitRate);
838    success = success && meta->findInt32(kKeyStride, &stride);
839    success = success && meta->findInt32(kKeySliceHeight, &sliceHeight);
840    CHECK(success);
841    CHECK(stride != 0);
842
843    OMX_VIDEO_CODINGTYPE compressionFormat = OMX_VIDEO_CodingUnused;
844    if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mime)) {
845        compressionFormat = OMX_VIDEO_CodingAVC;
846    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG4, mime)) {
847        compressionFormat = OMX_VIDEO_CodingMPEG4;
848    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_H263, mime)) {
849        compressionFormat = OMX_VIDEO_CodingH263;
850    } else {
851        LOGE("Not a supported video mime type: %s", mime);
852        CHECK(!"Should not be here. Not a supported video mime type.");
853    }
854
855    OMX_COLOR_FORMATTYPE colorFormat;
856    CHECK_EQ(OK, findTargetColorFormat(meta, &colorFormat));
857
858    if (!strcasecmp("OMX.Nvidia.h264.encoder", mComponentName)) {
859        colorFormat = OMX_COLOR_FormatYUV420Planar;
860    }
861
862    status_t err;
863    OMX_PARAM_PORTDEFINITIONTYPE def;
864    OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
865
866    //////////////////////// Input port /////////////////////////
867    CHECK_EQ(setVideoPortFormatType(
868            kPortIndexInput, OMX_VIDEO_CodingUnused,
869            colorFormat), OK);
870
871    InitOMXParams(&def);
872    def.nPortIndex = kPortIndexInput;
873
874    err = mOMX->getParameter(
875            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
876    CHECK_EQ(err, OK);
877
878    def.nBufferSize = getFrameSize(colorFormat,
879            stride > 0? stride: -stride, sliceHeight);
880
881    CHECK_EQ(def.eDomain, OMX_PortDomainVideo);
882
883    video_def->nFrameWidth = width;
884    video_def->nFrameHeight = height;
885    video_def->nStride = stride;
886    video_def->nSliceHeight = sliceHeight;
887    video_def->xFramerate = (frameRate << 16);  // Q16 format
888    video_def->eCompressionFormat = OMX_VIDEO_CodingUnused;
889    video_def->eColorFormat = colorFormat;
890
891    err = mOMX->setParameter(
892            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
893    CHECK_EQ(err, OK);
894
895    //////////////////////// Output port /////////////////////////
896    CHECK_EQ(setVideoPortFormatType(
897            kPortIndexOutput, compressionFormat, OMX_COLOR_FormatUnused),
898            OK);
899    InitOMXParams(&def);
900    def.nPortIndex = kPortIndexOutput;
901
902    err = mOMX->getParameter(
903            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
904
905    CHECK_EQ(err, OK);
906    CHECK_EQ(def.eDomain, OMX_PortDomainVideo);
907
908    video_def->nFrameWidth = width;
909    video_def->nFrameHeight = height;
910    video_def->xFramerate = 0;      // No need for output port
911    video_def->nBitrate = bitRate;  // Q16 format
912    video_def->eCompressionFormat = compressionFormat;
913    video_def->eColorFormat = OMX_COLOR_FormatUnused;
914
915    err = mOMX->setParameter(
916            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
917    CHECK_EQ(err, OK);
918
919    /////////////////// Codec-specific ////////////////////////
920    switch (compressionFormat) {
921        case OMX_VIDEO_CodingMPEG4:
922        {
923            CHECK_EQ(setupMPEG4EncoderParameters(meta), OK);
924            break;
925        }
926
927        case OMX_VIDEO_CodingH263:
928            CHECK_EQ(setupH263EncoderParameters(meta), OK);
929            break;
930
931        case OMX_VIDEO_CodingAVC:
932        {
933            CHECK_EQ(setupAVCEncoderParameters(meta), OK);
934            break;
935        }
936
937        default:
938            CHECK(!"Support for this compressionFormat to be implemented.");
939            break;
940    }
941}
942
943static OMX_U32 setPFramesSpacing(int32_t iFramesInterval, int32_t frameRate) {
944    if (iFramesInterval < 0) {
945        return 0xFFFFFFFF;
946    } else if (iFramesInterval == 0) {
947        return 0;
948    }
949    OMX_U32 ret = frameRate * iFramesInterval;
950    CHECK(ret > 1);
951    return ret;
952}
953
954status_t OMXCodec::setupErrorCorrectionParameters() {
955    OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType;
956    InitOMXParams(&errorCorrectionType);
957    errorCorrectionType.nPortIndex = kPortIndexOutput;
958
959    status_t err = mOMX->getParameter(
960            mNode, OMX_IndexParamVideoErrorCorrection,
961            &errorCorrectionType, sizeof(errorCorrectionType));
962    CHECK_EQ(err, OK);
963
964    errorCorrectionType.bEnableHEC = OMX_FALSE;
965    errorCorrectionType.bEnableResync = OMX_TRUE;
966    errorCorrectionType.nResynchMarkerSpacing = 256;
967    errorCorrectionType.bEnableDataPartitioning = OMX_FALSE;
968    errorCorrectionType.bEnableRVLC = OMX_FALSE;
969
970    err = mOMX->setParameter(
971            mNode, OMX_IndexParamVideoErrorCorrection,
972            &errorCorrectionType, sizeof(errorCorrectionType));
973    CHECK_EQ(err, OK);
974    return OK;
975}
976
977status_t OMXCodec::setupBitRate(int32_t bitRate) {
978    OMX_VIDEO_PARAM_BITRATETYPE bitrateType;
979    InitOMXParams(&bitrateType);
980    bitrateType.nPortIndex = kPortIndexOutput;
981
982    status_t err = mOMX->getParameter(
983            mNode, OMX_IndexParamVideoBitrate,
984            &bitrateType, sizeof(bitrateType));
985    CHECK_EQ(err, OK);
986
987    bitrateType.eControlRate = OMX_Video_ControlRateVariable;
988    bitrateType.nTargetBitrate = bitRate;
989
990    err = mOMX->setParameter(
991            mNode, OMX_IndexParamVideoBitrate,
992            &bitrateType, sizeof(bitrateType));
993    CHECK_EQ(err, OK);
994    return OK;
995}
996
997status_t OMXCodec::getVideoProfileLevel(
998        const sp<MetaData>& meta,
999        const CodecProfileLevel& defaultProfileLevel,
1000        CodecProfileLevel &profileLevel) {
1001    CODEC_LOGV("Default profile: %ld, level %ld",
1002            defaultProfileLevel.mProfile, defaultProfileLevel.mLevel);
1003
1004    // Are the default profile and level overwriten?
1005    int32_t profile, level;
1006    if (!meta->findInt32(kKeyVideoProfile, &profile)) {
1007        profile = defaultProfileLevel.mProfile;
1008    }
1009    if (!meta->findInt32(kKeyVideoLevel, &level)) {
1010        level = defaultProfileLevel.mLevel;
1011    }
1012    CODEC_LOGV("Target profile: %d, level: %d", profile, level);
1013
1014    // Are the target profile and level supported by the encoder?
1015    OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
1016    InitOMXParams(&param);
1017    param.nPortIndex = kPortIndexOutput;
1018    for (param.nProfileIndex = 0;; ++param.nProfileIndex) {
1019        status_t err = mOMX->getParameter(
1020                mNode, OMX_IndexParamVideoProfileLevelQuerySupported,
1021                &param, sizeof(param));
1022
1023        if (err != OK) return err;
1024
1025        int32_t supportedProfile = static_cast<int32_t>(param.eProfile);
1026        int32_t supportedLevel = static_cast<int32_t>(param.eLevel);
1027        CODEC_LOGV("Supported profile: %d, level %d",
1028            supportedProfile, supportedLevel);
1029
1030        if (profile == supportedProfile &&
1031            level == supportedLevel) {
1032            profileLevel.mProfile = profile;
1033            profileLevel.mLevel = level;
1034            return OK;
1035        }
1036    }
1037
1038    CODEC_LOGE("Target profile (%d) and level (%d) is not supported",
1039            profile, level);
1040    return BAD_VALUE;
1041}
1042
1043status_t OMXCodec::setupH263EncoderParameters(const sp<MetaData>& meta) {
1044    int32_t iFramesInterval, frameRate, bitRate;
1045    bool success = meta->findInt32(kKeyBitRate, &bitRate);
1046    success = success && meta->findInt32(kKeySampleRate, &frameRate);
1047    success = success && meta->findInt32(kKeyIFramesInterval, &iFramesInterval);
1048    CHECK(success);
1049    OMX_VIDEO_PARAM_H263TYPE h263type;
1050    InitOMXParams(&h263type);
1051    h263type.nPortIndex = kPortIndexOutput;
1052
1053    status_t err = mOMX->getParameter(
1054            mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type));
1055    CHECK_EQ(err, OK);
1056
1057    h263type.nAllowedPictureTypes =
1058        OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
1059
1060    h263type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);
1061    if (h263type.nPFrames == 0) {
1062        h263type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
1063    }
1064    h263type.nBFrames = 0;
1065
1066    // Check profile and level parameters
1067    CodecProfileLevel defaultProfileLevel, profileLevel;
1068    defaultProfileLevel.mProfile = OMX_VIDEO_H263ProfileBaseline;
1069    defaultProfileLevel.mLevel = OMX_VIDEO_H263Level45;
1070    err = getVideoProfileLevel(meta, defaultProfileLevel, profileLevel);
1071    if (err != OK) return err;
1072    h263type.eProfile = static_cast<OMX_VIDEO_H263PROFILETYPE>(profileLevel.mProfile);
1073    h263type.eLevel = static_cast<OMX_VIDEO_H263LEVELTYPE>(profileLevel.mLevel);
1074
1075    h263type.bPLUSPTYPEAllowed = OMX_FALSE;
1076    h263type.bForceRoundingTypeToZero = OMX_FALSE;
1077    h263type.nPictureHeaderRepetition = 0;
1078    h263type.nGOBHeaderInterval = 0;
1079
1080    err = mOMX->setParameter(
1081            mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type));
1082    CHECK_EQ(err, OK);
1083
1084    CHECK_EQ(setupBitRate(bitRate), OK);
1085    CHECK_EQ(setupErrorCorrectionParameters(), OK);
1086
1087    return OK;
1088}
1089
1090status_t OMXCodec::setupMPEG4EncoderParameters(const sp<MetaData>& meta) {
1091    int32_t iFramesInterval, frameRate, bitRate;
1092    bool success = meta->findInt32(kKeyBitRate, &bitRate);
1093    success = success && meta->findInt32(kKeySampleRate, &frameRate);
1094    success = success && meta->findInt32(kKeyIFramesInterval, &iFramesInterval);
1095    CHECK(success);
1096    OMX_VIDEO_PARAM_MPEG4TYPE mpeg4type;
1097    InitOMXParams(&mpeg4type);
1098    mpeg4type.nPortIndex = kPortIndexOutput;
1099
1100    status_t err = mOMX->getParameter(
1101            mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type));
1102    CHECK_EQ(err, OK);
1103
1104    mpeg4type.nSliceHeaderSpacing = 0;
1105    mpeg4type.bSVH = OMX_FALSE;
1106    mpeg4type.bGov = OMX_FALSE;
1107
1108    mpeg4type.nAllowedPictureTypes =
1109        OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
1110
1111    mpeg4type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);
1112    if (mpeg4type.nPFrames == 0) {
1113        mpeg4type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
1114    }
1115    mpeg4type.nBFrames = 0;
1116    mpeg4type.nIDCVLCThreshold = 0;
1117    mpeg4type.bACPred = OMX_TRUE;
1118    mpeg4type.nMaxPacketSize = 256;
1119    mpeg4type.nTimeIncRes = 1000;
1120    mpeg4type.nHeaderExtension = 0;
1121    mpeg4type.bReversibleVLC = OMX_FALSE;
1122
1123    // Check profile and level parameters
1124    CodecProfileLevel defaultProfileLevel, profileLevel;
1125    defaultProfileLevel.mProfile = OMX_VIDEO_MPEG4ProfileSimple;
1126    defaultProfileLevel.mLevel = OMX_VIDEO_MPEG4Level2;
1127    err = getVideoProfileLevel(meta, defaultProfileLevel, profileLevel);
1128    if (err != OK) return err;
1129    mpeg4type.eProfile = static_cast<OMX_VIDEO_MPEG4PROFILETYPE>(profileLevel.mProfile);
1130    mpeg4type.eLevel = static_cast<OMX_VIDEO_MPEG4LEVELTYPE>(profileLevel.mLevel);
1131
1132    err = mOMX->setParameter(
1133            mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type));
1134    CHECK_EQ(err, OK);
1135
1136    CHECK_EQ(setupBitRate(bitRate), OK);
1137    CHECK_EQ(setupErrorCorrectionParameters(), OK);
1138
1139    return OK;
1140}
1141
1142status_t OMXCodec::setupAVCEncoderParameters(const sp<MetaData>& meta) {
1143    int32_t iFramesInterval, frameRate, bitRate;
1144    bool success = meta->findInt32(kKeyBitRate, &bitRate);
1145    success = success && meta->findInt32(kKeySampleRate, &frameRate);
1146    success = success && meta->findInt32(kKeyIFramesInterval, &iFramesInterval);
1147    CHECK(success);
1148
1149    OMX_VIDEO_PARAM_AVCTYPE h264type;
1150    InitOMXParams(&h264type);
1151    h264type.nPortIndex = kPortIndexOutput;
1152
1153    status_t err = mOMX->getParameter(
1154            mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));
1155    CHECK_EQ(err, OK);
1156
1157    h264type.nAllowedPictureTypes =
1158        OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
1159
1160    h264type.nSliceHeaderSpacing = 0;
1161    h264type.nBFrames = 0;   // No B frames support yet
1162    h264type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);
1163    if (h264type.nPFrames == 0) {
1164        h264type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
1165    }
1166
1167    // Check profile and level parameters
1168    CodecProfileLevel defaultProfileLevel, profileLevel;
1169    defaultProfileLevel.mProfile = h264type.eProfile;
1170    defaultProfileLevel.mLevel = h264type.eLevel;
1171    err = getVideoProfileLevel(meta, defaultProfileLevel, profileLevel);
1172    if (err != OK) return err;
1173    h264type.eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>(profileLevel.mProfile);
1174    h264type.eLevel = static_cast<OMX_VIDEO_AVCLEVELTYPE>(profileLevel.mLevel);
1175
1176    if (h264type.eProfile == OMX_VIDEO_AVCProfileBaseline) {
1177        h264type.bUseHadamard = OMX_TRUE;
1178        h264type.nRefFrames = 1;
1179        h264type.nRefIdx10ActiveMinus1 = 0;
1180        h264type.nRefIdx11ActiveMinus1 = 0;
1181        h264type.bEntropyCodingCABAC = OMX_FALSE;
1182        h264type.bWeightedPPrediction = OMX_FALSE;
1183        h264type.bconstIpred = OMX_FALSE;
1184        h264type.bDirect8x8Inference = OMX_FALSE;
1185        h264type.bDirectSpatialTemporal = OMX_FALSE;
1186        h264type.nCabacInitIdc = 0;
1187    }
1188
1189    if (h264type.nBFrames != 0) {
1190        h264type.nAllowedPictureTypes |= OMX_VIDEO_PictureTypeB;
1191    }
1192
1193    h264type.bEnableUEP = OMX_FALSE;
1194    h264type.bEnableFMO = OMX_FALSE;
1195    h264type.bEnableASO = OMX_FALSE;
1196    h264type.bEnableRS = OMX_FALSE;
1197    h264type.bFrameMBsOnly = OMX_TRUE;
1198    h264type.bMBAFF = OMX_FALSE;
1199    h264type.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable;
1200
1201    if (!strcasecmp("OMX.Nvidia.h264.encoder", mComponentName)) {
1202        h264type.eLevel = OMX_VIDEO_AVCLevelMax;
1203    }
1204
1205    err = mOMX->setParameter(
1206            mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));
1207    CHECK_EQ(err, OK);
1208
1209    CHECK_EQ(setupBitRate(bitRate), OK);
1210
1211    return OK;
1212}
1213
1214status_t OMXCodec::setVideoOutputFormat(
1215        const char *mime, OMX_U32 width, OMX_U32 height) {
1216    CODEC_LOGV("setVideoOutputFormat width=%ld, height=%ld", width, height);
1217
1218    OMX_VIDEO_CODINGTYPE compressionFormat = OMX_VIDEO_CodingUnused;
1219    if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mime)) {
1220        compressionFormat = OMX_VIDEO_CodingAVC;
1221    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG4, mime)) {
1222        compressionFormat = OMX_VIDEO_CodingMPEG4;
1223    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_H263, mime)) {
1224        compressionFormat = OMX_VIDEO_CodingH263;
1225    } else {
1226        LOGE("Not a supported video mime type: %s", mime);
1227        CHECK(!"Should not be here. Not a supported video mime type.");
1228    }
1229
1230    status_t err = setVideoPortFormatType(
1231            kPortIndexInput, compressionFormat, OMX_COLOR_FormatUnused);
1232
1233    if (err != OK) {
1234        return err;
1235    }
1236
1237#if 1
1238    {
1239        OMX_VIDEO_PARAM_PORTFORMATTYPE format;
1240        InitOMXParams(&format);
1241        format.nPortIndex = kPortIndexOutput;
1242        format.nIndex = 0;
1243
1244        status_t err = mOMX->getParameter(
1245                mNode, OMX_IndexParamVideoPortFormat,
1246                &format, sizeof(format));
1247        CHECK_EQ(err, OK);
1248        CHECK_EQ(format.eCompressionFormat, OMX_VIDEO_CodingUnused);
1249
1250        static const int OMX_QCOM_COLOR_FormatYVU420SemiPlanar = 0x7FA30C00;
1251
1252        CHECK(format.eColorFormat == OMX_COLOR_FormatYUV420Planar
1253               || format.eColorFormat == OMX_COLOR_FormatYUV420SemiPlanar
1254               || format.eColorFormat == OMX_COLOR_FormatCbYCrY
1255               || format.eColorFormat == OMX_QCOM_COLOR_FormatYVU420SemiPlanar);
1256
1257        err = mOMX->setParameter(
1258                mNode, OMX_IndexParamVideoPortFormat,
1259                &format, sizeof(format));
1260
1261        if (err != OK) {
1262            return err;
1263        }
1264    }
1265#endif
1266
1267    OMX_PARAM_PORTDEFINITIONTYPE def;
1268    InitOMXParams(&def);
1269    def.nPortIndex = kPortIndexInput;
1270
1271    OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
1272
1273    err = mOMX->getParameter(
1274            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1275
1276    CHECK_EQ(err, OK);
1277
1278#if 1
1279    // XXX Need a (much) better heuristic to compute input buffer sizes.
1280    const size_t X = 64 * 1024;
1281    if (def.nBufferSize < X) {
1282        def.nBufferSize = X;
1283    }
1284#endif
1285
1286    CHECK_EQ(def.eDomain, OMX_PortDomainVideo);
1287
1288    video_def->nFrameWidth = width;
1289    video_def->nFrameHeight = height;
1290
1291    video_def->eCompressionFormat = compressionFormat;
1292    video_def->eColorFormat = OMX_COLOR_FormatUnused;
1293
1294    err = mOMX->setParameter(
1295            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1296
1297    if (err != OK) {
1298        return err;
1299    }
1300
1301    ////////////////////////////////////////////////////////////////////////////
1302
1303    InitOMXParams(&def);
1304    def.nPortIndex = kPortIndexOutput;
1305
1306    err = mOMX->getParameter(
1307            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1308    CHECK_EQ(err, OK);
1309    CHECK_EQ(def.eDomain, OMX_PortDomainVideo);
1310
1311#if 0
1312    def.nBufferSize =
1313        (((width + 15) & -16) * ((height + 15) & -16) * 3) / 2;  // YUV420
1314#endif
1315
1316    video_def->nFrameWidth = width;
1317    video_def->nFrameHeight = height;
1318
1319    err = mOMX->setParameter(
1320            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1321
1322    return err;
1323}
1324
1325OMXCodec::OMXCodec(
1326        const sp<IOMX> &omx, IOMX::node_id node, uint32_t quirks,
1327        bool isEncoder,
1328        const char *mime,
1329        const char *componentName,
1330        const sp<MediaSource> &source)
1331    : mOMX(omx),
1332      mOMXLivesLocally(omx->livesLocally(getpid())),
1333      mNode(node),
1334      mQuirks(quirks),
1335      mIsEncoder(isEncoder),
1336      mMIME(strdup(mime)),
1337      mComponentName(strdup(componentName)),
1338      mSource(source),
1339      mCodecSpecificDataIndex(0),
1340      mState(LOADED),
1341      mInitialBufferSubmit(true),
1342      mSignalledEOS(false),
1343      mNoMoreOutputData(false),
1344      mOutputPortSettingsHaveChanged(false),
1345      mSeekTimeUs(-1),
1346      mSeekMode(ReadOptions::SEEK_CLOSEST_SYNC),
1347      mTargetTimeUs(-1),
1348      mSkipTimeUs(-1),
1349      mLeftOverBuffer(NULL),
1350      mPaused(false) {
1351    mPortStatus[kPortIndexInput] = ENABLED;
1352    mPortStatus[kPortIndexOutput] = ENABLED;
1353
1354    setComponentRole();
1355}
1356
1357// static
1358void OMXCodec::setComponentRole(
1359        const sp<IOMX> &omx, IOMX::node_id node, bool isEncoder,
1360        const char *mime) {
1361    struct MimeToRole {
1362        const char *mime;
1363        const char *decoderRole;
1364        const char *encoderRole;
1365    };
1366
1367    static const MimeToRole kMimeToRole[] = {
1368        { MEDIA_MIMETYPE_AUDIO_MPEG,
1369            "audio_decoder.mp3", "audio_encoder.mp3" },
1370        { MEDIA_MIMETYPE_AUDIO_AMR_NB,
1371            "audio_decoder.amrnb", "audio_encoder.amrnb" },
1372        { MEDIA_MIMETYPE_AUDIO_AMR_WB,
1373            "audio_decoder.amrwb", "audio_encoder.amrwb" },
1374        { MEDIA_MIMETYPE_AUDIO_AAC,
1375            "audio_decoder.aac", "audio_encoder.aac" },
1376        { MEDIA_MIMETYPE_VIDEO_AVC,
1377            "video_decoder.avc", "video_encoder.avc" },
1378        { MEDIA_MIMETYPE_VIDEO_MPEG4,
1379            "video_decoder.mpeg4", "video_encoder.mpeg4" },
1380        { MEDIA_MIMETYPE_VIDEO_H263,
1381            "video_decoder.h263", "video_encoder.h263" },
1382    };
1383
1384    static const size_t kNumMimeToRole =
1385        sizeof(kMimeToRole) / sizeof(kMimeToRole[0]);
1386
1387    size_t i;
1388    for (i = 0; i < kNumMimeToRole; ++i) {
1389        if (!strcasecmp(mime, kMimeToRole[i].mime)) {
1390            break;
1391        }
1392    }
1393
1394    if (i == kNumMimeToRole) {
1395        return;
1396    }
1397
1398    const char *role =
1399        isEncoder ? kMimeToRole[i].encoderRole
1400                  : kMimeToRole[i].decoderRole;
1401
1402    if (role != NULL) {
1403        OMX_PARAM_COMPONENTROLETYPE roleParams;
1404        InitOMXParams(&roleParams);
1405
1406        strncpy((char *)roleParams.cRole,
1407                role, OMX_MAX_STRINGNAME_SIZE - 1);
1408
1409        roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0';
1410
1411        status_t err = omx->setParameter(
1412                node, OMX_IndexParamStandardComponentRole,
1413                &roleParams, sizeof(roleParams));
1414
1415        if (err != OK) {
1416            LOGW("Failed to set standard component role '%s'.", role);
1417        }
1418    }
1419}
1420
1421void OMXCodec::setComponentRole() {
1422    setComponentRole(mOMX, mNode, mIsEncoder, mMIME);
1423}
1424
1425OMXCodec::~OMXCodec() {
1426    CHECK(mState == LOADED || mState == ERROR);
1427
1428    status_t err = mOMX->freeNode(mNode);
1429    CHECK_EQ(err, OK);
1430
1431    mNode = NULL;
1432    setState(DEAD);
1433
1434    clearCodecSpecificData();
1435
1436    free(mComponentName);
1437    mComponentName = NULL;
1438
1439    free(mMIME);
1440    mMIME = NULL;
1441}
1442
1443status_t OMXCodec::init() {
1444    // mLock is held.
1445
1446    CHECK_EQ(mState, LOADED);
1447
1448    status_t err;
1449    if (!(mQuirks & kRequiresLoadedToIdleAfterAllocation)) {
1450        err = mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
1451        CHECK_EQ(err, OK);
1452        setState(LOADED_TO_IDLE);
1453    }
1454
1455    err = allocateBuffers();
1456    CHECK_EQ(err, OK);
1457
1458    if (mQuirks & kRequiresLoadedToIdleAfterAllocation) {
1459        err = mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
1460        CHECK_EQ(err, OK);
1461
1462        setState(LOADED_TO_IDLE);
1463    }
1464
1465    while (mState != EXECUTING && mState != ERROR) {
1466        mAsyncCompletion.wait(mLock);
1467    }
1468
1469    return mState == ERROR ? UNKNOWN_ERROR : OK;
1470}
1471
1472// static
1473bool OMXCodec::isIntermediateState(State state) {
1474    return state == LOADED_TO_IDLE
1475        || state == IDLE_TO_EXECUTING
1476        || state == EXECUTING_TO_IDLE
1477        || state == IDLE_TO_LOADED
1478        || state == RECONFIGURING;
1479}
1480
1481status_t OMXCodec::allocateBuffers() {
1482    status_t err = allocateBuffersOnPort(kPortIndexInput);
1483
1484    if (err != OK) {
1485        return err;
1486    }
1487
1488    return allocateBuffersOnPort(kPortIndexOutput);
1489}
1490
1491status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {
1492    OMX_PARAM_PORTDEFINITIONTYPE def;
1493    InitOMXParams(&def);
1494    def.nPortIndex = portIndex;
1495
1496    status_t err = mOMX->getParameter(
1497            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
1498
1499    if (err != OK) {
1500        return err;
1501    }
1502
1503    CODEC_LOGI("allocating %lu buffers of size %lu on %s port",
1504            def.nBufferCountActual, def.nBufferSize,
1505            portIndex == kPortIndexInput ? "input" : "output");
1506
1507    size_t totalSize = def.nBufferCountActual * def.nBufferSize;
1508    mDealer[portIndex] = new MemoryDealer(totalSize, "OMXCodec");
1509
1510    for (OMX_U32 i = 0; i < def.nBufferCountActual; ++i) {
1511        sp<IMemory> mem = mDealer[portIndex]->allocate(def.nBufferSize);
1512        CHECK(mem.get() != NULL);
1513
1514        BufferInfo info;
1515        info.mData = NULL;
1516        info.mSize = def.nBufferSize;
1517
1518        IOMX::buffer_id buffer;
1519        if (portIndex == kPortIndexInput
1520                && (mQuirks & kRequiresAllocateBufferOnInputPorts)) {
1521            if (mOMXLivesLocally) {
1522                mem.clear();
1523
1524                err = mOMX->allocateBuffer(
1525                        mNode, portIndex, def.nBufferSize, &buffer,
1526                        &info.mData);
1527            } else {
1528                err = mOMX->allocateBufferWithBackup(
1529                        mNode, portIndex, mem, &buffer);
1530            }
1531        } else if (portIndex == kPortIndexOutput
1532                && (mQuirks & kRequiresAllocateBufferOnOutputPorts)) {
1533            if (mOMXLivesLocally) {
1534                mem.clear();
1535
1536                err = mOMX->allocateBuffer(
1537                        mNode, portIndex, def.nBufferSize, &buffer,
1538                        &info.mData);
1539            } else {
1540                err = mOMX->allocateBufferWithBackup(
1541                        mNode, portIndex, mem, &buffer);
1542            }
1543        } else {
1544            err = mOMX->useBuffer(mNode, portIndex, mem, &buffer);
1545        }
1546
1547        if (err != OK) {
1548            LOGE("allocate_buffer_with_backup failed");
1549            return err;
1550        }
1551
1552        if (mem != NULL) {
1553            info.mData = mem->pointer();
1554        }
1555
1556        info.mBuffer = buffer;
1557        info.mOwnedByComponent = false;
1558        info.mMem = mem;
1559        info.mMediaBuffer = NULL;
1560
1561        if (portIndex == kPortIndexOutput) {
1562            if (!(mOMXLivesLocally
1563                        && (mQuirks & kRequiresAllocateBufferOnOutputPorts)
1564                        && (mQuirks & kDefersOutputBufferAllocation))) {
1565                // If the node does not fill in the buffer ptr at this time,
1566                // we will defer creating the MediaBuffer until receiving
1567                // the first FILL_BUFFER_DONE notification instead.
1568                info.mMediaBuffer = new MediaBuffer(info.mData, info.mSize);
1569                info.mMediaBuffer->setObserver(this);
1570            }
1571        }
1572
1573        mPortBuffers[portIndex].push(info);
1574
1575        CODEC_LOGV("allocated buffer %p on %s port", buffer,
1576             portIndex == kPortIndexInput ? "input" : "output");
1577    }
1578
1579    // dumpPortStatus(portIndex);
1580
1581    return OK;
1582}
1583
1584void OMXCodec::on_message(const omx_message &msg) {
1585    Mutex::Autolock autoLock(mLock);
1586
1587    switch (msg.type) {
1588        case omx_message::EVENT:
1589        {
1590            onEvent(
1591                 msg.u.event_data.event, msg.u.event_data.data1,
1592                 msg.u.event_data.data2);
1593
1594            break;
1595        }
1596
1597        case omx_message::EMPTY_BUFFER_DONE:
1598        {
1599            IOMX::buffer_id buffer = msg.u.extended_buffer_data.buffer;
1600
1601            CODEC_LOGV("EMPTY_BUFFER_DONE(buffer: %p)", buffer);
1602
1603            Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexInput];
1604            size_t i = 0;
1605            while (i < buffers->size() && (*buffers)[i].mBuffer != buffer) {
1606                ++i;
1607            }
1608
1609            CHECK(i < buffers->size());
1610            if (!(*buffers)[i].mOwnedByComponent) {
1611                LOGW("We already own input buffer %p, yet received "
1612                     "an EMPTY_BUFFER_DONE.", buffer);
1613            }
1614
1615            buffers->editItemAt(i).mOwnedByComponent = false;
1616
1617            if (mPortStatus[kPortIndexInput] == DISABLING) {
1618                CODEC_LOGV("Port is disabled, freeing buffer %p", buffer);
1619
1620                status_t err =
1621                    mOMX->freeBuffer(mNode, kPortIndexInput, buffer);
1622                CHECK_EQ(err, OK);
1623
1624                buffers->removeAt(i);
1625            } else if (mState != ERROR
1626                    && mPortStatus[kPortIndexInput] != SHUTTING_DOWN) {
1627                CHECK_EQ(mPortStatus[kPortIndexInput], ENABLED);
1628                drainInputBuffer(&buffers->editItemAt(i));
1629            }
1630            break;
1631        }
1632
1633        case omx_message::FILL_BUFFER_DONE:
1634        {
1635            IOMX::buffer_id buffer = msg.u.extended_buffer_data.buffer;
1636            OMX_U32 flags = msg.u.extended_buffer_data.flags;
1637
1638            CODEC_LOGV("FILL_BUFFER_DONE(buffer: %p, size: %ld, flags: 0x%08lx, timestamp: %lld us (%.2f secs))",
1639                 buffer,
1640                 msg.u.extended_buffer_data.range_length,
1641                 flags,
1642                 msg.u.extended_buffer_data.timestamp,
1643                 msg.u.extended_buffer_data.timestamp / 1E6);
1644
1645            Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
1646            size_t i = 0;
1647            while (i < buffers->size() && (*buffers)[i].mBuffer != buffer) {
1648                ++i;
1649            }
1650
1651            CHECK(i < buffers->size());
1652            BufferInfo *info = &buffers->editItemAt(i);
1653
1654            if (!info->mOwnedByComponent) {
1655                LOGW("We already own output buffer %p, yet received "
1656                     "a FILL_BUFFER_DONE.", buffer);
1657            }
1658
1659            info->mOwnedByComponent = false;
1660
1661            if (mPortStatus[kPortIndexOutput] == DISABLING) {
1662                CODEC_LOGV("Port is disabled, freeing buffer %p", buffer);
1663
1664                status_t err =
1665                    mOMX->freeBuffer(mNode, kPortIndexOutput, buffer);
1666                CHECK_EQ(err, OK);
1667
1668                buffers->removeAt(i);
1669#if 0
1670            } else if (mPortStatus[kPortIndexOutput] == ENABLED
1671                       && (flags & OMX_BUFFERFLAG_EOS)) {
1672                CODEC_LOGV("No more output data.");
1673                mNoMoreOutputData = true;
1674                mBufferFilled.signal();
1675#endif
1676            } else if (mPortStatus[kPortIndexOutput] != SHUTTING_DOWN) {
1677                CHECK_EQ(mPortStatus[kPortIndexOutput], ENABLED);
1678
1679                if (info->mMediaBuffer == NULL) {
1680                    CHECK(mOMXLivesLocally);
1681                    CHECK(mQuirks & kRequiresAllocateBufferOnOutputPorts);
1682                    CHECK(mQuirks & kDefersOutputBufferAllocation);
1683
1684                    // The qcom video decoders on Nexus don't actually allocate
1685                    // output buffer memory on a call to OMX_AllocateBuffer
1686                    // the "pBuffer" member of the OMX_BUFFERHEADERTYPE
1687                    // structure is only filled in later.
1688
1689                    info->mMediaBuffer = new MediaBuffer(
1690                            msg.u.extended_buffer_data.data_ptr,
1691                            info->mSize);
1692                    info->mMediaBuffer->setObserver(this);
1693                }
1694
1695                MediaBuffer *buffer = info->mMediaBuffer;
1696
1697                if (msg.u.extended_buffer_data.range_offset
1698                        + msg.u.extended_buffer_data.range_length
1699                            > buffer->size()) {
1700                    CODEC_LOGE(
1701                            "Codec lied about its buffer size requirements, "
1702                            "sending a buffer larger than the originally "
1703                            "advertised size in FILL_BUFFER_DONE!");
1704                }
1705                buffer->set_range(
1706                        msg.u.extended_buffer_data.range_offset,
1707                        msg.u.extended_buffer_data.range_length);
1708
1709                buffer->meta_data()->clear();
1710
1711                buffer->meta_data()->setInt64(
1712                        kKeyTime, msg.u.extended_buffer_data.timestamp);
1713
1714                if (msg.u.extended_buffer_data.flags & OMX_BUFFERFLAG_SYNCFRAME) {
1715                    buffer->meta_data()->setInt32(kKeyIsSyncFrame, true);
1716                }
1717                if (msg.u.extended_buffer_data.flags & OMX_BUFFERFLAG_CODECCONFIG) {
1718                    buffer->meta_data()->setInt32(kKeyIsCodecConfig, true);
1719                }
1720
1721                buffer->meta_data()->setPointer(
1722                        kKeyPlatformPrivate,
1723                        msg.u.extended_buffer_data.platform_private);
1724
1725                buffer->meta_data()->setPointer(
1726                        kKeyBufferID,
1727                        msg.u.extended_buffer_data.buffer);
1728
1729                if (msg.u.extended_buffer_data.flags & OMX_BUFFERFLAG_EOS) {
1730                    CODEC_LOGV("No more output data.");
1731                    mNoMoreOutputData = true;
1732                }
1733
1734                if (mTargetTimeUs >= 0) {
1735                    CHECK(msg.u.extended_buffer_data.timestamp <= mTargetTimeUs);
1736
1737                    if (msg.u.extended_buffer_data.timestamp < mTargetTimeUs) {
1738                        CODEC_LOGV(
1739                                "skipping output buffer at timestamp %lld us",
1740                                msg.u.extended_buffer_data.timestamp);
1741
1742                        fillOutputBuffer(info);
1743                        break;
1744                    }
1745
1746                    CODEC_LOGV(
1747                            "returning output buffer at target timestamp "
1748                            "%lld us",
1749                            msg.u.extended_buffer_data.timestamp);
1750
1751                    mTargetTimeUs = -1;
1752                }
1753
1754                mFilledBuffers.push_back(i);
1755                mBufferFilled.signal();
1756            }
1757
1758            break;
1759        }
1760
1761        default:
1762        {
1763            CHECK(!"should not be here.");
1764            break;
1765        }
1766    }
1767}
1768
1769void OMXCodec::onEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
1770    switch (event) {
1771        case OMX_EventCmdComplete:
1772        {
1773            onCmdComplete((OMX_COMMANDTYPE)data1, data2);
1774            break;
1775        }
1776
1777        case OMX_EventError:
1778        {
1779            LOGE("ERROR(0x%08lx, %ld)", data1, data2);
1780
1781            setState(ERROR);
1782            break;
1783        }
1784
1785        case OMX_EventPortSettingsChanged:
1786        {
1787            onPortSettingsChanged(data1);
1788            break;
1789        }
1790
1791#if 0
1792        case OMX_EventBufferFlag:
1793        {
1794            CODEC_LOGV("EVENT_BUFFER_FLAG(%ld)", data1);
1795
1796            if (data1 == kPortIndexOutput) {
1797                mNoMoreOutputData = true;
1798            }
1799            break;
1800        }
1801#endif
1802
1803        default:
1804        {
1805            CODEC_LOGV("EVENT(%d, %ld, %ld)", event, data1, data2);
1806            break;
1807        }
1808    }
1809}
1810
1811// Has the format changed in any way that the client would have to be aware of?
1812static bool formatHasNotablyChanged(
1813        const sp<MetaData> &from, const sp<MetaData> &to) {
1814    if (from.get() == NULL && to.get() == NULL) {
1815        return false;
1816    }
1817
1818    if ((from.get() == NULL && to.get() != NULL)
1819        || (from.get() != NULL && to.get() == NULL)) {
1820        return true;
1821    }
1822
1823    const char *mime_from, *mime_to;
1824    CHECK(from->findCString(kKeyMIMEType, &mime_from));
1825    CHECK(to->findCString(kKeyMIMEType, &mime_to));
1826
1827    if (strcasecmp(mime_from, mime_to)) {
1828        return true;
1829    }
1830
1831    if (!strcasecmp(mime_from, MEDIA_MIMETYPE_VIDEO_RAW)) {
1832        int32_t colorFormat_from, colorFormat_to;
1833        CHECK(from->findInt32(kKeyColorFormat, &colorFormat_from));
1834        CHECK(to->findInt32(kKeyColorFormat, &colorFormat_to));
1835
1836        if (colorFormat_from != colorFormat_to) {
1837            return true;
1838        }
1839
1840        int32_t width_from, width_to;
1841        CHECK(from->findInt32(kKeyWidth, &width_from));
1842        CHECK(to->findInt32(kKeyWidth, &width_to));
1843
1844        if (width_from != width_to) {
1845            return true;
1846        }
1847
1848        int32_t height_from, height_to;
1849        CHECK(from->findInt32(kKeyHeight, &height_from));
1850        CHECK(to->findInt32(kKeyHeight, &height_to));
1851
1852        if (height_from != height_to) {
1853            return true;
1854        }
1855    } else if (!strcasecmp(mime_from, MEDIA_MIMETYPE_AUDIO_RAW)) {
1856        int32_t numChannels_from, numChannels_to;
1857        CHECK(from->findInt32(kKeyChannelCount, &numChannels_from));
1858        CHECK(to->findInt32(kKeyChannelCount, &numChannels_to));
1859
1860        if (numChannels_from != numChannels_to) {
1861            return true;
1862        }
1863
1864        int32_t sampleRate_from, sampleRate_to;
1865        CHECK(from->findInt32(kKeySampleRate, &sampleRate_from));
1866        CHECK(to->findInt32(kKeySampleRate, &sampleRate_to));
1867
1868        if (sampleRate_from != sampleRate_to) {
1869            return true;
1870        }
1871    }
1872
1873    return false;
1874}
1875
1876void OMXCodec::onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data) {
1877    switch (cmd) {
1878        case OMX_CommandStateSet:
1879        {
1880            onStateChange((OMX_STATETYPE)data);
1881            break;
1882        }
1883
1884        case OMX_CommandPortDisable:
1885        {
1886            OMX_U32 portIndex = data;
1887            CODEC_LOGV("PORT_DISABLED(%ld)", portIndex);
1888
1889            CHECK(mState == EXECUTING || mState == RECONFIGURING);
1890            CHECK_EQ(mPortStatus[portIndex], DISABLING);
1891            CHECK_EQ(mPortBuffers[portIndex].size(), 0);
1892
1893            mPortStatus[portIndex] = DISABLED;
1894
1895            if (mState == RECONFIGURING) {
1896                CHECK_EQ(portIndex, kPortIndexOutput);
1897
1898                sp<MetaData> oldOutputFormat = mOutputFormat;
1899                initOutputFormat(mSource->getFormat());
1900
1901                // Don't notify clients if the output port settings change
1902                // wasn't of importance to them, i.e. it may be that just the
1903                // number of buffers has changed and nothing else.
1904                mOutputPortSettingsHaveChanged =
1905                    formatHasNotablyChanged(oldOutputFormat, mOutputFormat);
1906
1907                enablePortAsync(portIndex);
1908
1909                status_t err = allocateBuffersOnPort(portIndex);
1910                CHECK_EQ(err, OK);
1911            }
1912            break;
1913        }
1914
1915        case OMX_CommandPortEnable:
1916        {
1917            OMX_U32 portIndex = data;
1918            CODEC_LOGV("PORT_ENABLED(%ld)", portIndex);
1919
1920            CHECK(mState == EXECUTING || mState == RECONFIGURING);
1921            CHECK_EQ(mPortStatus[portIndex], ENABLING);
1922
1923            mPortStatus[portIndex] = ENABLED;
1924
1925            if (mState == RECONFIGURING) {
1926                CHECK_EQ(portIndex, kPortIndexOutput);
1927
1928                setState(EXECUTING);
1929
1930                fillOutputBuffers();
1931            }
1932            break;
1933        }
1934
1935        case OMX_CommandFlush:
1936        {
1937            OMX_U32 portIndex = data;
1938
1939            CODEC_LOGV("FLUSH_DONE(%ld)", portIndex);
1940
1941            CHECK_EQ(mPortStatus[portIndex], SHUTTING_DOWN);
1942            mPortStatus[portIndex] = ENABLED;
1943
1944            CHECK_EQ(countBuffersWeOwn(mPortBuffers[portIndex]),
1945                     mPortBuffers[portIndex].size());
1946
1947            if (mState == RECONFIGURING) {
1948                CHECK_EQ(portIndex, kPortIndexOutput);
1949
1950                disablePortAsync(portIndex);
1951            } else if (mState == EXECUTING_TO_IDLE) {
1952                if (mPortStatus[kPortIndexInput] == ENABLED
1953                    && mPortStatus[kPortIndexOutput] == ENABLED) {
1954                    CODEC_LOGV("Finished flushing both ports, now completing "
1955                         "transition from EXECUTING to IDLE.");
1956
1957                    mPortStatus[kPortIndexInput] = SHUTTING_DOWN;
1958                    mPortStatus[kPortIndexOutput] = SHUTTING_DOWN;
1959
1960                    status_t err =
1961                        mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
1962                    CHECK_EQ(err, OK);
1963                }
1964            } else {
1965                // We're flushing both ports in preparation for seeking.
1966
1967                if (mPortStatus[kPortIndexInput] == ENABLED
1968                    && mPortStatus[kPortIndexOutput] == ENABLED) {
1969                    CODEC_LOGV("Finished flushing both ports, now continuing from"
1970                         " seek-time.");
1971
1972                    // We implicitly resume pulling on our upstream source.
1973                    mPaused = false;
1974
1975                    drainInputBuffers();
1976                    fillOutputBuffers();
1977                }
1978            }
1979
1980            break;
1981        }
1982
1983        default:
1984        {
1985            CODEC_LOGV("CMD_COMPLETE(%d, %ld)", cmd, data);
1986            break;
1987        }
1988    }
1989}
1990
1991void OMXCodec::onStateChange(OMX_STATETYPE newState) {
1992    CODEC_LOGV("onStateChange %d", newState);
1993
1994    switch (newState) {
1995        case OMX_StateIdle:
1996        {
1997            CODEC_LOGV("Now Idle.");
1998            if (mState == LOADED_TO_IDLE) {
1999                status_t err = mOMX->sendCommand(
2000                        mNode, OMX_CommandStateSet, OMX_StateExecuting);
2001
2002                CHECK_EQ(err, OK);
2003
2004                setState(IDLE_TO_EXECUTING);
2005            } else {
2006                CHECK_EQ(mState, EXECUTING_TO_IDLE);
2007
2008                CHECK_EQ(
2009                    countBuffersWeOwn(mPortBuffers[kPortIndexInput]),
2010                    mPortBuffers[kPortIndexInput].size());
2011
2012                CHECK_EQ(
2013                    countBuffersWeOwn(mPortBuffers[kPortIndexOutput]),
2014                    mPortBuffers[kPortIndexOutput].size());
2015
2016                status_t err = mOMX->sendCommand(
2017                        mNode, OMX_CommandStateSet, OMX_StateLoaded);
2018
2019                CHECK_EQ(err, OK);
2020
2021                err = freeBuffersOnPort(kPortIndexInput);
2022                CHECK_EQ(err, OK);
2023
2024                err = freeBuffersOnPort(kPortIndexOutput);
2025                CHECK_EQ(err, OK);
2026
2027                mPortStatus[kPortIndexInput] = ENABLED;
2028                mPortStatus[kPortIndexOutput] = ENABLED;
2029
2030                setState(IDLE_TO_LOADED);
2031            }
2032            break;
2033        }
2034
2035        case OMX_StateExecuting:
2036        {
2037            CHECK_EQ(mState, IDLE_TO_EXECUTING);
2038
2039            CODEC_LOGV("Now Executing.");
2040
2041            setState(EXECUTING);
2042
2043            // Buffers will be submitted to the component in the first
2044            // call to OMXCodec::read as mInitialBufferSubmit is true at
2045            // this point. This ensures that this on_message call returns,
2046            // releases the lock and ::init can notice the state change and
2047            // itself return.
2048            break;
2049        }
2050
2051        case OMX_StateLoaded:
2052        {
2053            CHECK_EQ(mState, IDLE_TO_LOADED);
2054
2055            CODEC_LOGV("Now Loaded.");
2056
2057            setState(LOADED);
2058            break;
2059        }
2060
2061        case OMX_StateInvalid:
2062        {
2063            setState(ERROR);
2064            break;
2065        }
2066
2067        default:
2068        {
2069            CHECK(!"should not be here.");
2070            break;
2071        }
2072    }
2073}
2074
2075// static
2076size_t OMXCodec::countBuffersWeOwn(const Vector<BufferInfo> &buffers) {
2077    size_t n = 0;
2078    for (size_t i = 0; i < buffers.size(); ++i) {
2079        if (!buffers[i].mOwnedByComponent) {
2080            ++n;
2081        }
2082    }
2083
2084    return n;
2085}
2086
2087status_t OMXCodec::freeBuffersOnPort(
2088        OMX_U32 portIndex, bool onlyThoseWeOwn) {
2089    Vector<BufferInfo> *buffers = &mPortBuffers[portIndex];
2090
2091    status_t stickyErr = OK;
2092
2093    for (size_t i = buffers->size(); i-- > 0;) {
2094        BufferInfo *info = &buffers->editItemAt(i);
2095
2096        if (onlyThoseWeOwn && info->mOwnedByComponent) {
2097            continue;
2098        }
2099
2100        CHECK_EQ(info->mOwnedByComponent, false);
2101
2102        CODEC_LOGV("freeing buffer %p on port %ld", info->mBuffer, portIndex);
2103
2104        status_t err =
2105            mOMX->freeBuffer(mNode, portIndex, info->mBuffer);
2106
2107        if (err != OK) {
2108            stickyErr = err;
2109        }
2110
2111        if (info->mMediaBuffer != NULL) {
2112            info->mMediaBuffer->setObserver(NULL);
2113
2114            // Make sure nobody but us owns this buffer at this point.
2115            CHECK_EQ(info->mMediaBuffer->refcount(), 0);
2116
2117            info->mMediaBuffer->release();
2118        }
2119
2120        buffers->removeAt(i);
2121    }
2122
2123    CHECK(onlyThoseWeOwn || buffers->isEmpty());
2124
2125    return stickyErr;
2126}
2127
2128void OMXCodec::onPortSettingsChanged(OMX_U32 portIndex) {
2129    CODEC_LOGV("PORT_SETTINGS_CHANGED(%ld)", portIndex);
2130
2131    CHECK_EQ(mState, EXECUTING);
2132    CHECK_EQ(portIndex, kPortIndexOutput);
2133    setState(RECONFIGURING);
2134
2135    if (mQuirks & kNeedsFlushBeforeDisable) {
2136        if (!flushPortAsync(portIndex)) {
2137            onCmdComplete(OMX_CommandFlush, portIndex);
2138        }
2139    } else {
2140        disablePortAsync(portIndex);
2141    }
2142}
2143
2144bool OMXCodec::flushPortAsync(OMX_U32 portIndex) {
2145    CHECK(mState == EXECUTING || mState == RECONFIGURING
2146            || mState == EXECUTING_TO_IDLE);
2147
2148    CODEC_LOGV("flushPortAsync(%ld): we own %d out of %d buffers already.",
2149         portIndex, countBuffersWeOwn(mPortBuffers[portIndex]),
2150         mPortBuffers[portIndex].size());
2151
2152    CHECK_EQ(mPortStatus[portIndex], ENABLED);
2153    mPortStatus[portIndex] = SHUTTING_DOWN;
2154
2155    if ((mQuirks & kRequiresFlushCompleteEmulation)
2156        && countBuffersWeOwn(mPortBuffers[portIndex])
2157                == mPortBuffers[portIndex].size()) {
2158        // No flush is necessary and this component fails to send a
2159        // flush-complete event in this case.
2160
2161        return false;
2162    }
2163
2164    status_t err =
2165        mOMX->sendCommand(mNode, OMX_CommandFlush, portIndex);
2166    CHECK_EQ(err, OK);
2167
2168    return true;
2169}
2170
2171void OMXCodec::disablePortAsync(OMX_U32 portIndex) {
2172    CHECK(mState == EXECUTING || mState == RECONFIGURING);
2173
2174    CHECK_EQ(mPortStatus[portIndex], ENABLED);
2175    mPortStatus[portIndex] = DISABLING;
2176
2177    status_t err =
2178        mOMX->sendCommand(mNode, OMX_CommandPortDisable, portIndex);
2179    CHECK_EQ(err, OK);
2180
2181    freeBuffersOnPort(portIndex, true);
2182}
2183
2184void OMXCodec::enablePortAsync(OMX_U32 portIndex) {
2185    CHECK(mState == EXECUTING || mState == RECONFIGURING);
2186
2187    CHECK_EQ(mPortStatus[portIndex], DISABLED);
2188    mPortStatus[portIndex] = ENABLING;
2189
2190    status_t err =
2191        mOMX->sendCommand(mNode, OMX_CommandPortEnable, portIndex);
2192    CHECK_EQ(err, OK);
2193}
2194
2195void OMXCodec::fillOutputBuffers() {
2196    CHECK_EQ(mState, EXECUTING);
2197
2198    // This is a workaround for some decoders not properly reporting
2199    // end-of-output-stream. If we own all input buffers and also own
2200    // all output buffers and we already signalled end-of-input-stream,
2201    // the end-of-output-stream is implied.
2202    if (mSignalledEOS
2203            && countBuffersWeOwn(mPortBuffers[kPortIndexInput])
2204                == mPortBuffers[kPortIndexInput].size()
2205            && countBuffersWeOwn(mPortBuffers[kPortIndexOutput])
2206                == mPortBuffers[kPortIndexOutput].size()) {
2207        mNoMoreOutputData = true;
2208        mBufferFilled.signal();
2209
2210        return;
2211    }
2212
2213    Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
2214    for (size_t i = 0; i < buffers->size(); ++i) {
2215        fillOutputBuffer(&buffers->editItemAt(i));
2216    }
2217}
2218
2219void OMXCodec::drainInputBuffers() {
2220    CHECK(mState == EXECUTING || mState == RECONFIGURING);
2221
2222    Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexInput];
2223    for (size_t i = 0; i < buffers->size(); ++i) {
2224        drainInputBuffer(&buffers->editItemAt(i));
2225    }
2226}
2227
2228void OMXCodec::drainInputBuffer(BufferInfo *info) {
2229    CHECK_EQ(info->mOwnedByComponent, false);
2230
2231    if (mSignalledEOS) {
2232        return;
2233    }
2234
2235    if (mCodecSpecificDataIndex < mCodecSpecificData.size()) {
2236        const CodecSpecificData *specific =
2237            mCodecSpecificData[mCodecSpecificDataIndex];
2238
2239        size_t size = specific->mSize;
2240
2241        if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mMIME)
2242                && !(mQuirks & kWantsNALFragments)) {
2243            static const uint8_t kNALStartCode[4] =
2244                    { 0x00, 0x00, 0x00, 0x01 };
2245
2246            CHECK(info->mSize >= specific->mSize + 4);
2247
2248            size += 4;
2249
2250            memcpy(info->mData, kNALStartCode, 4);
2251            memcpy((uint8_t *)info->mData + 4,
2252                   specific->mData, specific->mSize);
2253        } else {
2254            CHECK(info->mSize >= specific->mSize);
2255            memcpy(info->mData, specific->mData, specific->mSize);
2256        }
2257
2258        mNoMoreOutputData = false;
2259
2260        CODEC_LOGV("calling emptyBuffer with codec specific data");
2261
2262        status_t err = mOMX->emptyBuffer(
2263                mNode, info->mBuffer, 0, size,
2264                OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_CODECCONFIG,
2265                0);
2266        CHECK_EQ(err, OK);
2267
2268        info->mOwnedByComponent = true;
2269
2270        ++mCodecSpecificDataIndex;
2271        return;
2272    }
2273
2274    if (mPaused) {
2275        return;
2276    }
2277
2278    status_t err;
2279
2280    bool signalEOS = false;
2281    int64_t timestampUs = 0;
2282
2283    size_t offset = 0;
2284    int32_t n = 0;
2285    for (;;) {
2286        MediaBuffer *srcBuffer;
2287        MediaSource::ReadOptions options;
2288        if (mSkipTimeUs >= 0) {
2289            options.setSkipFrame(mSkipTimeUs);
2290        }
2291        if (mSeekTimeUs >= 0) {
2292            if (mLeftOverBuffer) {
2293                mLeftOverBuffer->release();
2294                mLeftOverBuffer = NULL;
2295            }
2296            options.setSeekTo(mSeekTimeUs, mSeekMode);
2297
2298            mSeekTimeUs = -1;
2299            mSeekMode = ReadOptions::SEEK_CLOSEST_SYNC;
2300            mBufferFilled.signal();
2301
2302            err = mSource->read(&srcBuffer, &options);
2303
2304            if (err == OK) {
2305                int64_t targetTimeUs;
2306                if (srcBuffer->meta_data()->findInt64(
2307                            kKeyTargetTime, &targetTimeUs)
2308                        && targetTimeUs >= 0) {
2309                    mTargetTimeUs = targetTimeUs;
2310                } else {
2311                    mTargetTimeUs = -1;
2312                }
2313            }
2314        } else if (mLeftOverBuffer) {
2315            srcBuffer = mLeftOverBuffer;
2316            mLeftOverBuffer = NULL;
2317
2318            err = OK;
2319        } else {
2320            err = mSource->read(&srcBuffer, &options);
2321        }
2322
2323        if (err != OK) {
2324            signalEOS = true;
2325            mFinalStatus = err;
2326            mSignalledEOS = true;
2327            break;
2328        }
2329
2330        size_t remainingBytes = info->mSize - offset;
2331
2332        if (srcBuffer->range_length() > remainingBytes) {
2333            if (offset == 0) {
2334                CODEC_LOGE(
2335                     "Codec's input buffers are too small to accomodate "
2336                     "buffer read from source (info->mSize = %d, srcLength = %d)",
2337                     info->mSize, srcBuffer->range_length());
2338
2339                srcBuffer->release();
2340                srcBuffer = NULL;
2341
2342                setState(ERROR);
2343                return;
2344            }
2345
2346            mLeftOverBuffer = srcBuffer;
2347            break;
2348        }
2349
2350        if (mIsEncoder && (mQuirks & kAvoidMemcopyInputRecordingFrames)) {
2351            CHECK(mOMXLivesLocally && offset == 0);
2352            OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *) info->mBuffer;
2353            header->pBuffer = (OMX_U8 *) srcBuffer->data() + srcBuffer->range_offset();
2354        } else {
2355            memcpy((uint8_t *)info->mData + offset,
2356                    (const uint8_t *)srcBuffer->data() + srcBuffer->range_offset(),
2357                    srcBuffer->range_length());
2358        }
2359
2360        int64_t lastBufferTimeUs;
2361        CHECK(srcBuffer->meta_data()->findInt64(kKeyTime, &lastBufferTimeUs));
2362        CHECK(lastBufferTimeUs >= 0);
2363
2364        if (offset == 0) {
2365            timestampUs = lastBufferTimeUs;
2366        }
2367
2368        offset += srcBuffer->range_length();
2369
2370        srcBuffer->release();
2371        srcBuffer = NULL;
2372
2373        ++n;
2374
2375        if (!(mQuirks & kSupportsMultipleFramesPerInputBuffer)) {
2376            break;
2377        }
2378
2379        int64_t coalescedDurationUs = lastBufferTimeUs - timestampUs;
2380
2381        if (coalescedDurationUs > 250000ll) {
2382            // Don't coalesce more than 250ms worth of encoded data at once.
2383            break;
2384        }
2385    }
2386
2387    if (n > 1) {
2388        LOGV("coalesced %d frames into one input buffer", n);
2389    }
2390
2391    OMX_U32 flags = OMX_BUFFERFLAG_ENDOFFRAME;
2392
2393    if (signalEOS) {
2394        flags |= OMX_BUFFERFLAG_EOS;
2395    } else {
2396        mNoMoreOutputData = false;
2397    }
2398
2399    CODEC_LOGV("Calling emptyBuffer on buffer %p (length %d), "
2400               "timestamp %lld us (%.2f secs)",
2401               info->mBuffer, offset,
2402               timestampUs, timestampUs / 1E6);
2403
2404    err = mOMX->emptyBuffer(
2405            mNode, info->mBuffer, 0, offset,
2406            flags, timestampUs);
2407
2408    if (err != OK) {
2409        setState(ERROR);
2410        return;
2411    }
2412
2413    info->mOwnedByComponent = true;
2414
2415    // This component does not ever signal the EOS flag on output buffers,
2416    // Thanks for nothing.
2417    if (mSignalledEOS && !strcmp(mComponentName, "OMX.TI.Video.encoder")) {
2418        mNoMoreOutputData = true;
2419        mBufferFilled.signal();
2420    }
2421}
2422
2423void OMXCodec::fillOutputBuffer(BufferInfo *info) {
2424    CHECK_EQ(info->mOwnedByComponent, false);
2425
2426    if (mNoMoreOutputData) {
2427        CODEC_LOGV("There is no more output data available, not "
2428             "calling fillOutputBuffer");
2429        return;
2430    }
2431
2432    CODEC_LOGV("Calling fill_buffer on buffer %p", info->mBuffer);
2433    status_t err = mOMX->fillBuffer(mNode, info->mBuffer);
2434
2435    if (err != OK) {
2436        CODEC_LOGE("fillBuffer failed w/ error 0x%08x", err);
2437
2438        setState(ERROR);
2439        return;
2440    }
2441
2442    info->mOwnedByComponent = true;
2443}
2444
2445void OMXCodec::drainInputBuffer(IOMX::buffer_id buffer) {
2446    Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexInput];
2447    for (size_t i = 0; i < buffers->size(); ++i) {
2448        if ((*buffers)[i].mBuffer == buffer) {
2449            drainInputBuffer(&buffers->editItemAt(i));
2450            return;
2451        }
2452    }
2453
2454    CHECK(!"should not be here.");
2455}
2456
2457void OMXCodec::fillOutputBuffer(IOMX::buffer_id buffer) {
2458    Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
2459    for (size_t i = 0; i < buffers->size(); ++i) {
2460        if ((*buffers)[i].mBuffer == buffer) {
2461            fillOutputBuffer(&buffers->editItemAt(i));
2462            return;
2463        }
2464    }
2465
2466    CHECK(!"should not be here.");
2467}
2468
2469void OMXCodec::setState(State newState) {
2470    mState = newState;
2471    mAsyncCompletion.signal();
2472
2473    // This may cause some spurious wakeups but is necessary to
2474    // unblock the reader if we enter ERROR state.
2475    mBufferFilled.signal();
2476}
2477
2478void OMXCodec::setRawAudioFormat(
2479        OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels) {
2480
2481    // port definition
2482    OMX_PARAM_PORTDEFINITIONTYPE def;
2483    InitOMXParams(&def);
2484    def.nPortIndex = portIndex;
2485    status_t err = mOMX->getParameter(
2486            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
2487    CHECK_EQ(err, OK);
2488    def.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
2489    CHECK_EQ(mOMX->setParameter(mNode, OMX_IndexParamPortDefinition,
2490            &def, sizeof(def)), OK);
2491
2492    // pcm param
2493    OMX_AUDIO_PARAM_PCMMODETYPE pcmParams;
2494    InitOMXParams(&pcmParams);
2495    pcmParams.nPortIndex = portIndex;
2496
2497    err = mOMX->getParameter(
2498            mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams));
2499
2500    CHECK_EQ(err, OK);
2501
2502    pcmParams.nChannels = numChannels;
2503    pcmParams.eNumData = OMX_NumericalDataSigned;
2504    pcmParams.bInterleaved = OMX_TRUE;
2505    pcmParams.nBitPerSample = 16;
2506    pcmParams.nSamplingRate = sampleRate;
2507    pcmParams.ePCMMode = OMX_AUDIO_PCMModeLinear;
2508
2509    if (numChannels == 1) {
2510        pcmParams.eChannelMapping[0] = OMX_AUDIO_ChannelCF;
2511    } else {
2512        CHECK_EQ(numChannels, 2);
2513
2514        pcmParams.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
2515        pcmParams.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
2516    }
2517
2518    err = mOMX->setParameter(
2519            mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams));
2520
2521    CHECK_EQ(err, OK);
2522}
2523
2524static OMX_AUDIO_AMRBANDMODETYPE pickModeFromBitRate(bool isAMRWB, int32_t bps) {
2525    if (isAMRWB) {
2526        if (bps <= 6600) {
2527            return OMX_AUDIO_AMRBandModeWB0;
2528        } else if (bps <= 8850) {
2529            return OMX_AUDIO_AMRBandModeWB1;
2530        } else if (bps <= 12650) {
2531            return OMX_AUDIO_AMRBandModeWB2;
2532        } else if (bps <= 14250) {
2533            return OMX_AUDIO_AMRBandModeWB3;
2534        } else if (bps <= 15850) {
2535            return OMX_AUDIO_AMRBandModeWB4;
2536        } else if (bps <= 18250) {
2537            return OMX_AUDIO_AMRBandModeWB5;
2538        } else if (bps <= 19850) {
2539            return OMX_AUDIO_AMRBandModeWB6;
2540        } else if (bps <= 23050) {
2541            return OMX_AUDIO_AMRBandModeWB7;
2542        }
2543
2544        // 23850 bps
2545        return OMX_AUDIO_AMRBandModeWB8;
2546    } else {  // AMRNB
2547        if (bps <= 4750) {
2548            return OMX_AUDIO_AMRBandModeNB0;
2549        } else if (bps <= 5150) {
2550            return OMX_AUDIO_AMRBandModeNB1;
2551        } else if (bps <= 5900) {
2552            return OMX_AUDIO_AMRBandModeNB2;
2553        } else if (bps <= 6700) {
2554            return OMX_AUDIO_AMRBandModeNB3;
2555        } else if (bps <= 7400) {
2556            return OMX_AUDIO_AMRBandModeNB4;
2557        } else if (bps <= 7950) {
2558            return OMX_AUDIO_AMRBandModeNB5;
2559        } else if (bps <= 10200) {
2560            return OMX_AUDIO_AMRBandModeNB6;
2561        }
2562
2563        // 12200 bps
2564        return OMX_AUDIO_AMRBandModeNB7;
2565    }
2566}
2567
2568void OMXCodec::setAMRFormat(bool isWAMR, int32_t bitRate) {
2569    OMX_U32 portIndex = mIsEncoder ? kPortIndexOutput : kPortIndexInput;
2570
2571    OMX_AUDIO_PARAM_AMRTYPE def;
2572    InitOMXParams(&def);
2573    def.nPortIndex = portIndex;
2574
2575    status_t err =
2576        mOMX->getParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
2577
2578    CHECK_EQ(err, OK);
2579
2580    def.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatFSF;
2581
2582    def.eAMRBandMode = pickModeFromBitRate(isWAMR, bitRate);
2583    err = mOMX->setParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
2584    CHECK_EQ(err, OK);
2585
2586    ////////////////////////
2587
2588    if (mIsEncoder) {
2589        sp<MetaData> format = mSource->getFormat();
2590        int32_t sampleRate;
2591        int32_t numChannels;
2592        CHECK(format->findInt32(kKeySampleRate, &sampleRate));
2593        CHECK(format->findInt32(kKeyChannelCount, &numChannels));
2594
2595        setRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
2596    }
2597}
2598
2599void OMXCodec::setAACFormat(int32_t numChannels, int32_t sampleRate, int32_t bitRate) {
2600    CHECK(numChannels == 1 || numChannels == 2);
2601    if (mIsEncoder) {
2602        //////////////// input port ////////////////////
2603        setRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
2604
2605        //////////////// output port ////////////////////
2606        // format
2607        OMX_AUDIO_PARAM_PORTFORMATTYPE format;
2608        format.nPortIndex = kPortIndexOutput;
2609        format.nIndex = 0;
2610        status_t err = OMX_ErrorNone;
2611        while (OMX_ErrorNone == err) {
2612            CHECK_EQ(mOMX->getParameter(mNode, OMX_IndexParamAudioPortFormat,
2613                    &format, sizeof(format)), OK);
2614            if (format.eEncoding == OMX_AUDIO_CodingAAC) {
2615                break;
2616            }
2617            format.nIndex++;
2618        }
2619        CHECK_EQ(OK, err);
2620        CHECK_EQ(mOMX->setParameter(mNode, OMX_IndexParamAudioPortFormat,
2621                &format, sizeof(format)), OK);
2622
2623        // port definition
2624        OMX_PARAM_PORTDEFINITIONTYPE def;
2625        InitOMXParams(&def);
2626        def.nPortIndex = kPortIndexOutput;
2627        CHECK_EQ(mOMX->getParameter(mNode, OMX_IndexParamPortDefinition,
2628                &def, sizeof(def)), OK);
2629        def.format.audio.bFlagErrorConcealment = OMX_TRUE;
2630        def.format.audio.eEncoding = OMX_AUDIO_CodingAAC;
2631        CHECK_EQ(mOMX->setParameter(mNode, OMX_IndexParamPortDefinition,
2632                &def, sizeof(def)), OK);
2633
2634        // profile
2635        OMX_AUDIO_PARAM_AACPROFILETYPE profile;
2636        InitOMXParams(&profile);
2637        profile.nPortIndex = kPortIndexOutput;
2638        CHECK_EQ(mOMX->getParameter(mNode, OMX_IndexParamAudioAac,
2639                &profile, sizeof(profile)), OK);
2640        profile.nChannels = numChannels;
2641        profile.eChannelMode = (numChannels == 1?
2642                OMX_AUDIO_ChannelModeMono: OMX_AUDIO_ChannelModeStereo);
2643        profile.nSampleRate = sampleRate;
2644        profile.nBitRate = bitRate;
2645        profile.nAudioBandWidth = 0;
2646        profile.nFrameLength = 0;
2647        profile.nAACtools = OMX_AUDIO_AACToolAll;
2648        profile.nAACERtools = OMX_AUDIO_AACERNone;
2649        profile.eAACProfile = OMX_AUDIO_AACObjectLC;
2650        profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4FF;
2651        CHECK_EQ(mOMX->setParameter(mNode, OMX_IndexParamAudioAac,
2652                &profile, sizeof(profile)), OK);
2653
2654    } else {
2655        OMX_AUDIO_PARAM_AACPROFILETYPE profile;
2656        InitOMXParams(&profile);
2657        profile.nPortIndex = kPortIndexInput;
2658
2659        status_t err = mOMX->getParameter(
2660                mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
2661        CHECK_EQ(err, OK);
2662
2663        profile.nChannels = numChannels;
2664        profile.nSampleRate = sampleRate;
2665        profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4ADTS;
2666
2667        err = mOMX->setParameter(
2668                mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
2669        CHECK_EQ(err, OK);
2670    }
2671}
2672
2673void OMXCodec::setImageOutputFormat(
2674        OMX_COLOR_FORMATTYPE format, OMX_U32 width, OMX_U32 height) {
2675    CODEC_LOGV("setImageOutputFormat(%ld, %ld)", width, height);
2676
2677#if 0
2678    OMX_INDEXTYPE index;
2679    status_t err = mOMX->get_extension_index(
2680            mNode, "OMX.TI.JPEG.decode.Config.OutputColorFormat", &index);
2681    CHECK_EQ(err, OK);
2682
2683    err = mOMX->set_config(mNode, index, &format, sizeof(format));
2684    CHECK_EQ(err, OK);
2685#endif
2686
2687    OMX_PARAM_PORTDEFINITIONTYPE def;
2688    InitOMXParams(&def);
2689    def.nPortIndex = kPortIndexOutput;
2690
2691    status_t err = mOMX->getParameter(
2692            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
2693    CHECK_EQ(err, OK);
2694
2695    CHECK_EQ(def.eDomain, OMX_PortDomainImage);
2696
2697    OMX_IMAGE_PORTDEFINITIONTYPE *imageDef = &def.format.image;
2698
2699    CHECK_EQ(imageDef->eCompressionFormat, OMX_IMAGE_CodingUnused);
2700    imageDef->eColorFormat = format;
2701    imageDef->nFrameWidth = width;
2702    imageDef->nFrameHeight = height;
2703
2704    switch (format) {
2705        case OMX_COLOR_FormatYUV420PackedPlanar:
2706        case OMX_COLOR_FormatYUV411Planar:
2707        {
2708            def.nBufferSize = (width * height * 3) / 2;
2709            break;
2710        }
2711
2712        case OMX_COLOR_FormatCbYCrY:
2713        {
2714            def.nBufferSize = width * height * 2;
2715            break;
2716        }
2717
2718        case OMX_COLOR_Format32bitARGB8888:
2719        {
2720            def.nBufferSize = width * height * 4;
2721            break;
2722        }
2723
2724        case OMX_COLOR_Format16bitARGB4444:
2725        case OMX_COLOR_Format16bitARGB1555:
2726        case OMX_COLOR_Format16bitRGB565:
2727        case OMX_COLOR_Format16bitBGR565:
2728        {
2729            def.nBufferSize = width * height * 2;
2730            break;
2731        }
2732
2733        default:
2734            CHECK(!"Should not be here. Unknown color format.");
2735            break;
2736    }
2737
2738    def.nBufferCountActual = def.nBufferCountMin;
2739
2740    err = mOMX->setParameter(
2741            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
2742    CHECK_EQ(err, OK);
2743}
2744
2745void OMXCodec::setJPEGInputFormat(
2746        OMX_U32 width, OMX_U32 height, OMX_U32 compressedSize) {
2747    OMX_PARAM_PORTDEFINITIONTYPE def;
2748    InitOMXParams(&def);
2749    def.nPortIndex = kPortIndexInput;
2750
2751    status_t err = mOMX->getParameter(
2752            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
2753    CHECK_EQ(err, OK);
2754
2755    CHECK_EQ(def.eDomain, OMX_PortDomainImage);
2756    OMX_IMAGE_PORTDEFINITIONTYPE *imageDef = &def.format.image;
2757
2758    CHECK_EQ(imageDef->eCompressionFormat, OMX_IMAGE_CodingJPEG);
2759    imageDef->nFrameWidth = width;
2760    imageDef->nFrameHeight = height;
2761
2762    def.nBufferSize = compressedSize;
2763    def.nBufferCountActual = def.nBufferCountMin;
2764
2765    err = mOMX->setParameter(
2766            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
2767    CHECK_EQ(err, OK);
2768}
2769
2770void OMXCodec::addCodecSpecificData(const void *data, size_t size) {
2771    CodecSpecificData *specific =
2772        (CodecSpecificData *)malloc(sizeof(CodecSpecificData) + size - 1);
2773
2774    specific->mSize = size;
2775    memcpy(specific->mData, data, size);
2776
2777    mCodecSpecificData.push(specific);
2778}
2779
2780void OMXCodec::clearCodecSpecificData() {
2781    for (size_t i = 0; i < mCodecSpecificData.size(); ++i) {
2782        free(mCodecSpecificData.editItemAt(i));
2783    }
2784    mCodecSpecificData.clear();
2785    mCodecSpecificDataIndex = 0;
2786}
2787
2788status_t OMXCodec::start(MetaData *meta) {
2789    Mutex::Autolock autoLock(mLock);
2790
2791    if (mState != LOADED) {
2792        return UNKNOWN_ERROR;
2793    }
2794
2795    sp<MetaData> params = new MetaData;
2796    if (mQuirks & kWantsNALFragments) {
2797        params->setInt32(kKeyWantsNALFragments, true);
2798    }
2799    if (meta) {
2800        int64_t startTimeUs = 0;
2801        int64_t timeUs;
2802        if (meta->findInt64(kKeyTime, &timeUs)) {
2803            startTimeUs = timeUs;
2804        }
2805        params->setInt64(kKeyTime, startTimeUs);
2806    }
2807    status_t err = mSource->start(params.get());
2808
2809    if (err != OK) {
2810        return err;
2811    }
2812
2813    mCodecSpecificDataIndex = 0;
2814    mInitialBufferSubmit = true;
2815    mSignalledEOS = false;
2816    mNoMoreOutputData = false;
2817    mOutputPortSettingsHaveChanged = false;
2818    mSeekTimeUs = -1;
2819    mSeekMode = ReadOptions::SEEK_CLOSEST_SYNC;
2820    mTargetTimeUs = -1;
2821    mFilledBuffers.clear();
2822    mPaused = false;
2823
2824    return init();
2825}
2826
2827status_t OMXCodec::stop() {
2828    CODEC_LOGV("stop mState=%d", mState);
2829
2830    Mutex::Autolock autoLock(mLock);
2831
2832    while (isIntermediateState(mState)) {
2833        mAsyncCompletion.wait(mLock);
2834    }
2835
2836    switch (mState) {
2837        case LOADED:
2838        case ERROR:
2839            break;
2840
2841        case EXECUTING:
2842        {
2843            setState(EXECUTING_TO_IDLE);
2844
2845            if (mQuirks & kRequiresFlushBeforeShutdown) {
2846                CODEC_LOGV("This component requires a flush before transitioning "
2847                     "from EXECUTING to IDLE...");
2848
2849                bool emulateInputFlushCompletion =
2850                    !flushPortAsync(kPortIndexInput);
2851
2852                bool emulateOutputFlushCompletion =
2853                    !flushPortAsync(kPortIndexOutput);
2854
2855                if (emulateInputFlushCompletion) {
2856                    onCmdComplete(OMX_CommandFlush, kPortIndexInput);
2857                }
2858
2859                if (emulateOutputFlushCompletion) {
2860                    onCmdComplete(OMX_CommandFlush, kPortIndexOutput);
2861                }
2862            } else {
2863                mPortStatus[kPortIndexInput] = SHUTTING_DOWN;
2864                mPortStatus[kPortIndexOutput] = SHUTTING_DOWN;
2865
2866                status_t err =
2867                    mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
2868                CHECK_EQ(err, OK);
2869            }
2870
2871            while (mState != LOADED && mState != ERROR) {
2872                mAsyncCompletion.wait(mLock);
2873            }
2874
2875            break;
2876        }
2877
2878        default:
2879        {
2880            CHECK(!"should not be here.");
2881            break;
2882        }
2883    }
2884
2885    if (mLeftOverBuffer) {
2886        mLeftOverBuffer->release();
2887        mLeftOverBuffer = NULL;
2888    }
2889
2890    mSource->stop();
2891
2892    CODEC_LOGV("stopped");
2893
2894    return OK;
2895}
2896
2897sp<MetaData> OMXCodec::getFormat() {
2898    Mutex::Autolock autoLock(mLock);
2899
2900    return mOutputFormat;
2901}
2902
2903status_t OMXCodec::read(
2904        MediaBuffer **buffer, const ReadOptions *options) {
2905    *buffer = NULL;
2906
2907    Mutex::Autolock autoLock(mLock);
2908
2909    if (mState != EXECUTING && mState != RECONFIGURING) {
2910        return UNKNOWN_ERROR;
2911    }
2912
2913    bool seeking = false;
2914    int64_t seekTimeUs;
2915    ReadOptions::SeekMode seekMode;
2916    if (options && options->getSeekTo(&seekTimeUs, &seekMode)) {
2917        seeking = true;
2918    }
2919    int64_t skipTimeUs;
2920    if (options && options->getSkipFrame(&skipTimeUs)) {
2921        mSkipTimeUs = skipTimeUs;
2922    } else {
2923        mSkipTimeUs = -1;
2924    }
2925
2926    if (mInitialBufferSubmit) {
2927        mInitialBufferSubmit = false;
2928
2929        if (seeking) {
2930            CHECK(seekTimeUs >= 0);
2931            mSeekTimeUs = seekTimeUs;
2932            mSeekMode = seekMode;
2933
2934            // There's no reason to trigger the code below, there's
2935            // nothing to flush yet.
2936            seeking = false;
2937            mPaused = false;
2938        }
2939
2940        drainInputBuffers();
2941
2942        if (mState == EXECUTING) {
2943            // Otherwise mState == RECONFIGURING and this code will trigger
2944            // after the output port is reenabled.
2945            fillOutputBuffers();
2946        }
2947    }
2948
2949    if (seeking) {
2950        CODEC_LOGV("seeking to %lld us (%.2f secs)", seekTimeUs, seekTimeUs / 1E6);
2951
2952        mSignalledEOS = false;
2953
2954        CHECK(seekTimeUs >= 0);
2955        mSeekTimeUs = seekTimeUs;
2956        mSeekMode = seekMode;
2957
2958        mFilledBuffers.clear();
2959
2960        CHECK_EQ(mState, EXECUTING);
2961
2962        bool emulateInputFlushCompletion = !flushPortAsync(kPortIndexInput);
2963        bool emulateOutputFlushCompletion = !flushPortAsync(kPortIndexOutput);
2964
2965        if (emulateInputFlushCompletion) {
2966            onCmdComplete(OMX_CommandFlush, kPortIndexInput);
2967        }
2968
2969        if (emulateOutputFlushCompletion) {
2970            onCmdComplete(OMX_CommandFlush, kPortIndexOutput);
2971        }
2972
2973        while (mSeekTimeUs >= 0) {
2974            mBufferFilled.wait(mLock);
2975        }
2976    }
2977
2978    while (mState != ERROR && !mNoMoreOutputData && mFilledBuffers.empty()) {
2979        mBufferFilled.wait(mLock);
2980    }
2981
2982    if (mState == ERROR) {
2983        return UNKNOWN_ERROR;
2984    }
2985
2986    if (mFilledBuffers.empty()) {
2987        return mSignalledEOS ? mFinalStatus : ERROR_END_OF_STREAM;
2988    }
2989
2990    if (mOutputPortSettingsHaveChanged) {
2991        mOutputPortSettingsHaveChanged = false;
2992
2993        return INFO_FORMAT_CHANGED;
2994    }
2995
2996    size_t index = *mFilledBuffers.begin();
2997    mFilledBuffers.erase(mFilledBuffers.begin());
2998
2999    BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(index);
3000    info->mMediaBuffer->add_ref();
3001    *buffer = info->mMediaBuffer;
3002
3003    return OK;
3004}
3005
3006void OMXCodec::signalBufferReturned(MediaBuffer *buffer) {
3007    Mutex::Autolock autoLock(mLock);
3008
3009    Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
3010    for (size_t i = 0; i < buffers->size(); ++i) {
3011        BufferInfo *info = &buffers->editItemAt(i);
3012
3013        if (info->mMediaBuffer == buffer) {
3014            CHECK_EQ(mPortStatus[kPortIndexOutput], ENABLED);
3015            fillOutputBuffer(info);
3016            return;
3017        }
3018    }
3019
3020    CHECK(!"should not be here.");
3021}
3022
3023static const char *imageCompressionFormatString(OMX_IMAGE_CODINGTYPE type) {
3024    static const char *kNames[] = {
3025        "OMX_IMAGE_CodingUnused",
3026        "OMX_IMAGE_CodingAutoDetect",
3027        "OMX_IMAGE_CodingJPEG",
3028        "OMX_IMAGE_CodingJPEG2K",
3029        "OMX_IMAGE_CodingEXIF",
3030        "OMX_IMAGE_CodingTIFF",
3031        "OMX_IMAGE_CodingGIF",
3032        "OMX_IMAGE_CodingPNG",
3033        "OMX_IMAGE_CodingLZW",
3034        "OMX_IMAGE_CodingBMP",
3035    };
3036
3037    size_t numNames = sizeof(kNames) / sizeof(kNames[0]);
3038
3039    if (type < 0 || (size_t)type >= numNames) {
3040        return "UNKNOWN";
3041    } else {
3042        return kNames[type];
3043    }
3044}
3045
3046static const char *colorFormatString(OMX_COLOR_FORMATTYPE type) {
3047    static const char *kNames[] = {
3048        "OMX_COLOR_FormatUnused",
3049        "OMX_COLOR_FormatMonochrome",
3050        "OMX_COLOR_Format8bitRGB332",
3051        "OMX_COLOR_Format12bitRGB444",
3052        "OMX_COLOR_Format16bitARGB4444",
3053        "OMX_COLOR_Format16bitARGB1555",
3054        "OMX_COLOR_Format16bitRGB565",
3055        "OMX_COLOR_Format16bitBGR565",
3056        "OMX_COLOR_Format18bitRGB666",
3057        "OMX_COLOR_Format18bitARGB1665",
3058        "OMX_COLOR_Format19bitARGB1666",
3059        "OMX_COLOR_Format24bitRGB888",
3060        "OMX_COLOR_Format24bitBGR888",
3061        "OMX_COLOR_Format24bitARGB1887",
3062        "OMX_COLOR_Format25bitARGB1888",
3063        "OMX_COLOR_Format32bitBGRA8888",
3064        "OMX_COLOR_Format32bitARGB8888",
3065        "OMX_COLOR_FormatYUV411Planar",
3066        "OMX_COLOR_FormatYUV411PackedPlanar",
3067        "OMX_COLOR_FormatYUV420Planar",
3068        "OMX_COLOR_FormatYUV420PackedPlanar",
3069        "OMX_COLOR_FormatYUV420SemiPlanar",
3070        "OMX_COLOR_FormatYUV422Planar",
3071        "OMX_COLOR_FormatYUV422PackedPlanar",
3072        "OMX_COLOR_FormatYUV422SemiPlanar",
3073        "OMX_COLOR_FormatYCbYCr",
3074        "OMX_COLOR_FormatYCrYCb",
3075        "OMX_COLOR_FormatCbYCrY",
3076        "OMX_COLOR_FormatCrYCbY",
3077        "OMX_COLOR_FormatYUV444Interleaved",
3078        "OMX_COLOR_FormatRawBayer8bit",
3079        "OMX_COLOR_FormatRawBayer10bit",
3080        "OMX_COLOR_FormatRawBayer8bitcompressed",
3081        "OMX_COLOR_FormatL2",
3082        "OMX_COLOR_FormatL4",
3083        "OMX_COLOR_FormatL8",
3084        "OMX_COLOR_FormatL16",
3085        "OMX_COLOR_FormatL24",
3086        "OMX_COLOR_FormatL32",
3087        "OMX_COLOR_FormatYUV420PackedSemiPlanar",
3088        "OMX_COLOR_FormatYUV422PackedSemiPlanar",
3089        "OMX_COLOR_Format18BitBGR666",
3090        "OMX_COLOR_Format24BitARGB6666",
3091        "OMX_COLOR_Format24BitABGR6666",
3092    };
3093
3094    size_t numNames = sizeof(kNames) / sizeof(kNames[0]);
3095
3096    if (type == OMX_QCOM_COLOR_FormatYVU420SemiPlanar) {
3097        return "OMX_QCOM_COLOR_FormatYVU420SemiPlanar";
3098    } else if (type < 0 || (size_t)type >= numNames) {
3099        return "UNKNOWN";
3100    } else {
3101        return kNames[type];
3102    }
3103}
3104
3105static const char *videoCompressionFormatString(OMX_VIDEO_CODINGTYPE type) {
3106    static const char *kNames[] = {
3107        "OMX_VIDEO_CodingUnused",
3108        "OMX_VIDEO_CodingAutoDetect",
3109        "OMX_VIDEO_CodingMPEG2",
3110        "OMX_VIDEO_CodingH263",
3111        "OMX_VIDEO_CodingMPEG4",
3112        "OMX_VIDEO_CodingWMV",
3113        "OMX_VIDEO_CodingRV",
3114        "OMX_VIDEO_CodingAVC",
3115        "OMX_VIDEO_CodingMJPEG",
3116    };
3117
3118    size_t numNames = sizeof(kNames) / sizeof(kNames[0]);
3119
3120    if (type < 0 || (size_t)type >= numNames) {
3121        return "UNKNOWN";
3122    } else {
3123        return kNames[type];
3124    }
3125}
3126
3127static const char *audioCodingTypeString(OMX_AUDIO_CODINGTYPE type) {
3128    static const char *kNames[] = {
3129        "OMX_AUDIO_CodingUnused",
3130        "OMX_AUDIO_CodingAutoDetect",
3131        "OMX_AUDIO_CodingPCM",
3132        "OMX_AUDIO_CodingADPCM",
3133        "OMX_AUDIO_CodingAMR",
3134        "OMX_AUDIO_CodingGSMFR",
3135        "OMX_AUDIO_CodingGSMEFR",
3136        "OMX_AUDIO_CodingGSMHR",
3137        "OMX_AUDIO_CodingPDCFR",
3138        "OMX_AUDIO_CodingPDCEFR",
3139        "OMX_AUDIO_CodingPDCHR",
3140        "OMX_AUDIO_CodingTDMAFR",
3141        "OMX_AUDIO_CodingTDMAEFR",
3142        "OMX_AUDIO_CodingQCELP8",
3143        "OMX_AUDIO_CodingQCELP13",
3144        "OMX_AUDIO_CodingEVRC",
3145        "OMX_AUDIO_CodingSMV",
3146        "OMX_AUDIO_CodingG711",
3147        "OMX_AUDIO_CodingG723",
3148        "OMX_AUDIO_CodingG726",
3149        "OMX_AUDIO_CodingG729",
3150        "OMX_AUDIO_CodingAAC",
3151        "OMX_AUDIO_CodingMP3",
3152        "OMX_AUDIO_CodingSBC",
3153        "OMX_AUDIO_CodingVORBIS",
3154        "OMX_AUDIO_CodingWMA",
3155        "OMX_AUDIO_CodingRA",
3156        "OMX_AUDIO_CodingMIDI",
3157    };
3158
3159    size_t numNames = sizeof(kNames) / sizeof(kNames[0]);
3160
3161    if (type < 0 || (size_t)type >= numNames) {
3162        return "UNKNOWN";
3163    } else {
3164        return kNames[type];
3165    }
3166}
3167
3168static const char *audioPCMModeString(OMX_AUDIO_PCMMODETYPE type) {
3169    static const char *kNames[] = {
3170        "OMX_AUDIO_PCMModeLinear",
3171        "OMX_AUDIO_PCMModeALaw",
3172        "OMX_AUDIO_PCMModeMULaw",
3173    };
3174
3175    size_t numNames = sizeof(kNames) / sizeof(kNames[0]);
3176
3177    if (type < 0 || (size_t)type >= numNames) {
3178        return "UNKNOWN";
3179    } else {
3180        return kNames[type];
3181    }
3182}
3183
3184static const char *amrBandModeString(OMX_AUDIO_AMRBANDMODETYPE type) {
3185    static const char *kNames[] = {
3186        "OMX_AUDIO_AMRBandModeUnused",
3187        "OMX_AUDIO_AMRBandModeNB0",
3188        "OMX_AUDIO_AMRBandModeNB1",
3189        "OMX_AUDIO_AMRBandModeNB2",
3190        "OMX_AUDIO_AMRBandModeNB3",
3191        "OMX_AUDIO_AMRBandModeNB4",
3192        "OMX_AUDIO_AMRBandModeNB5",
3193        "OMX_AUDIO_AMRBandModeNB6",
3194        "OMX_AUDIO_AMRBandModeNB7",
3195        "OMX_AUDIO_AMRBandModeWB0",
3196        "OMX_AUDIO_AMRBandModeWB1",
3197        "OMX_AUDIO_AMRBandModeWB2",
3198        "OMX_AUDIO_AMRBandModeWB3",
3199        "OMX_AUDIO_AMRBandModeWB4",
3200        "OMX_AUDIO_AMRBandModeWB5",
3201        "OMX_AUDIO_AMRBandModeWB6",
3202        "OMX_AUDIO_AMRBandModeWB7",
3203        "OMX_AUDIO_AMRBandModeWB8",
3204    };
3205
3206    size_t numNames = sizeof(kNames) / sizeof(kNames[0]);
3207
3208    if (type < 0 || (size_t)type >= numNames) {
3209        return "UNKNOWN";
3210    } else {
3211        return kNames[type];
3212    }
3213}
3214
3215static const char *amrFrameFormatString(OMX_AUDIO_AMRFRAMEFORMATTYPE type) {
3216    static const char *kNames[] = {
3217        "OMX_AUDIO_AMRFrameFormatConformance",
3218        "OMX_AUDIO_AMRFrameFormatIF1",
3219        "OMX_AUDIO_AMRFrameFormatIF2",
3220        "OMX_AUDIO_AMRFrameFormatFSF",
3221        "OMX_AUDIO_AMRFrameFormatRTPPayload",
3222        "OMX_AUDIO_AMRFrameFormatITU",
3223    };
3224
3225    size_t numNames = sizeof(kNames) / sizeof(kNames[0]);
3226
3227    if (type < 0 || (size_t)type >= numNames) {
3228        return "UNKNOWN";
3229    } else {
3230        return kNames[type];
3231    }
3232}
3233
3234void OMXCodec::dumpPortStatus(OMX_U32 portIndex) {
3235    OMX_PARAM_PORTDEFINITIONTYPE def;
3236    InitOMXParams(&def);
3237    def.nPortIndex = portIndex;
3238
3239    status_t err = mOMX->getParameter(
3240            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
3241    CHECK_EQ(err, OK);
3242
3243    printf("%s Port = {\n", portIndex == kPortIndexInput ? "Input" : "Output");
3244
3245    CHECK((portIndex == kPortIndexInput && def.eDir == OMX_DirInput)
3246          || (portIndex == kPortIndexOutput && def.eDir == OMX_DirOutput));
3247
3248    printf("  nBufferCountActual = %ld\n", def.nBufferCountActual);
3249    printf("  nBufferCountMin = %ld\n", def.nBufferCountMin);
3250    printf("  nBufferSize = %ld\n", def.nBufferSize);
3251
3252    switch (def.eDomain) {
3253        case OMX_PortDomainImage:
3254        {
3255            const OMX_IMAGE_PORTDEFINITIONTYPE *imageDef = &def.format.image;
3256
3257            printf("\n");
3258            printf("  // Image\n");
3259            printf("  nFrameWidth = %ld\n", imageDef->nFrameWidth);
3260            printf("  nFrameHeight = %ld\n", imageDef->nFrameHeight);
3261            printf("  nStride = %ld\n", imageDef->nStride);
3262
3263            printf("  eCompressionFormat = %s\n",
3264                   imageCompressionFormatString(imageDef->eCompressionFormat));
3265
3266            printf("  eColorFormat = %s\n",
3267                   colorFormatString(imageDef->eColorFormat));
3268
3269            break;
3270        }
3271
3272        case OMX_PortDomainVideo:
3273        {
3274            OMX_VIDEO_PORTDEFINITIONTYPE *videoDef = &def.format.video;
3275
3276            printf("\n");
3277            printf("  // Video\n");
3278            printf("  nFrameWidth = %ld\n", videoDef->nFrameWidth);
3279            printf("  nFrameHeight = %ld\n", videoDef->nFrameHeight);
3280            printf("  nStride = %ld\n", videoDef->nStride);
3281
3282            printf("  eCompressionFormat = %s\n",
3283                   videoCompressionFormatString(videoDef->eCompressionFormat));
3284
3285            printf("  eColorFormat = %s\n",
3286                   colorFormatString(videoDef->eColorFormat));
3287
3288            break;
3289        }
3290
3291        case OMX_PortDomainAudio:
3292        {
3293            OMX_AUDIO_PORTDEFINITIONTYPE *audioDef = &def.format.audio;
3294
3295            printf("\n");
3296            printf("  // Audio\n");
3297            printf("  eEncoding = %s\n",
3298                   audioCodingTypeString(audioDef->eEncoding));
3299
3300            if (audioDef->eEncoding == OMX_AUDIO_CodingPCM) {
3301                OMX_AUDIO_PARAM_PCMMODETYPE params;
3302                InitOMXParams(&params);
3303                params.nPortIndex = portIndex;
3304
3305                err = mOMX->getParameter(
3306                        mNode, OMX_IndexParamAudioPcm, &params, sizeof(params));
3307                CHECK_EQ(err, OK);
3308
3309                printf("  nSamplingRate = %ld\n", params.nSamplingRate);
3310                printf("  nChannels = %ld\n", params.nChannels);
3311                printf("  bInterleaved = %d\n", params.bInterleaved);
3312                printf("  nBitPerSample = %ld\n", params.nBitPerSample);
3313
3314                printf("  eNumData = %s\n",
3315                       params.eNumData == OMX_NumericalDataSigned
3316                        ? "signed" : "unsigned");
3317
3318                printf("  ePCMMode = %s\n", audioPCMModeString(params.ePCMMode));
3319            } else if (audioDef->eEncoding == OMX_AUDIO_CodingAMR) {
3320                OMX_AUDIO_PARAM_AMRTYPE amr;
3321                InitOMXParams(&amr);
3322                amr.nPortIndex = portIndex;
3323
3324                err = mOMX->getParameter(
3325                        mNode, OMX_IndexParamAudioAmr, &amr, sizeof(amr));
3326                CHECK_EQ(err, OK);
3327
3328                printf("  nChannels = %ld\n", amr.nChannels);
3329                printf("  eAMRBandMode = %s\n",
3330                        amrBandModeString(amr.eAMRBandMode));
3331                printf("  eAMRFrameFormat = %s\n",
3332                        amrFrameFormatString(amr.eAMRFrameFormat));
3333            }
3334
3335            break;
3336        }
3337
3338        default:
3339        {
3340            printf("  // Unknown\n");
3341            break;
3342        }
3343    }
3344
3345    printf("}\n");
3346}
3347
3348void OMXCodec::initOutputFormat(const sp<MetaData> &inputFormat) {
3349    mOutputFormat = new MetaData;
3350    mOutputFormat->setCString(kKeyDecoderComponent, mComponentName);
3351    if (mIsEncoder) {
3352        int32_t timeScale;
3353        if (inputFormat->findInt32(kKeyTimeScale, &timeScale)) {
3354            mOutputFormat->setInt32(kKeyTimeScale, timeScale);
3355        }
3356    }
3357
3358    OMX_PARAM_PORTDEFINITIONTYPE def;
3359    InitOMXParams(&def);
3360    def.nPortIndex = kPortIndexOutput;
3361
3362    status_t err = mOMX->getParameter(
3363            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
3364    CHECK_EQ(err, OK);
3365
3366    switch (def.eDomain) {
3367        case OMX_PortDomainImage:
3368        {
3369            OMX_IMAGE_PORTDEFINITIONTYPE *imageDef = &def.format.image;
3370            CHECK_EQ(imageDef->eCompressionFormat, OMX_IMAGE_CodingUnused);
3371
3372            mOutputFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RAW);
3373            mOutputFormat->setInt32(kKeyColorFormat, imageDef->eColorFormat);
3374            mOutputFormat->setInt32(kKeyWidth, imageDef->nFrameWidth);
3375            mOutputFormat->setInt32(kKeyHeight, imageDef->nFrameHeight);
3376            break;
3377        }
3378
3379        case OMX_PortDomainAudio:
3380        {
3381            OMX_AUDIO_PORTDEFINITIONTYPE *audio_def = &def.format.audio;
3382
3383            if (audio_def->eEncoding == OMX_AUDIO_CodingPCM) {
3384                OMX_AUDIO_PARAM_PCMMODETYPE params;
3385                InitOMXParams(&params);
3386                params.nPortIndex = kPortIndexOutput;
3387
3388                err = mOMX->getParameter(
3389                        mNode, OMX_IndexParamAudioPcm, &params, sizeof(params));
3390                CHECK_EQ(err, OK);
3391
3392                CHECK_EQ(params.eNumData, OMX_NumericalDataSigned);
3393                CHECK_EQ(params.nBitPerSample, 16);
3394                CHECK_EQ(params.ePCMMode, OMX_AUDIO_PCMModeLinear);
3395
3396                int32_t numChannels, sampleRate;
3397                inputFormat->findInt32(kKeyChannelCount, &numChannels);
3398                inputFormat->findInt32(kKeySampleRate, &sampleRate);
3399
3400                if ((OMX_U32)numChannels != params.nChannels) {
3401                    LOGW("Codec outputs a different number of channels than "
3402                         "the input stream contains (contains %d channels, "
3403                         "codec outputs %ld channels).",
3404                         numChannels, params.nChannels);
3405                }
3406
3407                mOutputFormat->setCString(
3408                        kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW);
3409
3410                // Use the codec-advertised number of channels, as some
3411                // codecs appear to output stereo even if the input data is
3412                // mono. If we know the codec lies about this information,
3413                // use the actual number of channels instead.
3414                mOutputFormat->setInt32(
3415                        kKeyChannelCount,
3416                        (mQuirks & kDecoderLiesAboutNumberOfChannels)
3417                            ? numChannels : params.nChannels);
3418
3419                // The codec-reported sampleRate is not reliable...
3420                mOutputFormat->setInt32(kKeySampleRate, sampleRate);
3421            } else if (audio_def->eEncoding == OMX_AUDIO_CodingAMR) {
3422                OMX_AUDIO_PARAM_AMRTYPE amr;
3423                InitOMXParams(&amr);
3424                amr.nPortIndex = kPortIndexOutput;
3425
3426                err = mOMX->getParameter(
3427                        mNode, OMX_IndexParamAudioAmr, &amr, sizeof(amr));
3428                CHECK_EQ(err, OK);
3429
3430                CHECK_EQ(amr.nChannels, 1);
3431                mOutputFormat->setInt32(kKeyChannelCount, 1);
3432
3433                if (amr.eAMRBandMode >= OMX_AUDIO_AMRBandModeNB0
3434                    && amr.eAMRBandMode <= OMX_AUDIO_AMRBandModeNB7) {
3435                    mOutputFormat->setCString(
3436                            kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AMR_NB);
3437                    mOutputFormat->setInt32(kKeySampleRate, 8000);
3438                } else if (amr.eAMRBandMode >= OMX_AUDIO_AMRBandModeWB0
3439                            && amr.eAMRBandMode <= OMX_AUDIO_AMRBandModeWB8) {
3440                    mOutputFormat->setCString(
3441                            kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AMR_WB);
3442                    mOutputFormat->setInt32(kKeySampleRate, 16000);
3443                } else {
3444                    CHECK(!"Unknown AMR band mode.");
3445                }
3446            } else if (audio_def->eEncoding == OMX_AUDIO_CodingAAC) {
3447                mOutputFormat->setCString(
3448                        kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
3449                int32_t numChannels, sampleRate, bitRate;
3450                inputFormat->findInt32(kKeyChannelCount, &numChannels);
3451                inputFormat->findInt32(kKeySampleRate, &sampleRate);
3452                inputFormat->findInt32(kKeyBitRate, &bitRate);
3453                mOutputFormat->setInt32(kKeyChannelCount, numChannels);
3454                mOutputFormat->setInt32(kKeySampleRate, sampleRate);
3455                mOutputFormat->setInt32(kKeyBitRate, bitRate);
3456            } else {
3457                CHECK(!"Should not be here. Unknown audio encoding.");
3458            }
3459            break;
3460        }
3461
3462        case OMX_PortDomainVideo:
3463        {
3464            OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
3465
3466            if (video_def->eCompressionFormat == OMX_VIDEO_CodingUnused) {
3467                mOutputFormat->setCString(
3468                        kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RAW);
3469            } else if (video_def->eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
3470                mOutputFormat->setCString(
3471                        kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
3472            } else if (video_def->eCompressionFormat == OMX_VIDEO_CodingH263) {
3473                mOutputFormat->setCString(
3474                        kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
3475            } else if (video_def->eCompressionFormat == OMX_VIDEO_CodingAVC) {
3476                mOutputFormat->setCString(
3477                        kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
3478            } else {
3479                CHECK(!"Unknown compression format.");
3480            }
3481
3482            if (!strcmp(mComponentName, "OMX.PV.avcdec")) {
3483                // This component appears to be lying to me.
3484                mOutputFormat->setInt32(
3485                        kKeyWidth, (video_def->nFrameWidth + 15) & -16);
3486                mOutputFormat->setInt32(
3487                        kKeyHeight, (video_def->nFrameHeight + 15) & -16);
3488            } else {
3489                mOutputFormat->setInt32(kKeyWidth, video_def->nFrameWidth);
3490                mOutputFormat->setInt32(kKeyHeight, video_def->nFrameHeight);
3491            }
3492
3493            mOutputFormat->setInt32(kKeyColorFormat, video_def->eColorFormat);
3494            break;
3495        }
3496
3497        default:
3498        {
3499            CHECK(!"should not be here, neither audio nor video.");
3500            break;
3501        }
3502    }
3503}
3504
3505status_t OMXCodec::pause() {
3506    Mutex::Autolock autoLock(mLock);
3507
3508    mPaused = true;
3509
3510    return OK;
3511}
3512
3513////////////////////////////////////////////////////////////////////////////////
3514
3515status_t QueryCodecs(
3516        const sp<IOMX> &omx,
3517        const char *mime, bool queryDecoders,
3518        Vector<CodecCapabilities> *results) {
3519    results->clear();
3520
3521    for (int index = 0;; ++index) {
3522        const char *componentName;
3523
3524        if (!queryDecoders) {
3525            componentName = GetCodec(
3526                    kEncoderInfo, sizeof(kEncoderInfo) / sizeof(kEncoderInfo[0]),
3527                    mime, index);
3528        } else {
3529            componentName = GetCodec(
3530                    kDecoderInfo, sizeof(kDecoderInfo) / sizeof(kDecoderInfo[0]),
3531                    mime, index);
3532        }
3533
3534        if (!componentName) {
3535            return OK;
3536        }
3537
3538        if (strncmp(componentName, "OMX.", 4)) {
3539            // Not an OpenMax component but a software codec.
3540
3541            results->push();
3542            CodecCapabilities *caps = &results->editItemAt(results->size() - 1);
3543            caps->mComponentName = componentName;
3544
3545            continue;
3546        }
3547
3548        sp<OMXCodecObserver> observer = new OMXCodecObserver;
3549        IOMX::node_id node;
3550        status_t err = omx->allocateNode(componentName, observer, &node);
3551
3552        if (err != OK) {
3553            continue;
3554        }
3555
3556        OMXCodec::setComponentRole(omx, node, !queryDecoders, mime);
3557
3558        results->push();
3559        CodecCapabilities *caps = &results->editItemAt(results->size() - 1);
3560        caps->mComponentName = componentName;
3561
3562        OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
3563        InitOMXParams(&param);
3564
3565        param.nPortIndex = queryDecoders ? 0 : 1;
3566
3567        for (param.nProfileIndex = 0;; ++param.nProfileIndex) {
3568            err = omx->getParameter(
3569                    node, OMX_IndexParamVideoProfileLevelQuerySupported,
3570                    &param, sizeof(param));
3571
3572            if (err != OK) {
3573                break;
3574            }
3575
3576            CodecProfileLevel profileLevel;
3577            profileLevel.mProfile = param.eProfile;
3578            profileLevel.mLevel = param.eLevel;
3579
3580            caps->mProfileLevels.push(profileLevel);
3581        }
3582
3583        CHECK_EQ(omx->freeNode(node), OK);
3584    }
3585}
3586
3587}  // namespace android
3588