| /* |
| * 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/ABitReader.h> |
| #include <media/stagefright/foundation/ABuffer.h> |
| #include <media/stagefright/foundation/ADebug.h> |
| #include <media/stagefright/foundation/AMessage.h> |
| #include <media/stagefright/MediaBuffer.h> |
| #include <media/stagefright/MediaCodec.h> |
| #include <media/stagefright/MediaDefs.h> |
| #include <media/stagefright/MediaErrors.h> |
| |
| namespace android { |
| |
| NuPlayer::Decoder::Decoder( |
| const sp<AMessage> ¬ify, |
| 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("NPDecoder"); |
| mDecoderLooper->start(false, false, ANDROID_PRIORITY_AUDIO); |
| |
| mCodecLooper = new ALooper; |
| mCodecLooper->setName("NPDecoder-CL"); |
| mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO); |
| } |
| |
| NuPlayer::Decoder::~Decoder() { |
| mDecoderLooper->unregisterHandler(id()); |
| mDecoderLooper->stop(); |
| |
| releaseAndResetMediaBuffers(); |
| } |
| |
| static |
| status_t PostAndAwaitResponse( |
| const sp<AMessage> &msg, sp<AMessage> *response) { |
| status_t err = msg->postAndAwaitResponse(response); |
| |
| if (err != OK) { |
| return err; |
| } |
| |
| if (!(*response)->findInt32("err", &err)) { |
| err = OK; |
| } |
| |
| return err; |
| } |
| |
| void NuPlayer::Decoder::rememberCodecSpecificData(const sp<AMessage> &format) { |
| mCSDsForCurrentFormat.clear(); |
| for (int32_t i = 0; ; ++i) { |
| AString tag = "csd-"; |
| tag.append(i); |
| sp<ABuffer> buffer; |
| if (!format->findBuffer(tag.c_str(), &buffer)) { |
| break; |
| } |
| mCSDsForCurrentFormat.push(buffer); |
| } |
| } |
| |
| 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 */); |
| int32_t secure = 0; |
| if (format->findInt32("secure", &secure) && secure != 0) { |
| if (mCodec != NULL) { |
| mCodec->getName(&mComponentName); |
| mComponentName.append(".secure"); |
| mCodec->release(); |
| ALOGI("[%s] creating", mComponentName.c_str()); |
| mCodec = MediaCodec::CreateByComponentName( |
| mCodecLooper, mComponentName.c_str()); |
| } |
| } |
| if (mCodec == NULL) { |
| ALOGE("Failed to create %s%s decoder", |
| (secure ? "secure " : ""), mime.c_str()); |
| handleError(UNKNOWN_ERROR); |
| return; |
| } |
| |
| mCodec->getName(&mComponentName); |
| |
| status_t err; |
| if (mNativeWindow != NULL) { |
| // disconnect from surface as MediaCodec will reconnect |
| err = native_window_api_disconnect( |
| surface.get(), NATIVE_WINDOW_API_MEDIA); |
| // We treat this as a warning, as this is a preparatory step. |
| // Codec will try to connect to the surface, which is where |
| // any error signaling will occur. |
| ALOGW_IF(err != OK, "failed to disconnect from surface: %d", err); |
| } |
| err = mCodec->configure( |
| format, surface, NULL /* crypto */, 0 /* flags */); |
| if (err != OK) { |
| ALOGE("Failed to configure %s decoder (err=%d)", mComponentName.c_str(), err); |
| mCodec->release(); |
| mCodec.clear(); |
| handleError(err); |
| return; |
| } |
| rememberCodecSpecificData(format); |
| |
| // 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); |
| mCodec->release(); |
| mCodec.clear(); |
| handleError(err); |
| return; |
| } |
| |
| // the following should work after start |
| CHECK_EQ((status_t)OK, mCodec->getInputBuffers(&mInputBuffers)); |
| releaseAndResetMediaBuffers(); |
| 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::releaseAndResetMediaBuffers() { |
| for (size_t i = 0; i < mMediaBuffers.size(); i++) { |
| if (mMediaBuffers[i] != NULL) { |
| mMediaBuffers[i]->release(); |
| mMediaBuffers.editItemAt(i) = NULL; |
| } |
| } |
| mMediaBuffers.resize(mInputBuffers.size()); |
| for (size_t i = 0; i < mMediaBuffers.size(); i++) { |
| mMediaBuffers.editItemAt(i) = NULL; |
| } |
| mInputBufferIsDequeued.clear(); |
| mInputBufferIsDequeued.resize(mInputBuffers.size()); |
| for (size_t i = 0; i < mInputBufferIsDequeued.size(); i++) { |
| mInputBufferIsDequeued.editItemAt(i) = false; |
| } |
| |
| mPendingInputMessages.clear(); |
| } |
| |
| 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::signalUpdateFormat(const sp<AMessage> &format) { |
| sp<AMessage> msg = new AMessage(kWhatUpdateFormat, id()); |
| msg->setMessage("format", format); |
| msg->post(); |
| } |
| |
| status_t NuPlayer::Decoder::getInputBuffers(Vector<sp<ABuffer> > *buffers) const { |
| sp<AMessage> msg = new AMessage(kWhatGetInputBuffers, id()); |
| msg->setPointer("buffers", buffers); |
| |
| sp<AMessage> response; |
| return PostAndAwaitResponse(msg, &response); |
| } |
| |
| void NuPlayer::Decoder::handleError(int32_t err) |
| { |
| // We cannot immediately release the codec due to buffers still outstanding |
| // in the renderer. We signal to the player the error so it can shutdown/release the |
| // decoder after flushing and increment the generation to discard unnecessary messages. |
| |
| ++mBufferGeneration; |
| |
| 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) { |
| ALOGE("Failed to dequeue input buffer for %s (err=%d)", |
| mComponentName.c_str(), res); |
| handleError(res); |
| } |
| return false; |
| } |
| |
| CHECK_LT(bufferIx, mInputBuffers.size()); |
| |
| if (mMediaBuffers[bufferIx] != NULL) { |
| mMediaBuffers[bufferIx]->release(); |
| mMediaBuffers.editItemAt(bufferIx) = NULL; |
| } |
| mInputBufferIsDequeued.editItemAt(bufferIx) = true; |
| |
| sp<AMessage> reply = new AMessage(kWhatInputBufferFilled, id()); |
| reply->setSize("buffer-ix", bufferIx); |
| reply->setInt32("generation", mBufferGeneration); |
| |
| if (!mCSDsToSubmit.isEmpty()) { |
| sp<ABuffer> buffer = mCSDsToSubmit.itemAt(0); |
| ALOGI("[%s] resubmitting CSD", mComponentName.c_str()); |
| reply->setBuffer("buffer", buffer); |
| mCSDsToSubmit.removeAt(0); |
| CHECK(onInputBufferFilled(reply)); |
| return true; |
| } |
| |
| while (!mPendingInputMessages.empty()) { |
| sp<AMessage> msg = *mPendingInputMessages.begin(); |
| if (!onInputBufferFilled(msg)) { |
| break; |
| } |
| mPendingInputMessages.erase(mPendingInputMessages.begin()); |
| } |
| |
| if (!mInputBufferIsDequeued.editItemAt(bufferIx)) { |
| return true; |
| } |
| |
| sp<AMessage> notify = mNotify->dup(); |
| notify->setInt32("what", kWhatFillThisBuffer); |
| notify->setBuffer("buffer", mInputBuffers[bufferIx]); |
| notify->setMessage("reply", reply); |
| notify->post(); |
| return true; |
| } |
| |
| bool 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); |
| |
| // handle widevine classic source - that fills an arbitrary input buffer |
| MediaBuffer *mediaBuffer = NULL; |
| if (hasBuffer) { |
| mediaBuffer = (MediaBuffer *)(buffer->getMediaBufferBase()); |
| if (mediaBuffer != NULL) { |
| // likely filled another buffer than we requested: adjust buffer index |
| size_t ix; |
| for (ix = 0; ix < mInputBuffers.size(); ix++) { |
| const sp<ABuffer> &buf = mInputBuffers[ix]; |
| if (buf->data() == mediaBuffer->data()) { |
| // all input buffers are dequeued on start, hence the check |
| if (!mInputBufferIsDequeued[ix]) { |
| ALOGV("[%s] received MediaBuffer for #%zu instead of #%zu", |
| mComponentName.c_str(), ix, bufferIx); |
| mediaBuffer->release(); |
| return false; |
| } |
| |
| // TRICKY: need buffer for the metadata, so instead, set |
| // codecBuffer to the same (though incorrect) buffer to |
| // avoid a memcpy into the codecBuffer |
| codecBuffer = buffer; |
| codecBuffer->setRange( |
| mediaBuffer->range_offset(), |
| mediaBuffer->range_length()); |
| bufferIx = ix; |
| break; |
| } |
| } |
| CHECK(ix < mInputBuffers.size()); |
| } |
| } |
| |
| |
| |
| 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 true; |
| } |
| |
| // attempt to queue EOS |
| status_t err = mCodec->queueInputBuffer( |
| bufferIx, |
| 0, |
| 0, |
| 0, |
| MediaCodec::BUFFER_FLAG_EOS); |
| if (err == OK) { |
| mInputBufferIsDequeued.editItemAt(bufferIx) = false; |
| } else if (streamErr == ERROR_END_OF_STREAM) { |
| streamErr = err; |
| // err will not be ERROR_END_OF_STREAM |
| } |
| |
| if (streamErr != ERROR_END_OF_STREAM) { |
| ALOGE("Stream error for %s (err=%d), EOS %s queued", |
| mComponentName.c_str(), |
| streamErr, |
| err == OK ? "successfully" : "unsuccessfully"); |
| handleError(streamErr); |
| } |
| } else { |
| int64_t timeUs = 0; |
| uint32_t flags = 0; |
| CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); |
| |
| int32_t eos, csd; |
| // we do not expect SYNCFRAME for decoder |
| if (buffer->meta()->findInt32("eos", &eos) && eos) { |
| flags |= MediaCodec::BUFFER_FLAG_EOS; |
| } else if (buffer->meta()->findInt32("csd", &csd) && csd) { |
| flags |= MediaCodec::BUFFER_FLAG_CODECCONFIG; |
| } |
| |
| // 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) { |
| if (mediaBuffer != NULL) { |
| mediaBuffer->release(); |
| } |
| ALOGE("Failed to queue input buffer for %s (err=%d)", |
| mComponentName.c_str(), err); |
| handleError(err); |
| } else { |
| mInputBufferIsDequeued.editItemAt(bufferIx) = false; |
| if (mediaBuffer != NULL) { |
| CHECK(mMediaBuffers[bufferIx] == NULL); |
| mMediaBuffers.editItemAt(bufferIx) = mediaBuffer; |
| } |
| } |
| } |
| return true; |
| } |
| |
| 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) { |
| ALOGE("Failed to dequeue output buffer for %s (err=%d)", |
| mComponentName.c_str(), res); |
| 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) { |
| int64_t timestampNs; |
| CHECK(msg->findInt64("timestampNs", ×tampNs)); |
| err = mCodec->renderOutputBufferAndRelease(bufferIx, timestampNs); |
| } 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(); |
| mCSDsToSubmit = mCSDsForCurrentFormat; // copy operator |
| ++mBufferGeneration; |
| } |
| |
| if (err != OK) { |
| ALOGE("failed to flush %s (err=%d)", mComponentName.c_str(), err); |
| handleError(err); |
| // finish with posting kWhatFlushCompleted. |
| // we attempt to release the buffers even if flush fails. |
| } |
| releaseAndResetMediaBuffers(); |
| |
| 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 |
| status_t error = |
| native_window_api_connect( |
| mNativeWindow->getNativeWindow().get(), |
| NATIVE_WINDOW_API_MEDIA); |
| ALOGW_IF(error != NO_ERROR, |
| "[%s] failed to connect to native window, error=%d", |
| mComponentName.c_str(), error); |
| } |
| mComponentName = "decoder"; |
| } |
| |
| releaseAndResetMediaBuffers(); |
| |
| if (err != OK) { |
| ALOGE("failed to release %s (err=%d)", mComponentName.c_str(), err); |
| handleError(err); |
| // finish with posting kWhatShutdownCompleted. |
| } |
| |
| 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 kWhatUpdateFormat: |
| { |
| sp<AMessage> format; |
| CHECK(msg->findMessage("format", &format)); |
| rememberCodecSpecificData(format); |
| break; |
| } |
| |
| case kWhatGetInputBuffers: |
| { |
| uint32_t replyID; |
| CHECK(msg->senderAwaitsResponse(&replyID)); |
| |
| Vector<sp<ABuffer> > *dstBuffers; |
| CHECK(msg->findPointer("buffers", (void **)&dstBuffers)); |
| |
| dstBuffers->clear(); |
| for (size_t i = 0; i < mInputBuffers.size(); i++) { |
| dstBuffers->push(mInputBuffers[i]); |
| } |
| |
| (new AMessage)->postReply(replyID); |
| break; |
| } |
| |
| case kWhatCodecNotify: |
| { |
| if (!isStaleReply(msg)) { |
| int32_t numInput, numOutput; |
| |
| if (!msg->findInt32("input-buffers", &numInput)) { |
| numInput = INT32_MAX; |
| } |
| |
| if (!msg->findInt32("output-buffers", &numOutput)) { |
| numOutput = INT32_MAX; |
| } |
| |
| if (!mPaused) { |
| while (numInput-- > 0 && handleAnInputBuffer()) {} |
| } |
| |
| while (numOutput-- > 0 && handleAnOutputBuffer()) {} |
| } |
| |
| requestCodecNotification(); |
| break; |
| } |
| |
| case kWhatInputBufferFilled: |
| { |
| if (!isStaleReply(msg)) { |
| if (!mPendingInputMessages.empty() |
| || !onInputBufferFilled(msg)) { |
| mPendingInputMessages.push_back(msg); |
| } |
| } |
| |
| break; |
| } |
| |
| case kWhatRenderBuffer: |
| { |
| if (!isStaleReply(msg)) { |
| onRenderBuffer(msg); |
| } |
| break; |
| } |
| |
| case kWhatFlush: |
| { |
| sp<AMessage> format; |
| if (msg->findMessage("new-format", &format)) { |
| rememberCodecSpecificData(format); |
| } |
| onFlush(); |
| break; |
| } |
| |
| case kWhatResume: |
| { |
| onResume(); |
| break; |
| } |
| |
| case kWhatShutdown: |
| { |
| onShutdown(); |
| break; |
| } |
| |
| default: |
| TRESPASS(); |
| break; |
| } |
| } |
| |
| void NuPlayer::Decoder::signalFlush(const sp<AMessage> &format) { |
| sp<AMessage> msg = new AMessage(kWhatFlush, id()); |
| if (format != NULL) { |
| msg->setMessage("new-format", format); |
| } |
| msg->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; |
| } |
| |
| struct CCData { |
| CCData(uint8_t type, uint8_t data1, uint8_t data2) |
| : mType(type), mData1(data1), mData2(data2) { |
| } |
| bool getChannel(size_t *channel) const { |
| if (mData1 >= 0x10 && mData1 <= 0x1f) { |
| *channel = (mData1 >= 0x18 ? 1 : 0) + (mType ? 2 : 0); |
| return true; |
| } |
| return false; |
| } |
| |
| uint8_t mType; |
| uint8_t mData1; |
| uint8_t mData2; |
| }; |
| |
| static bool isNullPad(CCData *cc) { |
| return cc->mData1 < 0x10 && cc->mData2 < 0x10; |
| } |
| |
| static void dumpBytePair(const sp<ABuffer> &ccBuf) { |
| size_t offset = 0; |
| AString out; |
| |
| while (offset < ccBuf->size()) { |
| char tmp[128]; |
| |
| CCData *cc = (CCData *) (ccBuf->data() + offset); |
| |
| if (isNullPad(cc)) { |
| // 1 null pad or XDS metadata, ignore |
| offset += sizeof(CCData); |
| continue; |
| } |
| |
| if (cc->mData1 >= 0x20 && cc->mData1 <= 0x7f) { |
| // 2 basic chars |
| sprintf(tmp, "[%d]Basic: %c %c", cc->mType, cc->mData1, cc->mData2); |
| } else if ((cc->mData1 == 0x11 || cc->mData1 == 0x19) |
| && cc->mData2 >= 0x30 && cc->mData2 <= 0x3f) { |
| // 1 special char |
| sprintf(tmp, "[%d]Special: %02x %02x", cc->mType, cc->mData1, cc->mData2); |
| } else if ((cc->mData1 == 0x12 || cc->mData1 == 0x1A) |
| && cc->mData2 >= 0x20 && cc->mData2 <= 0x3f){ |
| // 1 Spanish/French char |
| sprintf(tmp, "[%d]Spanish: %02x %02x", cc->mType, cc->mData1, cc->mData2); |
| } else if ((cc->mData1 == 0x13 || cc->mData1 == 0x1B) |
| && cc->mData2 >= 0x20 && cc->mData2 <= 0x3f){ |
| // 1 Portuguese/German/Danish char |
| sprintf(tmp, "[%d]German: %02x %02x", cc->mType, cc->mData1, cc->mData2); |
| } else if ((cc->mData1 == 0x11 || cc->mData1 == 0x19) |
| && cc->mData2 >= 0x20 && cc->mData2 <= 0x2f){ |
| // Mid-Row Codes (Table 69) |
| sprintf(tmp, "[%d]Mid-row: %02x %02x", cc->mType, cc->mData1, cc->mData2); |
| } else if (((cc->mData1 == 0x14 || cc->mData1 == 0x1c) |
| && cc->mData2 >= 0x20 && cc->mData2 <= 0x2f) |
| || |
| ((cc->mData1 == 0x17 || cc->mData1 == 0x1f) |
| && cc->mData2 >= 0x21 && cc->mData2 <= 0x23)){ |
| // Misc Control Codes (Table 70) |
| sprintf(tmp, "[%d]Ctrl: %02x %02x", cc->mType, cc->mData1, cc->mData2); |
| } else if ((cc->mData1 & 0x70) == 0x10 |
| && (cc->mData2 & 0x40) == 0x40 |
| && ((cc->mData1 & 0x07) || !(cc->mData2 & 0x20)) ) { |
| // Preamble Address Codes (Table 71) |
| sprintf(tmp, "[%d]PAC: %02x %02x", cc->mType, cc->mData1, cc->mData2); |
| } else { |
| sprintf(tmp, "[%d]Invalid: %02x %02x", cc->mType, cc->mData1, cc->mData2); |
| } |
| |
| if (out.size() > 0) { |
| out.append(", "); |
| } |
| |
| out.append(tmp); |
| |
| offset += sizeof(CCData); |
| } |
| |
| ALOGI("%s", out.c_str()); |
| } |
| |
| NuPlayer::CCDecoder::CCDecoder(const sp<AMessage> ¬ify) |
| : mNotify(notify), |
| mCurrentChannel(0), |
| mSelectedTrack(-1) { |
| for (size_t i = 0; i < sizeof(mTrackIndices)/sizeof(mTrackIndices[0]); ++i) { |
| mTrackIndices[i] = -1; |
| } |
| } |
| |
| size_t NuPlayer::CCDecoder::getTrackCount() const { |
| return mFoundChannels.size(); |
| } |
| |
| sp<AMessage> NuPlayer::CCDecoder::getTrackInfo(size_t index) const { |
| if (!isTrackValid(index)) { |
| return NULL; |
| } |
| |
| sp<AMessage> format = new AMessage(); |
| |
| format->setInt32("type", MEDIA_TRACK_TYPE_SUBTITLE); |
| format->setString("language", "und"); |
| format->setString("mime", MEDIA_MIMETYPE_TEXT_CEA_608); |
| //CC1, field 0 channel 0 |
| bool isDefaultAuto = (mFoundChannels[index] == 0); |
| format->setInt32("auto", isDefaultAuto); |
| format->setInt32("default", isDefaultAuto); |
| format->setInt32("forced", 0); |
| |
| return format; |
| } |
| |
| status_t NuPlayer::CCDecoder::selectTrack(size_t index, bool select) { |
| if (!isTrackValid(index)) { |
| return BAD_VALUE; |
| } |
| |
| if (select) { |
| if (mSelectedTrack == (ssize_t)index) { |
| ALOGE("track %zu already selected", index); |
| return BAD_VALUE; |
| } |
| ALOGV("selected track %zu", index); |
| mSelectedTrack = index; |
| } else { |
| if (mSelectedTrack != (ssize_t)index) { |
| ALOGE("track %zu is not selected", index); |
| return BAD_VALUE; |
| } |
| ALOGV("unselected track %zu", index); |
| mSelectedTrack = -1; |
| } |
| |
| return OK; |
| } |
| |
| bool NuPlayer::CCDecoder::isSelected() const { |
| return mSelectedTrack >= 0 && mSelectedTrack < (int32_t) getTrackCount(); |
| } |
| |
| bool NuPlayer::CCDecoder::isTrackValid(size_t index) const { |
| return index < getTrackCount(); |
| } |
| |
| int32_t NuPlayer::CCDecoder::getTrackIndex(size_t channel) const { |
| if (channel < sizeof(mTrackIndices)/sizeof(mTrackIndices[0])) { |
| return mTrackIndices[channel]; |
| } |
| return -1; |
| } |
| |
| // returns true if a new CC track is found |
| bool NuPlayer::CCDecoder::extractFromSEI(const sp<ABuffer> &accessUnit) { |
| int64_t timeUs; |
| CHECK(accessUnit->meta()->findInt64("timeUs", &timeUs)); |
| |
| sp<ABuffer> sei; |
| if (!accessUnit->meta()->findBuffer("sei", &sei) || sei == NULL) { |
| return false; |
| } |
| |
| bool trackAdded = false; |
| |
| NALBitReader br(sei->data() + 1, sei->size() - 1); |
| // sei_message() |
| while (br.atLeastNumBitsLeft(16)) { // at least 16-bit for sei_message() |
| uint32_t payload_type = 0; |
| size_t payload_size = 0; |
| uint8_t last_byte; |
| |
| do { |
| last_byte = br.getBits(8); |
| payload_type += last_byte; |
| } while (last_byte == 0xFF); |
| |
| do { |
| last_byte = br.getBits(8); |
| payload_size += last_byte; |
| } while (last_byte == 0xFF); |
| |
| // sei_payload() |
| if (payload_type == 4) { |
| // user_data_registered_itu_t_t35() |
| |
| // ATSC A/72: 6.4.2 |
| uint8_t itu_t_t35_country_code = br.getBits(8); |
| uint16_t itu_t_t35_provider_code = br.getBits(16); |
| uint32_t user_identifier = br.getBits(32); |
| uint8_t user_data_type_code = br.getBits(8); |
| |
| payload_size -= 1 + 2 + 4 + 1; |
| |
| if (itu_t_t35_country_code == 0xB5 |
| && itu_t_t35_provider_code == 0x0031 |
| && user_identifier == 'GA94' |
| && user_data_type_code == 0x3) { |
| // MPEG_cc_data() |
| // ATSC A/53 Part 4: 6.2.3.1 |
| br.skipBits(1); //process_em_data_flag |
| bool process_cc_data_flag = br.getBits(1); |
| br.skipBits(1); //additional_data_flag |
| size_t cc_count = br.getBits(5); |
| br.skipBits(8); // em_data; |
| payload_size -= 2; |
| |
| if (process_cc_data_flag) { |
| AString out; |
| |
| sp<ABuffer> ccBuf = new ABuffer(cc_count * sizeof(CCData)); |
| ccBuf->setRange(0, 0); |
| |
| for (size_t i = 0; i < cc_count; i++) { |
| uint8_t marker = br.getBits(5); |
| CHECK_EQ(marker, 0x1f); |
| |
| bool cc_valid = br.getBits(1); |
| uint8_t cc_type = br.getBits(2); |
| // remove odd parity bit |
| uint8_t cc_data_1 = br.getBits(8) & 0x7f; |
| uint8_t cc_data_2 = br.getBits(8) & 0x7f; |
| |
| if (cc_valid |
| && (cc_type == 0 || cc_type == 1)) { |
| CCData cc(cc_type, cc_data_1, cc_data_2); |
| if (!isNullPad(&cc)) { |
| size_t channel; |
| if (cc.getChannel(&channel) && getTrackIndex(channel) < 0) { |
| mTrackIndices[channel] = mFoundChannels.size(); |
| mFoundChannels.push_back(channel); |
| trackAdded = true; |
| } |
| memcpy(ccBuf->data() + ccBuf->size(), |
| (void *)&cc, sizeof(cc)); |
| ccBuf->setRange(0, ccBuf->size() + sizeof(CCData)); |
| } |
| } |
| } |
| payload_size -= cc_count * 3; |
| |
| mCCMap.add(timeUs, ccBuf); |
| break; |
| } |
| } else { |
| ALOGV("Malformed SEI payload type 4"); |
| } |
| } else { |
| ALOGV("Unsupported SEI payload type %d", payload_type); |
| } |
| |
| // skipping remaining bits of this payload |
| br.skipBits(payload_size * 8); |
| } |
| |
| return trackAdded; |
| } |
| |
| sp<ABuffer> NuPlayer::CCDecoder::filterCCBuf( |
| const sp<ABuffer> &ccBuf, size_t index) { |
| sp<ABuffer> filteredCCBuf = new ABuffer(ccBuf->size()); |
| filteredCCBuf->setRange(0, 0); |
| |
| size_t cc_count = ccBuf->size() / sizeof(CCData); |
| const CCData* cc_data = (const CCData*)ccBuf->data(); |
| for (size_t i = 0; i < cc_count; ++i) { |
| size_t channel; |
| if (cc_data[i].getChannel(&channel)) { |
| mCurrentChannel = channel; |
| } |
| if (mCurrentChannel == mFoundChannels[index]) { |
| memcpy(filteredCCBuf->data() + filteredCCBuf->size(), |
| (void *)&cc_data[i], sizeof(CCData)); |
| filteredCCBuf->setRange(0, filteredCCBuf->size() + sizeof(CCData)); |
| } |
| } |
| |
| return filteredCCBuf; |
| } |
| |
| void NuPlayer::CCDecoder::decode(const sp<ABuffer> &accessUnit) { |
| if (extractFromSEI(accessUnit)) { |
| ALOGI("Found CEA-608 track"); |
| sp<AMessage> msg = mNotify->dup(); |
| msg->setInt32("what", kWhatTrackAdded); |
| msg->post(); |
| } |
| // TODO: extract CC from other sources |
| } |
| |
| void NuPlayer::CCDecoder::display(int64_t timeUs) { |
| if (!isTrackValid(mSelectedTrack)) { |
| ALOGE("Could not find current track(index=%d)", mSelectedTrack); |
| return; |
| } |
| |
| ssize_t index = mCCMap.indexOfKey(timeUs); |
| if (index < 0) { |
| ALOGV("cc for timestamp %" PRId64 " not found", timeUs); |
| return; |
| } |
| |
| sp<ABuffer> ccBuf = filterCCBuf(mCCMap.valueAt(index), mSelectedTrack); |
| |
| if (ccBuf->size() > 0) { |
| #if 0 |
| dumpBytePair(ccBuf); |
| #endif |
| |
| ccBuf->meta()->setInt32("trackIndex", mSelectedTrack); |
| ccBuf->meta()->setInt64("timeUs", timeUs); |
| ccBuf->meta()->setInt64("durationUs", 0ll); |
| |
| sp<AMessage> msg = mNotify->dup(); |
| msg->setInt32("what", kWhatClosedCaptionData); |
| msg->setBuffer("buffer", ccBuf); |
| msg->post(); |
| } |
| |
| // remove all entries before timeUs |
| mCCMap.removeItemsAt(0, index + 1); |
| } |
| |
| void NuPlayer::CCDecoder::flush() { |
| mCCMap.clear(); |
| } |
| |
| } // namespace android |
| |
