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 "FakeCamHwIsp20.h"
19 #include "Isp20Evts.h"
20 #include "FakeSensorHw.h"
21 #include "rk_isp20_hw.h"
22 #include "Isp20_module_dbg.h"
23 #include "mediactl/mediactl-priv.h"
24 #include <linux/v4l2-subdev.h>
25 #include <sys/mman.h>
26 #include <sys/stat.h>
27
28 namespace RkCam {
FakeCamHwIsp20()29 FakeCamHwIsp20::FakeCamHwIsp20() : isp_index(0)
30 {
31 ENTER_CAMHW_FUNCTION();
32 _rx_memory_type = V4L2_MEMORY_DMABUF;
33 _tx_memory_type = V4L2_MEMORY_DMABUF;
34 mNoReadBack = false;
35 EXIT_CAMHW_FUNCTION();
36 }
37
~FakeCamHwIsp20()38 FakeCamHwIsp20::~FakeCamHwIsp20()
39 {
40 ENTER_CAMHW_FUNCTION();
41 setupOffLineLink(isp_index, false);
42 EXIT_CAMHW_FUNCTION();
43 }
44
45 XCamReturn
init(const char * sns_ent_name)46 FakeCamHwIsp20::init(const char* sns_ent_name)
47 {
48 XCamReturn ret = XCAM_RETURN_NO_ERROR;
49
50 ret = CamHwIsp20::init(sns_ent_name);
51 if (ret)
52 return ret;
53
54 // special for fake sensor
55 SmartPtr<BaseSensorHw> sensorHw;
56 mSensorDev->close();
57 sensorHw = new FakeSensorHw();
58 mSensorDev = sensorHw;
59 mSensorDev->open();
60 mIspStatsStream->set_event_handle_dev(sensorHw);
61
62 return XCAM_RETURN_NO_ERROR;
63 }
64
65 XCamReturn
prepare(uint32_t width,uint32_t height,int mode,int t_delay,int g_delay)66 FakeCamHwIsp20::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
67 {
68 XCamReturn ret = XCAM_RETURN_NO_ERROR;
69 SmartPtr<BaseSensorHw> sensorHw;
70
71 ENTER_CAMHW_FUNCTION();
72
73 SmartPtr<FakeSensorHw> fakeSensorHw = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
74
75 std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
76 if ((it = mSensorHwInfos.find(sns_name)) == mSensorHwInfos.end()) {
77 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_name);
78 return XCAM_RETURN_ERROR_SENSOR;
79 }
80
81 rk_sensor_full_info_t *s_info = it->second.ptr();
82 isp_index = s_info->isp_info->logic_id;
83 #ifndef USE_RAWSTREAM_LIB
84 setupOffLineLink(isp_index, true);
85 #endif
86 init_mipi_devices(s_info);
87 fakeSensorHw->set_mipi_tx_devs(_mipi_tx_devs);
88
89 #ifndef USE_RAWSTREAM_LIB
90 mRawCapUnit->set_tx_devices(_mipi_tx_devs);
91 mRawProcUnit->set_rx_devices(_mipi_rx_devs);
92 mRawProcUnit->setPollCallback(this);
93 #endif
94 ret = CamHwIsp20::prepare(width, height, mode, t_delay, g_delay);
95 if (ret)
96 return ret;
97
98 if (mIspSofStream.ptr())
99 mIspSofStream->setPollCallback (NULL);
100
101 EXIT_CAMHW_FUNCTION();
102 return ret;
103 }
104
105 XCamReturn
poll_buffer_ready(SmartPtr<V4l2BufferProxy> & buf,int dev_index)106 FakeCamHwIsp20::poll_buffer_ready (SmartPtr<V4l2BufferProxy> &buf, int dev_index)
107 {
108 SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
109 // notify fakesensor one frame has been processed by ISP
110 return fakeSensor->on_dqueue(dev_index, buf);
111 }
112
113 XCamReturn
init_mipi_devices(rk_sensor_full_info_t * s_info)114 FakeCamHwIsp20::init_mipi_devices(rk_sensor_full_info_t *s_info)
115 {
116 /*
117 * for _mipi_tx_devs, index 0 refer to short frame always, inedex 1 refer
118 * to middle frame always, index 2 refert to long frame always.
119 * for CIF usecase, because mipi_id0 refert to long frame always, so we
120 * should know the HDR mode firstly befor building the relationship between
121 * _mipi_tx_devs array and mipi_idx. here we just set the mipi_idx to
122 * _mipi_tx_devs, we will build the real relation in start.
123 * for CIF usecase, rawwr2_path is always connected to _mipi_tx_devs[0],
124 * rawwr0_path is always connected to _mipi_tx_devs[1], and rawwr1_path is always
125 * connected to _mipi_tx_devs[0]
126 */
127 //short frame
128 _mipi_tx_devs[0] = new FakeV4l2Device ();
129 _mipi_tx_devs[0]->open();
130 _mipi_tx_devs[0]->set_mem_type(_tx_memory_type);
131 _mipi_tx_devs[0]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
132
133 _mipi_rx_devs[0] = new V4l2Device (s_info->isp_info->rawrd2_s_path);//rkisp_rawrd2_s
134 _mipi_rx_devs[0]->open();
135 _mipi_rx_devs[0]->set_mem_type(_rx_memory_type);
136 //mid frame
137 _mipi_tx_devs[1] = new FakeV4l2Device ();
138 _mipi_tx_devs[1]->open();
139 _mipi_tx_devs[1]->set_mem_type(_tx_memory_type);
140 _mipi_tx_devs[1]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
141
142 _mipi_rx_devs[1] = new V4l2Device (s_info->isp_info->rawrd0_m_path);//rkisp_rawrd0_m
143 _mipi_rx_devs[1]->open();
144 _mipi_rx_devs[1]->set_mem_type(_rx_memory_type);
145 //long frame
146 _mipi_tx_devs[2] = new FakeV4l2Device ();
147 _mipi_tx_devs[2]->open();
148 _mipi_tx_devs[2]->set_mem_type(_tx_memory_type);
149 _mipi_tx_devs[2]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
150
151 _mipi_rx_devs[2] = new V4l2Device (s_info->isp_info->rawrd1_l_path);//rkisp_rawrd1_l
152 _mipi_rx_devs[2]->open();
153 _mipi_rx_devs[2]->set_mem_type(_rx_memory_type);
154 for (int i = 0; i < 3; i++) {
155 if (_linked_to_isp) {
156 if (_rawbuf_type == RK_AIQ_RAW_FILE) {
157 _mipi_tx_devs[0]->set_use_type(2);
158 _mipi_tx_devs[i]->set_buffer_count(1);
159 _mipi_rx_devs[i]->set_buffer_count(1);
160 } else if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
161 _mipi_tx_devs[0]->set_use_type(1);
162 _mipi_tx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
163 _mipi_rx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
164 } else {
165 _mipi_tx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
166 _mipi_rx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
167 }
168 } else {
169 _mipi_tx_devs[i]->set_buffer_count(VIPCAP_TX_BUF_NUM);
170 _mipi_rx_devs[i]->set_buffer_count(VIPCAP_TX_BUF_NUM);
171 }
172 SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
173 rk_aiq_exposure_sensor_descriptor sns_des;
174 fakeSensor->get_sensor_desc(&sns_des);
175 _mipi_tx_devs[i]->set_format(sns_des.sensor_output_width,
176 sns_des.sensor_output_height,
177 sns_des.sensor_pixelformat);
178 _mipi_rx_devs[i]->set_format(sns_des.sensor_output_width,
179 sns_des.sensor_output_height,
180 sns_des.sensor_pixelformat);
181 }
182 return XCAM_RETURN_NO_ERROR;
183 }
184
185 XCamReturn
poll_event_ready(uint32_t sequence,int type)186 FakeCamHwIsp20::poll_event_ready (uint32_t sequence, int type)
187 {
188 struct v4l2_event event;
189 event.u.frame_sync.frame_sequence = sequence;
190
191 mIspSofStream->stop();
192 SmartPtr<VideoBuffer> buf =
193 mIspSofStream->new_video_buffer(event, NULL);
194
195 CamHwBase::poll_buffer_ready(buf);
196
197 return XCAM_RETURN_NO_ERROR;
198 }
199
200 XCamReturn
enqueueRawBuffer(void * rawdata,bool sync)201 FakeCamHwIsp20::enqueueRawBuffer(void *rawdata, bool sync)
202 {
203 ENTER_XCORE_FUNCTION();
204 XCamReturn ret = XCAM_RETURN_NO_ERROR;
205 struct rk_aiq_vbuf vbuf;
206 memset(&vbuf, 0, sizeof(vbuf));
207 parse_rk_rawdata(rawdata, &vbuf);
208 SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
209 fakeSensor->enqueue_rawbuffer(&vbuf, sync);
210 poll_event_ready(vbuf.buf_info[0].frame_id, V4L2_EVENT_FRAME_SYNC);
211 EXIT_XCORE_FUNCTION();
212 return ret;
213 }
214
215 XCamReturn
enqueueRawFile(const char * path)216 FakeCamHwIsp20::enqueueRawFile(const char *path)
217 {
218 ENTER_XCORE_FUNCTION();
219 XCamReturn ret = XCAM_RETURN_NO_ERROR;
220 struct rk_aiq_vbuf vbuf;
221 memset(&vbuf, 0, sizeof(vbuf));
222 if (0 != access(path, F_OK)) {
223 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "file: %s is not exist!", path);
224 return XCAM_RETURN_ERROR_PARAM;
225 }
226
227 FILE *fp = fopen(path, "rb");
228 if (!fp) {
229 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "open file: %s failed", path);
230 return XCAM_RETURN_ERROR_FAILED;
231 }
232
233 ret = parse_rk_rawfile(fp, &vbuf);
234 if (ret != XCAM_RETURN_NO_ERROR) {
235 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "Failed to parse rk rawfile!");
236 fclose(fp);
237 return ret;
238 }
239 fclose(fp);
240 SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
241 fakeSensor->enqueue_rawbuffer(&vbuf, true);
242 poll_event_ready(vbuf.buf_info[0].frame_id, V4L2_EVENT_FRAME_SYNC);
243 EXIT_XCORE_FUNCTION();
244 return ret;
245 }
246
247 void
parse_rk_rawdata(void * rawdata,struct rk_aiq_vbuf * vbuf)248 FakeCamHwIsp20::parse_rk_rawdata(void *rawdata, struct rk_aiq_vbuf *vbuf)
249 {
250 unsigned short tag = 0;
251 struct _block_header header;
252 uint8_t *p = (uint8_t *)rawdata;
253 uint8_t *actual_raw[3] = {NULL, NULL, NULL};
254 int actual_raw_len[3] = {0, 0, 0};
255 bool is_actual_rawdata = false;
256 bool bExit = false;
257 while(!bExit){
258 tag = *((unsigned short*)p);
259 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "tag=0x%04x\n",tag);
260 switch (tag)
261 {
262 case START_TAG:
263 p = p+TAG_BYTE_LEN;
264 memset(_st_addr, 0, sizeof(_st_addr));
265 memset(&_rawfmt, 0, sizeof(_rawfmt));
266 memset(&_finfo, 0, sizeof(_finfo));
267 break;
268 case NORMAL_RAW_TAG:
269 {
270 header = *((struct _block_header *)p);
271 p = p + sizeof(struct _block_header);
272 if (header.block_length == sizeof(struct _st_addrinfo)) {
273 _st_addr[0] = *((struct _st_addrinfo*)p);
274 }else{
275 //actual raw data
276 is_actual_rawdata = true;
277 actual_raw[0] = p;
278 actual_raw_len[0] = header.block_length;
279 }
280 p = p + header.block_length;
281
282 break;
283 }
284 case HDR_S_RAW_TAG:
285 {
286 header = *((struct _block_header *)p);
287 p = p + sizeof(struct _block_header);
288 if (header.block_length == sizeof(struct _st_addrinfo)) {
289 _st_addr[0] = *((struct _st_addrinfo*)p);
290 }else{
291 //actual raw data
292 is_actual_rawdata = true;
293 actual_raw[0] = p;
294 actual_raw_len[0] = header.block_length;
295 }
296 p = p + header.block_length;
297 break;
298 }
299 case HDR_M_RAW_TAG:
300 {
301 header = *((struct _block_header *)p);
302 p = p + sizeof(struct _block_header);
303 if (header.block_length == sizeof(struct _st_addrinfo)) {
304 _st_addr[1] = *((struct _st_addrinfo*)p);
305 }else{
306 //actual raw data
307 is_actual_rawdata = true;
308 actual_raw[1] = p;
309 actual_raw_len[1] = header.block_length;
310 }
311 p = p + header.block_length;
312 break;
313 }
314 case HDR_L_RAW_TAG:
315 {
316 header = *((struct _block_header *)p);
317 p = p + sizeof(struct _block_header);
318 if (header.block_length == sizeof(struct _st_addrinfo)) {
319 _st_addr[2] = *((struct _st_addrinfo*)p);
320 }else{
321 //actual raw data
322 is_actual_rawdata = true;
323 actual_raw[2] = p;
324 actual_raw_len[2] = header.block_length;
325 }
326 p = p + header.block_length;
327 break;
328 }
329 case FORMAT_TAG:
330 {
331 _rawfmt = *((struct _raw_format *)p);
332 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "hdr_mode=%d,bayer_fmt=%d\n",_rawfmt.hdr_mode,_rawfmt.bayer_fmt);
333 p = p + sizeof(struct _block_header) + _rawfmt.size;
334 break;
335 }
336 case STATS_TAG:
337 {
338 _finfo = *((rk_aiq_frame_info_t *)p);
339 p = p + sizeof(struct _block_header) + _finfo.size;
340 break;
341 }
342 case ISP_REG_FMT_TAG:
343 {
344 header = *((struct _block_header *)p);
345 p += sizeof(struct _block_header);
346 p = p + header.block_length;
347 break;
348 }
349 case ISP_REG_TAG:
350 {
351 header = *((struct _block_header *)p);
352 p += sizeof(struct _block_header);
353 p = p + header.block_length;
354 break;
355 }
356 case ISPP_REG_FMT_TAG:
357 {
358 header = *((struct _block_header *)p);
359 p += sizeof(struct _block_header);
360 p = p + header.block_length;
361 break;
362 }
363 case ISPP_REG_TAG:
364 {
365 header = *((struct _block_header *)p);
366 p += sizeof(struct _block_header);
367 p = p + header.block_length;
368 break;
369 }
370 case PLATFORM_TAG:
371 {
372 header = *((struct _block_header *)p);
373 p += sizeof(struct _block_header);
374 p = p + header.block_length;
375 break;
376 }
377 case END_TAG:
378 {
379 bExit = true;
380 break;
381 }
382 default:
383 {
384 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "Not support TAG(0x%04x)\n", tag);
385 bExit = true;
386 break;
387 }
388 }
389 }
390
391 vbuf->frame_width = _rawfmt.width;
392 vbuf->frame_height = _rawfmt.height;
393 vbuf->base_addr = rawdata;
394 if (_rawfmt.hdr_mode == 1) {
395 if (is_actual_rawdata) {
396 vbuf->buf_info[0].data_addr = actual_raw[0];
397 vbuf->buf_info[0].data_fd = 0;
398 vbuf->buf_info[0].data_length = actual_raw_len[0];
399 } else {
400 if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
401 if (sizeof(uint8_t*) == 4) {
402 vbuf->buf_info[0].data_addr = (uint8_t*)(long)(_st_addr[0].laddr);
403 } else if (sizeof(uint8_t*) == 8) {
404 vbuf->buf_info[0].data_addr =
405 (uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);
406 }
407
408 vbuf->buf_info[0].data_fd = 0;
409 } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
410 vbuf->buf_info[0].data_fd = _st_addr[0].fd;
411 vbuf->buf_info[0].data_addr = NULL;
412 }
413 vbuf->buf_info[0].data_length = _st_addr[0].size;
414 }
415 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr=%p,fd=%d,length=%d\n",
416 vbuf->buf_info[0].data_addr,
417 vbuf->buf_info[0].data_fd,
418 vbuf->buf_info[0].data_length);
419
420 vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
421 vbuf->buf_info[0].exp_gain = (float)_finfo.normal_gain;
422 vbuf->buf_info[0].exp_time = (float)_finfo.normal_exp;
423 vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.normal_gain_reg;
424 vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.normal_exp_reg;
425 vbuf->buf_info[0].valid = true;
426 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
427 vbuf->buf_info[0].exp_gain,
428 vbuf->buf_info[0].exp_time,
429 vbuf->buf_info[0].exp_gain_reg,
430 vbuf->buf_info[0].exp_time_reg);
431 } else if (_rawfmt.hdr_mode == 2) {
432 if (is_actual_rawdata) {
433 vbuf->buf_info[0].data_addr = actual_raw[0];
434 vbuf->buf_info[0].data_fd = 0;
435 vbuf->buf_info[0].data_length = actual_raw_len[0];
436 } else {
437 if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
438 if (sizeof(uint8_t*) == 4) {
439 vbuf->buf_info[0].data_addr = (uint8_t*)(long)(_st_addr[0].laddr);
440 } else if (sizeof(uint8_t*) == 8) {
441 vbuf->buf_info[0].data_addr =
442 (uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);
443 }
444 vbuf->buf_info[0].data_fd = 0;
445 } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
446 vbuf->buf_info[0].data_addr = NULL;
447 vbuf->buf_info[0].data_fd = _st_addr[0].fd;
448 }
449 vbuf->buf_info[0].data_length = _st_addr[0].size;
450 }
451 vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
452 vbuf->buf_info[0].exp_gain = (float)_finfo.hdr_gain_s;
453 vbuf->buf_info[0].exp_time = (float)_finfo.hdr_exp_s;
454 vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.hdr_gain_s_reg;
455 vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.hdr_exp_s_reg;
456 vbuf->buf_info[0].valid = true;
457 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: data_addr=%p,fd=%d,,length=%d\n",
458 vbuf->buf_info[0].data_addr,
459 vbuf->buf_info[0].data_fd,
460 vbuf->buf_info[0].data_length);
461 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
462 vbuf->buf_info[0].exp_gain,
463 vbuf->buf_info[0].exp_time,
464 vbuf->buf_info[0].exp_gain_reg,
465 vbuf->buf_info[0].exp_time_reg);
466 if (is_actual_rawdata) {
467 vbuf->buf_info[1].data_addr = actual_raw[1];//actual_raw[1]
468 vbuf->buf_info[1].data_fd = 0;
469 vbuf->buf_info[1].data_length = actual_raw_len[1];//actual_raw_len[1]
470 } else {
471 if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
472 if (sizeof(uint8_t*) == 4) {
473 vbuf->buf_info[1].data_addr = (uint8_t*)(long)(_st_addr[1].laddr);
474 } else if (sizeof(uint8_t*) == 8) {
475 vbuf->buf_info[1].data_addr =
476 (uint8_t*)(((uint64_t)_st_addr[1].haddr << 32) + _st_addr[1].laddr);
477 }
478 vbuf->buf_info[1].data_fd = 0;
479 } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
480 vbuf->buf_info[1].data_addr = NULL;
481 vbuf->buf_info[1].data_fd = _st_addr[1].fd;
482 }
483 vbuf->buf_info[1].data_length = _st_addr[1].size;
484 }
485 vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
486 vbuf->buf_info[1].exp_gain = (float)_finfo.hdr_gain_m;
487 vbuf->buf_info[1].exp_time = (float)_finfo.hdr_exp_m;
488 vbuf->buf_info[1].exp_gain_reg = (uint32_t)_finfo.hdr_gain_m_reg;
489 vbuf->buf_info[1].exp_time_reg = (uint32_t)_finfo.hdr_exp_m_reg;
490 vbuf->buf_info[1].valid = true;
491 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: data_addr=%p,fd=%d,,length=%d\n",
492 vbuf->buf_info[1].data_addr,
493 vbuf->buf_info[1].data_fd,
494 vbuf->buf_info[1].data_length);
495 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
496 vbuf->buf_info[1].exp_gain,
497 vbuf->buf_info[1].exp_time,
498 vbuf->buf_info[1].exp_gain_reg,
499 vbuf->buf_info[1].exp_time_reg);
500 } else if (_rawfmt.hdr_mode == 3) {
501 if (is_actual_rawdata) {
502 vbuf->buf_info[0].data_addr = actual_raw[0];
503 vbuf->buf_info[0].data_fd = 0;
504 vbuf->buf_info[0].data_length = actual_raw_len[0];
505 } else {
506 if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
507 if (sizeof(uint8_t*) == 4) {
508 vbuf->buf_info[0].data_addr = (uint8_t*)(long)(_st_addr[0].laddr);
509 } else if (sizeof(uint8_t*) == 8) {
510 vbuf->buf_info[0].data_addr =
511 (uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);
512 }
513 vbuf->buf_info[0].data_fd = 0;
514 } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
515 vbuf->buf_info[0].data_addr = NULL;
516 vbuf->buf_info[0].data_fd = _st_addr[0].fd;
517 }
518 vbuf->buf_info[0].data_length = _st_addr[0].size;
519 }
520 vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
521 vbuf->buf_info[0].exp_gain = (float)_finfo.hdr_gain_s;
522 vbuf->buf_info[0].exp_time = (float)_finfo.hdr_exp_s;
523 vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.hdr_gain_s_reg;
524 vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.hdr_exp_s_reg;
525 vbuf->buf_info[0].valid = true;
526 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: data_addr=%p,fd=%d,,length=%d\n",
527 vbuf->buf_info[0].data_addr,
528 vbuf->buf_info[0].data_fd,
529 vbuf->buf_info[0].data_length);
530 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
531 vbuf->buf_info[0].exp_gain,
532 vbuf->buf_info[0].exp_time,
533 vbuf->buf_info[0].exp_gain_reg,
534 vbuf->buf_info[0].exp_time_reg);
535
536 if (is_actual_rawdata) {
537 vbuf->buf_info[1].data_addr = actual_raw[1];
538 vbuf->buf_info[1].data_fd = 0;
539 vbuf->buf_info[1].data_length = actual_raw_len[1];
540 } else {
541 if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
542 if (sizeof(uint8_t*) == 4) {
543 vbuf->buf_info[1].data_addr = (uint8_t*)(long)(_st_addr[1].laddr);
544 } else if (sizeof(uint8_t*) == 8) {
545 vbuf->buf_info[1].data_addr =
546 (uint8_t*)(((uint64_t)_st_addr[1].haddr << 32) + _st_addr[1].laddr);
547 }
548 vbuf->buf_info[1].data_fd = 0;
549 } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
550 vbuf->buf_info[1].data_addr = NULL;
551 vbuf->buf_info[1].data_fd = _st_addr[1].fd;
552 }
553 vbuf->buf_info[1].data_length = _st_addr[1].size;
554 }
555 vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
556 vbuf->buf_info[1].exp_gain = (float)_finfo.hdr_gain_m;
557 vbuf->buf_info[1].exp_time = (float)_finfo.hdr_exp_m;
558 vbuf->buf_info[1].exp_gain_reg = (uint32_t)_finfo.hdr_gain_m_reg;
559 vbuf->buf_info[1].exp_time_reg = (uint32_t)_finfo.hdr_exp_m_reg;
560 vbuf->buf_info[1].valid = true;
561 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: data_addr=%p,fd=%d,,length=%d\n",
562 vbuf->buf_info[1].data_addr,
563 vbuf->buf_info[1].data_fd,
564 vbuf->buf_info[1].data_length);
565 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
566 vbuf->buf_info[1].exp_gain,
567 vbuf->buf_info[1].exp_time,
568 vbuf->buf_info[1].exp_gain_reg,
569 vbuf->buf_info[1].exp_time_reg);
570
571 if (is_actual_rawdata) {
572 vbuf->buf_info[2].data_addr = actual_raw[2];
573 vbuf->buf_info[2].data_fd = 0;
574 vbuf->buf_info[2].data_length = actual_raw_len[2];
575 } else {
576 if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
577 if (sizeof(uint8_t*) == 4) {
578 vbuf->buf_info[2].data_addr = (uint8_t*)(long)(_st_addr[2].laddr);
579 } else if (sizeof(uint8_t*) == 8) {
580 vbuf->buf_info[2].data_addr =
581 (uint8_t*)(((uint64_t)_st_addr[2].haddr << 32) + _st_addr[2].laddr);
582 }
583 vbuf->buf_info[2].data_fd = 0;
584 } else if (_rawbuf_type == RK_AIQ_RAW_FD) {
585 vbuf->buf_info[2].data_addr = NULL;
586 vbuf->buf_info[2].data_fd = _st_addr[2].fd;
587 }
588 vbuf->buf_info[2].data_length = _st_addr[2].size;
589 }
590 vbuf->buf_info[2].frame_id = _rawfmt.frame_id;
591 vbuf->buf_info[2].exp_gain = (float)_finfo.hdr_gain_l;
592 vbuf->buf_info[2].exp_time = (float)_finfo.hdr_exp_l;
593 vbuf->buf_info[2].exp_gain_reg = (uint32_t)_finfo.hdr_gain_l_reg;
594 vbuf->buf_info[2].exp_time_reg = (uint32_t)_finfo.hdr_exp_l_reg;
595 vbuf->buf_info[2].valid = true;
596 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[2]: data_addr=%p,fd=%d,,length=%d\n",
597 vbuf->buf_info[2].data_addr,
598 vbuf->buf_info[2].data_fd,
599 vbuf->buf_info[2].data_length);
600 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[2]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
601 vbuf->buf_info[2].exp_gain,
602 vbuf->buf_info[2].exp_time,
603 vbuf->buf_info[2].exp_gain_reg,
604 vbuf->buf_info[2].exp_time_reg);
605 }
606
607 }
608
609 XCamReturn
parse_rk_rawfile(FILE * fp,struct rk_aiq_vbuf * vbuf)610 FakeCamHwIsp20::parse_rk_rawfile(FILE *fp, struct rk_aiq_vbuf *vbuf)
611 {
612 unsigned short tag = 0;
613 struct _block_header header;
614 bool bExit = false;
615
616 if (!_mipi_rx_devs[0]->is_activated()) {
617 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "device(%s) hasn't activated(%d) yet!!!\n",
618 XCAM_STR (_mipi_rx_devs[0]->get_device_name()),
619 _mipi_rx_devs[0]->is_activated());
620 return XCAM_RETURN_ERROR_FAILED;
621 }
622
623 while(!bExit){
624 int ret = fread(&tag, sizeof(tag), 1, fp);
625 if (ret == 0)
626 break;
627 fseek(fp, TAG_BYTE_LEN*(-1), SEEK_CUR);//backforwad to tag start
628 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "tag=0x%04x\n",tag);
629 switch (tag)
630 {
631 case START_TAG:
632 fseek(fp, TAG_BYTE_LEN, SEEK_CUR);
633 memset(_st_addr, 0, sizeof(_st_addr));
634 memset(&_rawfmt, 0, sizeof(_rawfmt));
635 memset(&_finfo, 0, sizeof(_finfo));
636 break;
637 case NORMAL_RAW_TAG:
638 {
639 fread(&header, sizeof(header), 1, fp);
640 if (header.block_length > 0) {
641 vbuf->buf_info[0].data_addr = (uint8_t*)_mipi_rx_devs[0]->get_buffer_by_index(0)->get_expbuf_usrptr();
642 fread(vbuf->buf_info[0].data_addr, header.block_length, 1, fp);
643 vbuf->buf_info[0].data_length = header.block_length;
644 }
645 break;
646 }
647 case HDR_S_RAW_TAG:
648 {
649 fread(&header, sizeof(header), 1, fp);
650 if (header.block_length > 0) {
651 vbuf->buf_info[0].data_addr = (uint8_t*)_mipi_rx_devs[0]->get_buffer_by_index(0)->get_expbuf_usrptr();
652 fread(vbuf->buf_info[0].data_addr, header.block_length, 1, fp);
653 vbuf->buf_info[0].data_length = header.block_length;
654 }
655 break;
656 }
657 case HDR_M_RAW_TAG:
658 {
659 fread(&header, sizeof(header), 1, fp);
660 if (header.block_length > 0) {
661 vbuf->buf_info[1].data_addr = (uint8_t*)_mipi_rx_devs[1]->get_buffer_by_index(0)->get_expbuf_usrptr();
662 fread(vbuf->buf_info[1].data_addr, header.block_length, 1, fp);
663 vbuf->buf_info[1].data_length = header.block_length;
664 }
665 break;
666 }
667 case HDR_L_RAW_TAG:
668 {
669 fread(&header, sizeof(header), 1, fp);
670 if (header.block_length > 0) {
671 vbuf->buf_info[2].data_addr = (uint8_t*)_mipi_rx_devs[1]->get_buffer_by_index(0)->get_expbuf_usrptr();
672 fread(vbuf->buf_info[2].data_addr, header.block_length, 1, fp);
673 vbuf->buf_info[2].data_length = header.block_length;
674 }
675 break;
676 }
677 case FORMAT_TAG:
678 {
679 fread(&_rawfmt, sizeof(_rawfmt), 1, fp);
680 LOGD_CAMHW_SUBM(FAKECAM_SUBM, "hdr_mode=%d,bayer_fmt=%d\n",_rawfmt.hdr_mode,_rawfmt.bayer_fmt);
681 break;
682 }
683 case STATS_TAG:
684 {
685 fread(&_finfo, sizeof(_finfo), 1, fp);
686 break;
687 }
688 case ISP_REG_FMT_TAG:
689 {
690 fread(&header, sizeof(header), 1, fp);
691 fseek(fp, header.block_length, SEEK_CUR);
692 break;
693 }
694 case ISP_REG_TAG:
695 {
696 fread(&header, sizeof(header), 1, fp);
697 fseek(fp, header.block_length, SEEK_CUR);
698 break;
699 }
700 case ISPP_REG_FMT_TAG:
701 {
702 fread(&header, sizeof(header), 1, fp);
703 fseek(fp, header.block_length, SEEK_CUR);
704 break;
705 }
706 case ISPP_REG_TAG:
707 {
708 fread(&header, sizeof(header), 1, fp);
709 fseek(fp, header.block_length, SEEK_CUR);
710 break;
711 }
712 case PLATFORM_TAG:
713 {
714 fread(&header, sizeof(header), 1, fp);
715 fseek(fp, header.block_length, SEEK_CUR);
716 break;
717 }
718 case END_TAG:
719 {
720 bExit = true;
721 break;
722 }
723 default:
724 {
725 LOGE_CAMHW_SUBM(FAKECAM_SUBM, "Not support TAG(0x%04x)\n", tag);
726 bExit = true;
727 break;
728 }
729 }
730 }
731
732 vbuf->frame_width = _rawfmt.width;
733 vbuf->frame_height = _rawfmt.height;
734 if (_rawfmt.hdr_mode == 1) {
735 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr=%p,fd=%d,length=%d\n",
736 vbuf->buf_info[0].data_addr,
737 vbuf->buf_info[0].data_fd,
738 vbuf->buf_info[0].data_length);
739
740 vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
741 vbuf->buf_info[0].exp_gain = (float)_finfo.normal_gain;
742 vbuf->buf_info[0].exp_time = (float)_finfo.normal_exp;
743 vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.normal_gain_reg;
744 vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.normal_exp_reg;
745 vbuf->buf_info[0].valid = true;
746 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
747 vbuf->buf_info[0].exp_gain,
748 vbuf->buf_info[0].exp_time,
749 vbuf->buf_info[0].exp_gain_reg,
750 vbuf->buf_info[0].exp_time_reg);
751 }else if (_rawfmt.hdr_mode == 2) {
752 vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
753 vbuf->buf_info[0].exp_gain = (float)_finfo.normal_gain;
754 vbuf->buf_info[0].exp_time = (float)_finfo.normal_exp;
755 vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.normal_gain_reg;
756 vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.normal_exp_reg;
757 vbuf->buf_info[0].valid = true;
758 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: data_addr=%p,fd=%d,,length=%d\n",
759 vbuf->buf_info[0].data_addr,
760 vbuf->buf_info[0].data_fd,
761 vbuf->buf_info[0].data_length);
762 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
763 vbuf->buf_info[0].exp_gain,
764 vbuf->buf_info[0].exp_time,
765 vbuf->buf_info[0].exp_gain_reg,
766 vbuf->buf_info[0].exp_time_reg);
767
768 vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
769 vbuf->buf_info[1].exp_gain = (float)_finfo.hdr_gain_m;
770 vbuf->buf_info[1].exp_time = (float)_finfo.hdr_exp_m;
771 vbuf->buf_info[1].exp_gain_reg = (uint32_t)_finfo.hdr_gain_m_reg;
772 vbuf->buf_info[1].exp_time_reg = (uint32_t)_finfo.hdr_exp_m_reg;
773 vbuf->buf_info[1].valid = true;
774 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: data_addr=%p,fd=%d,,length=%d\n",
775 vbuf->buf_info[1].data_addr,
776 vbuf->buf_info[1].data_fd,
777 vbuf->buf_info[1].data_length);
778 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
779 vbuf->buf_info[1].exp_gain,
780 vbuf->buf_info[1].exp_time,
781 vbuf->buf_info[1].exp_gain_reg,
782 vbuf->buf_info[1].exp_time_reg);
783 }else if (_rawfmt.hdr_mode == 3) {
784 vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
785 vbuf->buf_info[0].exp_gain = (float)_finfo.normal_gain;
786 vbuf->buf_info[0].exp_time = (float)_finfo.normal_exp;
787 vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.normal_gain_reg;
788 vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.normal_exp_reg;
789 vbuf->buf_info[0].valid = true;
790 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: data_addr=%p,fd=%d,,length=%d\n",
791 vbuf->buf_info[0].data_addr,
792 vbuf->buf_info[0].data_fd,
793 vbuf->buf_info[0].data_length);
794 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
795 vbuf->buf_info[0].exp_gain,
796 vbuf->buf_info[0].exp_time,
797 vbuf->buf_info[0].exp_gain_reg,
798 vbuf->buf_info[0].exp_time_reg);
799
800 vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
801 vbuf->buf_info[1].exp_gain = (float)_finfo.hdr_gain_m;
802 vbuf->buf_info[1].exp_time = (float)_finfo.hdr_exp_m;
803 vbuf->buf_info[1].exp_gain_reg = (uint32_t)_finfo.hdr_gain_m_reg;
804 vbuf->buf_info[1].exp_time_reg = (uint32_t)_finfo.hdr_exp_m_reg;
805 vbuf->buf_info[1].valid = true;
806 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: data_addr=%p,fd=%d,,length=%d\n",
807 vbuf->buf_info[1].data_addr,
808 vbuf->buf_info[1].data_fd,
809 vbuf->buf_info[1].data_length);
810 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
811 vbuf->buf_info[1].exp_gain,
812 vbuf->buf_info[1].exp_time,
813 vbuf->buf_info[1].exp_gain_reg,
814 vbuf->buf_info[1].exp_time_reg);
815
816 vbuf->buf_info[2].frame_id = _rawfmt.frame_id;
817 vbuf->buf_info[2].exp_gain = (float)_finfo.hdr_gain_l;
818 vbuf->buf_info[2].exp_time = (float)_finfo.hdr_exp_l;
819 vbuf->buf_info[2].exp_gain_reg = (uint32_t)_finfo.hdr_gain_l_reg;
820 vbuf->buf_info[2].exp_time_reg = (uint32_t)_finfo.hdr_exp_l_reg;
821 vbuf->buf_info[2].valid = true;
822 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[2]: data_addr=%p,fd=%d,,length=%d\n",
823 vbuf->buf_info[2].data_addr,
824 vbuf->buf_info[2].data_fd,
825 vbuf->buf_info[2].data_length);
826 LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[2]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
827 vbuf->buf_info[2].exp_gain,
828 vbuf->buf_info[2].exp_time,
829 vbuf->buf_info[2].exp_gain_reg,
830 vbuf->buf_info[2].exp_time_reg);
831 }
832
833 return XCAM_RETURN_NO_ERROR;
834 }
835
836 XCamReturn
registRawdataCb(void (* callback)(void *))837 FakeCamHwIsp20::registRawdataCb(void (*callback)(void *))
838 {
839 ENTER_XCORE_FUNCTION();
840 XCamReturn ret = XCAM_RETURN_NO_ERROR;
841 SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
842 ret = fakeSensor->register_rawdata_callback(callback);
843 EXIT_XCORE_FUNCTION();
844 return ret;
845 }
846
847 XCamReturn
rawdataPrepare(rk_aiq_raw_prop_t prop)848 FakeCamHwIsp20::rawdataPrepare(rk_aiq_raw_prop_t prop)
849 {
850 ENTER_XCORE_FUNCTION();
851 XCamReturn ret = XCAM_RETURN_NO_ERROR;
852
853
854 _rawbuf_type = prop.rawbuf_type;
855 if (_rawbuf_type == RK_AIQ_RAW_ADDR)
856 {
857 _rx_memory_type = V4L2_MEMORY_USERPTR;
858 _tx_memory_type = V4L2_MEMORY_USERPTR;
859 }
860 else if (_rawbuf_type == RK_AIQ_RAW_FD)
861 {
862 _rx_memory_type = V4L2_MEMORY_DMABUF;
863 _tx_memory_type = V4L2_MEMORY_DMABUF;
864 }
865 else if(_rawbuf_type == RK_AIQ_RAW_DATA)
866 {
867 _rx_memory_type = V4L2_MEMORY_MMAP;
868 _tx_memory_type = V4L2_MEMORY_USERPTR;
869 }
870 else if(_rawbuf_type == RK_AIQ_RAW_FILE)
871 {
872 _rx_memory_type = V4L2_MEMORY_MMAP;
873 _tx_memory_type = V4L2_MEMORY_USERPTR;
874 }
875 else {
876 LOGE_CAMHW_SUBM(FAKECAM_SUBM,"Not support raw data type:%d", _rawbuf_type);
877 return XCAM_RETURN_ERROR_PARAM;
878 }
879 SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
880 ret = fakeSensor->prepare(prop);
881 EXIT_XCORE_FUNCTION();
882 return ret;
883 }
884
setupOffLineLink(int isp_index,bool enable)885 XCamReturn FakeCamHwIsp20::setupOffLineLink(int isp_index, bool enable)
886 {
887 media_device* device = NULL;
888 media_entity* entity = NULL;
889 media_pad* src_pad = NULL;
890 media_pad* sink_pad = NULL;
891 int lvds_max_entities = 6;
892 int lvds_entity = 0;
893
894 device = media_device_new(mIspHwInfos.isp_info[isp_index].media_dev_path);
895 if (!device) return XCAM_RETURN_ERROR_FAILED;
896
897 /* Enumerate entities, pads and links. */
898 media_device_enumerate(device);
899 entity = media_get_entity_by_name(device, "rkisp-isp-subdev", strlen("rkisp-isp-subdev"));
900 if (!entity) {
901 goto FAIL;
902 }
903
904 sink_pad = (media_pad*)media_entity_get_pad(entity, 0);
905 if (!sink_pad) {
906 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkisp-isp-subdev sink pad failed!\n");
907 goto FAIL;
908 }
909
910 for (lvds_entity = 0; lvds_entity < lvds_max_entities; lvds_entity++) {
911 char entity_name[128] = {0};
912 src_pad = NULL;
913 if (!lvds_entity) {
914 snprintf(entity_name, 128, "rkcif-mipi-lvds");
915 } else {
916 snprintf(entity_name, 128, "rkcif-mipi-lvds%d", lvds_entity);
917 }
918 entity = media_get_entity_by_name(device, entity_name, strlen(entity_name));
919 if (entity) {
920 src_pad = (media_pad*)media_entity_get_pad(entity, 0);
921 if (!src_pad) {
922 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-mipi-lvds%d source pad s failed!\n",
923 lvds_entity);
924 goto FAIL;
925 }
926 }
927
928 if (src_pad && sink_pad) {
929 if (enable) {
930 media_setup_link(device, src_pad, sink_pad, 0);
931 } else
932 media_setup_link(device, src_pad, sink_pad, MEDIA_LNK_FL_ENABLED);
933 }
934 }
935
936 media_device_unref(device);
937 return XCAM_RETURN_NO_ERROR;
938 FAIL:
939 media_device_unref(device);
940 return XCAM_RETURN_ERROR_FAILED;
941 }
942
FakeCamHwIsp21()943 FakeCamHwIsp21::FakeCamHwIsp21()
944 : FakeCamHwIsp20() {
945 }
946
~FakeCamHwIsp21()947 FakeCamHwIsp21::~FakeCamHwIsp21()
948 {
949 ENTER_CAMHW_FUNCTION();
950 EXIT_CAMHW_FUNCTION();
951 }
952
953 XCamReturn
init(const char * sns_ent_name)954 FakeCamHwIsp21::init(const char* sns_ent_name)
955 {
956 return FakeCamHwIsp20::init(sns_ent_name);
957 }
958
959 XCamReturn
prepare(uint32_t width,uint32_t height,int mode,int t_delay,int g_delay)960 FakeCamHwIsp21::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
961 {
962 return FakeCamHwIsp20::prepare(width, height, mode, t_delay, g_delay);
963 }
964
965 XCamReturn
enqueueRawBuffer(void * rawdata,bool sync)966 FakeCamHwIsp21::enqueueRawBuffer(void *rawdata, bool sync)
967 {
968 return FakeCamHwIsp20::enqueueRawBuffer(rawdata, sync);
969 }
970
971 XCamReturn
enqueueRawFile(const char * path)972 FakeCamHwIsp21::enqueueRawFile(const char *path)
973 {
974 return FakeCamHwIsp20::enqueueRawFile(path);
975 }
976
977 XCamReturn
registRawdataCb(void (* callback)(void *))978 FakeCamHwIsp21::registRawdataCb(void (*callback)(void *))
979 {
980 return FakeCamHwIsp20::registRawdataCb(callback);
981 }
982
983 XCamReturn
rawdataPrepare(rk_aiq_raw_prop_t prop)984 FakeCamHwIsp21::rawdataPrepare(rk_aiq_raw_prop_t prop)
985 {
986 return FakeCamHwIsp20::rawdataPrepare(prop);
987 }
988
989 XCamReturn
poll_event_ready(uint32_t sequence,int type)990 FakeCamHwIsp21::poll_event_ready (uint32_t sequence, int type)
991 {
992 return FakeCamHwIsp20::poll_event_ready (sequence, type);
993 }
994
FakeCamHwIsp3x()995 FakeCamHwIsp3x::FakeCamHwIsp3x()
996 : FakeCamHwIsp20() {
997 }
998
~FakeCamHwIsp3x()999 FakeCamHwIsp3x::~FakeCamHwIsp3x()
1000 {
1001 ENTER_CAMHW_FUNCTION();
1002 EXIT_CAMHW_FUNCTION();
1003 }
1004
1005 XCamReturn
init(const char * sns_ent_name)1006 FakeCamHwIsp3x::init(const char* sns_ent_name)
1007 {
1008 return FakeCamHwIsp20::init(sns_ent_name);
1009 }
1010
1011 XCamReturn
prepare(uint32_t width,uint32_t height,int mode,int t_delay,int g_delay)1012 FakeCamHwIsp3x::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
1013 {
1014 return FakeCamHwIsp20::prepare(width, height, mode, t_delay, g_delay);
1015 }
1016
1017 XCamReturn
enqueueRawBuffer(void * rawdata,bool sync)1018 FakeCamHwIsp3x::enqueueRawBuffer(void *rawdata, bool sync)
1019 {
1020 return FakeCamHwIsp20::enqueueRawBuffer(rawdata, sync);
1021 }
1022
1023 XCamReturn
enqueueRawFile(const char * path)1024 FakeCamHwIsp3x::enqueueRawFile(const char *path)
1025 {
1026 return FakeCamHwIsp20::enqueueRawFile(path);
1027 }
1028
1029 XCamReturn
registRawdataCb(void (* callback)(void *))1030 FakeCamHwIsp3x::registRawdataCb(void (*callback)(void *))
1031 {
1032 return FakeCamHwIsp20::registRawdataCb(callback);
1033 }
1034
1035 XCamReturn
rawdataPrepare(rk_aiq_raw_prop_t prop)1036 FakeCamHwIsp3x::rawdataPrepare(rk_aiq_raw_prop_t prop)
1037 {
1038 return FakeCamHwIsp20::rawdataPrepare(prop);
1039 }
1040
1041 XCamReturn
poll_event_ready(uint32_t sequence,int type)1042 FakeCamHwIsp3x::poll_event_ready (uint32_t sequence, int type)
1043 {
1044 return FakeCamHwIsp20::poll_event_ready (sequence, type);
1045 }
1046
FakeCamHwIsp32()1047 FakeCamHwIsp32::FakeCamHwIsp32()
1048 : FakeCamHwIsp20() {
1049 }
1050
~FakeCamHwIsp32()1051 FakeCamHwIsp32::~FakeCamHwIsp32()
1052 {
1053 ENTER_CAMHW_FUNCTION();
1054 EXIT_CAMHW_FUNCTION();
1055 }
1056
1057 XCamReturn
init(const char * sns_ent_name)1058 FakeCamHwIsp32::init(const char* sns_ent_name)
1059 {
1060 return FakeCamHwIsp20::init(sns_ent_name);
1061 }
1062
1063 XCamReturn
prepare(uint32_t width,uint32_t height,int mode,int t_delay,int g_delay)1064 FakeCamHwIsp32::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
1065 {
1066 return FakeCamHwIsp20::prepare(width, height, mode, t_delay, g_delay);
1067 }
1068
1069 XCamReturn
enqueueRawBuffer(void * rawdata,bool sync)1070 FakeCamHwIsp32::enqueueRawBuffer(void *rawdata, bool sync)
1071 {
1072 return FakeCamHwIsp20::enqueueRawBuffer(rawdata, sync);
1073 }
1074
1075 XCamReturn
enqueueRawFile(const char * path)1076 FakeCamHwIsp32::enqueueRawFile(const char *path)
1077 {
1078 return FakeCamHwIsp20::enqueueRawFile(path);
1079 }
1080
1081 XCamReturn
registRawdataCb(void (* callback)(void *))1082 FakeCamHwIsp32::registRawdataCb(void (*callback)(void *))
1083 {
1084 return FakeCamHwIsp20::registRawdataCb(callback);
1085 }
1086
1087 XCamReturn
rawdataPrepare(rk_aiq_raw_prop_t prop)1088 FakeCamHwIsp32::rawdataPrepare(rk_aiq_raw_prop_t prop)
1089 {
1090 return FakeCamHwIsp20::rawdataPrepare(prop);
1091 }
1092
1093 XCamReturn
poll_event_ready(uint32_t sequence,int type)1094 FakeCamHwIsp32::poll_event_ready (uint32_t sequence, int type)
1095 {
1096 return FakeCamHwIsp20::poll_event_ready (sequence, type);
1097 }
1098
1099 } //namspace RkCam
1100