1 /* 2 * Copyright (c) 2021 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 #ifndef _RAW_STREAM_PROC_UNIT_H_ 18 #define _RAW_STREAM_PROC_UNIT_H_ 19 #include <v4l2_device.h> 20 #include "poll_thread.h" 21 #include "xcam_mutex.h" 22 #include "Stream.h" 23 #include "rk_aiq_offline_raw.h" 24 #include "rk_vi_user_api2_stream_cfg.h" 25 #include <map> 26 27 using namespace XCam; 28 29 namespace RkRawStream { 30 31 typedef void (*isp_trigger_readback_callback)(void *tg); 32 33 #ifndef ANDROID_OS 34 typedef void (*user_isp_process_done_callback)(int dev_index); 35 #else 36 typedef std::function<void(int dev_index)> user_isp_process_done_callback; 37 #endif 38 39 int _parse_rk_rawdata(void *rawdata, rkrawstream_rkraw2_t *rkraw2); 40 41 class CamHwIsp20; 42 class EmptyClass; 43 class RawProcThread; 44 45 class SimpleFdBuf 46 { 47 public: 48 int _fd; 49 int _index; 50 int _seq; 51 uint64_t _ts; 52 uint8_t *_userptr; SimpleFdBuf(int fd,int index)53 SimpleFdBuf(int fd, int index) {_fd = fd; _index = index;} SimpleFdBuf()54 SimpleFdBuf() {_fd = 0; _userptr = NULL;} 55 // ~EmptyClass() {} 56 }; 57 58 class RawStreamProcUnit : public PollCallback 59 { 60 public: 61 //explicit RawStreamProcUnit (char *ispdev, char *dev0, char *dev1, char *dev2, bool linked_to_isp); 62 explicit RawStreamProcUnit (const rk_sensor_full_info_t *s_info, uint8_t is_offline); 63 virtual ~RawStreamProcUnit (); 64 virtual XCamReturn start (); 65 virtual XCamReturn stop (); 66 XCamReturn prepare(int idx, uint8_t buf_memory_type, uint8_t buf_cnt); 67 void set_working_mode (int mode); 68 void set_rx_format(uint32_t width, uint32_t height, uint32_t pix_fmt, int mode); 69 void setup_pipeline_fmt(uint32_t width, uint32_t height); 70 void set_rx_devices(); 71 SmartPtr<V4l2Device> _mipi_rx_devs[3]; 72 /* 73 74 75 SmartPtr<V4l2Device> get_rx_device (int index); 76 void set_rx_format (const struct v4l2_subdev_format& sns_sd_fmt, uint32_t sns_v4l_pix_fmt); 77 void set_rx_format (const struct v4l2_subdev_selection& sns_sd_sel, uint32_t sns_v4l_pix_fmt); 78 void set_devices (SmartPtr<V4l2SubDevice> ispdev, CamHwIsp20* handle); 79 void set_hdr_frame_readback_infos(int frame_id, int times); 80 void set_hdr_global_tmo_mode(int frame_id, bool mode); 81 82 void notify_sof(uint64_t time, int frameid); 83 */ 84 void send_sync_buf(SmartPtr<V4l2BufferProxy> &buf_s, SmartPtr<V4l2BufferProxy> &buf_m, SmartPtr<V4l2BufferProxy> &buf_l); 85 void send_sync_buf2(uint8_t *rkraw_data); 86 void _send_sync_buf(rkrawstream_rkraw2_t *rkraw2); 87 bool raw_buffer_proc(); setMulCamConc(bool cc)88 void setMulCamConc(bool cc) { 89 _is_multi_cam_conc = cc; 90 } 91 enum { 92 ISP_MIPI_HDR_S = 0, 93 ISP_MIPI_HDR_M, 94 ISP_MIPI_HDR_L, 95 ISP_MIPI_HDR_MAX, 96 }; 97 // notify CamHwIsp one frame has been processed setPollCallback(PollCallback * cb)98 void setPollCallback(PollCallback* cb) { _PollCallback = cb; } 99 // from PollCallback poll_buffer_ready(SmartPtr<VideoBuffer> & buf,int type)100 virtual XCamReturn poll_buffer_ready (SmartPtr<VideoBuffer> &buf, int type) { return XCAM_RETURN_ERROR_FAILED; } poll_buffer_failed(int64_t timestamp,const char * msg)101 virtual XCamReturn poll_buffer_failed (int64_t timestamp, const char *msg) { return XCAM_RETURN_ERROR_FAILED; } poll_buffer_ready(SmartPtr<VideoBuffer> & buf)102 virtual XCamReturn poll_buffer_ready (SmartPtr<VideoBuffer> &buf) { return XCAM_RETURN_ERROR_FAILED; } 103 virtual XCamReturn poll_buffer_ready (SmartPtr<V4l2BufferProxy> &buf, int dev_index); poll_event_ready(uint32_t sequence,int type)104 virtual XCamReturn poll_event_ready (uint32_t sequence, int type) { return XCAM_RETURN_ERROR_FAILED; } poll_event_failed(int64_t timestamp,const char * msg)105 virtual XCamReturn poll_event_failed (int64_t timestamp, const char *msg) { return XCAM_RETURN_ERROR_FAILED; } setCamPhyId(int phyId)106 void setCamPhyId(int phyId) { 107 mCamPhyId = phyId; 108 } 109 user_isp_process_done_callback user_isp_process_done_cb; 110 /* 111 XCamReturn capture_raw_ctl(capture_raw_t type, int count = 0, const char* capture_dir = nullptr, char* output_dir = nullptr) { 112 if (!_rawCap) 113 return XCAM_RETURN_ERROR_FAILED; 114 return _rawCap->capture_raw_ctl(type, count, capture_dir, output_dir); 115 } 116 117 XCamReturn notify_capture_raw() { 118 if (!_rawCap) 119 return XCAM_RETURN_ERROR_FAILED; 120 return _rawCap->notify_capture_raw(); 121 } 122 */ 123 124 //isp_trigger_readback_callback isp_trigger_readback_cb; 125 //void set_isp_trigger_readback_callback(isp_trigger_readback_callback cb) { 126 // isp_trigger_readback_cb = cb; 127 //} 128 //SmartPtr<V4l2Device> _return_dev[3]; 129 protected: 130 XCAM_DEAD_COPY (RawStreamProcUnit); 131 132 void trigger_isp_readback (); 133 void match_lumadetect_map (uint32_t sequence, sint32_t &additional_times); 134 void match_globaltmostate_map(uint32_t sequence, bool &isHdrGlobalTmo); 135 XCamReturn match_sof_timestamp_map(sint32_t sequence, uint64_t ×tamp); 136 int mCamPhyId; 137 char _sns_name[32]; 138 protected: 139 SmartPtr<V4l2Device> _dev[3]; 140 int _dev_index[3]; 141 SmartPtr<RKStream> _stream[3]; 142 int _working_mode; 143 int _mipi_dev_max; 144 bool _is_multi_cam_conc; 145 146 147 Mutex _buf_mutex; 148 std::map<uint32_t, int> _isp_hdr_fid2times_map; 149 std::map<uint32_t, bool> _isp_hdr_fid2ready_map; 150 std::map<uint32_t, bool> _hdr_global_tmo_state_map; 151 std::map<sint32_t, uint64_t> _sof_timestamp_map; 152 153 SafeList<V4l2BufferProxy> buf_list[3]; 154 SafeList<V4l2BufferProxy> cache_list[3]; 155 SafeList<SimpleFdBuf> cache_list2[3]; 156 157 SmartPtr<RawProcThread> _raw_proc_thread; 158 //CamHwIsp20* _camHw; 159 SmartPtr<V4l2SubDevice> _isp_core_dev; 160 SmartPtr<V4l2Device> dummy_dev; 161 bool _first_trigger; 162 Mutex _mipi_trigger_mutex; 163 SafeList<EmptyClass> _msg_queue; 164 PollCallback* _PollCallback; 165 enum v4l2_memory _memory_type; 166 167 int _offline_index; 168 int _offline_seq; 169 //CaptureRawData* _rawCap; 170 bool is_multi_isp_mode; 171 uint8_t _is_offline_mode; 172 int _width; 173 int _height; 174 uint8_t *_rawbuffer[3]; 175 176 }; 177 178 class RawProcThread 179 : public Thread 180 { 181 public: RawProcThread(RawStreamProcUnit * handle)182 RawProcThread (RawStreamProcUnit *handle) 183 : Thread ("RawProcThread") 184 , _handle (handle) 185 {} 186 187 protected: loop()188 virtual bool loop () { 189 return _handle->raw_buffer_proc (); 190 } 191 192 private: 193 RawStreamProcUnit *_handle; 194 }; 195 196 class EmptyClass 197 { 198 public: EmptyClass()199 EmptyClass() {} ~EmptyClass()200 ~EmptyClass() {} 201 }; 202 } 203 #endif 204 205 206