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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/* -*- 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_EncoderConfig_h_
#define mozilla_EncoderConfig_h_
#include "mozilla/dom/ImageBitmapBinding.h"
#include "H264.h"
namespace mozilla {
enum class CodecType {
_BeginVideo_,
H264,
VP8,
VP9,
AV1,
_EndVideo_,
_BeginAudio_ = _EndVideo_,
Opus,
Vorbis,
Flac,
AAC,
PCM,
G722,
_EndAudio_,
Unknown,
};
enum class Usage {
Realtime, // Low latency prefered
Record
};
enum class BitrateMode { Constant, Variable };
// Scalable Video Coding (SVC) settings for WebCodecs:
// https://www.w3.org/TR/webrtc-svc/
enum class ScalabilityMode { None, L1T2, L1T3 };
enum class HardwarePreference { RequireHardware, RequireSoftware, None };
// TODO: Automatically generate this (Bug 1865896)
const char* GetCodecTypeString(const CodecType& aCodecType);
enum class H264BitStreamFormat { AVC, ANNEXB };
struct H264Specific final {
const H264_PROFILE mProfile;
const H264_LEVEL mLevel;
const H264BitStreamFormat mFormat;
H264Specific(H264_PROFILE aProfile, H264_LEVEL aLevel,
H264BitStreamFormat aFormat)
: mProfile(aProfile), mLevel(aLevel), mFormat(aFormat) {}
};
enum class OpusBitstreamFormat { Opus, OGG };
// The default values come from the Web Codecs specification.
struct OpusSpecific final {
enum class Application { Unspecified, Voip, Audio, RestricedLowDelay };
Application mApplication = Application::Unspecified;
uint64_t mFrameDuration = 20000; // microseconds
uint8_t mComplexity = 10; // 0-10
OpusBitstreamFormat mFormat = OpusBitstreamFormat::Opus;
uint64_t mPacketLossPerc = 0; // 0-100
bool mUseInBandFEC = false;
bool mUseDTX = false;
};
enum class VPXComplexity { Normal, High, Higher, Max };
struct VP8Specific {
VP8Specific() = default;
// Ignore webrtc::VideoCodecVP8::errorConcealmentOn,
// for it's always false in the codebase (except libwebrtc test cases).
VP8Specific(const VPXComplexity aComplexity, const bool aResilience,
const uint8_t aNumTemporalLayers, const bool aDenoising,
const bool aAutoResize, const bool aFrameDropping)
: mComplexity(aComplexity),
mResilience(aResilience),
mNumTemporalLayers(aNumTemporalLayers),
mDenoising(aDenoising),
mAutoResize(aAutoResize),
mFrameDropping(aFrameDropping) {}
const VPXComplexity mComplexity{VPXComplexity::Normal};
const bool mResilience{true};
const uint8_t mNumTemporalLayers{1};
const bool mDenoising{true};
const bool mAutoResize{false};
const bool mFrameDropping{false};
};
struct VP9Specific : public VP8Specific {
VP9Specific() = default;
VP9Specific(const VPXComplexity aComplexity, const bool aResilience,
const uint8_t aNumTemporalLayers, const bool aDenoising,
const bool aAutoResize, const bool aFrameDropping,
const bool aAdaptiveQp, const uint8_t aNumSpatialLayers,
const bool aFlexible)
: VP8Specific(aComplexity, aResilience, aNumTemporalLayers, aDenoising,
aAutoResize, aFrameDropping),
mAdaptiveQp(aAdaptiveQp),
mNumSpatialLayers(aNumSpatialLayers),
mFlexible(aFlexible) {}
const bool mAdaptiveQp{true};
const uint8_t mNumSpatialLayers{1};
const bool mFlexible{false};
};
// A class that holds the intial configuration of an encoder. For simplicity,
// this is used for both audio and video encoding. Members irrelevant to the
// instance are to be ignored, and are set at their default value.
class EncoderConfig final {
public:
using PixelFormat = dom::ImageBitmapFormat;
using CodecSpecific =
Variant<H264Specific, OpusSpecific, VP8Specific, VP9Specific>;
EncoderConfig(const EncoderConfig& aConfig) = default;
// This constructor is used for video encoders
EncoderConfig(const CodecType aCodecType, gfx::IntSize aSize,
const Usage aUsage, const PixelFormat aPixelFormat,
const PixelFormat aSourcePixelFormat, const uint8_t aFramerate,
const size_t aKeyframeInterval, const uint32_t aBitrate,
const BitrateMode aBitrateMode,
const HardwarePreference aHardwarePreference,
const ScalabilityMode aScalabilityMode,
const Maybe<CodecSpecific>& aCodecSpecific)
: mCodec(aCodecType),
mSize(aSize),
mBitrateMode(aBitrateMode),
mBitrate(aBitrate),
mUsage(aUsage),
mHardwarePreference(aHardwarePreference),
mPixelFormat(aPixelFormat),
mSourcePixelFormat(aSourcePixelFormat),
mScalabilityMode(aScalabilityMode),
mFramerate(aFramerate),
mKeyframeInterval(aKeyframeInterval),
mCodecSpecific(aCodecSpecific) {
MOZ_ASSERT(IsVideo());
}
// This constructor is used for audio encoders
EncoderConfig(const CodecType aCodecType, uint32_t aNumberOfChannels,
const BitrateMode aBitrateMode, uint32_t aSampleRate,
uint32_t aBitrate, const Maybe<CodecSpecific>& aCodecSpecific)
: mCodec(aCodecType),
mBitrateMode(aBitrateMode),
mBitrate(aBitrate),
mNumberOfChannels(aNumberOfChannels),
mSampleRate(aSampleRate),
mCodecSpecific(aCodecSpecific) {
MOZ_ASSERT(IsAudio());
}
static CodecType CodecTypeForMime(const nsACString& aMimeType);
nsCString ToString() const;
bool IsVideo() const {
return mCodec > CodecType::_BeginVideo_ && mCodec < CodecType::_EndVideo_;
}
bool IsAudio() const {
return mCodec > CodecType::_BeginAudio_ && mCodec < CodecType::_EndAudio_;
}
CodecType mCodec{};
gfx::IntSize mSize{};
BitrateMode mBitrateMode{};
uint32_t mBitrate{};
Usage mUsage{};
// Video-only
HardwarePreference mHardwarePreference{};
PixelFormat mPixelFormat{};
PixelFormat mSourcePixelFormat{};
ScalabilityMode mScalabilityMode{};
uint8_t mFramerate{};
size_t mKeyframeInterval{};
// Audio-only
uint32_t mNumberOfChannels{};
uint32_t mSampleRate{};
Maybe<CodecSpecific> mCodecSpecific{};
};
} // namespace mozilla
#endif // mozilla_EncoderConfig_h_
|
