1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
/*
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "media/engine/scopedvideoencoder.h"
#include <vector>
#include "api/video_codecs/video_encoder.h"
namespace cricket {
namespace {
class ScopedVideoEncoder : public webrtc::VideoEncoder {
public:
ScopedVideoEncoder(WebRtcVideoEncoderFactory* factory,
webrtc::VideoEncoder* encoder);
int32_t InitEncode(const webrtc::VideoCodec* codec_settings,
int32_t number_of_cores,
size_t max_payload_size) override;
int32_t RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback) override;
int32_t Release() override;
int32_t Encode(const webrtc::VideoFrame& frame,
const webrtc::CodecSpecificInfo* codec_specific_info,
const std::vector<webrtc::FrameType>* frame_types) override;
int32_t SetChannelParameters(uint32_t packet_loss, int64_t rtt) override;
int32_t SetRates(uint32_t bitrate, uint32_t framerate) override;
int32_t SetRateAllocation(const webrtc::BitrateAllocation& allocation,
uint32_t framerate) override;
ScalingSettings GetScalingSettings() const override;
int32_t SetPeriodicKeyFrames(bool enable) override;
bool SupportsNativeHandle() const override;
const char* ImplementationName() const override;
~ScopedVideoEncoder() override;
private:
WebRtcVideoEncoderFactory* factory_;
webrtc::VideoEncoder* encoder_;
};
ScopedVideoEncoder::ScopedVideoEncoder(WebRtcVideoEncoderFactory* factory,
webrtc::VideoEncoder* encoder)
: factory_(factory), encoder_(encoder) {}
int32_t ScopedVideoEncoder::InitEncode(const webrtc::VideoCodec* codec_settings,
int32_t number_of_cores,
size_t max_payload_size) {
return encoder_->InitEncode(codec_settings, number_of_cores,
max_payload_size);
}
int32_t ScopedVideoEncoder::RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback) {
return encoder_->RegisterEncodeCompleteCallback(callback);
}
int32_t ScopedVideoEncoder::Release() {
return encoder_->Release();
}
int32_t ScopedVideoEncoder::Encode(
const webrtc::VideoFrame& frame,
const webrtc::CodecSpecificInfo* codec_specific_info,
const std::vector<webrtc::FrameType>* frame_types) {
return encoder_->Encode(frame, codec_specific_info, frame_types);
}
int32_t ScopedVideoEncoder::SetChannelParameters(uint32_t packet_loss,
int64_t rtt) {
return encoder_->SetChannelParameters(packet_loss, rtt);
}
int32_t ScopedVideoEncoder::SetRates(uint32_t bitrate, uint32_t framerate) {
return encoder_->SetRates(bitrate, framerate);
}
int32_t ScopedVideoEncoder::SetRateAllocation(
const webrtc::BitrateAllocation& allocation,
uint32_t framerate) {
return encoder_->SetRateAllocation(allocation, framerate);
}
webrtc::VideoEncoder::ScalingSettings ScopedVideoEncoder::GetScalingSettings()
const {
return encoder_->GetScalingSettings();
}
int32_t ScopedVideoEncoder::SetPeriodicKeyFrames(bool enable) {
return encoder_->SetPeriodicKeyFrames(enable);
}
bool ScopedVideoEncoder::SupportsNativeHandle() const {
return encoder_->SupportsNativeHandle();
}
const char* ScopedVideoEncoder::ImplementationName() const {
return encoder_->ImplementationName();
}
ScopedVideoEncoder::~ScopedVideoEncoder() {
factory_->DestroyVideoEncoder(encoder_);
}
} // namespace
std::unique_ptr<webrtc::VideoEncoder> CreateScopedVideoEncoder(
WebRtcVideoEncoderFactory* factory,
const VideoCodec& codec) {
webrtc::VideoEncoder* encoder = factory->CreateVideoEncoder(codec);
if (!encoder)
return nullptr;
return std::unique_ptr<webrtc::VideoEncoder>(
new ScopedVideoEncoder(factory, encoder));
}
} // namespace cricket
|
