1 #include "RawStreamCapUnit.h"
2 #include "rkcif-config.h"
3 #include "MediaInfo.h"
4 #include "xcam_defs.h"
5
6 namespace RkRawStream {
RawStreamCapUnit(char * dev0,char * dev1,char * dev2)7 RawStreamCapUnit::RawStreamCapUnit (char *dev0, char *dev1, char *dev2)
8 :_skip_num(0)
9 ,_mipi_dev_max(0)
10 ,_state(RAW_CAP_STATE_INVALID)
11 ,_memory_type(V4L2_MEMORY_MMAP)
12 ,user_on_frame_capture_cb(NULL)
13 {
14 if(dev0){
15 LOGD_RKSTREAM( "%s open device %s", __FUNCTION__, dev0);
16 _dev[0] = new V4l2Device (dev0);
17 _dev[0]->open();
18 _dev[0]->set_mem_type(_memory_type);
19 _mipi_dev_max++;
20 }
21 if(dev1){
22 LOGD_RKSTREAM( "%s open device %s", __FUNCTION__, dev1);
23 _dev[1] = new V4l2Device (dev1);
24 _dev[1]->open();
25 _dev[1]->set_mem_type(_memory_type);
26 _mipi_dev_max++;
27 }
28 if(dev2){
29 LOGD_RKSTREAM( "%s open device %s", __FUNCTION__, dev2);
30 _dev[2] = new V4l2Device (dev2);
31 _dev[2]->open();
32 _dev[2]->set_mem_type(_memory_type);
33 _mipi_dev_max++;
34 }
35
36 for (int i = 0; i < _mipi_dev_max; i++) {
37 if (_dev[i].ptr())
38 _dev[i]->set_buffer_count(STREAM_VIPCAP_BUF_NUM);
39
40 if (_dev[i].ptr())
41 _dev[i]->set_buf_sync (true);
42
43 _dev_bakup[i] = _dev[i];
44 _dev_index[i] = i;
45 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_TX);
46 _stream[i]->setPollCallback(this);
47 }
48 _sensor_dev = NULL;
49 _state = RAW_CAP_STATE_INITED;
50 }
51
RawStreamCapUnit(const rk_sensor_full_info_t * s_info)52 RawStreamCapUnit::RawStreamCapUnit (const rk_sensor_full_info_t *s_info)
53 :_skip_num(0)
54 ,_mipi_dev_max(0)
55 ,_state(RAW_CAP_STATE_INVALID)
56 ,_memory_type(V4L2_MEMORY_MMAP)
57 ,user_on_frame_capture_cb(NULL)
58 {
59 bool linked_to_isp = s_info->linked_to_isp;
60
61 strncpy(_sns_name, s_info->sensor_name.c_str(), 32);
62
63 /*
64 * for _mipi_tx_devs, index 0 refer to short frame always, inedex 1 refer
65 * to middle frame always, index 2 refert to long frame always.
66 * for CIF usecase, because mipi_id0 refert to long frame always, so we
67 * should know the HDR mode firstly befor building the relationship between
68 * _mipi_tx_devs array and mipi_idx. here we just set the mipi_idx to
69 * _mipi_tx_devs, we will build the real relation in start.
70 * for CIF usecase, rawwr2_path is always connected to _mipi_tx_devs[0],
71 * rawwr0_path is always connected to _mipi_tx_devs[1], and rawwr1_path is always
72 * connected to _mipi_tx_devs[0]
73 */
74 //short frame
75 if (strlen(s_info->isp_info->rawrd2_s_path)) {
76 if (linked_to_isp)
77 _dev[0] = new V4l2Device (s_info->isp_info->rawwr2_path);//rkisp_rawwr2
78 else {
79 if (s_info->dvp_itf) {
80 if (strlen(s_info->cif_info->stream_cif_path))
81 _dev[0] = new V4l2Device (s_info->cif_info->stream_cif_path);
82 else
83 _dev[0] = new V4l2Device (s_info->cif_info->dvp_id0);
84 } else{
85 _dev[0] = new V4l2Device (s_info->cif_info->mipi_id0);
86 }
87 }
88 _dev[0]->open();
89 _dev[0]->set_mem_type(_memory_type);
90 }
91 //mid frame
92 if (strlen(s_info->isp_info->rawrd0_m_path)) {
93 if (linked_to_isp)
94 _dev[1] = new V4l2Device (s_info->isp_info->rawwr0_path);//rkisp_rawwr0
95 else {
96 if (!s_info->dvp_itf)
97 _dev[1] = new V4l2Device (s_info->cif_info->mipi_id1);
98 }
99
100 if (_dev[1].ptr()){
101 _dev[1]->open();
102 _dev[1]->set_mem_type(_memory_type);
103 }
104 }
105 //long frame
106 if (strlen(s_info->isp_info->rawrd1_l_path)) {
107 if (linked_to_isp)
108 _dev[2] = new V4l2Device (s_info->isp_info->rawwr1_path);//rkisp_rawwr1
109 else {
110 if (!s_info->dvp_itf)
111 _dev[2] = new V4l2Device (s_info->cif_info->mipi_id2);//rkisp_rawwr1
112 }
113 if (_dev[2].ptr()){
114 _dev[2]->open();
115 _dev[2]->set_mem_type(_memory_type);
116 }
117 }
118 for (int i = 0; i < 3; i++) {
119 if (linked_to_isp) {
120 if (_dev[i].ptr())
121 _dev[i]->set_buffer_count(STREAM_ISP_BUF_NUM);
122 } else {
123 if (_dev[i].ptr())
124 _dev[i]->set_buffer_count(STREAM_VIPCAP_BUF_NUM);
125 }
126 if (_dev[i].ptr())
127 _dev[i]->set_buf_sync (true);
128
129 _dev_bakup[i] = _dev[i];
130 _dev_index[i] = i;
131 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_TX);
132 _stream[i]->setPollCallback(this);
133 }
134
135
136 _sensor_dev = new V4l2SubDevice(s_info->device_name.c_str());
137 _sensor_dev->open();
138 _state = RAW_CAP_STATE_INITED;
139
140 is_multi_isp_mode = s_info->isp_info->is_multi_isp_mode;
141 }
142
143 void
set_devices(RawStreamProcUnit * proc)144 RawStreamCapUnit::set_devices(RawStreamProcUnit *proc)
145 {
146 _proc_stream = proc;
147 }
148
~RawStreamCapUnit()149 RawStreamCapUnit::~RawStreamCapUnit ()
150 {
151 _state = RAW_CAP_STATE_INVALID;
152 }
153
start()154 XCamReturn RawStreamCapUnit::start()
155 {
156 LOGD_RKSTREAM( "%s enter", __FUNCTION__);
157 for (int i = 0; i < _mipi_dev_max; i++) {
158 _stream[i]->start();
159 }
160 _state = RAW_CAP_STATE_STARTED;
161 LOGD_RKSTREAM( "%s exit", __FUNCTION__);
162 return XCAM_RETURN_NO_ERROR;
163 }
164
stop()165 XCamReturn RawStreamCapUnit::stop ()
166 {
167 LOGD_RKSTREAM( "%s enter", __FUNCTION__);
168 for (int i = 0; i < _mipi_dev_max; i++) {
169 _stream[i]->stopThreadOnly();
170 }
171 _buf_mutex.lock();
172 for (int i = 0; i < _mipi_dev_max; i++) {
173 buf_list[i].clear ();
174 }
175 for (int i = 0; i < _mipi_dev_max; i++) {
176 user_used_buf_list[i].clear ();
177 }
178 _buf_mutex.unlock();
179 for (int i = 0; i < _mipi_dev_max; i++) {
180 _stream[i]->stopDeviceOnly();
181 }
182 _state = RAW_CAP_STATE_STOPPED;
183 LOGD_RKSTREAM( "%s exit", __FUNCTION__);
184 return XCAM_RETURN_NO_ERROR;
185 }
186
stop_device()187 XCamReturn RawStreamCapUnit::stop_device ()
188 {
189 LOGD_RKSTREAM( "%s enter", __FUNCTION__);
190 for (int i = 0; i < _mipi_dev_max; i++) {
191 _stream[i]->stopThreadOnly();
192 }
193 for (int i = 0; i < _mipi_dev_max; i++) {
194 _stream[i]->stopDeviceStreamoff();
195 }
196 _state = RAW_CAP_STATE_STOPPED;
197 LOGD_RKSTREAM( "%s exit", __FUNCTION__);
198 return XCAM_RETURN_NO_ERROR;
199 }
200
release_buffer()201 XCamReturn RawStreamCapUnit::release_buffer ()
202 {
203 LOGD_RKSTREAM( "%s enter", __FUNCTION__);
204 _buf_mutex.lock();
205 for (int i = 0; i < _mipi_dev_max; i++) {
206 buf_list[i].clear ();
207 }
208 for (int i = 0; i < _mipi_dev_max; i++) {
209 user_used_buf_list[i].clear ();
210 }
211 _buf_mutex.unlock();
212 for (int i = 0; i < _mipi_dev_max; i++) {
213 _stream[i]->stopDeviceFreebuffer();
214 }
215 _state = RAW_CAP_STATE_STOPPED;
216 LOGD_RKSTREAM( "%s exit", __FUNCTION__);
217 return XCAM_RETURN_NO_ERROR;
218 }
219
220
221 XCamReturn
prepare(int idx,uint8_t buf_memory_type,uint8_t buf_cnt)222 RawStreamCapUnit::prepare(int idx, uint8_t buf_memory_type, uint8_t buf_cnt)
223 {
224 XCamReturn ret = XCAM_RETURN_NO_ERROR;
225 _memory_type = (enum v4l2_memory)buf_memory_type;
226 LOGE_RKSTREAM("RawStreamCapUnit::prepare idx:%d buf_memory_type: %d\n",idx, buf_memory_type);
227 // mipi rx/tx format should match to sensor.
228 for (int i = 0; i < 3; i++) {
229 if (!(idx & (1 << i)))
230 continue;
231
232 if(buf_memory_type)
233 _dev[i]->set_mem_type(_memory_type);
234
235 if(buf_cnt)
236 _dev[i]->set_buffer_count(buf_cnt);
237
238 ret = _dev[i]->prepare();
239 if (ret < 0)
240 LOGE_RKSTREAM( "mipi tx:%d prepare err: %d\n", i, ret);
241
242 _stream[i]->set_device_prepared(true);
243 }
244 _state = RAW_CAP_STATE_PREPARED;
245 LOGD_RKSTREAM( "%s exit", __FUNCTION__);
246 return ret;
247 }
248
249 void
set_working_mode(int mode)250 RawStreamCapUnit::set_working_mode(int mode)
251 {
252 LOGD_RKSTREAM( "%s enter,mode=0x%x", __FUNCTION__, mode);
253 _working_mode = mode;
254
255 switch (_working_mode) {
256 case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
257 case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
258 _mipi_dev_max = 3;
259 break;
260 case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
261 case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
262 _mipi_dev_max = 2;
263 break;
264 default:
265 _mipi_dev_max = 1;
266 }
267 LOGD_RKSTREAM( "%s exit", __FUNCTION__);
268 }
269
270 void
set_tx_format(uint32_t width,uint32_t height,uint32_t pix_fmt,int mode)271 RawStreamCapUnit::set_tx_format(uint32_t width, uint32_t height, uint32_t pix_fmt, int mode)
272 {
273 struct v4l2_format format;
274 memset(&format, 0, sizeof(format));
275
276 for (int i = 0; i < 3; i++) {
277 if (_dev[i].ptr()){
278 _dev[i]->get_format (format);
279
280 int bpp = pixFmt2Bpp(format.fmt.pix.pixelformat);
281 int mem_mode = mode;
282 int ret1 = _dev[i]->io_control (RKCIF_CMD_SET_CSI_MEMORY_MODE, &mem_mode);
283 if (ret1)
284 LOGE_RKSTREAM("set RKCIF_CMD_SET_CSI_MEMORY_MODE failed !\n");
285
286 LOGI_RKSTREAM("set_tx_format: setup fmt %dx%d, 0x%x mem_mode %d\n",width, height, format.fmt.pix.pixelformat, mem_mode);
287 _dev[i]->set_format(width,
288 height,
289 format.fmt.pix.pixelformat,
290 V4L2_FIELD_NONE,
291 0);
292 }
293 }
294 }
295
296 void
set_sensor_format(uint32_t width,uint32_t height,uint32_t fps)297 RawStreamCapUnit::set_sensor_format(uint32_t width, uint32_t height, uint32_t fps)
298 {
299 if(_sensor_dev.ptr()){
300 struct v4l2_subdev_format format;
301 memset(&format, 0, sizeof(format));
302 _sensor_dev->getFormat(format);
303
304
305 format.pad = 0;
306 format.which = V4L2_SUBDEV_FORMAT_ACTIVE;
307 format.format.width = width;
308 format.format.height = height;
309 _sensor_dev->setFormat(format);
310 }
311 }
312
313 void
set_sensor_mode(uint32_t mode)314 RawStreamCapUnit::set_sensor_mode(uint32_t mode)
315 {
316 rkmodule_hdr_cfg hdr_cfg;
317 __u32 hdr_mode = NO_HDR;
318 if(_sensor_dev.ptr()){
319 switch (mode) {
320 case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
321 case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
322 hdr_mode = HDR_X3;
323 break;
324 case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
325 case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
326 hdr_mode = HDR_X2;
327 break;
328 default:
329 hdr_mode = NO_HDR;
330 }
331
332 hdr_cfg.hdr_mode = hdr_mode;
333 if (_sensor_dev->io_control(RKMODULE_SET_HDR_CFG, &hdr_cfg) < 0) {
334 LOGE_RKSTREAM("set_sensor_mode failed to set hdr mode %d\n", hdr_mode);
335 //return XCAM_RETURN_ERROR_IOCTL;
336 }
337 }
338 }
339
340 /*
341 void
342 RawStreamCapUnit::prepare_cif_mipi()
343 {
344 LOGD_RKSTREAM( "%s enter,working_mode=0x%x", __FUNCTION__, _working_mode);
345
346 FakeV4l2Device* fake_dev = dynamic_cast<FakeV4l2Device* >(_dev[0].ptr());
347
348 if (fake_dev) {
349 LOGD_RKSTREAM("ignore fake tx");
350 return;
351 }
352
353 SmartPtr<V4l2Device> tx_devs_tmp[3] =
354 {
355 _dev_bakup[0],
356 _dev_bakup[1],
357 _dev_bakup[2],
358 };
359
360 // _mipi_tx_devs
361 if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
362 // use _mipi_tx_devs[0] only
363 // id0 as normal
364 // do nothing
365 LOGD_RKSTREAM( "CIF tx: %s -> normal",
366 _dev[0]->get_device_name());
367 } else if (RK_AIQ_HDR_GET_WORKING_MODE(_working_mode) == RK_AIQ_WORKING_MODE_ISP_HDR2) {
368 // use _mipi_tx_devs[0] and _mipi_tx_devs[1]
369 // id0 as l, id1 as s
370 SmartPtr<V4l2Device> tmp = tx_devs_tmp[1];
371 tx_devs_tmp[1] = tx_devs_tmp[0];
372 tx_devs_tmp[0] = tmp;
373 LOGD_RKSTREAM( "CIF tx: %s -> long",
374 _dev[1]->get_device_name());
375 LOGD_RKSTREAM( "CIF tx: %s -> short",
376 _dev[0]->get_device_name());
377 } else if (RK_AIQ_HDR_GET_WORKING_MODE(_working_mode) == RK_AIQ_WORKING_MODE_ISP_HDR3) {
378 // use _mipi_tx_devs[0] and _mipi_tx_devs[1]
379 // id0 as l, id1 as m, id2 as s
380 SmartPtr<V4l2Device> tmp = tx_devs_tmp[2];
381 tx_devs_tmp[2] = tx_devs_tmp[0];
382 tx_devs_tmp[0] = tmp;
383 LOGD_RKSTREAM( "CIF tx: %s -> long",
384 _dev[2]->get_device_name());
385 LOGD_RKSTREAM( "CIF tx: %s -> middle",
386 _dev[1]->get_device_name());
387 LOGD_RKSTREAM( "CIF tx: %s -> short",
388 _dev[0]->get_device_name());
389 } else {
390 LOGE( "wrong hdr mode: %d\n", _working_mode);
391 }
392 for (int i = 0; i < 3; i++) {
393 _dev[i] = tx_devs_tmp[i];
394 _dev_index[i] = i;
395 _stream[i].release();
396 _stream[i] = new RKRawStream(_dev[i], i, ISP_POLL_TX);
397 _stream[i]->setPollCallback(this);
398 }
399 LOGD_RKSTREAM( "%s exit", __FUNCTION__);
400 }
401 */
402
403 XCamReturn
poll_buffer_ready(SmartPtr<V4l2BufferProxy> & buf,int dev_index)404 RawStreamCapUnit::poll_buffer_ready (SmartPtr<V4l2BufferProxy> &buf, int dev_index)
405 {
406 XCamReturn ret = XCAM_RETURN_NO_ERROR;
407 SmartPtr<V4l2BufferProxy> buf_s, buf_m, buf_l;
408 LOGD_RKSTREAM( "%s enter,dev_index=0x%x", __FUNCTION__, dev_index);
409
410 _buf_mutex.lock();
411 buf_list[dev_index].push(buf);
412 ret = sync_raw_buf(buf_s, buf_m, buf_l);
413 _buf_mutex.unlock();
414
415
416 if (ret == XCAM_RETURN_NO_ERROR) {
417 //if (_proc_stream)
418 // _proc_stream->send_sync_buf(buf_s, buf_m, buf_l);
419
420 if (user_on_frame_capture_cb){
421 struct timespec tx_timestamp;
422 int tx_timems;
423 user_takes_buf = false;
424
425 do_capture_callback(buf_s, buf_m, buf_l);
426
427 clock_gettime(CLOCK_MONOTONIC, &tx_timestamp);
428 tx_timems = XCAM_TIMESPEC_2_USEC(tx_timestamp) / 1000;
429 LOGI_RKSTREAM("BUFDEBUG vicapdq [%s] index %d seq %d tx_time %d", _sns_name, buf_s->get_v4l2_buf_index(), buf_s->get_sequence(),tx_timems);
430 if(user_takes_buf){
431 switch (_working_mode) {
432 case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
433 case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
434 user_used_buf_list[0].push(buf_s);
435 user_used_buf_list[1].push(buf_m);
436 user_used_buf_list[2].push(buf_l);
437 break;
438 case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
439 case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
440 user_used_buf_list[0].push(buf_s);
441 user_used_buf_list[1].push(buf_m);
442 break;
443 default:
444 user_used_buf_list[0].push(buf_s);
445 }
446 }
447 }
448 /*
449 if (_camHw->mHwResLintener) {
450 struct VideoBufferInfo vbufInfo;
451 vbufInfo.init(_format.fmt.pix.pixelformat, _format.fmt.pix.width, _format.fmt.pix.height,
452 _format.fmt.pix.width, _format.fmt.pix.height, _format.fmt.pix.sizeimage, true);
453 SmartPtr<SubVideoBuffer> subvbuf = new SubVideoBuffer (buf_s);
454 subvbuf->_buf_type = ISP_POLL_TX;
455 subvbuf->set_sequence(buf_s->get_sequence());
456 subvbuf->set_video_info(vbufInfo);
457 SmartPtr<VideoBuffer> vbuf = subvbuf.dynamic_cast_ptr<VideoBuffer>();
458 _camHw->mHwResLintener->hwResCb(vbuf);
459 }
460 */
461 }
462
463 return XCAM_RETURN_NO_ERROR;
464 }
465
466 XCamReturn
sync_raw_buf(SmartPtr<V4l2BufferProxy> & buf_s,SmartPtr<V4l2BufferProxy> & buf_m,SmartPtr<V4l2BufferProxy> & buf_l)467 RawStreamCapUnit::sync_raw_buf
468 (
469 SmartPtr<V4l2BufferProxy> &buf_s,
470 SmartPtr<V4l2BufferProxy> &buf_m,
471 SmartPtr<V4l2BufferProxy> &buf_l
472 )
473 {
474 uint32_t sequence_s = -1, sequence_m = -1, sequence_l = -1;
475
476 for (int i = 0; i < _mipi_dev_max; i++) {
477 if (buf_list[i].is_empty()) {
478 return XCAM_RETURN_ERROR_FAILED;
479 }
480 }
481
482 buf_l = buf_list[ISP_MIPI_HDR_L].front();
483 if (buf_l.ptr())
484 sequence_l = buf_l->get_sequence();
485
486 buf_m = buf_list[ISP_MIPI_HDR_M].front();
487 if (buf_m.ptr())
488 sequence_m = buf_m->get_sequence();
489
490 buf_s = buf_list[ISP_MIPI_HDR_S].front();
491
492 if (buf_s.ptr()) {
493 sequence_s = buf_s->get_sequence();
494 if ((_working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
495 _working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) &&
496 buf_m.ptr() && buf_l.ptr() && buf_s.ptr() &&
497 sequence_l == sequence_s && sequence_m == sequence_s) {
498
499 buf_list[ISP_MIPI_HDR_S].erase(buf_s);
500 buf_list[ISP_MIPI_HDR_M].erase(buf_m);
501 buf_list[ISP_MIPI_HDR_L].erase(buf_l);
502 //if (check_skip_frame(sequence_s)) {
503 // LOGW_RKSTREAM( "skip frame %d", sequence_s);
504 // goto end;
505 //}
506 } else if ((_working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
507 _working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) &&
508 buf_m.ptr() && buf_s.ptr() && sequence_m == sequence_s) {
509 buf_list[ISP_MIPI_HDR_S].erase(buf_s);
510 buf_list[ISP_MIPI_HDR_M].erase(buf_m);
511 //if (check_skip_frame(sequence_s)) {
512 // LOGE_RKSTREAM( "skip frame %d", sequence_s);
513 // goto end;
514 //}
515 } else if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
516 buf_list[ISP_MIPI_HDR_S].erase(buf_s);
517 //if (check_skip_frame(sequence_s)) {
518 // LOGW_RKSTREAM( "skip frame %d", sequence_s);
519 // goto end;
520 //}
521 } else {
522 LOGW_RKSTREAM( "do nothing, sequence not match l: %d, s: %d, m: %d !!!",
523 sequence_l, sequence_s, sequence_m);
524 }
525 return XCAM_RETURN_NO_ERROR;
526 }
527 end:
528 return XCAM_RETURN_ERROR_FAILED;
529 }
530
rkraw_append_buf(uint8_t * p,uint16_t tag,SmartPtr<V4l2BufferProxy> & buf)531 void rkraw_append_buf(uint8_t *p, uint16_t tag, SmartPtr<V4l2BufferProxy> &buf)
532 {
533 struct _live_rkraw_buf *b = (struct _live_rkraw_buf *)p;
534 uint64_t uptr = buf->get_v4l2_userptr();
535
536 b->_header.block_id = tag;
537 b->_header.block_length = sizeof(struct _st_addrinfo_stream);
538 b->_addr.idx = buf->get_v4l2_buf_index();
539 b->_addr.fd = buf->get_expbuf_fd();
540 b->_addr.size = buf->get_v4l2_buf_planar_length(0);
541 b->_addr.timestamp = buf->get_timestamp();
542 b->_addr.haddr = uptr >> 32;
543 b->_addr.laddr = uptr & 0xFFFFFFFF;
544 }
545
546 XCamReturn
do_capture_callback(SmartPtr<V4l2BufferProxy> & buf_s,SmartPtr<V4l2BufferProxy> & buf_m,SmartPtr<V4l2BufferProxy> & buf_l)547 RawStreamCapUnit::do_capture_callback
548 (
549 SmartPtr<V4l2BufferProxy> &buf_s,
550 SmartPtr<V4l2BufferProxy> &buf_m,
551 SmartPtr<V4l2BufferProxy> &buf_l
552 )
553 {
554 struct v4l2_buffer *vbuf[3];
555 struct v4l2_format *vfmt[3];
556 int vfd[3];
557 int state = -1;
558
559 int index = buf_s->get_v4l2_buf_index();
560 if(index > STREAM_VIPCAP_BUF_NUM-1){
561 LOGW_RKSTREAM("do_capture_callback: bad index %d!",index);
562 }
563
564 uint8_t *p = (uint8_t *)&_rkraw_data[index];
565 uint16_t *tag = (uint16_t *)p;
566 p = p + 2;
567 *tag = START_TAG;
568
569 struct _raw_format *f = (struct _raw_format *)p;
570 p = p + sizeof(struct _raw_format);
571 f->tag = FORMAT_TAG;
572 f->size = sizeof(struct _raw_format) - sizeof(struct _block_header);
573 f->vesrion = 0x0200;
574 memcpy(f->sensor, _sns_name, 32);
575 memset(f->scene, 0, 32);
576 f->frame_id = buf_s->get_sequence();
577 f->width = _format.fmt.pix.width;
578 f->height = _format.fmt.pix.height;
579
580 //TODO: use correct fmt
581 f->bit_width = 0;
582 f->bayer_fmt = 0;
583
584 if ((_working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
585 _working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)) {
586 f->hdr_mode = 3;
587
588 rkraw_append_buf(p, HDR_S_RAW_TAG, buf_s);
589 p = p + sizeof(struct _live_rkraw_buf);
590
591 rkraw_append_buf(p, HDR_M_RAW_TAG, buf_m);
592 p = p + sizeof(struct _live_rkraw_buf);
593
594 rkraw_append_buf(p, HDR_L_RAW_TAG, buf_l);
595 p = p + sizeof(struct _live_rkraw_buf);
596
597
598 // vbuf[0] = (v4l2_buffer*) &buf_s->get_v4l2_buf();
599 // vbuf[1] = (v4l2_buffer*) &buf_m->get_v4l2_buf();
600 // vbuf[2] = (v4l2_buffer*) &buf_l->get_v4l2_buf();
601 // vfmt[0] = (v4l2_format*) &buf_s->get_v4l2_format();
602 // vfmt[1] = (v4l2_format*) &buf_m->get_v4l2_format();
603 // vfmt[2] = (v4l2_format*) &buf_l->get_v4l2_format();
604 // vfd[0] = buf_s->get_expbuf_fd();
605 // vfd[1] = buf_m->get_expbuf_fd();
606 // vfd[2] = buf_l->get_expbuf_fd();
607
608 // state = 3;
609
610 } else if ((_working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
611 _working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)) {
612 f->hdr_mode = 2;
613
614 rkraw_append_buf(p, HDR_S_RAW_TAG, buf_s);
615 p = p + sizeof(struct _live_rkraw_buf);
616
617 rkraw_append_buf(p, HDR_M_RAW_TAG, buf_m);
618 p = p + sizeof(struct _live_rkraw_buf);
619
620 // vbuf[0] = (v4l2_buffer*) &buf_s->get_v4l2_buf();
621 // vbuf[1] = (v4l2_buffer*) &buf_m->get_v4l2_buf();
622 // vbuf[2] = NULL;
623 // vfmt[0] = (v4l2_format*) &buf_s->get_v4l2_format();
624 // vfmt[1] = (v4l2_format*) &buf_m->get_v4l2_format();
625 // vfmt[2] = NULL;
626 // vfd[0] = buf_s->get_expbuf_fd();
627 // vfd[1] = buf_m->get_expbuf_fd();
628
629 // state = 2;
630
631 } else if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
632 f->hdr_mode = 1;
633
634 rkraw_append_buf(p, NORMAL_RAW_TAG, buf_s);
635 p = p + sizeof(struct _live_rkraw_buf);
636
637
638 // vbuf[0] = (v4l2_buffer*) &buf_s->get_v4l2_buf();
639 // vbuf[1] = NULL;
640 // vbuf[2] = NULL;
641 // vfmt[0] = (v4l2_format*) &buf_s->get_v4l2_format();
642 // vfmt[1] = NULL;
643 // vfmt[2] = NULL;
644 // vfd[0] = buf_s->get_expbuf_fd();
645
646 // state = 1;
647
648 }
649
650 tag = (uint16_t *)p;
651 p = p + 2;
652 *tag = END_TAG;
653
654 uint32_t rkraw_len = p - (uint8_t *)&_rkraw_data[index];
655 if(user_on_frame_capture_cb){
656 user_on_frame_capture_cb((uint8_t *)&_rkraw_data[index], rkraw_len);
657 //user_on_frame_capture_cb(vbuf, vfmt, vfd, state);
658 }
659
660 return XCAM_RETURN_NO_ERROR;
661 }
662
release_user_taked_buf(int dev_index)663 void RawStreamCapUnit::release_user_taked_buf(int dev_index)
664 {
665 _buf_mutex.lock();
666 if (!user_used_buf_list[dev_index].is_empty()) {
667 SmartPtr<V4l2BufferProxy> rx_buf = user_used_buf_list[dev_index].pop(-1);
668 struct timespec rx_timestamp;
669 clock_gettime(CLOCK_MONOTONIC, &rx_timestamp);
670 int64_t rx_timems = XCAM_TIMESPEC_2_USEC(rx_timestamp) / 1000;
671 LOGI_RKSTREAM("BUFDEBUG vicapq [%s] index %d seq %d rx_timems %ld \n", _sns_name,
672 rx_buf->get_v4l2_buf_index(), rx_buf->get_sequence(),rx_timems);
673 }
674 _buf_mutex.unlock();
675 }
676
set_dma_buf(int dev_index,int buf_index,int fd)677 void RawStreamCapUnit::set_dma_buf(int dev_index, int buf_index, int fd)
678 {
679 int ret, i;
680 struct v4l2_format format;
681 i = dev_index;
682 SmartPtr<V4l2Buffer> v4l2buf;
683
684 ret = _dev[i]->get_buffer(v4l2buf, buf_index);
685 if (ret != XCAM_RETURN_NO_ERROR) {
686 LOGE_RKSTREAM( "set_dma_buf can not get buffer\n", i);
687 return;
688 }
689 v4l2buf->set_expbuf_fd((const int)fd);
690 ret = _dev[i]->queue_buffer(v4l2buf);
691 if (ret != XCAM_RETURN_NO_ERROR) {
692 LOGE_RKSTREAM( "set_dma_buf queue buffer failed\n", i);
693 }
694 return;
695 }
696
697 }
698