Line data Source code
1 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 : /* This Source Code Form is subject to the terms of the Mozilla Public
4 : * License, v. 2.0. If a copy of the MPL was not distributed with this
5 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 :
7 : #include "mozilla/MozPromise.h"
8 : #include "MediaDecoderReaderWrapper.h"
9 :
10 : namespace mozilla {
11 :
12 0 : MediaDecoderReaderWrapper::MediaDecoderReaderWrapper(AbstractThread* aOwnerThread,
13 0 : MediaDecoderReader* aReader)
14 : : mOwnerThread(aOwnerThread)
15 : , mReader(aReader)
16 0 : , mWatchManager(this, aReader->OwnerThread())
17 0 : , mDuration(aReader->OwnerThread(),
18 0 : NullableTimeUnit(),
19 0 : "MediaDecoderReaderWrapper::mDuration (Mirror)")
20 : {
21 : // Must support either heuristic buffering or WaitForData().
22 0 : MOZ_ASSERT(mReader->UseBufferingHeuristics() ||
23 : mReader->IsWaitForDataSupported());
24 0 : }
25 :
26 0 : MediaDecoderReaderWrapper::~MediaDecoderReaderWrapper()
27 0 : {}
28 :
29 : media::TimeUnit
30 0 : MediaDecoderReaderWrapper::StartTime() const
31 : {
32 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
33 0 : MOZ_ASSERT(!mShutdown);
34 0 : return mStartTime.ref();
35 : }
36 :
37 : RefPtr<MediaDecoderReaderWrapper::MetadataPromise>
38 0 : MediaDecoderReaderWrapper::ReadMetadata()
39 : {
40 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
41 0 : MOZ_ASSERT(!mShutdown);
42 0 : return InvokeAsync(mReader->OwnerThread(), mReader.get(), __func__,
43 : &MediaDecoderReader::AsyncReadMetadata)
44 0 : ->Then(mOwnerThread, __func__, this,
45 : &MediaDecoderReaderWrapper::OnMetadataRead,
46 0 : &MediaDecoderReaderWrapper::OnMetadataNotRead);
47 : }
48 :
49 : RefPtr<MediaDecoderReaderWrapper::AudioDataPromise>
50 0 : MediaDecoderReaderWrapper::RequestAudioData()
51 : {
52 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
53 0 : MOZ_ASSERT(!mShutdown);
54 :
55 0 : int64_t startTime = StartTime().ToMicroseconds();
56 0 : return InvokeAsync(mReader->OwnerThread(), mReader.get(),
57 : __func__, &MediaDecoderReader::RequestAudioData)
58 0 : ->Then(mOwnerThread, __func__,
59 0 : [startTime] (RefPtr<AudioData> aAudio) {
60 0 : aAudio->AdjustForStartTime(startTime);
61 0 : return AudioDataPromise::CreateAndResolve(aAudio.forget(), __func__);
62 : },
63 0 : [] (const MediaResult& aError) {
64 : return AudioDataPromise::CreateAndReject(aError, __func__);
65 0 : });
66 : }
67 :
68 : RefPtr<MediaDecoderReaderWrapper::VideoDataPromise>
69 0 : MediaDecoderReaderWrapper::RequestVideoData(const media::TimeUnit& aTimeThreshold)
70 : {
71 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
72 0 : MOZ_ASSERT(!mShutdown);
73 :
74 0 : const auto threshold = aTimeThreshold > media::TimeUnit::Zero()
75 0 : ? aTimeThreshold + StartTime()
76 0 : : aTimeThreshold;
77 :
78 0 : int64_t startTime = StartTime().ToMicroseconds();
79 0 : return InvokeAsync(
80 0 : mReader->OwnerThread(), mReader.get(), __func__,
81 : &MediaDecoderReader::RequestVideoData, threshold)
82 0 : ->Then(mOwnerThread, __func__,
83 0 : [startTime] (RefPtr<VideoData> aVideo) {
84 0 : aVideo->AdjustForStartTime(startTime);
85 0 : return VideoDataPromise::CreateAndResolve(aVideo.forget(), __func__);
86 : },
87 0 : [] (const MediaResult& aError) {
88 : return VideoDataPromise::CreateAndReject(aError, __func__);
89 0 : });
90 : }
91 :
92 : RefPtr<MediaDecoderReader::SeekPromise>
93 0 : MediaDecoderReaderWrapper::Seek(const SeekTarget& aTarget)
94 : {
95 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
96 0 : SeekTarget adjustedTarget = aTarget;
97 0 : adjustedTarget.SetTime(adjustedTarget.GetTime() + StartTime());
98 : return InvokeAsync(
99 0 : mReader->OwnerThread(), mReader.get(), __func__,
100 : &MediaDecoderReader::Seek,
101 0 : Move(adjustedTarget));
102 : }
103 :
104 : RefPtr<MediaDecoderReaderWrapper::WaitForDataPromise>
105 0 : MediaDecoderReaderWrapper::WaitForData(MediaData::Type aType)
106 : {
107 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
108 0 : MOZ_ASSERT(mReader->IsWaitForDataSupported());
109 0 : return InvokeAsync(mReader->OwnerThread(), mReader.get(), __func__,
110 0 : &MediaDecoderReader::WaitForData, aType);
111 : }
112 :
113 : void
114 0 : MediaDecoderReaderWrapper::ReleaseResources()
115 : {
116 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
117 : nsCOMPtr<nsIRunnable> r =
118 0 : NewRunnableMethod("MediaDecoderReader::ReleaseResources",
119 : mReader,
120 0 : &MediaDecoderReader::ReleaseResources);
121 0 : mReader->OwnerThread()->Dispatch(r.forget());
122 0 : }
123 :
124 : void
125 0 : MediaDecoderReaderWrapper::ResetDecode(TrackSet aTracks)
126 : {
127 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
128 : nsCOMPtr<nsIRunnable> r =
129 0 : NewRunnableMethod<TrackSet>("MediaDecoderReader::ResetDecode",
130 : mReader,
131 : &MediaDecoderReader::ResetDecode,
132 0 : aTracks);
133 0 : mReader->OwnerThread()->Dispatch(r.forget());
134 0 : }
135 :
136 : RefPtr<ShutdownPromise>
137 0 : MediaDecoderReaderWrapper::Shutdown()
138 : {
139 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
140 0 : mShutdown = true;
141 0 : RefPtr<MediaDecoderReaderWrapper> self = this;
142 0 : return InvokeAsync(mReader->OwnerThread(), __func__, [self]() {
143 0 : self->mDuration.DisconnectIfConnected();
144 0 : self->mWatchManager.Shutdown();
145 0 : return self->mReader->Shutdown();
146 0 : });
147 : }
148 :
149 : RefPtr<MediaDecoderReaderWrapper::MetadataPromise>
150 0 : MediaDecoderReaderWrapper::OnMetadataRead(MetadataHolder&& aMetadata)
151 : {
152 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
153 0 : if (mShutdown) {
154 : return MetadataPromise::CreateAndReject(
155 0 : NS_ERROR_DOM_MEDIA_ABORT_ERR, __func__);
156 : }
157 :
158 0 : if (mStartTime.isNothing()) {
159 0 : mStartTime.emplace(aMetadata.mInfo->mStartTime);
160 : }
161 0 : return MetadataPromise::CreateAndResolve(Move(aMetadata), __func__);
162 : }
163 :
164 : RefPtr<MediaDecoderReaderWrapper::MetadataPromise>
165 0 : MediaDecoderReaderWrapper::OnMetadataNotRead(const MediaResult& aError)
166 : {
167 0 : return MetadataPromise::CreateAndReject(aError, __func__);
168 : }
169 :
170 : void
171 0 : MediaDecoderReaderWrapper::SetVideoBlankDecode(bool aIsBlankDecode)
172 : {
173 0 : MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
174 : nsCOMPtr<nsIRunnable> r =
175 0 : NewRunnableMethod<bool>("MediaDecoderReader::SetVideoNullDecode",
176 : mReader,
177 : &MediaDecoderReader::SetVideoNullDecode,
178 0 : aIsBlankDecode);
179 0 : mReader->OwnerThread()->Dispatch(r.forget());
180 0 : }
181 :
182 : void
183 0 : MediaDecoderReaderWrapper::UpdateDuration()
184 : {
185 0 : MOZ_ASSERT(mReader->OwnerThread()->IsCurrentThreadIn());
186 0 : mReader->UpdateDuration(mDuration.Ref().ref());
187 0 : }
188 :
189 : void
190 0 : MediaDecoderReaderWrapper::SetCanonicalDuration(
191 : AbstractCanonical<media::NullableTimeUnit>* aCanonical)
192 : {
193 : using DurationT = AbstractCanonical<media::NullableTimeUnit>;
194 0 : RefPtr<MediaDecoderReaderWrapper> self = this;
195 0 : RefPtr<DurationT> canonical = aCanonical;
196 0 : nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(
197 : "MediaDecoderReaderWrapper::SetCanonicalDuration",
198 0 : [this, self, canonical]() {
199 0 : mDuration.Connect(canonical);
200 0 : mWatchManager.Watch(mDuration,
201 0 : &MediaDecoderReaderWrapper::UpdateDuration);
202 0 : });
203 0 : mReader->OwnerThread()->Dispatch(r.forget());
204 0 : }
205 :
206 : } // namespace mozilla
|
