1 /*
2 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "webrtc/video_engine/vie_image_process_impl.h"
12
13 #include "webrtc/system_wrappers/interface/logging.h"
14 #include "webrtc/video_engine/include/vie_errors.h"
15 #include "webrtc/video_engine/vie_capturer.h"
16 #include "webrtc/video_engine/vie_channel.h"
17 #include "webrtc/video_engine/vie_channel_manager.h"
18 #include "webrtc/video_engine/vie_defines.h"
19 #include "webrtc/video_engine/vie_encoder.h"
20 #include "webrtc/video_engine/vie_impl.h"
21 #include "webrtc/video_engine/vie_input_manager.h"
22 #include "webrtc/video_engine/vie_shared_data.h"
23
24 namespace webrtc {
25
GetInterface(VideoEngine * video_engine)26 ViEImageProcess* ViEImageProcess::GetInterface(VideoEngine* video_engine) {
27 #ifdef WEBRTC_VIDEO_ENGINE_IMAGE_PROCESS_API
28 if (!video_engine) {
29 return NULL;
30 }
31 VideoEngineImpl* vie_impl = static_cast<VideoEngineImpl*>(video_engine);
32 ViEImageProcessImpl* vie_image_process_impl = vie_impl;
33 // Increase ref count.
34 (*vie_image_process_impl)++;
35 return vie_image_process_impl;
36 #else
37 return NULL;
38 #endif
39 }
40
Release()41 int ViEImageProcessImpl::Release() {
42 // Decrease ref count.
43 (*this)--;
44
45 int32_t ref_count = GetCount();
46 if (ref_count < 0) {
47 LOG(LS_ERROR) << "ViEImageProcess release too many times";
48 shared_data_->SetLastError(kViEAPIDoesNotExist);
49 return -1;
50 }
51 return ref_count;
52 }
53
ViEImageProcessImpl(ViESharedData * shared_data)54 ViEImageProcessImpl::ViEImageProcessImpl(ViESharedData* shared_data)
55 : shared_data_(shared_data) {}
56
~ViEImageProcessImpl()57 ViEImageProcessImpl::~ViEImageProcessImpl() {}
58
RegisterCaptureEffectFilter(const int capture_id,ViEEffectFilter & capture_filter)59 int ViEImageProcessImpl::RegisterCaptureEffectFilter(
60 const int capture_id,
61 ViEEffectFilter& capture_filter) {
62 LOG_F(LS_INFO) << "capture_id: " << capture_id;
63 ViEInputManagerScoped is(*(shared_data_->input_manager()));
64 ViECapturer* vie_capture = is.Capture(capture_id);
65 if (!vie_capture) {
66 shared_data_->SetLastError(kViEImageProcessInvalidCaptureId);
67 return -1;
68 }
69 if (vie_capture->RegisterEffectFilter(&capture_filter) != 0) {
70 shared_data_->SetLastError(kViEImageProcessFilterExists);
71 return -1;
72 }
73 return 0;
74 }
75
DeregisterCaptureEffectFilter(const int capture_id)76 int ViEImageProcessImpl::DeregisterCaptureEffectFilter(const int capture_id) {
77 LOG_F(LS_INFO) << "capture_id: " << capture_id;
78
79 ViEInputManagerScoped is(*(shared_data_->input_manager()));
80 ViECapturer* vie_capture = is.Capture(capture_id);
81 if (!vie_capture) {
82 shared_data_->SetLastError(kViEImageProcessInvalidCaptureId);
83 return -1;
84 }
85 if (vie_capture->RegisterEffectFilter(NULL) != 0) {
86 shared_data_->SetLastError(kViEImageProcessFilterDoesNotExist);
87 return -1;
88 }
89 return 0;
90 }
91
RegisterSendEffectFilter(const int video_channel,ViEEffectFilter & send_filter)92 int ViEImageProcessImpl::RegisterSendEffectFilter(
93 const int video_channel,
94 ViEEffectFilter& send_filter) {
95 LOG_F(LS_INFO) << "video_channel: " << video_channel;
96
97 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
98 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
99 if (vie_encoder == NULL) {
100 shared_data_->SetLastError(kViEImageProcessInvalidChannelId);
101 return -1;
102 }
103
104 if (vie_encoder->RegisterEffectFilter(&send_filter) != 0) {
105 shared_data_->SetLastError(kViEImageProcessFilterExists);
106 return -1;
107 }
108 return 0;
109 }
110
DeregisterSendEffectFilter(const int video_channel)111 int ViEImageProcessImpl::DeregisterSendEffectFilter(const int video_channel) {
112 LOG_F(LS_INFO) << "video_channel: " << video_channel;
113
114 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
115 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
116 if (vie_encoder == NULL) {
117 shared_data_->SetLastError(kViEImageProcessInvalidChannelId);
118 return -1;
119 }
120 if (vie_encoder->RegisterEffectFilter(NULL) != 0) {
121 shared_data_->SetLastError(kViEImageProcessFilterDoesNotExist);
122 return -1;
123 }
124 return 0;
125 }
126
RegisterRenderEffectFilter(const int video_channel,ViEEffectFilter & render_filter)127 int ViEImageProcessImpl::RegisterRenderEffectFilter(
128 const int video_channel,
129 ViEEffectFilter& render_filter) {
130 LOG_F(LS_INFO) << "video_channel: " << video_channel;
131
132 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
133 ViEChannel* vie_channel = cs.Channel(video_channel);
134 if (!vie_channel) {
135 shared_data_->SetLastError(kViEImageProcessInvalidChannelId);
136 return -1;
137 }
138 if (vie_channel->RegisterEffectFilter(&render_filter) != 0) {
139 shared_data_->SetLastError(kViEImageProcessFilterExists);
140 return -1;
141 }
142 return 0;
143 }
144
DeregisterRenderEffectFilter(const int video_channel)145 int ViEImageProcessImpl::DeregisterRenderEffectFilter(const int video_channel) {
146 LOG_F(LS_INFO) << "video_channel: " << video_channel;
147
148 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
149 ViEChannel* vie_channel = cs.Channel(video_channel);
150 if (!vie_channel) {
151 shared_data_->SetLastError(kViEImageProcessInvalidChannelId);
152 return -1;
153 }
154
155 if (vie_channel->RegisterEffectFilter(NULL) != 0) {
156 shared_data_->SetLastError(kViEImageProcessFilterDoesNotExist);
157 return -1;
158 }
159 return 0;
160 }
161
EnableDeflickering(const int capture_id,const bool enable)162 int ViEImageProcessImpl::EnableDeflickering(const int capture_id,
163 const bool enable) {
164 LOG_F(LS_INFO) << "capture_id: " << capture_id
165 << " enable: " << (enable ? "on" : "off");
166
167 ViEInputManagerScoped is(*(shared_data_->input_manager()));
168 ViECapturer* vie_capture = is.Capture(capture_id);
169 if (!vie_capture) {
170 shared_data_->SetLastError(kViEImageProcessInvalidChannelId);
171 return -1;
172 }
173
174 if (vie_capture->EnableDeflickering(enable) != 0) {
175 if (enable) {
176 shared_data_->SetLastError(kViEImageProcessAlreadyEnabled);
177 } else {
178 shared_data_->SetLastError(kViEImageProcessAlreadyDisabled);
179 }
180 return -1;
181 }
182 return 0;
183 }
184
EnableDenoising(const int capture_id,const bool enable)185 int ViEImageProcessImpl::EnableDenoising(const int capture_id,
186 const bool enable) {
187 LOG_F(LS_INFO) << "capture_id: " << capture_id
188 << " enable: " << (enable ? "on" : "off");
189
190 ViEInputManagerScoped is(*(shared_data_->input_manager()));
191 ViECapturer* vie_capture = is.Capture(capture_id);
192 if (!vie_capture) {
193 shared_data_->SetLastError(kViEImageProcessInvalidCaptureId);
194 return -1;
195 }
196
197 if (vie_capture->EnableDenoising(enable) != 0) {
198 if (enable) {
199 shared_data_->SetLastError(kViEImageProcessAlreadyEnabled);
200 } else {
201 shared_data_->SetLastError(kViEImageProcessAlreadyDisabled);
202 }
203 return -1;
204 }
205 return 0;
206 }
207
EnableColorEnhancement(const int video_channel,const bool enable)208 int ViEImageProcessImpl::EnableColorEnhancement(const int video_channel,
209 const bool enable) {
210 LOG_F(LS_INFO) << "video_channel: " << video_channel
211 << " enable: " << (enable ? "on" : "off");
212
213 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
214 ViEChannel* vie_channel = cs.Channel(video_channel);
215 if (!vie_channel) {
216 shared_data_->SetLastError(kViEImageProcessInvalidChannelId);
217 return -1;
218 }
219 if (vie_channel->EnableColorEnhancement(enable) != 0) {
220 if (enable) {
221 shared_data_->SetLastError(kViEImageProcessAlreadyEnabled);
222 } else {
223 shared_data_->SetLastError(kViEImageProcessAlreadyDisabled);
224 }
225 return -1;
226 }
227 return 0;
228 }
229
RegisterPreEncodeCallback(int video_channel,I420FrameCallback * pre_encode_callback)230 void ViEImageProcessImpl::RegisterPreEncodeCallback(
231 int video_channel,
232 I420FrameCallback* pre_encode_callback) {
233 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
234 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
235 vie_encoder->RegisterPreEncodeCallback(pre_encode_callback);
236 }
237
DeRegisterPreEncodeCallback(int video_channel)238 void ViEImageProcessImpl::DeRegisterPreEncodeCallback(int video_channel) {
239 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
240 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
241 assert(vie_encoder != NULL);
242 vie_encoder->DeRegisterPreEncodeCallback();
243 }
244
RegisterPostEncodeImageCallback(int video_channel,EncodedImageCallback * post_encode_callback)245 void ViEImageProcessImpl::RegisterPostEncodeImageCallback(
246 int video_channel,
247 EncodedImageCallback* post_encode_callback) {
248 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
249 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
250 assert(vie_encoder != NULL);
251 vie_encoder->RegisterPostEncodeImageCallback(post_encode_callback);
252 }
253
DeRegisterPostEncodeCallback(int video_channel)254 void ViEImageProcessImpl::DeRegisterPostEncodeCallback(int video_channel) {
255 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
256 ViEEncoder* vie_encoder = cs.Encoder(video_channel);
257 assert(vie_encoder != NULL);
258 vie_encoder->DeRegisterPostEncodeImageCallback();
259 }
260
RegisterPreDecodeImageCallback(int video_channel,EncodedImageCallback * pre_decode_callback)261 void ViEImageProcessImpl::RegisterPreDecodeImageCallback(
262 int video_channel,
263 EncodedImageCallback* pre_decode_callback) {
264 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
265 ViEChannel* channel = cs.Channel(video_channel);
266 channel->RegisterPreDecodeImageCallback(pre_decode_callback);
267 }
268
DeRegisterPreDecodeCallback(int video_channel)269 void ViEImageProcessImpl::DeRegisterPreDecodeCallback(int video_channel) {
270 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
271 ViEChannel* channel = cs.Channel(video_channel);
272 channel->RegisterPreDecodeImageCallback(NULL);
273 }
274
RegisterPreRenderCallback(int video_channel,I420FrameCallback * pre_render_callback)275 void ViEImageProcessImpl::RegisterPreRenderCallback(
276 int video_channel,
277 I420FrameCallback* pre_render_callback) {
278 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
279 ViEChannel* vie_channel = cs.Channel(video_channel);
280 assert(vie_channel != NULL);
281 vie_channel->RegisterPreRenderCallback(pre_render_callback);
282 }
283
DeRegisterPreRenderCallback(int video_channel)284 void ViEImageProcessImpl::DeRegisterPreRenderCallback(int video_channel) {
285 ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
286 ViEChannel* vie_channel = cs.Channel(video_channel);
287 assert(vie_channel != NULL);
288 vie_channel->RegisterPreRenderCallback(NULL);
289 }
290
291 } // namespace webrtc
292