Bug 1276570: Replace TargetQueues enum with bitwise-or flags. r?jwwang
MozReview-Commit-ID: 95rnjumeBf
--- a/dom/media/MediaDecoderReader.cpp
+++ b/dom/media/MediaDecoderReader.cpp
@@ -127,23 +127,25 @@ size_t MediaDecoderReader::SizeOfVideoQu
return mVideoQueue.GetSize();
}
size_t MediaDecoderReader::SizeOfAudioQueueInFrames()
{
return mAudioQueue.GetSize();
}
-nsresult MediaDecoderReader::ResetDecode(TargetQueues aQueues /*= AUDIO_VIDEO*/)
+nsresult MediaDecoderReader::ResetDecode(TrackSet aTracks)
{
- VideoQueue().Reset();
- mVideoDiscontinuity = true;
- mBaseVideoPromise.RejectIfExists(CANCELED, __func__);
+ if (aTracks.contains(TrackInfo::kVideoTrack)) {
+ VideoQueue().Reset();
+ mVideoDiscontinuity = true;
+ mBaseVideoPromise.RejectIfExists(CANCELED, __func__);
+ }
- if (aQueues == AUDIO_VIDEO) {
+ if (aTracks.contains(TrackInfo::kAudioTrack)) {
AudioQueue().Reset();
mAudioDiscontinuity = true;
mBaseAudioPromise.RejectIfExists(CANCELED, __func__);
}
return NS_OK;
}
--- a/dom/media/MediaDecoderReader.h
+++ b/dom/media/MediaDecoderReader.h
@@ -1,16 +1,17 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */
#if !defined(MediaDecoderReader_h_)
#define MediaDecoderReader_h_
+#include "mozilla/EnumSet.h"
#include "mozilla/MozPromise.h"
#include "AbstractMediaDecoder.h"
#include "MediaInfo.h"
#include "MediaData.h"
#include "MediaMetadataManager.h"
#include "MediaQueue.h"
#include "MediaTimer.h"
@@ -68,20 +69,17 @@ class MediaDecoderReader {
public:
enum NotDecodedReason {
END_OF_STREAM,
DECODE_ERROR,
WAITING_FOR_DATA,
CANCELED
};
- enum TargetQueues {
- VIDEO_ONLY,
- AUDIO_VIDEO
- };
+ using TrackSet = EnumSet<TrackInfo::TrackType>;
using MetadataPromise =
MozPromise<RefPtr<MetadataHolder>, ReadMetadataFailureReason, IsExclusive>;
using MediaDataPromise =
MozPromise<RefPtr<MediaData>, NotDecodedReason, IsExclusive>;
using SeekPromise = MozPromise<media::TimeUnit, nsresult, IsExclusive>;
// Note that, conceptually, WaitForData makes sense in a non-exclusive sense.
@@ -125,17 +123,21 @@ public:
// Request*Data() calls after this is called. Calls to Request*Data()
// made after this should be processed as usual.
//
// Normally this call preceedes a Seek() call, or shutdown.
//
// The first samples of every stream produced after a ResetDecode() call
// *must* be marked as "discontinuities". If it's not, seeking work won't
// properly!
- virtual nsresult ResetDecode(TargetQueues aQueues = AUDIO_VIDEO);
+ //
+ // aParam is a set of TrackInfo::TrackType enums specifying which
+ // queues need to be reset, defaulting to both audio and video tracks.
+ virtual nsresult ResetDecode(TrackSet aTracks = TrackSet(TrackInfo::kAudioTrack,
+ TrackInfo::kVideoTrack));
// Requests one audio sample from the reader.
//
// The decode should be performed asynchronously, and the promise should
// be resolved when it is complete. Don't hold the decoder
// monitor while calling this, as the implementation may try to wait
// on something that needs the monitor and deadlock.
virtual RefPtr<MediaDataPromise> RequestAudioData();
--- a/dom/media/MediaDecoderReaderWrapper.cpp
+++ b/dom/media/MediaDecoderReaderWrapper.cpp
@@ -388,31 +388,34 @@ MediaDecoderReaderWrapper::SetIdle()
{
MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
nsCOMPtr<nsIRunnable> r =
NewRunnableMethod(mReader, &MediaDecoderReader::SetIdle);
mReader->OwnerThread()->Dispatch(r.forget());
}
void
-MediaDecoderReaderWrapper::ResetDecode(TargetQueues aQueues)
+MediaDecoderReaderWrapper::ResetDecode(TrackSet aTracks)
{
MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
- if (aQueues == MediaDecoderReader::AUDIO_VIDEO) {
+ if (aTracks.contains(TrackInfo::kAudioTrack)) {
mAudioDataRequest.DisconnectIfExists();
mAudioWaitRequest.DisconnectIfExists();
}
- mVideoDataRequest.DisconnectIfExists();
- mVideoWaitRequest.DisconnectIfExists();
+
+ if (aTracks.contains(TrackInfo::kVideoTrack)) {
+ mVideoDataRequest.DisconnectIfExists();
+ mVideoWaitRequest.DisconnectIfExists();
+ }
nsCOMPtr<nsIRunnable> r =
- NewRunnableMethod<TargetQueues>(mReader,
- &MediaDecoderReader::ResetDecode,
- aQueues);
+ NewRunnableMethod<TrackSet>(mReader,
+ &MediaDecoderReader::ResetDecode,
+ aTracks);
mReader->OwnerThread()->Dispatch(r.forget());
}
RefPtr<ShutdownPromise>
MediaDecoderReaderWrapper::Shutdown()
{
MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
MOZ_ASSERT(!mRequestAudioDataCB);
--- a/dom/media/MediaDecoderReaderWrapper.h
+++ b/dom/media/MediaDecoderReaderWrapper.h
@@ -27,17 +27,17 @@ typedef MozPromise<bool, bool, /* isExcl
* is passed to the underlying reader.
*/
class MediaDecoderReaderWrapper {
typedef MediaDecoderReader::MetadataPromise MetadataPromise;
typedef MediaDecoderReader::MediaDataPromise MediaDataPromise;
typedef MediaDecoderReader::SeekPromise SeekPromise;
typedef MediaDecoderReader::WaitForDataPromise WaitForDataPromise;
typedef MediaDecoderReader::BufferedUpdatePromise BufferedUpdatePromise;
- typedef MediaDecoderReader::TargetQueues TargetQueues;
+ typedef MediaDecoderReader::TrackSet TrackSet;
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaDecoderReaderWrapper);
/*
* Type 1: void(MediaData*)
* void(RefPtr<MediaData>)
*/
template <typename T>
class ArgType1CheckHelper {
@@ -375,17 +375,17 @@ public:
bool IsWaitingVideoData() const;
RefPtr<SeekPromise> Seek(SeekTarget aTarget, media::TimeUnit aEndTime);
RefPtr<BufferedUpdatePromise> UpdateBufferedWithPromise();
RefPtr<ShutdownPromise> Shutdown();
void ReleaseMediaResources();
void SetIdle();
- void ResetDecode(TargetQueues aQueues);
+ void ResetDecode(TrackSet aTracks);
nsresult Init() { return mReader->Init(); }
bool IsWaitForDataSupported() const { return mReader->IsWaitForDataSupported(); }
bool IsAsync() const { return mReader->IsAsync(); }
bool UseBufferingHeuristics() const { return mReader->UseBufferingHeuristics(); }
bool ForceZeroStartTime() const { return mReader->ForceZeroStartTime(); }
bool VideoIsHardwareAccelerated() const {
--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -1399,17 +1399,17 @@ void MediaDecoderStateMachine::InitiateV
mSeekTask = new AccurateSeekTask(mDecoderID, OwnerThread(),
mReader.get(), Move(seekJob),
mInfo, Duration(), GetMediaTime());
mOnSeekingStart.Notify(MediaDecoderEventVisibility::Suppressed);
// Reset our state machine and decoding pipeline before seeking.
if (mSeekTask->NeedToResetMDSM()) {
- Reset(MediaDecoderReader::VIDEO_ONLY);
+ Reset(TrackInfo::kVideoTrack);
}
// Do the seek.
mSeekTaskRequest.Begin(
mSeekTask->Seek(Duration())->Then(OwnerThread(), __func__, this,
&MediaDecoderStateMachine::OnSeekTaskResolved,
&MediaDecoderStateMachine::OnSeekTaskRejected));
// Nobody is listening to this as OnSeekTaskResolved handles what is
@@ -2364,50 +2364,59 @@ nsresult MediaDecoderStateMachine::RunSt
return NS_OK;
}
}
return NS_OK;
}
void
-MediaDecoderStateMachine::Reset(MediaDecoderReader::TargetQueues aQueues /*= AUDIO_VIDEO*/)
+MediaDecoderStateMachine::Reset(TrackSet aTracks)
{
MOZ_ASSERT(OnTaskQueue());
DECODER_LOG("MediaDecoderStateMachine::Reset");
// We should be resetting because we're seeking, shutting down, or entering
// dormant state. We could also be in the process of going dormant, and have
// just switched to exiting dormant before we finished entering dormant,
// hence the DECODING_NONE case below.
MOZ_ASSERT(IsShutdown() ||
mState == DECODER_STATE_SEEKING ||
mState == DECODER_STATE_DORMANT);
-
- mDecodedVideoEndTime = 0;
- mVideoCompleted = false;
- VideoQueue().Reset();
-
- if (aQueues == MediaDecoderReader::AUDIO_VIDEO) {
+ // Assert that aTracks specifies to reset the video track because we
+ // don't currently support resetting just the audio track.
+ MOZ_ASSERT(aTracks.contains(TrackInfo::kVideoTrack));
+
+ if (aTracks.contains(TrackInfo::kAudioTrack) &&
+ aTracks.contains(TrackInfo::kVideoTrack)) {
// Stop the audio thread. Otherwise, MediaSink might be accessing AudioQueue
// outside of the decoder monitor while we are clearing the queue and causes
// crash for no samples to be popped.
StopMediaSink();
+ }
+
+ if (aTracks.contains(TrackInfo::kVideoTrack)) {
+ mDecodedVideoEndTime = 0;
+ mVideoCompleted = false;
+ VideoQueue().Reset();
+ }
+
+ if (aTracks.contains(TrackInfo::kAudioTrack)) {
mDecodedAudioEndTime = 0;
mAudioCompleted = false;
AudioQueue().Reset();
}
mMetadataRequest.DisconnectIfExists();
mSeekTaskRequest.DisconnectIfExists();
mPlaybackOffset = 0;
- mReader->ResetDecode(aQueues);
+ mReader->ResetDecode(aTracks);
}
int64_t
MediaDecoderStateMachine::GetClock(TimeStamp* aTimeStamp) const
{
MOZ_ASSERT(OnTaskQueue());
int64_t clockTime = mMediaSink->GetPosition(aTimeStamp);
NS_ASSERTION(GetMediaTime() <= clockTime, "Clock should go forwards.");
--- a/dom/media/MediaDecoderStateMachine.h
+++ b/dom/media/MediaDecoderStateMachine.h
@@ -130,16 +130,19 @@ enum class MediaEventType : int8_t {
are propagated by scheduling the state machine to run another cycle on the
shared state machine thread.
See MediaDecoder.h for more details.
*/
class MediaDecoderStateMachine
{
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaDecoderStateMachine)
+
+ using TrackSet = MediaDecoderReader::TrackSet;
+
public:
typedef MediaDecoderOwner::NextFrameStatus NextFrameStatus;
typedef mozilla::layers::ImageContainer::FrameID FrameID;
MediaDecoderStateMachine(MediaDecoder* aDecoder,
MediaDecoderReader* aReader,
bool aRealTime = false);
nsresult Init(MediaDecoder* aDecoder);
@@ -363,17 +366,18 @@ private:
void OnVideoNotDecoded(MediaDecoderReader::NotDecodedReason aReason)
{
MOZ_ASSERT(OnTaskQueue());
OnNotDecoded(MediaData::VIDEO_DATA, aReason);
}
// Resets all state related to decoding and playback, emptying all buffers
// and aborting all pending operations on the decode task queue.
- void Reset(MediaDecoderReader::TargetQueues aQueues = MediaDecoderReader::AUDIO_VIDEO);
+ void Reset(TrackSet aTracks = TrackSet(TrackInfo::kAudioTrack,
+ TrackInfo::kVideoTrack));
protected:
virtual ~MediaDecoderStateMachine();
void SetState(State aState);
void BufferedRangeUpdated();
--- a/dom/media/MediaFormatReader.cpp
+++ b/dom/media/MediaFormatReader.cpp
@@ -1339,49 +1339,57 @@ MediaFormatReader::WaitForData(MediaData
return WaitForDataPromise::CreateAndResolve(decoder.mType, __func__);
}
RefPtr<WaitForDataPromise> p = decoder.mWaitingPromise.Ensure(__func__);
ScheduleUpdate(trackType);
return p;
}
nsresult
-MediaFormatReader::ResetDecode(TargetQueues aQueues)
+MediaFormatReader::ResetDecode(TrackSet aTracks)
{
MOZ_ASSERT(OnTaskQueue());
LOGV("");
mSeekPromise.RejectIfExists(NS_OK, __func__);
mSkipRequest.DisconnectIfExists();
// Do the same for any data wait promises.
- if (aQueues == AUDIO_VIDEO) {
- mAudio.mWaitingPromise.RejectIfExists(WaitForDataRejectValue(MediaData::AUDIO_DATA, WaitForDataRejectValue::CANCELED), __func__);
+ if (aTracks.contains(TrackInfo::kAudioTrack)) {
+ mAudio.mWaitingPromise.RejectIfExists(
+ WaitForDataRejectValue(MediaData::AUDIO_DATA,
+ WaitForDataRejectValue::CANCELED), __func__);
}
- mVideo.mWaitingPromise.RejectIfExists(WaitForDataRejectValue(MediaData::VIDEO_DATA, WaitForDataRejectValue::CANCELED), __func__);
+
+ if (aTracks.contains(TrackInfo::kVideoTrack)) {
+ mVideo.mWaitingPromise.RejectIfExists(
+ WaitForDataRejectValue(MediaData::VIDEO_DATA,
+ WaitForDataRejectValue::CANCELED), __func__);
+ }
// Reset miscellaneous seeking state.
mPendingSeekTime.reset();
- if (HasVideo()) {
+ if (HasVideo() && aTracks.contains(TrackInfo::kVideoTrack)) {
mVideo.ResetDemuxer();
Reset(TrackInfo::kVideoTrack);
if (mVideo.HasPromise()) {
mVideo.RejectPromise(CANCELED, __func__);
}
}
- if (HasAudio() && aQueues == AUDIO_VIDEO) {
+ if (HasAudio() && aTracks.contains(TrackInfo::kAudioTrack)) {
mAudio.ResetDemuxer();
Reset(TrackInfo::kAudioTrack);
if (mAudio.HasPromise()) {
mAudio.RejectPromise(CANCELED, __func__);
}
}
- return MediaDecoderReader::ResetDecode(aQueues);
+
+ return MediaDecoderReader::ResetDecode(aTracks);
}
void
MediaFormatReader::Output(TrackType aTrack, MediaData* aSample)
{
if (!aSample) {
NS_WARNING("MediaFormatReader::Output() passed a null sample");
Error(aTrack);
--- a/dom/media/MediaFormatReader.h
+++ b/dom/media/MediaFormatReader.h
@@ -57,17 +57,17 @@ public:
RefPtr<BufferedUpdatePromise> UpdateBufferedWithPromise() override;
bool ForceZeroStartTime() const override;
// For Media Resource Management
void ReleaseMediaResources() override;
- nsresult ResetDecode(TargetQueues aQueues) override;
+ nsresult ResetDecode(TrackSet aTracks) override;
RefPtr<ShutdownPromise> Shutdown() override;
bool IsAsync() const override { return true; }
bool VideoIsHardwareAccelerated() const override;
bool IsWaitForDataSupported() const override { return true; }
--- a/dom/media/android/AndroidMediaReader.cpp
+++ b/dom/media/android/AndroidMediaReader.cpp
@@ -89,34 +89,34 @@ nsresult AndroidMediaReader::ReadMetadat
*aInfo = mInfo;
*aTags = nullptr;
return NS_OK;
}
RefPtr<ShutdownPromise>
AndroidMediaReader::Shutdown()
{
- ResetDecode(AUDIO_VIDEO);
+ ResetDecode();
if (mPlugin) {
GetAndroidMediaPluginHost()->DestroyDecoder(mPlugin);
mPlugin = nullptr;
}
return MediaDecoderReader::Shutdown();
}
// Resets all state related to decoding, emptying all buffers etc.
-nsresult AndroidMediaReader::ResetDecode(TargetQueues aQueues)
+nsresult AndroidMediaReader::ResetDecode(TrackSet aTracks)
{
if (mLastVideoFrame) {
mLastVideoFrame = nullptr;
}
mSeekRequest.DisconnectIfExists();
mSeekPromise.RejectIfExists(NS_OK, __func__);
- return MediaDecoderReader::ResetDecode(aQueues);
+ return MediaDecoderReader::ResetDecode(aTracks);
}
bool AndroidMediaReader::DecodeVideoFrame(bool &aKeyframeSkip,
int64_t aTimeThreshold)
{
// Record number of frames decoded and parsed. Automatically update the
// stats counters using the AutoNotifyDecoded stack-based class.
AbstractMediaDecoder::AutoNotifyDecoded a(mDecoder);
--- a/dom/media/android/AndroidMediaReader.h
+++ b/dom/media/android/AndroidMediaReader.h
@@ -37,17 +37,18 @@ class AndroidMediaReader : public MediaD
int64_t mAudioSeekTimeUs;
RefPtr<VideoData> mLastVideoFrame;
MozPromiseHolder<MediaDecoderReader::SeekPromise> mSeekPromise;
MozPromiseRequestHolder<MediaDecoderReader::MediaDataPromise> mSeekRequest;
public:
AndroidMediaReader(AbstractMediaDecoder* aDecoder,
const nsACString& aContentType);
- nsresult ResetDecode(TargetQueues aQueues) override;
+ nsresult ResetDecode(TrackSet aTracks = TrackSet(TrackInfo::kAudioTrack,
+ TrackInfo::kVideoTrack)) override;
bool DecodeAudioData() override;
bool DecodeVideoFrame(bool &aKeyframeSkip, int64_t aTimeThreshold) override;
nsresult ReadMetadata(MediaInfo* aInfo, MetadataTags** aTags) override;
RefPtr<SeekPromise> Seek(SeekTarget aTarget, int64_t aEndTime) override;
RefPtr<ShutdownPromise> Shutdown() override;
--- a/dom/media/ogg/OggReader.cpp
+++ b/dom/media/ogg/OggReader.cpp
@@ -164,27 +164,27 @@ OggReader::~OggReader()
}
nsresult OggReader::Init() {
int ret = ogg_sync_init(&mOggState);
NS_ENSURE_TRUE(ret == 0, NS_ERROR_FAILURE);
return NS_OK;
}
-nsresult OggReader::ResetDecode(TargetQueues aQueues)
+nsresult OggReader::ResetDecode(TrackSet aTracks)
{
- return ResetDecode(false, aQueues);
+ return ResetDecode(false, aTracks);
}
-nsresult OggReader::ResetDecode(bool start, TargetQueues aQueues)
+nsresult OggReader::ResetDecode(bool start, TrackSet aTracks)
{
MOZ_ASSERT(OnTaskQueue());
nsresult res = NS_OK;
- if (NS_FAILED(MediaDecoderReader::ResetDecode(aQueues))) {
+ if (NS_FAILED(MediaDecoderReader::ResetDecode(aTracks))) {
res = NS_ERROR_FAILURE;
}
// Discard any previously buffered packets/pages.
ogg_sync_reset(&mOggState);
if (mVorbisState && NS_FAILED(mVorbisState->Reset())) {
res = NS_ERROR_FAILURE;
}
--- a/dom/media/ogg/OggReader.h
+++ b/dom/media/ogg/OggReader.h
@@ -46,17 +46,18 @@ class OggReader final : public MediaDeco
public:
explicit OggReader(AbstractMediaDecoder* aDecoder);
protected:
~OggReader();
public:
nsresult Init() override;
- nsresult ResetDecode(TargetQueues aQueues = AUDIO_VIDEO) override;
+ nsresult ResetDecode(TrackSet aTracks = TrackSet(TrackInfo::kAudioTrack,
+ TrackInfo::kVideoTrack)) override;
bool DecodeAudioData() override;
// If the Theora granulepos has not been captured, it may read several packets
// until one with a granulepos has been captured, to ensure that all packets
// read have valid time info.
bool DecodeVideoFrame(bool &aKeyframeSkip, int64_t aTimeThreshold) override;
nsresult ReadMetadata(MediaInfo* aInfo, MetadataTags** aTags) override;
@@ -81,17 +82,19 @@ private:
RefPtr<AudioData> SyncDecodeToFirstAudioData();
RefPtr<VideoData> SyncDecodeToFirstVideoData();
// This monitor should be taken when reading or writing to mIsChained.
ReentrantMonitor mMonitor;
// Specialized Reset() method to signal if the seek is
// to the start of the stream.
- nsresult ResetDecode(bool start, TargetQueues aQueues = AUDIO_VIDEO);
+ nsresult ResetDecode(bool start,
+ TrackSet aTracks = TrackSet(TrackInfo::kAudioTrack,
+ TrackInfo::kVideoTrack));
nsresult SeekInternal(int64_t aTime, int64_t aEndTime);
bool HasSkeleton() {
return mSkeletonState != 0 && mSkeletonState->mActive;
}
// Seeks to the keyframe preceding the target time using available
--- a/dom/media/omx/MediaOmxReader.cpp
+++ b/dom/media/omx/MediaOmxReader.cpp
@@ -171,17 +171,17 @@ MediaOmxReader::Shutdown()
return p;
}
void MediaOmxReader::ReleaseMediaResources()
{
mMediaResourceRequest.DisconnectIfExists();
mMetadataPromise.RejectIfExists(ReadMetadataFailureReason::METADATA_ERROR, __func__);
- ResetDecode(AUDIO_VIDEO);
+ ResetDecode();
// Before freeing a video codec, all video buffers needed to be released
// even from graphics pipeline.
VideoFrameContainer* container = mDecoder->GetVideoFrameContainer();
if (container) {
container->ClearCurrentFrame();
}
if (mOmxDecoder.get()) {
mOmxDecoder->ReleaseMediaResources();
--- a/dom/media/omx/MediaOmxReader.h
+++ b/dom/media/omx/MediaOmxReader.h
@@ -69,21 +69,21 @@ protected:
public:
MediaOmxReader(AbstractMediaDecoder* aDecoder);
~MediaOmxReader();
protected:
void NotifyDataArrivedInternal() override;
public:
- nsresult ResetDecode(TargetQueues aQueues) override
+ nsresult ResetDecoder(TrackSet aTracks) override;
{
mSeekRequest.DisconnectIfExists();
mSeekPromise.RejectIfExists(NS_OK, __func__);
- return MediaDecoderReader::ResetDecode(aQueues);
+ return MediaDecoderReader::ResetDecode(aTracks);
}
bool DecodeAudioData() override;
bool DecodeVideoFrame(bool &aKeyframeSkip, int64_t aTimeThreshold) override;
void ReleaseMediaResources() override;
RefPtr<MediaDecoderReader::MetadataPromise> AsyncReadMetadata() override;
--- a/dom/media/raw/RawReader.cpp
+++ b/dom/media/raw/RawReader.cpp
@@ -22,20 +22,20 @@ RawReader::RawReader(AbstractMediaDecode
MOZ_COUNT_CTOR(RawReader);
}
RawReader::~RawReader()
{
MOZ_COUNT_DTOR(RawReader);
}
-nsresult RawReader::ResetDecode(TargetQueues aQueues)
+nsresult RawReader::ResetDecode(TrackSet aTracks)
{
mCurrentFrame = 0;
- return MediaDecoderReader::ResetDecode(aQueues);
+ return MediaDecoderReader::ResetDecode(aTracks);
}
nsresult RawReader::ReadMetadata(MediaInfo* aInfo,
MetadataTags** aTags)
{
MOZ_ASSERT(OnTaskQueue());
if (!ReadFromResource(reinterpret_cast<uint8_t*>(&mMetadata),
--- a/dom/media/raw/RawReader.h
+++ b/dom/media/raw/RawReader.h
@@ -15,17 +15,17 @@ class RawReader : public MediaDecoderRea
{
public:
explicit RawReader(AbstractMediaDecoder* aDecoder);
protected:
~RawReader();
public:
- nsresult ResetDecode(TargetQueues aQueues) override;
+ nsresult ResetDecode(TrackSet aTracks) override;
bool DecodeAudioData() override;
bool DecodeVideoFrame(bool &aKeyframeSkip,
int64_t aTimeThreshold) override;
nsresult ReadMetadata(MediaInfo* aInfo,
MetadataTags** aTags) override;
RefPtr<SeekPromise> Seek(SeekTarget aTarget, int64_t aEndTime) override;