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 <stdlib.h>
19 #include <fcntl.h>
20 #include "Stream.h"
21 #include "Isp20StatsBuffer.h"
22 #include "rkisp2-config.h"
23 #include "SensorHw.h"
24 #include "LensHw.h"
25 #include "Isp20_module_dbg.h"
26 #include "CamHwIsp20.h"
27 #include "CaptureRawData.h"
28 #include "rkcif-config.h"
29
30 namespace RkCam {
31
32 const int RkPollThread::default_poll_timeout = -1; // ms
33
34 const char*
35 RKStream::poll_type_to_str[ISP_POLL_POST_MAX] =
36 {
37 "luma_poll",
38 "isp_3a_stats_poll",
39 "isp_param_poll",
40 "ispp_fec_param_poll",
41 "ispp_tnr_param_poll",
42 "ispp_nr_param_poll",
43 "ispp_tnr_stats_poll",
44 "ispp_nr_stats_poll",
45 "isp_sof_poll",
46 "isp_tx_poll",
47 "isp_rx_poll",
48 "isp_sp_poll",
49 "isp_pdaf_poll",
50 "isp_gain",
51 "isp_nr_img",
52 "ispp_gain_kg",
53 "ispp_gain_wr",
54 "isp_stream_sync_poll",
55 "vicap_stream_on_evt",
56 "vicap_reset_evt",
57 "vicap_with_rk1608_reset_evt",
58 "vicap_scale_poll",
59 };
60
RkPollThread(const char * thName,int type,SmartPtr<V4l2Device> dev,RKStream * stream)61 RkPollThread::RkPollThread (const char* thName, int type, SmartPtr<V4l2Device> dev, RKStream *stream)
62 :Thread(thName)
63 ,_dev(dev)
64 ,_subdev(NULL)
65 ,_poll_callback (NULL)
66 ,_stream(stream)
67 ,frameid (0)
68 ,_dev_type(type)
69 {
70 _poll_stop_fd[0] = -1;
71 _poll_stop_fd[1] = -1;
72
73 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RkPollThread constructed");
74 }
75
RkPollThread(const char * thName,int type,SmartPtr<V4l2SubDevice> dev,RKStream * stream)76 RkPollThread::RkPollThread (const char* thName, int type, SmartPtr<V4l2SubDevice> dev, RKStream *stream)
77 :Thread(thName)
78 ,_dev(dev)
79 ,_subdev(dev)
80 ,_poll_callback (NULL)
81 ,_stream(stream)
82 ,frameid (0)
83 ,_dev_type(type)
84 {
85 _poll_stop_fd[0] = -1;
86 _poll_stop_fd[1] = -1;
87
88 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RkPollThread constructed");
89 }
90
~RkPollThread()91 RkPollThread::~RkPollThread ()
92 {
93 stop();
94 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "~RkPollThread destructed");
95 }
96
destroy_stop_fds()97 void RkPollThread::destroy_stop_fds () {
98 if (_poll_stop_fd[1] != -1 || _poll_stop_fd[0] != -1) {
99 close(_poll_stop_fd[0]);
100 close(_poll_stop_fd[1]);
101 _poll_stop_fd[0] = -1;
102 _poll_stop_fd[1] = -1;
103 }
104 }
105
create_stop_fds()106 XCamReturn RkPollThread::create_stop_fds () {
107 int status = 0;
108 XCamReturn ret = XCAM_RETURN_NO_ERROR;
109
110 destroy_stop_fds ();
111
112 status = pipe(_poll_stop_fd);
113 if (status < 0) {
114 XCAM_LOG_ERROR ("Failed to create ispp poll stop pipe: %s", strerror(errno));
115 ret = XCAM_RETURN_ERROR_UNKNOWN;
116 goto exit_error;
117 }
118
119 /**
120 * make the reading end of the pipe non blocking.
121 * This helps during flush to read any information left there without
122 * blocking
123 */
124 status = fcntl(_poll_stop_fd[0], F_SETFL, O_NONBLOCK);
125 if (status < 0) {
126 XCAM_LOG_ERROR ("Fail to set event ispp stop pipe flag: %s", strerror(errno));
127 ret = XCAM_RETURN_ERROR_UNKNOWN;
128 goto exit_error;
129 }
130
131 return XCAM_RETURN_NO_ERROR;
132 exit_error:
133 destroy_stop_fds ();
134 return ret;
135 }
136
start()137 XCamReturn RkPollThread::start ()
138 {
139 if (create_stop_fds ()) {
140 XCAM_LOG_ERROR("create stop fds failed !");
141 return XCAM_RETURN_ERROR_UNKNOWN;
142 }
143
144 Thread::start();
145
146 return XCAM_RETURN_NO_ERROR;
147 }
148
stop()149 XCamReturn RkPollThread::stop ()
150 {
151 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "RkPollThread %s:%s stop", get_name(),
152 _dev.ptr() ? _dev->get_device_name() :
153 _subdev.ptr() ? _subdev->get_device_name() : "null");
154 if (_poll_stop_fd[1] != -1) {
155 char buf = 0xf; // random value to write to flush fd.
156 unsigned int size = write(_poll_stop_fd[1], &buf, sizeof(char));
157 if (size != sizeof(char)) {
158 XCAM_LOG_WARNING("Flush write not completed");
159 }
160 }
161 Thread::stop();
162 destroy_stop_fds ();
163 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "stop done");
164 return XCAM_RETURN_NO_ERROR;
165 }
166
167 bool
setPollCallback(PollCallback * callback)168 RkPollThread::setPollCallback (PollCallback *callback)
169 {
170 //XCAM_ASSERT (!_poll_callback);
171 _poll_callback = callback;
172 return true;
173 }
174
175 XCamReturn
poll_buffer_loop()176 RkPollThread::poll_buffer_loop ()
177 {
178 XCamReturn ret = XCAM_RETURN_NO_ERROR;
179 int poll_ret = 0;
180 SmartPtr<V4l2Buffer> buf;
181 int stop_fd = -1;
182
183 stop_fd = _poll_stop_fd[0];
184 poll_ret = _dev->poll_event (RkPollThread::default_poll_timeout, stop_fd);
185
186 if (poll_ret == POLL_STOP_RET) {
187 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "poll buffer stop success !");
188 // stop success, return error to stop the poll thread
189 return XCAM_RETURN_ERROR_UNKNOWN;
190 }
191
192 if (poll_ret < 0 && (errno == EAGAIN || errno == EINTR)) {
193 XCAM_LOG_DEBUG("poll buffer event got interrupt(0x%x), continue\n",
194 poll_ret);
195 return XCAM_RETURN_ERROR_TIMEOUT;
196 } else if (poll_ret < 0) {
197 XCAM_LOG_DEBUG("poll buffer event got error(0x%x) exit\n", poll_ret);
198 return XCAM_RETURN_ERROR_UNKNOWN;
199 } else if (poll_ret == 0) {
200 XCAM_LOG_DEBUG("poll buffer event timeout(0x%x), continue\n",
201 poll_ret);
202 return XCAM_RETURN_ERROR_TIMEOUT;
203 }
204
205 ret = _dev->dequeue_buffer (buf);
206 if (ret != XCAM_RETURN_NO_ERROR) {
207 XCAM_LOG_WARNING ("dequeue buffer failed");
208 return ret;
209 }
210
211 XCAM_ASSERT (buf.ptr());
212
213 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "camId: %d, frameId: %d: dequeue buffer on %s\n",
214 mCamPhyId, buf->get_buf().sequence, RKStream::poll_type_to_str[_dev_type]);
215
216 if (_dev_type == ISP_POLL_TX || _dev_type == ISP_POLL_RX) {
217 SmartPtr<V4l2BufferProxy> buf_proxy = _stream->new_v4l2proxy_buffer(buf, _dev);
218 if (_poll_callback && buf_proxy.ptr())
219 _poll_callback->poll_buffer_ready (buf_proxy, ((RKRawStream*)_stream)->_dev_index);
220 } else if (_dev_type == ISP_POLL_PDAF_STATS) {
221 SmartPtr<V4l2BufferProxy> buf_proxy = _stream->new_v4l2proxy_buffer(buf, _dev);
222 if (_poll_callback && buf_proxy.ptr())
223 _poll_callback->poll_buffer_ready (buf_proxy, 0);
224 } else {
225 SmartPtr<VideoBuffer> video_buf = _stream->new_video_buffer(buf, _dev);
226 if (_poll_callback && video_buf.ptr())
227 _poll_callback->poll_buffer_ready (video_buf);
228 }
229
230 return ret;
231 }
232
RkEventPollThread(const char * thName,int type,SmartPtr<V4l2Device> dev,RKStream * stream)233 RkEventPollThread::RkEventPollThread (const char* thName, int type, SmartPtr<V4l2Device> dev, RKStream *stream)
234 :RkPollThread(thName, type, dev, stream)
235 {
236 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RkEventPollThread constructed");
237 }
238
RkEventPollThread(const char * thName,int type,SmartPtr<V4l2SubDevice> subdev,RKStream * stream)239 RkEventPollThread::RkEventPollThread (const char* thName, int type, SmartPtr<V4l2SubDevice> subdev, RKStream *stream)
240 :RkPollThread(thName, type, subdev, stream)
241 {
242 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RkEventPollThread constructed");
243 }
244
~RkEventPollThread()245 RkEventPollThread::~RkEventPollThread ()
246 {
247 stop();
248 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "~RkEventPollThread destructed");
249 }
250
251 XCamReturn
poll_event_loop()252 RkEventPollThread::poll_event_loop ()
253 {
254 XCamReturn ret = XCAM_RETURN_NO_ERROR;
255 int poll_ret = 0;
256 int stop_fd = -1;
257
258 stop_fd = _poll_stop_fd[0];
259 poll_ret = _dev->poll_event (RkPollThread::default_poll_timeout, stop_fd);
260
261 if (poll_ret == POLL_STOP_RET) {
262 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s: poll event stop success !", get_name());
263 // stop success, return error to stop the poll thread
264 return XCAM_RETURN_ERROR_UNKNOWN;
265 }
266
267 if (poll_ret < 0 && (errno == EAGAIN || errno == EINTR)) {
268 XCAM_LOG_DEBUG("poll buffer event got interrupt(0x%x), continue\n",
269 poll_ret);
270 return XCAM_RETURN_ERROR_TIMEOUT;
271 } else if (poll_ret < 0) {
272 XCAM_LOG_DEBUG("poll buffer event got error(0x%x) exit\n", poll_ret);
273 return XCAM_RETURN_ERROR_UNKNOWN;
274 } else if (poll_ret == 0) {
275 XCAM_LOG_WARNING ("poll event timeout and continue");
276 return XCAM_RETURN_ERROR_TIMEOUT;
277 }
278 xcam_mem_clear (_event);
279
280 ret = _dev->dequeue_event (_event);
281 if (ret != XCAM_RETURN_NO_ERROR) {
282 XCAM_LOG_WARNING ("dequeue event failed on dev:%s", XCAM_STR(_dev->get_device_name()));
283 return XCAM_RETURN_ERROR_IOCTL;
284 }
285
286 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "camId: %d, frameId: %d: dequeue the type(%d) of event on dev: %s",
287 mCamPhyId, _event.u.frame_sync.frame_sequence,
288 _event.type, XCAM_STR(_dev->get_device_name()));
289
290 if (_poll_callback && _stream) {
291 SmartPtr<VideoBuffer> video_buf = _stream->new_video_buffer(_event, _subdev);
292 _poll_callback->poll_buffer_ready (video_buf);
293 }
294
295 return ret;
296 }
297
298 /*--------------------ISP evt poll ---------------------------*/
299
300 XCamReturn
poll_event_loop()301 RkStreamEventPollThread::poll_event_loop () {
302 XCamReturn ret = RkEventPollThread::poll_event_loop();
303
304 if (ret == XCAM_RETURN_NO_ERROR) {
305 if (_event.type == CIFISP_V4L2_EVENT_STREAM_START) {
306 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s: poll stream on evt success", _dev->get_device_name());
307 _pIsp->notify_isp_stream_status(true);
308 } else if (_event.type == CIFISP_V4L2_EVENT_STREAM_STOP) {
309 LOGI_CAMHW_SUBM(ISP20HW_SUBM, "%s: poll stream off evt success", _dev->get_device_name());
310 _pIsp->notify_isp_stream_status(false);
311 // quit loop
312 emit_stop ();
313 return XCAM_RETURN_ERROR_UNKNOWN;
314 }
315 }
316
317 return ret;
318 }
319
320 XCamReturn
start()321 RkStreamEventPollThread::start()
322 {
323 XCamReturn ret = XCAM_RETURN_NO_ERROR;
324
325 ret = _dev->open(false);
326 if (ret) {
327 return ret;
328 }
329 _dev->subscribe_event(CIFISP_V4L2_EVENT_STREAM_START);
330 _dev->subscribe_event(CIFISP_V4L2_EVENT_STREAM_STOP);
331 return RkEventPollThread::start();
332 }
333
334 XCamReturn
stop()335 RkStreamEventPollThread::stop ()
336 {
337 XCamReturn ret = XCAM_RETURN_NO_ERROR;
338
339 ret = RkEventPollThread::stop();
340 if (_dev->is_opened()) {
341 _dev->unsubscribe_event(CIFISP_V4L2_EVENT_STREAM_START);
342 _dev->unsubscribe_event(CIFISP_V4L2_EVENT_STREAM_STOP);
343 ret = _dev->close();
344 }
345 return ret;
346 }
347
RKStream(SmartPtr<V4l2Device> dev,int type)348 RKStream::RKStream (SmartPtr<V4l2Device> dev, int type)
349 :_dev(dev)
350 ,_dev_type(type)
351 ,_dev_prepared(false)
352 {
353 _poll_thread = new RkPollThread(RKStream::poll_type_to_str[type], type, dev, this);
354 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKStream constructed");
355 }
356
RKStream(SmartPtr<V4l2SubDevice> dev,int type)357 RKStream::RKStream (SmartPtr<V4l2SubDevice> dev, int type)
358 :_subdev(dev)
359 ,_dev_type(type)
360 ,_dev_prepared(false)
361 {
362 _poll_thread = new RkEventPollThread(RKStream::poll_type_to_str[type], type, dev, this);
363 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKStream constructed");
364 }
365
RKStream(const char * path,int type)366 RKStream::RKStream (const char *path, int type)
367 :_dev_type(type)
368 ,_dev_prepared(false)
369 {
370 _dev = new V4l2Device(path);
371 _poll_thread = new RkPollThread(RKStream::poll_type_to_str[type], type, _dev, this);
372 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKStream constructed");
373 }
374
~RKStream()375 RKStream::~RKStream()
376 {
377 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "~RKStream destructed");
378 }
379
380 void
start()381 RKStream::start()
382 {
383 if (!_dev->is_activated())
384 _dev->start(_dev_prepared);
385
386 _poll_thread->setCamPhyId(mCamPhyId);
387 if (_dev_type == ISP_POLL_3A_STATS || \
388 _dev_type == ISP_POLL_TX || \
389 _dev_type == ISP_POLL_RX) {
390 _poll_thread->set_policy(SCHED_RR);
391 _poll_thread->set_priority(20);
392 }
393 _poll_thread->start();
394 }
395
396 void
startThreadOnly()397 RKStream::startThreadOnly()
398 {
399 _poll_thread->setCamPhyId(mCamPhyId);
400 if (_dev_type == ISP_POLL_3A_STATS || \
401 _dev_type == ISP_POLL_TX || \
402 _dev_type == ISP_POLL_RX) {
403 _poll_thread->set_policy(SCHED_RR);
404 _poll_thread->set_priority(20);
405 }
406 _poll_thread->start();
407 }
408
409 void
startDeviceOnly()410 RKStream::startDeviceOnly()
411 {
412 if (!_dev->is_activated())
413 _dev->start(_dev_prepared);
414 }
415
416 void
stop()417 RKStream::stop()
418 {
419 _poll_thread->stop();
420 _dev->stop();
421 _dev_prepared = false;
422 }
423
424 void
stopThreadOnly()425 RKStream::stopThreadOnly()
426 {
427 _poll_thread->stop();
428 }
429
430 void
stopDeviceOnly()431 RKStream::stopDeviceOnly()
432 {
433 _dev->stop();
434 _dev_prepared = false;
435 }
436
437 void
pause()438 RKStream::pause()
439 {
440 }
441
442 void
resume()443 RKStream::resume()
444 {
445 }
446
447 void
set_device_prepared(bool prepare)448 RKStream::set_device_prepared(bool prepare)
449 {
450 _dev_prepared = prepare;
451 }
452
new_video_buffer(SmartPtr<V4l2Buffer> buf,SmartPtr<V4l2Device> dev)453 SmartPtr<VideoBuffer> RKStream::new_video_buffer(SmartPtr<V4l2Buffer> buf,
454 SmartPtr<V4l2Device> dev)
455 {
456 SmartPtr<VideoBuffer> video_buf = new V4l2BufferProxy (buf, dev);
457 video_buf->_buf_type = _dev_type;
458 return video_buf;
459 }
460
461 bool
setPollCallback(PollCallback * callback)462 RKStream::setPollCallback (PollCallback *callback)
463 {
464 return _poll_thread->setPollCallback(callback);
465 }
466
getFormat(struct v4l2_format & format)467 XCamReturn RKStream::getFormat(struct v4l2_format &format)
468 {
469 return _dev->get_format (format);
470 }
471
getFormat(struct v4l2_subdev_format & format)472 XCamReturn RKStream::getFormat(struct v4l2_subdev_format &format)
473 {
474 return _subdev->getFormat (format);
475 }
476
RKStatsStream(SmartPtr<V4l2Device> dev,int type)477 RKStatsStream::RKStatsStream (SmartPtr<V4l2Device> dev, int type)
478 :RKStream(dev, type)
479 {
480 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKStream constructed");
481 }
482
483 //RKStatsStream::RKStatsStream (const char *name, int type)
484 // :RKStream(name, type)
485 //{
486 // LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKStream constructed");
487 //}
488
~RKStatsStream()489 RKStatsStream::~RKStatsStream()
490 {
491 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "~RKStream destructed");
492 }
493
set_event_handle_dev(SmartPtr<BaseSensorHw> & dev)494 bool RKStatsStream::set_event_handle_dev(SmartPtr<BaseSensorHw> &dev)
495 {
496 _event_handle_dev = dev;
497 return true;
498 }
499
set_iris_handle_dev(SmartPtr<LensHw> & dev)500 bool RKStatsStream::set_iris_handle_dev(SmartPtr<LensHw> &dev)
501 {
502 _iris_handle_dev = dev;
503 return true;
504 }
505
set_focus_handle_dev(SmartPtr<LensHw> & dev)506 bool RKStatsStream::set_focus_handle_dev(SmartPtr<LensHw> &dev)
507 {
508 _focus_handle_dev = dev;
509 return true;
510 }
511
set_rx_handle_dev(CamHwIsp20 * dev)512 bool RKStatsStream::set_rx_handle_dev(CamHwIsp20* dev)
513 {
514 _rx_handle_dev = dev;
515 return true;
516 }
517
518 SmartPtr<VideoBuffer>
new_video_buffer(SmartPtr<V4l2Buffer> buf,SmartPtr<V4l2Device> dev)519 RKStatsStream::new_video_buffer(SmartPtr<V4l2Buffer> buf,
520 SmartPtr<V4l2Device> dev)
521 {
522 ENTER_CAMHW_FUNCTION();
523 //SmartPtr<VideoBuffer> video_buf = nullptr;
524 SmartPtr<Isp20StatsBuffer> isp20stats_buf = nullptr;
525
526 SmartPtr<RkAiqIrisParamsProxy> irisParams = nullptr;
527 SmartPtr<RkAiqAfInfoProxy> afParams = nullptr;
528
529 if (_focus_handle_dev.ptr()) {
530 _focus_handle_dev->getAfInfoParams(afParams, buf->get_buf().sequence);
531 _focus_handle_dev->getIrisInfoParams(irisParams, buf->get_buf().sequence);
532 }
533
534 isp20stats_buf = new Isp20StatsBuffer(buf, dev, _event_handle_dev, _rx_handle_dev, afParams, irisParams);
535 isp20stats_buf->_buf_type = _dev_type;
536
537 EXIT_CAMHW_FUNCTION();
538
539 return isp20stats_buf;
540 }
541
542 /*--------------------sof event stream---------------------------*/
543 std::atomic<bool> RKSofEventStream::_is_subscribed{false};
544
RKSofEventStream(SmartPtr<V4l2SubDevice> dev,int type,bool linkedToRk1608)545 RKSofEventStream::RKSofEventStream (SmartPtr<V4l2SubDevice> dev, int type, bool linkedToRk1608)
546 :RKStream(dev, type)
547 {
548 _linked_to_1608 = linkedToRk1608;
549 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKSofEventStream constructed");
550 }
551
552 //RKSofEventStream::RKSofEventStream (const char *name, int type)
553 // :RKStream(name, type)
554 //{
555 // LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKSofEventStream constructed");
556 //}
557
~RKSofEventStream()558 RKSofEventStream::~RKSofEventStream()
559 {
560 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "~RKSofEventStream destructed");
561 }
562
563 void
start()564 RKSofEventStream::start()
565 {
566 _subdev->start(_dev_prepared);
567 _poll_thread->setCamPhyId(mCamPhyId);
568 _poll_thread->start();
569 _subdev->subscribe_event(V4L2_EVENT_FRAME_SYNC);
570 if (_linked_to_1608) {
571 if (!_is_subscribed.load()) {
572 _subdev->subscribe_event(V4L2_EVENT_RESET_DEV);
573 _is_subscribed.store(true);
574 }
575 } else {
576 _subdev->subscribe_event(V4L2_EVENT_RESET_DEV);
577 }
578 }
579
580 void
stop()581 RKSofEventStream::stop()
582 {
583 _poll_thread->stop();
584 _subdev->unsubscribe_event(V4L2_EVENT_FRAME_SYNC);
585 if (_linked_to_1608) {
586 if (_is_subscribed.load()) {
587 _subdev->unsubscribe_event(V4L2_EVENT_RESET_DEV);
588 _is_subscribed.store(false);
589 }
590 } else {
591 _subdev->unsubscribe_event(V4L2_EVENT_RESET_DEV);
592 }
593 _subdev->stop();
594 }
595
596 SmartPtr<VideoBuffer>
new_video_buffer(struct v4l2_event & event,SmartPtr<V4l2Device> dev)597 RKSofEventStream::new_video_buffer(struct v4l2_event &event,
598 SmartPtr<V4l2Device> dev)
599 {
600 ENTER_CAMHW_FUNCTION();
601 SmartPtr<VideoBuffer> video_buf = nullptr;
602 int64_t tv_sec = event.timestamp.tv_sec;
603 int64_t tv_nsec = event.timestamp.tv_nsec;
604 int exp_id = event.u.frame_sync.frame_sequence;
605 SmartPtr<SofEventData> evtdata = new SofEventData();
606 evtdata->_timestamp = tv_sec * 1000 * 1000 * 1000 + tv_nsec;
607 evtdata->_frameid = exp_id;
608
609 video_buf = new SofEventBuffer(evtdata, dev);
610 if (event.type == V4L2_EVENT_RESET_DEV) {
611 if (_linked_to_1608) {
612 video_buf->_buf_type = VICAP_WITH_RK1608_RESET_EVT;
613 } else
614 video_buf->_buf_type = VICAP_RESET_EVT;
615 } else {
616 video_buf->_buf_type = _dev_type;
617 }
618 video_buf->set_sequence (exp_id);
619 EXIT_CAMHW_FUNCTION();
620
621 return video_buf;
622 }
623
624 /*--------------------Output stream---------------------------*/
625
RKRawStream(SmartPtr<V4l2Device> dev,int index,int type)626 RKRawStream::RKRawStream (SmartPtr<V4l2Device> dev, int index, int type)
627 :RKStream(dev, type)
628 ,_dev_index(index)
629 {
630 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKRawStream constructed");
631 }
632
~RKRawStream()633 RKRawStream::~RKRawStream()
634 {
635 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "~RKRawStream destructed");
636 }
637
638 SmartPtr<V4l2BufferProxy>
new_v4l2proxy_buffer(SmartPtr<V4l2Buffer> buf,SmartPtr<V4l2Device> dev)639 RKRawStream::new_v4l2proxy_buffer(SmartPtr<V4l2Buffer> buf,
640 SmartPtr<V4l2Device> dev)
641 {
642 ENTER_CAMHW_FUNCTION();
643 SmartPtr<V4l2BufferProxy> buf_proxy = new V4l2BufferProxy(buf, dev);
644 buf_proxy->_buf_type = _dev_type;
645 EXIT_CAMHW_FUNCTION();
646
647 return buf_proxy;
648 }
649
650 SmartPtr<VideoBuffer>
new_video_buffer(SmartPtr<V4l2Buffer> buf,SmartPtr<V4l2Device> dev)651 RKRawStream::new_video_buffer(SmartPtr<V4l2Buffer> buf,
652 SmartPtr<V4l2Device> dev)
653 {
654 ENTER_CAMHW_FUNCTION();
655 buf->set_reserved((uintptr_t)_reserved);
656 SmartPtr<VideoBuffer> video_buf = new V4l2BufferProxy(buf, dev);
657 video_buf->_buf_type = _dev_type;
658 EXIT_CAMHW_FUNCTION();
659
660 return video_buf;
661 }
662
663 void
set_reserved_data(int bpp)664 RKRawStream::set_reserved_data(int bpp)
665 {
666 _bpp = bpp;
667 _reserved[0] = _dev_index;
668 _reserved[1] = bpp;
669 }
670
RKPdafStream(SmartPtr<V4l2Device> dev,int type)671 RKPdafStream::RKPdafStream (SmartPtr<V4l2Device> dev, int type)
672 :RKStream(dev, type)
673 {
674 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "RKRawStream constructed");
675 }
676
~RKPdafStream()677 RKPdafStream::~RKPdafStream()
678 {
679 LOGD_CAMHW_SUBM(ISP20HW_SUBM, "~RKRawStream destructed");
680 }
681
682 SmartPtr<V4l2BufferProxy>
new_v4l2proxy_buffer(SmartPtr<V4l2Buffer> buf,SmartPtr<V4l2Device> dev)683 RKPdafStream::new_v4l2proxy_buffer(SmartPtr<V4l2Buffer> buf,
684 SmartPtr<V4l2Device> dev)
685 {
686 ENTER_CAMHW_FUNCTION();
687 SmartPtr<PdafBufferProxy> buf_proxy = new PdafBufferProxy(buf, dev);
688 buf_proxy->_buf_type = _dev_type;
689 EXIT_CAMHW_FUNCTION();
690
691 return buf_proxy;
692 }
693
694 } //namspace RkCam
695