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 #ifndef _STREAM_H_ 18 #define _STREAM_H_ 19 #include <sys/mman.h> 20 #include <v4l2_device.h> 21 #include "poll_thread.h" 22 #include "xcam_mutex.h" 23 24 using namespace XCam; 25 26 namespace RkRawStream { 27 28 #define LOGD_RKSTREAM(...) XCAM_MODULE_LOG_DEBUG(XCORE_LOG_MODULE_RKRAWSTREAM, 0xff, ##__VA_ARGS__) 29 #define LOGI_RKSTREAM(...) XCAM_MODULE_LOG_INFO(XCORE_LOG_MODULE_RKRAWSTREAM, 0xff, ##__VA_ARGS__) 30 #define LOGW_RKSTREAM(...) XCAM_MODULE_LOG_WARNING(XCORE_LOG_MODULE_RKRAWSTREAM, 0xff, ##__VA_ARGS__) 31 #define LOGE_RKSTREAM(...) XCAM_MODULE_LOG_ERROR(XCORE_LOG_MODULE_RKRAWSTREAM, 0xff, ##__VA_ARGS__) 32 33 class RkPollThread; 34 35 class RKStream 36 { 37 public: 38 RKStream (SmartPtr<V4l2Device> dev, int type); 39 RKStream (SmartPtr<V4l2SubDevice> dev, int type); 40 RKStream (const char *path, int type); 41 virtual ~RKStream (); 42 virtual void start (); 43 virtual void startThreadOnly (); 44 virtual void startDeviceOnly (); 45 virtual void stop (); 46 virtual void stopThreadOnly (); 47 virtual void stopDeviceOnly (); 48 virtual void stopDeviceStreamoff (); 49 virtual void stopDeviceFreebuffer (); 50 virtual void pause (); 51 virtual void resume (); 52 virtual bool setPollCallback (PollCallback *callback); 53 virtual SmartPtr<VideoBuffer> 54 new_video_buffer(SmartPtr<V4l2Buffer> buf, SmartPtr<V4l2Device> dev); 55 virtual SmartPtr<VideoBuffer> new_video_buffer(struct v4l2_event & event,SmartPtr<V4l2Device> dev)56 new_video_buffer(struct v4l2_event &event, SmartPtr<V4l2Device> dev) { return NULL; } 57 virtual SmartPtr<V4l2BufferProxy> new_v4l2proxy_buffer(SmartPtr<V4l2Buffer> buf,SmartPtr<V4l2Device> dev)58 new_v4l2proxy_buffer(SmartPtr<V4l2Buffer> buf, SmartPtr<V4l2Device> dev) { return NULL; } 59 void set_device_prepared(bool prepare); 60 XCamReturn virtual getFormat(struct v4l2_format &format); 61 XCamReturn virtual getFormat(struct v4l2_subdev_format &format); 62 protected: 63 XCAM_DEAD_COPY (RKStream); 64 protected: 65 static const char* poll_type_to_str[ISP_POLL_POST_MAX]; 66 SmartPtr<V4l2Device> _dev; 67 SmartPtr<V4l2SubDevice> _subdev; 68 int _dev_type; 69 SmartPtr<RkPollThread> _poll_thread; 70 bool _dev_prepared; 71 }; 72 73 class RkPollThread : public Thread 74 { 75 public: 76 explicit RkPollThread (const char* thName, int type, SmartPtr<V4l2Device> dev, RKStream *stream); 77 explicit RkPollThread (const char* thName, int type, SmartPtr<V4l2SubDevice> dev, RKStream *stream); 78 virtual ~RkPollThread (); 79 virtual bool setPollCallback (PollCallback *callback); 80 virtual XCamReturn start(); 81 virtual XCamReturn stop (); 82 protected: 83 XCAM_DEAD_COPY (RkPollThread); 84 XCamReturn poll_buffer_loop (); loop()85 virtual bool loop () { 86 XCamReturn ret = poll_buffer_loop (); 87 if (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_ERROR_TIMEOUT || 88 ret == XCAM_RETURN_BYPASS) 89 return true; 90 return false; 91 } 92 XCamReturn create_stop_fds (); 93 void destroy_stop_fds (); 94 protected: 95 static const int default_poll_timeout; 96 SmartPtr<V4l2Device> _dev; 97 SmartPtr<V4l2SubDevice> _subdev; 98 PollCallback *_poll_callback; 99 RKStream *_stream; 100 //frame syncronization 101 int frameid; 102 int _dev_type; 103 int _poll_stop_fd[2]; 104 }; 105 106 class RkEventPollThread : public RkPollThread 107 { 108 public: 109 explicit RkEventPollThread (const char* thName, int type, SmartPtr<V4l2Device> dev, RKStream *stream); 110 explicit RkEventPollThread (const char* thName, int type, SmartPtr<V4l2SubDevice> subdev, RKStream *stream); 111 virtual ~RkEventPollThread (); 112 protected: 113 XCAM_DEAD_COPY (RkEventPollThread); 114 virtual XCamReturn poll_event_loop (); loop()115 virtual bool loop () { 116 XCamReturn ret = poll_event_loop (); 117 if (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_ERROR_TIMEOUT || 118 XCAM_RETURN_BYPASS) 119 return true; 120 return false; 121 } 122 //SmartPtr<V4l2SubDevice> _subdev; 123 struct v4l2_event _event; 124 }; 125 126 class RKRawStream : public RKStream 127 { 128 public: 129 RKRawStream (SmartPtr<V4l2Device> dev, int index, int type); 130 virtual ~RKRawStream (); 131 virtual SmartPtr<V4l2BufferProxy> 132 new_v4l2proxy_buffer(SmartPtr<V4l2Buffer> buf, SmartPtr<V4l2Device> dev); 133 public: 134 int _dev_index; 135 protected: 136 XCAM_DEAD_COPY (RKRawStream); 137 }; 138 139 /* 140 class RKStream 141 { 142 public: 143 RKStream (SmartPtr<V4l2Device> dev, int type); 144 RKStream (SmartPtr<V4l2SubDevice> dev, int type); 145 RKStream (const char *path, int type); 146 virtual ~RKStream (); 147 virtual void start (); 148 virtual void startThreadOnly (); 149 virtual void startDeviceOnly (); 150 virtual void stop (); 151 virtual void stopThreadOnly (); 152 virtual void stopDeviceOnly (); 153 virtual void pause (); 154 virtual void resume (); 155 virtual bool setPollCallback (PollCallback *callback); 156 virtual SmartPtr<VideoBuffer> 157 new_video_buffer(SmartPtr<V4l2Buffer> buf, SmartPtr<V4l2Device> dev); 158 virtual SmartPtr<VideoBuffer> 159 new_video_buffer(struct v4l2_event &event, SmartPtr<V4l2Device> dev) { return NULL; } 160 virtual SmartPtr<V4l2BufferProxy> 161 new_v4l2proxy_buffer(SmartPtr<V4l2Buffer> buf, SmartPtr<V4l2Device> dev) { return NULL; } 162 void set_device_prepared(bool prepare); 163 XCamReturn virtual getFormat(struct v4l2_format &format); 164 XCamReturn virtual getFormat(struct v4l2_subdev_format &format); 165 protected: 166 XCAM_DEAD_COPY (RKStream); 167 protected: 168 static const char* poll_type_to_str[ISP_POLL_POST_MAX]; 169 SmartPtr<V4l2Device> _dev; 170 SmartPtr<V4l2SubDevice> _subdev; 171 int _dev_type; 172 SmartPtr<RkPollThread> _poll_thread; 173 bool _dev_prepared; 174 }; 175 176 class BaseSensorHw; 177 class LensHw; 178 class RKStatsStream : public RKStream 179 { 180 public: 181 RKStatsStream (SmartPtr<V4l2Device> dev, int type); 182 // RKStatsStream (const char *name, int type); 183 virtual ~RKStatsStream (); 184 bool set_event_handle_dev(SmartPtr<BaseSensorHw> &dev); 185 bool set_iris_handle_dev(SmartPtr<LensHw> &dev); 186 bool set_focus_handle_dev(SmartPtr<LensHw> &dev); 187 bool set_rx_handle_dev(CamHwIsp20* dev); 188 virtual SmartPtr<VideoBuffer> 189 new_video_buffer(SmartPtr<V4l2Buffer> buf, SmartPtr<V4l2Device> dev); 190 protected: 191 XCAM_DEAD_COPY (RKStatsStream); 192 private: 193 //alliance devices 194 SmartPtr<BaseSensorHw> _event_handle_dev; 195 SmartPtr<LensHw> _iris_handle_dev; 196 SmartPtr<LensHw> _focus_handle_dev; 197 CamHwIsp20* _rx_handle_dev; 198 }; 199 200 class SubVideoBuffer : public VideoBuffer 201 { 202 public: 203 explicit SubVideoBuffer(int num, int index, int fd, const VideoBufferInfo& info) 204 : VideoBuffer(info) { 205 _buff_num = num; 206 _buff_idx = index; 207 _buff_fd = fd; 208 _buff_size = 0; 209 _buff_ptr = MAP_FAILED; 210 _v4l2buf_proxy = nullptr; 211 } 212 explicit SubVideoBuffer(int fd) 213 :VideoBuffer() 214 { 215 _buff_fd = fd; 216 _buff_size = 0; 217 _buff_ptr = MAP_FAILED; 218 _v4l2buf_proxy = nullptr; 219 } 220 explicit SubVideoBuffer(SmartPtr<V4l2BufferProxy> &buf) 221 :VideoBuffer() 222 { 223 _buff_fd = -1; 224 _buff_size = 0; 225 _buff_ptr = MAP_FAILED; 226 _v4l2buf_proxy = buf; 227 } 228 explicit SubVideoBuffer() 229 :VideoBuffer() 230 { 231 _buff_fd = -1; 232 _buff_size = 0; 233 _buff_ptr = MAP_FAILED; 234 _v4l2buf_proxy = nullptr; 235 } 236 virtual ~SubVideoBuffer() {} 237 virtual uint8_t *map () 238 { 239 if (_v4l2buf_proxy.ptr()) { 240 return (uint8_t *)_v4l2buf_proxy->get_v4l2_userptr(); 241 } 242 243 if (_buff_ptr == MAP_FAILED) { 244 _buff_ptr = mmap (NULL, _buff_size ? _buff_size: get_size (), PROT_READ | PROT_WRITE, MAP_SHARED, _buff_fd, 0); 245 if (_buff_ptr == MAP_FAILED) { 246 LOGE("mmap failed, size=%d,fd=%d",_buff_size,_buff_fd); 247 return nullptr; 248 } 249 } 250 return (uint8_t *)_buff_ptr; 251 } 252 virtual bool unmap () 253 { 254 if (_v4l2buf_proxy.ptr()) { 255 return true; 256 } 257 258 if (_buff_ptr != MAP_FAILED) { 259 munmap(_buff_ptr, _buff_size ? _buff_size: get_size ()); 260 _buff_ptr = MAP_FAILED; 261 } 262 return true; 263 } 264 virtual int get_fd () 265 { 266 if (_v4l2buf_proxy.ptr()) { 267 return _v4l2buf_proxy->get_expbuf_fd(); 268 } 269 return _buff_fd; 270 } 271 int set_buff_info(int fd, int size) 272 { 273 _buff_fd = fd; 274 _buff_size = size; 275 return 0; 276 } 277 278 int get_buf_num() { return _buff_num; } 279 280 int get_index() { return _buff_idx; } 281 282 int get_size() { return _buff_size; } 283 284 protected: 285 XCAM_DEAD_COPY (SubVideoBuffer); 286 private: 287 int _buff_fd; 288 int _buff_size; 289 int _buff_idx; 290 int _buff_num; 291 void *_buff_ptr; 292 SmartPtr<V4l2BufferProxy> _v4l2buf_proxy; 293 }; 294 295 class SubV4l2BufferProxy : public V4l2BufferProxy 296 { 297 public: 298 explicit SubV4l2BufferProxy(SmartPtr<V4l2Buffer> &buf, SmartPtr<V4l2Device> &device) 299 :V4l2BufferProxy(buf, device) 300 { 301 _buff_ptr = MAP_FAILED; 302 _buff_fd = -1; 303 _buff_size = 0; 304 } 305 virtual ~SubV4l2BufferProxy() {} 306 virtual uint8_t *map () 307 { 308 if (_buff_ptr == MAP_FAILED) { 309 _buff_ptr = mmap (NULL, _buff_size ? _buff_size: get_size (), PROT_READ | PROT_WRITE, MAP_SHARED, _buff_fd, 0); 310 if (_buff_ptr == MAP_FAILED) { 311 LOGE("mmap failed, size=%d,fd=%d",_buff_size,_buff_fd); 312 return nullptr; 313 } 314 } 315 return (uint8_t *)_buff_ptr; 316 } 317 virtual bool unmap () 318 { 319 if (_buff_ptr != MAP_FAILED) { 320 munmap(_buff_ptr, _buff_size ? _buff_size: get_size ()); 321 _buff_ptr = MAP_FAILED; 322 } 323 return true; 324 } 325 virtual int get_fd () 326 { 327 return _buff_fd; 328 } 329 int set_buff_info(int fd, int size) 330 { 331 _buff_fd = fd; 332 _buff_size = size; 333 return 0; 334 } 335 protected: 336 XCAM_DEAD_COPY (SubV4l2BufferProxy); 337 int _buff_fd; 338 int _buff_size; 339 void *_buff_ptr; 340 }; 341 */ 342 } 343 #endif 344