Bug 1036849 - Create SharedDecoderManager and SharedDecoderProxy; r=blakewu

dom/media/MediaDecoderReader.h

@@ -20,6 +20,7 @@ class TimeRanges;
 
 class RequestSampleCallback;
 class MediaDecoderReader;
+class SharedDecoderManager;
 
 // Encapsulates the decoding and reading of media data. Reading can either
 // synchronous and done on the calling "decode" thread, or asynchronous and
@@ -47,6 +48,7 @@ public:
   // Release media resources they should be released in dormant state
   // The reader can be made usable again by calling ReadMetadata().
   virtual void ReleaseMediaResources() {};
+  virtual void SetSharedDecoderManager(SharedDecoderManager* aManager) {}
   // Breaks reference-counted cycles. Called during shutdown.
   // WARNING: If you override this, you must call the base implementation
   // in your override.

dom/media/fmp4/MP4Reader.cpp

@@ -14,6 +14,7 @@
 #include "SharedThreadPool.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/TimeRanges.h"
+#include "SharedDecoderManager.h"
 
 #ifdef MOZ_EME
 #include "mozilla/CDMProxy.h"
@@ -415,11 +416,20 @@ MP4Reader::ReadMetadata(MediaInfo* aInfo,
     mInfo.mVideo.mDisplay =
       nsIntSize(video.display_width, video.display_height);
     mVideo.mCallback = new DecoderCallback(this, kVideo);
+    if (mSharedDecoderManager) {
+      mVideo.mDecoder =
+        mSharedDecoderManager->CreateH264Decoder(video,
+                                                 mLayersBackendType,
+                                                 mDecoder->GetImageContainer(),
+                                                 mVideo.mTaskQueue,
+                                                 mVideo.mCallback);
+    } else {
       mVideo.mDecoder = mPlatform->CreateH264Decoder(video,
                                                      mLayersBackendType,
                                                      mDecoder->GetImageContainer(),
                                                      mVideo.mTaskQueue,
                                                      mVideo.mCallback);
+    }
     NS_ENSURE_TRUE(mVideo.mDecoder != nullptr, NS_ERROR_FAILURE);
     nsresult rv = mVideo.mDecoder->Init();
     NS_ENSURE_SUCCESS(rv, rv);
@@ -473,12 +483,6 @@ MP4Reader::GetDecoderData(TrackType aTrack)
   return (aTrack == kAudio) ? mAudio : mVideo;
 }
 
-MediaDataDecoder*
-MP4Reader::Decoder(TrackType aTrack)
-{
-  return GetDecoderData(aTrack).mDecoder;
-}
-
 MP4Sample*
 MP4Reader::PopSample(TrackType aTrack)
 {
@@ -884,4 +888,21 @@ void MP4Reader::NotifyResourcesStatusChanged()
 #endif
 }
 
+void
+MP4Reader::SetIdle()
+{
+  if (mSharedDecoderManager && mVideo.mDecoder) {
+    mSharedDecoderManager->SetIdle(mVideo.mDecoder);
+    NotifyResourcesStatusChanged();
+  }
+}
+
+void
+MP4Reader::SetSharedDecoderManager(SharedDecoderManager* aManager)
+{
+#ifdef MOZ_GONK_MEDIACODEC
+  mSharedDecoderManager = aManager;
+#endif
+}
+
 } // namespace mozilla

dom/media/fmp4/MP4Reader.h

@@ -62,9 +62,12 @@ public:
   virtual nsresult GetBuffered(dom::TimeRanges* aBuffered) MOZ_OVERRIDE;
 
   // For Media Resource Management
+  virtual void SetIdle() MOZ_OVERRIDE;
   virtual bool IsWaitingMediaResources() MOZ_OVERRIDE;
   virtual bool IsDormantNeeded() MOZ_OVERRIDE;
   virtual void ReleaseMediaResources() MOZ_OVERRIDE;
+  virtual void SetSharedDecoderManager(SharedDecoderManager* aManager)
+    MOZ_OVERRIDE;
 
   virtual nsresult ResetDecode() MOZ_OVERRIDE;
 
@@ -179,7 +182,6 @@ private:
   uint64_t mLastReportedNumDecodedFrames;
 
   DecoderData& GetDecoderData(mp4_demuxer::TrackType aTrack);
-  MediaDataDecoder* Decoder(mp4_demuxer::TrackType aTrack);
 
   layers::LayersBackend mLayersBackendType;
 
@@ -193,6 +195,7 @@ private:
 
   bool mIndexReady;
   Monitor mIndexMonitor;
+  nsRefPtr<SharedDecoderManager> mSharedDecoderManager;
 };
 
 } // namespace mozilla

dom/media/fmp4/PlatformDecoderModule.h

@@ -230,8 +230,8 @@ public:
   virtual bool IsDormantNeeded() {
     return false;
   };
-  virtual void ReleaseMediaResources() {};
+  virtual void ReleaseMediaResources() {}
-  virtual void ReleaseDecoder() {};
+  virtual void ReleaseDecoder() {}
 };
 
 } // namespace mozilla

dom/media/fmp4/SharedDecoderManager.cpp

@@ -0,0 +1,207 @@
+/* -*- 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/. */
+
+#include "SharedDecoderManager.h"
+#include "mp4_demuxer/DecoderData.h"
+
+namespace mozilla {
+
+class SharedDecoderCallback : public MediaDataDecoderCallback
+{
+public:
+  SharedDecoderCallback(SharedDecoderManager* aManager) : mManager(aManager) {}
+
+  virtual void Output(MediaData* aData) MOZ_OVERRIDE
+  {
+    if (mManager->mActiveCallback) {
+      mManager->mActiveCallback->Output(aData);
+    }
+  }
+  virtual void Error() MOZ_OVERRIDE
+  {
+    if (mManager->mActiveCallback) {
+      mManager->mActiveCallback->Error();
+    }
+  }
+  virtual void InputExhausted() MOZ_OVERRIDE
+  {
+    if (mManager->mActiveCallback) {
+      mManager->mActiveCallback->InputExhausted();
+    }
+  }
+  virtual void DrainComplete() MOZ_OVERRIDE
+  {
+    if (mManager->mActiveCallback) {
+      mManager->DrainComplete();
+    }
+  }
+  virtual void NotifyResourcesStatusChanged() MOZ_OVERRIDE
+  {
+    if (mManager->mActiveCallback) {
+      mManager->mActiveCallback->NotifyResourcesStatusChanged();
+    }
+  }
+  virtual void ReleaseMediaResources() MOZ_OVERRIDE
+  {
+    if (mManager->mActiveCallback) {
+      mManager->mActiveCallback->ReleaseMediaResources();
+    }
+  }
+
+  SharedDecoderManager* mManager;
+};
+
+SharedDecoderManager::SharedDecoderManager()
+  : mActiveProxy(nullptr)
+  , mActiveCallback(nullptr)
+  , mWaitForInternalDrain(false)
+  , mMonitor("SharedDecoderProxy")
+{
+  mCallback = new SharedDecoderCallback(this);
+}
+
+SharedDecoderManager::~SharedDecoderManager() {}
+
+already_AddRefed<MediaDataDecoder>
+SharedDecoderManager::CreateH264Decoder(
+  const mp4_demuxer::VideoDecoderConfig& aConfig,
+  layers::LayersBackend aLayersBackend, layers::ImageContainer* aImageContainer,
+  MediaTaskQueue* aVideoTaskQueue, MediaDataDecoderCallback* aCallback)
+{
+  if (!mDecoder) {
+    nsAutoPtr<PlatformDecoderModule> platform(PlatformDecoderModule::Create());
+    mDecoder = platform->CreateH264Decoder(
+      aConfig, aLayersBackend, aImageContainer, aVideoTaskQueue, mCallback);
+    if (!mDecoder) {
+      return nullptr;
+    }
+    nsresult rv = mDecoder->Init();
+    NS_ENSURE_SUCCESS(rv, nullptr);
+  }
+
+  nsRefPtr<SharedDecoderProxy> proxy(new SharedDecoderProxy(this, aCallback));
+  return proxy.forget();
+}
+
+void
+SharedDecoderManager::Select(SharedDecoderProxy* aProxy)
+{
+  if (mActiveProxy == aProxy) {
+    return;
+  }
+  SetIdle(mActiveProxy);
+
+  mActiveProxy = aProxy;
+  mActiveCallback = aProxy->mCallback;
+}
+
+void
+SharedDecoderManager::SetIdle(MediaDataDecoder* aProxy)
+{
+  if (aProxy && mActiveProxy == aProxy) {
+    mWaitForInternalDrain = true;
+    mActiveProxy->Drain();
+    MonitorAutoLock mon(mMonitor);
+    while (mWaitForInternalDrain) {
+      mon.Wait();
+    }
+    mActiveProxy->Flush();
+    mActiveProxy = nullptr;
+  }
+}
+
+void
+SharedDecoderManager::DrainComplete()
+{
+  if (mWaitForInternalDrain) {
+    MonitorAutoLock mon(mMonitor);
+    mWaitForInternalDrain = false;
+    mon.NotifyAll();
+  } else {
+    mActiveCallback->DrainComplete();
+  }
+}
+
+SharedDecoderProxy::SharedDecoderProxy(
+  SharedDecoderManager* aManager, MediaDataDecoderCallback* aCallback)
+  : mManager(aManager), mCallback(aCallback)
+{
+}
+
+SharedDecoderProxy::~SharedDecoderProxy() { Shutdown(); }
+
+nsresult
+SharedDecoderProxy::Init()
+{
+  return NS_OK;
+}
+
+nsresult
+SharedDecoderProxy::Input(mp4_demuxer::MP4Sample* aSample)
+{
+  if (mManager->mActiveProxy != this) {
+    mManager->Select(this);
+  }
+  return mManager->mDecoder->Input(aSample);
+  return NS_OK;
+}
+
+nsresult
+SharedDecoderProxy::Flush()
+{
+  if (mManager->mActiveProxy == this) {
+    return mManager->mDecoder->Flush();
+  }
+  return NS_OK;
+}
+
+nsresult
+SharedDecoderProxy::Drain()
+{
+  if (mManager->mActiveProxy == this) {
+    return mManager->mDecoder->Drain();
+  }
+  return NS_OK;
+}
+
+nsresult
+SharedDecoderProxy::Shutdown()
+{
+  mManager->SetIdle(this);
+  return NS_OK;
+}
+
+bool
+SharedDecoderProxy::IsWaitingMediaResources()
+{
+  if (mManager->mActiveProxy == this) {
+    return mManager->mDecoder->IsWaitingMediaResources();
+  }
+  return mManager->mActiveProxy != nullptr;
+}
+
+bool
+SharedDecoderProxy::IsDormantNeeded()
+{
+  return mManager->mDecoder->IsDormantNeeded();
+}
+
+void
+SharedDecoderProxy::ReleaseMediaResources()
+{
+  if (mManager->mActiveProxy == this) {
+    mManager->mDecoder->ReleaseMediaResources();
+  }
+}
+
+void
+SharedDecoderProxy::ReleaseDecoder()
+{
+  if (mManager->mActiveProxy == this) {
+    mManager->mDecoder->ReleaseMediaResources();
+  }
+}
+}

dom/media/fmp4/SharedDecoderManager.h

@@ -0,0 +1,77 @@
+/* -*- 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/. */
+
+#ifndef SHARED_DECODER_MANAGER_H_
+#define SHARED_DECODER_MANAGER_H_
+
+#include "PlatformDecoderModule.h"
+#include "mozilla/Monitor.h"
+
+namespace mozilla
+{
+
+class MediaDataDecoder;
+class SharedDecoderProxy;
+class SharedDecoderCallback;
+
+class SharedDecoderManager
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedDecoderManager)
+
+  SharedDecoderManager();
+
+  already_AddRefed<MediaDataDecoder> CreateH264Decoder(
+    const mp4_demuxer::VideoDecoderConfig& aConfig,
+    layers::LayersBackend aLayersBackend,
+    layers::ImageContainer* aImageContainer, MediaTaskQueue* aVideoTaskQueue,
+    MediaDataDecoderCallback* aCallback);
+
+  void SetReader(MediaDecoderReader* aReader);
+  void Select(SharedDecoderProxy* aProxy);
+  void SetIdle(MediaDataDecoder* aProxy);
+
+  friend class SharedDecoderProxy;
+  friend class SharedDecoderCallback;
+
+private:
+  virtual ~SharedDecoderManager();
+  void DrainComplete();
+
+  nsRefPtr<MediaDataDecoder> mDecoder;
+  SharedDecoderProxy* mActiveProxy;
+  MediaDataDecoderCallback* mActiveCallback;
+  nsAutoPtr<MediaDataDecoderCallback> mCallback;
+  bool mWaitForInternalDrain;
+  Monitor mMonitor;
+};
+
+class SharedDecoderProxy : public MediaDataDecoder
+{
+public:
+  SharedDecoderProxy(SharedDecoderManager* aManager,
+                     MediaDataDecoderCallback* aCallback);
+  virtual ~SharedDecoderProxy();
+
+  virtual nsresult Init() MOZ_OVERRIDE;
+  virtual nsresult Input(mp4_demuxer::MP4Sample* aSample) MOZ_OVERRIDE;
+  virtual nsresult Flush() MOZ_OVERRIDE;
+  virtual nsresult Drain() MOZ_OVERRIDE;
+  virtual nsresult Shutdown() MOZ_OVERRIDE;
+  virtual bool IsWaitingMediaResources() MOZ_OVERRIDE;
+  virtual bool IsDormantNeeded() MOZ_OVERRIDE;
+  virtual void ReleaseMediaResources() MOZ_OVERRIDE;
+  virtual void ReleaseDecoder() MOZ_OVERRIDE;
+
+  friend class SharedDecoderManager;
+
+private:
+  nsRefPtr<SharedDecoderManager> mManager;
+  MediaDataDecoderCallback* mCallback;
+};
+}
+
+#endif

dom/media/fmp4/moz.build

@@ -8,12 +8,14 @@ EXPORTS += [
     'MP4Decoder.h',
     'MP4Reader.h',
     'PlatformDecoderModule.h',
+    'SharedDecoderManager.h',
 ]
 
 UNIFIED_SOURCES += [
     'BlankDecoderModule.cpp',
     'MP4Decoder.cpp',
     'PlatformDecoderModule.cpp',
+    'SharedDecoderManager.cpp',
 ]
 
 SOURCES += [

dom/media/mediasource/MediaSourceReader.cpp

@@ -14,6 +14,7 @@
 #include "MediaSourceUtils.h"
 #include "SourceBufferDecoder.h"
 #include "TrackBuffer.h"
+#include "SharedDecoderManager.h"
 
 #ifdef MOZ_FMP4
 #include "MP4Decoder.h"
@@ -62,6 +63,7 @@ MediaSourceReader::MediaSourceReader(MediaSourceDecoder* aDecoder)
   , mAudioIsSeeking(false)
   , mVideoIsSeeking(false)
   , mHasEssentialTrackBuffers(false)
+  , mSharedDecoderManager(new SharedDecoderManager())
 {
 }
 
@@ -371,6 +373,7 @@ MediaSourceReader::CreateSubDecoder(const nsACString& aType)
     new MediaDataDecodedListener<MediaSourceReader>(this, GetTaskQueue());
   reader->SetCallback(callback);
   reader->SetTaskQueue(GetTaskQueue());
+  reader->SetSharedDecoderManager(mSharedDecoderManager);
   reader->Init(nullptr);
 
   MSE_DEBUG("MediaSourceReader(%p)::CreateSubDecoder subdecoder %p subreader %p",

dom/media/mediasource/MediaSourceReader.h

@@ -175,6 +175,7 @@ private:
   bool mVideoIsSeeking;
 
   bool mHasEssentialTrackBuffers;
+  nsRefPtr<SharedDecoderManager> mSharedDecoderManager;
 };
 
 } // namespace mozilla