The Tor Browser: content/media/omx/OMXCodecProxy.cpp@44a2da4a2ab2 (annotated)

content/media/omx/OMXCodecProxy.cpp@44a2da4a2ab2 (annotated)

content/media/omx/OMXCodecProxy.cpp

Fri, 16 Jan 2015 04:50:19 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 04:50:19 +0100
branch: TOR_BUG_9701
changeset 13: 44a2da4a2ab2
permissions: -rw-r--r--

Replace accessor implementation with direct member state manipulation, by
request https://trac.torproject.org/projects/tor/ticket/9701#comment:32

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 //#define LOG_NDEBUG 0
 #define LOG_TAG "OMXCodecProxy"
 #include <binder/IPCThreadState.h>
 #include <cutils/properties.h>
 #include <stagefright/foundation/ADebug.h>
 #include <stagefright/MetaData.h>
 #include <stagefright/OMXCodec.h>
 #include <utils/Log.h>
 #include "nsDebug.h"
 #include "IMediaResourceManagerService.h"
 #include "OMXCodecProxy.h"
 namespace android {
 // static
 sp<OMXCodecProxy> OMXCodecProxy::Create(
         const sp<IOMX> &omx,
         const sp<MetaData> &meta, bool createEncoder,
         const sp<MediaSource> &source,
         const char *matchComponentName,
         uint32_t flags,
         const sp<ANativeWindow> &nativeWindow)
 {
   sp<OMXCodecProxy> proxy;
   const char *mime;
   if (!meta->findCString(kKeyMIMEType, &mime)) {
     return nullptr;
   }
   if (!strncasecmp(mime, "video/", 6)) {
     proxy = new OMXCodecProxy(omx, meta, createEncoder, source, matchComponentName, flags, nativeWindow);
   }
   return proxy;
 }
 OMXCodecProxy::OMXCodecProxy(
         const sp<IOMX> &omx,
         const sp<MetaData> &meta,
         bool createEncoder,
         const sp<MediaSource> &source,
         const char *matchComponentName,
         uint32_t flags,
         const sp<ANativeWindow> &nativeWindow)
     : mOMX(omx),
       mSrcMeta(meta),
       mIsEncoder(createEncoder),
       mSource(source),
       mComponentName(nullptr),
       mFlags(flags),
       mNativeWindow(nativeWindow),
       mState(MediaResourceManagerClient::CLIENT_STATE_WAIT_FOR_RESOURCE)
 {
 }
 OMXCodecProxy::~OMXCodecProxy()
 {
   mState = MediaResourceManagerClient::CLIENT_STATE_SHUTDOWN;
   if (mOMXCodec.get()) {
     wp<MediaSource> tmp = mOMXCodec;
     mOMXCodec.clear();
     while (tmp.promote() != nullptr) {
         // this value come from stagefrigh's AwesomePlayer.
         usleep(1000);
     }
   }
   // Complete all pending Binder ipc transactions
   IPCThreadState::self()->flushCommands();
   if (mManagerService.get() && mClient.get()) {
     mManagerService->cancelClient(mClient);
   }
   mSource.clear();
   free(mComponentName);
   mComponentName = nullptr;
 }
 MediaResourceManagerClient::State OMXCodecProxy::getState()
 {
   Mutex::Autolock autoLock(mLock);
   return mState;
 }
 void OMXCodecProxy::setEventListener(const wp<OMXCodecProxy::EventListener>& listener)
 {
   Mutex::Autolock autoLock(mLock);
   mEventListener = listener;
 }
 void OMXCodecProxy::notifyStatusChangedLocked()
 {
   if (mEventListener != nullptr) {
     sp<EventListener> listener = mEventListener.promote();
     if (listener != nullptr) {
       listener->statusChanged();
     }
   }
 }
 void OMXCodecProxy::requestResource()
 {
   Mutex::Autolock autoLock(mLock);
   if (mClient.get()) {
     return;
   }
   sp<MediaResourceManagerClient::EventListener> listener = this;
   mClient = new MediaResourceManagerClient(listener);
   mManagerService = mClient->getMediaResourceManagerService();
   if (!mManagerService.get()) {
     mClient = nullptr;
     return;
   }
   mManagerService->requestMediaResource(mClient, MediaResourceManagerClient::HW_VIDEO_DECODER);
 }
 bool OMXCodecProxy::IsWaitingResources()
 {
   Mutex::Autolock autoLock(mLock);
   return mState == MediaResourceManagerClient::CLIENT_STATE_WAIT_FOR_RESOURCE;
 }
 // called on Binder ipc thread
 void OMXCodecProxy::statusChanged(int event)
 {
   Mutex::Autolock autoLock(mLock);
   if (mState != MediaResourceManagerClient::CLIENT_STATE_WAIT_FOR_RESOURCE) {
     return;
   }
   mState = (MediaResourceManagerClient::State) event;
   if (mState != MediaResourceManagerClient::CLIENT_STATE_RESOURCE_ASSIGNED) {
     return;
   }
   const char *mime;
   if (!mSrcMeta->findCString(kKeyMIMEType, &mime)) {
     mState = MediaResourceManagerClient::CLIENT_STATE_SHUTDOWN;
     notifyStatusChangedLocked();
     return;
   }
   if (!strncasecmp(mime, "video/", 6)) {
     sp<MediaSource> codec;
     mOMXCodec = OMXCodec::Create(mOMX, mSrcMeta, mIsEncoder, mSource, mComponentName, mFlags, mNativeWindow);
     if (mOMXCodec == nullptr) {
       mState = MediaResourceManagerClient::CLIENT_STATE_SHUTDOWN;
       notifyStatusChangedLocked();
       return;
     }
     // Check if this video is sized such that we're comfortable
     // possibly using an OMX decoder.
     int32_t maxWidth, maxHeight;
     char propValue[PROPERTY_VALUE_MAX];
     property_get("ro.moz.omx.hw.max_width", propValue, "-1");
     maxWidth = atoi(propValue);
     property_get("ro.moz.omx.hw.max_height", propValue, "-1");
     maxHeight = atoi(propValue);
     int32_t width = -1, height = -1;
     if (maxWidth > 0 && maxHeight > 0 &&
         !(mOMXCodec->getFormat()->findInt32(kKeyWidth, &width) &&
           mOMXCodec->getFormat()->findInt32(kKeyHeight, &height) &&
           width * height <= maxWidth * maxHeight)) {
       printf_stderr("Failed to get video size, or it was too large for HW decoder (<w=%d, h=%d> but <maxW=%d, maxH=%d>)",
                     width, height, maxWidth, maxHeight);
       mOMXCodec.clear();
       mState = MediaResourceManagerClient::CLIENT_STATE_SHUTDOWN;
       notifyStatusChangedLocked();
       return;
     }
     if (mOMXCodec->start() != OK) {
       NS_WARNING("Couldn't start OMX video source");
       mOMXCodec.clear();
       mState = MediaResourceManagerClient::CLIENT_STATE_SHUTDOWN;
       notifyStatusChangedLocked();
       return;
     }
   }
   notifyStatusChangedLocked();
 }
 status_t OMXCodecProxy::start(MetaData *params)
 {
   Mutex::Autolock autoLock(mLock);
   if (mState != MediaResourceManagerClient::CLIENT_STATE_RESOURCE_ASSIGNED) {
     return NO_INIT;
   }
   CHECK(mOMXCodec.get() != nullptr);
   return mOMXCodec->start();
 }
 status_t OMXCodecProxy::stop()
 {
   Mutex::Autolock autoLock(mLock);
   if (mState != MediaResourceManagerClient::CLIENT_STATE_RESOURCE_ASSIGNED) {
     return NO_INIT;
   }
   CHECK(mOMXCodec.get() != nullptr);
   return mOMXCodec->stop();
 }
 sp<MetaData> OMXCodecProxy::getFormat()
 {
   Mutex::Autolock autoLock(mLock);
   if (mState != MediaResourceManagerClient::CLIENT_STATE_RESOURCE_ASSIGNED) {
     sp<MetaData> meta = new MetaData;
     return meta;
   }
   CHECK(mOMXCodec.get() != nullptr);
   return mOMXCodec->getFormat();
 }
 status_t OMXCodecProxy::read(MediaBuffer **buffer, const ReadOptions *options)
 {
   Mutex::Autolock autoLock(mLock);
   if (mState != MediaResourceManagerClient::CLIENT_STATE_RESOURCE_ASSIGNED) {
     return NO_INIT;
   }
   CHECK(mOMXCodec.get() != nullptr);
   return mOMXCodec->read(buffer, options);
 }
 status_t OMXCodecProxy::pause()
 {
   Mutex::Autolock autoLock(mLock);
   if (mState != MediaResourceManagerClient::CLIENT_STATE_RESOURCE_ASSIGNED) {
     return NO_INIT;
   }
   CHECK(mOMXCodec.get() != nullptr);
   return mOMXCodec->pause();
 }
 }  // namespace android

The Tor Browser / annotate

content/media/omx/OMXCodecProxy.cpp@44a2da4a2ab2 (annotated)

content/media/omx/OMXCodecProxy.cpp