From 5f14f9e6edbc4145f6b3358d60a01a31c2ac390a Mon Sep 17 00:00:00 2001 From: Tony Herre Date: Fri, 25 Aug 2023 14:53:44 +0200 Subject: [PATCH] Remove VCMEncodedFrame from webrtc::EncodedFrame inheritance MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Remove VCMEncodedFrame from the inheritance chain of EncodedFrames by - moving getters for EncodedImage fields up to EncodedImage - copying other non-deprecated fields & Methods from VCMEncodedFrame over to EncodedFrame - Removing EncodedFrame's inheritance of VCMEncodedFrame We leave VCMEncodedFrame as part of the (near) deprecated VideoCodingModule code. The only place which needs to accept either is in the generic decoder. Bug: webrtc:9378, b:296992877 Change-Id: I60706aebbb6eacc7fd4b35ec90cc903efdbe14c8 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/317160 Reviewed-by: Åsa Persson Auto-Submit: Tony Herre Commit-Queue: Tony Herre Reviewed-by: Philip Eliasson Cr-Commit-Position: refs/heads/main@{#40639} --- api/video/BUILD.gn | 5 +- api/video/DEPS | 10 +- api/video/encoded_frame.cc | 97 +++++++++++++++++++ api/video/encoded_frame.h | 45 ++++++++- api/video/encoded_image.h | 10 ++ modules/video_coding/decoder_database.cc | 4 +- modules/video_coding/decoder_database.h | 6 +- modules/video_coding/encoded_frame.h | 23 ----- modules/video_coding/generic_decoder.cc | 20 +++- modules/video_coding/generic_decoder.h | 8 ++ .../video_coding/generic_decoder_unittest.cc | 14 +-- modules/video_coding/video_receiver2.cc | 3 +- modules/video_coding/video_receiver2.h | 4 +- video/BUILD.gn | 1 + video/video_stream_buffer_controller.h | 1 + 15 files changed, 195 insertions(+), 56 deletions(-) diff --git a/api/video/BUILD.gn b/api/video/BUILD.gn index ae29d8eaa7..807fdcc3a9 100644 --- a/api/video/BUILD.gn +++ b/api/video/BUILD.gn @@ -170,7 +170,10 @@ rtc_library("encoded_frame") { ] deps = [ - "../../modules/video_coding:encoded_frame", + ":encoded_image", + ":video_frame", + "../../modules/rtp_rtcp:rtp_video_header", + "../../modules/video_coding:video_codec_interface", "../units:timestamp", ] absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ] diff --git a/api/video/DEPS b/api/video/DEPS index c84299f943..1dd2943d1f 100644 --- a/api/video/DEPS +++ b/api/video/DEPS @@ -1,11 +1,9 @@ specific_include_rules = { - # Until the new VideoStreamDecoder is implemented the current decoding - # pipeline will be used, and therefore EncodedFrame needs to inherit - # VCMEncodedFrame. - "encoded_frame.h": [ - "+modules/video_coding/encoded_frame.h", + "encoded_frame.h" : [ + "+modules/rtp_rtcp/source/rtp_video_header.h", + "+modules/video_coding/include/video_codec_interface.h", + "+modules/video_coding/include/video_coding_defines.h", ], - "encoded_image\.h" : [ "+rtc_base/ref_count.h", ], diff --git a/api/video/encoded_frame.cc b/api/video/encoded_frame.cc index c5e2abbbb4..cf3d4a20e5 100644 --- a/api/video/encoded_frame.cc +++ b/api/video/encoded_frame.cc @@ -11,6 +11,7 @@ #include "api/video/encoded_frame.h" #include "absl/types/optional.h" +#include "modules/rtp_rtcp/source/rtp_video_header.h" namespace webrtc { @@ -30,4 +31,100 @@ bool EncodedFrame::delayed_by_retransmission() const { return false; } +void EncodedFrame::CopyCodecSpecific(const RTPVideoHeader* header) { + if (header) { + switch (header->codec) { + case kVideoCodecVP8: { + const auto& vp8_header = + absl::get(header->video_type_header); + if (_codecSpecificInfo.codecType != kVideoCodecVP8) { + // This is the first packet for this frame. + _codecSpecificInfo.codecSpecific.VP8.temporalIdx = 0; + _codecSpecificInfo.codecSpecific.VP8.layerSync = false; + _codecSpecificInfo.codecSpecific.VP8.keyIdx = -1; + _codecSpecificInfo.codecType = kVideoCodecVP8; + } + _codecSpecificInfo.codecSpecific.VP8.nonReference = + vp8_header.nonReference; + if (vp8_header.temporalIdx != kNoTemporalIdx) { + _codecSpecificInfo.codecSpecific.VP8.temporalIdx = + vp8_header.temporalIdx; + _codecSpecificInfo.codecSpecific.VP8.layerSync = vp8_header.layerSync; + } + if (vp8_header.keyIdx != kNoKeyIdx) { + _codecSpecificInfo.codecSpecific.VP8.keyIdx = vp8_header.keyIdx; + } + break; + } + case kVideoCodecVP9: { + const auto& vp9_header = + absl::get(header->video_type_header); + if (_codecSpecificInfo.codecType != kVideoCodecVP9) { + // This is the first packet for this frame. + _codecSpecificInfo.codecSpecific.VP9.temporal_idx = 0; + _codecSpecificInfo.codecSpecific.VP9.gof_idx = 0; + _codecSpecificInfo.codecSpecific.VP9.inter_layer_predicted = false; + _codecSpecificInfo.codecType = kVideoCodecVP9; + } + _codecSpecificInfo.codecSpecific.VP9.inter_pic_predicted = + vp9_header.inter_pic_predicted; + _codecSpecificInfo.codecSpecific.VP9.flexible_mode = + vp9_header.flexible_mode; + _codecSpecificInfo.codecSpecific.VP9.num_ref_pics = + vp9_header.num_ref_pics; + for (uint8_t r = 0; r < vp9_header.num_ref_pics; ++r) { + _codecSpecificInfo.codecSpecific.VP9.p_diff[r] = + vp9_header.pid_diff[r]; + } + _codecSpecificInfo.codecSpecific.VP9.ss_data_available = + vp9_header.ss_data_available; + if (vp9_header.temporal_idx != kNoTemporalIdx) { + _codecSpecificInfo.codecSpecific.VP9.temporal_idx = + vp9_header.temporal_idx; + _codecSpecificInfo.codecSpecific.VP9.temporal_up_switch = + vp9_header.temporal_up_switch; + } + if (vp9_header.spatial_idx != kNoSpatialIdx) { + _codecSpecificInfo.codecSpecific.VP9.inter_layer_predicted = + vp9_header.inter_layer_predicted; + SetSpatialIndex(vp9_header.spatial_idx); + } + if (vp9_header.gof_idx != kNoGofIdx) { + _codecSpecificInfo.codecSpecific.VP9.gof_idx = vp9_header.gof_idx; + } + if (vp9_header.ss_data_available) { + _codecSpecificInfo.codecSpecific.VP9.num_spatial_layers = + vp9_header.num_spatial_layers; + _codecSpecificInfo.codecSpecific.VP9 + .spatial_layer_resolution_present = + vp9_header.spatial_layer_resolution_present; + if (vp9_header.spatial_layer_resolution_present) { + for (size_t i = 0; i < vp9_header.num_spatial_layers; ++i) { + _codecSpecificInfo.codecSpecific.VP9.width[i] = + vp9_header.width[i]; + _codecSpecificInfo.codecSpecific.VP9.height[i] = + vp9_header.height[i]; + } + } + _codecSpecificInfo.codecSpecific.VP9.gof.CopyGofInfoVP9( + vp9_header.gof); + } + break; + } + case kVideoCodecH264: { + _codecSpecificInfo.codecType = kVideoCodecH264; + break; + } + case kVideoCodecAV1: { + _codecSpecificInfo.codecType = kVideoCodecAV1; + break; + } + default: { + _codecSpecificInfo.codecType = kVideoCodecGeneric; + break; + } + } + } +} + } // namespace webrtc diff --git a/api/video/encoded_frame.h b/api/video/encoded_frame.h index 66aee227bb..72473ba021 100644 --- a/api/video/encoded_frame.h +++ b/api/video/encoded_frame.h @@ -16,14 +16,17 @@ #include "absl/types/optional.h" #include "api/units/timestamp.h" -#include "modules/video_coding/encoded_frame.h" +#include "api/video/encoded_image.h" +#include "api/video/video_codec_type.h" +#include "modules/rtp_rtcp/source/rtp_video_header.h" +#include "modules/video_coding/include/video_codec_interface.h" +#include "modules/video_coding/include/video_coding_defines.h" namespace webrtc { -// TODO(philipel): Remove webrtc::VCMEncodedFrame inheritance. // TODO(philipel): Move transport specific info out of EncodedFrame. // NOTE: This class is still under development and may change without notice. -class EncodedFrame : public webrtc::VCMEncodedFrame { +class EncodedFrame : public EncodedImage { public: static const uint8_t kMaxFrameReferences = 5; @@ -33,14 +36,16 @@ class EncodedFrame : public webrtc::VCMEncodedFrame { // When this frame was received. // TODO(bugs.webrtc.org/13756): Use Timestamp instead of int. - virtual int64_t ReceivedTime() const = 0; + virtual int64_t ReceivedTime() const { return -1; } // Returns a Timestamp from `ReceivedTime`, or nullopt if there is no receive // time. absl::optional ReceivedTimestamp() const; // When this frame should be rendered. // TODO(bugs.webrtc.org/13756): Use Timestamp instead of int. - virtual int64_t RenderTime() const = 0; + virtual int64_t RenderTime() const { return _renderTimeMs; } + // TODO(bugs.webrtc.org/13756): Migrate to ReceivedTimestamp. + int64_t RenderTimeMs() const { return _renderTimeMs; } // Returns a Timestamp from `RenderTime`, or nullopt if there is no // render time. absl::optional RenderTimestamp() const; @@ -55,6 +60,23 @@ class EncodedFrame : public webrtc::VCMEncodedFrame { void SetId(int64_t id) { id_ = id; } int64_t Id() const { return id_; } + uint8_t PayloadType() const { return _payloadType; } + + bool MissingFrame() const { return _missingFrame; } + + void SetRenderTime(const int64_t renderTimeMs) { + _renderTimeMs = renderTimeMs; + } + + const webrtc::EncodedImage& EncodedImage() const { + return static_cast(*this); + } + + const CodecSpecificInfo* CodecSpecific() const { return &_codecSpecificInfo; } + void SetCodecSpecific(const CodecSpecificInfo* codec_specific) { + _codecSpecificInfo = *codec_specific; + } + // TODO(philipel): Add simple modify/access functions to prevent adding too // many `references`. size_t num_references = 0; @@ -63,6 +85,19 @@ class EncodedFrame : public webrtc::VCMEncodedFrame { // mean that the last packet has a marker bit set). bool is_last_spatial_layer = true; + protected: + // TODO(https://bugs.webrtc.org/9378): Move RTP specifics down into a + // transport-aware subclass, eg RtpFrameObject. + void CopyCodecSpecific(const RTPVideoHeader* header); + + // TODO(https://bugs.webrtc.org/9378): Make fields private with + // getters/setters as needed. + int64_t _renderTimeMs = -1; + uint8_t _payloadType = 0; + bool _missingFrame = false; + CodecSpecificInfo _codecSpecificInfo; + VideoCodecType _codec = kVideoCodecGeneric; + private: // The ID of the frame is determined from RTP level information. The IDs are // used to describe order and dependencies between frames. diff --git a/api/video/encoded_image.h b/api/video/encoded_image.h index c1f14475cd..5fc4a0e60a 100644 --- a/api/video/encoded_image.h +++ b/api/video/encoded_image.h @@ -201,6 +201,14 @@ class RTC_EXPORT EncodedImage { at_target_quality_ = at_target_quality; } + webrtc::VideoFrameType FrameType() const { return _frameType; } + + void SetFrameType(webrtc::VideoFrameType frame_type) { + _frameType = frame_type; + } + VideoContentType contentType() const { return content_type_; } + VideoRotation rotation() const { return rotation_; } + uint32_t _encodedWidth = 0; uint32_t _encodedHeight = 0; // NTP time of the capture time in local timebase in milliseconds. @@ -223,6 +231,8 @@ class RTC_EXPORT EncodedImage { int64_t receive_start_ms = 0; int64_t receive_finish_ms = 0; } timing_; + EncodedImage::Timing video_timing() const { return timing_; } + EncodedImage::Timing* video_timing_mutable() { return &timing_; } private: size_t capacity() const { return encoded_data_ ? encoded_data_->size() : 0; } diff --git a/modules/video_coding/decoder_database.cc b/modules/video_coding/decoder_database.cc index 3410edc624..dabef41f95 100644 --- a/modules/video_coding/decoder_database.cc +++ b/modules/video_coding/decoder_database.cc @@ -86,7 +86,7 @@ void VCMDecoderDatabase::DeregisterReceiveCodecs() { } VCMGenericDecoder* VCMDecoderDatabase::GetDecoder( - const VCMEncodedFrame& frame, + const EncodedFrame& frame, VCMDecodedFrameCallback* decoded_frame_callback) { RTC_DCHECK_RUN_ON(&decoder_sequence_checker_); RTC_DCHECK(decoded_frame_callback->UserReceiveCallback()); @@ -117,7 +117,7 @@ VCMGenericDecoder* VCMDecoderDatabase::GetDecoder( return &*current_decoder_; } -void VCMDecoderDatabase::CreateAndInitDecoder(const VCMEncodedFrame& frame) { +void VCMDecoderDatabase::CreateAndInitDecoder(const EncodedFrame& frame) { uint8_t payload_type = frame.PayloadType(); RTC_DLOG(LS_INFO) << "Initializing decoder with payload type '" << int{payload_type} << "'."; diff --git a/modules/video_coding/decoder_database.h b/modules/video_coding/decoder_database.h index 98f4335621..87edcd05df 100644 --- a/modules/video_coding/decoder_database.h +++ b/modules/video_coding/decoder_database.h @@ -18,8 +18,8 @@ #include "absl/types/optional.h" #include "api/sequence_checker.h" +#include "api/video/encoded_frame.h" #include "api/video_codecs/video_decoder.h" -#include "modules/video_coding/encoded_frame.h" #include "modules/video_coding/generic_decoder.h" namespace webrtc { @@ -49,11 +49,11 @@ class VCMDecoderDatabase { // nullptr is returned if no decoder with the specified payload type was found // and the function failed to create one. VCMGenericDecoder* GetDecoder( - const VCMEncodedFrame& frame, + const EncodedFrame& frame, VCMDecodedFrameCallback* decoded_frame_callback); private: - void CreateAndInitDecoder(const VCMEncodedFrame& frame) + void CreateAndInitDecoder(const EncodedFrame& frame) RTC_RUN_ON(decoder_sequence_checker_); SequenceChecker decoder_sequence_checker_; diff --git a/modules/video_coding/encoded_frame.h b/modules/video_coding/encoded_frame.h index 87b59d8fdc..b8c9d14653 100644 --- a/modules/video_coding/encoded_frame.h +++ b/modules/video_coding/encoded_frame.h @@ -62,29 +62,6 @@ class RTC_EXPORT VCMEncodedFrame : public EncodedImage { * Get render time in milliseconds */ int64_t RenderTimeMs() const { return _renderTimeMs; } - /** - * Get frame type - */ - webrtc::VideoFrameType FrameType() const { return _frameType; } - /** - * Set frame type - */ - void SetFrameType(webrtc::VideoFrameType frame_type) { - _frameType = frame_type; - } - /** - * Get frame rotation - */ - VideoRotation rotation() const { return rotation_; } - /** - * Get video content type - */ - VideoContentType contentType() const { return content_type_; } - /** - * Get video timing - */ - EncodedImage::Timing video_timing() const { return timing_; } - EncodedImage::Timing* video_timing_mutable() { return &timing_; } /** * True if there's a frame missing before this frame */ diff --git a/modules/video_coding/generic_decoder.cc b/modules/video_coding/generic_decoder.cc index e3ce413876..7ebc3870ea 100644 --- a/modules/video_coding/generic_decoder.cc +++ b/modules/video_coding/generic_decoder.cc @@ -281,19 +281,30 @@ bool VCMGenericDecoder::Configure(const VideoDecoder::Settings& settings) { return ok; } +int32_t VCMGenericDecoder::Decode(const EncodedFrame& frame, Timestamp now) { + return Decode(frame, now, frame.RenderTimeMs(), frame.MissingFrame()); +} + int32_t VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, Timestamp now) { + return Decode(frame, now, frame.RenderTimeMs(), frame.MissingFrame()); +} + +int32_t VCMGenericDecoder::Decode(const EncodedImage& frame, + Timestamp now, + int64_t render_time_ms, + int64_t missing_frame) { TRACE_EVENT1("webrtc", "VCMGenericDecoder::Decode", "timestamp", frame.Timestamp()); FrameInfo frame_info; frame_info.rtp_timestamp = frame.Timestamp(); frame_info.decode_start = now; frame_info.render_time = - frame.RenderTimeMs() >= 0 - ? absl::make_optional(Timestamp::Millis(frame.RenderTimeMs())) + render_time_ms >= 0 + ? absl::make_optional(Timestamp::Millis(render_time_ms)) : absl::nullopt; frame_info.rotation = frame.rotation(); frame_info.timing = frame.video_timing(); - frame_info.ntp_time_ms = frame.EncodedImage().ntp_time_ms_; + frame_info.ntp_time_ms = frame.ntp_time_ms_; frame_info.packet_infos = frame.PacketInfos(); // Set correctly only for key frames. Thus, use latest key frame @@ -308,8 +319,7 @@ int32_t VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, Timestamp now) { frame_info.frame_type = frame.FrameType(); _callback->Map(std::move(frame_info)); - int32_t ret = decoder_->Decode(frame.EncodedImage(), frame.MissingFrame(), - frame.RenderTimeMs()); + int32_t ret = decoder_->Decode(frame, missing_frame, render_time_ms); VideoDecoder::DecoderInfo decoder_info = decoder_->GetDecoderInfo(); if (decoder_info != decoder_info_) { RTC_LOG(LS_INFO) << "Changed decoder implementation to: " diff --git a/modules/video_coding/generic_decoder.h b/modules/video_coding/generic_decoder.h index 5922b52b7c..be08fc66ee 100644 --- a/modules/video_coding/generic_decoder.h +++ b/modules/video_coding/generic_decoder.h @@ -18,6 +18,7 @@ #include "api/field_trials_view.h" #include "api/sequence_checker.h" +#include "api/video/encoded_frame.h" #include "api/video_codecs/video_decoder.h" #include "modules/video_coding/encoded_frame.h" #include "modules/video_coding/timing/timing.h" @@ -102,7 +103,10 @@ class VCMGenericDecoder { * * inputVideoBuffer reference to encoded video frame */ + // TODO(https://bugs.webrtc.org/9378): Remove VCMEncodedFrame variant + // once the usage from code in deprecated/ is gone. int32_t Decode(const VCMEncodedFrame& inputFrame, Timestamp now); + int32_t Decode(const EncodedFrame& inputFrame, Timestamp now); /** * Set decode callback. Deregistering while decoding is illegal. @@ -114,6 +118,10 @@ class VCMGenericDecoder { } private: + int32_t Decode(const EncodedImage& frame, + Timestamp now, + int64_t render_time_ms, + int64_t missing_frame); VCMDecodedFrameCallback* _callback = nullptr; VideoDecoder* const decoder_; VideoContentType _last_keyframe_content_type; diff --git a/modules/video_coding/generic_decoder_unittest.cc b/modules/video_coding/generic_decoder_unittest.cc index 32ae4bf42d..e8d1dad09f 100644 --- a/modules/video_coding/generic_decoder_unittest.cc +++ b/modules/video_coding/generic_decoder_unittest.cc @@ -94,7 +94,7 @@ class GenericDecoderTest : public ::testing::Test { TEST_F(GenericDecoderTest, PassesPacketInfos) { RtpPacketInfos packet_infos = CreatePacketInfos(3); - VCMEncodedFrame encoded_frame; + EncodedFrame encoded_frame; encoded_frame.SetPacketInfos(packet_infos); generic_decoder_.Decode(encoded_frame, clock_->CurrentTime()); time_controller_.AdvanceTime(TimeDelta::Millis(10)); @@ -107,7 +107,7 @@ TEST_F(GenericDecoderTest, FrameDroppedIfTooManyFramesInFlight) { constexpr int kMaxFramesInFlight = 10; decoder_.SetDelayedDecoding(10); for (int i = 0; i < kMaxFramesInFlight + 1; ++i) { - VCMEncodedFrame encoded_frame; + EncodedFrame encoded_frame; encoded_frame.SetTimestamp(90000 * i); generic_decoder_.Decode(encoded_frame, clock_->CurrentTime()); } @@ -128,7 +128,7 @@ TEST_F(GenericDecoderTest, PassesPacketInfosForDelayedDecoders) { { // Ensure the original frame is destroyed before the decoding is completed. - VCMEncodedFrame encoded_frame; + EncodedFrame encoded_frame; encoded_frame.SetPacketInfos(packet_infos); generic_decoder_.Decode(encoded_frame, clock_->CurrentTime()); } @@ -140,7 +140,7 @@ TEST_F(GenericDecoderTest, PassesPacketInfosForDelayedDecoders) { } TEST_F(GenericDecoderTest, MaxCompositionDelayNotSetByDefault) { - VCMEncodedFrame encoded_frame; + EncodedFrame encoded_frame; generic_decoder_.Decode(encoded_frame, clock_->CurrentTime()); time_controller_.AdvanceTime(TimeDelta::Millis(10)); absl::optional decoded_frame = user_callback_.PopLastFrame(); @@ -151,7 +151,7 @@ TEST_F(GenericDecoderTest, MaxCompositionDelayNotSetByDefault) { } TEST_F(GenericDecoderTest, MaxCompositionDelayActivatedByPlayoutDelay) { - VCMEncodedFrame encoded_frame; + EncodedFrame encoded_frame; // VideoReceiveStream2 would set MaxCompositionDelayInFrames if playout delay // is specified as X,Y, where X=0, Y>0. constexpr int kMaxCompositionDelayInFrames = 3; // ~50 ms at 60 fps. @@ -167,7 +167,7 @@ TEST_F(GenericDecoderTest, MaxCompositionDelayActivatedByPlayoutDelay) { } TEST_F(GenericDecoderTest, IsLowLatencyStreamFalseByDefault) { - VCMEncodedFrame encoded_frame; + EncodedFrame encoded_frame; generic_decoder_.Decode(encoded_frame, clock_->CurrentTime()); time_controller_.AdvanceTime(TimeDelta::Millis(10)); absl::optional decoded_frame = user_callback_.PopLastFrame(); @@ -176,7 +176,7 @@ TEST_F(GenericDecoderTest, IsLowLatencyStreamFalseByDefault) { } TEST_F(GenericDecoderTest, IsLowLatencyStreamActivatedByPlayoutDelay) { - VCMEncodedFrame encoded_frame; + EncodedFrame encoded_frame; const VideoPlayoutDelay kPlayoutDelay(TimeDelta::Zero(), TimeDelta::Millis(50)); timing_.set_min_playout_delay(kPlayoutDelay.min()); diff --git a/modules/video_coding/video_receiver2.cc b/modules/video_coding/video_receiver2.cc index 0751869a98..72f366dbe7 100644 --- a/modules/video_coding/video_receiver2.cc +++ b/modules/video_coding/video_receiver2.cc @@ -20,7 +20,6 @@ #include "api/video_codecs/video_codec.h" #include "api/video_codecs/video_decoder.h" #include "modules/video_coding/decoder_database.h" -#include "modules/video_coding/encoded_frame.h" #include "modules/video_coding/generic_decoder.h" #include "modules/video_coding/include/video_coding_defines.h" #include "modules/video_coding/timing/timing.h" @@ -74,7 +73,7 @@ bool VideoReceiver2::IsExternalDecoderRegistered(uint8_t payload_type) const { } // Must be called from inside the receive side critical section. -int32_t VideoReceiver2::Decode(const VCMEncodedFrame* frame) { +int32_t VideoReceiver2::Decode(const EncodedFrame* frame) { RTC_DCHECK_RUN_ON(&decoder_sequence_checker_); TRACE_EVENT0("webrtc", "VideoReceiver2::Decode"); // Change decoder if payload type has changed. diff --git a/modules/video_coding/video_receiver2.h b/modules/video_coding/video_receiver2.h index 4457a5b5b3..0d3bdb464f 100644 --- a/modules/video_coding/video_receiver2.h +++ b/modules/video_coding/video_receiver2.h @@ -16,9 +16,9 @@ #include "api/field_trials_view.h" #include "api/sequence_checker.h" +#include "api/video/encoded_frame.h" #include "api/video_codecs/video_decoder.h" #include "modules/video_coding/decoder_database.h" -#include "modules/video_coding/encoded_frame.h" #include "modules/video_coding/generic_decoder.h" #include "modules/video_coding/timing/timing.h" #include "rtc_base/system/no_unique_address.h" @@ -49,7 +49,7 @@ class VideoReceiver2 { bool IsExternalDecoderRegistered(uint8_t payload_type) const; int32_t RegisterReceiveCallback(VCMReceiveCallback* receive_callback); - int32_t Decode(const VCMEncodedFrame* frame); + int32_t Decode(const EncodedFrame* frame); private: RTC_NO_UNIQUE_ADDRESS SequenceChecker construction_sequence_checker_; diff --git a/video/BUILD.gn b/video/BUILD.gn index 3de58b6615..0349f2d830 100644 --- a/video/BUILD.gn +++ b/video/BUILD.gn @@ -277,6 +277,7 @@ rtc_library("video_stream_buffer_controller") { "../api/video:video_rtp_headers", "../modules/video_coding", "../modules/video_coding:frame_helpers", + "../modules/video_coding:video_codec_interface", "../modules/video_coding/timing:inter_frame_delay_variation_calculator", "../modules/video_coding/timing:jitter_estimator", "../modules/video_coding/timing:timing_module", diff --git a/video/video_stream_buffer_controller.h b/video/video_stream_buffer_controller.h index bb67304d06..f8793851dd 100644 --- a/video/video_stream_buffer_controller.h +++ b/video/video_stream_buffer_controller.h @@ -17,6 +17,7 @@ #include "api/task_queue/task_queue_base.h" #include "api/video/encoded_frame.h" #include "api/video/frame_buffer.h" +#include "modules/video_coding/include/video_coding_defines.h" #include "modules/video_coding/timing/inter_frame_delay_variation_calculator.h" #include "modules/video_coding/timing/jitter_estimator.h" #include "modules/video_coding/timing/timing.h"