1
2 #include "RawStreamProcUnit.h"
3 #include "MediaInfo.h"
4
5 namespace RkRawStream {
6
_parse_rk_rawdata(void * rawdata,rkrawstream_rkraw2_t * rkraw2)7 int _parse_rk_rawdata(void *rawdata, rkrawstream_rkraw2_t *rkraw2)
8 {
9 unsigned short tag = 0;
10 struct _block_header header;
11 uint8_t *p = (uint8_t *)rawdata;
12 bool bExit = false;
13
14 int bufsize[3] = {0};
15 uint8_t *userptr[3] = {NULL};
16 struct _st_addrinfo_stream _st_addr[3];
17 uint64_t uptr;
18
19 if(rawdata == NULL || rkraw2 == NULL){
20 return -1;
21 }
22 while(!bExit){
23 tag = *((unsigned short*)p);
24 LOGD_RKSTREAM("_parse_rk_rawdata tag=0x%04x\n",tag);
25 switch (tag)
26 {
27 case START_TAG:
28 p = p+TAG_BYTE_LEN;
29 memset(_st_addr, 0, sizeof(_st_addr));
30 memset(&rkraw2->_rawfmt, 0, sizeof(struct _raw_format));
31 memset(&rkraw2->_finfo, 0, sizeof(rk_aiq_frame_info_t));
32 break;
33 case NORMAL_RAW_TAG:
34 {
35 header = *((struct _block_header *)p);
36 p = p + sizeof(struct _block_header);
37 if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
38 _st_addr[0] = *((struct _st_addrinfo_stream*)p);
39 }else{
40 userptr[0] = p;
41 bufsize[0] = header.block_length;
42 }
43 p = p + header.block_length;
44
45 break;
46 }
47 case HDR_S_RAW_TAG:
48 {
49 header = *((struct _block_header *)p);
50 p = p + sizeof(struct _block_header);
51 if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
52 _st_addr[0] = *((struct _st_addrinfo_stream*)p);
53 }else{
54 userptr[0] = p;
55 bufsize[0] = header.block_length;
56 }
57 p = p + header.block_length;
58 break;
59 }
60 case HDR_M_RAW_TAG:
61 {
62 header = *((struct _block_header *)p);
63 p = p + sizeof(struct _block_header);
64 if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
65 _st_addr[1] = *((struct _st_addrinfo_stream*)p);
66 }else{
67 userptr[1] = p;
68 bufsize[1] = header.block_length;
69 }
70 p = p + header.block_length;
71 break;
72 }
73 case HDR_L_RAW_TAG:
74 {
75 header = *((struct _block_header *)p);
76 p = p + sizeof(struct _block_header);
77 if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
78 _st_addr[2] = *((struct _st_addrinfo_stream*)p);
79 }else{
80 userptr[2] = p;
81 bufsize[2] = header.block_length;
82 }
83 p = p + header.block_length;
84 break;
85 }
86 case FORMAT_TAG:
87 {
88 rkraw2->_rawfmt = *((struct _raw_format *)p);
89 p = p + sizeof(struct _block_header) + rkraw2->_rawfmt.size;
90 break;
91 }
92 case STATS_TAG:
93 {
94 rkraw2->_finfo = *((rk_aiq_frame_info_t *)p);
95 p = p + sizeof(struct _block_header) + rkraw2->_finfo.size;
96 break;
97 }
98 case ISP_REG_FMT_TAG:
99 {
100 header = *((struct _block_header *)p);
101 p += sizeof(struct _block_header);
102 p = p + header.block_length;
103 break;
104 }
105 case ISP_REG_TAG:
106 {
107 header = *((struct _block_header *)p);
108 p += sizeof(struct _block_header);
109 p = p + header.block_length;
110 break;
111 }
112 case ISPP_REG_FMT_TAG:
113 {
114 header = *((struct _block_header *)p);
115 p += sizeof(struct _block_header);
116 p = p + header.block_length;
117 break;
118 }
119 case ISPP_REG_TAG:
120 {
121 header = *((struct _block_header *)p);
122 p += sizeof(struct _block_header);
123 p = p + header.block_length;
124 break;
125 }
126 case PLATFORM_TAG:
127 {
128 header = *((struct _block_header *)p);
129 p += sizeof(struct _block_header);
130 p = p + header.block_length;
131 break;
132 }
133 case END_TAG:
134 {
135 bExit = true;
136 break;
137 }
138 default:
139 {
140 LOGW_RKSTREAM("Not support TAG(0x%04x)\n", tag);
141 bExit = true;
142 break;
143 }
144 }
145 }
146
147 if(_st_addr[0].fd || _st_addr[0].laddr){
148 uptr = _st_addr[0].haddr;
149 uptr = uptr << 32;
150 uptr = uptr | _st_addr[0].laddr;
151
152 rkraw2->plane[0].mode = 0;
153 rkraw2->plane[0].addr = uptr;
154 rkraw2->plane[0].fd = _st_addr[0].fd;
155 rkraw2->plane[0].idx = _st_addr[0].idx;
156 rkraw2->plane[0].size = _st_addr[0].size;
157 rkraw2->plane[0].timestamp = _st_addr[0].timestamp;
158 }
159 if(userptr[0]){
160 //sbuf_s->_userptr = _rawbuffer[0];
161 //memcpy(_rawbuffer[0], userptr[0], bufsize[0]);
162 rkraw2->plane[0].mode = 1;
163 rkraw2->plane[0].addr = (uint64_t)userptr[0];
164 rkraw2->plane[0].size = bufsize[0];
165 }
166
167 if(_st_addr[1].fd || _st_addr[1].laddr){
168 uptr = _st_addr[1].haddr;
169 uptr = uptr << 32;
170 uptr = uptr | _st_addr[1].laddr;
171
172 rkraw2->plane[1].mode = 0;
173 rkraw2->plane[1].addr = uptr;
174 rkraw2->plane[1].fd = _st_addr[1].fd;
175 rkraw2->plane[1].idx = _st_addr[1].idx;
176 rkraw2->plane[1].size = _st_addr[1].size;
177 rkraw2->plane[1].timestamp = _st_addr[1].timestamp;
178 }
179 if(userptr[1]){
180 //sbuf_m->_userptr = _rawbuffer[1];
181 //memcpy(_rawbuffer[1], userptr[1], bufsize[1]);
182
183 rkraw2->plane[1].mode = 1;
184 rkraw2->plane[1].addr = (uint64_t)userptr[1];
185 rkraw2->plane[1].size = bufsize[1];
186 }
187
188 if(_st_addr[2].fd || _st_addr[2].laddr){
189 uptr = _st_addr[2].haddr;
190 uptr = uptr << 32;
191 uptr = uptr | _st_addr[2].laddr;
192
193 rkraw2->plane[2].mode = 0;
194 rkraw2->plane[2].addr = uptr;
195 rkraw2->plane[2].fd = _st_addr[2].fd;
196 rkraw2->plane[2].idx = _st_addr[2].idx;
197 rkraw2->plane[2].size = _st_addr[2].size;
198 rkraw2->plane[2].timestamp = _st_addr[2].timestamp;
199 }
200 if(userptr[2]){
201 //sbuf_l->_userptr = _rawbuffer[2];
202 //memcpy(_rawbuffer[2], userptr[2], bufsize[2]);
203 rkraw2->plane[2].mode = 1;
204 rkraw2->plane[2].addr = (uint64_t)userptr[2];
205 rkraw2->plane[2].size = bufsize[2];
206 }
207
208 return 0;
209 }
210
211 // RawStreamProcUnit::RawStreamProcUnit (char *ispdev, char *dev0, char *dev1, char *dev2, bool linked_to_isp)
212 // : _first_trigger(true)
213 // , _is_multi_cam_conc(false)
214 // , user_isp_process_done_cb(NULL)
215 // , _memory_type(V4L2_MEMORY_DMABUF)
216 // {
217 // _raw_proc_thread = new RawProcThread(this);
218 // _PollCallback = NULL;
219 // //_rawCap = NULL;
220 // //short frame
221 // if (dev0) {
222 // _dev[0] = new V4l2Device (dev0);//rkisp_rawrd2_s
223 // _dev[0]->open();
224 // _dev[0]->set_mem_type(_memory_type);
225 // }
226 // //mid frame
227 // if (dev1) {
228 // _dev[1] = new V4l2Device (dev1);//rkisp_rawrd0_m
229 // _dev[1]->open();
230 // _dev[1]->set_mem_type(_memory_type);
231 // }
232 // //long frame
233 // if (dev2) {
234 // _dev[2] = new V4l2Device (dev2);//rkisp_rawrd1_l
235 // _dev[2]->open();
236 // _dev[2]->set_mem_type(_memory_type);
237 // }
238 // for (int i = 0; i < 3; i++) {
239 // if (linked_to_isp) {
240 // if (_dev[i].ptr())
241 // _dev[i]->set_buffer_count(STREAM_ISP_BUF_NUM);
242 // } else {
243 // if (_dev[i].ptr())
244 // _dev[i]->set_buffer_count(STREAM_VIPCAP_BUF_NUM);
245 // }
246 // if (_dev[i].ptr())
247 // _dev[i]->set_buf_sync (true);
248
249 // _dev_index[i] = i;
250 // _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_RX);
251 // _stream[i]->setPollCallback(this);
252
253 // }
254
255 // _isp_core_dev = new V4l2SubDevice(ispdev);
256 // _isp_core_dev->open();
257
258 // dummy_dev = new V4l2Device(NULL);
259 // }
260
RawStreamProcUnit(const rk_sensor_full_info_t * s_info,uint8_t is_offline)261 RawStreamProcUnit::RawStreamProcUnit (const rk_sensor_full_info_t *s_info, uint8_t is_offline)
262 : _first_trigger(true)
263 , _mipi_dev_max(0)
264 , _is_multi_cam_conc(false)
265 , user_isp_process_done_cb(NULL)
266 , _memory_type(V4L2_MEMORY_DMABUF)
267 {
268 _raw_proc_thread = new RawProcThread(this);
269 _PollCallback = NULL;
270
271 bool linked_to_isp = s_info->linked_to_isp;
272
273 _is_offline_mode = is_offline;
274
275 strncpy(_sns_name, s_info->sensor_name.c_str(), 32);
276 //short frame
277 if (strlen(s_info->isp_info->rawrd2_s_path)) {
278 _dev[0] = new V4l2Device (s_info->isp_info->rawrd2_s_path);//rkisp_rawrd2_s
279 _dev[0]->open();
280 _dev[0]->set_mem_type(_memory_type);
281 }
282 //mid frame
283 if (strlen(s_info->isp_info->rawrd0_m_path)) {
284 _dev[1] = new V4l2Device (s_info->isp_info->rawrd0_m_path);//rkisp_rawrd0_m
285 _dev[1]->open();
286 _dev[1]->set_mem_type(_memory_type);
287 }
288 //long frame
289 if (strlen(s_info->isp_info->rawrd1_l_path)) {
290 _dev[2] = new V4l2Device (s_info->isp_info->rawrd1_l_path);//rkisp_rawrd1_l
291 _dev[2]->open();
292 _dev[2]->set_mem_type(_memory_type);
293 }
294 for (int i = 0; i < 3; i++) {
295 if (linked_to_isp) {
296 if (_dev[i].ptr())
297 _dev[i]->set_buffer_count(STREAM_ISP_BUF_NUM);
298 } else {
299 if (_dev[i].ptr())
300 _dev[i]->set_buffer_count(STREAM_VIPCAP_BUF_NUM);
301 }
302 if (_dev[i].ptr())
303 _dev[i]->set_buf_sync (true);
304 _dev_index[i] = i;
305 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_RX);
306 _stream[i]->setPollCallback(this);
307
308 }
309
310 _isp_core_dev = new V4l2SubDevice(s_info->isp_info->isp_dev_path);
311 _isp_core_dev->open();
312
313 dummy_dev = new V4l2Device(NULL);
314
315 _offline_index = 0;
316 _offline_seq = 0;
317
318 is_multi_isp_mode = s_info->isp_info->is_multi_isp_mode;
319
320 _rawbuffer[0] = NULL;
321 _rawbuffer[1] = NULL;
322 _rawbuffer[2] = NULL;
323 }
324
~RawStreamProcUnit()325 RawStreamProcUnit::~RawStreamProcUnit ()
326 {
327 LOGD_RKSTREAM("enter ~RawStreamProcUnit\n");
328 _dev[0] -> close();
329 _dev[1] -> close();
330 _dev[2] -> close();
331 LOGD_RKSTREAM("exit ~RawStreamProcUnit\n");
332 }
333
start()334 XCamReturn RawStreamProcUnit::start()
335 {
336 //_rawCap = new CaptureRawData(mCamPhyId);
337 for (int i = 0; i < _mipi_dev_max; i++) {
338 _stream[i]->start();
339 }
340 _msg_queue.resume_pop();
341 _msg_queue.clear();
342 _raw_proc_thread->start();
343
344 _offline_index = 0;
345 _offline_seq = 0;
346 return XCAM_RETURN_NO_ERROR;
347 }
348
stop()349 XCamReturn RawStreamProcUnit::stop ()
350 {
351 _msg_queue.pause_pop();
352 _raw_proc_thread->stop();
353
354 for (int i = 0; i < _mipi_dev_max; i++) {
355 _stream[i]->stopThreadOnly();
356 }
357
358 _buf_mutex.lock();
359 for (int i = 0; i < _mipi_dev_max; i++) {
360 cache_list2[i].clear ();
361 }
362 _isp_hdr_fid2ready_map.clear();
363 _buf_mutex.unlock();
364
365 //_mipi_trigger_mutex.lock();
366 //_isp_hdr_fid2times_map.clear();
367 _sof_timestamp_map.clear();
368 //_mipi_trigger_mutex.unlock();
369
370 //if (_rawCap) {
371 // delete _rawCap;
372 // _rawCap = NULL;
373 // }
374 if(_is_offline_mode) {
375 for (int i = 0; i < _mipi_dev_max; i++) {
376 if(_rawbuffer[i]){
377 free(_rawbuffer[i]);
378 }
379 }
380 }
381 for (int i = 0; i < _mipi_dev_max; i++) {
382 _stream[i]->stopDeviceOnly();
383 }
384 return XCAM_RETURN_NO_ERROR;
385 }
386
387 XCamReturn
prepare(int idx,uint8_t buf_memory_type,uint8_t buf_cnt)388 RawStreamProcUnit::prepare(int idx, uint8_t buf_memory_type, uint8_t buf_cnt)
389 {
390 XCamReturn ret = XCAM_RETURN_NO_ERROR;
391 _memory_type = (enum v4l2_memory)buf_memory_type;
392 LOGE_RKSTREAM("RawStreamProcUnit::prepare idx:%d buf_memory_type: %d\n",idx, buf_memory_type);
393 // mipi rx/tx format should match to sensor.
394 for (int i = 0; i < 3; i++) {
395 if (!(idx & (1 << i)))
396 continue;
397
398 if(buf_memory_type)
399 _dev[i]->set_mem_type(_memory_type);
400
401 if(buf_cnt)
402 _dev[i]->set_buffer_count(buf_cnt);
403
404 ret = _dev[i]->prepare();
405 if (ret < 0)
406 LOGE_RKSTREAM("mipi tx:%d prepare err: %d\n", i, ret);
407
408 _stream[i]->set_device_prepared(true);
409 if(_is_offline_mode) {
410 _rawbuffer[i] = (uint8_t *)malloc(_width * _height * 2);
411 }
412 }
413 return ret;
414 }
415
416 void
set_working_mode(int mode)417 RawStreamProcUnit::set_working_mode(int mode)
418 {
419 _working_mode = mode;
420
421 switch (_working_mode) {
422 case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
423 case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
424 _mipi_dev_max = 3;
425 break;
426 case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
427 case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
428 _mipi_dev_max = 2;
429 break;
430 default:
431 _mipi_dev_max = 1;
432 }
433 LOGD_RKSTREAM("working_mode:0x%x, _mipi_dev_max=%d\n", _working_mode, _mipi_dev_max);
434 }
435
436 void
set_rx_format(uint32_t width,uint32_t height,uint32_t pix_fmt,int mode)437 RawStreamProcUnit::set_rx_format(uint32_t width, uint32_t height, uint32_t pix_fmt, int mode)
438 {
439 struct v4l2_format format;
440 memset(&format, 0, sizeof(format));
441
442 for (int i = 0; i < 3; i++) {
443 if (_dev[i].ptr()){
444 _dev[i]->get_format (format);
445
446 int bpp = pixFmt2Bpp(format.fmt.pix.pixelformat);
447 int mem_mode = mode;
448 int ret1 = _dev[i]->io_control (RKISP_CMD_SET_CSI_MEMORY_MODE, &mem_mode);
449 if (ret1)
450 LOGE_RKSTREAM("set CSI_MEM_WORD_LITTLE_ALIGN failed !\n");
451
452
453 LOGI_RKSTREAM("set_rx_format: setup fmt %dx%d, 0x%x mem_mode %d\n",width, height, format.fmt.pix.pixelformat, mem_mode);
454 if (_dev[i].ptr())
455 _dev[i]->set_format(width,
456 height,
457 format.fmt.pix.pixelformat,
458 V4L2_FIELD_NONE,
459 0);
460 }
461 }
462 }
463
464 void
setup_pipeline_fmt(uint32_t width,uint32_t height)465 RawStreamProcUnit::setup_pipeline_fmt(uint32_t width, uint32_t height)
466 {
467 int ret;
468 // set isp sink fmt, same as sensor bounds - crop
469 struct v4l2_subdev_format isp_sink_fmt;
470
471 memset(&isp_sink_fmt, 0, sizeof(isp_sink_fmt));
472 isp_sink_fmt.pad = 0;
473 isp_sink_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
474 ret = _isp_core_dev->getFormat(isp_sink_fmt);
475 if (ret) {
476 LOGE_RKSTREAM("set mIspCoreDev fmt failed !\n");
477 return;
478 }
479 isp_sink_fmt.format.width = width;
480 isp_sink_fmt.format.height = height;
481 //isp_sink_fmt.format.code = sns_sd_fmt.format.code;
482
483 ret = _isp_core_dev->setFormat(isp_sink_fmt);
484 if (ret) {
485 LOGE_RKSTREAM("set mIspCoreDev fmt failed !\n");
486 return;
487 }
488
489 LOGD_RKSTREAM("isp sink fmt info: fmt 0x%x, %dx%d !",
490 isp_sink_fmt.format.code, isp_sink_fmt.format.width, isp_sink_fmt.format.height);
491
492 // set selection, isp needn't do the crop
493 struct v4l2_subdev_selection aSelection;
494 memset(&aSelection, 0, sizeof(aSelection));
495
496 aSelection.which = V4L2_SUBDEV_FORMAT_ACTIVE;
497 aSelection.pad = 0;
498 aSelection.flags = 0;
499 aSelection.target = V4L2_SEL_TGT_CROP;
500 aSelection.r.width = width;
501 aSelection.r.height = height;
502 aSelection.r.left = 0;
503 aSelection.r.top = 0;
504 ret = _isp_core_dev->set_selection (aSelection);
505 if (ret) {
506 LOGE_RKSTREAM("set mIspCoreDev crop failed !\n");
507 return;
508 }
509
510 LOGD_RKSTREAM("isp sink crop info: %dx%d@%d,%d !",
511 aSelection.r.width, aSelection.r.height,
512 aSelection.r.left, aSelection.r.top);
513
514 // set isp rkisp-isp-subdev src crop
515 aSelection.pad = 2;
516 ret = _isp_core_dev->set_selection (aSelection);
517 if (ret) {
518 LOGE_RKSTREAM("set mIspCoreDev source crop failed !\n");
519 return;
520 }
521 LOGD_RKSTREAM("isp src crop info: %dx%d@%d,%d !",
522 aSelection.r.width, aSelection.r.height,
523 aSelection.r.left, aSelection.r.top);
524
525 // set isp rkisp-isp-subdev src pad fmt
526 struct v4l2_subdev_format isp_src_fmt;
527
528 memset(&isp_src_fmt, 0, sizeof(isp_src_fmt));
529 isp_src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
530 isp_src_fmt.pad = 2;
531 ret = _isp_core_dev->getFormat(isp_src_fmt);
532 if (ret) {
533 LOGE_RKSTREAM("get mIspCoreDev src fmt failed !\n");
534 return;
535 }
536
537 isp_src_fmt.format.width = aSelection.r.width;
538 isp_src_fmt.format.height = aSelection.r.height;
539 ret = _isp_core_dev->setFormat(isp_src_fmt);
540 if (ret) {
541 LOGE_RKSTREAM("set mIspCoreDev src fmt failed !\n");
542 return;
543 }
544
545 LOGD_RKSTREAM("isp src fmt info: fmt 0x%x, %dx%d !",
546 isp_src_fmt.format.code, isp_src_fmt.format.width, isp_src_fmt.format.height);
547 }
548 /*
549 SmartPtr<V4l2Device>
550 RawStreamProcUnit::get_rx_device(int index)
551 {
552 if (index > _mipi_dev_max)
553 return nullptr;
554 else
555 return _dev[index];
556 }
557
558
559 void
560 RawStreamProcUnit::set_rx_format(const struct v4l2_subdev_selection& sns_sd_sel, uint32_t sns_v4l_pix_fmt)
561 {
562 // set mipi tx,rx fmt
563 // for cif: same as sensor fmt
564
565 struct v4l2_format format;
566 memset(&format, 0, sizeof(format));
567
568 for (int i = 0; i < 3; i++) {
569 if (_dev[i].ptr())
570 _dev[i]->get_format (format);
571 if (format.fmt.pix.width != sns_sd_sel.r.width ||
572 format.fmt.pix.height != sns_sd_sel.r.height ||
573 format.fmt.pix.pixelformat != sns_v4l_pix_fmt) {
574 if (_dev[i].ptr())
575 _dev[i]->set_format(sns_sd_sel.r.width,
576 sns_sd_sel.r.height,
577 sns_v4l_pix_fmt,
578 V4L2_FIELD_NONE,
579 0);
580 }
581 }
582
583 LOGD_RKSTREAM("set rx fmt info: fmt 0x%x, %dx%d !",
584 sns_v4l_pix_fmt, sns_sd_sel.r.width, sns_sd_sel.r.height);
585 }
586
587 void
588 RawStreamProcUnit::set_devices(SmartPtr<V4l2SubDevice> ispdev, CamHwIsp20* handle)
589 {
590 _isp_core_dev = ispdev;
591 _camHw = handle;
592 }
593 */
594 XCamReturn
poll_buffer_ready(SmartPtr<V4l2BufferProxy> & buf,int dev_index)595 RawStreamProcUnit::poll_buffer_ready (SmartPtr<V4l2BufferProxy> &buf, int dev_index)
596 {
597 SmartLock locker (_buf_mutex);
598 // if (!buf_list[dev_index].is_empty()) {
599 // SmartPtr<V4l2BufferProxy> rx_buf = buf_list[dev_index].pop(-1);
600 // LOGD_RKSTREAM("%s dev_index:%d index:%d fd:%d\n",
601 // __func__, dev_index, rx_buf->get_v4l2_buf_index(), rx_buf->get_expbuf_fd());
602 // }
603 if (_PollCallback){
604 _PollCallback->poll_buffer_ready (buf, dev_index);
605 }
606
607 if(user_isp_process_done_cb)
608 user_isp_process_done_cb(dev_index);
609
610 return XCAM_RETURN_NO_ERROR;
611 }
612 /*
613 void
614 RawStreamProcUnit::set_hdr_frame_readback_infos(int frame_id, int times)
615 {
616 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL)
617 return;
618
619 _mipi_trigger_mutex.lock();
620 _isp_hdr_fid2times_map[frame_id] = times;
621 LOGD_RKSTREAM( "rdtimes seq %d \n", frame_id);
622 // trigger_isp_readback();
623 _mipi_trigger_mutex.unlock();
624 }
625
626 void
627 RawStreamProcUnit::match_lumadetect_map(uint32_t sequence, sint32_t &additional_times)
628 {
629 std::map<uint32_t, int>::iterator it_times_del;
630 _mipi_trigger_mutex.lock();
631 for (std::map<uint32_t, int>::iterator iter = _isp_hdr_fid2times_map.begin();
632 iter != _isp_hdr_fid2times_map.end();) {
633 if (iter->first < sequence) {
634 it_times_del = iter++;
635 LOGD_RKSTREAM( "del seq %d", it_times_del->first);
636 iter = _isp_hdr_fid2times_map.erase(it_times_del);
637 } else if (iter->first == sequence) {
638 additional_times = iter->second;
639 it_times_del = iter++;
640 LOGD_RKSTREAM( "del seq %d", it_times_del->first);
641 iter = _isp_hdr_fid2times_map.erase(it_times_del);
642 break;
643 } else {
644 LOGW( "%s missing rdtimes for buf_seq %d, min rdtimes_seq %d !",
645 __func__, sequence, iter->first);
646 additional_times = 0;
647 break;
648 }
649 }
650 _mipi_trigger_mutex.unlock();
651 }
652
653 void
654 RawStreamProcUnit::match_globaltmostate_map(uint32_t sequence, bool &isHdrGlobalTmo)
655 {
656 std::map<uint32_t, bool>::iterator it_del;
657 _mipi_trigger_mutex.lock();
658 for (std::map<uint32_t, bool>::iterator iter = _hdr_global_tmo_state_map.begin();
659 iter != _hdr_global_tmo_state_map.end();) {
660 if (iter->first < sequence) {
661 it_del = iter++;
662 LOGD_RKSTREAM( "del seq %d", it_del->first);
663 iter = _hdr_global_tmo_state_map.erase(it_del);
664 } else if (iter->first == sequence) {
665 isHdrGlobalTmo = iter->second;
666 it_del = iter++;
667 LOGD_RKSTREAM( "del seq %d", it_del->first);
668 iter = _hdr_global_tmo_state_map.erase(it_del);
669 break;
670 } else {
671 LOGW( "%s missing tmo state for buf_seq %d, min rdtimes_seq %d !",
672 __func__, sequence, iter->first);
673 break;
674 }
675 }
676 _mipi_trigger_mutex.unlock();
677 }
678
679 void
680 RawStreamProcUnit::set_hdr_global_tmo_mode(int frame_id, bool mode)
681 {
682 _mipi_trigger_mutex.lock();
683 _hdr_global_tmo_state_map[frame_id] = mode;
684 _mipi_trigger_mutex.unlock();
685 }
686
687 void
688 RawStreamProcUnit::notify_sof(uint64_t time, int frameid)
689 {
690 _mipi_trigger_mutex.lock();
691 while (_sof_timestamp_map.size() > 8) {
692 _sof_timestamp_map.erase(_sof_timestamp_map.begin());
693 }
694 _sof_timestamp_map[frameid] = time;
695 _mipi_trigger_mutex.unlock();
696 }
697 */
698
699 XCamReturn
match_sof_timestamp_map(sint32_t sequence,uint64_t & timestamp)700 RawStreamProcUnit::match_sof_timestamp_map(sint32_t sequence, uint64_t ×tamp)
701 {
702 XCamReturn ret = XCAM_RETURN_NO_ERROR;
703 std::map<int, uint64_t>::iterator it;
704 sint32_t search_id = sequence < 0 ? 0 : sequence;
705
706 it = _sof_timestamp_map.find(search_id);
707 if (it != _sof_timestamp_map.end()) {
708 timestamp = it->second;
709 } else {
710 LOGW( "can't find frameid(%d), get sof timestamp failed!\n",
711 sequence);
712 ret = XCAM_RETURN_ERROR_FAILED;
713 }
714
715 return ret;
716 }
717
718 bool
raw_buffer_proc()719 RawStreamProcUnit::raw_buffer_proc ()
720 {
721 LOGD_RKSTREAM("%s enter", __FUNCTION__);
722 if (_msg_queue.pop(-1).ptr())
723 trigger_isp_readback();
724 LOGD_RKSTREAM("%s exit", __FUNCTION__);
725 return true;
726 }
727
728 void
send_sync_buf2(uint8_t * rkraw_data)729 RawStreamProcUnit::send_sync_buf2(uint8_t *rkraw_data)
730 {
731 rkrawstream_rkraw2_t rkraw2;
732 _parse_rk_rawdata(rkraw_data, &rkraw2);
733 _send_sync_buf(&rkraw2);
734 }
735
736 void
_send_sync_buf(rkrawstream_rkraw2_t * rkraw2)737 RawStreamProcUnit::_send_sync_buf(rkrawstream_rkraw2_t *rkraw2)
738 {
739 SmartPtr<SimpleFdBuf> sbuf_s, sbuf_m, sbuf_l;
740 sbuf_s = new SimpleFdBuf();
741 sbuf_m = new SimpleFdBuf();
742 sbuf_l = new SimpleFdBuf();
743
744 /*
745 * Offline frames has no index and seq,
746 * so we assign them here.
747 */
748 if(rkraw2->plane[0].mode == 0){
749 sbuf_s->_userptr = (uint8_t *)rkraw2->plane[0].addr;
750 sbuf_s->_fd = rkraw2->plane[0].fd;
751 sbuf_s->_index = rkraw2->plane[0].idx;
752 sbuf_s->_seq = rkraw2->_rawfmt.frame_id;
753 sbuf_s->_ts = rkraw2->plane[0].timestamp;
754 } else {
755 memcpy(_rawbuffer[0], (uint8_t *)rkraw2->plane[0].addr, rkraw2->plane[0].size);
756 sbuf_s->_userptr = _rawbuffer[0];
757 sbuf_s->_index = _offline_index;
758 sbuf_s->_seq = _offline_seq;
759 }
760
761 _offline_index ++;
762 _offline_seq ++;
763
764 if(_offline_index == 4)
765 _offline_index = 0;
766
767 _buf_mutex.lock();
768 for (int i = 0; i < _mipi_dev_max; i++) {
769 if (i == ISP_MIPI_HDR_S)
770 cache_list2[ISP_MIPI_HDR_S].push(sbuf_s);
771 else if (i == ISP_MIPI_HDR_M)
772 cache_list2[ISP_MIPI_HDR_M].push(sbuf_m);
773 else if (i == ISP_MIPI_HDR_L)
774 cache_list2[ISP_MIPI_HDR_L].push(sbuf_l);
775 }
776 _isp_hdr_fid2ready_map[sbuf_s->_seq] = true;
777 _buf_mutex.unlock();
778
779 /* this means send sof event. */
780 //if (_is_offline_mode) {
781 // int mode = 1;
782 // rk_aiq_uapi2_sysctl_rawReproc_genIspParams(aiq_ctx, sbuf_s->_seq, &_finfo, mode);
783 //}
784 SmartPtr<EmptyClass> ec = new EmptyClass();
785 _msg_queue.push(ec);
786 }
787
788 void
trigger_isp_readback()789 RawStreamProcUnit::trigger_isp_readback()
790 {
791 std::map<uint32_t, bool>::iterator it_ready;
792 SmartPtr<V4l2Buffer> v4l2buf[3];
793 SmartPtr<V4l2BufferProxy> buf_proxy;
794 SmartPtr<SimpleFdBuf> simple_buf;
795 uint32_t sequence = -1;
796 sint32_t additional_times = -1;
797 bool isHdrGlobalTmo = false;
798 struct isp2x_csi_trigger tg = {
799 .sof_timestamp = 0,
800 .frame_timestamp = 0,
801 .frame_id = sequence,
802 .times = 0,
803 .mode = _mipi_dev_max == 1 ? T_START_X1 :
804 _mipi_dev_max == 2 ? T_START_X2 : T_START_X3,
805 /* .mode = T_START_X2, */
806 };
807 uint64_t sof_timestamp = 0;
808 SmartLock locker (_buf_mutex);
809
810 if (_isp_hdr_fid2ready_map.size() == 0) {
811 LOGE_RKSTREAM( "%s buf not ready !", __func__);
812 return;
813 }
814
815 it_ready = _isp_hdr_fid2ready_map.begin();
816 sequence = it_ready->first;
817
818 //rk_aiq_uapi2_sysctl_setAllReadyIspParams(aiq_ctx, sequence);
819 // if ( _working_mode != RK_AIQ_WORKING_MODE_NORMAL) {
820 // match_lumadetect_map(sequence, additional_times);
821 // if (additional_times == -1) {
822 // // LOGE( "%s rdtimes not ready for seq %d !", __func__, sequence);
823 // // return;
824 // additional_times = 0;//add by zyl
825 // }
826
827 // match_globaltmostate_map(sequence, isHdrGlobalTmo);
828 // //if (isHdrGlobalTmo && !_camHw->getDhazState())
829 // // additional_times = 0;
830 // } else {
831 // additional_times = 0;
832 // }
833 additional_times = 0;
834 _isp_hdr_fid2ready_map.erase(it_ready);
835
836
837 int ret = XCAM_RETURN_NO_ERROR;
838
839 // whether to start capturing raw files
840 //if (_rawCap)
841 // _rawCap->detect_capture_raw_status(sequence, _first_trigger);
842
843 //CaptureRawData::getInstance().detect_capture_raw_status(sequence, _first_trigger);
844 //_camHw->setIsppConfig(sequence);
845 for (int i = 0; i < _mipi_dev_max; i++) {
846 // ret = _dev[i]->get_buffer(v4l2buf[i],
847 // cache_list[i].front()->get_v4l2_buf_index());
848 // if (ret != XCAM_RETURN_NO_ERROR) {
849 // LOGE( "Rx[%d] can not get buffer\n", i);
850 // goto out;
851 // } else {
852 // buf_proxy = cache_list[i].pop(-1);
853
854 // buf_list[i].push(buf_proxy);
855 // if (_dev[i]->get_mem_type() == V4L2_MEMORY_USERPTR)
856 // v4l2buf[i]->set_expbuf_usrptr(buf_proxy->get_v4l2_userptr());
857 // else if (_dev[i]->get_mem_type() == V4L2_MEMORY_DMABUF){
858 // v4l2buf[i]->set_expbuf_fd(buf_proxy->get_expbuf_fd());
859 // }else if (_dev[i]->get_mem_type() == V4L2_MEMORY_MMAP) {
860 // if (_dev[i]->get_use_type() == 1)
861 // {
862 // memcpy((void*)v4l2buf[i]->get_expbuf_usrptr(),(void*)buf_proxy->get_v4l2_userptr(),v4l2buf[i]->get_buf().m.planes[0].length);
863 // v4l2buf[i]->set_reserved(buf_proxy->get_v4l2_userptr());
864 // }
865 // }
866
867 ret = _dev[i]->get_buffer(v4l2buf[i],
868 cache_list2[i].front()->_index);
869 if (ret != XCAM_RETURN_NO_ERROR) {
870 LOGE_RKSTREAM( "Rx[%d] can not get buffer\n", i);
871 goto out;
872 } else {
873 simple_buf = cache_list2[i].pop(-1);
874
875 if (_memory_type == V4L2_MEMORY_USERPTR){
876 LOGD_RKSTREAM("use V4L2_MEMORY_USERPTR\n");
877 v4l2buf[i]->set_expbuf_usrptr((uint64_t)simple_buf->_userptr);
878 }
879 else if (_memory_type == V4L2_MEMORY_DMABUF){
880 v4l2buf[i]->set_expbuf_fd(simple_buf->_fd);
881 }
882
883 // if (_rawCap) {
884 // _rawCap->dynamic_capture_raw(i, sequence, buf_proxy, v4l2buf[i],_mipi_dev_max,_working_mode,_dev[0]);
885
886 // if (_rawCap->is_need_save_metadata_and_register()) {
887 // rkisp_effect_params_v20 ispParams;
888 // _camHw->getEffectiveIspParams(ispParams, sequence);
889
890 // SmartPtr<BaseSensorHw> mSensorSubdev = _camHw->mSensorDev.dynamic_cast_ptr<BaseSensorHw>();
891 // SmartPtr<RkAiqExpParamsProxy> ExpParams = nullptr;
892 // mSensorSubdev->getEffectiveExpParams(ExpParams, sequence);
893
894 // SmartPtr<LensHw> mLensSubdev = _camHw->mLensDev.dynamic_cast_ptr<LensHw>();
895 // SmartPtr<RkAiqAfInfoProxy> afParams = nullptr;
896 // if (mLensSubdev.ptr())
897 // mLensSubdev->getAfInfoParams(afParams, sequence);
898 // _rawCap->save_metadata_and_register(sequence, ispParams, ExpParams, afParams, _working_mode);
899 // }
900 // }
901 //CaptureRawData::getInstance().dynamic_capture_raw(i, sequence, buf_proxy, v4l2buf[i],_mipi_dev_max,_working_mode,_dev[0]);
902 }
903 }
904
905 for (int i = 0; i < _mipi_dev_max; i++) {
906 ret = _dev[i]->queue_buffer(v4l2buf[i]);
907 if (ret != XCAM_RETURN_NO_ERROR) {
908 LOGE_RKSTREAM( "Rx[%d] queue buffer failed\n", i);
909 break;
910 }
911 }
912
913
914
915 tg.frame_id = sequence;
916 if (_first_trigger)
917 tg.times = 1;
918 else
919 tg.times += additional_times;
920
921 if (tg.times > 2)
922 tg.times = 2;
923 if (_is_multi_cam_conc && (tg.times < 1))
924 tg.times = 1;
925
926 tg.frame_timestamp = simple_buf->_ts * 1000;
927 tg.sof_timestamp = tg.frame_timestamp;
928 // tg.times = 1;//fixed to three times readback
929 LOGI_RKSTREAM(
930 "camId:%d frame[%d]: sof_ts %" PRId64 "ms, frame_ts %" PRId64 "ms, globalTmo(%d), readback(%d) fd %d\n",
931 mCamPhyId,
932 sequence,
933 tg.sof_timestamp / 1000 / 1000,
934 tg.frame_timestamp / 1000 / 1000,
935 isHdrGlobalTmo,
936 tg.times,
937 simple_buf->_fd);
938
939 if (ret == XCAM_RETURN_NO_ERROR)
940 _isp_core_dev->io_control(RKISP_CMD_TRIGGER_READ_BACK, &tg);
941 else
942 LOGE_RKSTREAM( "%s frame[%d] queue failed, don't read back!\n",
943 __func__, sequence);
944 //if (_rawCap)
945 // _rawCap->update_capture_raw_status(_first_trigger);
946 //CaptureRawData::getInstance().update_capture_raw_status(_first_trigger);
947 _first_trigger = false;
948 out:
949 return;
950 }
951
952 }
953
954