SourceBuffer implementation

.gitignore

@@ -5,4 +5,5 @@ Cargo.lock
 glue_diffs/
 *~
 .cargo/
-/NDK/
+/NDK/
+**/.DS_Store

gecko-media/data/header_files.json

@@ -103,7 +103,6 @@
   "MediaResult.h": "dom/media/MediaResult.h",
   "MediaSegment.h": "dom/media/MediaSegment.h",
   "MediaShutdownManager.h": "dom/media/MediaShutdownManager.h",
-  "MediaSourceDecoder.h": "dom/media/mediasource/MediaSourceDecoder.h",
   "MediaSourceDemuxer.h": "dom/media/mediasource/MediaSourceDemuxer.h",
   "MediaSourceUtils.h": "dom/media/mediasource/MediaSourceUtils.h",
   "MediaStatistics.h": "dom/media/MediaStatistics.h",
@@ -140,7 +139,6 @@
   "SharedBuffer.h": "dom/media/SharedBuffer.h",
   "SimpleMap.h": "dom/media/platforms/SimpleMap.h",
   "SinfParser.h": "dom/media/mp4/SinfParser.h",
-  "SourceBufferAttributes.h": "dom/media/mediasource/SourceBufferAttributes.h",
   "SourceBufferResource.h": "dom/media/mediasource/SourceBufferResource.h",
   "SourceBufferTask.h": "dom/media/mediasource/SourceBufferTask.h",
   "SpecialSystemDirectory.h": "xpcom/io/SpecialSystemDirectory.h",

gecko-media/gecko/glue/GeckoMediaDecoder.cpp

@@ -37,7 +37,6 @@ GeckoMediaDecoder::GeckoMediaDecoder(MediaDecoderInit& aInit)
   : MediaDecoder(aInit)
   , mGeckoWatchManager(this, aInit.mOwner->AbstractMainThread())
 {
-  mExplicitDuration.emplace(UnspecifiedNaN<double>());
   mGeckoWatchManager.Watch(mBuffered, &GeckoMediaDecoder::NotifyBuffered);
 }
 

gecko-media/gecko/glue/GeckoMediaSourceBuffer.cpp

@@ -17,8 +17,10 @@ struct GeckoMediaSourceBuffer
   GeckoMediaSourceBuffer(size_t aId,
                          GeckoMediaSourceBufferImpl aImpl,
                          size_t aParentId,
-                         const char* aMimeType)
-    : mSourceBuffer(new SourceBuffer(aImpl, aParentId, aMimeType))
+                         const char* aMimeType,
+                         bool aGenerateTimestamps)
+    : mSourceBuffer(
+        new SourceBuffer(aImpl, aParentId, aMimeType, aGenerateTimestamps))
     , mId(aId)
   {
   }
@@ -35,13 +37,59 @@ void
 GeckoMedia_SourceBuffer_Create(size_t aId,
                                GeckoMediaSourceBufferImpl aImpl,
                                size_t aParentId,
-                               const char* aMimeType)
+                               const char* aMimeType,
+                               bool aGenerateTimestamps)
 {
   GeckoMediaSourceBuffer* reflector =
-    sReflectors.AppendElement(GeckoMediaSourceBuffer(aId, aImpl, aParentId, aMimeType));
+    sReflectors.AppendElement(GeckoMediaSourceBuffer(
+      aId, aImpl, aParentId, aMimeType, aGenerateTimestamps));
   MOZ_ASSERT(GetReflector(aId) == reflector);
 }
 
+void
+GeckoMedia_SourceBuffer_EvictData(size_t aId, size_t aLength, bool* aBufferFull)
+{
+  IMPL_GECKO_MEDIA_REFLECTOR_GET(GeckoMediaSourceBuffer)
+
+  reflector->mSourceBuffer->EvictData(aLength, aBufferFull);
+}
+
+void
+GeckoMedia_SourceBuffer_AppendData(size_t aId,
+                                   const uint8_t* aData,
+                                   size_t aLength)
+{
+  IMPL_GECKO_MEDIA_REFLECTOR_GET(GeckoMediaSourceBuffer)
+
+  reflector->mSourceBuffer->AppendData(aData, aLength);
+}
+
+void
+GeckoMedia_SourceBuffer_AbortBufferAppend(size_t aId)
+{
+  IMPL_GECKO_MEDIA_REFLECTOR_GET(GeckoMediaSourceBuffer)
+
+  reflector->mSourceBuffer->AbortBufferAppend();
+}
+
+void
+GeckoMedia_SourceBuffer_ResetParserState(size_t aId)
+{
+  IMPL_GECKO_MEDIA_REFLECTOR_GET(GeckoMediaSourceBuffer)
+
+  reflector->mSourceBuffer->ResetParserState();
+}
+
+void
+GeckoMedia_SourceBuffer_RangeRemoval(size_t aId,
+                                     double aStart,
+                                     double aEnd)
+{
+  IMPL_GECKO_MEDIA_REFLECTOR_GET(GeckoMediaSourceBuffer)
+
+  reflector->mSourceBuffer->RangeRemoval(aStart, aEnd);
+}
+
 SourceBuffer*
 GetSourceBuffer(const size_t aId)
 {

gecko-media/gecko/glue/MediaSource.cpp

@@ -15,6 +15,7 @@
 #include "mozilla/Logging.h"
 #include "mozilla/Preferences.h"
 #include "nsThreadManager.h"
+#include "SourceBuffer.h"
 
 mozilla::LogModule*
 GetMediaSourceLog()
@@ -61,6 +62,8 @@ namespace dom {
 
 MediaSource::MediaSource(GeckoMediaSourceImpl aImpl)
   : mImpl(aImpl)
+  , mSourceBuffers(GetSourceBuffers())
+  , mActiveSourceBuffers(GetActiveSourceBuffers())
   , mDecoder(nullptr)
 {
 }
@@ -79,14 +82,56 @@ MediaSource::~MediaSource()
   (*mImpl.mFree)(mImpl.mContext);
 }
 
+SourceBufferList*
+MediaSource::SourceBuffers()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT_IF(ReadyState() == MediaSourceReadyState::Closed, mSourceBuffers->Length() == 0);
+  return mSourceBuffers;
+}
+
+SourceBufferList*
+MediaSource::GetSourceBuffers()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  CALLBACK_GUARD(GetSourceBuffers, nullptr);
+  size_t* id = CALLBACK_CALL(GetSourceBuffers);
+  if (NS_WARN_IF(!id)) {
+    return nullptr;
+  }
+
+  return GetSourceBufferList(*id);
+}
+
+SourceBufferList*
+MediaSource::ActiveSourceBuffers()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT_IF(ReadyState() == MediaSourceReadyState::Closed, mActiveSourceBuffers->Length() == 0);
+  return mActiveSourceBuffers;
+}
+
+SourceBufferList*
+MediaSource::GetActiveSourceBuffers()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  CALLBACK_GUARD(GetActiveSourceBuffers, nullptr);
+  size_t* id = (*mImpl.mGetActiveSourceBuffers)(mImpl.mContext);
+  if (NS_WARN_IF(!id)) {
+    return nullptr;
+  }
+
+  return GetSourceBufferList(*id);
+}
+
 double
 MediaSource::Duration()
 {
   MOZ_ASSERT(NS_IsMainThread());
-  if (NS_WARN_IF(!mImpl.mContext || !mImpl.mGetDuration)) {
-    return 0;
-  }
-  return (*mImpl.mGetDuration)(mImpl.mContext);
+  CALLBACK_GUARD(GetDuration, 0);
+  return CALLBACK_CALL(GetDuration);
 }
 
 void
@@ -104,22 +149,54 @@ MediaSourceReadyState
 MediaSource::ReadyState()
 {
   MOZ_ASSERT(NS_IsMainThread());
-  if (NS_WARN_IF(!mImpl.mContext || !mImpl.mGetReadyState)) {
-    return MediaSourceReadyState::Unknown;
-  }
-
-  return (*mImpl.mGetReadyState)(mImpl.mContext);
+  CALLBACK_GUARD(GetReadyState, MediaSourceReadyState::Unknown);
+  return CALLBACK_CALL(GetReadyState);
 }
 
 bool
-MediaSource::HasLiveSeekableRange()
+MediaSource::Attach(MediaSourceDecoder* aDecoder)
 {
   MOZ_ASSERT(NS_IsMainThread());
-  if (NS_WARN_IF(!mImpl.mContext || !mImpl.mHasLiveSeekableRange)) {
+  MSE_DEBUG("Attach(aDecoder=%p) owner=%p", aDecoder, aDecoder->GetOwner());
+  MOZ_ASSERT(aDecoder);
+  MOZ_ASSERT(aDecoder->GetOwner());
+  if (ReadyState() != MediaSourceReadyState::Closed) {
     return false;
   }
+  MOZ_ASSERT(!mDecoder);
+  mDecoder = aDecoder;
+  mDecoder->AttachMediaSource(this);
+  SetReadyState(MediaSourceReadyState::Open);
+  return true;
+}
 
-  return (*mImpl.mHasLiveSeekableRange)(mImpl.mContext);
+void
+MediaSource::Detach()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_RELEASE_ASSERT(mCompletionPromises.IsEmpty());
+  MSE_DEBUG("mDecoder=%p owner=%p",
+            mDecoder.get(),
+            mDecoder ? mDecoder->GetOwner() : nullptr);
+  if (!mDecoder) {
+    MOZ_ASSERT(ReadyState() == MediaSourceReadyState::Closed);
+    MOZ_ASSERT(mActiveSourceBuffers->Length() == 0 &&
+               mSourceBuffers->Length() == 0);
+    return;
+  }
+  SetReadyState(MediaSourceReadyState::Closed);
+  mSourceBuffers->Clear();
+  mActiveSourceBuffers->Clear();
+  mDecoder->DetachMediaSource();
+  mDecoder = nullptr;
+}
+
+bool
+MediaSource::HasLiveSeekableRange()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  CALLBACK_GUARD(HasLiveSeekableRange, false);
+  return CALLBACK_CALL(HasLiveSeekableRange);
 }
 
 media::TimeInterval
@@ -167,6 +244,50 @@ MediaSource::EndOfStreamError(const GeckoMediaEndOfStreamError aError)
   }
 }
 
+RefPtr<MediaSource::ActiveCompletionPromise>
+MediaSource::SourceBufferIsActive(SourceBuffer* aSourceBuffer)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  bool initMissing = false;
+  bool found = false;
+  for (uint32_t i = 0; i < mSourceBuffers->Length() ; i++) {
+    SourceBuffer* sourceBuffer = mSourceBuffers->IndexedGetter(i, found);
+    MOZ_ALWAYS_TRUE(found);
+    if (sourceBuffer == aSourceBuffer) {
+      sourceBuffer->SetActive(true);
+    } else if (!sourceBuffer->GetActive()) {
+      // Some source buffers haven't yet received an init segment.
+      // There's nothing more we can do at this stage.
+      initMissing = true;
+    }
+  }
+
+  if (initMissing || !mDecoder) {
+    return ActiveCompletionPromise::CreateAndResolve(true, __func__);
+  }
+
+  mDecoder->NotifyInitDataArrived();
+
+  // Add our promise to the queue.
+  // It will be resolved once the HTMLMediaElement modifies its readyState.
+  MozPromiseHolder<ActiveCompletionPromise> holder;
+  RefPtr<ActiveCompletionPromise> promise = holder.Ensure(__func__);
+  mCompletionPromises.AppendElement(Move(holder));
+  return promise;
+}
+
+void
+MediaSource::CompletePendingTransactions()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MSE_DEBUG("Resolving %u promises", unsigned(mCompletionPromises.Length()));
+  for (auto& promise : mCompletionPromises) {
+    promise.Resolve(true, __func__);
+  }
+  mCompletionPromises.Clear();
+}
+
 /* static */
 bool
 MediaSource::IsTypeSupported(const char* aType)

gecko-media/gecko/glue/MediaSourceDecoder.cpp

@@ -27,7 +27,7 @@ using namespace mozilla::media;
 namespace mozilla {
 
 MediaSourceDecoder::MediaSourceDecoder(MediaDecoderInit& aInit)
-  : MediaDecoder(aInit)
+  : GeckoMediaDecoder(aInit)
   , mMediaSource(nullptr)
   , mEnded(false)
 {
@@ -177,7 +177,7 @@ MediaSourceDecoder::Shutdown()
   }
   mDemuxer = nullptr;
 
-  MediaDecoder::Shutdown();
+  GeckoMediaDecoder::Shutdown();
 }
 
 void
@@ -354,6 +354,16 @@ MediaSourceDecoder::NotifyInitDataArrived()
   }
 }
 
+void
+MediaSourceDecoder::NotifyDataArrived()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_DIAGNOSTIC_ASSERT(!IsShutdown());
+  AbstractThread::AutoEnter context(AbstractMainThread());
+  NotifyReaderDataArrived();
+  GetOwner()->DownloadProgressed();
+}
+
 already_AddRefed<nsIPrincipal>
 MediaSourceDecoder::GetCurrentPrincipal()
 {

gecko-media/gecko/glue/Player.cpp

@@ -10,6 +10,9 @@
 #include "GeckoMediaDecoder.h"
 #include "GeckoMediaDecoderOwner.h"
 #include "GeckoMediaMacros.h"
+#include "GeckoMediaSource.h"
+#include "MediaSource.h"
+#include "MediaSourceDecoder.h"
 #include "RustMediaResource.h"
 #include "UniquePtr.h"
 #include "mozilla/RefPtr.h"
@@ -111,6 +114,42 @@ GeckoMedia_Player_CreateNetworkPlayer(size_t aId,
   resource->SetDecoder(reflector->mDecoder);
 }
 
+bool
+GeckoMedia_Player_CreateMediaSourcePlayer(size_t aId,
+                                          size_t aMediaSourceId,
+                                          PlayerCallbackObject aCallback,
+                                          FrameAllocatorObject aAllocator)
+{
+  Player* reflector =
+    sReflectors.AppendElement(Player(aId, aCallback, aAllocator));
+  MOZ_ASSERT(GetReflector(aId) == reflector);
+
+  MediaDecoderInit decoderInit(
+    reflector->mDecoderOwner.get(),
+    1.0,   // volume
+    true,  // mPreservesPitch
+    1.0,   // mPlaybackRate
+    false, // mMinimizePreroll
+    false, // mHasSuspendTaint
+    false, // mLooping
+    MediaContainerType(MEDIAMIMETYPE("application/x.mediasource")));
+  RefPtr<MediaSourceDecoder> decoder = new MediaSourceDecoder(decoderInit);
+  reflector->mDecoder = static_cast<GeckoMediaDecoder*>(decoder);
+  reflector->mDecoderOwner->SetDecoder(reflector->mDecoder);
+
+  RefPtr<mozilla::dom::MediaSource> mediaSource =
+    GetMediaSource(aMediaSourceId);
+  if (NS_WARN_IF(!mediaSource || !mediaSource->Attach(decoder))) {
+    return false;
+  }
+
+  if (NS_WARN_IF(reflector->mDecoder->Load(nullptr) != NS_OK)) {
+    return false;
+  }
+
+  return true;
+}
+
 void
 GeckoMedia_Player_Play(size_t aId)
 {
@@ -144,5 +183,5 @@ void
 GeckoMedia_Player_SetPlaybackRate(size_t aId, double rate)
 {
   IMPL_GECKO_MEDIA_REFLECTOR_GET(Player)
-    reflector->mDecoder->SetPlaybackRate(rate);
+  reflector->mDecoder->SetPlaybackRate(rate);
 }