NuPlayerDecoder.cpp revision dc43dfa1294470a4413c37e863ef3b621da8681f 
1/*
2 * Copyright (C) 2010 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 "NuPlayerDecoder"
19#include <utils/Log.h>
20#include <inttypes.h>
21
22#include "NuPlayerDecoder.h"
23
24#include <media/ICrypto.h>
25#include <media/stagefright/foundation/ABitReader.h>
26#include <media/stagefright/foundation/ABuffer.h>
27#include <media/stagefright/foundation/ADebug.h>
28#include <media/stagefright/foundation/AMessage.h>
29#include <media/stagefright/MediaBuffer.h>
30#include <media/stagefright/MediaCodec.h>
31#include <media/stagefright/MediaDefs.h>
32#include <media/stagefright/MediaErrors.h>
33
34namespace android {
35
36NuPlayer::Decoder::Decoder(
37        const sp<AMessage> &notify,
38        const sp<NativeWindowWrapper> &nativeWindow)
39    : mNotify(notify),
40      mNativeWindow(nativeWindow),
41      mBufferGeneration(0),
42      mPaused(true),
43      mComponentName("decoder") {
44    // Every decoder has its own looper because MediaCodec operations
45    // are blocking, but NuPlayer needs asynchronous operations.
46    mDecoderLooper = new ALooper;
47    mDecoderLooper->setName("NPDecoder");
48    mDecoderLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
49
50    mCodecLooper = new ALooper;
51    mCodecLooper->setName("NPDecoder-CL");
52    mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
53}
54
55NuPlayer::Decoder::~Decoder() {
56}
57
58static
59status_t PostAndAwaitResponse(
60        const sp<AMessage> &msg, sp<AMessage> *response) {
61    status_t err = msg->postAndAwaitResponse(response);
62
63    if (err != OK) {
64        return err;
65    }
66
67    if (!(*response)->findInt32("err", &err)) {
68        err = OK;
69    }
70
71    return err;
72}
73
74void NuPlayer::Decoder::rememberCodecSpecificData(const sp<AMessage> &format) {
75    mCSDsForCurrentFormat.clear();
76    for (int32_t i = 0; ; ++i) {
77        AString tag = "csd-";
78        tag.append(i);
79        sp<ABuffer> buffer;
80        if (!format->findBuffer(tag.c_str(), &buffer)) {
81            break;
82        }
83        mCSDsForCurrentFormat.push(buffer);
84    }
85}
86
87void NuPlayer::Decoder::onConfigure(const sp<AMessage> &format) {
88    CHECK(mCodec == NULL);
89
90    ++mBufferGeneration;
91
92    AString mime;
93    CHECK(format->findString("mime", &mime));
94
95    sp<Surface> surface = NULL;
96    if (mNativeWindow != NULL) {
97        surface = mNativeWindow->getSurfaceTextureClient();
98    }
99
100    mComponentName = mime;
101    mComponentName.append(" decoder");
102    ALOGV("[%s] onConfigure (surface=%p)", mComponentName.c_str(), surface.get());
103
104    mCodec = MediaCodec::CreateByType(mCodecLooper, mime.c_str(), false /* encoder */);
105    int32_t secure = 0;
106    if (format->findInt32("secure", &secure) && secure != 0) {
107        if (mCodec != NULL) {
108            mCodec->getName(&mComponentName);
109            mComponentName.append(".secure");
110            mCodec->release();
111            ALOGI("[%s] creating", mComponentName.c_str());
112            mCodec = MediaCodec::CreateByComponentName(
113                    mCodecLooper, mComponentName.c_str());
114        }
115    }
116    if (mCodec == NULL) {
117        ALOGE("Failed to create %s%s decoder",
118                (secure ? "secure " : ""), mime.c_str());
119        handleError(UNKNOWN_ERROR);
120        return;
121    }
122
123    mCodec->getName(&mComponentName);
124
125    status_t err;
126    if (mNativeWindow != NULL) {
127        // disconnect from surface as MediaCodec will reconnect
128        err = native_window_api_disconnect(
129                surface.get(), NATIVE_WINDOW_API_MEDIA);
130        // We treat this as a warning, as this is a preparatory step.
131        // Codec will try to connect to the surface, which is where
132        // any error signaling will occur.
133        ALOGW_IF(err != OK, "failed to disconnect from surface: %d", err);
134    }
135    err = mCodec->configure(
136            format, surface, NULL /* crypto */, 0 /* flags */);
137    if (err != OK) {
138        ALOGE("Failed to configure %s decoder (err=%d)", mComponentName.c_str(), err);
139        handleError(err);
140        return;
141    }
142    rememberCodecSpecificData(format);
143
144    // the following should work in configured state
145    CHECK_EQ((status_t)OK, mCodec->getOutputFormat(&mOutputFormat));
146    CHECK_EQ((status_t)OK, mCodec->getInputFormat(&mInputFormat));
147
148    err = mCodec->start();
149    if (err != OK) {
150        ALOGE("Failed to start %s decoder (err=%d)", mComponentName.c_str(), err);
151        handleError(err);
152        return;
153    }
154
155    // the following should work after start
156    CHECK_EQ((status_t)OK, mCodec->getInputBuffers(&mInputBuffers));
157    releaseAndResetMediaBuffers();
158    CHECK_EQ((status_t)OK, mCodec->getOutputBuffers(&mOutputBuffers));
159    ALOGV("[%s] got %zu input and %zu output buffers",
160            mComponentName.c_str(),
161            mInputBuffers.size(),
162            mOutputBuffers.size());
163
164    requestCodecNotification();
165    mPaused = false;
166}
167
168void NuPlayer::Decoder::releaseAndResetMediaBuffers() {
169    for (size_t i = 0; i < mMediaBuffers.size(); i++) {
170        if (mMediaBuffers[i] != NULL) {
171            mMediaBuffers[i]->release();
172            mMediaBuffers.editItemAt(i) = NULL;
173        }
174    }
175    mMediaBuffers.resize(mInputBuffers.size());
176    for (size_t i = 0; i < mMediaBuffers.size(); i++) {
177        mMediaBuffers.editItemAt(i) = NULL;
178    }
179    mInputBufferIsDequeued.clear();
180    mInputBufferIsDequeued.resize(mInputBuffers.size());
181    for (size_t i = 0; i < mInputBufferIsDequeued.size(); i++) {
182        mInputBufferIsDequeued.editItemAt(i) = false;
183    }
184}
185
186void NuPlayer::Decoder::requestCodecNotification() {
187    if (mCodec != NULL) {
188        sp<AMessage> reply = new AMessage(kWhatCodecNotify, id());
189        reply->setInt32("generation", mBufferGeneration);
190        mCodec->requestActivityNotification(reply);
191    }
192}
193
194bool NuPlayer::Decoder::isStaleReply(const sp<AMessage> &msg) {
195    int32_t generation;
196    CHECK(msg->findInt32("generation", &generation));
197    return generation != mBufferGeneration;
198}
199
200void NuPlayer::Decoder::init() {
201    mDecoderLooper->registerHandler(this);
202}
203
204void NuPlayer::Decoder::configure(const sp<AMessage> &format) {
205    sp<AMessage> msg = new AMessage(kWhatConfigure, id());
206    msg->setMessage("format", format);
207    msg->post();
208}
209
210void NuPlayer::Decoder::signalUpdateFormat(const sp<AMessage> &format) {
211    sp<AMessage> msg = new AMessage(kWhatUpdateFormat, id());
212    msg->setMessage("format", format);
213    msg->post();
214}
215
216status_t NuPlayer::Decoder::getInputBuffers(Vector<sp<ABuffer> > *buffers) const {
217    sp<AMessage> msg = new AMessage(kWhatGetInputBuffers, id());
218    msg->setPointer("buffers", buffers);
219
220    sp<AMessage> response;
221    return PostAndAwaitResponse(msg, &response);
222}
223
224void NuPlayer::Decoder::handleError(int32_t err)
225{
226    mCodec->release();
227
228    sp<AMessage> notify = mNotify->dup();
229    notify->setInt32("what", kWhatError);
230    notify->setInt32("err", err);
231    notify->post();
232}
233
234bool NuPlayer::Decoder::handleAnInputBuffer() {
235    size_t bufferIx = -1;
236    status_t res = mCodec->dequeueInputBuffer(&bufferIx);
237    ALOGV("[%s] dequeued input: %d",
238            mComponentName.c_str(), res == OK ? (int)bufferIx : res);
239    if (res != OK) {
240        if (res != -EAGAIN) {
241            handleError(res);
242        }
243        return false;
244    }
245
246    CHECK_LT(bufferIx, mInputBuffers.size());
247
248    if (mMediaBuffers[bufferIx] != NULL) {
249        mMediaBuffers[bufferIx]->release();
250        mMediaBuffers.editItemAt(bufferIx) = NULL;
251    }
252    mInputBufferIsDequeued.editItemAt(bufferIx) = true;
253
254    sp<AMessage> reply = new AMessage(kWhatInputBufferFilled, id());
255    reply->setSize("buffer-ix", bufferIx);
256    reply->setInt32("generation", mBufferGeneration);
257
258    if (!mCSDsToSubmit.isEmpty()) {
259        sp<ABuffer> buffer = mCSDsToSubmit.itemAt(0);
260        ALOGI("[%s] resubmitting CSD", mComponentName.c_str());
261        reply->setBuffer("buffer", buffer);
262        mCSDsToSubmit.removeAt(0);
263        reply->post();
264        return true;
265    }
266
267    sp<AMessage> notify = mNotify->dup();
268    notify->setInt32("what", kWhatFillThisBuffer);
269    notify->setBuffer("buffer", mInputBuffers[bufferIx]);
270    notify->setMessage("reply", reply);
271    notify->post();
272    return true;
273}
274
275void android::NuPlayer::Decoder::onInputBufferFilled(const sp<AMessage> &msg) {
276    size_t bufferIx;
277    CHECK(msg->findSize("buffer-ix", &bufferIx));
278    CHECK_LT(bufferIx, mInputBuffers.size());
279    sp<ABuffer> codecBuffer = mInputBuffers[bufferIx];
280
281    sp<ABuffer> buffer;
282    bool hasBuffer = msg->findBuffer("buffer", &buffer);
283
284    // handle widevine classic source - that fills an arbitrary input buffer
285    MediaBuffer *mediaBuffer = NULL;
286    if (hasBuffer && buffer->meta()->findPointer(
287            "mediaBuffer", (void **)&mediaBuffer)) {
288        if (mediaBuffer == NULL) {
289            // received no actual buffer
290            ALOGW("[%s] received null MediaBuffer %s",
291                    mComponentName.c_str(), msg->debugString().c_str());
292            buffer = NULL;
293        } else {
294            // likely filled another buffer than we requested: adjust buffer index
295            size_t ix;
296            for (ix = 0; ix < mInputBuffers.size(); ix++) {
297                const sp<ABuffer> &buf = mInputBuffers[ix];
298                if (buf->data() == mediaBuffer->data()) {
299                    // all input buffers are dequeued on start, hence the check
300                    CHECK(mInputBufferIsDequeued[ix]);
301                    ALOGV("[%s] received MediaBuffer for #%zu instead of #%zu",
302                            mComponentName.c_str(), ix, bufferIx);
303
304                    // TRICKY: need buffer for the metadata, so instead, set
305                    // codecBuffer to the same (though incorrect) buffer to
306                    // avoid a memcpy into the codecBuffer
307                    codecBuffer = buffer;
308                    codecBuffer->setRange(
309                            mediaBuffer->range_offset(),
310                            mediaBuffer->range_length());
311                    bufferIx = ix;
312                    break;
313                }
314            }
315            CHECK(ix < mInputBuffers.size());
316        }
317    }
318
319    mInputBufferIsDequeued.editItemAt(bufferIx) = false;
320
321    if (buffer == NULL /* includes !hasBuffer */) {
322        int32_t streamErr = ERROR_END_OF_STREAM;
323        CHECK(msg->findInt32("err", &streamErr) || !hasBuffer);
324
325        if (streamErr == OK) {
326            /* buffers are returned to hold on to */
327            return;
328        }
329
330        // attempt to queue EOS
331        status_t err = mCodec->queueInputBuffer(
332                bufferIx,
333                0,
334                0,
335                0,
336                MediaCodec::BUFFER_FLAG_EOS);
337        if (streamErr == ERROR_END_OF_STREAM && err != OK) {
338            streamErr = err;
339            // err will not be ERROR_END_OF_STREAM
340        }
341
342        if (streamErr != ERROR_END_OF_STREAM) {
343            handleError(streamErr);
344        }
345    } else {
346        int64_t timeUs = 0;
347        uint32_t flags = 0;
348        CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
349
350        int32_t eos, csd;
351        // we do not expect SYNCFRAME for decoder
352        if (buffer->meta()->findInt32("eos", &eos) && eos) {
353            flags |= MediaCodec::BUFFER_FLAG_EOS;
354        } else if (buffer->meta()->findInt32("csd", &csd) && csd) {
355            flags |= MediaCodec::BUFFER_FLAG_CODECCONFIG;
356        }
357
358        // copy into codec buffer
359        if (buffer != codecBuffer) {
360            CHECK_LE(buffer->size(), codecBuffer->capacity());
361            codecBuffer->setRange(0, buffer->size());
362            memcpy(codecBuffer->data(), buffer->data(), buffer->size());
363        }
364
365        status_t err = mCodec->queueInputBuffer(
366                        bufferIx,
367                        codecBuffer->offset(),
368                        codecBuffer->size(),
369                        timeUs,
370                        flags);
371        if (err != OK) {
372            ALOGE("Failed to queue input buffer for %s (err=%d)",
373                    mComponentName.c_str(), err);
374            handleError(err);
375        }
376
377        if (mediaBuffer != NULL) {
378            CHECK(mMediaBuffers[bufferIx] == NULL);
379            mMediaBuffers.editItemAt(bufferIx) = mediaBuffer;
380        }
381    }
382}
383
384bool NuPlayer::Decoder::handleAnOutputBuffer() {
385    size_t bufferIx = -1;
386    size_t offset;
387    size_t size;
388    int64_t timeUs;
389    uint32_t flags;
390    status_t res = mCodec->dequeueOutputBuffer(
391            &bufferIx, &offset, &size, &timeUs, &flags);
392
393    if (res != OK) {
394        ALOGV("[%s] dequeued output: %d", mComponentName.c_str(), res);
395    } else {
396        ALOGV("[%s] dequeued output: %d (time=%lld flags=%" PRIu32 ")",
397                mComponentName.c_str(), (int)bufferIx, timeUs, flags);
398    }
399
400    if (res == INFO_OUTPUT_BUFFERS_CHANGED) {
401        res = mCodec->getOutputBuffers(&mOutputBuffers);
402        if (res != OK) {
403            ALOGE("Failed to get output buffers for %s after INFO event (err=%d)",
404                    mComponentName.c_str(), res);
405            handleError(res);
406            return false;
407        }
408        // NuPlayer ignores this
409        return true;
410    } else if (res == INFO_FORMAT_CHANGED) {
411        sp<AMessage> format = new AMessage();
412        res = mCodec->getOutputFormat(&format);
413        if (res != OK) {
414            ALOGE("Failed to get output format for %s after INFO event (err=%d)",
415                    mComponentName.c_str(), res);
416            handleError(res);
417            return false;
418        }
419
420        sp<AMessage> notify = mNotify->dup();
421        notify->setInt32("what", kWhatOutputFormatChanged);
422        notify->setMessage("format", format);
423        notify->post();
424        return true;
425    } else if (res == INFO_DISCONTINUITY) {
426        // nothing to do
427        return true;
428    } else if (res != OK) {
429        if (res != -EAGAIN) {
430            handleError(res);
431        }
432        return false;
433    }
434
435    CHECK_LT(bufferIx, mOutputBuffers.size());
436    sp<ABuffer> buffer = mOutputBuffers[bufferIx];
437    buffer->setRange(offset, size);
438    buffer->meta()->clear();
439    buffer->meta()->setInt64("timeUs", timeUs);
440    if (flags & MediaCodec::BUFFER_FLAG_EOS) {
441        buffer->meta()->setInt32("eos", true);
442    }
443    // we do not expect CODECCONFIG or SYNCFRAME for decoder
444
445    sp<AMessage> reply = new AMessage(kWhatRenderBuffer, id());
446    reply->setSize("buffer-ix", bufferIx);
447    reply->setInt32("generation", mBufferGeneration);
448
449    sp<AMessage> notify = mNotify->dup();
450    notify->setInt32("what", kWhatDrainThisBuffer);
451    notify->setBuffer("buffer", buffer);
452    notify->setMessage("reply", reply);
453    notify->post();
454
455    // FIXME: This should be handled after rendering is complete,
456    // but Renderer needs it now
457    if (flags & MediaCodec::BUFFER_FLAG_EOS) {
458        ALOGV("queueing eos [%s]", mComponentName.c_str());
459        sp<AMessage> notify = mNotify->dup();
460        notify->setInt32("what", kWhatEOS);
461        notify->setInt32("err", ERROR_END_OF_STREAM);
462        notify->post();
463    }
464    return true;
465}
466
467void NuPlayer::Decoder::onRenderBuffer(const sp<AMessage> &msg) {
468    status_t err;
469    int32_t render;
470    size_t bufferIx;
471    CHECK(msg->findSize("buffer-ix", &bufferIx));
472    if (msg->findInt32("render", &render) && render) {
473        int64_t timestampNs;
474        CHECK(msg->findInt64("timestampNs", &timestampNs));
475        err = mCodec->renderOutputBufferAndRelease(bufferIx, timestampNs);
476    } else {
477        err = mCodec->releaseOutputBuffer(bufferIx);
478    }
479    if (err != OK) {
480        ALOGE("failed to release output buffer for %s (err=%d)",
481                mComponentName.c_str(), err);
482        handleError(err);
483    }
484}
485
486void NuPlayer::Decoder::onFlush() {
487    status_t err = OK;
488    if (mCodec != NULL) {
489        err = mCodec->flush();
490        mCSDsToSubmit = mCSDsForCurrentFormat; // copy operator
491        ++mBufferGeneration;
492    }
493
494    if (err != OK) {
495        ALOGE("failed to flush %s (err=%d)", mComponentName.c_str(), err);
496        handleError(err);
497        return;
498    }
499
500    releaseAndResetMediaBuffers();
501
502    sp<AMessage> notify = mNotify->dup();
503    notify->setInt32("what", kWhatFlushCompleted);
504    notify->post();
505    mPaused = true;
506}
507
508void NuPlayer::Decoder::onResume() {
509    mPaused = false;
510}
511
512void NuPlayer::Decoder::onShutdown() {
513    status_t err = OK;
514    if (mCodec != NULL) {
515        err = mCodec->release();
516        mCodec = NULL;
517        ++mBufferGeneration;
518
519        if (mNativeWindow != NULL) {
520            // reconnect to surface as MediaCodec disconnected from it
521            status_t error =
522                    native_window_api_connect(
523                            mNativeWindow->getNativeWindow().get(),
524                            NATIVE_WINDOW_API_MEDIA);
525            ALOGW_IF(error != NO_ERROR,
526                    "[%s] failed to connect to native window, error=%d",
527                    mComponentName.c_str(), error);
528        }
529        mComponentName = "decoder";
530    }
531
532    releaseAndResetMediaBuffers();
533
534    if (err != OK) {
535        ALOGE("failed to release %s (err=%d)", mComponentName.c_str(), err);
536        handleError(err);
537        return;
538    }
539
540    sp<AMessage> notify = mNotify->dup();
541    notify->setInt32("what", kWhatShutdownCompleted);
542    notify->post();
543    mPaused = true;
544}
545
546void NuPlayer::Decoder::onMessageReceived(const sp<AMessage> &msg) {
547    ALOGV("[%s] onMessage: %s", mComponentName.c_str(), msg->debugString().c_str());
548
549    switch (msg->what()) {
550        case kWhatConfigure:
551        {
552            sp<AMessage> format;
553            CHECK(msg->findMessage("format", &format));
554            onConfigure(format);
555            break;
556        }
557
558        case kWhatUpdateFormat:
559        {
560            sp<AMessage> format;
561            CHECK(msg->findMessage("format", &format));
562            rememberCodecSpecificData(format);
563            break;
564        }
565
566        case kWhatGetInputBuffers:
567        {
568            uint32_t replyID;
569            CHECK(msg->senderAwaitsResponse(&replyID));
570
571            Vector<sp<ABuffer> > *dstBuffers;
572            CHECK(msg->findPointer("buffers", (void **)&dstBuffers));
573
574            dstBuffers->clear();
575            for (size_t i = 0; i < mInputBuffers.size(); i++) {
576                dstBuffers->push(mInputBuffers[i]);
577            }
578
579            (new AMessage)->postReply(replyID);
580            break;
581        }
582
583        case kWhatCodecNotify:
584        {
585            if (!isStaleReply(msg)) {
586                if (!mPaused) {
587                    while (handleAnInputBuffer()) {
588                    }
589                }
590
591                while (handleAnOutputBuffer()) {
592                }
593            }
594
595            requestCodecNotification();
596            break;
597        }
598
599        case kWhatInputBufferFilled:
600        {
601            if (!isStaleReply(msg)) {
602                onInputBufferFilled(msg);
603            } else {
604                /* release any MediaBuffer passed in the stale buffer */
605                sp<ABuffer> buffer;
606                MediaBuffer *mediaBuffer = NULL;
607                if (msg->findBuffer("buffer", &buffer) &&
608                    buffer->meta()->findPointer(
609                            "mediaBuffer", (void **)&mediaBuffer) &&
610                    mediaBuffer != NULL) {
611                    mediaBuffer->release();
612                }
613            }
614
615            break;
616        }
617
618        case kWhatRenderBuffer:
619        {
620            if (!isStaleReply(msg)) {
621                onRenderBuffer(msg);
622            }
623            break;
624        }
625
626        case kWhatFlush:
627        {
628            sp<AMessage> format;
629            if (msg->findMessage("new-format", &format)) {
630                rememberCodecSpecificData(format);
631            }
632            onFlush();
633            break;
634        }
635
636        case kWhatResume:
637        {
638            onResume();
639            break;
640        }
641
642        case kWhatShutdown:
643        {
644            onShutdown();
645            break;
646        }
647
648        default:
649            TRESPASS();
650            break;
651    }
652}
653
654void NuPlayer::Decoder::signalFlush(const sp<AMessage> &format) {
655    sp<AMessage> msg = new AMessage(kWhatFlush, id());
656    if (format != NULL) {
657        msg->setMessage("new-format", format);
658    }
659    msg->post();
660}
661
662void NuPlayer::Decoder::signalResume() {
663    (new AMessage(kWhatResume, id()))->post();
664}
665
666void NuPlayer::Decoder::initiateShutdown() {
667    (new AMessage(kWhatShutdown, id()))->post();
668}
669
670bool NuPlayer::Decoder::supportsSeamlessAudioFormatChange(const sp<AMessage> &targetFormat) const {
671    if (targetFormat == NULL) {
672        return true;
673    }
674
675    AString mime;
676    if (!targetFormat->findString("mime", &mime)) {
677        return false;
678    }
679
680    if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_AAC)) {
681        // field-by-field comparison
682        const char * keys[] = { "channel-count", "sample-rate", "is-adts" };
683        for (unsigned int i = 0; i < sizeof(keys) / sizeof(keys[0]); i++) {
684            int32_t oldVal, newVal;
685            if (!mOutputFormat->findInt32(keys[i], &oldVal) ||
686                    !targetFormat->findInt32(keys[i], &newVal) ||
687                    oldVal != newVal) {
688                return false;
689            }
690        }
691
692        sp<ABuffer> oldBuf, newBuf;
693        if (mOutputFormat->findBuffer("csd-0", &oldBuf) &&
694                targetFormat->findBuffer("csd-0", &newBuf)) {
695            if (oldBuf->size() != newBuf->size()) {
696                return false;
697            }
698            return !memcmp(oldBuf->data(), newBuf->data(), oldBuf->size());
699        }
700    }
701    return false;
702}
703
704bool NuPlayer::Decoder::supportsSeamlessFormatChange(const sp<AMessage> &targetFormat) const {
705    if (mOutputFormat == NULL) {
706        return false;
707    }
708
709    if (targetFormat == NULL) {
710        return true;
711    }
712
713    AString oldMime, newMime;
714    if (!mOutputFormat->findString("mime", &oldMime)
715            || !targetFormat->findString("mime", &newMime)
716            || !(oldMime == newMime)) {
717        return false;
718    }
719
720    bool audio = !strncasecmp(oldMime.c_str(), "audio/", strlen("audio/"));
721    bool seamless;
722    if (audio) {
723        seamless = supportsSeamlessAudioFormatChange(targetFormat);
724    } else {
725        int32_t isAdaptive;
726        seamless = (mCodec != NULL &&
727                mInputFormat->findInt32("adaptive-playback", &isAdaptive) &&
728                isAdaptive);
729    }
730
731    ALOGV("%s seamless support for %s", seamless ? "yes" : "no", oldMime.c_str());
732    return seamless;
733}
734
735struct CCData {
736    CCData(uint8_t type, uint8_t data1, uint8_t data2)
737        : mType(type), mData1(data1), mData2(data2) {
738    }
739    bool getChannel(size_t *channel) const {
740        if (mData1 >= 0x10 && mData1 <= 0x1f) {
741            *channel = (mData1 >= 0x18 ? 1 : 0) + (mType ? 2 : 0);
742            return true;
743        }
744        return false;
745    }
746
747    uint8_t mType;
748    uint8_t mData1;
749    uint8_t mData2;
750};
751
752static bool isNullPad(CCData *cc) {
753    return cc->mData1 < 0x10 && cc->mData2 < 0x10;
754}
755
756static void dumpBytePair(const sp<ABuffer> &ccBuf) {
757    size_t offset = 0;
758    AString out;
759
760    while (offset < ccBuf->size()) {
761        char tmp[128];
762
763        CCData *cc = (CCData *) (ccBuf->data() + offset);
764
765        if (isNullPad(cc)) {
766            // 1 null pad or XDS metadata, ignore
767            offset += sizeof(CCData);
768            continue;
769        }
770
771        if (cc->mData1 >= 0x20 && cc->mData1 <= 0x7f) {
772            // 2 basic chars
773            sprintf(tmp, "[%d]Basic: %c %c", cc->mType, cc->mData1, cc->mData2);
774        } else if ((cc->mData1 == 0x11 || cc->mData1 == 0x19)
775                 && cc->mData2 >= 0x30 && cc->mData2 <= 0x3f) {
776            // 1 special char
777            sprintf(tmp, "[%d]Special: %02x %02x", cc->mType, cc->mData1, cc->mData2);
778        } else if ((cc->mData1 == 0x12 || cc->mData1 == 0x1A)
779                 && cc->mData2 >= 0x20 && cc->mData2 <= 0x3f){
780            // 1 Spanish/French char
781            sprintf(tmp, "[%d]Spanish: %02x %02x", cc->mType, cc->mData1, cc->mData2);
782        } else if ((cc->mData1 == 0x13 || cc->mData1 == 0x1B)
783                 && cc->mData2 >= 0x20 && cc->mData2 <= 0x3f){
784            // 1 Portuguese/German/Danish char
785            sprintf(tmp, "[%d]German: %02x %02x", cc->mType, cc->mData1, cc->mData2);
786        } else if ((cc->mData1 == 0x11 || cc->mData1 == 0x19)
787                 && cc->mData2 >= 0x20 && cc->mData2 <= 0x2f){
788            // Mid-Row Codes (Table 69)
789            sprintf(tmp, "[%d]Mid-row: %02x %02x", cc->mType, cc->mData1, cc->mData2);
790        } else if (((cc->mData1 == 0x14 || cc->mData1 == 0x1c)
791                  && cc->mData2 >= 0x20 && cc->mData2 <= 0x2f)
792                  ||
793                   ((cc->mData1 == 0x17 || cc->mData1 == 0x1f)
794                  && cc->mData2 >= 0x21 && cc->mData2 <= 0x23)){
795            // Misc Control Codes (Table 70)
796            sprintf(tmp, "[%d]Ctrl: %02x %02x", cc->mType, cc->mData1, cc->mData2);
797        } else if ((cc->mData1 & 0x70) == 0x10
798                && (cc->mData2 & 0x40) == 0x40
799                && ((cc->mData1 & 0x07) || !(cc->mData2 & 0x20)) ) {
800            // Preamble Address Codes (Table 71)
801            sprintf(tmp, "[%d]PAC: %02x %02x", cc->mType, cc->mData1, cc->mData2);
802        } else {
803            sprintf(tmp, "[%d]Invalid: %02x %02x", cc->mType, cc->mData1, cc->mData2);
804        }
805
806        if (out.size() > 0) {
807            out.append(", ");
808        }
809
810        out.append(tmp);
811
812        offset += sizeof(CCData);
813    }
814
815    ALOGI("%s", out.c_str());
816}
817
818NuPlayer::CCDecoder::CCDecoder(const sp<AMessage> &notify)
819    : mNotify(notify),
820      mCurrentChannel(0),
821      mSelectedTrack(-1) {
822      for (size_t i = 0; i < sizeof(mTrackIndices)/sizeof(mTrackIndices[0]); ++i) {
823          mTrackIndices[i] = -1;
824      }
825}
826
827size_t NuPlayer::CCDecoder::getTrackCount() const {
828    return mFoundChannels.size();
829}
830
831sp<AMessage> NuPlayer::CCDecoder::getTrackInfo(size_t index) const {
832    if (!isTrackValid(index)) {
833        return NULL;
834    }
835
836    sp<AMessage> format = new AMessage();
837
838    format->setInt32("type", MEDIA_TRACK_TYPE_SUBTITLE);
839    format->setString("language", "und");
840    format->setString("mime", MEDIA_MIMETYPE_TEXT_CEA_608);
841    //CC1, field 0 channel 0
842    bool isDefaultAuto = (mFoundChannels[index] == 0);
843    format->setInt32("auto", isDefaultAuto);
844    format->setInt32("default", isDefaultAuto);
845    format->setInt32("forced", 0);
846
847    return format;
848}
849
850status_t NuPlayer::CCDecoder::selectTrack(size_t index, bool select) {
851    if (!isTrackValid(index)) {
852        return BAD_VALUE;
853    }
854
855    if (select) {
856        if (mSelectedTrack == (ssize_t)index) {
857            ALOGE("track %zu already selected", index);
858            return BAD_VALUE;
859        }
860        ALOGV("selected track %zu", index);
861        mSelectedTrack = index;
862    } else {
863        if (mSelectedTrack != (ssize_t)index) {
864            ALOGE("track %zu is not selected", index);
865            return BAD_VALUE;
866        }
867        ALOGV("unselected track %zu", index);
868        mSelectedTrack = -1;
869    }
870
871    return OK;
872}
873
874bool NuPlayer::CCDecoder::isSelected() const {
875    return mSelectedTrack >= 0 && mSelectedTrack < (int32_t) getTrackCount();
876}
877
878bool NuPlayer::CCDecoder::isTrackValid(size_t index) const {
879    return index < getTrackCount();
880}
881
882int32_t NuPlayer::CCDecoder::getTrackIndex(size_t channel) const {
883    if (channel < sizeof(mTrackIndices)/sizeof(mTrackIndices[0])) {
884        return mTrackIndices[channel];
885    }
886    return -1;
887}
888
889// returns true if a new CC track is found
890bool NuPlayer::CCDecoder::extractFromSEI(const sp<ABuffer> &accessUnit) {
891    int64_t timeUs;
892    CHECK(accessUnit->meta()->findInt64("timeUs", &timeUs));
893
894    sp<ABuffer> sei;
895    if (!accessUnit->meta()->findBuffer("sei", &sei) || sei == NULL) {
896        return false;
897    }
898
899    bool trackAdded = false;
900
901    NALBitReader br(sei->data() + 1, sei->size() - 1);
902    // sei_message()
903    while (br.atLeastNumBitsLeft(16)) { // at least 16-bit for sei_message()
904        uint32_t payload_type = 0;
905        size_t payload_size = 0;
906        uint8_t last_byte;
907
908        do {
909            last_byte = br.getBits(8);
910            payload_type += last_byte;
911        } while (last_byte == 0xFF);
912
913        do {
914            last_byte = br.getBits(8);
915            payload_size += last_byte;
916        } while (last_byte == 0xFF);
917
918        // sei_payload()
919        if (payload_type == 4) {
920            // user_data_registered_itu_t_t35()
921
922            // ATSC A/72: 6.4.2
923            uint8_t itu_t_t35_country_code = br.getBits(8);
924            uint16_t itu_t_t35_provider_code = br.getBits(16);
925            uint32_t user_identifier = br.getBits(32);
926            uint8_t user_data_type_code = br.getBits(8);
927
928            payload_size -= 1 + 2 + 4 + 1;
929
930            if (itu_t_t35_country_code == 0xB5
931                    && itu_t_t35_provider_code == 0x0031
932                    && user_identifier == 'GA94'
933                    && user_data_type_code == 0x3) {
934                // MPEG_cc_data()
935                // ATSC A/53 Part 4: 6.2.3.1
936                br.skipBits(1); //process_em_data_flag
937                bool process_cc_data_flag = br.getBits(1);
938                br.skipBits(1); //additional_data_flag
939                size_t cc_count = br.getBits(5);
940                br.skipBits(8); // em_data;
941                payload_size -= 2;
942
943                if (process_cc_data_flag) {
944                    AString out;
945
946                    sp<ABuffer> ccBuf = new ABuffer(cc_count * sizeof(CCData));
947                    ccBuf->setRange(0, 0);
948
949                    for (size_t i = 0; i < cc_count; i++) {
950                        uint8_t marker = br.getBits(5);
951                        CHECK_EQ(marker, 0x1f);
952
953                        bool cc_valid = br.getBits(1);
954                        uint8_t cc_type = br.getBits(2);
955                        // remove odd parity bit
956                        uint8_t cc_data_1 = br.getBits(8) & 0x7f;
957                        uint8_t cc_data_2 = br.getBits(8) & 0x7f;
958
959                        if (cc_valid
960                                && (cc_type == 0 || cc_type == 1)) {
961                            CCData cc(cc_type, cc_data_1, cc_data_2);
962                            if (!isNullPad(&cc)) {
963                                size_t channel;
964                                if (cc.getChannel(&channel) && getTrackIndex(channel) < 0) {
965                                    mTrackIndices[channel] = mFoundChannels.size();
966                                    mFoundChannels.push_back(channel);
967                                    trackAdded = true;
968                                }
969                                memcpy(ccBuf->data() + ccBuf->size(),
970                                        (void *)&cc, sizeof(cc));
971                                ccBuf->setRange(0, ccBuf->size() + sizeof(CCData));
972                            }
973                        }
974                    }
975                    payload_size -= cc_count * 3;
976
977                    mCCMap.add(timeUs, ccBuf);
978                    break;
979                }
980            } else {
981                ALOGV("Malformed SEI payload type 4");
982            }
983        } else {
984            ALOGV("Unsupported SEI payload type %d", payload_type);
985        }
986
987        // skipping remaining bits of this payload
988        br.skipBits(payload_size * 8);
989    }
990
991    return trackAdded;
992}
993
994sp<ABuffer> NuPlayer::CCDecoder::filterCCBuf(
995        const sp<ABuffer> &ccBuf, size_t index) {
996    sp<ABuffer> filteredCCBuf = new ABuffer(ccBuf->size());
997    filteredCCBuf->setRange(0, 0);
998
999    size_t cc_count = ccBuf->size() / sizeof(CCData);
1000    const CCData* cc_data = (const CCData*)ccBuf->data();
1001    for (size_t i = 0; i < cc_count; ++i) {
1002        size_t channel;
1003        if (cc_data[i].getChannel(&channel)) {
1004            mCurrentChannel = channel;
1005        }
1006        if (mCurrentChannel == mFoundChannels[index]) {
1007            memcpy(filteredCCBuf->data() + filteredCCBuf->size(),
1008                    (void *)&cc_data[i], sizeof(CCData));
1009            filteredCCBuf->setRange(0, filteredCCBuf->size() + sizeof(CCData));
1010        }
1011    }
1012
1013    return filteredCCBuf;
1014}
1015
1016void NuPlayer::CCDecoder::decode(const sp<ABuffer> &accessUnit) {
1017    if (extractFromSEI(accessUnit)) {
1018        ALOGI("Found CEA-608 track");
1019        sp<AMessage> msg = mNotify->dup();
1020        msg->setInt32("what", kWhatTrackAdded);
1021        msg->post();
1022    }
1023    // TODO: extract CC from other sources
1024}
1025
1026void NuPlayer::CCDecoder::display(int64_t timeUs) {
1027    if (!isTrackValid(mSelectedTrack)) {
1028        ALOGE("Could not find current track(index=%d)", mSelectedTrack);
1029        return;
1030    }
1031
1032    ssize_t index = mCCMap.indexOfKey(timeUs);
1033    if (index < 0) {
1034        ALOGV("cc for timestamp %" PRId64 " not found", timeUs);
1035        return;
1036    }
1037
1038    sp<ABuffer> ccBuf = filterCCBuf(mCCMap.valueAt(index), mSelectedTrack);
1039
1040    if (ccBuf->size() > 0) {
1041#if 0
1042        dumpBytePair(ccBuf);
1043#endif
1044
1045        ccBuf->meta()->setInt32("trackIndex", mSelectedTrack);
1046        ccBuf->meta()->setInt64("timeUs", timeUs);
1047        ccBuf->meta()->setInt64("durationUs", 0ll);
1048
1049        sp<AMessage> msg = mNotify->dup();
1050        msg->setInt32("what", kWhatClosedCaptionData);
1051        msg->setBuffer("buffer", ccBuf);
1052        msg->post();
1053    }
1054
1055    // remove all entries before timeUs
1056    mCCMap.removeItemsAt(0, index + 1);
1057}
1058
1059void NuPlayer::CCDecoder::flush() {
1060    mCCMap.clear();
1061}
1062
1063}  // namespace android
1064
1065