1 /*
2 * Copyright (c) 2019 Rockchip Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 */
17
18 #include "CamHwSimulator.h"
19 #include "xcam_thread.h"
20 #include "isp20_hw_simulator.h"
21 // globals for communicating with simulator
22
23 static XCam::Mutex g_sim_luma_mutex{false};
24 static XCam::Cond g_sim_luma_cond{false};
25 static volatile bool g_wait_luma = true;
26 static volatile bool g_luma_terminal = false;
27 static volatile bool g_luma_wait_result = true;
28 static XCam::Mutex g_luma_mutex{false};
29 static XCam::Cond g_luma_cond{false};
30
31 static XCam::Mutex g_sim_mutex{false};
32 static XCam::Cond g_sim_cond{false};
33 static volatile bool g_wait_stats = true;
34 static volatile bool g_terminal = false;
35 static volatile bool g_wait_result = true;
36 static XCam::Mutex g_3a_mutex{false};
37 static XCam::Cond g_3a_cond{false};
38
39 // extern shared var from demo.cpp
40 extern rk_sim_isp_v200_luma_t g_simisp_luma;
41 extern rk_sim_isp_v200_stats_t g_simisp_stats;
42 extern rk_sim_isp_v200_params_t g_simisp_params;
43
analyze_sim_luma()44 int analyze_sim_luma()
45 {
46 // wake up FakePollThread
47 //RkCam::CamHwSimulator* simctx = (RkCam::CamHwSimulator*)ctx;
48 {
49 SmartLock locker(g_sim_luma_mutex);
50 g_wait_luma = false;
51 SmartLock resultlocker(g_luma_mutex);
52 g_luma_wait_result = true;
53 LOGD("gsim broadcast...");
54 g_sim_luma_cond.broadcast ();
55 }
56 // wait result
57 {
58 LOGD("wait luma result ...");
59 SmartLock locker(g_luma_mutex);
60 if (g_luma_wait_result)
61 g_luma_cond.wait(g_luma_mutex);
62 LOGD("wait luma result over...");
63 }
64 return 0;
65 }
66
analyze_sim_stats()67 int analyze_sim_stats()
68 {
69 // wake up FakePollThread
70 //RkCam::CamHwSimulator* simctx = (RkCam::CamHwSimulator*)ctx;
71 {
72 SmartLock locker(g_sim_mutex);
73 g_wait_stats = false;
74 SmartLock resultlocker(g_3a_mutex);
75 g_wait_result = true;
76 LOGD("gsim broadcast...");
77 g_sim_cond.broadcast ();
78 }
79 // wait result
80 {
81 LOGD("wait 3a result ...");
82 SmartLock locker(g_3a_mutex);
83 if (g_wait_result)
84 g_3a_cond.wait(g_3a_mutex);
85 LOGD("wait 3a result over...");
86 }
87 return 0;
88 }
89
90 namespace RkCam {
91 class FakePollLumaThread : public PollThread
92 {
93 public:
FakePollLumaThread()94 FakePollLumaThread(): PollThread() {};
~FakePollLumaThread()95 virtual ~FakePollLumaThread() {};
96 protected:
97 SmartPtr<VideoBuffer> new_video_buffer(SmartPtr<V4l2Buffer> buf,
98 SmartPtr<V4l2Device> dev,
99 int type);
100 };
101
102 SmartPtr<VideoBuffer>
new_video_buffer(SmartPtr<V4l2Buffer> buf,SmartPtr<V4l2Device> dev,int type)103 FakePollLumaThread::new_video_buffer(SmartPtr<V4l2Buffer> buf,
104 SmartPtr<V4l2Device> dev,
105 int type)
106 {
107 {
108 LOGD("wait sim luma ...");
109 SmartLock locker(g_sim_luma_mutex);
110 if (g_wait_luma && !g_luma_terminal) {
111 g_sim_luma_cond.wait(g_sim_luma_mutex);
112 }
113 g_wait_luma = true;
114 LOGD("wait sim luma over ...");
115 }
116 // TODO: convert simulator stats to video buffer
117 SmartPtr<VideoBuffer> video_buf = new V4l2BufferProxy (buf, dev);
118
119 return video_buf;
120 }
121
122 class FakePollThread : public PollThread
123 {
124 public:
FakePollThread()125 FakePollThread(): PollThread() {};
~FakePollThread()126 virtual ~FakePollThread() {};
127 protected:
128 SmartPtr<VideoBuffer> new_video_buffer(SmartPtr<V4l2Buffer> buf,
129 SmartPtr<V4l2Device> dev,
130 int type);
131 };
132
133 SmartPtr<VideoBuffer>
new_video_buffer(SmartPtr<V4l2Buffer> buf,SmartPtr<V4l2Device> dev,int type)134 FakePollThread::new_video_buffer(SmartPtr<V4l2Buffer> buf,
135 SmartPtr<V4l2Device> dev,
136 int type)
137 {
138 {
139 LOGD("wait sim stats ...");
140 SmartLock locker(g_sim_mutex);
141 if (g_wait_stats && !g_terminal) {
142 g_sim_cond.wait(g_sim_mutex);
143 }
144 g_wait_stats = true;
145 LOGD("wait sim stats over ...");
146 }
147 // TODO: convert simulator stats to video buffer
148 SmartPtr<VideoBuffer> video_buf = new V4l2BufferProxy (buf, dev);
149
150 return video_buf;
151 }
152
153 class FakeLumaV4l2Device : public V4l2Device
154 {
155 public:
FakeLumaV4l2Device()156 FakeLumaV4l2Device () : V4l2Device("/dev/null") {};
~FakeLumaV4l2Device()157 virtual ~FakeLumaV4l2Device () {};
start()158 virtual XCamReturn start () {
159 _active = true;
160 return XCAM_RETURN_NO_ERROR;
161 };
stop()162 virtual XCamReturn stop () {
163 _active = false;
164 return XCAM_RETURN_NO_ERROR;
165 };
dequeue_buffer(SmartPtr<V4l2Buffer> & buf)166 virtual XCamReturn dequeue_buffer (SmartPtr<V4l2Buffer> &buf) {
167 ENTER_CAMHW_FUNCTION();
168 g_simisp_luma.valid_luma = true;
169 v4l2_buf.m.userptr = (unsigned long)&g_simisp_luma;
170 buf = new V4l2Buffer(v4l2_buf, format);
171 EXIT_CAMHW_FUNCTION();
172 return XCAM_RETURN_NO_ERROR;
173 };
queue_buffer(SmartPtr<V4l2Buffer> & buf)174 virtual XCamReturn queue_buffer (SmartPtr<V4l2Buffer> &buf) {
175 ENTER_CAMHW_FUNCTION();
176 EXIT_CAMHW_FUNCTION();
177 return XCAM_RETURN_NO_ERROR;
178 };
179 private:
180 struct v4l2_buffer v4l2_buf;
181 struct v4l2_format format;
182 };
183
184 class FakeV4l2Device : public V4l2Device
185 {
186 public:
FakeV4l2Device()187 FakeV4l2Device () : V4l2Device("/dev/null") {};
~FakeV4l2Device()188 virtual ~FakeV4l2Device () {};
start()189 virtual XCamReturn start () {
190 _active = true;
191 return XCAM_RETURN_NO_ERROR;
192 };
stop()193 virtual XCamReturn stop () {
194 _active = false;
195 return XCAM_RETURN_NO_ERROR;
196 };
dequeue_buffer(SmartPtr<V4l2Buffer> & buf)197 virtual XCamReturn dequeue_buffer (SmartPtr<V4l2Buffer> &buf) {
198 ENTER_CAMHW_FUNCTION();
199 g_simisp_stats.valid_awb = true;
200 g_simisp_stats.valid_ae = true;
201 g_simisp_stats.valid_af = true;
202 v4l2_buf.m.userptr = (unsigned long)&g_simisp_stats;
203 buf = new V4l2Buffer(v4l2_buf, format);
204 EXIT_CAMHW_FUNCTION();
205 return XCAM_RETURN_NO_ERROR;
206 };
queue_buffer(SmartPtr<V4l2Buffer> & buf)207 virtual XCamReturn queue_buffer (SmartPtr<V4l2Buffer> &buf) {
208 ENTER_CAMHW_FUNCTION();
209 EXIT_CAMHW_FUNCTION();
210 return XCAM_RETURN_NO_ERROR;
211 };
212 private:
213 struct v4l2_buffer v4l2_buf;
214 struct v4l2_format format;
215 };
216
CamHwSimulator()217 CamHwSimulator::CamHwSimulator()
218 {
219 ENTER_CAMHW_FUNCTION();
220 EXIT_CAMHW_FUNCTION();
221 }
222
~CamHwSimulator()223 CamHwSimulator::~CamHwSimulator()
224 {
225 ENTER_CAMHW_FUNCTION();
226 EXIT_CAMHW_FUNCTION();
227 }
228
229 XCamReturn
init(const char * sns_ent_name)230 CamHwSimulator::init(const char* sns_ent_name)
231 {
232 ENTER_CAMHW_FUNCTION();
233 mIspLumaDev = new FakeLumaV4l2Device ();
234 mIspLumaDev->open();
235 mPollLumathread = new FakePollLumaThread();
236 mPollLumathread->set_isp_luma_device(mIspLumaDev);
237 mPollLumathread->set_poll_callback (this);
238
239 mIspStatsDev = new FakeV4l2Device ();
240 mIspStatsDev->open();
241 mPollthread = new FakePollThread();
242 mPollthread->set_isp_stats_device(mIspStatsDev);
243 mPollthread->set_poll_callback (this);
244 EXIT_CAMHW_FUNCTION();
245
246 return XCAM_RETURN_NO_ERROR;
247 }
248
249 XCamReturn
setIspParams(SmartPtr<RkAiqIspParamsProxy> & ispParams)250 CamHwSimulator::setIspParams(SmartPtr<RkAiqIspParamsProxy>& ispParams)
251 {
252 ENTER_CAMHW_FUNCTION();
253 CamHwBase::setIspParams(ispParams);
254 // TODO: set new params to variable shared with simulator
255 //awb
256 g_simisp_params.awb_gain_algo = ispParams->data()->awb_gain;
257 g_simisp_params.awb_hw0_para = ispParams->data()->awb_cfg_v200;
258 g_simisp_params.awb_hw1_para = ispParams->data()->awb_cfg_v201;
259 //g_simisp_params.awb_smooth_factor = ispParams->data()->awb_smooth_factor;
260 LOGD("new awb threeDyuvIllu[2] %d ...", g_simisp_params.awb_hw0_para.threeDyuvIllu[2]);
261 LOGD("new awb stat3aAwbGainOut.rgain %f ...", g_simisp_params.awb_gain_algo.rgain);
262 //ae
263 g_simisp_params.ae_hw_config.ae_meas = ispParams->data()->aec_meas;
264 g_simisp_params.ae_hw_config.hist_meas = ispParams->data()->hist_meas;
265 LOGE("return new AeHwConfig,rawae1.wnd_num=%d,rawae2.win.h_size=%d,rawhist2.weight[25]=%d",
266 g_simisp_params.ae_hw_config.ae_meas.rawae1.wnd_num,
267 g_simisp_params.ae_hw_config.ae_meas.rawae2.win.h_size,
268 g_simisp_params.ae_hw_config.hist_meas.rawhist1.weight[25]);
269
270 #if 1
271 g_simisp_params.rkaiq_anr_proc_res = ispParams->data()->rkaiq_anr_proc_res;
272 #endif
273
274 #if 1
275 g_simisp_params.rkaiq_asharp_proc_res = ispParams->data()->rkaiq_asharp_proc_res;
276 #endif
277 // adhaz
278 g_simisp_params.adhaz_config = ispParams->data()->adhaz_config;
279
280 //agamma
281 g_simisp_params.agamma_config = ispParams->data()->agamma;
282
283 g_simisp_params.blc = ispParams->data()->blc;
284
285 //ahdr
286 g_simisp_params.ahdr_proc_res = ispParams->data()->ahdr_proc_res;
287
288 g_simisp_params.lscHwConf = ispParams->data()->lsc;
289 g_simisp_params.ccmHwConf = ispParams->data()->ccm;
290
291 g_simisp_params.dpcc = ispParams->data()->dpcc;
292
293 g_simisp_params.lut3d_hw_conf = ispParams->data()->lut3d;
294
295 //debayer
296 g_simisp_params.adebayer_config = ispParams->data()->demosaic;
297 //agic
298 g_simisp_params.agic_config = ispParams->data()->gic;
299
300 {
301 SmartLock locker(g_3a_mutex);
302 g_wait_result = false;
303 g_3a_cond.broadcast ();
304 }
305 EXIT_CAMHW_FUNCTION();
306
307 return XCAM_RETURN_NO_ERROR;
308 }
309
310 XCamReturn
setHdrProcessCount(uint32_t frame_id,rk_aiq_luma_params_t luma_params)311 CamHwSimulator::setHdrProcessCount(uint32_t frame_id, rk_aiq_luma_params_t luma_params)
312 {
313 ENTER_CAMHW_FUNCTION();
314
315 //TODO::set HDR process count to register
316 printf("lumatest set process count: %d\n", count);
317 {
318 SmartLock locker(g_luma_mutex);
319 g_luma_wait_result = false;
320 g_luma_cond.broadcast();
321 }
322
323 EXIT_CAMHW_FUNCTION();
324
325 return XCAM_RETURN_NO_ERROR;
326 }
327
328 XCamReturn
deInit()329 CamHwSimulator::deInit()
330 {
331 ENTER_CAMHW_FUNCTION();
332 mIspStatsDev->close();
333 mIspLumaDev->close();
334 EXIT_CAMHW_FUNCTION();
335
336 return CamHwBase::deInit();
337 }
338
339 XCamReturn
prepare(uint32_t width,uint32_t height,rk_aiq_working_mode_t mode)340 CamHwSimulator::prepare(uint32_t width, uint32_t height, rk_aiq_working_mode_t mode)
341 {
342 return CamHwBase::prepare(width, height, mode, 0, 0);
343 }
344
345 XCamReturn
start()346 CamHwSimulator::start()
347 {
348 ENTER_CAMHW_FUNCTION();
349 mIspStatsDev->start();
350 mIspLumaDev->start();
351 EXIT_CAMHW_FUNCTION();
352
353 return CamHwBase::start();
354 }
355
356 XCamReturn
stop()357 CamHwSimulator::stop()
358 {
359 ENTER_CAMHW_FUNCTION();
360 {
361 SmartLock locker(g_sim_mutex);
362 g_wait_stats = false;
363 g_terminal = true;
364 g_sim_cond.broadcast ();
365
366 g_wait_luma = false;
367 g_luma_terminal = true;
368 g_sim_luma_cond.broadcast ();
369 }
370 mIspStatsDev->stop();
371 mIspLumaDev->stop();
372
373 EXIT_CAMHW_FUNCTION();
374
375 return CamHwBase::stop();
376 }
377
378 XCamReturn
getSensorModeData(const char * sns_ent_name,rk_aiq_exposure_sensor_descriptor & sns_des)379 CamHwSimulator::getSensorModeData(const char* sns_ent_name,
380 rk_aiq_exposure_sensor_descriptor& sns_des)
381 {
382 sns_des.sensor_output_width = g_simisp_params.rawWidth;
383 sns_des.sensor_output_height = g_simisp_params.rawHeight;
384 sns_des.isp_acq_width = g_simisp_params.rawWidth;
385 sns_des.isp_acq_height = g_simisp_params.rawHeight;
386
387 return XCAM_RETURN_NO_ERROR;
388 }
389 XCamReturn
setExposureParams(SmartPtr<RkAiqExpParamsProxy> & expPar)390 CamHwSimulator::setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar)
391 {
392 return CamHwBase::setExposureParams(expPar);
393 }
394
395 XCamReturn
setFocusParams(SmartPtr<RkAiqFocusParamsProxy> & focus_params)396 CamHwSimulator::setFocusParams(SmartPtr<RkAiqFocusParamsProxy>& focus_params)
397 {
398 return CamHwBase::setFocusParams(focus_params);
399 }
400
401 XCamReturn
setIspLumaListener(IspLumaListener * lumaListener)402 CamHwSimulator::setIspLumaListener(IspLumaListener* lumaListener)
403 {
404 return CamHwBase::setIspLumaListener(lumaListener);
405 }
406
407 XCamReturn
setIspStatsListener(IspStatsListener * statsListener)408 CamHwSimulator::setIspStatsListener(IspStatsListener* statsListener)
409 {
410 return CamHwBase::setIspStatsListener(statsListener);
411 }
412
413 XCamReturn
setEvtsListener(IspEvtsListener * evtListener)414 CamHwSimulator::setEvtsListener(IspEvtsListener* evtListener)
415 {
416 return CamHwBase::setEvtsListener(evtListener);
417 }
418
419 };
420