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

Prepare for splitting FrameType into AudioFrameType and VideoFrameType

Browse Source 
This cl deprecates the FrameType enum, and adds aliases AudioFrameType
and VideoFrameType.

After downstream usage is updated, the enums will be separated
and be moved out of common_types.h.

Bug: webrtc:6883
Change-Id: I2aaf660169da45f22574b4cbb16aea8522cc07a6
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/123184
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27011}
This commit is contained in:
Niels Möller 2019-03-07 10:18:23 +01:00 committed by Commit Bot
parent 0b69826ffb
commit 87e2d785a0
98 changed files with 226 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
BUILD.gn
View File

@ -452,6 +452,7 @@ rtc_source_set("webrtc_common") {
"api/video:video_bitrate_allocation",
"api/video:video_frame",
"rtc_base:checks",
"rtc_base:deprecation",
"//third_party/abseil-cpp/absl/strings",
]
}

5
api/fec_controller.h
View File

@ -74,8 +74,9 @@ class FecController {
int64_t round_trip_time_ms) = 0;
// Informs of encoded output.
virtual void UpdateWithEncodedData(size_t encoded_image_length,
FrameType encoded_image_frametype) = 0;
virtual void UpdateWithEncodedData(
size_t encoded_image_length,
VideoFrameType encoded_image_frametype) = 0;
// Returns whether this FEC Controller needs Loss Vector Mask as input.
virtual bool UseLossVectorMask() = 0;

2
api/test/mock_video_encoder.h
View File

@ -40,7 +40,7 @@ class MockVideoEncoder : public VideoEncoder {
MOCK_METHOD3(Encode,
int32_t(const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<FrameType>* frame_types));
const std::vector<VideoFrameType>* frame_types));
MOCK_METHOD1(RegisterEncodeCompleteCallback,
int32_t(EncodedImageCallback* callback));
MOCK_METHOD0(Release, int32_t());

2
api/test/videocodec_test_stats.h
View File

@ -43,7 +43,7 @@ class VideoCodecTestStats {
size_t encode_time_us = 0;
size_t target_bitrate_kbps = 0;
size_t length_bytes = 0;
webrtc::FrameType frame_type = kVideoFrameDelta;
webrtc::VideoFrameType frame_type = kVideoFrameDelta;
// Layering.
size_t spatial_idx = 0;

2
api/video/encoded_image.h
View File

@ -115,7 +115,7 @@ class RTC_EXPORT EncodedImage {
// NTP time of the capture time in local timebase in milliseconds.
int64_t ntp_time_ms_ = 0;
int64_t capture_time_ms_ = 0;
FrameType _frameType = kVideoFrameDelta;
VideoFrameType _frameType = kVideoFrameDelta;
VideoRotation rotation_ = kVideoRotation_0;
VideoContentType content_type_ = VideoContentType::UNSPECIFIED;
bool _completeFrame = false;

6
api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc
View File

@ -95,7 +95,7 @@ class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test {
}
int32_t Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
++encode_count_;
if (encode_complete_callback_ &&
encode_return_code_ == WEBRTC_VIDEO_CODEC_OK) {
@ -181,7 +181,7 @@ void VideoEncoderSoftwareFallbackWrapperTest::EncodeFrame(int expected_ret) {
rtc::scoped_refptr<I420Buffer> buffer =
I420Buffer::Create(codec_.width, codec_.height);
I420Buffer::SetBlack(buffer);
std::vector<FrameType> types(1, kVideoFrameKey);
std::vector<VideoFrameType> types(1, kVideoFrameKey);
frame_ =
absl::make_unique<VideoFrame>(VideoFrame::Builder()
@ -293,7 +293,7 @@ TEST_F(VideoEncoderSoftwareFallbackWrapperTest,
EXPECT_EQ(&callback2, fake_encoder_->encode_complete_callback_);
// Encoding a frame using the fallback should arrive at the new callback.
std::vector<FrameType> types(1, kVideoFrameKey);
std::vector<VideoFrameType> types(1, kVideoFrameKey);
frame_->set_timestamp(frame_->timestamp() + 1000);
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_->Encode(*frame_, &types));

4
api/video_codecs/video_encoder.cc
View File

@ -104,13 +104,13 @@ VideoEncoder::EncoderInfo::~EncoderInfo() = default;
// Implementations of the interface must implement one or the other of these two
// methods.
int32_t VideoEncoder::Encode(const VideoFrame& frame,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
return Encode(frame, nullptr, frame_types);
}
int32_t VideoEncoder::Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
return Encode(frame, frame_types);
}

4
api/video_codecs/video_encoder.h
View File

@ -242,12 +242,12 @@ class RTC_EXPORT VideoEncoder {
// WEBRTC_VIDEO_CODEC_MEMORY
// WEBRTC_VIDEO_CODEC_ERROR
virtual int32_t Encode(const VideoFrame& frame,
const std::vector<FrameType>* frame_types);
const std::vector<VideoFrameType>* frame_types);
// TODO(bugs.webrtc.org/10379): Deprecated. Delete, and make above method pure
// virtual, as soon as downstream applications are updated.
virtual int32_t Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types);
const std::vector<VideoFrameType>* frame_types);
// Inform the encoder about the new target bit rate.
//

4
api/video_codecs/video_encoder_software_fallback_wrapper.cc
View File

@ -88,7 +88,7 @@ class VideoEncoderSoftwareFallbackWrapper final : public VideoEncoder {
int32_t Release() override;
int32_t Encode(const VideoFrame& frame,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int32_t SetRateAllocation(const VideoBitrateAllocation& bitrate_allocation,
uint32_t framerate) override;
EncoderInfo GetEncoderInfo() const override;
@ -252,7 +252,7 @@ int32_t VideoEncoderSoftwareFallbackWrapper::Release() {
int32_t VideoEncoderSoftwareFallbackWrapper::Encode(
const VideoFrame& frame,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
if (use_fallback_encoder_)
return fallback_encoder_->Encode(frame, frame_types);
int32_t ret = encoder_->Encode(frame, frame_types);

14
audio/channel_send.cc
View File

@ -55,7 +55,7 @@ constexpr int64_t kMaxRetransmissionWindowMs = 1000;
constexpr int64_t kMinRetransmissionWindowMs = 30;
MediaTransportEncodedAudioFrame::FrameType
MediaTransportFrameTypeForWebrtcFrameType(webrtc::FrameType frame_type) {
MediaTransportFrameTypeForWebrtcFrameType(webrtc::AudioFrameType frame_type) {
switch (frame_type) {
case kAudioFrameSpeech:
return MediaTransportEncodedAudioFrame::FrameType::kSpeech;
@ -184,7 +184,7 @@ class ChannelSend
class ProcessAndEncodeAudioTask;
// From AudioPacketizationCallback in the ACM
int32_t SendData(FrameType frameType,
int32_t SendData(AudioFrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
const uint8_t* payloadData,
@ -196,13 +196,13 @@ class ChannelSend
int SetSendRtpHeaderExtension(bool enable, RTPExtensionType type, int id);
int32_t SendRtpAudio(FrameType frameType,
int32_t SendRtpAudio(AudioFrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
rtc::ArrayView<const uint8_t> payload,
const RTPFragmentationHeader* fragmentation);
int32_t SendMediaTransportAudio(FrameType frameType,
int32_t SendMediaTransportAudio(AudioFrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
rtc::ArrayView<const uint8_t> payload,
@ -492,7 +492,7 @@ class ChannelSend::ProcessAndEncodeAudioTask : public rtc::QueuedTask {
ChannelSend* const channel_;
};
int32_t ChannelSend::SendData(FrameType frameType,
int32_t ChannelSend::SendData(AudioFrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
const uint8_t* payloadData,
@ -516,7 +516,7 @@ int32_t ChannelSend::SendData(FrameType frameType,
}
}
int32_t ChannelSend::SendRtpAudio(FrameType frameType,
int32_t ChannelSend::SendRtpAudio(AudioFrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
rtc::ArrayView<const uint8_t> payload,
@ -589,7 +589,7 @@ int32_t ChannelSend::SendRtpAudio(FrameType frameType,
}
int32_t ChannelSend::SendMediaTransportAudio(
FrameType frameType,
AudioFrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
rtc::ArrayView<const uint8_t> payload,

2
call/rtp_payload_params_unittest.cc
View File

@ -347,7 +347,7 @@ class RtpPayloadParamsVp8ToGenericTest : public ::testing::Test {
void ConvertAndCheck(int temporal_index,
int64_t shared_frame_id,
FrameType frame_type,
VideoFrameType frame_type,
LayerSync layer_sync,
const std::set<int64_t>& expected_deps,
uint16_t width = 0,

10
common_types.h
View File

@ -25,7 +25,9 @@
namespace webrtc {
enum FrameType {
// TODO(bugs.webrtc.org/6883): This type should be split into separate types for
// audio and video, and then moved out of this file.
enum FrameTypeDeprecated {
kEmptyFrame = 0,
kAudioFrameSpeech = 1,
kAudioFrameCN = 2,
@ -33,6 +35,12 @@ enum FrameType {
kVideoFrameDelta = 4,
};
// Can't use RTC_DEPRECATED until Chromium is updated.
typedef FrameTypeDeprecated FrameType;
using AudioFrameType = FrameTypeDeprecated;
using VideoFrameType = FrameTypeDeprecated;
// Statistics for RTCP packet types.
struct RtcpPacketTypeCounter {
RtcpPacketTypeCounter()

5
media/engine/encoder_simulcast_proxy.cc
View File

@ -43,8 +43,9 @@ int EncoderSimulcastProxy::InitEncode(const VideoCodec* inst,
return ret;
}
int EncoderSimulcastProxy::Encode(const VideoFrame& input_image,
const std::vector<FrameType>* frame_types) {
int EncoderSimulcastProxy::Encode(
const VideoFrame& input_image,
const std::vector<VideoFrameType>* frame_types) {
return encoder_->Encode(input_image, frame_types);
}

2
media/engine/encoder_simulcast_proxy.h
View File

@ -46,7 +46,7 @@ class EncoderSimulcastProxy : public VideoEncoder {
int number_of_cores,
size_t max_payload_size) override;
int Encode(const VideoFrame& input_image,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
int SetRateAllocation(const VideoBitrateAllocation& bitrate,
uint32_t new_framerate) override;

2
media/engine/encoder_simulcast_proxy_unittest.cc
View File

@ -48,7 +48,7 @@ class MockEncoder : public VideoEncoder {
Encode,
int32_t(const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<FrameType>* frame_types) /* override */);
const std::vector<VideoFrameType>* frame_types) /* override */);
MOCK_CONST_METHOD0(GetEncoderInfo, VideoEncoder::EncoderInfo(void));
};

2
media/engine/fake_webrtc_video_engine.cc
View File

@ -151,7 +151,7 @@ int32_t FakeWebRtcVideoEncoder::InitEncode(
int32_t FakeWebRtcVideoEncoder::Encode(
const webrtc::VideoFrame& inputImage,
const webrtc::CodecSpecificInfo* codecSpecificInfo,
const std::vector<webrtc::FrameType>* frame_types) {
const std::vector<webrtc::VideoFrameType>* frame_types) {
rtc::CritScope lock(&crit_);
++num_frames_encoded_;
init_encode_event_.Set();

7
media/engine/fake_webrtc_video_engine.h
View File

@ -88,9 +88,10 @@ class FakeWebRtcVideoEncoder : public webrtc::VideoEncoder {
int32_t InitEncode(const webrtc::VideoCodec* codecSettings,
int32_t numberOfCores,
size_t maxPayloadSize) override;
int32_t Encode(const webrtc::VideoFrame& inputImage,
const webrtc::CodecSpecificInfo* codecSpecificInfo,
const std::vector<webrtc::FrameType>* frame_types) override;
int32_t Encode(
const webrtc::VideoFrame& inputImage,
const webrtc::CodecSpecificInfo* codecSpecificInfo,
const std::vector<webrtc::VideoFrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback) override;
int32_t Release() override;

4
media/engine/simulcast_encoder_adapter.cc
View File

@ -338,7 +338,7 @@ int SimulcastEncoderAdapter::InitEncode(const VideoCodec* inst,
int SimulcastEncoderAdapter::Encode(
const VideoFrame& input_image,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
if (!Initialized()) {
@ -375,7 +375,7 @@ int SimulcastEncoderAdapter::Encode(
continue;
}
std::vector<FrameType> stream_frame_types;
std::vector<VideoFrameType> stream_frame_types;
if (send_key_frame) {
stream_frame_types.push_back(kVideoFrameKey);
streaminfos_[stream_idx].key_frame_request = false;

2
media/engine/simulcast_encoder_adapter.h
View File

@ -45,7 +45,7 @@ class SimulcastEncoderAdapter : public VideoEncoder {
int number_of_cores,
size_t max_payload_size) override;
int Encode(const VideoFrame& input_image,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
int SetRateAllocation(const VideoBitrateAllocation& bitrate,
uint32_t new_framerate) override;

10
media/engine/simulcast_encoder_adapter_unittest.cc
View File

@ -198,7 +198,7 @@ class MockVideoEncoder : public VideoEncoder {
Encode,
int32_t(const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<FrameType>* frame_types) /* override */);
const std::vector<VideoFrameType>* frame_types) /* override */);
int32_t RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) /* override */ {
@ -556,7 +556,7 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
.set_timestamp_ms(1000)
.set_rotation(kVideoRotation_180)
.build();
std::vector<FrameType> frame_types;
std::vector<VideoFrameType> frame_types;
// Encode with three streams.
EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
@ -890,7 +890,7 @@ TEST_F(TestSimulcastEncoderAdapterFake,
// frame and can't otherwise be modified/resized.
for (MockVideoEncoder* encoder : helper_->factory()->encoders())
EXPECT_CALL(*encoder, Encode(::testing::Ref(input_frame), _, _)).Times(1);
std::vector<FrameType> frame_types(3, kVideoFrameKey);
std::vector<VideoFrameType> frame_types(3, kVideoFrameKey);
EXPECT_EQ(0, adapter_->Encode(input_frame, &frame_types));
}
@ -916,7 +916,7 @@ TEST_F(TestSimulcastEncoderAdapterFake, TestFailureReturnCodesFromEncodeCalls) {
.set_timestamp_us(0)
.set_rotation(kVideoRotation_0)
.build();
std::vector<FrameType> frame_types(3, kVideoFrameKey);
std::vector<VideoFrameType> frame_types(3, kVideoFrameKey);
EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE,
adapter_->Encode(input_frame, &frame_types));
}
@ -1031,7 +1031,7 @@ TEST_F(TestSimulcastEncoderAdapterFake, ActivatesCorrectStreamsInInitEncode) {
EXPECT_CALL(*original_encoders[1], Encode(_, _, _)).Times(0);
EXPECT_CALL(*original_encoders[2], Encode(_, _, _)).Times(0);
std::vector<FrameType> frame_types;
std::vector<VideoFrameType> frame_types;
frame_types.resize(3, kVideoFrameKey);
EXPECT_EQ(0, adapter_->Encode(input_frame, &frame_types));
}

4
modules/audio_coding/acm2/acm_receiver_unittest.cc
View File

@ -103,7 +103,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
return num_10ms_frames;
}
int SendData(FrameType frame_type,
int SendData(AudioFrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
@ -139,7 +139,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
uint32_t timestamp_;
bool packet_sent_; // Set when SendData is called reset when inserting audio.
uint32_t last_packet_send_timestamp_;
FrameType last_frame_type_;
AudioFrameType last_frame_type_;
};
#if defined(WEBRTC_ANDROID)

2
modules/audio_coding/acm2/acm_send_test.cc
View File

@ -123,7 +123,7 @@ std::unique_ptr<Packet> AcmSendTestOldApi::NextPacket() {
// This method receives the callback from ACM when a new packet is produced.
int32_t AcmSendTestOldApi::SendData(
FrameType frame_type,
AudioFrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,

4
modules/audio_coding/acm2/acm_send_test.h
View File

@ -50,7 +50,7 @@ class AcmSendTestOldApi : public AudioPacketizationCallback,
std::unique_ptr<Packet> NextPacket() override;
// Inherited from AudioPacketizationCallback.
int32_t SendData(FrameType frame_type,
int32_t SendData(AudioFrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
@ -75,7 +75,7 @@ class AcmSendTestOldApi : public AudioPacketizationCallback,
bool codec_registered_;
int test_duration_ms_;
// The following member variables are set whenever SendData() is called.
FrameType frame_type_;
AudioFrameType frame_type_;
int payload_type_;
uint32_t timestamp_;
uint16_t sequence_number_;

2
modules/audio_coding/acm2/audio_coding_module.cc
View File

@ -393,7 +393,7 @@ int32_t AudioCodingModuleImpl::Encode(const InputData& input_data) {
RTPFragmentationHeader my_fragmentation;
ConvertEncodedInfoToFragmentationHeader(encoded_info, &my_fragmentation);
FrameType frame_type;
AudioFrameType frame_type;
if (encode_buffer_.size() == 0 && encoded_info.send_even_if_empty) {
frame_type = kEmptyFrame;
encoded_info.payload_type = previous_pltype;

8
modules/audio_coding/acm2/audio_coding_module_unittest.cc
View File

@ -104,7 +104,7 @@ class PacketizationCallbackStubOldApi : public AudioPacketizationCallback {
last_payload_type_(-1),
last_timestamp_(0) {}
int32_t SendData(FrameType frame_type,
int32_t SendData(AudioFrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
@ -129,7 +129,7 @@ class PacketizationCallbackStubOldApi : public AudioPacketizationCallback {
return rtc::checked_cast<int>(last_payload_vec_.size());
}
FrameType last_frame_type() const {
AudioFrameType last_frame_type() const {
rtc::CritScope lock(&crit_sect_);
return last_frame_type_;
}
@ -151,7 +151,7 @@ class PacketizationCallbackStubOldApi : public AudioPacketizationCallback {
private:
int num_calls_ RTC_GUARDED_BY(crit_sect_);
FrameType last_frame_type_ RTC_GUARDED_BY(crit_sect_);
AudioFrameType last_frame_type_ RTC_GUARDED_BY(crit_sect_);
int last_payload_type_ RTC_GUARDED_BY(crit_sect_);
uint32_t last_timestamp_ RTC_GUARDED_BY(crit_sect_);
std::vector<uint8_t> last_payload_vec_ RTC_GUARDED_BY(crit_sect_);
@ -430,7 +430,7 @@ class AudioCodingModuleTestWithComfortNoiseOldApi
// that is contain comfort noise.
const struct {
int ix;
FrameType type;
AudioFrameType type;
} expectation[] = {
{2, kAudioFrameCN}, {5, kEmptyFrame}, {8, kEmptyFrame},
{11, kAudioFrameCN}, {14, kEmptyFrame}, {17, kEmptyFrame},

4
modules/audio_coding/include/audio_coding_module.h
View File

@ -40,7 +40,7 @@ class AudioPacketizationCallback {
public:
virtual ~AudioPacketizationCallback() {}
virtual int32_t SendData(FrameType frame_type,
virtual int32_t SendData(AudioFrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
@ -53,7 +53,7 @@ class ACMVADCallback {
public:
virtual ~ACMVADCallback() {}
virtual int32_t InFrameType(FrameType frame_type) = 0;
virtual int32_t InFrameType(AudioFrameType frame_type) = 0;
};
class AudioCodingModule {

2
modules/audio_coding/neteq/tools/rtp_encode.cc
View File

@ -107,7 +107,7 @@ class Packetizer : public AudioPacketizationCallback {
ssrc_(ssrc),
timestamp_rate_hz_(timestamp_rate_hz) {}
int32_t SendData(FrameType frame_type,
int32_t SendData(AudioFrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,

2
modules/audio_coding/test/Channel.cc
View File

@ -18,7 +18,7 @@
namespace webrtc {
int32_t Channel::SendData(FrameType frameType,
int32_t Channel::SendData(AudioFrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
const uint8_t* payloadData,

2
modules/audio_coding/test/Channel.h
View File

@ -47,7 +47,7 @@ class Channel : public AudioPacketizationCallback {
Channel(int16_t chID = -1);
~Channel() override;
int32_t SendData(FrameType frameType,
int32_t SendData(AudioFrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
const uint8_t* payloadData,

6
modules/audio_coding/test/EncodeDecodeTest.cc
View File

@ -33,8 +33,10 @@ TestPacketization::~TestPacketization() {
}
int32_t TestPacketization::SendData(
const FrameType /* frameType */, const uint8_t payloadType,
const uint32_t timeStamp, const uint8_t* payloadData,
const AudioFrameType /* frameType */,
const uint8_t payloadType,
const uint32_t timeStamp,
const uint8_t* payloadData,
const size_t payloadSize,
const RTPFragmentationHeader* /* fragmentation */) {
_rtpStream->Write(payloadType, timeStamp, _seqNo++, payloadData, payloadSize,

2
modules/audio_coding/test/EncodeDecodeTest.h
View File

@ -28,7 +28,7 @@ class TestPacketization : public AudioPacketizationCallback {
public:
TestPacketization(RTPStream *rtpStream, uint16_t frequency);
~TestPacketization();
int32_t SendData(const FrameType frameType,
int32_t SendData(const AudioFrameType frameType,
const uint8_t payloadType,
const uint32_t timeStamp,
const uint8_t* payloadData,

2
modules/audio_coding/test/TestAllCodecs.cc
View File

@ -60,7 +60,7 @@ void TestPack::RegisterReceiverACM(AudioCodingModule* acm) {
return;
}
int32_t TestPack::SendData(FrameType frame_type,
int32_t TestPack::SendData(AudioFrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,

2
modules/audio_coding/test/TestAllCodecs.h
View File

@ -25,7 +25,7 @@ class TestPack : public AudioPacketizationCallback {
void RegisterReceiverACM(AudioCodingModule* acm);
int32_t SendData(FrameType frame_type,
int32_t SendData(AudioFrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,

2
modules/audio_coding/test/TestStereo.cc
View File

@ -40,7 +40,7 @@ void TestPackStereo::RegisterReceiverACM(AudioCodingModule* acm) {
return;
}
int32_t TestPackStereo::SendData(const FrameType frame_type,
int32_t TestPackStereo::SendData(const AudioFrameType frame_type,
const uint8_t payload_type,
const uint32_t timestamp,
const uint8_t* payload_data,

2
modules/audio_coding/test/TestStereo.h
View File

@ -31,7 +31,7 @@ class TestPackStereo : public AudioPacketizationCallback {
void RegisterReceiverACM(AudioCodingModule* acm);
int32_t SendData(const FrameType frame_type,
int32_t SendData(const AudioFrameType frame_type,
const uint8_t payload_type,
const uint32_t timestamp,
const uint8_t* payload_data,

2
modules/audio_coding/test/TestVADDTX.cc
View File

@ -33,7 +33,7 @@ ActivityMonitor::ActivityMonitor() {
ResetStatistics();
}
int32_t ActivityMonitor::InFrameType(FrameType frame_type) {
int32_t ActivityMonitor::InFrameType(AudioFrameType frame_type) {
counter_[frame_type]++;
return 0;
}

2
modules/audio_coding/test/TestVADDTX.h
View File

@ -25,7 +25,7 @@ namespace webrtc {
class ActivityMonitor : public ACMVADCallback {
public:
ActivityMonitor();
int32_t InFrameType(FrameType frame_type);
int32_t InFrameType(AudioFrameType frame_type);
void PrintStatistics();
void ResetStatistics();
void GetStatistics(uint32_t* stats);

3
modules/include/module_common_types.h
View File

@ -30,7 +30,8 @@ struct WebRtcRTPHeader {
RTPVideoHeader video;
RTPHeader header;
FrameType frameType;
// Used for video only.
VideoFrameType frameType;
// NTP time of the capture time in local timebase in milliseconds.
int64_t ntp_time_ms;
};

2
modules/rtp_rtcp/source/rtp_format.cc
View File

@ -29,7 +29,7 @@ std::unique_ptr<RtpPacketizer> RtpPacketizer::Create(
PayloadSizeLimits limits,
// Codec-specific details.
const RTPVideoHeader& rtp_video_header,
FrameType frame_type,
VideoFrameType frame_type,
const RTPFragmentationHeader* fragmentation) {
switch (type) {
case kVideoCodecH264: {

4
modules/rtp_rtcp/source/rtp_format.h
View File

@ -39,7 +39,7 @@ class RtpPacketizer {
PayloadSizeLimits limits,
// Codec-specific details.
const RTPVideoHeader& rtp_video_header,
FrameType frame_type,
VideoFrameType frame_type,
const RTPFragmentationHeader* fragmentation);
virtual ~RtpPacketizer() = default;
@ -71,7 +71,7 @@ class RtpDepacketizer {
const uint8_t* payload;
size_t payload_length;
FrameType frame_type;
VideoFrameType frame_type;
};
static RtpDepacketizer* Create(VideoCodecType type);

4
modules/rtp_rtcp/source/rtp_format_video_generic.cc
View File

@ -26,7 +26,7 @@ RtpPacketizerGeneric::RtpPacketizerGeneric(
rtc::ArrayView<const uint8_t> payload,
PayloadSizeLimits limits,
const RTPVideoHeader& rtp_video_header,
FrameType frame_type)
VideoFrameType frame_type)
: remaining_payload_(payload) {
BuildHeader(rtp_video_header, frame_type);
@ -72,7 +72,7 @@ bool RtpPacketizerGeneric::NextPacket(RtpPacketToSend* packet) {
}
void RtpPacketizerGeneric::BuildHeader(const RTPVideoHeader& rtp_video_header,
FrameType frame_type) {
VideoFrameType frame_type) {
header_size_ = kGenericHeaderLength;
header_[0] = RtpFormatVideoGeneric::kFirstPacketBit;
if (frame_type == kVideoFrameKey) {

4
modules/rtp_rtcp/source/rtp_format_video_generic.h
View File

@ -38,7 +38,7 @@ class RtpPacketizerGeneric : public RtpPacketizer {
RtpPacketizerGeneric(rtc::ArrayView<const uint8_t> payload,
PayloadSizeLimits limits,
const RTPVideoHeader& rtp_video_header,
FrameType frametype);
VideoFrameType frametype);
~RtpPacketizerGeneric() override;
@ -52,7 +52,7 @@ class RtpPacketizerGeneric : public RtpPacketizer {
private:
// Fills header_ and header_size_ members.
void BuildHeader(const RTPVideoHeader& rtp_video_header,
FrameType frame_type);
VideoFrameType frame_type);
uint8_t header_[3];
size_t header_size_;

6
modules/rtp_rtcp/source/rtp_sender_audio.cc
View File

@ -30,7 +30,7 @@ namespace webrtc {
namespace {
const char* FrameTypeToString(FrameType frame_type) {
const char* FrameTypeToString(AudioFrameType frame_type) {
switch (frame_type) {
case kEmptyFrame:
return "empty";
@ -88,7 +88,7 @@ int32_t RTPSenderAudio::RegisterAudioPayload(absl::string_view payload_name,
return 0;
}
bool RTPSenderAudio::MarkerBit(FrameType frame_type, int8_t payload_type) {
bool RTPSenderAudio::MarkerBit(AudioFrameType frame_type, int8_t payload_type) {
rtc::CritScope cs(&send_audio_critsect_);
// for audio true for first packet in a speech burst
bool marker_bit = false;
@ -131,7 +131,7 @@ bool RTPSenderAudio::MarkerBit(FrameType frame_type, int8_t payload_type) {
return marker_bit;
}
bool RTPSenderAudio::SendAudio(FrameType frame_type,
bool RTPSenderAudio::SendAudio(AudioFrameType frame_type,
int8_t payload_type,
uint32_t rtp_timestamp,
const uint8_t* payload_data,

4
modules/rtp_rtcp/source/rtp_sender_audio.h
View File

@ -39,7 +39,7 @@ class RTPSenderAudio {
size_t channels,
uint32_t rate);
bool SendAudio(FrameType frame_type,
bool SendAudio(AudioFrameType frame_type,
int8_t payload_type,
uint32_t capture_timestamp,
const uint8_t* payload_data,
@ -60,7 +60,7 @@ class RTPSenderAudio {
uint16_t duration,
bool marker_bit); // set on first packet in talk burst
bool MarkerBit(FrameType frame_type, int8_t payload_type);
bool MarkerBit(AudioFrameType frame_type, int8_t payload_type);
private:
bool LogAndSendToNetwork(std::unique_ptr<RtpPacketToSend> packet,

6
modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -54,7 +54,7 @@ void BuildRedPayload(const RtpPacketToSend& media_packet,
void AddRtpHeaderExtensions(const RTPVideoHeader& video_header,
const absl::optional<PlayoutDelay>& playout_delay,
FrameType frame_type,
VideoFrameType frame_type,
bool set_video_rotation,
bool set_color_space,
bool set_frame_marking,
@ -167,7 +167,7 @@ bool IsBaseLayer(const RTPVideoHeader& video_header) {
return true;
}
const char* FrameTypeToString(FrameType frame_type) {
const char* FrameTypeToString(VideoFrameType frame_type) {
switch (frame_type) {
case kEmptyFrame:
return "empty";
@ -421,7 +421,7 @@ absl::optional<uint32_t> RTPSenderVideo::FlexfecSsrc() const {
return absl::nullopt;
}
bool RTPSenderVideo::SendVideo(FrameType frame_type,
bool RTPSenderVideo::SendVideo(VideoFrameType frame_type,
int8_t payload_type,
uint32_t rtp_timestamp,
int64_t capture_time_ms,

2
modules/rtp_rtcp/source/rtp_sender_video.h
View File

@ -59,7 +59,7 @@ class RTPSenderVideo {
const WebRtcKeyValueConfig& field_trials);
virtual ~RTPSenderVideo();
bool SendVideo(FrameType frame_type,
bool SendVideo(VideoFrameType frame_type,
int8_t payload_type,
uint32_t capture_timestamp,
int64_t capture_time_ms,

9
modules/video_coding/codecs/h264/h264_encoder_impl.cc
View File

@ -64,7 +64,7 @@ int NumberOfThreads(int width, int height, int number_of_cores) {
return 1;
}
FrameType ConvertToVideoFrameType(EVideoFrameType type) {
VideoFrameType ConvertToVideoFrameType(EVideoFrameType type) {
switch (type) {
case videoFrameTypeIDR:
return kVideoFrameKey;
@ -381,9 +381,10 @@ int32_t H264EncoderImpl::SetRateAllocation(
return WEBRTC_VIDEO_CODEC_OK;
}
int32_t H264EncoderImpl::Encode(const VideoFrame& input_frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) {
int32_t H264EncoderImpl::Encode(
const VideoFrame& input_frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) {
if (encoders_.empty()) {
ReportError();
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;

2
modules/video_coding/codecs/h264/h264_encoder_impl.h
View File

@ -68,7 +68,7 @@ class H264EncoderImpl : public H264Encoder {
// passed to the encode complete callback.
int32_t Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
EncoderInfo GetEncoderInfo() const override;

2
modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h
View File

@ -43,7 +43,7 @@ class MultiplexEncoderAdapter : public VideoEncoder {
int number_of_cores,
size_t max_payload_size) override;
int Encode(const VideoFrame& input_image,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
int SetRateAllocation(const VideoBitrateAllocation& bitrate,
uint32_t new_framerate) override;

8
modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc
View File

@ -115,11 +115,13 @@ MultiplexImageComponentHeader UnpackFrameHeader(const uint8_t* buffer) {
ByteReader<uint32_t>::ReadBigEndian(buffer + offset);
offset += sizeof(uint32_t);
// TODO(nisse): This makes the wire format depend on the numeric values of the
// VideoCodecType and VideoFrameType enum constants.
frame_header.codec_type = static_cast<VideoCodecType>(
ByteReader<uint8_t>::ReadBigEndian(buffer + offset));
offset += sizeof(uint8_t);
frame_header.frame_type = static_cast<FrameType>(
frame_header.frame_type = static_cast<VideoFrameType>(
ByteReader<uint8_t>::ReadBigEndian(buffer + offset));
offset += sizeof(uint8_t);
@ -181,8 +183,8 @@ EncodedImage MultiplexEncodedImagePacker::PackAndRelease(
// key frame so as to decode the whole image without previous frame data.
// Thus only when all components are key frames, we can mark the combined
// frame as key frame.
if (frame_header.frame_type == FrameType::kVideoFrameDelta) {
combined_image._frameType = FrameType::kVideoFrameDelta;
if (frame_header.frame_type == VideoFrameType::kVideoFrameDelta) {
combined_image._frameType = VideoFrameType::kVideoFrameDelta;
}
frame_headers.push_back(frame_header);

2
modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.h
View File

@ -67,7 +67,7 @@ struct MultiplexImageComponentHeader {
VideoCodecType codec_type;
// Indicated the underlying frame is a key frame or delta frame.
FrameType frame_type;
VideoFrameType frame_type;
};
const int kMultiplexImageComponentHeaderSize =
sizeof(uint32_t) + sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t) +

4
modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
View File

@ -138,12 +138,12 @@ int MultiplexEncoderAdapter::InitEncode(const VideoCodec* inst,
int MultiplexEncoderAdapter::Encode(
const VideoFrame& input_image,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
if (!encoded_complete_callback_) {
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
}
std::vector<FrameType> adjusted_frame_types;
std::vector<VideoFrameType> adjusted_frame_types;
if (key_frame_interval_ > 0 && picture_index_ % key_frame_interval_ == 0) {
adjusted_frame_types.push_back(kVideoFrameKey);
} else {

6
modules/video_coding/codecs/test/videoprocessor.cc
View File

@ -285,9 +285,9 @@ void VideoProcessor::ProcessFrame() {
}
// Encode.
const std::vector<FrameType> frame_types =
(frame_number == 0) ? std::vector<FrameType>{kVideoFrameKey}
: std::vector<FrameType>{kVideoFrameDelta};
const std::vector<VideoFrameType> frame_types =
(frame_number == 0) ? std::vector<VideoFrameType>{kVideoFrameKey}
: std::vector<VideoFrameType>{kVideoFrameDelta};
const int encode_return_code = encoder_->Encode(input_frame, &frame_types);
for (size_t i = 0; i < num_simulcast_or_spatial_layers_; ++i) {
FrameStatistics* frame_stat = stats_->GetFrame(frame_number, i);

2
modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
View File

@ -737,7 +737,7 @@ size_t LibvpxVp8Encoder::SteadyStateSize(int sid, int tid) {
int LibvpxVp8Encoder::Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_EQ(frame.width(), codec_.width);
RTC_DCHECK_EQ(frame.height(), codec_.height);

2
modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
View File

@ -47,7 +47,7 @@ class LibvpxVp8Encoder : public VideoEncoder {
int Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;

8
modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
View File

@ -74,11 +74,11 @@ class TestVp8Impl : public VideoCodecUnitTest {
EncodedImage* encoded_frame,
CodecSpecificInfo* codec_specific_info,
bool keyframe = false) {
std::vector<FrameType> frame_types;
std::vector<VideoFrameType> frame_types;
if (keyframe) {
frame_types.emplace_back(FrameType::kVideoFrameKey);
frame_types.emplace_back(VideoFrameType::kVideoFrameKey);
} else {
frame_types.emplace_back(FrameType::kVideoFrameDelta);
frame_types.emplace_back(VideoFrameType::kVideoFrameDelta);
}
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
encoder_->Encode(input_frame, &frame_types));
@ -484,7 +484,7 @@ TEST_F(TestVp8Impl, KeepsTimestampOnReencode) {
.Times(2)
.WillRepeatedly(Return(vpx_codec_err_t::VPX_CODEC_OK));
auto delta_frame = std::vector<FrameType>{kVideoFrameDelta};
auto delta_frame = std::vector<VideoFrameType>{kVideoFrameDelta};
encoder.Encode(*NextInputFrame(), nullptr, &delta_frame);
}

2
modules/video_coding/codecs/vp9/vp9_impl.cc
View File

@ -714,7 +714,7 @@ uint32_t VP9EncoderImpl::MaxIntraTarget(uint32_t optimal_buffer_size) {
int VP9EncoderImpl::Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
if (!inited_) {
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
}

2
modules/video_coding/codecs/vp9/vp9_impl.h
View File

@ -45,7 +45,7 @@ class VP9EncoderImpl : public VP9Encoder {
int Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;

2
modules/video_coding/encoded_frame.h
View File

@ -67,7 +67,7 @@ class VCMEncodedFrame : protected EncodedImage {
/**
* Get frame type
*/
webrtc::FrameType FrameType() const { return _frameType; }
webrtc::VideoFrameType FrameType() const { return _frameType; }
/**
* Get frame rotation
*/

2
modules/video_coding/fec_controller_default.cc
View File

@ -177,7 +177,7 @@ void FecControllerDefault::SetProtectionMethod(bool enable_fec,
}
void FecControllerDefault::UpdateWithEncodedData(
const size_t encoded_image_length,
const FrameType encoded_image_frametype) {
const VideoFrameType encoded_image_frametype) {
const size_t encoded_length = encoded_image_length;
CritScope lock(&crit_sect_);
if (encoded_length > 0) {

5
modules/video_coding/fec_controller_default.h
View File

@ -44,8 +44,9 @@ class FecControllerDefault : public FecController {
uint8_t fraction_lost,
std::vector<bool> loss_mask_vector,
int64_t round_trip_time_ms) override;
void UpdateWithEncodedData(const size_t encoded_image_length,
const FrameType encoded_image_frametype) override;
void UpdateWithEncodedData(
const size_t encoded_image_length,
const VideoFrameType encoded_image_frametype) override;
bool UseLossVectorMask() override;
float GetProtectionOverheadRateThreshold();

2
modules/video_coding/frame_buffer.cc
View File

@ -29,7 +29,7 @@ VCMFrameBuffer::VCMFrameBuffer()
VCMFrameBuffer::~VCMFrameBuffer() {}
webrtc::FrameType VCMFrameBuffer::FrameType() const {
webrtc::VideoFrameType VCMFrameBuffer::FrameType() const {
return _sessionInfo.FrameType();
}

2
modules/video_coding/frame_buffer.h
View File

@ -70,7 +70,7 @@ class VCMFrameBuffer : public VCMEncodedFrame {
int64_t LatestPacketTimeMs() const;
webrtc::FrameType FrameType() const;
webrtc::VideoFrameType FrameType() const;
private:
void SetState(VCMFrameBufferStateEnum state); // Set state of frame

2
modules/video_coding/frame_object.cc
View File

@ -121,7 +121,7 @@ int RtpFrameObject::times_nacked() const {
return times_nacked_;
}
FrameType RtpFrameObject::frame_type() const {
VideoFrameType RtpFrameObject::frame_type() const {
return frame_type_;
}

4
modules/video_coding/frame_object.h
View File

@ -36,7 +36,7 @@ class RtpFrameObject : public EncodedFrame {
uint16_t first_seq_num() const;
uint16_t last_seq_num() const;
int times_nacked() const;
enum FrameType frame_type() const;
VideoFrameType frame_type() const;
VideoCodecType codec_type() const;
int64_t ReceivedTime() const override;
int64_t RenderTime() const override;
@ -49,7 +49,7 @@ class RtpFrameObject : public EncodedFrame {
void AllocateBitstreamBuffer(size_t frame_size);
rtc::scoped_refptr<PacketBuffer> packet_buffer_;
enum FrameType frame_type_;
VideoFrameType frame_type_;
VideoCodecType codec_type_;
uint16_t first_seq_num_;
uint16_t last_seq_num_;

4
modules/video_coding/jitter_buffer_unittest.cc
View File

@ -362,7 +362,7 @@ class TestRunningJitterBuffer : public ::testing::TestWithParam<std::string>,
return jitter_buffer_->InsertPacket(packet, &retransmitted);
}
VCMFrameBufferEnum InsertFrame(FrameType frame_type) {
VCMFrameBufferEnum InsertFrame(VideoFrameType frame_type) {
stream_generator_->GenerateFrame(
frame_type, (frame_type != kEmptyFrame) ? 1 : 0,
(frame_type == kEmptyFrame) ? 1 : 0, clock_->TimeInMilliseconds());
@ -371,7 +371,7 @@ class TestRunningJitterBuffer : public ::testing::TestWithParam<std::string>,
return ret;
}
VCMFrameBufferEnum InsertFrames(int num_frames, FrameType frame_type) {
VCMFrameBufferEnum InsertFrames(int num_frames, VideoFrameType frame_type) {
VCMFrameBufferEnum ret_for_all = kNoError;
for (int i = 0; i < num_frames; ++i) {
VCMFrameBufferEnum ret = InsertFrame(frame_type);

2
modules/video_coding/packet.cc
View File

@ -46,7 +46,7 @@ VCMPacket::VCMPacket(const uint8_t* ptr,
size_t size,
const RTPHeader& rtp_header,
const RTPVideoHeader& videoHeader,
FrameType frame_type,
VideoFrameType frame_type,
int64_t ntp_time_ms)
: payloadType(rtp_header.payloadType),
timestamp(rtp_header.timestamp),

4
modules/video_coding/packet.h
View File

@ -32,7 +32,7 @@ class VCMPacket {
size_t size,
const RTPHeader& rtp_header,
const RTPVideoHeader& video_header,
FrameType frame_type,
VideoFrameType frame_type,
int64_t ntp_time_ms);
~VCMPacket();
@ -58,7 +58,7 @@ class VCMPacket {
bool markerBit;
int timesNacked;
FrameType frameType;
VideoFrameType frameType;
VCMNaluCompleteness completeNALU; // Default is kNaluIncomplete.
bool insertStartCode; // True if a start code should be inserted before this

4
modules/video_coding/receiver_unittest.cc
View File

@ -56,7 +56,7 @@ class TestVCMReceiver : public ::testing::Test {
return receiver_.InsertPacket(packet);
}
int32_t InsertFrame(FrameType frame_type, bool complete) {
int32_t InsertFrame(VideoFrameType frame_type, bool complete) {
int num_of_packets = complete ? 1 : 2;
stream_generator_->GenerateFrame(
frame_type, (frame_type != kEmptyFrame) ? num_of_packets : 0,
@ -322,7 +322,7 @@ class SimulatedClockWithFrames : public SimulatedClock {
void GenerateAndInsertFrame(int64_t render_timestamp_ms) {
VCMPacket packet;
stream_generator_->GenerateFrame(FrameType::kVideoFrameKey,
stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey,
1, // media packets
0, // empty packets
render_timestamp_ms);

4
modules/video_coding/session_info.h
View File

@ -54,7 +54,7 @@ class VCMSessionInfo {
int NumPackets() const;
bool HaveFirstPacket() const;
bool HaveLastPacket() const;
webrtc::FrameType FrameType() const { return frame_type_; }
webrtc::VideoFrameType FrameType() const { return frame_type_; }
int LowSequenceNumber() const;
// Returns highest sequence number, media or empty.
@ -103,7 +103,7 @@ class VCMSessionInfo {
void UpdateCompleteSession();
bool complete_;
webrtc::FrameType frame_type_;
webrtc::VideoFrameType frame_type_;
// Packets in this frame.
PacketList packets_;
int empty_seq_num_low_;

4
modules/video_coding/test/stream_generator.cc
View File

@ -29,7 +29,7 @@ void StreamGenerator::Init(uint16_t start_seq_num, int64_t current_time) {
memset(packet_buffer_, 0, sizeof(packet_buffer_));
}
void StreamGenerator::GenerateFrame(FrameType type,
void StreamGenerator::GenerateFrame(VideoFrameType type,
int num_media_packets,
int num_empty_packets,
int64_t time_ms) {
@ -54,7 +54,7 @@ VCMPacket StreamGenerator::GeneratePacket(uint16_t sequence_number,
unsigned int size,
bool first_packet,
bool marker_bit,
FrameType type) {
VideoFrameType type) {
EXPECT_LT(size, kMaxPacketSize);
VCMPacket packet;
packet.seqNum = sequence_number;

4
modules/video_coding/test/stream_generator.h
View File

@ -34,7 +34,7 @@ class StreamGenerator {
// |time_ms| denotes the timestamp you want to put on the frame, and the unit
// is millisecond. GenerateFrame will translate |time_ms| into a 90kHz
// timestamp and put it on the frame.
void GenerateFrame(FrameType type,
void GenerateFrame(VideoFrameType type,
int num_media_packets,
int num_empty_packets,
int64_t time_ms);
@ -56,7 +56,7 @@ class StreamGenerator {
unsigned int size,
bool first_packet,
bool marker_bit,
FrameType type);
VideoFrameType type);
std::list<VCMPacket>::iterator GetPacketIterator(int index);

44
modules/video_coding/utility/simulcast_test_fixture_impl.cc
View File

@ -294,8 +294,8 @@ void SimulcastTestFixtureImpl::SetRates(uint32_t bitrate_kbps, uint32_t fps) {
void SimulcastTestFixtureImpl::RunActiveStreamsTest(
const std::vector<bool> active_streams) {
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
UpdateActiveStreams(active_streams);
// Set sufficient bitrate for all streams so we can test active without
// bitrate being an issue.
@ -326,7 +326,7 @@ void SimulcastTestFixtureImpl::UpdateActiveStreams(
}
void SimulcastTestFixtureImpl::ExpectStreams(
FrameType frame_type,
VideoFrameType frame_type,
const std::vector<bool> expected_streams_active) {
ASSERT_EQ(static_cast<int>(expected_streams_active.size()),
kNumberOfSimulcastStreams);
@ -367,7 +367,7 @@ void SimulcastTestFixtureImpl::ExpectStreams(
}
}
void SimulcastTestFixtureImpl::ExpectStreams(FrameType frame_type,
void SimulcastTestFixtureImpl::ExpectStreams(VideoFrameType frame_type,
int expected_video_streams) {
ASSERT_GE(expected_video_streams, 0);
ASSERT_LE(expected_video_streams, kNumberOfSimulcastStreams);
@ -396,8 +396,8 @@ void SimulcastTestFixtureImpl::VerifyTemporalIdxAndSyncForAllSpatialLayers(
// a key frame was only requested for some of them.
void SimulcastTestFixtureImpl::TestKeyFrameRequestsOnAllStreams() {
SetRates(kMaxBitrates[2], 30); // To get all three streams.
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
ExpectStreams(kVideoFrameKey, kNumberOfSimulcastStreams);
EXPECT_EQ(0, encoder_->Encode(*input_frame_, &frame_types));
@ -431,8 +431,8 @@ void SimulcastTestFixtureImpl::TestKeyFrameRequestsOnAllStreams() {
void SimulcastTestFixtureImpl::TestPaddingAllStreams() {
// We should always encode the base layer.
SetRates(kMinBitrates[0] - 1, 30);
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
ExpectStreams(kVideoFrameKey, 1);
EXPECT_EQ(0, encoder_->Encode(*input_frame_, &frame_types));
@ -444,8 +444,8 @@ void SimulcastTestFixtureImpl::TestPaddingAllStreams() {
void SimulcastTestFixtureImpl::TestPaddingTwoStreams() {
// We have just enough to get only the first stream and padding for two.
SetRates(kMinBitrates[0], 30);
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
ExpectStreams(kVideoFrameKey, 1);
EXPECT_EQ(0, encoder_->Encode(*input_frame_, &frame_types));
@ -458,8 +458,8 @@ void SimulcastTestFixtureImpl::TestPaddingTwoStreamsOneMaxedOut() {
// We are just below limit of sending second stream, so we should get
// the first stream maxed out (at |maxBitrate|), and padding for two.
SetRates(kTargetBitrates[0] + kMinBitrates[1] - 1, 30);
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
ExpectStreams(kVideoFrameKey, 1);
EXPECT_EQ(0, encoder_->Encode(*input_frame_, &frame_types));
@ -471,8 +471,8 @@ void SimulcastTestFixtureImpl::TestPaddingTwoStreamsOneMaxedOut() {
void SimulcastTestFixtureImpl::TestPaddingOneStream() {
// We have just enough to send two streams, so padding for one stream.
SetRates(kTargetBitrates[0] + kMinBitrates[1], 30);
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
ExpectStreams(kVideoFrameKey, 2);
EXPECT_EQ(0, encoder_->Encode(*input_frame_, &frame_types));
@ -485,8 +485,8 @@ void SimulcastTestFixtureImpl::TestPaddingOneStreamTwoMaxedOut() {
// We are just below limit of sending third stream, so we should get
// first stream's rate maxed out at |targetBitrate|, second at |maxBitrate|.
SetRates(kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] - 1, 30);
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
ExpectStreams(kVideoFrameKey, 2);
EXPECT_EQ(0, encoder_->Encode(*input_frame_, &frame_types));
@ -498,8 +498,8 @@ void SimulcastTestFixtureImpl::TestPaddingOneStreamTwoMaxedOut() {
void SimulcastTestFixtureImpl::TestSendAllStreams() {
// We have just enough to send all streams.
SetRates(kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2], 30);
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
ExpectStreams(kVideoFrameKey, 3);
EXPECT_EQ(0, encoder_->Encode(*input_frame_, &frame_types));
@ -511,8 +511,8 @@ void SimulcastTestFixtureImpl::TestSendAllStreams() {
void SimulcastTestFixtureImpl::TestDisablingStreams() {
// We should get three media streams.
SetRates(kMaxBitrates[0] + kMaxBitrates[1] + kMaxBitrates[2], 30);
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
ExpectStreams(kVideoFrameKey, 3);
EXPECT_EQ(0, encoder_->Encode(*input_frame_, &frame_types));
@ -617,8 +617,8 @@ void SimulcastTestFixtureImpl::SwitchingToOneStream(int width, int height) {
// Encode one frame and verify.
SetRates(kMaxBitrates[0] + kMaxBitrates[1], 30);
std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
kVideoFrameDelta);
EXPECT_CALL(
encoder_callback_,
OnEncodedImage(AllOf(Field(&EncodedImage::_frameType, kVideoFrameKey),

4
modules/video_coding/utility/simulcast_test_fixture_impl.h
View File

@ -67,9 +67,9 @@ class SimulcastTestFixtureImpl final : public SimulcastTestFixture {
void SetRates(uint32_t bitrate_kbps, uint32_t fps);
void RunActiveStreamsTest(const std::vector<bool> active_streams);
void UpdateActiveStreams(const std::vector<bool> active_streams);
void ExpectStreams(FrameType frame_type,
void ExpectStreams(VideoFrameType frame_type,
const std::vector<bool> expected_streams_active);
void ExpectStreams(FrameType frame_type, int expected_video_streams);
void ExpectStreams(VideoFrameType frame_type, int expected_video_streams);
void VerifyTemporalIdxAndSyncForAllSpatialLayers(
TestEncodedImageCallback* encoder_callback,
const int* expected_temporal_idx,

4
sdk/android/src/jni/android_media_encoder.cc
View File

@ -100,7 +100,7 @@ class MediaCodecVideoEncoder : public VideoEncoder {
size_t /* max_payload_size */) override;
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* /* codec_specific_info */,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) override;
int32_t Release() override;
@ -595,7 +595,7 @@ int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
int32_t MediaCodecVideoEncoder::Encode(
const VideoFrame& frame,
const CodecSpecificInfo* /* codec_specific_info */,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
if (sw_fallback_required_)
return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;

4
sdk/android/src/jni/encoded_image.cc
View File

@ -20,7 +20,7 @@ namespace webrtc {
namespace jni {
ScopedJavaLocalRef<jobject> NativeToJavaFrameType(JNIEnv* env,
FrameType frame_type) {
VideoFrameType frame_type) {
return Java_FrameType_fromNativeIndex(env, frame_type);
}
@ -43,7 +43,7 @@ ScopedJavaLocalRef<jobject> NativeToJavaEncodedImage(
ScopedJavaLocalRef<jobjectArray> NativeToJavaFrameTypeArray(
JNIEnv* env,
const std::vector<FrameType>& frame_types) {
const std::vector<VideoFrameType>& frame_types) {
return NativeToJavaObjectArray(
env, frame_types, org_webrtc_EncodedImage_00024FrameType_clazz(env),
&NativeToJavaFrameType);

4
sdk/android/src/jni/encoded_image.h
View File

@ -25,12 +25,12 @@ class EncodedImage;
namespace jni {
ScopedJavaLocalRef<jobject> NativeToJavaFrameType(JNIEnv* env,
FrameType frame_type);
VideoFrameType frame_type);
ScopedJavaLocalRef<jobject> NativeToJavaEncodedImage(JNIEnv* jni,
const EncodedImage& image);
ScopedJavaLocalRef<jobjectArray> NativeToJavaFrameTypeArray(
JNIEnv* env,
const std::vector<FrameType>& frame_types);
const std::vector<VideoFrameType>& frame_types);
} // namespace jni
} // namespace webrtc

4
sdk/android/src/jni/video_encoder_wrapper.cc
View File

@ -120,7 +120,7 @@ int32_t VideoEncoderWrapper::Release() {
int32_t VideoEncoderWrapper::Encode(
const VideoFrame& frame,
const CodecSpecificInfo* /* codec_specific_info */,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
if (!initialized_) {
// Most likely initializing the codec failed.
return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
@ -275,7 +275,7 @@ void VideoEncoderWrapper::OnEncodedFrame(JNIEnv* jni,
frame._encodedHeight = encoded_height;
frame.SetTimestamp(frame_extra_info.timestamp_rtp);
frame.capture_time_ms_ = capture_time_ns / rtc::kNumNanosecsPerMillisec;
frame._frameType = (FrameType)frame_type;
frame._frameType = (VideoFrameType)frame_type;
frame.rotation_ = (VideoRotation)rotation;
frame._completeFrame = complete_frame;
if (qp == -1) {

2
sdk/android/src/jni/video_encoder_wrapper.h
View File

@ -43,7 +43,7 @@ class VideoEncoderWrapper : public VideoEncoder {
int32_t Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int32_t SetRateAllocation(const VideoBitrateAllocation& allocation,
uint32_t framerate) override;

2
sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm
View File

@ -52,7 +52,7 @@
encodedImage.timing_.flags = self.flags;
encodedImage.timing_.encode_start_ms = self.encodeStartMs;
encodedImage.timing_.encode_finish_ms = self.encodeFinishMs;
encodedImage._frameType = webrtc::FrameType(self.frameType);
encodedImage._frameType = webrtc::VideoFrameType(self.frameType);
encodedImage.rotation_ = webrtc::VideoRotation(self.rotation);
encodedImage._completeFrame = self.completeFrame;
encodedImage.qp_ = self.qp ? self.qp.intValue : -1;

2
sdk/objc/native/src/objc_video_encoder_factory.mm
View File

@ -75,7 +75,7 @@ class ObjCVideoEncoder : public VideoEncoder {
int32_t Encode(const VideoFrame &frame,
const CodecSpecificInfo *codec_specific_info,
const std::vector<FrameType> *frame_types) override {
const std::vector<VideoFrameType> *frame_types) override {
NSMutableArray<NSNumber *> *rtcFrameTypes = [NSMutableArray array];
for (size_t i = 0; i < frame_types->size(); ++i) {
[rtcFrameTypes addObject:@(RTCFrameType(frame_types->at(i)))];

4
sdk/objc/unittests/objc_video_encoder_factory_tests.mm
View File

@ -84,7 +84,7 @@ TEST(ObjCVideoEncoderFactoryTest, EncodeReturnsOKOnSuccess) {
.set_rotation(webrtc::kVideoRotation_0)
.set_timestamp_us(0)
.build();
std::vector<webrtc::FrameType> frame_types;
std::vector<webrtc::VideoFrameType> frame_types;
EXPECT_EQ(encoder->Encode(frame, &frame_types), WEBRTC_VIDEO_CODEC_OK);
}
@ -102,7 +102,7 @@ TEST(ObjCVideoEncoderFactoryTest, EncodeReturnsErrorOnFail) {
.set_rotation(webrtc::kVideoRotation_0)
.set_timestamp_us(0)
.build();
std::vector<webrtc::FrameType> frame_types;
std::vector<webrtc::VideoFrameType> frame_types;
EXPECT_EQ(encoder->Encode(frame, &frame_types), WEBRTC_VIDEO_CODEC_ERROR);
}

2
test/configurable_frame_size_encoder.cc
View File

@ -46,7 +46,7 @@ int32_t ConfigurableFrameSizeEncoder::InitEncode(
int32_t ConfigurableFrameSizeEncoder::Encode(
const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
EncodedImage encodedImage(buffer_.get(), current_frame_size_,
max_frame_size_);
encodedImage._completeFrame = true;

2
test/configurable_frame_size_encoder.h
View File

@ -39,7 +39,7 @@ class ConfigurableFrameSizeEncoder : public VideoEncoder {
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) override;

16
test/fake_encoder.cc
View File

@ -82,7 +82,7 @@ int32_t FakeEncoder::InitEncode(const VideoCodec* config,
int32_t FakeEncoder::Encode(const VideoFrame& input_image,
const CodecSpecificInfo* /*codec_specific_info*/,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
unsigned char max_framerate;
unsigned char num_simulcast_streams;
SimulcastStream simulcast_streams[kMaxSimulcastStreams];
@ -161,7 +161,7 @@ std::unique_ptr<RTPFragmentationHeader> FakeEncoder::EncodeHook(
}
FakeEncoder::FrameInfo FakeEncoder::NextFrame(
const std::vector<FrameType>* frame_types,
const std::vector<VideoFrameType>* frame_types,
bool keyframe,
uint8_t num_simulcast_streams,
const VideoBitrateAllocation& target_bitrate,
@ -171,7 +171,7 @@ FakeEncoder::FrameInfo FakeEncoder::NextFrame(
frame_info.keyframe = keyframe;
if (frame_types) {
for (FrameType frame_type : *frame_types) {
for (VideoFrameType frame_type : *frame_types) {
if (frame_type == kVideoFrameKey) {
frame_info.keyframe = true;
break;
@ -356,7 +356,7 @@ void DelayedEncoder::SetDelay(int delay_ms) {
int32_t DelayedEncoder::Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
SleepMs(delay_ms_);
@ -390,7 +390,7 @@ class MultithreadedFakeH264Encoder::EncodeTask : public rtc::QueuedTask {
EncodeTask(MultithreadedFakeH264Encoder* encoder,
const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types)
const std::vector<VideoFrameType>* frame_types)
: encoder_(encoder),
input_image_(input_image),
codec_specific_info_(),
@ -409,13 +409,13 @@ class MultithreadedFakeH264Encoder::EncodeTask : public rtc::QueuedTask {
MultithreadedFakeH264Encoder* const encoder_;
VideoFrame input_image_;
CodecSpecificInfo codec_specific_info_;
std::vector<FrameType> frame_types_;
std::vector<VideoFrameType> frame_types_;
};
int32_t MultithreadedFakeH264Encoder::Encode(
const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
std::unique_ptr<rtc::TaskQueue>& queue =
@ -434,7 +434,7 @@ int32_t MultithreadedFakeH264Encoder::Encode(
int32_t MultithreadedFakeH264Encoder::EncodeCallback(
const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
return FakeH264Encoder::Encode(input_image, codec_specific_info, frame_types);
}

10
test/fake_encoder.h
View File

@ -46,7 +46,7 @@ class FakeEncoder : public VideoEncoder {
size_t max_payload_size) override;
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) override;
int32_t Release() override;
@ -72,7 +72,7 @@ class FakeEncoder : public VideoEncoder {
std::vector<SpatialLayer> layers;
};
FrameInfo NextFrame(const std::vector<FrameType>* frame_types,
FrameInfo NextFrame(const std::vector<VideoFrameType>* frame_types,
bool keyframe,
uint8_t num_simulcast_streams,
const VideoBitrateAllocation& target_bitrate,
@ -126,7 +126,7 @@ class DelayedEncoder : public test::FakeEncoder {
void SetDelay(int delay_ms);
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
private:
int delay_ms_ RTC_GUARDED_BY(sequence_checker_);
@ -148,11 +148,11 @@ class MultithreadedFakeH264Encoder : public test::FakeH264Encoder {
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int32_t EncodeCallback(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types);
const std::vector<VideoFrameType>* frame_types);
int32_t Release() override;

2
test/fake_vp8_encoder.cc
View File

@ -92,7 +92,7 @@ void FakeVP8Encoder::SetupTemporalLayers(const VideoCodec& codec) {
void FakeVP8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
size_t size_bytes,
FrameType frame_type,
VideoFrameType frame_type,
int stream_idx,
uint32_t timestamp) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);

2
test/fake_vp8_encoder.h
View File

@ -48,7 +48,7 @@ class FakeVP8Encoder : public FakeEncoder {
void SetupTemporalLayers(const VideoCodec& codec);
void PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
size_t size_bytes,
FrameType frame_type,
VideoFrameType frame_type,
int stream_idx,
uint32_t timestamp);

4
test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.cc
View File

@ -87,7 +87,7 @@ int32_t QualityAnalyzingVideoEncoder::Release() {
int32_t QualityAnalyzingVideoEncoder::Encode(
const VideoFrame& frame,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
{
rtc::CritScope crit(&lock_);
// Store id to be able to retrieve it in analyzing callback.
@ -245,7 +245,7 @@ bool QualityAnalyzingVideoEncoder::ShouldDiscard(
// are equal or less than required one are interesting, so all above
// have to be discarded. For other frames only required spatial index
// is interesting, so all others have to be discarded.
if (encoded_image._frameType == FrameType::kVideoFrameKey) {
if (encoded_image._frameType == VideoFrameType::kVideoFrameKey) {
return *encoded_image.SpatialIndex() > *required_spatial_index;
} else {
return *encoded_image.SpatialIndex() != *required_spatial_index;

2
test/pc/e2e/analyzer/video/quality_analyzing_video_encoder.h
View File

@ -68,7 +68,7 @@ class QualityAnalyzingVideoEncoder : public VideoEncoder,
EncodedImageCallback* callback) override;
int32_t Release() override;
int32_t Encode(const VideoFrame& frame,
const std::vector<FrameType>* frame_types) override;
const std::vector<VideoFrameType>* frame_types) override;
int32_t SetRates(uint32_t bitrate, uint32_t framerate) override;
int32_t SetRateAllocation(const VideoBitrateAllocation& allocation,
uint32_t framerate) override;

2
test/video_encoder_proxy_factory.h
View File

@ -62,7 +62,7 @@ class VideoEncoderProxyFactory final : public VideoEncoderFactory {
private:
int32_t Encode(const VideoFrame& input_image,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
return encoder_->Encode(input_image, frame_types);
}
int32_t InitEncode(const VideoCodec* config,

6
video/end_to_end_tests/network_state_tests.cc
View File

@ -269,7 +269,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
{
rtc::CritScope lock(&test_crit_);
if (sender_state_ == kNetworkDown) {
@ -365,7 +365,7 @@ TEST_F(NetworkStateEndToEndTest, NewVideoSendStreamsRespectVideoNetworkDown) {
}
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
ADD_FAILURE() << "Unexpected frame encode.";
return test::FakeEncoder::Encode(input_image, codec_specific_info,
frame_types);
@ -390,7 +390,7 @@ TEST_F(NetworkStateEndToEndTest, NewVideoSendStreamsIgnoreAudioNetworkDown) {
}
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
encoded_frame_ = true;
return test::FakeEncoder::Encode(input_image, codec_specific_info,
frame_types);

2
video/picture_id_tests.cc
View File

@ -72,7 +72,7 @@ class PictureIdObserver : public test::RtpRtcpObserver {
int16_t picture_id;
int16_t tl0_pic_idx;
uint8_t temporal_idx;
FrameType frame_type;
VideoFrameType frame_type;
};
bool ParsePayload(const uint8_t* packet,

2
video/video_quality_test.cc
View File

@ -142,7 +142,7 @@ class QualityTestVideoEncoder : public VideoEncoder,
}
int32_t Release() override { return encoder_->Release(); }
int32_t Encode(const VideoFrame& frame,
const std::vector<FrameType>* frame_types) {
const std::vector<VideoFrameType>* frame_types) {
if (analyzer_) {
analyzer_->PreEncodeOnFrame(frame);
}

8
video/video_send_stream_tests.cc
View File

@ -1984,7 +1984,7 @@ TEST_F(VideoSendStreamTest,
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
ADD_FAILURE()
<< "Unexpected Encode call since the send stream is not started";
return 0;
@ -2318,7 +2318,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
int32_t Encode(const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
EXPECT_TRUE(IsReadyForEncode());
observation_complete_.Set();
@ -2537,7 +2537,7 @@ class VideoCodecConfigObserver : public test::SendTest,
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
// Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
return 0;
}
@ -3003,7 +3003,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
private:
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
CodecSpecificInfo specifics;
specifics.codecType = kVideoCodecGeneric;

3
video/video_stream_encoder.cc
View File

@ -1731,7 +1731,8 @@ void VideoStreamEncoder::RunPostEncode(EncodedImage encoded_image,
// Run post encode tasks, such as overuse detection and frame rate/drop
// stats for internal encoders.
const size_t frame_size = encoded_image.size();
const bool keyframe = encoded_image._frameType == FrameType::kVideoFrameKey;
const bool keyframe =
encoded_image._frameType == VideoFrameType::kVideoFrameKey;
if (frame_size > 0) {
frame_dropper_.Fill(frame_size, !keyframe);

2
video/video_stream_encoder.h
View File

@ -316,7 +316,7 @@ class VideoStreamEncoder : public VideoStreamEncoderInterface,
// TODO(sprang): Change actually support keyframe per simulcast stream, or
// turn this into a simple bool |pending_keyframe_request_|.
std::vector<FrameType> next_frame_types_ RTC_GUARDED_BY(&encoder_queue_);
std::vector<VideoFrameType> next_frame_types_ RTC_GUARDED_BY(&encoder_queue_);
FrameEncodeTimer frame_encoder_timer_;

24
video/video_stream_encoder_unittest.cc
View File

@ -606,14 +606,14 @@ class VideoStreamEncoderTest : public ::testing::Test {
return last_update_rect_;
}
const std::vector<FrameType>& LastFrameTypes() const {
const std::vector<VideoFrameType>& LastFrameTypes() const {
rtc::CritScope lock(&local_crit_sect_);
return last_frame_types_;
}
void InjectFrame(const VideoFrame& input_image, bool keyframe) {
const std::vector<FrameType> frame_type = {keyframe ? kVideoFrameKey
: kVideoFrameDelta};
const std::vector<VideoFrameType> frame_type = {
keyframe ? kVideoFrameKey : kVideoFrameDelta};
{
rtc::CritScope lock(&local_crit_sect_);
last_frame_types_ = frame_type;
@ -640,7 +640,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
private:
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<FrameType>* frame_types) override {
const std::vector<VideoFrameType>* frame_types) override {
bool block_encode;
{
rtc::CritScope lock(&local_crit_sect_);
@ -747,7 +747,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
absl::optional<VideoBitrateAllocation> last_bitrate_allocation_;
VideoFrame::UpdateRect last_update_rect_
RTC_GUARDED_BY(local_crit_sect_) = {0, 0, 0, 0};
std::vector<FrameType> last_frame_types_;
std::vector<VideoFrameType> last_frame_types_;
bool expect_null_frame_ = false;
EncodedImageCallback* encoded_image_callback_
RTC_GUARDED_BY(local_crit_sect_) = nullptr;
@ -3605,20 +3605,20 @@ TEST_F(VideoStreamEncoderTest, SetsFrameTypes) {
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
EXPECT_THAT(fake_encoder_.LastFrameTypes(),
testing::ElementsAre(FrameType{kVideoFrameKey}));
testing::ElementsAre(VideoFrameType{kVideoFrameKey}));
// Insert delta frame.
video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
WaitForEncodedFrame(2);
EXPECT_THAT(fake_encoder_.LastFrameTypes(),
testing::ElementsAre(FrameType{kVideoFrameDelta}));
testing::ElementsAre(VideoFrameType{kVideoFrameDelta}));
// Request next frame be a key-frame.
video_stream_encoder_->SendKeyFrame();
video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
WaitForEncodedFrame(3);
EXPECT_THAT(fake_encoder_.LastFrameTypes(),
testing::ElementsAre(FrameType{kVideoFrameKey}));
testing::ElementsAre(VideoFrameType{kVideoFrameKey}));
video_stream_encoder_->Stop();
}
@ -3669,23 +3669,23 @@ TEST_F(VideoStreamEncoderTest, RequestKeyframeInternalSource) {
fake_encoder_.InjectFrame(CreateFrame(1, nullptr), true);
EXPECT_TRUE(WaitForFrame(kDefaultTimeoutMs));
EXPECT_THAT(fake_encoder_.LastFrameTypes(),
testing::ElementsAre(FrameType{kVideoFrameKey}));
testing::ElementsAre(VideoFrameType{kVideoFrameKey}));
const std::vector<FrameType> kDeltaFrame = {kVideoFrameDelta};
const std::vector<VideoFrameType> kDeltaFrame = {kVideoFrameDelta};
// Need to set timestamp manually since manually for injected frame.
VideoFrame frame = CreateFrame(101, nullptr);
frame.set_timestamp(101);
fake_encoder_.InjectFrame(frame, false);
EXPECT_TRUE(WaitForFrame(kDefaultTimeoutMs));
EXPECT_THAT(fake_encoder_.LastFrameTypes(),
testing::ElementsAre(FrameType{kVideoFrameDelta}));
testing::ElementsAre(VideoFrameType{kVideoFrameDelta}));
// Request key-frame. The forces a dummy frame down into the encoder.
fake_encoder_.ExpectNullFrame();
video_stream_encoder_->SendKeyFrame();
EXPECT_TRUE(WaitForFrame(kDefaultTimeoutMs));
EXPECT_THAT(fake_encoder_.LastFrameTypes(),
testing::ElementsAre(FrameType{kVideoFrameKey}));
testing::ElementsAre(VideoFrameType{kVideoFrameKey}));
video_stream_encoder_->Stop();
}