media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp - android_frameworks_av - Gitiles

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 //#define LOG_NDEBUG 0
 #define LOG_TAG "NuPlayerDecoder"
 #include <utils/Log.h>
 #include <inttypes.h>

 #include "NuPlayerDecoder.h"

 #include <media/ICrypto.h>
 #include <media/stagefright/foundation/ABuffer.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/foundation/AMessage.h>
 #include <media/stagefright/MediaCodec.h>
 #include <media/stagefright/MediaDefs.h>
 #include <media/stagefright/MediaErrors.h>

 namespace android {

 NuPlayer::Decoder::Decoder(
         const sp<AMessage> &notify,
         const sp<NativeWindowWrapper> &nativeWindow)
     : mNotify(notify),
       mNativeWindow(nativeWindow),
       mBufferGeneration(0),
       mPaused(true),
       mComponentName("decoder") {
     // Every decoder has its own looper because MediaCodec operations
     // are blocking, but NuPlayer needs asynchronous operations.
     mDecoderLooper = new ALooper;
     mDecoderLooper->setName("NuPlayerDecoder");
     mDecoderLooper->start(false, false, ANDROID_PRIORITY_AUDIO);

     mCodecLooper = new ALooper;
     mCodecLooper->setName("NuPlayerDecoder-MC");
     mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
 }

 NuPlayer::Decoder::~Decoder() {
 }

 void NuPlayer::Decoder::onConfigure(const sp<AMessage> &format) {
     CHECK(mCodec == NULL);

     ++mBufferGeneration;

     AString mime;
     CHECK(format->findString("mime", &mime));

     sp<Surface> surface = NULL;
     if (mNativeWindow != NULL) {
         surface = mNativeWindow->getSurfaceTextureClient();
     }

     mComponentName = mime;
     mComponentName.append(" decoder");
     ALOGV("[%s] onConfigure (surface=%p)", mComponentName.c_str(), surface.get());

     mCodec = MediaCodec::CreateByType(mCodecLooper, mime.c_str(), false /* encoder */);
     if (mCodec == NULL) {
         ALOGE("Failed to create %s decoder", mime.c_str());
         handleError(UNKNOWN_ERROR);
         return;
     }

     mCodec->getName(&mComponentName);

     if (mNativeWindow != NULL) {
         // disconnect from surface as MediaCodec will reconnect
         CHECK_EQ((int)NO_ERROR,
                 native_window_api_disconnect(
                         surface.get(),
                         NATIVE_WINDOW_API_MEDIA));
     }
     status_t err = mCodec->configure(
             format, surface, NULL /* crypto */, 0 /* flags */);
     if (err != OK) {
         ALOGE("Failed to configure %s decoder (err=%d)", mComponentName.c_str(), err);
         handleError(err);
         return;
     }
     // the following should work in configured state
     CHECK_EQ((status_t)OK, mCodec->getOutputFormat(&mOutputFormat));
     CHECK_EQ((status_t)OK, mCodec->getInputFormat(&mInputFormat));

     err = mCodec->start();
     if (err != OK) {
         ALOGE("Failed to start %s decoder (err=%d)", mComponentName.c_str(), err);
         handleError(err);
         return;
     }

     // the following should work after start
     CHECK_EQ((status_t)OK, mCodec->getInputBuffers(&mInputBuffers));
     CHECK_EQ((status_t)OK, mCodec->getOutputBuffers(&mOutputBuffers));
     ALOGV("[%s] got %zu input and %zu output buffers",
             mComponentName.c_str(),
             mInputBuffers.size(),
             mOutputBuffers.size());

     requestCodecNotification();
     mPaused = false;
 }

 void NuPlayer::Decoder::requestCodecNotification() {
     if (mCodec != NULL) {
         sp<AMessage> reply = new AMessage(kWhatCodecNotify, id());
         reply->setInt32("generation", mBufferGeneration);
         mCodec->requestActivityNotification(reply);
     }
 }

 bool NuPlayer::Decoder::isStaleReply(const sp<AMessage> &msg) {
     int32_t generation;
     CHECK(msg->findInt32("generation", &generation));
     return generation != mBufferGeneration;
 }

 void NuPlayer::Decoder::init() {
     mDecoderLooper->registerHandler(this);
 }

 void NuPlayer::Decoder::configure(const sp<AMessage> &format) {
     sp<AMessage> msg = new AMessage(kWhatConfigure, id());
     msg->setMessage("format", format);
     msg->post();
 }

 void NuPlayer::Decoder::handleError(int32_t err)
 {
     sp<AMessage> notify = mNotify->dup();
     notify->setInt32("what", kWhatError);
     notify->setInt32("err", err);
     notify->post();
 }

 bool NuPlayer::Decoder::handleAnInputBuffer() {
     size_t bufferIx = -1;
     status_t res = mCodec->dequeueInputBuffer(&bufferIx);
     ALOGV("[%s] dequeued input: %d",
             mComponentName.c_str(), res == OK ? (int)bufferIx : res);
     if (res != OK) {
         if (res != -EAGAIN) {
             handleError(res);
         }
         return false;
     }

     CHECK_LT(bufferIx, mInputBuffers.size());

     sp<AMessage> reply = new AMessage(kWhatInputBufferFilled, id());
     reply->setSize("buffer-ix", bufferIx);
     reply->setInt32("generation", mBufferGeneration);

     sp<AMessage> notify = mNotify->dup();
     notify->setInt32("what", kWhatFillThisBuffer);
     notify->setBuffer("buffer", mInputBuffers[bufferIx]);
     notify->setMessage("reply", reply);
     notify->post();
     return true;
 }

 void android::NuPlayer::Decoder::onInputBufferFilled(const sp<AMessage> &msg) {
     size_t bufferIx;
     CHECK(msg->findSize("buffer-ix", &bufferIx));
     CHECK_LT(bufferIx, mInputBuffers.size());
     sp<ABuffer> codecBuffer = mInputBuffers[bufferIx];

     sp<ABuffer> buffer;
     bool hasBuffer = msg->findBuffer("buffer", &buffer);
     if (buffer == NULL /* includes !hasBuffer */) {
         int32_t streamErr = ERROR_END_OF_STREAM;
         CHECK(msg->findInt32("err", &streamErr) || !hasBuffer);

         if (streamErr == OK) {
             /* buffers are returned to hold on to */
             return;
         }

         // attempt to queue EOS
         status_t err = mCodec->queueInputBuffer(
                 bufferIx,
                 0,
                 0,
                 0,
                 MediaCodec::BUFFER_FLAG_EOS);
         if (streamErr == ERROR_END_OF_STREAM && err != OK) {
             streamErr = err;
             // err will not be ERROR_END_OF_STREAM
         }

         if (streamErr != ERROR_END_OF_STREAM) {
             handleError(streamErr);
         }
     } else {
         int64_t timeUs = 0;
         uint32_t flags = 0;
         CHECK(buffer->meta()->findInt64("timeUs", &timeUs));

         int32_t eos;
         // we do not expect CODECCONFIG or SYNCFRAME for decoder
         if (buffer->meta()->findInt32("eos", &eos) && eos) {
             flags |= MediaCodec::BUFFER_FLAG_EOS;
         }

         // copy into codec buffer
         if (buffer != codecBuffer) {
             CHECK_LE(buffer->size(), codecBuffer->capacity());
             codecBuffer->setRange(0, buffer->size());
             memcpy(codecBuffer->data(), buffer->data(), buffer->size());
         }

         status_t err = mCodec->queueInputBuffer(
                         bufferIx,
                         codecBuffer->offset(),
                         codecBuffer->size(),
                         timeUs,
                         flags);
         if (err != OK) {
             ALOGE("Failed to queue input buffer for %s (err=%d)",
                     mComponentName.c_str(), err);
             handleError(err);
         }
     }
 }

 bool NuPlayer::Decoder::handleAnOutputBuffer() {
     size_t bufferIx = -1;
     size_t offset;
     size_t size;
     int64_t timeUs;
     uint32_t flags;
     status_t res = mCodec->dequeueOutputBuffer(
             &bufferIx, &offset, &size, &timeUs, &flags);

     if (res != OK) {
         ALOGV("[%s] dequeued output: %d", mComponentName.c_str(), res);
     } else {
         ALOGV("[%s] dequeued output: %d (time=%lld flags=%" PRIu32 ")",
                 mComponentName.c_str(), (int)bufferIx, timeUs, flags);
     }

     if (res == INFO_OUTPUT_BUFFERS_CHANGED) {
         res = mCodec->getOutputBuffers(&mOutputBuffers);
         if (res != OK) {
             ALOGE("Failed to get output buffers for %s after INFO event (err=%d)",
                     mComponentName.c_str(), res);
             handleError(res);
             return false;
         }
         // NuPlayer ignores this
         return true;
     } else if (res == INFO_FORMAT_CHANGED) {
         sp<AMessage> format = new AMessage();
         res = mCodec->getOutputFormat(&format);
         if (res != OK) {
             ALOGE("Failed to get output format for %s after INFO event (err=%d)",
                     mComponentName.c_str(), res);
             handleError(res);
             return false;
         }

         sp<AMessage> notify = mNotify->dup();
         notify->setInt32("what", kWhatOutputFormatChanged);
         notify->setMessage("format", format);
         notify->post();
         return true;
     } else if (res == INFO_DISCONTINUITY) {
         // nothing to do
         return true;
     } else if (res != OK) {
         if (res != -EAGAIN) {
             handleError(res);
         }
         return false;
     }

     CHECK_LT(bufferIx, mOutputBuffers.size());
     sp<ABuffer> buffer = mOutputBuffers[bufferIx];
     buffer->setRange(offset, size);
     buffer->meta()->clear();
     buffer->meta()->setInt64("timeUs", timeUs);
     if (flags & MediaCodec::BUFFER_FLAG_EOS) {
         buffer->meta()->setInt32("eos", true);
     }
     // we do not expect CODECCONFIG or SYNCFRAME for decoder

     sp<AMessage> reply = new AMessage(kWhatRenderBuffer, id());
     reply->setSize("buffer-ix", bufferIx);
     reply->setInt32("generation", mBufferGeneration);

     sp<AMessage> notify = mNotify->dup();
     notify->setInt32("what", kWhatDrainThisBuffer);
     notify->setBuffer("buffer", buffer);
     notify->setMessage("reply", reply);
     notify->post();

     // FIXME: This should be handled after rendering is complete,
     // but Renderer needs it now
     if (flags & MediaCodec::BUFFER_FLAG_EOS) {
         ALOGV("queueing eos [%s]", mComponentName.c_str());
         sp<AMessage> notify = mNotify->dup();
         notify->setInt32("what", kWhatEOS);
         notify->setInt32("err", ERROR_END_OF_STREAM);
         notify->post();
     }
     return true;
 }

 void NuPlayer::Decoder::onRenderBuffer(const sp<AMessage> &msg) {
     status_t err;
     int32_t render;
     size_t bufferIx;
     CHECK(msg->findSize("buffer-ix", &bufferIx));
     if (msg->findInt32("render", &render) && render) {
         err = mCodec->renderOutputBufferAndRelease(bufferIx);
     } else {
         err = mCodec->releaseOutputBuffer(bufferIx);
     }
     if (err != OK) {
         ALOGE("failed to release output buffer for %s (err=%d)",
                 mComponentName.c_str(), err);
         handleError(err);
     }
 }

 void NuPlayer::Decoder::onFlush() {
     status_t err = OK;
     if (mCodec != NULL) {
         err = mCodec->flush();
         ++mBufferGeneration;
     }

     if (err != OK) {
         ALOGE("failed to flush %s (err=%d)", mComponentName.c_str(), err);
         handleError(err);
         return;
     }

     sp<AMessage> notify = mNotify->dup();
     notify->setInt32("what", kWhatFlushCompleted);
     notify->post();
     mPaused = true;
 }

 void NuPlayer::Decoder::onResume() {
     mPaused = false;
 }

 void NuPlayer::Decoder::onShutdown() {
     status_t err = OK;
     if (mCodec != NULL) {
         err = mCodec->release();
         mCodec = NULL;
         ++mBufferGeneration;

         if (mNativeWindow != NULL) {
             // reconnect to surface as MediaCodec disconnected from it
             CHECK_EQ((int)NO_ERROR,
                     native_window_api_connect(
                             mNativeWindow->getNativeWindow().get(),
                             NATIVE_WINDOW_API_MEDIA));
         }
         mComponentName = "decoder";
     }

     if (err != OK) {
         ALOGE("failed to release %s (err=%d)", mComponentName.c_str(), err);
         handleError(err);
         return;
     }

     sp<AMessage> notify = mNotify->dup();
     notify->setInt32("what", kWhatShutdownCompleted);
     notify->post();
     mPaused = true;
 }

 void NuPlayer::Decoder::onMessageReceived(const sp<AMessage> &msg) {
     ALOGV("[%s] onMessage: %s", mComponentName.c_str(), msg->debugString().c_str());

     switch (msg->what()) {
         case kWhatConfigure:
         {
             sp<AMessage> format;
             CHECK(msg->findMessage("format", &format));
             onConfigure(format);
             break;
         }

         case kWhatCodecNotify:
         {
             if (!isStaleReply(msg)) {
                 if (!mPaused) {
                     while (handleAnInputBuffer()) {
                     }
                 }

                 while (handleAnOutputBuffer()) {
                 }
             }

             requestCodecNotification();
             break;
         }

         case kWhatInputBufferFilled:
         {
             if (!isStaleReply(msg)) {
                 onInputBufferFilled(msg);
             }
             break;
         }

         case kWhatRenderBuffer:
         {
             if (!isStaleReply(msg)) {
                 onRenderBuffer(msg);
             }
             break;
         }

         case kWhatFlush:
         {
             onFlush();
             break;
         }

         case kWhatResume:
         {
             onResume();
             break;
         }

         case kWhatShutdown:
         {
             onShutdown();
             break;
         }

         default:
             TRESPASS();
             break;
     }
 }

 void NuPlayer::Decoder::signalFlush() {
     (new AMessage(kWhatFlush, id()))->post();
 }

 void NuPlayer::Decoder::signalResume() {
     (new AMessage(kWhatResume, id()))->post();
 }

 void NuPlayer::Decoder::initiateShutdown() {
     (new AMessage(kWhatShutdown, id()))->post();
 }

 bool NuPlayer::Decoder::supportsSeamlessAudioFormatChange(const sp<AMessage> &targetFormat) const {
     if (targetFormat == NULL) {
         return true;
     }

     AString mime;
     if (!targetFormat->findString("mime", &mime)) {
         return false;
     }

     if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_AAC)) {
         // field-by-field comparison
         const char * keys[] = { "channel-count", "sample-rate", "is-adts" };
         for (unsigned int i = 0; i < sizeof(keys) / sizeof(keys[0]); i++) {
             int32_t oldVal, newVal;
             if (!mOutputFormat->findInt32(keys[i], &oldVal) ||
                     !targetFormat->findInt32(keys[i], &newVal) ||
                     oldVal != newVal) {
                 return false;
             }
         }

         sp<ABuffer> oldBuf, newBuf;
         if (mOutputFormat->findBuffer("csd-0", &oldBuf) &&
                 targetFormat->findBuffer("csd-0", &newBuf)) {
             if (oldBuf->size() != newBuf->size()) {
                 return false;
             }
             return !memcmp(oldBuf->data(), newBuf->data(), oldBuf->size());
         }
     }
     return false;
 }

 bool NuPlayer::Decoder::supportsSeamlessFormatChange(const sp<AMessage> &targetFormat) const {
     if (mOutputFormat == NULL) {
         return false;
     }

     if (targetFormat == NULL) {
         return true;
     }

     AString oldMime, newMime;
     if (!mOutputFormat->findString("mime", &oldMime)
             || !targetFormat->findString("mime", &newMime)
             || !(oldMime == newMime)) {
         return false;
     }

     bool audio = !strncasecmp(oldMime.c_str(), "audio/", strlen("audio/"));
     bool seamless;
     if (audio) {
         seamless = supportsSeamlessAudioFormatChange(targetFormat);
     } else {
         int32_t isAdaptive;
         seamless = (mCodec != NULL &&
                 mInputFormat->findInt32("adaptive-playback", &isAdaptive) &&
                 isAdaptive);
     }

     ALOGV("%s seamless support for %s", seamless ? "yes" : "no", oldMime.c_str());
     return seamless;
 }

 }  // namespace android
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	//#define LOG_NDEBUG 0
	#define LOG_TAG "NuPlayerDecoder"
	#include <utils/Log.h>
	#include <inttypes.h>

	#include "NuPlayerDecoder.h"

	#include <media/ICrypto.h>
	#include <media/stagefright/foundation/ABuffer.h>
	#include <media/stagefright/foundation/ADebug.h>
	#include <media/stagefright/foundation/AMessage.h>
	#include <media/stagefright/MediaCodec.h>
	#include <media/stagefright/MediaDefs.h>
	#include <media/stagefright/MediaErrors.h>

	namespace android {

	NuPlayer::Decoder::Decoder(
	const sp<AMessage> &notify,
	const sp<NativeWindowWrapper> &nativeWindow)
	: mNotify(notify),
	mNativeWindow(nativeWindow),
	mBufferGeneration(0),
	mPaused(true),
	mComponentName("decoder") {
	// Every decoder has its own looper because MediaCodec operations
	// are blocking, but NuPlayer needs asynchronous operations.
	mDecoderLooper = new ALooper;
	mDecoderLooper->setName("NuPlayerDecoder");
	mDecoderLooper->start(false, false, ANDROID_PRIORITY_AUDIO);

	mCodecLooper = new ALooper;
	mCodecLooper->setName("NuPlayerDecoder-MC");
	mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
	}

	NuPlayer::Decoder::~Decoder() {
	}

	void NuPlayer::Decoder::onConfigure(const sp<AMessage> &format) {
	CHECK(mCodec == NULL);

	++mBufferGeneration;

	AString mime;
	CHECK(format->findString("mime", &mime));

	sp<Surface> surface = NULL;
	if (mNativeWindow != NULL) {
	surface = mNativeWindow->getSurfaceTextureClient();
	}

	mComponentName = mime;
	mComponentName.append(" decoder");
	ALOGV("[%s] onConfigure (surface=%p)", mComponentName.c_str(), surface.get());

	mCodec = MediaCodec::CreateByType(mCodecLooper, mime.c_str(), false /* encoder */);
	if (mCodec == NULL) {
	ALOGE("Failed to create %s decoder", mime.c_str());
	handleError(UNKNOWN_ERROR);
	return;
	}

	mCodec->getName(&mComponentName);

	if (mNativeWindow != NULL) {
	// disconnect from surface as MediaCodec will reconnect
	CHECK_EQ((int)NO_ERROR,
	native_window_api_disconnect(
	surface.get(),
	NATIVE_WINDOW_API_MEDIA));
	}
	status_t err = mCodec->configure(
	format, surface, NULL /* crypto /, 0 / flags */);
	if (err != OK) {
	ALOGE("Failed to configure %s decoder (err=%d)", mComponentName.c_str(), err);
	handleError(err);
	return;
	}
	// the following should work in configured state
	CHECK_EQ((status_t)OK, mCodec->getOutputFormat(&mOutputFormat));
	CHECK_EQ((status_t)OK, mCodec->getInputFormat(&mInputFormat));

	err = mCodec->start();
	if (err != OK) {
	ALOGE("Failed to start %s decoder (err=%d)", mComponentName.c_str(), err);
	handleError(err);
	return;
	}

	// the following should work after start
	CHECK_EQ((status_t)OK, mCodec->getInputBuffers(&mInputBuffers));
	CHECK_EQ((status_t)OK, mCodec->getOutputBuffers(&mOutputBuffers));
	ALOGV("[%s] got %zu input and %zu output buffers",
	mComponentName.c_str(),
	mInputBuffers.size(),
	mOutputBuffers.size());

	requestCodecNotification();
	mPaused = false;
	}

	void NuPlayer::Decoder::requestCodecNotification() {
	if (mCodec != NULL) {
	sp<AMessage> reply = new AMessage(kWhatCodecNotify, id());
	reply->setInt32("generation", mBufferGeneration);
	mCodec->requestActivityNotification(reply);
	}
	}

	bool NuPlayer::Decoder::isStaleReply(const sp<AMessage> &msg) {
	int32_t generation;
	CHECK(msg->findInt32("generation", &generation));
	return generation != mBufferGeneration;
	}

	void NuPlayer::Decoder::init() {
	mDecoderLooper->registerHandler(this);
	}

	void NuPlayer::Decoder::configure(const sp<AMessage> &format) {
	sp<AMessage> msg = new AMessage(kWhatConfigure, id());
	msg->setMessage("format", format);
	msg->post();
	}

	void NuPlayer::Decoder::handleError(int32_t err)
	{
	sp<AMessage> notify = mNotify->dup();
	notify->setInt32("what", kWhatError);
	notify->setInt32("err", err);
	notify->post();
	}

	bool NuPlayer::Decoder::handleAnInputBuffer() {
	size_t bufferIx = -1;
	status_t res = mCodec->dequeueInputBuffer(&bufferIx);
	ALOGV("[%s] dequeued input: %d",
	mComponentName.c_str(), res == OK ? (int)bufferIx : res);
	if (res != OK) {
	if (res != -EAGAIN) {
	handleError(res);
	}
	return false;
	}

	CHECK_LT(bufferIx, mInputBuffers.size());

	sp<AMessage> reply = new AMessage(kWhatInputBufferFilled, id());
	reply->setSize("buffer-ix", bufferIx);
	reply->setInt32("generation", mBufferGeneration);

	sp<AMessage> notify = mNotify->dup();
	notify->setInt32("what", kWhatFillThisBuffer);
	notify->setBuffer("buffer", mInputBuffers[bufferIx]);
	notify->setMessage("reply", reply);
	notify->post();
	return true;
	}

	void android::NuPlayer::Decoder::onInputBufferFilled(const sp<AMessage> &msg) {
	size_t bufferIx;
	CHECK(msg->findSize("buffer-ix", &bufferIx));
	CHECK_LT(bufferIx, mInputBuffers.size());
	sp<ABuffer> codecBuffer = mInputBuffers[bufferIx];

	sp<ABuffer> buffer;
	bool hasBuffer = msg->findBuffer("buffer", &buffer);
	if (buffer == NULL /* includes !hasBuffer */) {
	int32_t streamErr = ERROR_END_OF_STREAM;
	CHECK(msg->findInt32("err", &streamErr) \|\| !hasBuffer);

	if (streamErr == OK) {
	/* buffers are returned to hold on to */
	return;
	}

	// attempt to queue EOS
	status_t err = mCodec->queueInputBuffer(
	bufferIx,
	0,
	0,
	0,
	MediaCodec::BUFFER_FLAG_EOS);
	if (streamErr == ERROR_END_OF_STREAM && err != OK) {
	streamErr = err;
	// err will not be ERROR_END_OF_STREAM
	}

	if (streamErr != ERROR_END_OF_STREAM) {
	handleError(streamErr);
	}
	} else {
	int64_t timeUs = 0;
	uint32_t flags = 0;
	CHECK(buffer->meta()->findInt64("timeUs", &timeUs));

	int32_t eos;
	// we do not expect CODECCONFIG or SYNCFRAME for decoder
	if (buffer->meta()->findInt32("eos", &eos) && eos) {
	flags \|= MediaCodec::BUFFER_FLAG_EOS;
	}

	// copy into codec buffer
	if (buffer != codecBuffer) {
	CHECK_LE(buffer->size(), codecBuffer->capacity());
	codecBuffer->setRange(0, buffer->size());
	memcpy(codecBuffer->data(), buffer->data(), buffer->size());
	}

	status_t err = mCodec->queueInputBuffer(
	bufferIx,
	codecBuffer->offset(),
	codecBuffer->size(),
	timeUs,
	flags);
	if (err != OK) {
	ALOGE("Failed to queue input buffer for %s (err=%d)",
	mComponentName.c_str(), err);
	handleError(err);
	}
	}
	}

	bool NuPlayer::Decoder::handleAnOutputBuffer() {
	size_t bufferIx = -1;
	size_t offset;
	size_t size;
	int64_t timeUs;
	uint32_t flags;
	status_t res = mCodec->dequeueOutputBuffer(
	&bufferIx, &offset, &size, &timeUs, &flags);

	if (res != OK) {
	ALOGV("[%s] dequeued output: %d", mComponentName.c_str(), res);
	} else {
	ALOGV("[%s] dequeued output: %d (time=%lld flags=%" PRIu32 ")",
	mComponentName.c_str(), (int)bufferIx, timeUs, flags);
	}

	if (res == INFO_OUTPUT_BUFFERS_CHANGED) {
	res = mCodec->getOutputBuffers(&mOutputBuffers);
	if (res != OK) {
	ALOGE("Failed to get output buffers for %s after INFO event (err=%d)",
	mComponentName.c_str(), res);
	handleError(res);
	return false;
	}
	// NuPlayer ignores this
	return true;
	} else if (res == INFO_FORMAT_CHANGED) {
	sp<AMessage> format = new AMessage();
	res = mCodec->getOutputFormat(&format);
	if (res != OK) {
	ALOGE("Failed to get output format for %s after INFO event (err=%d)",
	mComponentName.c_str(), res);
	handleError(res);
	return false;
	}

	sp<AMessage> notify = mNotify->dup();
	notify->setInt32("what", kWhatOutputFormatChanged);
	notify->setMessage("format", format);
	notify->post();
	return true;
	} else if (res == INFO_DISCONTINUITY) {
	// nothing to do
	return true;
	} else if (res != OK) {
	if (res != -EAGAIN) {
	handleError(res);
	}
	return false;
	}

	CHECK_LT(bufferIx, mOutputBuffers.size());
	sp<ABuffer> buffer = mOutputBuffers[bufferIx];
	buffer->setRange(offset, size);
	buffer->meta()->clear();
	buffer->meta()->setInt64("timeUs", timeUs);
	if (flags & MediaCodec::BUFFER_FLAG_EOS) {
	buffer->meta()->setInt32("eos", true);
	}
	// we do not expect CODECCONFIG or SYNCFRAME for decoder

	sp<AMessage> reply = new AMessage(kWhatRenderBuffer, id());
	reply->setSize("buffer-ix", bufferIx);
	reply->setInt32("generation", mBufferGeneration);

	sp<AMessage> notify = mNotify->dup();
	notify->setInt32("what", kWhatDrainThisBuffer);
	notify->setBuffer("buffer", buffer);
	notify->setMessage("reply", reply);
	notify->post();

	// FIXME: This should be handled after rendering is complete,
	// but Renderer needs it now
	if (flags & MediaCodec::BUFFER_FLAG_EOS) {
	ALOGV("queueing eos [%s]", mComponentName.c_str());
	sp<AMessage> notify = mNotify->dup();
	notify->setInt32("what", kWhatEOS);
	notify->setInt32("err", ERROR_END_OF_STREAM);
	notify->post();
	}
	return true;
	}

	void NuPlayer::Decoder::onRenderBuffer(const sp<AMessage> &msg) {
	status_t err;
	int32_t render;
	size_t bufferIx;
	CHECK(msg->findSize("buffer-ix", &bufferIx));
	if (msg->findInt32("render", &render) && render) {
	err = mCodec->renderOutputBufferAndRelease(bufferIx);
	} else {
	err = mCodec->releaseOutputBuffer(bufferIx);
	}
	if (err != OK) {
	ALOGE("failed to release output buffer for %s (err=%d)",
	mComponentName.c_str(), err);
	handleError(err);
	}
	}

	void NuPlayer::Decoder::onFlush() {
	status_t err = OK;
	if (mCodec != NULL) {
	err = mCodec->flush();
	++mBufferGeneration;
	}

	if (err != OK) {
	ALOGE("failed to flush %s (err=%d)", mComponentName.c_str(), err);
	handleError(err);
	return;
	}

	sp<AMessage> notify = mNotify->dup();
	notify->setInt32("what", kWhatFlushCompleted);
	notify->post();
	mPaused = true;
	}

	void NuPlayer::Decoder::onResume() {
	mPaused = false;
	}

	void NuPlayer::Decoder::onShutdown() {
	status_t err = OK;
	if (mCodec != NULL) {
	err = mCodec->release();
	mCodec = NULL;
	++mBufferGeneration;

	if (mNativeWindow != NULL) {
	// reconnect to surface as MediaCodec disconnected from it
	CHECK_EQ((int)NO_ERROR,
	native_window_api_connect(
	mNativeWindow->getNativeWindow().get(),
	NATIVE_WINDOW_API_MEDIA));
	}
	mComponentName = "decoder";
	}

	if (err != OK) {
	ALOGE("failed to release %s (err=%d)", mComponentName.c_str(), err);
	handleError(err);
	return;
	}

	sp<AMessage> notify = mNotify->dup();
	notify->setInt32("what", kWhatShutdownCompleted);
	notify->post();
	mPaused = true;
	}

	void NuPlayer::Decoder::onMessageReceived(const sp<AMessage> &msg) {
	ALOGV("[%s] onMessage: %s", mComponentName.c_str(), msg->debugString().c_str());

	switch (msg->what()) {
	case kWhatConfigure:
	{
	sp<AMessage> format;
	CHECK(msg->findMessage("format", &format));
	onConfigure(format);
	break;
	}

	case kWhatCodecNotify:
	{
	if (!isStaleReply(msg)) {
	if (!mPaused) {
	while (handleAnInputBuffer()) {
	}
	}

	while (handleAnOutputBuffer()) {
	}
	}

	requestCodecNotification();
	break;
	}

	case kWhatInputBufferFilled:
	{
	if (!isStaleReply(msg)) {
	onInputBufferFilled(msg);
	}
	break;
	}

	case kWhatRenderBuffer:
	{
	if (!isStaleReply(msg)) {
	onRenderBuffer(msg);
	}
	break;
	}

	case kWhatFlush:
	{
	onFlush();
	break;
	}

	case kWhatResume:
	{
	onResume();
	break;
	}

	case kWhatShutdown:
	{
	onShutdown();
	break;
	}

	default:
	TRESPASS();
	break;
	}
	}

	void NuPlayer::Decoder::signalFlush() {
	(new AMessage(kWhatFlush, id()))->post();
	}

	void NuPlayer::Decoder::signalResume() {
	(new AMessage(kWhatResume, id()))->post();
	}

	void NuPlayer::Decoder::initiateShutdown() {
	(new AMessage(kWhatShutdown, id()))->post();
	}

	bool NuPlayer::Decoder::supportsSeamlessAudioFormatChange(const sp<AMessage> &targetFormat) const {
	if (targetFormat == NULL) {
	return true;
	}

	AString mime;
	if (!targetFormat->findString("mime", &mime)) {
	return false;
	}

	if (!strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_AAC)) {
	// field-by-field comparison
	const char * keys[] = { "channel-count", "sample-rate", "is-adts" };
	for (unsigned int i = 0; i < sizeof(keys) / sizeof(keys[0]); i++) {
	int32_t oldVal, newVal;
	if (!mOutputFormat->findInt32(keys[i], &oldVal) \|\|
	!targetFormat->findInt32(keys[i], &newVal) \|\|
	oldVal != newVal) {
	return false;
	}
	}

	sp<ABuffer> oldBuf, newBuf;
	if (mOutputFormat->findBuffer("csd-0", &oldBuf) &&
	targetFormat->findBuffer("csd-0", &newBuf)) {
	if (oldBuf->size() != newBuf->size()) {
	return false;
	}
	return !memcmp(oldBuf->data(), newBuf->data(), oldBuf->size());
	}
	}
	return false;
	}

	bool NuPlayer::Decoder::supportsSeamlessFormatChange(const sp<AMessage> &targetFormat) const {
	if (mOutputFormat == NULL) {
	return false;
	}

	if (targetFormat == NULL) {
	return true;
	}

	AString oldMime, newMime;
	if (!mOutputFormat->findString("mime", &oldMime)
	\|\| !targetFormat->findString("mime", &newMime)
	\|\| !(oldMime == newMime)) {
	return false;
	}

	bool audio = !strncasecmp(oldMime.c_str(), "audio/", strlen("audio/"));
	bool seamless;
	if (audio) {
	seamless = supportsSeamlessAudioFormatChange(targetFormat);
	} else {
	int32_t isAdaptive;
	seamless = (mCodec != NULL &&
	mInputFormat->findInt32("adaptive-playback", &isAdaptive) &&
	isAdaptive);
	}

	ALOGV("%s seamless support for %s", seamless ? "yes" : "no", oldMime.c_str());
	return seamless;
	}

	} // namespace android