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 <sys/select.h>
19 #include <time.h>
20 #include "FakeSensorHw.h"
21 #include "fake_v4l2_device.h"
22 namespace RkCam {
23 using namespace std;
24
rk_format_to_media_format(rk_aiq_format_t format)25 static uint32_t rk_format_to_media_format(rk_aiq_format_t format)
26 {
27 uint32_t pixelformat = -1;
28 switch (format) {
29 case RK_PIX_FMT_SBGGR8:
30 pixelformat = MEDIA_BUS_FMT_SBGGR8_1X8;
31 break;
32 case RK_PIX_FMT_SRGGB8:
33 pixelformat = MEDIA_BUS_FMT_SRGGB8_1X8;
34 break;
35 case RK_PIX_FMT_SGBRG8:
36 pixelformat = MEDIA_BUS_FMT_SGBRG8_1X8;
37 break;
38 case RK_PIX_FMT_SGRBG8:
39 pixelformat = MEDIA_BUS_FMT_SGRBG8_1X8;
40 break;
41 case RK_PIX_FMT_SBGGR10:
42 pixelformat = MEDIA_BUS_FMT_SBGGR10_1X10;
43 break;
44 case RK_PIX_FMT_SRGGB10:
45 pixelformat = MEDIA_BUS_FMT_SRGGB10_1X10;
46 break;
47 case RK_PIX_FMT_SGBRG10:
48 pixelformat = MEDIA_BUS_FMT_SGBRG10_1X10;
49 break;
50 case RK_PIX_FMT_SGRBG10:
51 pixelformat = MEDIA_BUS_FMT_SGRBG10_1X10;
52 break;
53 case RK_PIX_FMT_SBGGR12:
54 pixelformat = MEDIA_BUS_FMT_SBGGR12_1X12;
55 break;
56 case RK_PIX_FMT_SRGGB12:
57 pixelformat = MEDIA_BUS_FMT_SRGGB12_1X12;
58 break;
59 case RK_PIX_FMT_SGBRG12:
60 pixelformat = MEDIA_BUS_FMT_SGBRG12_1X12;
61 break;
62 case RK_PIX_FMT_SGRBG12:
63 pixelformat = MEDIA_BUS_FMT_SGRBG12_1X12;
64 break;
65 case RK_PIX_FMT_SBGGR14:
66 pixelformat = MEDIA_BUS_FMT_SBGGR14_1X14;
67 break;
68 case RK_PIX_FMT_SRGGB14:
69 pixelformat = MEDIA_BUS_FMT_SRGGB14_1X14;
70 break;
71 case RK_PIX_FMT_SGBRG14:
72 pixelformat = MEDIA_BUS_FMT_SGBRG14_1X14;
73 break;
74 case RK_PIX_FMT_SGRBG14:
75 pixelformat = MEDIA_BUS_FMT_SGRBG14_1X14;
76 break;
77 default:
78 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "%s no support format: %d\n",
79 __func__, format);
80 }
81 return pixelformat;
82 }
83
FakeSensorHw()84 FakeSensorHw::FakeSensorHw()
85 : SensorHw ("/dev/null")
86 , _sync_cond(false)
87 , _need_sync(false)
88 {
89 ENTER_CAMHW_FUNCTION();
90 _timer = new CTimer(this);
91 pFunc = NULL;
92 EXIT_CAMHW_FUNCTION();
93 }
94
~FakeSensorHw()95 FakeSensorHw::~FakeSensorHw()
96 {
97 ENTER_CAMHW_FUNCTION();
98 delete _timer;
99 EXIT_CAMHW_FUNCTION();
100 }
101
102 int
get_blank(rk_aiq_exposure_sensor_descriptor * sns_des)103 FakeSensorHw::get_blank(rk_aiq_exposure_sensor_descriptor* sns_des)
104 {
105 sns_des->pixel_periods_per_line = sns_des->sensor_output_width;
106 sns_des->line_periods_per_field = sns_des->sensor_output_height;
107 return 0;
108 }
109
110 int
get_pixel(rk_aiq_exposure_sensor_descriptor * sns_des)111 FakeSensorHw::get_pixel(rk_aiq_exposure_sensor_descriptor* sns_des)
112 {
113 sns_des->pixel_clock_freq_mhz = 600.0f;
114 return 0;
115 }
116
117 int
get_sensor_fps(float & fps)118 FakeSensorHw::get_sensor_fps(float& fps)
119 {
120 fps = 25.0f;
121
122 return 0;
123 }
124
125 int
get_sensor_desc(rk_aiq_exposure_sensor_descriptor * sns_des)126 FakeSensorHw::get_sensor_desc(rk_aiq_exposure_sensor_descriptor* sns_des)
127 {
128 sns_des->sensor_output_width = _width;
129 sns_des->sensor_output_height = _height;
130 sns_des->sensor_pixelformat = get_v4l2_pixelformat(_fmt_code);
131 return 0;
132 }
133
134 int
get_exposure_range(rk_aiq_exposure_sensor_descriptor * sns_des)135 FakeSensorHw::get_exposure_range(rk_aiq_exposure_sensor_descriptor* sns_des)
136 {
137 sns_des->coarse_integration_time_min = 1;
138 sns_des->coarse_integration_time_max_margin = 10;
139 return 0;
140 }
141
142 int
get_nr_switch(rk_aiq_sensor_nr_switch_t * nr_switch)143 FakeSensorHw::get_nr_switch(rk_aiq_sensor_nr_switch_t* nr_switch)
144 {
145
146 nr_switch->valid = false;
147 nr_switch->direct = 0;
148 nr_switch->up_thres = 0;
149 nr_switch->down_thres = 0;
150 nr_switch->div_coeff = 0;
151
152 return 0;
153 }
154
155 XCamReturn
get_sensor_descriptor(rk_aiq_exposure_sensor_descriptor * sns_des)156 FakeSensorHw::get_sensor_descriptor(rk_aiq_exposure_sensor_descriptor *sns_des)
157 {
158 memset(sns_des, 0, sizeof(rk_aiq_exposure_sensor_descriptor));
159
160 if (get_sensor_desc(sns_des))
161 return XCAM_RETURN_ERROR_IOCTL;
162
163 if (get_blank(sns_des))
164 return XCAM_RETURN_ERROR_IOCTL;
165
166 /*
167 * pixel rate is not equal to pclk sometimes
168 * prefer to use pclk = ppl * lpp * fps
169 */
170 float fps = 0;
171 if (get_sensor_fps(fps) == 0)
172 sns_des->pixel_clock_freq_mhz =
173 (float)(sns_des->pixel_periods_per_line) *
174 sns_des->line_periods_per_field * fps / 1000000.0;
175 else if (get_pixel(sns_des))
176 return XCAM_RETURN_ERROR_IOCTL;
177
178 if (get_exposure_range(sns_des))
179 return XCAM_RETURN_ERROR_IOCTL;
180
181 if (get_nr_switch(&sns_des->nr_switch)) {
182 // do nothing;
183 }
184
185 return XCAM_RETURN_NO_ERROR;
186 }
187
188 XCamReturn
setExposureParams(SmartPtr<RkAiqExpParamsProxy> & expPar)189 FakeSensorHw::setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar)
190 {
191 ENTER_CAMHW_FUNCTION();
192
193 if (_first) {
194 RKAiqAecExpInfoWrapper_t* exp = &expPar->data()->result;
195 SmartPtr<RkAiqSensorExpParamsProxy> expParamsProxy = NULL;
196 if (exp->ae_proc_res_rk.exp_set_cnt > 0) {
197 SmartPtr<rk_aiq_sensor_exp_info_t> tmp;
198 if (_expParamsPool->has_free_items()) {
199 expParamsProxy = _expParamsPool->get_item();
200 tmp = expParamsProxy->data();
201 } else {
202 LOGE_CAMHW_SUBM(SENSOR_SUBM, "%s: no free params buffer!\n", __FUNCTION__);
203 return XCAM_RETURN_ERROR_MEM;
204 }
205 int lastIdx = exp->ae_proc_res_rk.exp_set_cnt - 1;
206 tmp->aecExpInfo.LinearExp = exp->ae_proc_res_rk.exp_set_tbl[lastIdx].LinearExp;
207 tmp->aecExpInfo.HdrExp[0] = exp->ae_proc_res_rk.exp_set_tbl[lastIdx].HdrExp[0];
208 tmp->aecExpInfo.HdrExp[1] = exp->ae_proc_res_rk.exp_set_tbl[lastIdx].HdrExp[1];
209 tmp->aecExpInfo.HdrExp[2] = exp->ae_proc_res_rk.exp_set_tbl[lastIdx].HdrExp[2];
210 tmp->aecExpInfo.frame_length_lines = exp->ae_proc_res_rk.exp_set_tbl[lastIdx].frame_length_lines;
211 tmp->aecExpInfo.line_length_pixels = exp->ae_proc_res_rk.exp_set_tbl[lastIdx].line_length_pixels;
212 tmp->aecExpInfo.pixel_clock_freq_mhz = exp->ae_proc_res_rk.exp_set_tbl[lastIdx].pixel_clock_freq_mhz;
213 }
214 _effecting_exp_map[0] = expParamsProxy;
215 _first = false;
216
217 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "exp-sync: first set exp, add id[0] to the effected exp map");
218 }
219
220 EXIT_CAMHW_FUNCTION();
221 return XCAM_RETURN_NO_ERROR;
222 }
223
224 XCamReturn
getSensorModeData(const char * sns_ent_name,rk_aiq_exposure_sensor_descriptor & sns_des)225 FakeSensorHw::getSensorModeData(const char* sns_ent_name,
226 rk_aiq_exposure_sensor_descriptor& sns_des)
227 {
228 rk_aiq_exposure_sensor_descriptor sensor_desc;
229 get_sensor_descriptor (&sensor_desc);
230
231 _sns_entity_name = sns_ent_name;
232 sns_des.coarse_integration_time_min =
233 sensor_desc.coarse_integration_time_min;
234 sns_des.coarse_integration_time_max_margin =
235 sensor_desc.coarse_integration_time_max_margin;
236 sns_des.fine_integration_time_min =
237 sensor_desc.fine_integration_time_min;
238 sns_des.fine_integration_time_max_margin =
239 sensor_desc.fine_integration_time_max_margin;
240
241 sns_des.frame_length_lines = sensor_desc.line_periods_per_field;
242 sns_des.line_length_pck = sensor_desc.pixel_periods_per_line;
243 sns_des.vt_pix_clk_freq_hz = sensor_desc.pixel_clock_freq_mhz/* * 1000000 */;
244 sns_des.pixel_clock_freq_mhz = sensor_desc.pixel_clock_freq_mhz/* * 1000000 */;
245
246 //add nr_switch
247 sns_des.nr_switch = sensor_desc.nr_switch;
248
249 sns_des.sensor_output_width = sensor_desc.sensor_output_width;
250 sns_des.sensor_output_height = sensor_desc.sensor_output_height;
251 sns_des.sensor_pixelformat = sensor_desc.sensor_pixelformat;
252
253 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "vts-hts-pclk: %d-%d-%d-%f, rect: [%dx%d]\n",
254 sns_des.frame_length_lines,
255 sns_des.line_length_pck,
256 sns_des.vt_pix_clk_freq_hz,
257 sns_des.pixel_clock_freq_mhz,
258 sns_des.sensor_output_width,
259 sns_des.sensor_output_height);
260
261 return XCAM_RETURN_NO_ERROR;
262 }
263
264 XCamReturn
handle_sof(int64_t time,uint32_t frameid)265 FakeSensorHw::handle_sof(int64_t time, uint32_t frameid)
266 {
267 ENTER_CAMHW_FUNCTION();
268 EXIT_CAMHW_FUNCTION();
269 return XCAM_RETURN_NO_ERROR;
270 }
271
272 XCamReturn
set_working_mode(int mode)273 FakeSensorHw::set_working_mode(int mode)
274 {
275 __u32 hdr_mode = NO_HDR;
276
277 if (mode == RK_AIQ_WORKING_MODE_NORMAL) {
278 hdr_mode = NO_HDR;
279 } else if (mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
280 mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
281 hdr_mode = HDR_X2;
282 } else if (mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
283 mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
284 hdr_mode = HDR_X3;
285 } else {
286 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "failed to set hdr mode to %d", mode);
287 return XCAM_RETURN_ERROR_FAILED;
288 }
289
290 _working_mode = mode;
291
292 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "%s _working_mode: %d\n",
293 __func__, _working_mode);
294
295 return XCAM_RETURN_NO_ERROR;
296 }
297
298 XCamReturn
set_mirror_flip(bool mirror,bool flip,int32_t & skip_frame_sequence)299 FakeSensorHw::set_mirror_flip(bool mirror, bool flip, int32_t& skip_frame_sequence)
300 {
301 return XCAM_RETURN_NO_ERROR;
302 }
303
304
305 XCamReturn
get_mirror_flip(bool & mirror,bool & flip)306 FakeSensorHw::get_mirror_flip(bool& mirror, bool& flip)
307 {
308 return XCAM_RETURN_NO_ERROR;
309 }
310
311 XCamReturn
set_exp_delay_info(int time_delay,int gain_delay,int hcg_lcg_mode_delay)312 FakeSensorHw::set_exp_delay_info(int time_delay, int gain_delay, int hcg_lcg_mode_delay)
313 {
314
315 return XCAM_RETURN_NO_ERROR;
316 }
317
318 XCamReturn
start(bool prepared)319 FakeSensorHw::start(bool prepared)
320 {
321 ENTER_CAMHW_FUNCTION();
322
323 V4l2SubDevice::start();
324
325 _timer->SetTimer(0, 100000);
326 _timer->StartTimer();
327
328 EXIT_CAMHW_FUNCTION();
329 return XCAM_RETURN_NO_ERROR;
330 }
331
332 XCamReturn
stop()333 FakeSensorHw::stop()
334 {
335 ENTER_CAMHW_FUNCTION();
336 _timer->StopTimer();
337 _vbuf_list.clear();
338 SensorHw::stop();
339 EXIT_CAMHW_FUNCTION();
340 return XCAM_RETURN_NO_ERROR;
341 }
342
343 XCamReturn
get_selection(int pad,uint32_t target,struct v4l2_subdev_selection & select)344 FakeSensorHw::get_selection (int pad, uint32_t target, struct v4l2_subdev_selection &select)
345 {
346 XCAM_ASSERT (is_opened());
347
348 return XCAM_RETURN_ERROR_IOCTL;
349 }
350
351 XCamReturn
getFormat(struct v4l2_subdev_format & aFormat)352 FakeSensorHw::getFormat(struct v4l2_subdev_format &aFormat)
353 {
354 int ret = 0;
355 ENTER_CAMHW_FUNCTION();
356 aFormat.format.width = _width;
357 aFormat.format.height = _height;
358 aFormat.format.code = _fmt_code;
359 aFormat.format.field = V4L2_FIELD_NONE;
360 aFormat.format.colorspace = V4L2_COLORSPACE_470_SYSTEM_M;
361 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "pad: %d, which: %d, width: %d, "
362 "height: %d, format: 0x%x, field: %d, color space: %d",
363 aFormat.pad,
364 aFormat.which,
365 aFormat.format.width,
366 aFormat.format.height,
367 aFormat.format.code,
368 aFormat.format.field,
369 aFormat.format.colorspace);
370 EXIT_CAMHW_FUNCTION();
371 return XCAM_RETURN_NO_ERROR;
372 }
373
374 XCamReturn
prepare(rk_aiq_raw_prop_t prop)375 FakeSensorHw::prepare(rk_aiq_raw_prop_t prop)
376 {
377 ENTER_CAMHW_FUNCTION();
378 _width = prop.frame_width;
379 _height = prop.frame_height;
380 _fmt_code = rk_format_to_media_format(prop.format);
381 _rawbuf_type = prop.rawbuf_type;
382 EXIT_CAMHW_FUNCTION();
383 return XCAM_RETURN_NO_ERROR;
384 }
385
386 XCamReturn
enqueue_rawbuffer(struct rk_aiq_vbuf * vbuf,bool sync)387 FakeSensorHw::enqueue_rawbuffer(struct rk_aiq_vbuf *vbuf, bool sync)
388 {
389 int max_count = 0;
390 SmartPtr<FakeV4l2Device> fake_v4l2_dev;
391 ENTER_CAMHW_FUNCTION();
392 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
393 max_count = 1;
394 } else if (_working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
395 _working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
396 max_count = 2;
397 } else if (_working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
398 _working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
399 max_count = 3;
400 }
401
402 if (_frame_sequence != uint32_t(-1) && vbuf->buf_info[0].frame_id != _frame_sequence + 1) {
403 LOGW_CAMHW_SUBM(FAKECAM_SUBM, "enqueue frame id(%u) isn't contiguous, change the id to %u",
404 vbuf->buf_info[0].frame_id, _frame_sequence + 1);
405 vbuf->buf_info[0].frame_id = ++_frame_sequence;
406 } else
407 _frame_sequence = vbuf->buf_info[0].frame_id;
408
409 vbuf->buf_info[1].frame_id = vbuf->buf_info[0].frame_id;
410 vbuf->buf_info[2].frame_id = vbuf->buf_info[0].frame_id;
411
412 for (int i = 0; i < max_count; i++) {
413 fake_v4l2_dev = _mipi_tx_dev[i].dynamic_cast_ptr<FakeV4l2Device>();
414 fake_v4l2_dev->enqueue_rawbuffer(&vbuf->buf_info[i]);
415 }
416 _mutex.lock();
417 _vbuf_list.push_back(*vbuf);
418
419 while (_effecting_exp_map.size() > 4)
420 _effecting_exp_map.erase(_effecting_exp_map.begin());
421
422 int fid = vbuf->buf_info[0].frame_id;
423 // check valid firstly
424 bool exp_val_valid = true;
425
426 #if 1
427 //check float exposure, not reg value
428 if (fabs(vbuf->buf_info[0].exp_time - 0.0f) < FLT_EPSILON || fabs(vbuf->buf_info[0].exp_gain - 0.0f) < FLT_EPSILON)
429 exp_val_valid = false;
430
431 if (exp_val_valid && (RK_AIQ_HDR_GET_WORKING_MODE(_working_mode) == RK_AIQ_WORKING_MODE_ISP_HDR2)) {
432 if (fabs(vbuf->buf_info[1].exp_time - 0.0f) < FLT_EPSILON || fabs(vbuf->buf_info[1].exp_gain - 0.0f) < FLT_EPSILON)
433 exp_val_valid = false;
434 }
435
436 if (exp_val_valid && (RK_AIQ_HDR_GET_WORKING_MODE(_working_mode) == RK_AIQ_WORKING_MODE_ISP_HDR3)) {
437 if (fabs(vbuf->buf_info[2].exp_time - 0.0f) < FLT_EPSILON || fabs(vbuf->buf_info[2].exp_gain - 0.0f) < FLT_EPSILON)
438 exp_val_valid = false;
439 }
440
441 #else
442 if ((vbuf->buf_info[0].exp_gain_reg) == 0)
443 exp_val_valid = false;
444
445 if (exp_val_valid && (RK_AIQ_HDR_GET_WORKING_MODE(_working_mode) == RK_AIQ_WORKING_MODE_ISP_HDR2)) {
446 if (vbuf->buf_info[1].exp_gain_reg == 0)
447 exp_val_valid = false;
448 }
449
450 if (exp_val_valid && (RK_AIQ_HDR_GET_WORKING_MODE(_working_mode) == RK_AIQ_WORKING_MODE_ISP_HDR3)) {
451 if (vbuf->buf_info[2].exp_gain_reg == 0)
452 exp_val_valid = false;
453 }
454 #endif
455
456 if (exp_val_valid) {
457 SmartPtr<RkAiqSensorExpParamsProxy> exp_param_prx = _expParamsPool->get_item();
458
459 exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global = vbuf->buf_info[0].exp_gain_reg;
460 exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time = vbuf->buf_info[0].exp_time_reg;
461 exp_param_prx->data()->aecExpInfo.LinearExp.exp_real_params.analog_gain = vbuf->buf_info[0].exp_gain;
462 exp_param_prx->data()->aecExpInfo.LinearExp.exp_real_params.integration_time = vbuf->buf_info[0].exp_time;
463 exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.digital_gain_global = 1;
464 exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.isp_digital_gain = 1;
465 exp_param_prx->data()->aecExpInfo.LinearExp.exp_real_params.digital_gain = 1.0f;
466 exp_param_prx->data()->aecExpInfo.LinearExp.exp_real_params.isp_dgain = 1.0f;
467
468 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global = vbuf->buf_info[2].exp_gain_reg;
469 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time = vbuf->buf_info[2].exp_time_reg;
470 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_real_params.analog_gain = vbuf->buf_info[2].exp_gain;
471 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_real_params.integration_time = vbuf->buf_info[2].exp_time;
472 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.digital_gain_global = 1;
473 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.isp_digital_gain = 1;
474 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_real_params.digital_gain = 1.0f;
475 exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_real_params.isp_dgain = 1.0f;
476
477 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global = vbuf->buf_info[1].exp_gain_reg;
478 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time = vbuf->buf_info[1].exp_time_reg;
479 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain = vbuf->buf_info[1].exp_gain;
480 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time = vbuf->buf_info[1].exp_time;
481 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.digital_gain_global = 1;
482 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.isp_digital_gain = 1;
483 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_real_params.digital_gain = 1.0f;
484 exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_real_params.isp_dgain = 1.0f;
485
486
487 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global = vbuf->buf_info[0].exp_gain_reg;
488 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time = vbuf->buf_info[0].exp_time_reg;
489 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain = vbuf->buf_info[0].exp_gain;
490 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time = vbuf->buf_info[0].exp_time;
491 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.digital_gain_global = 1;
492 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.isp_digital_gain = 1;
493 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_real_params.digital_gain = 1.0f;
494 exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_real_params.isp_dgain = 1.0f;
495
496 _effecting_exp_map[fid] = exp_param_prx;
497 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "add id[%d] to the effected exp map", fid);
498 } else {
499 LOGW_CAMHW_SUBM(FAKECAM_SUBM, "invalid expo info of fid %d", fid);
500 }
501 _mutex.unlock();
502 if (sync) {
503 _need_sync = sync;
504 if (_sync_cond.timedwait(_sync_mutex, 5000000) != 0) {
505 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "wait raw buffer process done timeout");
506 return XCAM_RETURN_ERROR_TIMEOUT;
507 }
508 }
509 EXIT_CAMHW_FUNCTION();
510 return XCAM_RETURN_NO_ERROR;
511 }
512
513 XCamReturn
register_rawdata_callback(void (* callback)(void *))514 FakeSensorHw::register_rawdata_callback(void (*callback)(void *))
515 {
516 ENTER_XCORE_FUNCTION();
517 XCamReturn ret = XCAM_RETURN_NO_ERROR;
518 pFunc = callback;
519 EXIT_XCORE_FUNCTION();
520 return ret;
521 }
522
523 XCamReturn
on_dqueue(int dev_idx,SmartPtr<V4l2BufferProxy> buf_proxy)524 FakeSensorHw::on_dqueue(int dev_idx, SmartPtr<V4l2BufferProxy> buf_proxy)
525 {
526 ENTER_XCORE_FUNCTION();
527 XCamReturn ret = XCAM_RETURN_NO_ERROR;
528 std::list<struct rk_aiq_vbuf>::iterator it;
529 SmartLock locker (_mutex);
530
531 if (!_vbuf_list.empty()) {
532 for(it = _vbuf_list.begin(); it != _vbuf_list.end(); it++) {
533 if (_rawbuf_type == RK_AIQ_RAW_DATA) {
534 uintptr_t ptr = buf_proxy->get_reserved();
535 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "rawbuf_type(data): %p vs 0x%x",it->buf_info[dev_idx].data_addr,ptr);
536 if (it->buf_info[dev_idx].data_addr == (uint8_t*)ptr) {
537 it->buf_info[dev_idx].valid = false;
538 break;
539 }
540 } else if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
541 uintptr_t ptr = buf_proxy->get_v4l2_userptr();
542 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "rawbuf_type(addr): %p vs 0x%x",it->buf_info[dev_idx].data_addr,ptr);
543 if (it->buf_info[dev_idx].data_addr == (uint8_t*)ptr) {
544 it->buf_info[dev_idx].valid = false;
545 break;
546 }
547 } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
548 uint32_t buf_fd = buf_proxy->get_expbuf_fd();
549 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "rawbuf_type(fd): %d vs %d",it->buf_info[dev_idx].data_fd,buf_fd);
550 if (it->buf_info[dev_idx].data_fd == buf_fd) {
551 it->buf_info[dev_idx].valid = false;
552 break;
553 }
554 } else if (_rawbuf_type == RK_AIQ_RAW_FILE) {
555 uintptr_t ptr = buf_proxy->get_v4l2_userptr();
556 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "rawbuf_type(file): %p vs 0x%x",it->buf_info[dev_idx].data_addr,ptr);
557 if (it->buf_info[dev_idx].data_addr == (uint8_t*)ptr) {
558 it->buf_info[dev_idx].valid = false;
559 break;
560 }
561 } else {
562 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "raw buf type is wrong:0x%x",_rawbuf_type);
563 return XCAM_RETURN_ERROR_FAILED;
564 }
565
566 }
567 if (it != _vbuf_list.end()) {
568 switch (_working_mode)
569 {
570 case RK_AIQ_WORKING_MODE_NORMAL:
571 if (!it->buf_info[0].valid) {
572 goto out;
573 }
574 break;
575 case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
576 case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
577 if (!it->buf_info[0].valid && !it->buf_info[1].valid) {
578 goto out;
579 }
580 break;
581 case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
582 case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
583 if (!it->buf_info[0].valid && !it->buf_info[1].valid && !it->buf_info[2].valid) {
584 goto out;
585 }
586 break;
587 }
588 }
589 }
590 EXIT_XCORE_FUNCTION();
591 return ret;
592 out:
593 _vbuf_list.erase(it);
594
595 if (_need_sync) {
596 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "give off signal");
597 _sync_cond.signal();
598 }else {
599 if (pFunc)
600 pFunc(it->base_addr);
601 }
602 EXIT_XCORE_FUNCTION();
603 return ret;
604 }
605
606 XCamReturn
set_mipi_tx_devs(SmartPtr<V4l2Device> mipi_tx_devs[3])607 FakeSensorHw::set_mipi_tx_devs(SmartPtr<V4l2Device> mipi_tx_devs[3])
608 {
609 _mipi_tx_dev[0] = mipi_tx_devs[0];
610 _mipi_tx_dev[1] = mipi_tx_devs[1];
611 _mipi_tx_dev[2] = mipi_tx_devs[2];
612 return XCAM_RETURN_NO_ERROR;
613 }
614
CTimer(FakeSensorHw * dev)615 CTimer::CTimer(FakeSensorHw *dev):
616 m_second(0), m_microsecond(0)
617 {
618 _dev = dev;
619 }
620
~CTimer()621 CTimer::~CTimer()
622 {
623 }
624
SetTimer(long second,long microsecond)625 void CTimer::SetTimer(long second, long microsecond)
626 {
627 m_second = second;
628 m_microsecond = microsecond;
629 }
630
StartTimer()631 void CTimer::StartTimer()
632 {
633 pthread_create(&thread_timer, NULL, OnTimer_stub, this);
634 }
635
StopTimer()636 void CTimer::StopTimer()
637 {
638 #ifndef __ANDROID__
639 pthread_cancel(thread_timer);
640 #endif
641 pthread_join(thread_timer, NULL);
642 }
643
thread_proc()644 void CTimer::thread_proc()
645 {
646 while (true)
647 {
648 OnTimer();
649 #ifndef __ANDROID__
650 pthread_testcancel();
651 #endif
652 struct timeval tempval;
653 tempval.tv_sec = m_second;
654 tempval.tv_usec = m_microsecond;
655 select(0, NULL, NULL, NULL, &tempval);
656 }
657 }
658
OnTimer()659 void CTimer::OnTimer()
660 {
661 SmartPtr<FakeV4l2Device> fake_v4l2_dev;
662 ENTER_CAMHW_FUNCTION();
663 if (_dev->_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
664 fake_v4l2_dev = _dev->_mipi_tx_dev[0].dynamic_cast_ptr<FakeV4l2Device>();
665 fake_v4l2_dev->on_timer_proc();
666 } else if (_dev->_working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
667 _dev->_working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
668 fake_v4l2_dev = _dev->_mipi_tx_dev[0].dynamic_cast_ptr<FakeV4l2Device>();
669 fake_v4l2_dev->on_timer_proc();
670 fake_v4l2_dev = _dev->_mipi_tx_dev[1].dynamic_cast_ptr<FakeV4l2Device>();
671 fake_v4l2_dev->on_timer_proc();
672 } else if (_dev->_working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
673 _dev->_working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
674 fake_v4l2_dev = _dev->_mipi_tx_dev[0].dynamic_cast_ptr<FakeV4l2Device>();
675 fake_v4l2_dev->on_timer_proc();
676 fake_v4l2_dev = _dev->_mipi_tx_dev[1].dynamic_cast_ptr<FakeV4l2Device>();
677 fake_v4l2_dev->on_timer_proc();
678 fake_v4l2_dev = _dev->_mipi_tx_dev[2].dynamic_cast_ptr<FakeV4l2Device>();
679 fake_v4l2_dev->on_timer_proc();
680
681 }
682 EXIT_XCORE_FUNCTION();
683 }
684
685 }; //namespace RkCam
686