blob: 7021c3c7dcaede4d82a1d3bdc5f934ca86a01959 [file] [log] [blame]
niklase@google.com470e71d2011-07-07 08:21:25 +00001/*
leozwang@webrtc.org39e96592012-03-01 18:22:48 +00002 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
niklase@google.com470e71d2011-07-07 08:21:25 +00003 *
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
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#ifndef VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_
12#define VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_
niklase@google.com470e71d2011-07-07 08:21:25 +000013
Benjamin Wright52426ed2019-03-01 11:01:59 -080014#include <atomic>
pwestin@webrtc.org1da1ce02011-10-13 15:19:55 +000015#include <list>
philipelfd5a20f2016-11-15 00:57:57 -080016#include <map>
kwiberg27f982b2016-03-01 11:52:33 -080017#include <memory>
Peter Boström9c017252016-02-26 16:26:20 +010018#include <string>
kjellander@webrtc.org0fcaf992015-11-26 15:24:52 +010019#include <vector>
pwestin@webrtc.org1da1ce02011-10-13 15:19:55 +000020
Niels Möller2ff1f2a2018-08-09 16:16:34 +020021#include "absl/types/optional.h"
Danil Chapovalovc71d85b2019-10-16 19:18:21 +020022#include "api/array_view.h"
Steve Anton10542f22019-01-11 09:11:00 -080023#include "api/crypto/frame_decryptor_interface.h"
Johannes Krond0b69a82018-12-03 14:18:53 +010024#include "api/video/color_space.h"
Niels Möller2ff1f2a2018-08-09 16:16:34 +020025#include "api/video_codecs/video_codec.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020026#include "call/rtp_packet_sink_interface.h"
Niels Möllerdf9e9ae2018-07-31 08:29:53 +020027#include "call/syncable.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020028#include "call/video_receive_stream.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020029#include "modules/rtp_rtcp/include/receive_statistics.h"
30#include "modules/rtp_rtcp/include/remote_ntp_time_estimator.h"
Niels Möllerb0573bc2017-09-25 10:47:00 +020031#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020032#include "modules/rtp_rtcp/include/rtp_rtcp.h"
33#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
Danil Chapovalovc71d85b2019-10-16 19:18:21 +020034#include "modules/rtp_rtcp/source/rtp_packet_received.h"
35#include "modules/rtp_rtcp/source/rtp_video_header.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020036#include "modules/video_coding/h264_sps_pps_tracker.h"
Elad Alon7d6a4c02019-02-25 13:00:51 +010037#include "modules/video_coding/loss_notification_controller.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020038#include "modules/video_coding/packet_buffer.h"
39#include "modules/video_coding/rtp_frame_reference_finder.h"
Danil Chapovalov09860e02019-10-30 14:12:24 +010040#include "modules/video_coding/unique_timestamp_counter.h"
Steve Anton10542f22019-01-11 09:11:00 -080041#include "rtc_base/constructor_magic.h"
42#include "rtc_base/critical_section.h"
Bjorn Tereliusa194e582017-10-25 13:07:09 +020043#include "rtc_base/numerics/sequence_number_util.h"
Sebastian Janssonb55015e2019-04-09 13:44:04 +020044#include "rtc_base/synchronization/sequence_checker.h"
Benjamin Wright00765292018-11-30 16:18:26 -080045#include "rtc_base/thread_annotations.h"
46#include "rtc_base/thread_checker.h"
47#include "video/buffered_frame_decryptor.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000048
mflodman@webrtc.orgad4ee362011-11-28 22:39:24 +000049namespace webrtc {
niklase@google.com470e71d2011-07-07 08:21:25 +000050
philipelfd5a20f2016-11-15 00:57:57 -080051class NackModule;
mflodmanc0e58a32016-04-25 01:26:26 -070052class PacketRouter;
mflodmandc7d0d22016-05-06 05:32:22 -070053class ProcessThread;
wu@webrtc.org822fbd82013-08-15 23:38:54 +000054class ReceiveStatistics;
mflodmancfc8e3b2016-05-03 21:22:04 -070055class ReceiveStatisticsProxy;
mflodmanc0e58a32016-04-25 01:26:26 -070056class RtcpRttStats;
nisse38cc1d62017-02-13 05:59:46 -080057class RtpPacketReceived;
mflodmanc0e58a32016-04-25 01:26:26 -070058class Transport;
brandtrd55c3f62016-10-31 04:51:33 -070059class UlpfecReceiver;
Peter Boström0b250722016-04-22 18:23:15 +020060
Elad Alon7d6a4c02019-02-25 13:00:51 +010061class RtpVideoStreamReceiver : public LossNotificationSender,
62 public RecoveredPacketReceiver,
nisse0f15f922017-06-21 01:05:22 -070063 public RtpPacketSinkInterface,
Niels Möller479c0552019-05-23 16:57:01 +020064 public KeyFrameRequestSender,
Benjamin Wright00765292018-11-30 16:18:26 -080065 public video_coding::OnCompleteFrameCallback,
Benjamin Wright52426ed2019-03-01 11:01:59 -080066 public OnDecryptedFrameCallback,
67 public OnDecryptionStatusChangeCallback {
mflodman@webrtc.orgad4ee362011-11-28 22:39:24 +000068 public:
nisseb1f2ff92017-06-09 04:01:55 -070069 RtpVideoStreamReceiver(
Sebastian Jansson8026d602019-03-04 19:39:01 +010070 Clock* clock,
philipelfd5a20f2016-11-15 00:57:57 -080071 Transport* transport,
72 RtcpRttStats* rtt_stats,
Niels Möller60f4e292019-05-20 11:06:33 +020073 // The packet router is optional; if provided, the RtpRtcp module for this
74 // stream is registered as a candidate for sending REMB and transport
75 // feedback.
philipelfd5a20f2016-11-15 00:57:57 -080076 PacketRouter* packet_router,
philipelfd5a20f2016-11-15 00:57:57 -080077 const VideoReceiveStream::Config* config,
nisseca5706d2017-09-11 02:32:16 -070078 ReceiveStatistics* rtp_receive_statistics,
philipelfd5a20f2016-11-15 00:57:57 -080079 ReceiveStatisticsProxy* receive_stats_proxy,
80 ProcessThread* process_thread,
philipelfd5a20f2016-11-15 00:57:57 -080081 NackSender* nack_sender,
Niels Möller2f5554d2019-05-29 13:35:14 +020082 // The KeyFrameRequestSender is optional; if not provided, key frame
83 // requests are sent via the internal RtpRtcp module.
84 KeyFrameRequestSender* keyframe_request_sender,
Benjamin Wright192eeec2018-10-17 17:27:25 -070085 video_coding::OnCompleteFrameCallback* complete_frame_callback,
86 rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor);
Mirko Bonadei8fdcac32018-08-28 16:30:18 +020087 ~RtpVideoStreamReceiver() override;
niklase@google.com470e71d2011-07-07 08:21:25 +000088
Niels Möller2ff1f2a2018-08-09 16:16:34 +020089 void AddReceiveCodec(const VideoCodec& video_codec,
Mirta Dvornicicfe68daa2019-05-23 13:21:12 +020090 const std::map<std::string, std::string>& codec_params,
91 bool raw_payload);
wu@webrtc.org822fbd82013-08-15 23:38:54 +000092
mflodman@webrtc.orgad4ee362011-11-28 22:39:24 +000093 void StartReceive();
94 void StopReceive();
niklase@google.com470e71d2011-07-07 08:21:25 +000095
Niels Möllerdf9e9ae2018-07-31 08:29:53 +020096 // Produces the transport-related timestamps; current_delay_ms is left unset.
97 absl::optional<Syncable::Info> GetSyncInfo() const;
98
Peter Boströmd1d66ba2016-02-08 14:07:14 +010099 bool DeliverRtcp(const uint8_t* rtcp_packet, size_t rtcp_packet_length);
niklase@google.com470e71d2011-07-07 08:21:25 +0000100
philipeld4fac692017-09-04 07:03:46 -0700101 void FrameContinuous(int64_t seq_num);
philipelfd5a20f2016-11-15 00:57:57 -0800102
philipeld4fac692017-09-04 07:03:46 -0700103 void FrameDecoded(int64_t seq_num);
philipelfd5a20f2016-11-15 00:57:57 -0800104
mflodmandc7d0d22016-05-06 05:32:22 -0700105 void SignalNetworkState(NetworkState state);
106
Danil Chapovalov09860e02019-10-30 14:12:24 +0100107 // Returns number of different frames seen.
108 int GetUniqueFramesSeen() const {
109 RTC_DCHECK_RUN_ON(&worker_task_checker_);
110 return frame_counter_.GetUniqueSeen();
111 }
Ilya Nikolaevskiyd397a0d2018-02-21 15:57:09 +0100112
nisse0f15f922017-06-21 01:05:22 -0700113 // Implements RtpPacketSinkInterface.
114 void OnRtpPacket(const RtpPacketReceived& packet) override;
nisse38cc1d62017-02-13 05:59:46 -0800115
philipel2837edc2018-10-02 13:55:47 +0200116 // TODO(philipel): Stop using VCMPacket in the new jitter buffer and then
Niels Möller125b5d62019-03-11 16:11:07 +0100117 // remove this function. Public only for tests.
Danil Chapovalovc71d85b2019-10-16 19:18:21 +0200118 void OnReceivedPayloadData(rtc::ArrayView<const uint8_t> codec_payload,
119 const RtpPacketReceived& rtp_packet,
120 const RTPVideoHeader& video);
philipel2837edc2018-10-02 13:55:47 +0200121
nisse30e89312017-05-29 08:16:37 -0700122 // Implements RecoveredPacketReceiver.
123 void OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override;
niklase@google.com470e71d2011-07-07 08:21:25 +0000124
Niels Möller41684372019-03-25 15:51:03 +0100125 // Send an RTCP keyframe request.
Niels Möller479c0552019-05-23 16:57:01 +0200126 void RequestKeyFrame() override;
mflodmancfc8e3b2016-05-03 21:22:04 -0700127
Elad Alon7d6a4c02019-02-25 13:00:51 +0100128 // Implements LossNotificationSender.
129 void SendLossNotification(uint16_t last_decoded_seq_num,
130 uint16_t last_received_seq_num,
Elad Alone86af2c2019-06-03 14:37:50 +0200131 bool decodability_flag,
132 bool buffering_allowed) override;
Elad Alon7d6a4c02019-02-25 13:00:51 +0100133
brandtrf7c6d722016-12-08 08:25:47 -0800134 bool IsUlpfecEnabled() const;
mflodmandc7d0d22016-05-06 05:32:22 -0700135 bool IsRetransmissionsEnabled() const;
Benjamin Wright52426ed2019-03-01 11:01:59 -0800136
137 // Returns true if a decryptor is attached and frames can be decrypted.
138 // Updated by OnDecryptionStatusChangeCallback. Note this refers to Frame
139 // Decryption not SRTP.
140 bool IsDecryptable() const;
141
mflodmandc7d0d22016-05-06 05:32:22 -0700142 // Don't use, still experimental.
143 void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
144
philipelfd5a20f2016-11-15 00:57:57 -0800145 // Implements OnCompleteFrameCallback.
146 void OnCompleteFrame(
philipele7c891f2018-02-22 14:35:06 +0100147 std::unique_ptr<video_coding::EncodedFrame> frame) override;
philipelfd5a20f2016-11-15 00:57:57 -0800148
Benjamin Wright00765292018-11-30 16:18:26 -0800149 // Implements OnDecryptedFrameCallback.
150 void OnDecryptedFrame(
151 std::unique_ptr<video_coding::RtpFrameObject> frame) override;
152
Benjamin Wright52426ed2019-03-01 11:01:59 -0800153 // Implements OnDecryptionStatusChangeCallback.
Benjamin Wright2af5dcb2019-04-09 20:08:41 +0000154 void OnDecryptionStatusChange(
155 FrameDecryptorInterface::Status status) override;
Benjamin Wright52426ed2019-03-01 11:01:59 -0800156
Benjamin Wrighta5564482019-04-03 10:44:18 -0700157 // Optionally set a frame decryptor after a stream has started. This will not
158 // reset the decoder state.
159 void SetFrameDecryptor(
160 rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor);
161
Tommi81de14f2018-03-25 22:19:25 +0200162 // Called by VideoReceiveStream when stats are updated.
163 void UpdateRtt(int64_t max_rtt_ms);
philipelfd5a20f2016-11-15 00:57:57 -0800164
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200165 absl::optional<int64_t> LastReceivedPacketMs() const;
166 absl::optional<int64_t> LastReceivedKeyframePacketMs() const;
philipel3184f8e2017-05-18 08:08:53 -0700167
eladalonc0d481a2017-08-02 07:39:07 -0700168 // RtpDemuxer only forwards a given RTP packet to one sink. However, some
169 // sinks, such as FlexFEC, might wish to be informed of all of the packets
170 // a given sink receives (or any set of sinks). They may do so by registering
171 // themselves as secondary sinks.
172 void AddSecondarySink(RtpPacketSinkInterface* sink);
173 void RemoveSecondarySink(const RtpPacketSinkInterface* sink);
174
mflodman@webrtc.orgad4ee362011-11-28 22:39:24 +0000175 private:
Elad Alonef09c5b2019-05-31 13:25:50 +0200176 // Used for buffering RTCP feedback messages and sending them all together.
177 // Note:
178 // 1. Key frame requests and NACKs are mutually exclusive, with the
179 // former taking precedence over the latter.
180 // 2. Loss notifications are orthogonal to either. (That is, may be sent
181 // alongside either.)
182 class RtcpFeedbackBuffer : public KeyFrameRequestSender,
183 public NackSender,
184 public LossNotificationSender {
185 public:
186 RtcpFeedbackBuffer(KeyFrameRequestSender* key_frame_request_sender,
187 NackSender* nack_sender,
188 LossNotificationSender* loss_notification_sender);
189
190 ~RtcpFeedbackBuffer() override = default;
191
192 // KeyFrameRequestSender implementation.
193 void RequestKeyFrame() override;
194
195 // NackSender implementation.
Elad Alonef09c5b2019-05-31 13:25:50 +0200196 void SendNack(const std::vector<uint16_t>& sequence_numbers,
197 bool buffering_allowed) override;
198
199 // LossNotificationSender implementation.
200 void SendLossNotification(uint16_t last_decoded_seq_num,
201 uint16_t last_received_seq_num,
Elad Alone86af2c2019-06-03 14:37:50 +0200202 bool decodability_flag,
203 bool buffering_allowed) override;
Elad Alonef09c5b2019-05-31 13:25:50 +0200204
205 // Send all RTCP feedback messages buffered thus far.
206 void SendBufferedRtcpFeedback();
207
208 private:
209 KeyFrameRequestSender* const key_frame_request_sender_;
210 NackSender* const nack_sender_;
211 LossNotificationSender* const loss_notification_sender_;
212
213 // NACKs are accessible from two threads due to nack_module_ being a module.
214 rtc::CriticalSection cs_;
215
216 // Key-frame-request-related state.
217 bool request_key_frame_ RTC_GUARDED_BY(cs_);
218
219 // NACK-related state.
220 std::vector<uint16_t> nack_sequence_numbers_ RTC_GUARDED_BY(cs_);
221
222 // LNTF-related state.
223 struct LossNotificationState {
224 LossNotificationState(uint16_t last_decoded_seq_num,
225 uint16_t last_received_seq_num,
226 bool decodability_flag)
227 : last_decoded_seq_num(last_decoded_seq_num),
228 last_received_seq_num(last_received_seq_num),
229 decodability_flag(decodability_flag) {}
230
231 uint16_t last_decoded_seq_num;
232 uint16_t last_received_seq_num;
233 bool decodability_flag;
234 };
235 absl::optional<LossNotificationState> lntf_state_ RTC_GUARDED_BY(cs_);
236 };
237
Niels Möller2ff1f2a2018-08-09 16:16:34 +0200238 // Entry point doing non-stats work for a received packet. Called
239 // for the same packet both before and after RED decapsulation.
240 void ReceivePacket(const RtpPacketReceived& packet);
241 // Parses and handles RED headers.
stefan@webrtc.org7bb8f022013-09-06 13:40:11 +0000242 // This function assumes that it's being called from only one thread.
Niels Möller1f3206c2018-09-14 08:26:32 +0200243 void ParseAndHandleEncapsulatingHeader(const RtpPacketReceived& packet);
Niels Möllerbc010472018-03-23 13:22:29 +0100244 void NotifyReceiverOfEmptyPacket(uint16_t seq_num);
asapersson@webrtc.org0800db72015-01-15 07:40:20 +0000245 void UpdateHistograms();
brandtre6f98c72016-11-11 03:28:30 -0800246 bool IsRedEnabled() const;
philipel022b54e2016-12-20 04:15:59 -0800247 void InsertSpsPpsIntoTracker(uint8_t payload_type);
Danil Chapovalovce1ffcd2019-10-22 17:12:42 +0200248 void OnInsertedPacket(video_coding::PacketBuffer::InsertResult result);
249 void OnAssembledFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
niklase@google.com470e71d2011-07-07 08:21:25 +0000250
Peter Boström4fa7eca2016-03-02 15:05:53 +0100251 Clock* const clock_;
Tommi733b5472016-06-10 17:58:01 +0200252 // Ownership of this object lies with VideoReceiveStream, which owns |this|.
253 const VideoReceiveStream::Config& config_;
mflodmanc0e58a32016-04-25 01:26:26 -0700254 PacketRouter* const packet_router_;
mflodmandc7d0d22016-05-06 05:32:22 -0700255 ProcessThread* const process_thread_;
Peter Boström4fa7eca2016-03-02 15:05:53 +0100256
257 RemoteNtpTimeEstimator ntp_estimator_;
Peter Boström4fa7eca2016-03-02 15:05:53 +0100258
Niels Möllerb0573bc2017-09-25 10:47:00 +0200259 RtpHeaderExtensionMap rtp_header_extensions_;
nisseca5706d2017-09-11 02:32:16 -0700260 ReceiveStatistics* const rtp_receive_statistics_;
brandtrd55c3f62016-10-31 04:51:33 -0700261 std::unique_ptr<UlpfecReceiver> ulpfec_receiver_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000262
Sebastian Janssonb55015e2019-04-09 13:44:04 +0200263 SequenceChecker worker_task_checker_;
danilchapa37de392017-09-09 04:17:22 -0700264 bool receiving_ RTC_GUARDED_BY(worker_task_checker_);
danilchapa37de392017-09-09 04:17:22 -0700265 int64_t last_packet_log_ms_ RTC_GUARDED_BY(worker_task_checker_);
mflodmanc0e58a32016-04-25 01:26:26 -0700266
267 const std::unique_ptr<RtpRtcp> rtp_rtcp_;
philipelfd5a20f2016-11-15 00:57:57 -0800268
philipelfd5a20f2016-11-15 00:57:57 -0800269 video_coding::OnCompleteFrameCallback* complete_frame_callback_;
Niels Möller2f5554d2019-05-29 13:35:14 +0200270 KeyFrameRequestSender* const keyframe_request_sender_;
Elad Alonef09c5b2019-05-31 13:25:50 +0200271
272 RtcpFeedbackBuffer rtcp_feedback_buffer_;
philipelfd5a20f2016-11-15 00:57:57 -0800273 std::unique_ptr<NackModule> nack_module_;
Elad Alon7d6a4c02019-02-25 13:00:51 +0100274 std::unique_ptr<LossNotificationController> loss_notification_controller_;
Elad Alonef09c5b2019-05-31 13:25:50 +0200275
Danil Chapovalovf7457e52019-09-20 17:57:15 +0200276 video_coding::PacketBuffer packet_buffer_;
Danil Chapovalov09860e02019-10-30 14:12:24 +0100277 UniqueTimestampCounter frame_counter_ RTC_GUARDED_BY(worker_task_checker_);
philipel7acc4a42019-09-26 11:25:52 +0200278
279 rtc::CriticalSection reference_finder_lock_;
280 std::unique_ptr<video_coding::RtpFrameReferenceFinder> reference_finder_
281 RTC_GUARDED_BY(reference_finder_lock_);
282 absl::optional<VideoCodecType> current_codec_;
283 uint32_t last_assembled_frame_rtp_timestamp_;
284
philipelfd5a20f2016-11-15 00:57:57 -0800285 rtc::CriticalSection last_seq_num_cs_;
philipeld4fac692017-09-04 07:03:46 -0700286 std::map<int64_t, uint16_t> last_seq_num_for_pic_id_
danilchapa37de392017-09-09 04:17:22 -0700287 RTC_GUARDED_BY(last_seq_num_cs_);
philipelfd5a20f2016-11-15 00:57:57 -0800288 video_coding::H264SpsPpsTracker tracker_;
Niels Möller2ff1f2a2018-08-09 16:16:34 +0200289
Mirta Dvornicicfe68daa2019-05-23 13:21:12 +0200290 // Maps payload type to codec type, for packetization.
291 std::map<uint8_t, absl::optional<VideoCodecType>> payload_type_map_;
292
philipel022b54e2016-12-20 04:15:59 -0800293 // TODO(johan): Remove pt_codec_params_ once
294 // https://bugs.chromium.org/p/webrtc/issues/detail?id=6883 is resolved.
295 // Maps a payload type to a map of out-of-band supplied codec parameters.
296 std::map<uint8_t, std::map<std::string, std::string>> pt_codec_params_;
297 int16_t last_payload_type_ = -1;
philipel2c53b132017-05-16 08:06:30 -0700298
299 bool has_received_frame_;
eladalonc0d481a2017-08-02 07:39:07 -0700300
eladalon8b073052017-08-25 00:49:08 -0700301 std::vector<RtpPacketSinkInterface*> secondary_sinks_
danilchapa37de392017-09-09 04:17:22 -0700302 RTC_GUARDED_BY(worker_task_checker_);
Jonas Oreland49ac5952018-09-26 16:04:32 +0200303
Chen Xing90f3b892019-06-25 10:16:14 +0200304 // Info for GetSyncInfo is updated on network or worker thread, and queried on
305 // the worker thread.
306 rtc::CriticalSection sync_info_lock_;
Jonas Oreland49ac5952018-09-26 16:04:32 +0200307 absl::optional<uint32_t> last_received_rtp_timestamp_
Chen Xing90f3b892019-06-25 10:16:14 +0200308 RTC_GUARDED_BY(sync_info_lock_);
Jonas Oreland49ac5952018-09-26 16:04:32 +0200309 absl::optional<int64_t> last_received_rtp_system_time_ms_
Chen Xing90f3b892019-06-25 10:16:14 +0200310 RTC_GUARDED_BY(sync_info_lock_);
Benjamin Wright192eeec2018-10-17 17:27:25 -0700311
Benjamin Wright00765292018-11-30 16:18:26 -0800312 // Used to validate the buffered frame decryptor is always run on the correct
313 // thread.
314 rtc::ThreadChecker network_tc_;
315 // Handles incoming encrypted frames and forwards them to the
316 // rtp_reference_finder if they are decryptable.
317 std::unique_ptr<BufferedFrameDecryptor> buffered_frame_decryptor_
318 RTC_PT_GUARDED_BY(network_tc_);
Benjamin Wright52426ed2019-03-01 11:01:59 -0800319 std::atomic<bool> frames_decryptable_;
Johannes Krond0b69a82018-12-03 14:18:53 +0100320 absl::optional<ColorSpace> last_color_space_;
philipel7acc4a42019-09-26 11:25:52 +0200321
Ilya Nikolaevskiy815e00c2019-11-12 15:20:21 +0000322 int64_t last_completed_picture_id_ = 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000323};
mflodman@webrtc.orgad4ee362011-11-28 22:39:24 +0000324
kjellander@webrtc.org0fcaf992015-11-26 15:24:52 +0100325} // namespace webrtc
mflodman@webrtc.orgad4ee362011-11-28 22:39:24 +0000326
Mirko Bonadei92ea95e2017-09-15 06:47:31 +0200327#endif // VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_