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