• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #ifndef API_VIDEO_CODECS_VIDEO_CODEC_H_
12 #define API_VIDEO_CODECS_VIDEO_CODEC_H_
13 
14 #include <stddef.h>
15 #include <stdint.h>
16 
17 #include <string>
18 
19 #include "absl/types/optional.h"
20 #include "api/video/video_bitrate_allocation.h"
21 #include "api/video/video_codec_type.h"
22 #include "common_types.h"  // NOLINT(build/include_directory)
23 #include "rtc_base/system/rtc_export.h"
24 
25 namespace webrtc {
26 
27 // The VideoCodec class represents an old defacto-apis, which we're migrating
28 // away from slowly.
29 
30 // Video codec
31 enum class VideoCodecComplexity {
32   kComplexityNormal = 0,
33   kComplexityHigh = 1,
34   kComplexityHigher = 2,
35   kComplexityMax = 3
36 };
37 
38 // VP8 specific
39 struct VideoCodecVP8 {
40   bool operator==(const VideoCodecVP8& other) const;
41   bool operator!=(const VideoCodecVP8& other) const {
42     return !(*this == other);
43   }
44   VideoCodecComplexity complexity;
45   unsigned char numberOfTemporalLayers;
46   bool denoisingOn;
47   bool automaticResizeOn;
48   bool frameDroppingOn;
49   int keyFrameInterval;
50 };
51 
52 enum class InterLayerPredMode : int {
53   kOff = 0,      // Inter-layer prediction is disabled.
54   kOn = 1,       // Inter-layer prediction is enabled.
55   kOnKeyPic = 2  // Inter-layer prediction is enabled but limited to key frames.
56 };
57 
58 // VP9 specific.
59 struct VideoCodecVP9 {
60   bool operator==(const VideoCodecVP9& other) const;
61   bool operator!=(const VideoCodecVP9& other) const {
62     return !(*this == other);
63   }
64   VideoCodecComplexity complexity;
65   unsigned char numberOfTemporalLayers;
66   bool denoisingOn;
67   bool frameDroppingOn;
68   int keyFrameInterval;
69   bool adaptiveQpMode;
70   bool automaticResizeOn;
71   unsigned char numberOfSpatialLayers;
72   bool flexibleMode;
73   InterLayerPredMode interLayerPred;
74 };
75 
76 // H264 specific.
77 struct VideoCodecH264 {
78   bool operator==(const VideoCodecH264& other) const;
79   bool operator!=(const VideoCodecH264& other) const {
80     return !(*this == other);
81   }
82   bool frameDroppingOn;
83   int keyFrameInterval;
84   uint8_t numberOfTemporalLayers;
85 };
86 
87 // Translates from name of codec to codec type and vice versa.
88 RTC_EXPORT const char* CodecTypeToPayloadString(VideoCodecType type);
89 RTC_EXPORT VideoCodecType PayloadStringToCodecType(const std::string& name);
90 
91 union VideoCodecUnion {
92   VideoCodecVP8 VP8;
93   VideoCodecVP9 VP9;
94   VideoCodecH264 H264;
95 };
96 
97 enum class VideoCodecMode { kRealtimeVideo, kScreensharing };
98 
99 // Common video codec properties
100 class RTC_EXPORT VideoCodec {
101  public:
102   VideoCodec();
103 
104   // Public variables. TODO(hta): Make them private with accessors.
105   VideoCodecType codecType;
106   unsigned char plType;
107 
108   // TODO(nisse): Change to int, for consistency.
109   uint16_t width;
110   uint16_t height;
111 
112   unsigned int startBitrate;  // kilobits/sec.
113   unsigned int maxBitrate;    // kilobits/sec.
114   unsigned int minBitrate;    // kilobits/sec.
115 
116   uint32_t maxFramerate;
117 
118   // This enables/disables encoding and sending when there aren't multiple
119   // simulcast streams,by allocating 0 bitrate if inactive.
120   bool active;
121 
122   unsigned int qpMax;
123   unsigned char numberOfSimulcastStreams;
124   SimulcastStream simulcastStream[kMaxSimulcastStreams];
125   SpatialLayer spatialLayers[kMaxSpatialLayers];
126 
127   VideoCodecMode mode;
128   bool expect_encode_from_texture;
129 
130   // The size of pool which is used to store video frame buffers inside decoder.
131   // If value isn't present some codec-default value will be used.
132   // If value is present and decoder doesn't have buffer pool the
133   // value will be ignored.
134   absl::optional<int> buffer_pool_size;
135 
136   // Timing frames configuration. There is delay of delay_ms between two
137   // consequent timing frames, excluding outliers. Frame is always made a
138   // timing frame if it's at least outlier_ratio in percent of "ideal" average
139   // frame given bitrate and framerate, i.e. if it's bigger than
140   // |outlier_ratio / 100.0 * bitrate_bps / fps| in bits. This way, timing
141   // frames will not be sent too often usually. Yet large frames will always
142   // have timing information for debug purposes because they are more likely to
143   // cause extra delays.
144   struct TimingFrameTriggerThresholds {
145     int64_t delay_ms;
146     uint16_t outlier_ratio_percent;
147   } timing_frame_thresholds;
148 
149   bool operator==(const VideoCodec& other) const = delete;
150   bool operator!=(const VideoCodec& other) const = delete;
151 
152   // Accessors for codec specific information.
153   // There is a const version of each that returns a reference,
154   // and a non-const version that returns a pointer, in order
155   // to allow modification of the parameters.
156   VideoCodecVP8* VP8();
157   const VideoCodecVP8& VP8() const;
158   VideoCodecVP9* VP9();
159   const VideoCodecVP9& VP9() const;
160   VideoCodecH264* H264();
161   const VideoCodecH264& H264() const;
162 
163  private:
164   // TODO(hta): Consider replacing the union with a pointer type.
165   // This will allow removing the VideoCodec* types from this file.
166   VideoCodecUnion codec_specific_;
167 };
168 
169 }  // namespace webrtc
170 #endif  // API_VIDEO_CODECS_VIDEO_CODEC_H_
171