1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
/* -*- 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 mozilla_dom_ImageDecoder_h
#define mozilla_dom_ImageDecoder_h
#include "FrameTimeout.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/dom/ImageDecoderBinding.h"
#include "mozilla/dom/WebCodecsUtils.h"
#include "mozilla/gfx/Point.h"
#include "mozilla/media/MediaUtils.h"
#include "nsCycleCollectionParticipant.h"
#include "nsWrapperCache.h"
class nsIGlobalObject;
namespace mozilla {
class MediaResult;
namespace image {
class AnonymousDecoder;
class SourceBuffer;
enum class DecoderType;
enum class SurfaceFlags : uint8_t;
struct DecodeFramesResult;
struct DecodeFrameCountResult;
struct DecodeMetadataResult;
} // namespace image
namespace dom {
class Promise;
struct ImageDecoderReadRequest;
class ImageDecoder final : public nsISupports,
public nsWrapperCache,
public media::ShutdownConsumer {
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(ImageDecoder)
public:
ImageDecoder(nsCOMPtr<nsIGlobalObject>&& aParent, const nsAString& aType);
public:
nsIGlobalObject* GetParentObject() const { return mParent; }
JSObject* WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) override;
static already_AddRefed<ImageDecoder> Constructor(
const GlobalObject& aGlobal, const ImageDecoderInit& aInit,
ErrorResult& aRv);
static already_AddRefed<Promise> IsTypeSupported(const GlobalObject& aGlobal,
const nsAString& aType,
ErrorResult& aRv);
void GetType(nsAString& aType) const;
bool Complete() const { return mComplete; }
Promise* Completed() const { return mCompletePromise; }
ImageTrackList* Tracks() const { return mTracks; }
already_AddRefed<Promise> Decode(const ImageDecodeOptions& aOptions,
ErrorResult& aRv);
void Reset();
void Close();
void OnShutdown() override;
void OnSourceBufferComplete(const MediaResult& aResult);
void QueueSelectTrackMessage(uint32_t aSelectedIndex);
void ProcessControlMessageQueue();
private:
~ImageDecoder();
class ControlMessage;
class ConfigureMessage;
class DecodeMetadataMessage;
class DecodeFrameMessage;
class SelectTrackMessage;
std::queue<UniquePtr<ControlMessage>> mControlMessageQueue;
bool mMessageQueueBlocked = false;
bool mTracksEstablished = false;
struct OutstandingDecode {
RefPtr<Promise> mPromise;
uint32_t mFrameIndex = 0;
bool mCompleteFramesOnly = true;
};
// VideoFrame can run on either main thread or worker thread.
void AssertIsOnOwningThread() const { NS_ASSERT_OWNINGTHREAD(ImageDecoder); }
void Initialize(const GlobalObject& aGLobal, const ImageDecoderInit& aInit,
ErrorResult& aRv);
void Destroy();
void Reset(const MediaResult& aResult);
void Close(const MediaResult& aResult);
void QueueConfigureMessage(const Maybe<gfx::IntSize>& aOutputSize,
ColorSpaceConversion aColorSpaceConversion);
void QueueDecodeMetadataMessage();
void QueueDecodeFrameMessage();
void ResumeControlMessageQueue();
MessageProcessedResult ProcessConfigureMessage(ConfigureMessage* aMsg);
MessageProcessedResult ProcessDecodeMetadataMessage(
DecodeMetadataMessage* aMsg);
MessageProcessedResult ProcessDecodeFrameMessage(DecodeFrameMessage* aMsg);
MessageProcessedResult ProcessSelectTrackMessage(SelectTrackMessage* aMsg);
void CheckOutstandingDecodes();
void OnCompleteSuccess();
void OnCompleteFailed(const MediaResult& aResult);
void OnMetadataSuccess(const image::DecodeMetadataResult& aMetadata);
void OnMetadataFailed(const nsresult& aErr);
void RequestFrameCount(uint32_t aKnownFrameCount);
void OnFrameCountSuccess(const image::DecodeFrameCountResult& aResult);
void OnFrameCountFailed(const nsresult& aErr);
void RequestDecodeFrames(uint32_t aFramesToDecode);
void OnDecodeFramesSuccess(const image::DecodeFramesResult& aResult);
void OnDecodeFramesFailed(const nsresult& aErr);
nsCOMPtr<nsIGlobalObject> mParent;
RefPtr<media::ShutdownWatcher> mShutdownWatcher;
RefPtr<ImageTrackList> mTracks;
RefPtr<ImageDecoderReadRequest> mReadRequest;
RefPtr<Promise> mCompletePromise;
RefPtr<image::SourceBuffer> mSourceBuffer;
RefPtr<image::AnonymousDecoder> mDecoder;
AutoTArray<OutstandingDecode, 1> mOutstandingDecodes;
nsAutoString mType;
image::FrameTimeout mFramesTimestamp;
bool mComplete = false;
bool mHasFrameCount = false;
bool mHasFramePending = false;
bool mTypeNotSupported = false;
bool mClosed = false;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_ImageDecoder_h
|
