1 /*
2  * Copyright 2014 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 <algorithm>
23 
24 #include "NuPlayerCCDecoder.h"
25 #include "NuPlayerDecoder.h"
26 #include "NuPlayerDrm.h"
27 #include "NuPlayerRenderer.h"
28 #include "NuPlayerSource.h"
29 
30 #include <cutils/properties.h>
31 #include <mediadrm/ICrypto.h>
32 #include <media/MediaBufferHolder.h>
33 #include <media/MediaCodecBuffer.h>
34 #include <media/stagefright/foundation/ABuffer.h>
35 #include <media/stagefright/foundation/ADebug.h>
36 #include <media/stagefright/foundation/AMessage.h>
37 #include <media/stagefright/foundation/avc_utils.h>
38 #include <media/stagefright/MediaBuffer.h>
39 #include <media/stagefright/MediaCodec.h>
40 #include <media/stagefright/MediaDefs.h>
41 #include <media/stagefright/MediaErrors.h>
42 #include <media/stagefright/SurfaceUtils.h>
43 #include <gui/Surface.h>
44 
45 #include "ATSParser.h"
46 
47 namespace android {
48 
49 static float kDisplayRefreshingRate = 60.f; // TODO: get this from the display
50 
51 // The default total video frame rate of a stream when that info is not available from
52 // the source.
53 static float kDefaultVideoFrameRateTotal = 30.f;
54 
getAudioDeepBufferSetting()55 static inline bool getAudioDeepBufferSetting() {
56     return property_get_bool("media.stagefright.audio.deep", false /* default_value */);
57 }
58 
Decoder(const sp<AMessage> & notify,const sp<Source> & source,pid_t pid,uid_t uid,const sp<Renderer> & renderer,const sp<Surface> & surface,const sp<CCDecoder> & ccDecoder)59 NuPlayer::Decoder::Decoder(
60         const sp<AMessage> &notify,
61         const sp<Source> &source,
62         pid_t pid,
63         uid_t uid,
64         const sp<Renderer> &renderer,
65         const sp<Surface> &surface,
66         const sp<CCDecoder> &ccDecoder)
67     : DecoderBase(notify),
68       mSurface(surface),
69       mSource(source),
70       mRenderer(renderer),
71       mCCDecoder(ccDecoder),
72       mPid(pid),
73       mUid(uid),
74       mSkipRenderingUntilMediaTimeUs(-1LL),
75       mNumFramesTotal(0LL),
76       mNumInputFramesDropped(0LL),
77       mNumOutputFramesDropped(0LL),
78       mVideoWidth(0),
79       mVideoHeight(0),
80       mIsAudio(true),
81       mIsVideoAVC(false),
82       mIsSecure(false),
83       mIsEncrypted(false),
84       mIsEncryptedObservedEarlier(false),
85       mFormatChangePending(false),
86       mTimeChangePending(false),
87       mFrameRateTotal(kDefaultVideoFrameRateTotal),
88       mPlaybackSpeed(1.0f),
89       mNumVideoTemporalLayerTotal(1), // decode all layers
90       mNumVideoTemporalLayerAllowed(1),
91       mCurrentMaxVideoTemporalLayerId(0),
92       mResumePending(false),
93       mComponentName("decoder") {
94     mCodecLooper = new ALooper;
95     mCodecLooper->setName("NPDecoder-CL");
96     mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
97     mVideoTemporalLayerAggregateFps[0] = mFrameRateTotal;
98 }
99 
~Decoder()100 NuPlayer::Decoder::~Decoder() {
101     // Need to stop looper first since mCodec could be accessed on the mDecoderLooper.
102     stopLooper();
103     if (mCodec != NULL) {
104         mCodec->release();
105     }
106     releaseAndResetMediaBuffers();
107 }
108 
getStats() const109 sp<AMessage> NuPlayer::Decoder::getStats() const {
110 
111     mStats->setInt64("frames-total", mNumFramesTotal);
112     mStats->setInt64("frames-dropped-input", mNumInputFramesDropped);
113     mStats->setInt64("frames-dropped-output", mNumOutputFramesDropped);
114     mStats->setFloat("frame-rate-total", mFrameRateTotal);
115 
116     // i'm mutexed right now.
117     // make our own copy, so we aren't victim to any later changes.
118     sp<AMessage> copiedStats = mStats->dup();
119     return copiedStats;
120 }
121 
setVideoSurface(const sp<Surface> & surface)122 status_t NuPlayer::Decoder::setVideoSurface(const sp<Surface> &surface) {
123     if (surface == NULL || ADebug::isExperimentEnabled("legacy-setsurface")) {
124         return BAD_VALUE;
125     }
126 
127     sp<AMessage> msg = new AMessage(kWhatSetVideoSurface, this);
128 
129     msg->setObject("surface", surface);
130     sp<AMessage> response;
131     status_t err = msg->postAndAwaitResponse(&response);
132     if (err == OK && response != NULL) {
133         CHECK(response->findInt32("err", &err));
134     }
135     return err;
136 }
137 
onMessageReceived(const sp<AMessage> & msg)138 void NuPlayer::Decoder::onMessageReceived(const sp<AMessage> &msg) {
139     ALOGV("[%s] onMessage: %s", mComponentName.c_str(), msg->debugString().c_str());
140 
141     switch (msg->what()) {
142         case kWhatCodecNotify:
143         {
144             int32_t cbID;
145             CHECK(msg->findInt32("callbackID", &cbID));
146 
147             ALOGV("[%s] kWhatCodecNotify: cbID = %d, paused = %d",
148                     mIsAudio ? "audio" : "video", cbID, mPaused);
149 
150             if (mPaused) {
151                 break;
152             }
153 
154             switch (cbID) {
155                 case MediaCodec::CB_INPUT_AVAILABLE:
156                 {
157                     int32_t index;
158                     CHECK(msg->findInt32("index", &index));
159 
160                     handleAnInputBuffer(index);
161                     break;
162                 }
163 
164                 case MediaCodec::CB_OUTPUT_AVAILABLE:
165                 {
166                     int32_t index;
167                     size_t offset;
168                     size_t size;
169                     int64_t timeUs;
170                     int32_t flags;
171 
172                     CHECK(msg->findInt32("index", &index));
173                     CHECK(msg->findSize("offset", &offset));
174                     CHECK(msg->findSize("size", &size));
175                     CHECK(msg->findInt64("timeUs", &timeUs));
176                     CHECK(msg->findInt32("flags", &flags));
177 
178                     handleAnOutputBuffer(index, offset, size, timeUs, flags);
179                     break;
180                 }
181 
182                 case MediaCodec::CB_OUTPUT_FORMAT_CHANGED:
183                 {
184                     sp<AMessage> format;
185                     CHECK(msg->findMessage("format", &format));
186 
187                     handleOutputFormatChange(format);
188                     break;
189                 }
190 
191                 case MediaCodec::CB_ERROR:
192                 {
193                     status_t err;
194                     CHECK(msg->findInt32("err", &err));
195                     ALOGE("Decoder (%s) reported error : 0x%x",
196                             mIsAudio ? "audio" : "video", err);
197 
198                     handleError(err);
199                     break;
200                 }
201 
202                 default:
203                 {
204                     TRESPASS();
205                     break;
206                 }
207             }
208 
209             break;
210         }
211 
212         case kWhatRenderBuffer:
213         {
214             if (!isStaleReply(msg)) {
215                 onRenderBuffer(msg);
216             }
217             break;
218         }
219 
220         case kWhatAudioOutputFormatChanged:
221         {
222             if (!isStaleReply(msg)) {
223                 status_t err;
224                 if (msg->findInt32("err", &err) && err != OK) {
225                     ALOGE("Renderer reported 0x%x when changing audio output format", err);
226                     handleError(err);
227                 }
228             }
229             break;
230         }
231 
232         case kWhatSetVideoSurface:
233         {
234             sp<AReplyToken> replyID;
235             CHECK(msg->senderAwaitsResponse(&replyID));
236 
237             sp<RefBase> obj;
238             CHECK(msg->findObject("surface", &obj));
239             sp<Surface> surface = static_cast<Surface *>(obj.get()); // non-null
240             int32_t err = INVALID_OPERATION;
241             // NOTE: in practice mSurface is always non-null, but checking here for completeness
242             if (mCodec != NULL && mSurface != NULL) {
243                 // TODO: once AwesomePlayer is removed, remove this automatic connecting
244                 // to the surface by MediaPlayerService.
245                 //
246                 // at this point MediaPlayerService::client has already connected to the
247                 // surface, which MediaCodec does not expect
248                 err = nativeWindowDisconnect(surface.get(), "kWhatSetVideoSurface(surface)");
249                 if (err == OK) {
250                     err = mCodec->setSurface(surface);
251                     ALOGI_IF(err, "codec setSurface returned: %d", err);
252                     if (err == OK) {
253                         // reconnect to the old surface as MPS::Client will expect to
254                         // be able to disconnect from it.
255                         (void)nativeWindowConnect(mSurface.get(), "kWhatSetVideoSurface(mSurface)");
256                         mSurface = surface;
257                     }
258                 }
259                 if (err != OK) {
260                     // reconnect to the new surface on error as MPS::Client will expect to
261                     // be able to disconnect from it.
262                     (void)nativeWindowConnect(surface.get(), "kWhatSetVideoSurface(err)");
263                 }
264             }
265 
266             sp<AMessage> response = new AMessage;
267             response->setInt32("err", err);
268             response->postReply(replyID);
269             break;
270         }
271 
272         case kWhatDrmReleaseCrypto:
273         {
274             ALOGV("kWhatDrmReleaseCrypto");
275             onReleaseCrypto(msg);
276             break;
277         }
278 
279         default:
280             DecoderBase::onMessageReceived(msg);
281             break;
282     }
283 }
284 
onConfigure(const sp<AMessage> & format)285 void NuPlayer::Decoder::onConfigure(const sp<AMessage> &format) {
286     CHECK(mCodec == NULL);
287 
288     mFormatChangePending = false;
289     mTimeChangePending = false;
290 
291     ++mBufferGeneration;
292 
293     AString mime;
294     CHECK(format->findString("mime", &mime));
295 
296     mIsAudio = !strncasecmp("audio/", mime.c_str(), 6);
297     mIsVideoAVC = !strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mime.c_str());
298 
299     mComponentName = mime;
300     mComponentName.append(" decoder");
301     ALOGV("[%s] onConfigure (surface=%p)", mComponentName.c_str(), mSurface.get());
302 
303     mCodec = MediaCodec::CreateByType(
304             mCodecLooper, mime.c_str(), false /* encoder */, NULL /* err */, mPid, mUid);
305     int32_t secure = 0;
306     if (format->findInt32("secure", &secure) && secure != 0) {
307         if (mCodec != NULL) {
308             mCodec->getName(&mComponentName);
309             mComponentName.append(".secure");
310             mCodec->release();
311             ALOGI("[%s] creating", mComponentName.c_str());
312             mCodec = MediaCodec::CreateByComponentName(
313                     mCodecLooper, mComponentName.c_str(), NULL /* err */, mPid, mUid);
314         }
315     }
316     if (mCodec == NULL) {
317         ALOGE("Failed to create %s%s decoder",
318                 (secure ? "secure " : ""), mime.c_str());
319         handleError(UNKNOWN_ERROR);
320         return;
321     }
322     mIsSecure = secure;
323 
324     mCodec->getName(&mComponentName);
325 
326     status_t err;
327     if (mSurface != NULL) {
328         // disconnect from surface as MediaCodec will reconnect
329         err = nativeWindowDisconnect(mSurface.get(), "onConfigure");
330         // We treat this as a warning, as this is a preparatory step.
331         // Codec will try to connect to the surface, which is where
332         // any error signaling will occur.
333         ALOGW_IF(err != OK, "failed to disconnect from surface: %d", err);
334     }
335 
336     // Modular DRM
337     void *pCrypto;
338     if (!format->findPointer("crypto", &pCrypto)) {
339         pCrypto = NULL;
340     }
341     sp<ICrypto> crypto = (ICrypto*)pCrypto;
342     // non-encrypted source won't have a crypto
343     mIsEncrypted = (crypto != NULL);
344     // configure is called once; still using OR in case the behavior changes.
345     mIsEncryptedObservedEarlier = mIsEncryptedObservedEarlier || mIsEncrypted;
346     ALOGV("onConfigure mCrypto: %p (%d)  mIsSecure: %d",
347             crypto.get(), (crypto != NULL ? crypto->getStrongCount() : 0), mIsSecure);
348 
349     err = mCodec->configure(
350             format, mSurface, crypto, 0 /* flags */);
351 
352     if (err != OK) {
353         ALOGE("Failed to configure [%s] decoder (err=%d)", mComponentName.c_str(), err);
354         mCodec->release();
355         mCodec.clear();
356         handleError(err);
357         return;
358     }
359     rememberCodecSpecificData(format);
360 
361     // the following should work in configured state
362     CHECK_EQ((status_t)OK, mCodec->getOutputFormat(&mOutputFormat));
363     CHECK_EQ((status_t)OK, mCodec->getInputFormat(&mInputFormat));
364 
365     mStats->setString("mime", mime.c_str());
366     mStats->setString("component-name", mComponentName.c_str());
367 
368     if (!mIsAudio) {
369         int32_t width, height;
370         if (mOutputFormat->findInt32("width", &width)
371                 && mOutputFormat->findInt32("height", &height)) {
372             mStats->setInt32("width", width);
373             mStats->setInt32("height", height);
374         }
375     }
376 
377     sp<AMessage> reply = new AMessage(kWhatCodecNotify, this);
378     mCodec->setCallback(reply);
379 
380     err = mCodec->start();
381     if (err != OK) {
382         ALOGE("Failed to start [%s] decoder (err=%d)", mComponentName.c_str(), err);
383         mCodec->release();
384         mCodec.clear();
385         handleError(err);
386         return;
387     }
388 
389     releaseAndResetMediaBuffers();
390 
391     mPaused = false;
392     mResumePending = false;
393 }
394 
onSetParameters(const sp<AMessage> & params)395 void NuPlayer::Decoder::onSetParameters(const sp<AMessage> &params) {
396     bool needAdjustLayers = false;
397     float frameRateTotal;
398     if (params->findFloat("frame-rate-total", &frameRateTotal)
399             && mFrameRateTotal != frameRateTotal) {
400         needAdjustLayers = true;
401         mFrameRateTotal = frameRateTotal;
402     }
403 
404     int32_t numVideoTemporalLayerTotal;
405     if (params->findInt32("temporal-layer-count", &numVideoTemporalLayerTotal)
406             && numVideoTemporalLayerTotal >= 0
407             && numVideoTemporalLayerTotal <= kMaxNumVideoTemporalLayers
408             && mNumVideoTemporalLayerTotal != numVideoTemporalLayerTotal) {
409         needAdjustLayers = true;
410         mNumVideoTemporalLayerTotal = std::max(numVideoTemporalLayerTotal, 1);
411     }
412 
413     if (needAdjustLayers && mNumVideoTemporalLayerTotal > 1) {
414         // TODO: For now, layer fps is calculated for some specific architectures.
415         // But it really should be extracted from the stream.
416         mVideoTemporalLayerAggregateFps[0] =
417             mFrameRateTotal / (float)(1LL << (mNumVideoTemporalLayerTotal - 1));
418         for (int32_t i = 1; i < mNumVideoTemporalLayerTotal; ++i) {
419             mVideoTemporalLayerAggregateFps[i] =
420                 mFrameRateTotal / (float)(1LL << (mNumVideoTemporalLayerTotal - i))
421                 + mVideoTemporalLayerAggregateFps[i - 1];
422         }
423     }
424 
425     float playbackSpeed;
426     if (params->findFloat("playback-speed", &playbackSpeed)
427             && mPlaybackSpeed != playbackSpeed) {
428         needAdjustLayers = true;
429         mPlaybackSpeed = playbackSpeed;
430     }
431 
432     if (needAdjustLayers) {
433         float decodeFrameRate = mFrameRateTotal;
434         // enable temporal layering optimization only if we know the layering depth
435         if (mNumVideoTemporalLayerTotal > 1) {
436             int32_t layerId;
437             for (layerId = 0; layerId < mNumVideoTemporalLayerTotal - 1; ++layerId) {
438                 if (mVideoTemporalLayerAggregateFps[layerId] * mPlaybackSpeed
439                         >= kDisplayRefreshingRate * 0.9) {
440                     break;
441                 }
442             }
443             mNumVideoTemporalLayerAllowed = layerId + 1;
444             decodeFrameRate = mVideoTemporalLayerAggregateFps[layerId];
445         }
446         ALOGV("onSetParameters: allowed layers=%d, decodeFps=%g",
447                 mNumVideoTemporalLayerAllowed, decodeFrameRate);
448 
449         if (mCodec == NULL) {
450             ALOGW("onSetParameters called before codec is created.");
451             return;
452         }
453 
454         sp<AMessage> codecParams = new AMessage();
455         codecParams->setFloat("operating-rate", decodeFrameRate * mPlaybackSpeed);
456         mCodec->setParameters(codecParams);
457     }
458 }
459 
onSetRenderer(const sp<Renderer> & renderer)460 void NuPlayer::Decoder::onSetRenderer(const sp<Renderer> &renderer) {
461     mRenderer = renderer;
462 }
463 
onResume(bool notifyComplete)464 void NuPlayer::Decoder::onResume(bool notifyComplete) {
465     mPaused = false;
466 
467     if (notifyComplete) {
468         mResumePending = true;
469     }
470 
471     if (mCodec == NULL) {
472         ALOGE("[%s] onResume without a valid codec", mComponentName.c_str());
473         handleError(NO_INIT);
474         return;
475     }
476     mCodec->start();
477 }
478 
doFlush(bool notifyComplete)479 void NuPlayer::Decoder::doFlush(bool notifyComplete) {
480     if (mCCDecoder != NULL) {
481         mCCDecoder->flush();
482     }
483 
484     if (mRenderer != NULL) {
485         mRenderer->flush(mIsAudio, notifyComplete);
486         mRenderer->signalTimeDiscontinuity();
487     }
488 
489     status_t err = OK;
490     if (mCodec != NULL) {
491         err = mCodec->flush();
492         mCSDsToSubmit = mCSDsForCurrentFormat; // copy operator
493         ++mBufferGeneration;
494     }
495 
496     if (err != OK) {
497         ALOGE("failed to flush [%s] (err=%d)", mComponentName.c_str(), err);
498         handleError(err);
499         // finish with posting kWhatFlushCompleted.
500         // we attempt to release the buffers even if flush fails.
501     }
502     releaseAndResetMediaBuffers();
503     mPaused = true;
504 }
505 
506 
onFlush()507 void NuPlayer::Decoder::onFlush() {
508     doFlush(true);
509 
510     if (isDiscontinuityPending()) {
511         // This could happen if the client starts seeking/shutdown
512         // after we queued an EOS for discontinuities.
513         // We can consider discontinuity handled.
514         finishHandleDiscontinuity(false /* flushOnTimeChange */);
515     }
516 
517     sp<AMessage> notify = mNotify->dup();
518     notify->setInt32("what", kWhatFlushCompleted);
519     notify->post();
520 }
521 
onShutdown(bool notifyComplete)522 void NuPlayer::Decoder::onShutdown(bool notifyComplete) {
523     status_t err = OK;
524 
525     // if there is a pending resume request, notify complete now
526     notifyResumeCompleteIfNecessary();
527 
528     if (mCodec != NULL) {
529         err = mCodec->release();
530         mCodec = NULL;
531         ++mBufferGeneration;
532 
533         if (mSurface != NULL) {
534             // reconnect to surface as MediaCodec disconnected from it
535             status_t error = nativeWindowConnect(mSurface.get(), "onShutdown");
536             ALOGW_IF(error != NO_ERROR,
537                     "[%s] failed to connect to native window, error=%d",
538                     mComponentName.c_str(), error);
539         }
540         mComponentName = "decoder";
541     }
542 
543     releaseAndResetMediaBuffers();
544 
545     if (err != OK) {
546         ALOGE("failed to release [%s] (err=%d)", mComponentName.c_str(), err);
547         handleError(err);
548         // finish with posting kWhatShutdownCompleted.
549     }
550 
551     if (notifyComplete) {
552         sp<AMessage> notify = mNotify->dup();
553         notify->setInt32("what", kWhatShutdownCompleted);
554         notify->post();
555         mPaused = true;
556     }
557 }
558 
559 /*
560  * returns true if we should request more data
561  */
doRequestBuffers()562 bool NuPlayer::Decoder::doRequestBuffers() {
563     if (isDiscontinuityPending()) {
564         return false;
565     }
566     status_t err = OK;
567     while (err == OK && !mDequeuedInputBuffers.empty()) {
568         size_t bufferIx = *mDequeuedInputBuffers.begin();
569         sp<AMessage> msg = new AMessage();
570         msg->setSize("buffer-ix", bufferIx);
571         err = fetchInputData(msg);
572         if (err != OK && err != ERROR_END_OF_STREAM) {
573             // if EOS, need to queue EOS buffer
574             break;
575         }
576         mDequeuedInputBuffers.erase(mDequeuedInputBuffers.begin());
577 
578         if (!mPendingInputMessages.empty()
579                 || !onInputBufferFetched(msg)) {
580             mPendingInputMessages.push_back(msg);
581         }
582     }
583 
584     return err == -EWOULDBLOCK
585             && mSource->feedMoreTSData() == OK;
586 }
587 
handleError(int32_t err)588 void NuPlayer::Decoder::handleError(int32_t err)
589 {
590     // We cannot immediately release the codec due to buffers still outstanding
591     // in the renderer.  We signal to the player the error so it can shutdown/release the
592     // decoder after flushing and increment the generation to discard unnecessary messages.
593 
594     ++mBufferGeneration;
595 
596     sp<AMessage> notify = mNotify->dup();
597     notify->setInt32("what", kWhatError);
598     notify->setInt32("err", err);
599     notify->post();
600 }
601 
releaseCrypto()602 status_t NuPlayer::Decoder::releaseCrypto()
603 {
604     ALOGV("releaseCrypto");
605 
606     sp<AMessage> msg = new AMessage(kWhatDrmReleaseCrypto, this);
607 
608     sp<AMessage> response;
609     status_t status = msg->postAndAwaitResponse(&response);
610     if (status == OK && response != NULL) {
611         CHECK(response->findInt32("status", &status));
612         ALOGV("releaseCrypto ret: %d ", status);
613     } else {
614         ALOGE("releaseCrypto err: %d", status);
615     }
616 
617     return status;
618 }
619 
onReleaseCrypto(const sp<AMessage> & msg)620 void NuPlayer::Decoder::onReleaseCrypto(const sp<AMessage>& msg)
621 {
622     status_t status = INVALID_OPERATION;
623     if (mCodec != NULL) {
624         status = mCodec->releaseCrypto();
625     } else {
626         // returning OK if the codec has been already released
627         status = OK;
628         ALOGE("onReleaseCrypto No mCodec. err: %d", status);
629     }
630 
631     sp<AMessage> response = new AMessage;
632     response->setInt32("status", status);
633     // Clearing the state as it's tied to crypto. mIsEncryptedObservedEarlier is sticky though
634     // and lasts for the lifetime of this codec. See its use in fetchInputData.
635     mIsEncrypted = false;
636 
637     sp<AReplyToken> replyID;
638     CHECK(msg->senderAwaitsResponse(&replyID));
639     response->postReply(replyID);
640 }
641 
handleAnInputBuffer(size_t index)642 bool NuPlayer::Decoder::handleAnInputBuffer(size_t index) {
643     if (isDiscontinuityPending()) {
644         return false;
645     }
646 
647     if (mCodec == NULL) {
648         ALOGE("[%s] handleAnInputBuffer without a valid codec", mComponentName.c_str());
649         handleError(NO_INIT);
650         return false;
651     }
652 
653     sp<MediaCodecBuffer> buffer;
654     mCodec->getInputBuffer(index, &buffer);
655 
656     if (buffer == NULL) {
657         ALOGE("[%s] handleAnInputBuffer, failed to get input buffer", mComponentName.c_str());
658         handleError(UNKNOWN_ERROR);
659         return false;
660     }
661 
662     if (index >= mInputBuffers.size()) {
663         for (size_t i = mInputBuffers.size(); i <= index; ++i) {
664             mInputBuffers.add();
665             mMediaBuffers.add();
666             mInputBufferIsDequeued.add();
667             mMediaBuffers.editItemAt(i) = NULL;
668             mInputBufferIsDequeued.editItemAt(i) = false;
669         }
670     }
671     mInputBuffers.editItemAt(index) = buffer;
672 
673     //CHECK_LT(bufferIx, mInputBuffers.size());
674 
675     if (mMediaBuffers[index] != NULL) {
676         mMediaBuffers[index]->release();
677         mMediaBuffers.editItemAt(index) = NULL;
678     }
679     mInputBufferIsDequeued.editItemAt(index) = true;
680 
681     if (!mCSDsToSubmit.isEmpty()) {
682         sp<AMessage> msg = new AMessage();
683         msg->setSize("buffer-ix", index);
684 
685         sp<ABuffer> buffer = mCSDsToSubmit.itemAt(0);
686         ALOGV("[%s] resubmitting CSD", mComponentName.c_str());
687         msg->setBuffer("buffer", buffer);
688         mCSDsToSubmit.removeAt(0);
689         if (!onInputBufferFetched(msg)) {
690             handleError(UNKNOWN_ERROR);
691             return false;
692         }
693         return true;
694     }
695 
696     while (!mPendingInputMessages.empty()) {
697         sp<AMessage> msg = *mPendingInputMessages.begin();
698         if (!onInputBufferFetched(msg)) {
699             break;
700         }
701         mPendingInputMessages.erase(mPendingInputMessages.begin());
702     }
703 
704     if (!mInputBufferIsDequeued.editItemAt(index)) {
705         return true;
706     }
707 
708     mDequeuedInputBuffers.push_back(index);
709 
710     onRequestInputBuffers();
711     return true;
712 }
713 
handleAnOutputBuffer(size_t index,size_t offset,size_t size,int64_t timeUs,int32_t flags)714 bool NuPlayer::Decoder::handleAnOutputBuffer(
715         size_t index,
716         size_t offset,
717         size_t size,
718         int64_t timeUs,
719         int32_t flags) {
720     if (mCodec == NULL) {
721         ALOGE("[%s] handleAnOutputBuffer without a valid codec", mComponentName.c_str());
722         handleError(NO_INIT);
723         return false;
724     }
725 
726 //    CHECK_LT(bufferIx, mOutputBuffers.size());
727     sp<MediaCodecBuffer> buffer;
728     mCodec->getOutputBuffer(index, &buffer);
729 
730     if (buffer == NULL) {
731         ALOGE("[%s] handleAnOutputBuffer, failed to get output buffer", mComponentName.c_str());
732         handleError(UNKNOWN_ERROR);
733         return false;
734     }
735 
736     if (index >= mOutputBuffers.size()) {
737         for (size_t i = mOutputBuffers.size(); i <= index; ++i) {
738             mOutputBuffers.add();
739         }
740     }
741 
742     mOutputBuffers.editItemAt(index) = buffer;
743 
744     buffer->setRange(offset, size);
745     buffer->meta()->clear();
746     buffer->meta()->setInt64("timeUs", timeUs);
747 
748     bool eos = flags & MediaCodec::BUFFER_FLAG_EOS;
749     // we do not expect CODECCONFIG or SYNCFRAME for decoder
750 
751     sp<AMessage> reply = new AMessage(kWhatRenderBuffer, this);
752     reply->setSize("buffer-ix", index);
753     reply->setInt32("generation", mBufferGeneration);
754     reply->setSize("size", size);
755 
756     if (eos) {
757         ALOGV("[%s] saw output EOS", mIsAudio ? "audio" : "video");
758 
759         buffer->meta()->setInt32("eos", true);
760         reply->setInt32("eos", true);
761     }
762 
763     mNumFramesTotal += !mIsAudio;
764 
765     if (mSkipRenderingUntilMediaTimeUs >= 0) {
766         if (timeUs < mSkipRenderingUntilMediaTimeUs) {
767             ALOGV("[%s] dropping buffer at time %lld as requested.",
768                      mComponentName.c_str(), (long long)timeUs);
769 
770             reply->post();
771             if (eos) {
772                 notifyResumeCompleteIfNecessary();
773                 if (mRenderer != NULL && !isDiscontinuityPending()) {
774                     mRenderer->queueEOS(mIsAudio, ERROR_END_OF_STREAM);
775                 }
776             }
777             return true;
778         }
779 
780         mSkipRenderingUntilMediaTimeUs = -1;
781     }
782 
783     // wait until 1st frame comes out to signal resume complete
784     notifyResumeCompleteIfNecessary();
785 
786     if (mRenderer != NULL) {
787         // send the buffer to renderer.
788         mRenderer->queueBuffer(mIsAudio, buffer, reply);
789         if (eos && !isDiscontinuityPending()) {
790             mRenderer->queueEOS(mIsAudio, ERROR_END_OF_STREAM);
791         }
792     }
793 
794     return true;
795 }
796 
handleOutputFormatChange(const sp<AMessage> & format)797 void NuPlayer::Decoder::handleOutputFormatChange(const sp<AMessage> &format) {
798     if (!mIsAudio) {
799         int32_t width, height;
800         if (format->findInt32("width", &width)
801                 && format->findInt32("height", &height)) {
802             mStats->setInt32("width", width);
803             mStats->setInt32("height", height);
804         }
805         sp<AMessage> notify = mNotify->dup();
806         notify->setInt32("what", kWhatVideoSizeChanged);
807         notify->setMessage("format", format);
808         notify->post();
809     } else if (mRenderer != NULL) {
810         uint32_t flags;
811         int64_t durationUs;
812         bool hasVideo = (mSource->getFormat(false /* audio */) != NULL);
813         if (getAudioDeepBufferSetting() // override regardless of source duration
814                 || (mSource->getDuration(&durationUs) == OK
815                         && durationUs > AUDIO_SINK_MIN_DEEP_BUFFER_DURATION_US)) {
816             flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
817         } else {
818             flags = AUDIO_OUTPUT_FLAG_NONE;
819         }
820 
821         sp<AMessage> reply = new AMessage(kWhatAudioOutputFormatChanged, this);
822         reply->setInt32("generation", mBufferGeneration);
823         mRenderer->changeAudioFormat(
824                 format, false /* offloadOnly */, hasVideo,
825                 flags, mSource->isStreaming(), reply);
826     }
827 }
828 
releaseAndResetMediaBuffers()829 void NuPlayer::Decoder::releaseAndResetMediaBuffers() {
830     for (size_t i = 0; i < mMediaBuffers.size(); i++) {
831         if (mMediaBuffers[i] != NULL) {
832             mMediaBuffers[i]->release();
833             mMediaBuffers.editItemAt(i) = NULL;
834         }
835     }
836     mMediaBuffers.resize(mInputBuffers.size());
837     for (size_t i = 0; i < mMediaBuffers.size(); i++) {
838         mMediaBuffers.editItemAt(i) = NULL;
839     }
840     mInputBufferIsDequeued.clear();
841     mInputBufferIsDequeued.resize(mInputBuffers.size());
842     for (size_t i = 0; i < mInputBufferIsDequeued.size(); i++) {
843         mInputBufferIsDequeued.editItemAt(i) = false;
844     }
845 
846     mPendingInputMessages.clear();
847     mDequeuedInputBuffers.clear();
848     mSkipRenderingUntilMediaTimeUs = -1;
849 }
850 
requestCodecNotification()851 void NuPlayer::Decoder::requestCodecNotification() {
852     if (mCodec != NULL) {
853         sp<AMessage> reply = new AMessage(kWhatCodecNotify, this);
854         reply->setInt32("generation", mBufferGeneration);
855         mCodec->requestActivityNotification(reply);
856     }
857 }
858 
isStaleReply(const sp<AMessage> & msg)859 bool NuPlayer::Decoder::isStaleReply(const sp<AMessage> &msg) {
860     int32_t generation;
861     CHECK(msg->findInt32("generation", &generation));
862     return generation != mBufferGeneration;
863 }
864 
fetchInputData(sp<AMessage> & reply)865 status_t NuPlayer::Decoder::fetchInputData(sp<AMessage> &reply) {
866     sp<ABuffer> accessUnit;
867     bool dropAccessUnit = true;
868     do {
869         status_t err = mSource->dequeueAccessUnit(mIsAudio, &accessUnit);
870 
871         if (err == -EWOULDBLOCK) {
872             return err;
873         } else if (err != OK) {
874             if (err == INFO_DISCONTINUITY) {
875                 int32_t type;
876                 CHECK(accessUnit->meta()->findInt32("discontinuity", &type));
877 
878                 bool formatChange =
879                     (mIsAudio &&
880                      (type & ATSParser::DISCONTINUITY_AUDIO_FORMAT))
881                     || (!mIsAudio &&
882                             (type & ATSParser::DISCONTINUITY_VIDEO_FORMAT));
883 
884                 bool timeChange = (type & ATSParser::DISCONTINUITY_TIME) != 0;
885 
886                 ALOGI("%s discontinuity (format=%d, time=%d)",
887                         mIsAudio ? "audio" : "video", formatChange, timeChange);
888 
889                 bool seamlessFormatChange = false;
890                 sp<AMessage> newFormat = mSource->getFormat(mIsAudio);
891                 if (formatChange) {
892                     seamlessFormatChange =
893                         supportsSeamlessFormatChange(newFormat);
894                     // treat seamless format change separately
895                     formatChange = !seamlessFormatChange;
896                 }
897 
898                 // For format or time change, return EOS to queue EOS input,
899                 // then wait for EOS on output.
900                 if (formatChange /* not seamless */) {
901                     mFormatChangePending = true;
902                     err = ERROR_END_OF_STREAM;
903                 } else if (timeChange) {
904                     rememberCodecSpecificData(newFormat);
905                     mTimeChangePending = true;
906                     err = ERROR_END_OF_STREAM;
907                 } else if (seamlessFormatChange) {
908                     // reuse existing decoder and don't flush
909                     rememberCodecSpecificData(newFormat);
910                     continue;
911                 } else {
912                     // This stream is unaffected by the discontinuity
913                     return -EWOULDBLOCK;
914                 }
915             }
916 
917             // reply should only be returned without a buffer set
918             // when there is an error (including EOS)
919             CHECK(err != OK);
920 
921             reply->setInt32("err", err);
922             return ERROR_END_OF_STREAM;
923         }
924 
925         dropAccessUnit = false;
926         if (!mIsAudio && !mIsEncrypted) {
927             // Extra safeguard if higher-level behavior changes. Otherwise, not required now.
928             // Preventing the buffer from being processed (and sent to codec) if this is a later
929             // round of playback but this time without prepareDrm. Or if there is a race between
930             // stop (which is not blocking) and releaseDrm allowing buffers being processed after
931             // Crypto has been released (GenericSource currently prevents this race though).
932             // Particularly doing this check before IsAVCReferenceFrame call to prevent parsing
933             // of encrypted data.
934             if (mIsEncryptedObservedEarlier) {
935                 ALOGE("fetchInputData: mismatched mIsEncrypted/mIsEncryptedObservedEarlier (0/1)");
936 
937                 return INVALID_OPERATION;
938             }
939 
940             int32_t layerId = 0;
941             bool haveLayerId = accessUnit->meta()->findInt32("temporal-layer-id", &layerId);
942             if (mRenderer->getVideoLateByUs() > 100000LL
943                     && mIsVideoAVC
944                     && !IsAVCReferenceFrame(accessUnit)) {
945                 dropAccessUnit = true;
946             } else if (haveLayerId && mNumVideoTemporalLayerTotal > 1) {
947                 // Add only one layer each time.
948                 if (layerId > mCurrentMaxVideoTemporalLayerId + 1
949                         || layerId >= mNumVideoTemporalLayerAllowed) {
950                     dropAccessUnit = true;
951                     ALOGV("dropping layer(%d), speed=%g, allowed layer count=%d, max layerId=%d",
952                             layerId, mPlaybackSpeed, mNumVideoTemporalLayerAllowed,
953                             mCurrentMaxVideoTemporalLayerId);
954                 } else if (layerId > mCurrentMaxVideoTemporalLayerId) {
955                     mCurrentMaxVideoTemporalLayerId = layerId;
956                 } else if (layerId == 0 && mNumVideoTemporalLayerTotal > 1
957                         && IsIDR(accessUnit->data(), accessUnit->size())) {
958                     mCurrentMaxVideoTemporalLayerId = mNumVideoTemporalLayerTotal - 1;
959                 }
960             }
961             if (dropAccessUnit) {
962                 if (layerId <= mCurrentMaxVideoTemporalLayerId && layerId > 0) {
963                     mCurrentMaxVideoTemporalLayerId = layerId - 1;
964                 }
965                 ++mNumInputFramesDropped;
966             }
967         }
968     } while (dropAccessUnit);
969 
970     // ALOGV("returned a valid buffer of %s data", mIsAudio ? "mIsAudio" : "video");
971 #if 0
972     int64_t mediaTimeUs;
973     CHECK(accessUnit->meta()->findInt64("timeUs", &mediaTimeUs));
974     ALOGV("[%s] feeding input buffer at media time %.3f",
975          mIsAudio ? "audio" : "video",
976          mediaTimeUs / 1E6);
977 #endif
978 
979     if (mCCDecoder != NULL) {
980         mCCDecoder->decode(accessUnit);
981     }
982 
983     reply->setBuffer("buffer", accessUnit);
984 
985     return OK;
986 }
987 
onInputBufferFetched(const sp<AMessage> & msg)988 bool NuPlayer::Decoder::onInputBufferFetched(const sp<AMessage> &msg) {
989     if (mCodec == NULL) {
990         ALOGE("[%s] onInputBufferFetched without a valid codec", mComponentName.c_str());
991         handleError(NO_INIT);
992         return false;
993     }
994 
995     size_t bufferIx;
996     CHECK(msg->findSize("buffer-ix", &bufferIx));
997     CHECK_LT(bufferIx, mInputBuffers.size());
998     sp<MediaCodecBuffer> codecBuffer = mInputBuffers[bufferIx];
999 
1000     sp<ABuffer> buffer;
1001     bool hasBuffer = msg->findBuffer("buffer", &buffer);
1002     bool needsCopy = true;
1003 
1004     if (buffer == NULL /* includes !hasBuffer */) {
1005         int32_t streamErr = ERROR_END_OF_STREAM;
1006         CHECK(msg->findInt32("err", &streamErr) || !hasBuffer);
1007 
1008         CHECK(streamErr != OK);
1009 
1010         // attempt to queue EOS
1011         status_t err = mCodec->queueInputBuffer(
1012                 bufferIx,
1013                 0,
1014                 0,
1015                 0,
1016                 MediaCodec::BUFFER_FLAG_EOS);
1017         if (err == OK) {
1018             mInputBufferIsDequeued.editItemAt(bufferIx) = false;
1019         } else if (streamErr == ERROR_END_OF_STREAM) {
1020             streamErr = err;
1021             // err will not be ERROR_END_OF_STREAM
1022         }
1023 
1024         if (streamErr != ERROR_END_OF_STREAM) {
1025             ALOGE("Stream error for [%s] (err=%d), EOS %s queued",
1026                     mComponentName.c_str(),
1027                     streamErr,
1028                     err == OK ? "successfully" : "unsuccessfully");
1029             handleError(streamErr);
1030         }
1031     } else {
1032         sp<AMessage> extra;
1033         if (buffer->meta()->findMessage("extra", &extra) && extra != NULL) {
1034             int64_t resumeAtMediaTimeUs;
1035             if (extra->findInt64(
1036                         "resume-at-mediaTimeUs", &resumeAtMediaTimeUs)) {
1037                 ALOGV("[%s] suppressing rendering until %lld us",
1038                         mComponentName.c_str(), (long long)resumeAtMediaTimeUs);
1039                 mSkipRenderingUntilMediaTimeUs = resumeAtMediaTimeUs;
1040             }
1041         }
1042 
1043         int64_t timeUs = 0;
1044         uint32_t flags = 0;
1045         CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
1046 
1047         int32_t eos, csd;
1048         // we do not expect SYNCFRAME for decoder
1049         if (buffer->meta()->findInt32("eos", &eos) && eos) {
1050             flags |= MediaCodec::BUFFER_FLAG_EOS;
1051         } else if (buffer->meta()->findInt32("csd", &csd) && csd) {
1052             flags |= MediaCodec::BUFFER_FLAG_CODECCONFIG;
1053         }
1054 
1055         // Modular DRM
1056         MediaBufferBase *mediaBuf = NULL;
1057         NuPlayerDrm::CryptoInfo *cryptInfo = NULL;
1058 
1059         // copy into codec buffer
1060         if (needsCopy) {
1061             if (buffer->size() > codecBuffer->capacity()) {
1062                 handleError(ERROR_BUFFER_TOO_SMALL);
1063                 mDequeuedInputBuffers.push_back(bufferIx);
1064                 return false;
1065             }
1066 
1067             if (buffer->data() != NULL) {
1068                 codecBuffer->setRange(0, buffer->size());
1069                 memcpy(codecBuffer->data(), buffer->data(), buffer->size());
1070             } else { // No buffer->data()
1071                 //Modular DRM
1072                 sp<RefBase> holder;
1073                 if (buffer->meta()->findObject("mediaBufferHolder", &holder)) {
1074                     mediaBuf = (holder != nullptr) ?
1075                         static_cast<MediaBufferHolder*>(holder.get())->mediaBuffer() : nullptr;
1076                 }
1077                 if (mediaBuf != NULL) {
1078                     if (mediaBuf->size() > codecBuffer->capacity()) {
1079                         handleError(ERROR_BUFFER_TOO_SMALL);
1080                         mDequeuedInputBuffers.push_back(bufferIx);
1081                         return false;
1082                     }
1083 
1084                     codecBuffer->setRange(0, mediaBuf->size());
1085                     memcpy(codecBuffer->data(), mediaBuf->data(), mediaBuf->size());
1086 
1087                     MetaDataBase &meta_data = mediaBuf->meta_data();
1088                     cryptInfo = NuPlayerDrm::getSampleCryptoInfo(meta_data);
1089                 } else { // No mediaBuf
1090                     ALOGE("onInputBufferFetched: buffer->data()/mediaBuf are NULL for %p",
1091                             buffer.get());
1092                     handleError(UNKNOWN_ERROR);
1093                     return false;
1094                 }
1095             } // buffer->data()
1096         } // needsCopy
1097 
1098         status_t err;
1099         AString errorDetailMsg;
1100         if (cryptInfo != NULL) {
1101             err = mCodec->queueSecureInputBuffer(
1102                     bufferIx,
1103                     codecBuffer->offset(),
1104                     cryptInfo->subSamples,
1105                     cryptInfo->numSubSamples,
1106                     cryptInfo->key,
1107                     cryptInfo->iv,
1108                     cryptInfo->mode,
1109                     cryptInfo->pattern,
1110                     timeUs,
1111                     flags,
1112                     &errorDetailMsg);
1113             // synchronous call so done with cryptInfo here
1114             free(cryptInfo);
1115         } else {
1116             err = mCodec->queueInputBuffer(
1117                     bufferIx,
1118                     codecBuffer->offset(),
1119                     codecBuffer->size(),
1120                     timeUs,
1121                     flags,
1122                     &errorDetailMsg);
1123         } // no cryptInfo
1124 
1125         if (err != OK) {
1126             ALOGE("onInputBufferFetched: queue%sInputBuffer failed for [%s] (err=%d, %s)",
1127                     (cryptInfo != NULL ? "Secure" : ""),
1128                     mComponentName.c_str(), err, errorDetailMsg.c_str());
1129             handleError(err);
1130         } else {
1131             mInputBufferIsDequeued.editItemAt(bufferIx) = false;
1132         }
1133 
1134     }   // buffer != NULL
1135     return true;
1136 }
1137 
onRenderBuffer(const sp<AMessage> & msg)1138 void NuPlayer::Decoder::onRenderBuffer(const sp<AMessage> &msg) {
1139     status_t err;
1140     int32_t render;
1141     size_t bufferIx;
1142     int32_t eos;
1143     size_t size;
1144     CHECK(msg->findSize("buffer-ix", &bufferIx));
1145 
1146     if (!mIsAudio) {
1147         int64_t timeUs;
1148         sp<MediaCodecBuffer> buffer = mOutputBuffers[bufferIx];
1149         buffer->meta()->findInt64("timeUs", &timeUs);
1150 
1151         if (mCCDecoder != NULL && mCCDecoder->isSelected()) {
1152             mCCDecoder->display(timeUs);
1153         }
1154     }
1155 
1156     if (mCodec == NULL) {
1157         err = NO_INIT;
1158     } else if (msg->findInt32("render", &render) && render) {
1159         int64_t timestampNs;
1160         CHECK(msg->findInt64("timestampNs", &timestampNs));
1161         err = mCodec->renderOutputBufferAndRelease(bufferIx, timestampNs);
1162     } else {
1163         if (!msg->findInt32("eos", &eos) || !eos ||
1164                 !msg->findSize("size", &size) || size) {
1165             mNumOutputFramesDropped += !mIsAudio;
1166         }
1167         err = mCodec->releaseOutputBuffer(bufferIx);
1168     }
1169     if (err != OK) {
1170         ALOGE("failed to release output buffer for [%s] (err=%d)",
1171                 mComponentName.c_str(), err);
1172         handleError(err);
1173     }
1174     if (msg->findInt32("eos", &eos) && eos
1175             && isDiscontinuityPending()) {
1176         finishHandleDiscontinuity(true /* flushOnTimeChange */);
1177     }
1178 }
1179 
isDiscontinuityPending() const1180 bool NuPlayer::Decoder::isDiscontinuityPending() const {
1181     return mFormatChangePending || mTimeChangePending;
1182 }
1183 
finishHandleDiscontinuity(bool flushOnTimeChange)1184 void NuPlayer::Decoder::finishHandleDiscontinuity(bool flushOnTimeChange) {
1185     ALOGV("finishHandleDiscontinuity: format %d, time %d, flush %d",
1186             mFormatChangePending, mTimeChangePending, flushOnTimeChange);
1187 
1188     // If we have format change, pause and wait to be killed;
1189     // If we have time change only, flush and restart fetching.
1190 
1191     if (mFormatChangePending) {
1192         mPaused = true;
1193     } else if (mTimeChangePending) {
1194         if (flushOnTimeChange) {
1195             doFlush(false /* notifyComplete */);
1196             signalResume(false /* notifyComplete */);
1197         }
1198     }
1199 
1200     // Notify NuPlayer to either shutdown decoder, or rescan sources
1201     sp<AMessage> msg = mNotify->dup();
1202     msg->setInt32("what", kWhatInputDiscontinuity);
1203     msg->setInt32("formatChange", mFormatChangePending);
1204     msg->post();
1205 
1206     mFormatChangePending = false;
1207     mTimeChangePending = false;
1208 }
1209 
supportsSeamlessAudioFormatChange(const sp<AMessage> & targetFormat) const1210 bool NuPlayer::Decoder::supportsSeamlessAudioFormatChange(
1211         const sp<AMessage> &targetFormat) const {
1212     if (targetFormat == NULL) {
1213         return true;
1214     }
1215 
1216     AString mime;
1217     if (!targetFormat->findString("mime", &mime)) {
1218         return false;
1219     }
1220 
1221     if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_AAC)) {
1222         // field-by-field comparison
1223         const char * keys[] = { "channel-count", "sample-rate", "is-adts" };
1224         for (unsigned int i = 0; i < sizeof(keys) / sizeof(keys[0]); i++) {
1225             int32_t oldVal, newVal;
1226             if (!mInputFormat->findInt32(keys[i], &oldVal) ||
1227                     !targetFormat->findInt32(keys[i], &newVal) ||
1228                     oldVal != newVal) {
1229                 return false;
1230             }
1231         }
1232 
1233         sp<ABuffer> oldBuf, newBuf;
1234         if (mInputFormat->findBuffer("csd-0", &oldBuf) &&
1235                 targetFormat->findBuffer("csd-0", &newBuf)) {
1236             if (oldBuf->size() != newBuf->size()) {
1237                 return false;
1238             }
1239             return !memcmp(oldBuf->data(), newBuf->data(), oldBuf->size());
1240         }
1241     }
1242     return false;
1243 }
1244 
supportsSeamlessFormatChange(const sp<AMessage> & targetFormat) const1245 bool NuPlayer::Decoder::supportsSeamlessFormatChange(const sp<AMessage> &targetFormat) const {
1246     if (mInputFormat == NULL) {
1247         return false;
1248     }
1249 
1250     if (targetFormat == NULL) {
1251         return true;
1252     }
1253 
1254     AString oldMime, newMime;
1255     if (!mInputFormat->findString("mime", &oldMime)
1256             || !targetFormat->findString("mime", &newMime)
1257             || !(oldMime == newMime)) {
1258         return false;
1259     }
1260 
1261     bool audio = !strncasecmp(oldMime.c_str(), "audio/", strlen("audio/"));
1262     bool seamless;
1263     if (audio) {
1264         seamless = supportsSeamlessAudioFormatChange(targetFormat);
1265     } else {
1266         int32_t isAdaptive;
1267         seamless = (mCodec != NULL &&
1268                 mInputFormat->findInt32("adaptive-playback", &isAdaptive) &&
1269                 isAdaptive);
1270     }
1271 
1272     ALOGV("%s seamless support for %s", seamless ? "yes" : "no", oldMime.c_str());
1273     return seamless;
1274 }
1275 
rememberCodecSpecificData(const sp<AMessage> & format)1276 void NuPlayer::Decoder::rememberCodecSpecificData(const sp<AMessage> &format) {
1277     if (format == NULL) {
1278         return;
1279     }
1280     mCSDsForCurrentFormat.clear();
1281     for (int32_t i = 0; ; ++i) {
1282         AString tag = "csd-";
1283         tag.append(i);
1284         sp<ABuffer> buffer;
1285         if (!format->findBuffer(tag.c_str(), &buffer)) {
1286             break;
1287         }
1288         mCSDsForCurrentFormat.push(buffer);
1289     }
1290 }
1291 
notifyResumeCompleteIfNecessary()1292 void NuPlayer::Decoder::notifyResumeCompleteIfNecessary() {
1293     if (mResumePending) {
1294         mResumePending = false;
1295 
1296         sp<AMessage> notify = mNotify->dup();
1297         notify->setInt32("what", kWhatResumeCompleted);
1298         notify->post();
1299     }
1300 }
1301 
1302 }  // namespace android
1303 
1304