admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move RtpFrameObject and EncodedFrame out of video_coding namespace.

Browse Source 
Bug: webrtc:12579
Change-Id: Ib7ecd624eb5c54abb77fe08440a014aa1e963865
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/212860
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33542}
This commit is contained in:
philipel 2021-03-23 12:00:49 +01:00 committed by Commit Bot
parent 93ee168671
commit ca18809ee5
44 changed files with 195 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/video/encoded_frame.cc
View File

@ -11,11 +11,9 @@
#include "api/video/encoded_frame.h"
namespace webrtc {
namespace video_coding {
bool EncodedFrame::delayed_by_retransmission() const {
return 0;
}
} // namespace video_coding
} // namespace webrtc

5
api/video/encoded_frame.h
View File

@ -17,7 +17,6 @@
#include "modules/video_coding/encoded_frame.h"
namespace webrtc {
namespace video_coding {
// TODO(philipel): Remove webrtc::VCMEncodedFrame inheritance.
// TODO(philipel): Move transport specific info out of EncodedFrame.
@ -60,7 +59,11 @@ class EncodedFrame : public webrtc::VCMEncodedFrame {
int64_t id_ = -1;
};
// TODO(bugs.webrtc.org/12579): Remove when downstream has been updated.
namespace video_coding {
using ::webrtc::EncodedFrame;
} // namespace video_coding
} // namespace webrtc
#endif // API_VIDEO_ENCODED_FRAME_H_

2
api/video/video_stream_decoder.h
View File

@ -46,7 +46,7 @@ class VideoStreamDecoderInterface {
virtual ~VideoStreamDecoderInterface() = default;
virtual void OnFrame(std::unique_ptr<video_coding::EncodedFrame> frame) = 0;
virtual void OnFrame(std::unique_ptr<EncodedFrame> frame) = 0;
virtual void SetMinPlayoutDelay(TimeDelta min_delay) = 0;
virtual void SetMaxPlayoutDelay(TimeDelta max_delay) = 0;

2
modules/video_coding/frame_buffer2_unittest.cc
View File

@ -199,7 +199,7 @@ class TestFrameBuffer2 : public ::testing::Test {
time_task_queue_.PostTask([this, max_wait_time, keyframe_required]() {
buffer_->NextFrame(
max_wait_time, keyframe_required, &time_task_queue_,
[this](std::unique_ptr<video_coding::EncodedFrame> frame,
[this](std::unique_ptr<EncodedFrame> frame,
video_coding::FrameBuffer::ReturnReason reason) {
if (reason != FrameBuffer::ReturnReason::kStopped) {
frames_.emplace_back(std::move(frame));

2
modules/video_coding/frame_object.cc
View File

@ -19,7 +19,6 @@
#include "rtc_base/checks.h"
namespace webrtc {
namespace video_coding {
RtpFrameObject::RtpFrameObject(
uint16_t first_seq_num,
uint16_t last_seq_num,
@ -128,5 +127,4 @@ const RTPVideoHeader& RtpFrameObject::GetRtpVideoHeader() const {
return rtp_video_header_;
}
} // namespace video_coding
} // namespace webrtc

5
modules/video_coding/frame_object.h
View File

@ -15,7 +15,6 @@
#include "api/video/encoded_frame.h"
namespace webrtc {
namespace video_coding {
class RtpFrameObject : public EncodedFrame {
public:
@ -64,7 +63,11 @@ class RtpFrameObject : public EncodedFrame {
int times_nacked_;
};
// TODO(bugs.webrtc.org/12579): Remove when downstream has been updated.
namespace video_coding {
using ::webrtc::RtpFrameObject;
} // namespace video_coding
} // namespace webrtc
#endif // MODULES_VIDEO_CODING_FRAME_OBJECT_H_

2
modules/video_coding/rtp_frame_id_only_ref_finder.cc
View File

@ -17,7 +17,7 @@
namespace webrtc {
RtpFrameReferenceFinder::ReturnVector RtpFrameIdOnlyRefFinder::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame,
std::unique_ptr<RtpFrameObject> frame,
int frame_id) {
frame->SetSpatialIndex(0);
frame->SetId(unwrapper_.Unwrap(frame_id & (kFrameIdLength - 1)));

2
modules/video_coding/rtp_frame_id_only_ref_finder.h
View File

@ -25,7 +25,7 @@ class RtpFrameIdOnlyRefFinder {
RtpFrameIdOnlyRefFinder() = default;
RtpFrameReferenceFinder::ReturnVector ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame,
std::unique_ptr<RtpFrameObject> frame,
int frame_id);
private:

6
modules/video_coding/rtp_frame_reference_finder.cc
View File

@ -27,7 +27,7 @@ class RtpFrameReferenceFinderImpl {
RtpFrameReferenceFinderImpl() = default;
RtpFrameReferenceFinder::ReturnVector ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame);
std::unique_ptr<RtpFrameObject> frame);
RtpFrameReferenceFinder::ReturnVector PaddingReceived(uint16_t seq_num);
void ClearTo(uint16_t seq_num);
@ -45,7 +45,7 @@ class RtpFrameReferenceFinderImpl {
};
RtpFrameReferenceFinder::ReturnVector RtpFrameReferenceFinderImpl::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
const RTPVideoHeader& video_header = frame->GetRtpVideoHeader();
if (video_header.generic.has_value()) {
@ -156,7 +156,7 @@ RtpFrameReferenceFinder::RtpFrameReferenceFinder(
RtpFrameReferenceFinder::~RtpFrameReferenceFinder() = default;
void RtpFrameReferenceFinder::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
// If we have cleared past this frame, drop it.
if (cleared_to_seq_num_ != -1 &&
AheadOf<uint16_t>(cleared_to_seq_num_, frame->first_seq_num())) {

8
modules/video_coding/rtp_frame_reference_finder.h
View File

@ -25,8 +25,7 @@ class RtpFrameReferenceFinderImpl;
class OnCompleteFrameCallback {
public:
virtual ~OnCompleteFrameCallback() {}
virtual void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) = 0;
virtual void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) = 0;
};
// TODO(bugs.webrtc.org/12579): Remove when downstream has been update.
@ -36,8 +35,7 @@ using OnCompleteFrameCallback = webrtc::OnCompleteFrameCallback;
class RtpFrameReferenceFinder {
public:
using ReturnVector =
absl::InlinedVector<std::unique_ptr<video_coding::RtpFrameObject>, 3>;
using ReturnVector = absl::InlinedVector<std::unique_ptr<RtpFrameObject>, 3>;
explicit RtpFrameReferenceFinder(OnCompleteFrameCallback* frame_callback);
explicit RtpFrameReferenceFinder(OnCompleteFrameCallback* frame_callback,
@ -50,7 +48,7 @@ class RtpFrameReferenceFinder {
// - We have too many stashed frames (determined by |kMaxStashedFrames|)
// so we drop this frame, or
// - It gets cleared by ClearTo, which also means we drop it.
void ManageFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
void ManageFrame(std::unique_ptr<RtpFrameObject> frame);
// Notifies that padding has been received, which the reference finder
// might need to calculate the references of a frame.

22
modules/video_coding/rtp_frame_reference_finder_unittest.cc
View File

@ -24,10 +24,9 @@
#include "test/gtest.h"
namespace webrtc {
namespace video_coding {
namespace {
std::unique_ptr<video_coding::RtpFrameObject> CreateFrame(
std::unique_ptr<RtpFrameObject> CreateFrame(
uint16_t seq_num_start,
uint16_t seq_num_end,
bool keyframe,
@ -39,7 +38,7 @@ std::unique_ptr<video_coding::RtpFrameObject> CreateFrame(
video_header.video_type_header = video_type_header;
// clang-format off
return std::make_unique<video_coding::RtpFrameObject>(
return std::make_unique<RtpFrameObject>(
seq_num_start,
seq_num_end,
/*markerBit=*/true,
@ -71,8 +70,7 @@ class TestRtpFrameReferenceFinder : public ::testing::Test,
uint16_t Rand() { return rand_.Rand<uint16_t>(); }
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override {
void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {
int64_t pid = frame->Id();
uint16_t sidx = *frame->SpatialIndex();
auto frame_it = frames_from_callback_.find(std::make_pair(pid, sidx));
@ -89,7 +87,7 @@ class TestRtpFrameReferenceFinder : public ::testing::Test,
void InsertGeneric(uint16_t seq_num_start,
uint16_t seq_num_end,
bool keyframe) {
std::unique_ptr<video_coding::RtpFrameObject> frame =
std::unique_ptr<RtpFrameObject> frame =
CreateFrame(seq_num_start, seq_num_end, keyframe, kVideoCodecGeneric,
RTPVideoTypeHeader());
@ -97,7 +95,7 @@ class TestRtpFrameReferenceFinder : public ::testing::Test,
}
void InsertH264(uint16_t seq_num_start, uint16_t seq_num_end, bool keyframe) {
std::unique_ptr<video_coding::RtpFrameObject> frame =
std::unique_ptr<RtpFrameObject> frame =
CreateFrame(seq_num_start, seq_num_end, keyframe, kVideoCodecH264,
RTPVideoTypeHeader());
reference_finder_->ManageFrame(std::move(frame));
@ -156,10 +154,9 @@ class TestRtpFrameReferenceFinder : public ::testing::Test,
return f1.first < f2.first;
}
};
std::map<std::pair<int64_t, uint8_t>,
std::unique_ptr<video_coding::EncodedFrame>,
FrameComp>
frames_from_callback_;
std::
map<std::pair<int64_t, uint8_t>, std::unique_ptr<EncodedFrame>, FrameComp>
frames_from_callback_;
};
TEST_F(TestRtpFrameReferenceFinder, PaddingPackets) {
@ -307,7 +304,7 @@ TEST_F(TestRtpFrameReferenceFinder, H264SequenceNumberWrapMulti) {
TEST_F(TestRtpFrameReferenceFinder, Av1FrameNoDependencyDescriptor) {
uint16_t sn = 0xFFFF;
std::unique_ptr<video_coding::RtpFrameObject> frame =
std::unique_ptr<RtpFrameObject> frame =
CreateFrame(/*seq_num_start=*/sn, /*seq_num_end=*/sn, /*keyframe=*/true,
kVideoCodecAV1, RTPVideoTypeHeader());
@ -317,5 +314,4 @@ TEST_F(TestRtpFrameReferenceFinder, Av1FrameNoDependencyDescriptor) {
CheckReferencesGeneric(sn);
}
} // namespace video_coding
} // namespace webrtc

5
modules/video_coding/rtp_generic_ref_finder.cc
View File

@ -17,7 +17,7 @@
namespace webrtc {
RtpFrameReferenceFinder::ReturnVector RtpGenericFrameRefFinder::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame,
std::unique_ptr<RtpFrameObject> frame,
const RTPVideoHeader::GenericDescriptorInfo& descriptor) {
// Frame IDs are unwrapped in the RtpVideoStreamReceiver, no need to unwrap
// them here.
@ -25,8 +25,7 @@ RtpFrameReferenceFinder::ReturnVector RtpGenericFrameRefFinder::ManageFrame(
frame->SetSpatialIndex(descriptor.spatial_index);
RtpFrameReferenceFinder::ReturnVector res;
if (video_coding::EncodedFrame::kMaxFrameReferences <
descriptor.dependencies.size()) {
if (EncodedFrame::kMaxFrameReferences < descriptor.dependencies.size()) {
RTC_LOG(LS_WARNING) << "Too many dependencies in generic descriptor.";
return res;
}

2
modules/video_coding/rtp_generic_ref_finder.h
View File

@ -23,7 +23,7 @@ class RtpGenericFrameRefFinder {
RtpGenericFrameRefFinder() = default;
RtpFrameReferenceFinder::ReturnVector ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame,
std::unique_ptr<RtpFrameObject> frame,
const RTPVideoHeader::GenericDescriptorInfo& descriptor);
};

5
modules/video_coding/rtp_seq_num_only_ref_finder.cc
View File

@ -17,7 +17,7 @@
namespace webrtc {
RtpFrameReferenceFinder::ReturnVector RtpSeqNumOnlyRefFinder::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
FrameDecision decision = ManageFrameInternal(frame.get());
RtpFrameReferenceFinder::ReturnVector res;
@ -39,8 +39,7 @@ RtpFrameReferenceFinder::ReturnVector RtpSeqNumOnlyRefFinder::ManageFrame(
}
RtpSeqNumOnlyRefFinder::FrameDecision
RtpSeqNumOnlyRefFinder::ManageFrameInternal(
video_coding::RtpFrameObject* frame) {
RtpSeqNumOnlyRefFinder::ManageFrameInternal(RtpFrameObject* frame) {
if (frame->frame_type() == VideoFrameType::kVideoFrameKey) {
last_seq_num_gop_.insert(std::make_pair(
frame->last_seq_num(),

6
modules/video_coding/rtp_seq_num_only_ref_finder.h
View File

@ -29,7 +29,7 @@ class RtpSeqNumOnlyRefFinder {
RtpSeqNumOnlyRefFinder() = default;
RtpFrameReferenceFinder::ReturnVector ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame);
std::unique_ptr<RtpFrameObject> frame);
RtpFrameReferenceFinder::ReturnVector PaddingReceived(uint16_t seq_num);
void ClearTo(uint16_t seq_num);
@ -39,7 +39,7 @@ class RtpSeqNumOnlyRefFinder {
enum FrameDecision { kStash, kHandOff, kDrop };
FrameDecision ManageFrameInternal(video_coding::RtpFrameObject* frame);
FrameDecision ManageFrameInternal(RtpFrameObject* frame);
void RetryStashedFrames(RtpFrameReferenceFinder::ReturnVector& res);
void UpdateLastPictureIdWithPadding(uint16_t seq_num);
@ -58,7 +58,7 @@ class RtpSeqNumOnlyRefFinder {
// Frames that have been fully received but didn't have all the information
// needed to determine their references.
std::deque<std::unique_ptr<video_coding::RtpFrameObject>> stashed_frames_;
std::deque<std::unique_ptr<RtpFrameObject>> stashed_frames_;
// Unwrapper used to unwrap generic RTP streams. In a generic stream we derive
// a picture id from the packet sequence number.

8
modules/video_coding/rtp_vp8_ref_finder.cc
View File

@ -17,7 +17,7 @@
namespace webrtc {
RtpFrameReferenceFinder::ReturnVector RtpVp8RefFinder::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
FrameDecision decision = ManageFrameInternal(frame.get());
RtpFrameReferenceFinder::ReturnVector res;
@ -39,7 +39,7 @@ RtpFrameReferenceFinder::ReturnVector RtpVp8RefFinder::ManageFrame(
}
RtpVp8RefFinder::FrameDecision RtpVp8RefFinder::ManageFrameInternal(
video_coding::RtpFrameObject* frame) {
RtpFrameObject* frame) {
const RTPVideoHeader& video_header = frame->GetRtpVideoHeader();
const RTPVideoHeaderVP8& codec_header =
absl::get<RTPVideoHeaderVP8>(video_header.video_type_header);
@ -178,7 +178,7 @@ RtpVp8RefFinder::FrameDecision RtpVp8RefFinder::ManageFrameInternal(
return kHandOff;
}
void RtpVp8RefFinder::UpdateLayerInfoVp8(video_coding::RtpFrameObject* frame,
void RtpVp8RefFinder::UpdateLayerInfoVp8(RtpFrameObject* frame,
int64_t unwrapped_tl0,
uint8_t temporal_idx) {
auto layer_info_it = layer_info_.find(unwrapped_tl0);
@ -226,7 +226,7 @@ void RtpVp8RefFinder::RetryStashedFrames(
} while (complete_frame);
}
void RtpVp8RefFinder::UnwrapPictureIds(video_coding::RtpFrameObject* frame) {
void RtpVp8RefFinder::UnwrapPictureIds(RtpFrameObject* frame) {
for (size_t i = 0; i < frame->num_references; ++i)
frame->references[i] = unwrapper_.Unwrap(frame->references[i]);
frame->SetId(unwrapper_.Unwrap(frame->Id()));

10
modules/video_coding/rtp_vp8_ref_finder.h
View File

@ -28,7 +28,7 @@ class RtpVp8RefFinder {
RtpVp8RefFinder() = default;
RtpFrameReferenceFinder::ReturnVector ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame);
std::unique_ptr<RtpFrameObject> frame);
void ClearTo(uint16_t seq_num);
private:
@ -40,12 +40,12 @@ class RtpVp8RefFinder {
enum FrameDecision { kStash, kHandOff, kDrop };
FrameDecision ManageFrameInternal(video_coding::RtpFrameObject* frame);
FrameDecision ManageFrameInternal(RtpFrameObject* frame);
void RetryStashedFrames(RtpFrameReferenceFinder::ReturnVector& res);
void UpdateLayerInfoVp8(video_coding::RtpFrameObject* frame,
void UpdateLayerInfoVp8(RtpFrameObject* frame,
int64_t unwrapped_tl0,
uint8_t temporal_idx);
void UnwrapPictureIds(video_coding::RtpFrameObject* frame);
void UnwrapPictureIds(RtpFrameObject* frame);
// Save the last picture id in order to detect when there is a gap in frames
// that have not yet been fully received.
@ -58,7 +58,7 @@ class RtpVp8RefFinder {
// Frames that have been fully received but didn't have all the information
// needed to determine their references.
std::deque<std::unique_ptr<video_coding::RtpFrameObject>> stashed_frames_;
std::deque<std::unique_ptr<RtpFrameObject>> stashed_frames_;
// Holds the information about the last completed frame for a given temporal
// layer given an unwrapped Tl0 picture index.

12
modules/video_coding/rtp_vp8_ref_finder_unittest.cc
View File

@ -25,7 +25,6 @@ using ::testing::SizeIs;
using ::testing::UnorderedElementsAreArray;
namespace webrtc {
namespace video_coding {
namespace {
MATCHER_P2(HasIdAndRefs, id, refs, "") {
@ -34,7 +33,7 @@ MATCHER_P2(HasIdAndRefs, id, refs, "") {
rtc::ArrayView<int64_t>(arg->references, arg->num_references));
}
Matcher<const std::vector<std::unique_ptr<video_coding::EncodedFrame>>&>
Matcher<const std::vector<std::unique_ptr<EncodedFrame>>&>
HasFrameWithIdAndRefs(int64_t frame_id, const std::vector<int64_t>& refs) {
return Contains(HasIdAndRefs(frame_id, refs));
}
@ -66,7 +65,7 @@ class Frame {
return *this;
}
operator std::unique_ptr<video_coding::RtpFrameObject>() {
operator std::unique_ptr<RtpFrameObject>() {
RTPVideoHeaderVP8 vp8_header{};
vp8_header.pictureId = *picture_id_;
vp8_header.temporalIdx = *temporal_id_;
@ -78,7 +77,7 @@ class Frame {
: VideoFrameType::kVideoFrameDelta;
video_header.video_type_header = vp8_header;
// clang-format off
return std::make_unique<video_coding::RtpFrameObject>(
return std::make_unique<RtpFrameObject>(
/*seq_num_start=*/0,
/*seq_num_end=*/0,
/*markerBit=*/true,
@ -113,14 +112,14 @@ class RtpVp8RefFinderTest : public ::testing::Test {
protected:
RtpVp8RefFinderTest() : ref_finder_(std::make_unique<RtpVp8RefFinder>()) {}
void Insert(std::unique_ptr<video_coding::RtpFrameObject> frame) {
void Insert(std::unique_ptr<RtpFrameObject> frame) {
for (auto& f : ref_finder_->ManageFrame(std::move(frame))) {
frames_.push_back(std::move(f));
}
}
std::unique_ptr<RtpVp8RefFinder> ref_finder_;
std::vector<std::unique_ptr<video_coding::EncodedFrame>> frames_;
std::vector<std::unique_ptr<EncodedFrame>> frames_;
};
TEST_F(RtpVp8RefFinderTest, Vp8RepeatedFrame_0) {
@ -358,5 +357,4 @@ TEST_F(RtpVp8RefFinderTest, Vp8DetectMissingFrame_0212) {
EXPECT_THAT(frames_, HasFrameWithIdAndRefs(8, {5, 6, 7}));
}
} // namespace video_coding
} // namespace webrtc

15
modules/video_coding/rtp_vp9_ref_finder.cc
View File

@ -18,7 +18,7 @@
namespace webrtc {
RtpFrameReferenceFinder::ReturnVector RtpVp9RefFinder::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
FrameDecision decision = ManageFrameInternal(frame.get());
RtpFrameReferenceFinder::ReturnVector res;
@ -40,7 +40,7 @@ RtpFrameReferenceFinder::ReturnVector RtpVp9RefFinder::ManageFrame(
}
RtpVp9RefFinder::FrameDecision RtpVp9RefFinder::ManageFrameInternal(
video_coding::RtpFrameObject* frame) {
RtpFrameObject* frame) {
const RTPVideoHeader& video_header = frame->GetRtpVideoHeader();
const RTPVideoHeaderVP9& codec_header =
absl::get<RTPVideoHeaderVP9>(video_header.video_type_header);
@ -57,8 +57,7 @@ RtpVp9RefFinder::FrameDecision RtpVp9RefFinder::ManageFrameInternal(
last_picture_id_ = frame->Id();
if (codec_header.flexible_mode) {
if (codec_header.num_ref_pics >
video_coding::EncodedFrame::kMaxFrameReferences) {
if (codec_header.num_ref_pics > EncodedFrame::kMaxFrameReferences) {
return kDrop;
}
frame->num_references = codec_header.num_ref_pics;
@ -179,8 +178,7 @@ RtpVp9RefFinder::FrameDecision RtpVp9RefFinder::ManageFrameInternal(
ForwardDiff<uint16_t, kFrameIdLength>(info->gof->pid_start, frame->Id());
size_t gof_idx = diff % info->gof->num_frames_in_gof;
if (info->gof->num_ref_pics[gof_idx] >
video_coding::EncodedFrame::kMaxFrameReferences) {
if (info->gof->num_ref_pics[gof_idx] > EncodedFrame::kMaxFrameReferences) {
return kDrop;
}
// Populate references according to the scalability structure.
@ -324,7 +322,7 @@ void RtpVp9RefFinder::RetryStashedFrames(
} while (complete_frame);
}
void RtpVp9RefFinder::FlattenFrameIdAndRefs(video_coding::RtpFrameObject* frame,
void RtpVp9RefFinder::FlattenFrameIdAndRefs(RtpFrameObject* frame,
bool inter_layer_predicted) {
for (size_t i = 0; i < frame->num_references; ++i) {
frame->references[i] =
@ -335,8 +333,7 @@ void RtpVp9RefFinder::FlattenFrameIdAndRefs(video_coding::RtpFrameObject* frame,
*frame->SpatialIndex());
if (inter_layer_predicted &&
frame->num_references + 1 <=
video_coding::EncodedFrame::kMaxFrameReferences) {
frame->num_references + 1 <= EncodedFrame::kMaxFrameReferences) {
frame->references[frame->num_references] = frame->Id() - 1;
++frame->num_references;
}

9
modules/video_coding/rtp_vp9_ref_finder.h
View File

@ -28,7 +28,7 @@ class RtpVp9RefFinder {
RtpVp9RefFinder() = default;
RtpFrameReferenceFinder::ReturnVector ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame);
std::unique_ptr<RtpFrameObject> frame);
void ClearTo(uint16_t seq_num);
private:
@ -48,7 +48,7 @@ class RtpVp9RefFinder {
uint16_t last_picture_id;
};
FrameDecision ManageFrameInternal(video_coding::RtpFrameObject* frame);
FrameDecision ManageFrameInternal(RtpFrameObject* frame);
void RetryStashedFrames(RtpFrameReferenceFinder::ReturnVector& res);
bool MissingRequiredFrameVp9(uint16_t picture_id, const GofInfo& info);
@ -58,8 +58,7 @@ class RtpVp9RefFinder {
uint8_t temporal_idx,
uint16_t pid_ref);
void FlattenFrameIdAndRefs(video_coding::RtpFrameObject* frame,
bool inter_layer_predicted);
void FlattenFrameIdAndRefs(RtpFrameObject* frame, bool inter_layer_predicted);
// Save the last picture id in order to detect when there is a gap in frames
// that have not yet been fully received.
@ -67,7 +66,7 @@ class RtpVp9RefFinder {
// Frames that have been fully received but didn't have all the information
// needed to determine their references.
std::deque<std::unique_ptr<video_coding::RtpFrameObject>> stashed_frames_;
std::deque<std::unique_ptr<RtpFrameObject>> stashed_frames_;
// Where the current scalability structure is in the
// |scalability_structures_| array.

8
modules/video_coding/rtp_vp9_ref_finder_unittest.cc
View File

@ -26,7 +26,6 @@ using ::testing::Property;
using ::testing::UnorderedElementsAreArray;
namespace webrtc {
namespace video_coding {
namespace {
class Frame {
@ -83,7 +82,7 @@ class Frame {
return *this;
}
operator std::unique_ptr<video_coding::RtpFrameObject>() {
operator std::unique_ptr<RtpFrameObject>() {
RTPVideoHeaderVP9 vp9_header{};
vp9_header.picture_id = *picture_id;
vp9_header.temporal_idx = *temporal_id;
@ -112,7 +111,7 @@ class Frame {
: VideoFrameType::kVideoFrameDelta;
video_header.video_type_header = vp9_header;
// clang-format off
return std::make_unique<video_coding::RtpFrameObject>(
return std::make_unique<RtpFrameObject>(
seq_num_start,
seq_num_end,
/*markerBit=*/true,
@ -209,7 +208,7 @@ class RtpVp9RefFinderTest : public ::testing::Test {
protected:
RtpVp9RefFinderTest() : ref_finder_(std::make_unique<RtpVp9RefFinder>()) {}
void Insert(std::unique_ptr<video_coding::RtpFrameObject> frame) {
void Insert(std::unique_ptr<RtpFrameObject> frame) {
for (auto& f : ref_finder_->ManageFrame(std::move(frame))) {
frames_.push_back(std::move(f));
}
@ -703,5 +702,4 @@ TEST_F(RtpVp9RefFinderTest, SpatialIndex) {
Contains(Pointee(Property(&EncodedFrame::SpatialIndex, 2))));
}
} // namespace video_coding
} // namespace webrtc

8
test/fuzzers/frame_buffer2_fuzzer.cc
View File

@ -49,7 +49,7 @@ struct DataReader {
size_t offset_ = 0;
};
class FuzzyFrameObject : public video_coding::EncodedFrame {
class FuzzyFrameObject : public EncodedFrame {
public:
FuzzyFrameObject() {}
~FuzzyFrameObject() {}
@ -80,8 +80,8 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
frame->SetId(reader.GetNum<int64_t>());
frame->SetSpatialIndex(reader.GetNum<uint8_t>() % 5);
frame->SetTimestamp(reader.GetNum<uint32_t>());
frame->num_references = reader.GetNum<uint8_t>() %
video_coding::EncodedFrame::kMaxFrameReferences;
frame->num_references =
reader.GetNum<uint8_t>() % EncodedFrame::kMaxFrameReferences;
for (size_t r = 0; r < frame->num_references; ++r)
frame->references[r] = reader.GetNum<int64_t>();
@ -98,7 +98,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
frame_buffer.NextFrame(
max_wait_time_ms, keyframe_required, &task_queue,
[&next_frame_task_running](
std::unique_ptr<video_coding::EncodedFrame> frame,
std::unique_ptr<EncodedFrame> frame,
video_coding::FrameBuffer::ReturnReason res) {
next_frame_task_running = false;
});

5
test/fuzzers/rtp_frame_reference_finder_fuzzer.cc
View File

@ -59,8 +59,7 @@ class DataReader {
};
class NullCallback : public OnCompleteFrameCallback {
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override {}
void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {}
};
absl::optional<RTPVideoHeader::GenericDescriptorInfo>
@ -135,7 +134,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
video_header.generic = GenerateGenericFrameDependencies(&reader);
// clang-format off
auto frame = std::make_unique<video_coding::RtpFrameObject>(
auto frame = std::make_unique<RtpFrameObject>(
first_seq_num,
last_seq_num,
marker_bit,

4
video/buffered_frame_decryptor.cc
View File

@ -36,7 +36,7 @@ void BufferedFrameDecryptor::SetFrameDecryptor(
}
void BufferedFrameDecryptor::ManageEncryptedFrame(
std::unique_ptr<video_coding::RtpFrameObject> encrypted_frame) {
std::unique_ptr<RtpFrameObject> encrypted_frame) {
switch (DecryptFrame(encrypted_frame.get())) {
case FrameDecision::kStash:
if (stashed_frames_.size() >= kMaxStashedFrames) {
@ -55,7 +55,7 @@ void BufferedFrameDecryptor::ManageEncryptedFrame(
}
BufferedFrameDecryptor::FrameDecision BufferedFrameDecryptor::DecryptFrame(
video_coding::RtpFrameObject* frame) {
RtpFrameObject* frame) {
// Optionally attempt to decrypt the raw video frame if it was provided.
if (frame_decryptor_ == nullptr) {
RTC_LOG(LS_INFO) << "Frame decryption required but not attached to this "

10
video/buffered_frame_decryptor.h
View File

@ -27,8 +27,7 @@ class OnDecryptedFrameCallback {
public:
virtual ~OnDecryptedFrameCallback() = default;
// Called each time a decrypted frame is returned.
virtual void OnDecryptedFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) = 0;
virtual void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) = 0;
};
// This callback is called each time there is a status change in the decryption
@ -72,8 +71,7 @@ class BufferedFrameDecryptor final {
// Determines whether the frame should be stashed, dropped or handed off to
// the OnDecryptedFrameCallback.
void ManageEncryptedFrame(
std::unique_ptr<video_coding::RtpFrameObject> encrypted_frame);
void ManageEncryptedFrame(std::unique_ptr<RtpFrameObject> encrypted_frame);
private:
// Represents what should be done with a given frame.
@ -82,7 +80,7 @@ class BufferedFrameDecryptor final {
// Attempts to decrypt the frame, if it fails and no prior frames have been
// decrypted it will return kStash. Otherwise fail to decrypts will return
// kDrop. Successful decryptions will always return kDecrypted.
FrameDecision DecryptFrame(video_coding::RtpFrameObject* frame);
FrameDecision DecryptFrame(RtpFrameObject* frame);
// Retries all the stashed frames this is triggered each time a kDecrypted
// event occurs.
void RetryStashedFrames();
@ -96,7 +94,7 @@ class BufferedFrameDecryptor final {
rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_;
OnDecryptedFrameCallback* const decrypted_frame_callback_;
OnDecryptionStatusChangeCallback* const decryption_status_change_callback_;
std::deque<std::unique_ptr<video_coding::RtpFrameObject>> stashed_frames_;
std::deque<std::unique_ptr<RtpFrameObject>> stashed_frames_;
};
} // namespace webrtc

8
video/buffered_frame_decryptor_unittest.cc
View File

@ -43,8 +43,7 @@ class BufferedFrameDecryptorTest : public ::testing::Test,
public OnDecryptionStatusChangeCallback {
public:
// Implements the OnDecryptedFrameCallbackInterface
void OnDecryptedFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) override {
void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override {
decrypted_frame_call_count_++;
}
@ -54,14 +53,13 @@ class BufferedFrameDecryptorTest : public ::testing::Test,
// Returns a new fake RtpFrameObject it abstracts the difficult construction
// of the RtpFrameObject to simplify testing.
std::unique_ptr<video_coding::RtpFrameObject> CreateRtpFrameObject(
bool key_frame) {
std::unique_ptr<RtpFrameObject> CreateRtpFrameObject(bool key_frame) {
seq_num_++;
RTPVideoHeader rtp_video_header;
rtp_video_header.generic.emplace();
// clang-format off
return std::make_unique<video_coding::RtpFrameObject>(
return std::make_unique<RtpFrameObject>(
seq_num_,
seq_num_,
/*markerBit=*/true,

13
video/rtp_video_stream_receiver.cc
View File

@ -794,7 +794,7 @@ void RtpVideoStreamReceiver::OnInsertedPacket(
}
const video_coding::PacketBuffer::Packet& last_packet = *packet;
OnAssembledFrame(std::make_unique<video_coding::RtpFrameObject>(
OnAssembledFrame(std::make_unique<RtpFrameObject>(
first_packet->seq_num, //
last_packet.seq_num, //
last_packet.marker_bit, //
@ -821,7 +821,7 @@ void RtpVideoStreamReceiver::OnInsertedPacket(
}
void RtpVideoStreamReceiver::OnAssembledFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
RTC_DCHECK_RUN_ON(&network_tc_);
RTC_DCHECK(frame);
@ -890,11 +890,10 @@ void RtpVideoStreamReceiver::OnAssembledFrame(
}
void RtpVideoStreamReceiver::OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) {
std::unique_ptr<EncodedFrame> frame) {
{
MutexLock lock(&last_seq_num_mutex_);
video_coding::RtpFrameObject* rtp_frame =
static_cast<video_coding::RtpFrameObject*>(frame.get());
RtpFrameObject* rtp_frame = static_cast<RtpFrameObject*>(frame.get());
last_seq_num_for_pic_id_[rtp_frame->Id()] = rtp_frame->last_seq_num();
}
last_completed_picture_id_ =
@ -903,7 +902,7 @@ void RtpVideoStreamReceiver::OnCompleteFrame(
}
void RtpVideoStreamReceiver::OnDecryptedFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
MutexLock lock(&reference_finder_lock_);
reference_finder_->ManageFrame(std::move(frame));
}
@ -970,7 +969,7 @@ void RtpVideoStreamReceiver::RemoveSecondarySink(
}
void RtpVideoStreamReceiver::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
MutexLock lock(&reference_finder_lock_);
reference_finder_->ManageFrame(std::move(frame));
}

11
video/rtp_video_stream_receiver.h
View File

@ -172,12 +172,10 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
// Implements OnCompleteFrameCallback.
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override;
void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
// Implements OnDecryptedFrameCallback.
void OnDecryptedFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) override;
void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override;
// Implements OnDecryptionStatusChangeCallback.
void OnDecryptionStatusChange(
@ -208,8 +206,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
private:
// Implements RtpVideoFrameReceiver.
void ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) override;
void ManageFrame(std::unique_ptr<RtpFrameObject> frame) override;
// Used for buffering RTCP feedback messages and sending them all together.
// Note:
@ -305,7 +302,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
ParseGenericDependenciesResult ParseGenericDependenciesExtension(
const RtpPacketReceived& rtp_packet,
RTPVideoHeader* video_header) RTC_RUN_ON(worker_task_checker_);
void OnAssembledFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame);
Clock* const clock_;
// Ownership of this object lies with VideoReceiveStream, which owns |this|.

13
video/rtp_video_stream_receiver2.cc
View File

@ -764,7 +764,7 @@ void RtpVideoStreamReceiver2::OnInsertedPacket(
}
const video_coding::PacketBuffer::Packet& last_packet = *packet;
OnAssembledFrame(std::make_unique<video_coding::RtpFrameObject>(
OnAssembledFrame(std::make_unique<RtpFrameObject>(
first_packet->seq_num, //
last_packet.seq_num, //
last_packet.marker_bit, //
@ -791,7 +791,7 @@ void RtpVideoStreamReceiver2::OnInsertedPacket(
}
void RtpVideoStreamReceiver2::OnAssembledFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
RTC_DCHECK(frame);
@ -859,10 +859,9 @@ void RtpVideoStreamReceiver2::OnAssembledFrame(
}
void RtpVideoStreamReceiver2::OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) {
std::unique_ptr<EncodedFrame> frame) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
video_coding::RtpFrameObject* rtp_frame =
static_cast<video_coding::RtpFrameObject*>(frame.get());
RtpFrameObject* rtp_frame = static_cast<RtpFrameObject*>(frame.get());
last_seq_num_for_pic_id_[rtp_frame->Id()] = rtp_frame->last_seq_num();
last_completed_picture_id_ =
@ -871,7 +870,7 @@ void RtpVideoStreamReceiver2::OnCompleteFrame(
}
void RtpVideoStreamReceiver2::OnDecryptedFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
reference_finder_->ManageFrame(std::move(frame));
}
@ -922,7 +921,7 @@ absl::optional<int64_t> RtpVideoStreamReceiver2::LastReceivedKeyframePacketMs()
}
void RtpVideoStreamReceiver2::ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
RTC_DCHECK_RUN_ON(&worker_task_checker_);
reference_finder_->ManageFrame(std::move(frame));
}

11
video/rtp_video_stream_receiver2.h
View File

@ -148,12 +148,10 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
void RequestPacketRetransmit(const std::vector<uint16_t>& sequence_numbers);
// Implements OnCompleteFrameCallback.
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override;
void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
// Implements OnDecryptedFrameCallback.
void OnDecryptedFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) override;
void OnDecryptedFrame(std::unique_ptr<RtpFrameObject> frame) override;
// Implements OnDecryptionStatusChangeCallback.
void OnDecryptionStatusChange(
@ -177,8 +175,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
private:
// Implements RtpVideoFrameReceiver.
void ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) override;
void ManageFrame(std::unique_ptr<RtpFrameObject> frame) override;
// Used for buffering RTCP feedback messages and sending them all together.
// Note:
@ -262,7 +259,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
ParseGenericDependenciesResult ParseGenericDependenciesExtension(
const RtpPacketReceived& rtp_packet,
RTPVideoHeader* video_header) RTC_RUN_ON(worker_task_checker_);
void OnAssembledFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
void OnAssembledFrame(std::unique_ptr<RtpFrameObject> frame);
Clock* const clock_;
// Ownership of this object lies with VideoReceiveStream, which owns |this|.

80
video/rtp_video_stream_receiver2_unittest.cc
View File

@ -51,8 +51,7 @@ namespace {
const uint8_t kH264StartCode[] = {0x00, 0x00, 0x00, 0x01};
std::vector<uint64_t> GetAbsoluteCaptureTimestamps(
const video_coding::EncodedFrame* frame) {
std::vector<uint64_t> GetAbsoluteCaptureTimestamps(const EncodedFrame* frame) {
std::vector<uint64_t> result;
for (const auto& packet_info : frame->PacketInfos()) {
if (packet_info.absolute_capture_time()) {
@ -97,21 +96,11 @@ class MockKeyFrameRequestSender : public KeyFrameRequestSender {
class MockOnCompleteFrameCallback : public OnCompleteFrameCallback {
public:
MOCK_METHOD(void, DoOnCompleteFrame, (video_coding::EncodedFrame*), ());
MOCK_METHOD(void,
DoOnCompleteFrameFailNullptr,
(video_coding::EncodedFrame*),
());
MOCK_METHOD(void,
DoOnCompleteFrameFailLength,
(video_coding::EncodedFrame*),
());
MOCK_METHOD(void,
DoOnCompleteFrameFailBitstream,
(video_coding::EncodedFrame*),
());
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override {
MOCK_METHOD(void, DoOnCompleteFrame, (EncodedFrame*), ());
MOCK_METHOD(void, DoOnCompleteFrameFailNullptr, (EncodedFrame*), ());
MOCK_METHOD(void, DoOnCompleteFrameFailLength, (EncodedFrame*), ());
MOCK_METHOD(void, DoOnCompleteFrameFailBitstream, (EncodedFrame*), ());
void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {
if (!frame) {
DoOnCompleteFrameFailNullptr(nullptr);
return;
@ -351,7 +340,7 @@ TEST_F(RtpVideoStreamReceiver2Test, CacheColorSpaceFromLastPacketOfKeyframe) {
EXPECT_TRUE(key_frame_packet2.GetExtension<ColorSpaceExtension>());
rtp_video_stream_receiver_->OnRtpPacket(key_frame_packet1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([kColorSpace](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
ASSERT_TRUE(frame->EncodedImage().ColorSpace());
EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
}));
@ -367,7 +356,7 @@ TEST_F(RtpVideoStreamReceiver2Test, CacheColorSpaceFromLastPacketOfKeyframe) {
// included in the RTP packet.
EXPECT_FALSE(delta_frame_packet.GetExtension<ColorSpaceExtension>());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([kColorSpace](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
ASSERT_TRUE(frame->EncodedImage().ColorSpace());
EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
}));
@ -409,11 +398,10 @@ TEST_F(RtpVideoStreamReceiver2Test, PacketInfoIsPropagatedIntoVideoFrames) {
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke(
[kAbsoluteCaptureTimestamp](video_coding::EncodedFrame* frame) {
EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
ElementsAre(kAbsoluteCaptureTimestamp));
}));
.WillOnce(Invoke([kAbsoluteCaptureTimestamp](EncodedFrame* frame) {
EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
ElementsAre(kAbsoluteCaptureTimestamp));
}));
rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
video_header);
}
@ -457,7 +445,7 @@ TEST_F(RtpVideoStreamReceiver2Test,
// Expect rtp video stream receiver to extrapolate it for the resulting video
// frame using absolute capture time from the previous packet.
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([](EncodedFrame* frame) {
EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame), SizeIs(1));
}));
rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
@ -670,9 +658,8 @@ TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) {
mock_on_complete_frame_callback_.AppendExpectedBitstream(idr_data.data(),
idr_data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
EXPECT_TRUE(frame->is_keyframe());
});
.WillOnce(
[&](EncodedFrame* frame) { EXPECT_TRUE(frame->is_keyframe()); });
rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
idr_video_header);
mock_on_complete_frame_callback_.ClearExpectedBitstream();
@ -682,9 +669,8 @@ TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) {
idr_data.size());
rtp_packet.SetSequenceNumber(3);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
EXPECT_FALSE(frame->is_keyframe());
});
.WillOnce(
[&](EncodedFrame* frame) { EXPECT_FALSE(frame->is_keyframe()); });
rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
idr_video_header);
}
@ -826,7 +812,7 @@ TEST_F(RtpVideoStreamReceiver2Test, ParseGenericDescriptorOnePacket) {
rtp_packet.SetSequenceNumber(1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce(Invoke([kSpatialIndex](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
EXPECT_EQ(frame->num_references, 2U);
EXPECT_EQ(frame->references[0], frame->Id() - 90);
EXPECT_EQ(frame->references[1], frame->Id() - 80);
@ -884,7 +870,7 @@ TEST_F(RtpVideoStreamReceiver2Test, ParseGenericDescriptorTwoPackets) {
data.size() - 1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce(Invoke([kSpatialIndex](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
EXPECT_EQ(frame->num_references, 0U);
EXPECT_EQ(frame->SpatialIndex(), kSpatialIndex);
EXPECT_EQ(frame->EncodedImage()._encodedWidth, 480u);
@ -963,13 +949,11 @@ TEST_F(RtpVideoStreamReceiver2Test, UnwrapsFrameId) {
int64_t first_picture_id;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
first_picture_id = frame->Id();
});
.WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
inject_packet(/*wrapped_frame_id=*/0xffff);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
.WillOnce([&](EncodedFrame* frame) {
EXPECT_EQ(frame->Id() - first_picture_id, 3);
});
inject_packet(/*wrapped_frame_id=*/0x0002);
@ -1034,9 +1018,7 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest, UnwrapsFrameId) {
// keyframe. Thus feed a key frame first, then test reodered delta frames.
int64_t first_picture_id;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
first_picture_id = frame->Id();
});
.WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
InjectPacketWith(stream_structure, keyframe_descriptor);
DependencyDescriptor deltaframe1_descriptor;
@ -1050,11 +1032,11 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest, UnwrapsFrameId) {
// Parser should unwrap frame ids correctly even if packets were reordered by
// the network.
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
.WillOnce([&](EncodedFrame* frame) {
// 0x0002 - 0xfff0
EXPECT_EQ(frame->Id() - first_picture_id, 18);
})
.WillOnce([&](video_coding::EncodedFrame* frame) {
.WillOnce([&](EncodedFrame* frame) {
// 0xfffe - 0xfff0
EXPECT_EQ(frame->Id() - first_picture_id, 14);
});
@ -1120,9 +1102,8 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest,
keyframe2_descriptor.frame_number = 3;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
EXPECT_EQ(frame->Id() & 0xFFFF, 3);
});
.WillOnce(
[&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 3); });
InjectPacketWith(stream_structure2, keyframe2_descriptor);
InjectPacketWith(stream_structure1, keyframe1_descriptor);
@ -1132,9 +1113,8 @@ TEST_F(RtpVideoStreamReceiver2DependencyDescriptorTest,
deltaframe_descriptor.frame_dependencies = stream_structure2.templates[0];
deltaframe_descriptor.frame_number = 4;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
EXPECT_EQ(frame->Id() & 0xFFFF, 4);
});
.WillOnce(
[&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 4); });
InjectPacketWith(stream_structure2, deltaframe_descriptor);
}
@ -1218,8 +1198,8 @@ TEST_P(RtpVideoStreamReceiver2TestPlayoutDelay, PlayoutDelay) {
// Expect the playout delay of encoded frame to be the same as the transmitted
// playout delay unless it was overridden by a field trial.
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([expected_playout_delay = GetParam().expected_delay](
video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([expected_playout_delay =
GetParam().expected_delay](EncodedFrame* frame) {
EXPECT_EQ(frame->EncodedImage().playout_delay_, expected_playout_delay);
}));
rtp_video_stream_receiver_->OnReceivedPayloadData(

11
video/rtp_video_stream_receiver_frame_transformer_delegate.cc
View File

@ -24,9 +24,8 @@ namespace {
class TransformableVideoReceiverFrame
: public TransformableVideoFrameInterface {
public:
TransformableVideoReceiverFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame,
uint32_t ssrc)
TransformableVideoReceiverFrame(std::unique_ptr<RtpFrameObject> frame,
uint32_t ssrc)
: frame_(std::move(frame)),
metadata_(frame_->GetRtpVideoHeader()),
ssrc_(ssrc) {}
@ -55,12 +54,12 @@ class TransformableVideoReceiverFrame
const VideoFrameMetadata& GetMetadata() const override { return metadata_; }
std::unique_ptr<video_coding::RtpFrameObject> ExtractFrame() && {
std::unique_ptr<RtpFrameObject> ExtractFrame() && {
return std::move(frame_);
}
private:
std::unique_ptr<video_coding::RtpFrameObject> frame_;
std::unique_ptr<RtpFrameObject> frame_;
const VideoFrameMetadata metadata_;
const uint32_t ssrc_;
};
@ -91,7 +90,7 @@ void RtpVideoStreamReceiverFrameTransformerDelegate::Reset() {
}
void RtpVideoStreamReceiverFrameTransformerDelegate::TransformFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) {
std::unique_ptr<RtpFrameObject> frame) {
RTC_DCHECK_RUN_ON(&network_sequence_checker_);
frame_transformer_->Transform(
std::make_unique<TransformableVideoReceiverFrame>(std::move(frame),

5
video/rtp_video_stream_receiver_frame_transformer_delegate.h
View File

@ -25,8 +25,7 @@ namespace webrtc {
// thread after transformation.
class RtpVideoFrameReceiver {
public:
virtual void ManageFrame(
std::unique_ptr<video_coding::RtpFrameObject> frame) = 0;
virtual void ManageFrame(std::unique_ptr<RtpFrameObject> frame) = 0;
protected:
virtual ~RtpVideoFrameReceiver() = default;
@ -47,7 +46,7 @@ class RtpVideoStreamReceiverFrameTransformerDelegate
void Reset();
// Delegates the call to FrameTransformerInterface::TransformFrame.
void TransformFrame(std::unique_ptr<video_coding::RtpFrameObject> frame);
void TransformFrame(std::unique_ptr<RtpFrameObject> frame);
// Implements TransformedFrameCallback. Can be called on any thread. Posts
// the transformed frame to be managed on the |network_thread_|.

8
video/rtp_video_stream_receiver_frame_transformer_delegate_unittest.cc
View File

@ -35,15 +35,15 @@ using ::testing::ElementsAre;
using ::testing::NiceMock;
using ::testing::SaveArg;
std::unique_ptr<video_coding::RtpFrameObject> CreateRtpFrameObject(
std::unique_ptr<RtpFrameObject> CreateRtpFrameObject(
const RTPVideoHeader& video_header) {
return std::make_unique<video_coding::RtpFrameObject>(
return std::make_unique<RtpFrameObject>(
0, 0, true, 0, 0, 0, 0, 0, VideoSendTiming(), 0, video_header.codec,
kVideoRotation_0, VideoContentType::UNSPECIFIED, video_header,
absl::nullopt, RtpPacketInfos(), EncodedImageBuffer::Create(0));
}
std::unique_ptr<video_coding::RtpFrameObject> CreateRtpFrameObject() {
std::unique_ptr<RtpFrameObject> CreateRtpFrameObject() {
return CreateRtpFrameObject(RTPVideoHeader());
}
@ -54,7 +54,7 @@ class TestRtpVideoFrameReceiver : public RtpVideoFrameReceiver {
MOCK_METHOD(void,
ManageFrame,
(std::unique_ptr<video_coding::RtpFrameObject> frame),
(std::unique_ptr<RtpFrameObject> frame),
(override));
};

80
video/rtp_video_stream_receiver_unittest.cc
View File

@ -50,8 +50,7 @@ namespace {
const uint8_t kH264StartCode[] = {0x00, 0x00, 0x00, 0x01};
std::vector<uint64_t> GetAbsoluteCaptureTimestamps(
const video_coding::EncodedFrame* frame) {
std::vector<uint64_t> GetAbsoluteCaptureTimestamps(const EncodedFrame* frame) {
std::vector<uint64_t> result;
for (const auto& packet_info : frame->PacketInfos()) {
if (packet_info.absolute_capture_time()) {
@ -96,21 +95,11 @@ class MockKeyFrameRequestSender : public KeyFrameRequestSender {
class MockOnCompleteFrameCallback : public OnCompleteFrameCallback {
public:
MOCK_METHOD(void, DoOnCompleteFrame, (video_coding::EncodedFrame*), ());
MOCK_METHOD(void,
DoOnCompleteFrameFailNullptr,
(video_coding::EncodedFrame*),
());
MOCK_METHOD(void,
DoOnCompleteFrameFailLength,
(video_coding::EncodedFrame*),
());
MOCK_METHOD(void,
DoOnCompleteFrameFailBitstream,
(video_coding::EncodedFrame*),
());
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override {
MOCK_METHOD(void, DoOnCompleteFrame, (EncodedFrame*), ());
MOCK_METHOD(void, DoOnCompleteFrameFailNullptr, (EncodedFrame*), ());
MOCK_METHOD(void, DoOnCompleteFrameFailLength, (EncodedFrame*), ());
MOCK_METHOD(void, DoOnCompleteFrameFailBitstream, (EncodedFrame*), ());
void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override {
if (!frame) {
DoOnCompleteFrameFailNullptr(nullptr);
return;
@ -338,7 +327,7 @@ TEST_F(RtpVideoStreamReceiverTest, CacheColorSpaceFromLastPacketOfKeyframe) {
EXPECT_TRUE(key_frame_packet2.GetExtension<ColorSpaceExtension>());
rtp_video_stream_receiver_->OnRtpPacket(key_frame_packet1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([kColorSpace](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
ASSERT_TRUE(frame->EncodedImage().ColorSpace());
EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
}));
@ -354,7 +343,7 @@ TEST_F(RtpVideoStreamReceiverTest, CacheColorSpaceFromLastPacketOfKeyframe) {
// included in the RTP packet.
EXPECT_FALSE(delta_frame_packet.GetExtension<ColorSpaceExtension>());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([kColorSpace](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
ASSERT_TRUE(frame->EncodedImage().ColorSpace());
EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
}));
@ -396,11 +385,10 @@ TEST_F(RtpVideoStreamReceiverTest, PacketInfoIsPropagatedIntoVideoFrames) {
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke(
[kAbsoluteCaptureTimestamp](video_coding::EncodedFrame* frame) {
EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
ElementsAre(kAbsoluteCaptureTimestamp));
}));
.WillOnce(Invoke([kAbsoluteCaptureTimestamp](EncodedFrame* frame) {
EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
ElementsAre(kAbsoluteCaptureTimestamp));
}));
rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
video_header);
}
@ -444,7 +432,7 @@ TEST_F(RtpVideoStreamReceiverTest,
// Expect rtp video stream receiver to extrapolate it for the resulting video
// frame using absolute capture time from the previous packet.
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([](EncodedFrame* frame) {
EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame), SizeIs(1));
}));
rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
@ -656,9 +644,8 @@ TEST_P(RtpVideoStreamReceiverTestH264, ForceSpsPpsIdrIsKeyframe) {
mock_on_complete_frame_callback_.AppendExpectedBitstream(idr_data.data(),
idr_data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
EXPECT_TRUE(frame->is_keyframe());
});
.WillOnce(
[&](EncodedFrame* frame) { EXPECT_TRUE(frame->is_keyframe()); });
rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
idr_video_header);
mock_on_complete_frame_callback_.ClearExpectedBitstream();
@ -668,9 +655,8 @@ TEST_P(RtpVideoStreamReceiverTestH264, ForceSpsPpsIdrIsKeyframe) {
idr_data.size());
rtp_packet.SetSequenceNumber(3);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
EXPECT_FALSE(frame->is_keyframe());
});
.WillOnce(
[&](EncodedFrame* frame) { EXPECT_FALSE(frame->is_keyframe()); });
rtp_video_stream_receiver_->OnReceivedPayloadData(idr_data, rtp_packet,
idr_video_header);
}
@ -858,7 +844,7 @@ TEST_F(RtpVideoStreamReceiverTest, ParseGenericDescriptorOnePacket) {
rtp_packet.SetSequenceNumber(1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce(Invoke([kSpatialIndex](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
EXPECT_EQ(frame->num_references, 2U);
EXPECT_EQ(frame->references[0], frame->Id() - 90);
EXPECT_EQ(frame->references[1], frame->Id() - 80);
@ -916,7 +902,7 @@ TEST_F(RtpVideoStreamReceiverTest, ParseGenericDescriptorTwoPackets) {
data.size() - 1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce(Invoke([kSpatialIndex](video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
EXPECT_EQ(frame->num_references, 0U);
EXPECT_EQ(frame->SpatialIndex(), kSpatialIndex);
EXPECT_EQ(frame->EncodedImage()._encodedWidth, 480u);
@ -995,13 +981,11 @@ TEST_F(RtpVideoStreamReceiverTest, UnwrapsFrameId) {
int64_t first_picture_id;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
first_picture_id = frame->Id();
});
.WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
inject_packet(/*wrapped_frame_id=*/0xffff);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
.WillOnce([&](EncodedFrame* frame) {
EXPECT_EQ(frame->Id() - first_picture_id, 3);
});
inject_packet(/*wrapped_frame_id=*/0x0002);
@ -1066,9 +1050,7 @@ TEST_F(RtpVideoStreamReceiverDependencyDescriptorTest, UnwrapsFrameId) {
// keyframe. Thus feed a key frame first, then test reodered delta frames.
int64_t first_picture_id;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
first_picture_id = frame->Id();
});
.WillOnce([&](EncodedFrame* frame) { first_picture_id = frame->Id(); });
InjectPacketWith(stream_structure, keyframe_descriptor);
DependencyDescriptor deltaframe1_descriptor;
@ -1082,11 +1064,11 @@ TEST_F(RtpVideoStreamReceiverDependencyDescriptorTest, UnwrapsFrameId) {
// Parser should unwrap frame ids correctly even if packets were reordered by
// the network.
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
.WillOnce([&](EncodedFrame* frame) {
// 0x0002 - 0xfff0
EXPECT_EQ(frame->Id() - first_picture_id, 18);
})
.WillOnce([&](video_coding::EncodedFrame* frame) {
.WillOnce([&](EncodedFrame* frame) {
// 0xfffe - 0xfff0
EXPECT_EQ(frame->Id() - first_picture_id, 14);
});
@ -1152,9 +1134,8 @@ TEST_F(RtpVideoStreamReceiverDependencyDescriptorTest,
keyframe2_descriptor.frame_number = 3;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
EXPECT_EQ(frame->Id() & 0xFFFF, 3);
});
.WillOnce(
[&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 3); });
InjectPacketWith(stream_structure2, keyframe2_descriptor);
InjectPacketWith(stream_structure1, keyframe1_descriptor);
@ -1164,9 +1145,8 @@ TEST_F(RtpVideoStreamReceiverDependencyDescriptorTest,
deltaframe_descriptor.frame_dependencies = stream_structure2.templates[0];
deltaframe_descriptor.frame_number = 4;
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce([&](video_coding::EncodedFrame* frame) {
EXPECT_EQ(frame->Id() & 0xFFFF, 4);
});
.WillOnce(
[&](EncodedFrame* frame) { EXPECT_EQ(frame->Id() & 0xFFFF, 4); });
InjectPacketWith(stream_structure2, deltaframe_descriptor);
}
@ -1264,8 +1244,8 @@ TEST_P(RtpVideoStreamReceiverTestPlayoutDelay, PlayoutDelay) {
// Expect the playout delay of encoded frame to be the same as the transmitted
// playout delay unless it was overridden by a field trial.
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([expected_playout_delay = GetParam().expected_delay](
video_coding::EncodedFrame* frame) {
.WillOnce(Invoke([expected_playout_delay =
GetParam().expected_delay](EncodedFrame* frame) {
EXPECT_EQ(frame->EncodedImage().playout_delay_, expected_playout_delay);
}));
rtp_video_stream_receiver_->OnReceivedPayloadData(

6
video/video_receive_stream.cc
View File

@ -60,7 +60,6 @@ constexpr int VideoReceiveStream::kMaxWaitForKeyFrameMs;
namespace {
using video_coding::EncodedFrame;
using ReturnReason = video_coding::FrameBuffer::ReturnReason;
constexpr int kMinBaseMinimumDelayMs = 0;
@ -69,7 +68,7 @@ constexpr int kMaxBaseMinimumDelayMs = 10000;
constexpr int kMaxWaitForFrameMs = 3000;
// Concrete instance of RecordableEncodedFrame wrapping needed content
// from video_coding::EncodedFrame.
// from EncodedFrame.
class WebRtcRecordableEncodedFrame : public RecordableEncodedFrame {
public:
explicit WebRtcRecordableEncodedFrame(const EncodedFrame& frame)
@ -554,8 +553,7 @@ void VideoReceiveStream::RequestKeyFrame(int64_t timestamp_ms) {
last_keyframe_request_ms_ = timestamp_ms;
}
void VideoReceiveStream::OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) {
void VideoReceiveStream::OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) {
RTC_DCHECK_RUN_ON(&network_sequence_checker_);
// TODO(https://bugs.webrtc.org/9974): Consider removing this workaround.
int64_t time_now_ms = clock_->TimeInMilliseconds();

5
video/video_receive_stream.h
View File

@ -112,8 +112,7 @@ class VideoReceiveStream : public webrtc::DEPRECATED_VideoReceiveStream,
bool buffering_allowed) override;
// Implements OnCompleteFrameCallback.
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override;
void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
// Implements CallStatsObserver::OnRttUpdate
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
@ -138,7 +137,7 @@ class VideoReceiveStream : public webrtc::DEPRECATED_VideoReceiveStream,
private:
int64_t GetWaitMs() const;
void StartNextDecode() RTC_RUN_ON(decode_queue_);
void HandleEncodedFrame(std::unique_ptr<video_coding::EncodedFrame> frame)
void HandleEncodedFrame(std::unique_ptr<EncodedFrame> frame)
RTC_RUN_ON(decode_queue_);
void HandleFrameBufferTimeout() RTC_RUN_ON(decode_queue_);
void UpdatePlayoutDelays() const

6
video/video_receive_stream2.cc
View File

@ -58,7 +58,6 @@ constexpr int VideoReceiveStream2::kMaxWaitForKeyFrameMs;
namespace {
using video_coding::EncodedFrame;
using ReturnReason = video_coding::FrameBuffer::ReturnReason;
constexpr int kMinBaseMinimumDelayMs = 0;
@ -69,7 +68,7 @@ constexpr int kMaxWaitForFrameMs = 3000;
constexpr int kDefaultMaximumPreStreamDecoders = 100;
// Concrete instance of RecordableEncodedFrame wrapping needed content
// from video_coding::EncodedFrame.
// from EncodedFrame.
class WebRtcRecordableEncodedFrame : public RecordableEncodedFrame {
public:
explicit WebRtcRecordableEncodedFrame(const EncodedFrame& frame)
@ -557,8 +556,7 @@ void VideoReceiveStream2::RequestKeyFrame(int64_t timestamp_ms) {
});
}
void VideoReceiveStream2::OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) {
void VideoReceiveStream2::OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
// TODO(https://bugs.webrtc.org/9974): Consider removing this workaround.

5
video/video_receive_stream2.h
View File

@ -131,8 +131,7 @@ class VideoReceiveStream2 : public webrtc::VideoReceiveStream,
bool buffering_allowed) override;
// Implements OnCompleteFrameCallback.
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override;
void OnCompleteFrame(std::unique_ptr<EncodedFrame> frame) override;
// Implements CallStatsObserver::OnRttUpdate
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
@ -158,7 +157,7 @@ class VideoReceiveStream2 : public webrtc::VideoReceiveStream,
void CreateAndRegisterExternalDecoder(const Decoder& decoder);
int64_t GetMaxWaitMs() const RTC_RUN_ON(decode_queue_);
void StartNextDecode() RTC_RUN_ON(decode_queue_);
void HandleEncodedFrame(std::unique_ptr<video_coding::EncodedFrame> frame)
void HandleEncodedFrame(std::unique_ptr<EncodedFrame> frame)
RTC_RUN_ON(decode_queue_);
void HandleFrameBufferTimeout(int64_t now_ms, int64_t wait_ms)
RTC_RUN_ON(worker_sequence_checker_);

5
video/video_receive_stream2_unittest.cc
View File

@ -84,7 +84,7 @@ class MockVideoDecoderFactory : public VideoDecoderFactory {
std::unique_ptr<VideoDecoder>(const SdpVideoFormat& format));
};
class FrameObjectFake : public video_coding::EncodedFrame {
class FrameObjectFake : public EncodedFrame {
public:
void SetPayloadType(uint8_t payload_type) { _payloadType = payload_type; }
@ -543,8 +543,7 @@ class VideoReceiveStream2TestWithSimulatedClock : public ::testing::Test {
void OnFrameDecoded() { event_->Set(); }
void PassEncodedFrameAndWait(
std::unique_ptr<video_coding::EncodedFrame> frame) {
void PassEncodedFrameAndWait(std::unique_ptr<EncodedFrame> frame) {
event_ = std::make_unique<rtc::Event>();
// This call will eventually end up in the Decoded method where the
// event is set.

15
video/video_receive_stream_unittest.cc
View File

@ -76,7 +76,7 @@ class MockVideoDecoder : public VideoDecoder {
const char* ImplementationName() const { return "MockVideoDecoder"; }
};
class FrameObjectFake : public video_coding::EncodedFrame {
class FrameObjectFake : public EncodedFrame {
public:
void SetPayloadType(uint8_t payload_type) { _payloadType = payload_type; }
@ -496,13 +496,12 @@ class VideoReceiveStreamTestWithSimulatedClock : public ::testing::Test {
void OnFrameDecoded() { event_->Set(); }
void PassEncodedFrameAndWait(
std::unique_ptr<video_coding::EncodedFrame> frame) {
event_ = std::make_unique<rtc::Event>();
// This call will eventually end up in the Decoded method where the
// event is set.
video_receive_stream_.OnCompleteFrame(std::move(frame));
event_->Wait(rtc::Event::kForever);
void PassEncodedFrameAndWait(std::unique_ptr<EncodedFrame> frame) {
event_ = std::make_unique<rtc::Event>();
// This call will eventually end up in the Decoded method where the
// event is set.
video_receive_stream_.OnCompleteFrame(std::move(frame));
event_->Wait(rtc::Event::kForever);
}
protected:

12
video/video_stream_decoder_impl.cc
View File

@ -50,8 +50,7 @@ VideoStreamDecoderImpl::~VideoStreamDecoderImpl() {
shut_down_ = true;
}
void VideoStreamDecoderImpl::OnFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) {
void VideoStreamDecoderImpl::OnFrame(std::unique_ptr<EncodedFrame> frame) {
if (!bookkeeping_queue_.IsCurrent()) {
bookkeeping_queue_.PostTask([this, frame = std::move(frame)]() mutable {
OnFrame(std::move(frame));
@ -123,8 +122,7 @@ VideoDecoder* VideoStreamDecoderImpl::GetDecoder(int payload_type) {
return decoder_.get();
}
void VideoStreamDecoderImpl::SaveFrameInfo(
const video_coding::EncodedFrame& frame) {
void VideoStreamDecoderImpl::SaveFrameInfo(const EncodedFrame& frame) {
FrameInfo* frame_info = &frame_info_[next_frame_info_index_];
frame_info->timestamp = frame.Timestamp();
frame_info->decode_start_time_ms = rtc::TimeMillis();
@ -139,7 +137,7 @@ void VideoStreamDecoderImpl::StartNextDecode() {
frame_buffer_.NextFrame(
max_wait_time, keyframe_required_, &bookkeeping_queue_,
[this](std::unique_ptr<video_coding::EncodedFrame> frame,
[this](std::unique_ptr<EncodedFrame> frame,
video_coding::FrameBuffer::ReturnReason res) mutable {
RTC_DCHECK_RUN_ON(&bookkeeping_queue_);
OnNextFrameCallback(std::move(frame), res);
@ -147,7 +145,7 @@ void VideoStreamDecoderImpl::StartNextDecode() {
}
void VideoStreamDecoderImpl::OnNextFrameCallback(
std::unique_ptr<video_coding::EncodedFrame> frame,
std::unique_ptr<EncodedFrame> frame,
video_coding::FrameBuffer::ReturnReason result) {
switch (result) {
case video_coding::FrameBuffer::kFrameFound: {
@ -204,7 +202,7 @@ void VideoStreamDecoderImpl::OnNextFrameCallback(
}
VideoStreamDecoderImpl::DecodeResult VideoStreamDecoderImpl::DecodeFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) {
std::unique_ptr<EncodedFrame> frame) {
RTC_DCHECK(frame);
VideoDecoder* decoder = GetDecoder(frame->PayloadType());

10
video/video_stream_decoder_impl.h
View File

@ -37,7 +37,7 @@ class VideoStreamDecoderImpl : public VideoStreamDecoderInterface {
~VideoStreamDecoderImpl() override;
void OnFrame(std::unique_ptr<video_coding::EncodedFrame> frame) override;
void OnFrame(std::unique_ptr<EncodedFrame> frame) override;
void SetMinPlayoutDelay(TimeDelta min_delay) override;
void SetMaxPlayoutDelay(TimeDelta max_delay) override;
@ -69,11 +69,10 @@ class VideoStreamDecoderImpl : public VideoStreamDecoderInterface {
VideoContentType content_type;
};
void SaveFrameInfo(const video_coding::EncodedFrame& frame)
RTC_RUN_ON(bookkeeping_queue_);
void SaveFrameInfo(const EncodedFrame& frame) RTC_RUN_ON(bookkeeping_queue_);
FrameInfo* GetFrameInfo(int64_t timestamp) RTC_RUN_ON(bookkeeping_queue_);
void StartNextDecode() RTC_RUN_ON(bookkeeping_queue_);
void OnNextFrameCallback(std::unique_ptr<video_coding::EncodedFrame> frame,
void OnNextFrameCallback(std::unique_ptr<EncodedFrame> frame,
video_coding::FrameBuffer::ReturnReason res)
RTC_RUN_ON(bookkeeping_queue_);
void OnDecodedFrameCallback(VideoFrame& decodedImage, // NOLINT
@ -82,8 +81,7 @@ class VideoStreamDecoderImpl : public VideoStreamDecoderInterface {
VideoDecoder* GetDecoder(int payload_type) RTC_RUN_ON(decode_queue_);
VideoStreamDecoderImpl::DecodeResult DecodeFrame(
std::unique_ptr<video_coding::EncodedFrame> frame)
RTC_RUN_ON(decode_queue_);
std::unique_ptr<EncodedFrame> frame) RTC_RUN_ON(decode_queue_);
VCMTiming timing_;
DecodeCallbacks decode_callbacks_;

2
video/video_stream_decoder_impl_unittest.cc
View File

@ -127,7 +127,7 @@ class FakeVideoDecoderFactory : public VideoDecoderFactory {
NiceMock<StubVideoDecoder> av1_decoder_;
};
class FakeEncodedFrame : public video_coding::EncodedFrame {
class FakeEncodedFrame : public EncodedFrame {
public:
int64_t ReceivedTime() const override { return 0; }
int64_t RenderTime() const override { return 0; }