1 /* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved. 2 * 3 * Redistribution and use in source and binary forms, with or without 4 * modification, are permitted provided that the following conditions are 5 * met: 6 * * Redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above 9 * copyright notice, this list of conditions and the following 10 * disclaimer in the documentation and/or other materials provided 11 * with the distribution. 12 * * Neither the name of The Linux Foundation nor the names of its 13 * contributors may be used to endorse or promote products derived 14 * from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 */ 29 30 #ifndef __QCAMERA3_CHANNEL_H__ 31 #define __QCAMERA3_CHANNEL_H__ 32 33 // System dependencies 34 #include <utils/List.h> 35 #include <utils/Mutex.h> 36 #include <utils/Vector.h> 37 #include "gralloc_priv.h" 38 39 // Camera dependencies 40 #include "cam_intf.h" 41 #include "cam_types.h" 42 #include "hardware/camera3.h" 43 #include "QCamera3HALHeader.h" 44 #include "QCamera3Mem.h" 45 #include "QCamera3PostProc.h" 46 #include "QCamera3Stream.h" 47 #include "QCamera3StreamMem.h" 48 49 extern "C" { 50 #include "mm_camera_interface.h" 51 #include "mm_jpeg_interface.h" 52 } 53 54 using namespace android; 55 56 #define MIN_STREAMING_BUFFER_NUM 7+11 57 58 #define QCAMERA_DUMP_FRM_PREVIEW 1 59 #define QCAMERA_DUMP_FRM_VIDEO (1<<1) 60 #define QCAMERA_DUMP_FRM_INPUT_JPEG (1<<2) 61 #define QCAMERA_DUMP_FRM_CALLBACK (1<<3) 62 #define QCAMERA_DUMP_FRM_OUTPUT_JPEG (1<<5) 63 #define QCAMERA_DUMP_FRM_INPUT_REPROCESS (1<<6) 64 65 typedef int64_t nsecs_t; 66 67 namespace qcamera { 68 69 typedef void (*channel_cb_routine)(mm_camera_super_buf_t *metadata, 70 camera3_stream_buffer_t *buffer, 71 uint32_t frame_number, bool isInputBuffer, 72 void *userdata); 73 74 typedef void (*channel_cb_buffer_err)(QCamera3Channel* ch, uint32_t frameNumber, 75 camera3_buffer_status_t err, 76 void *userdata); 77 78 class QCamera3Channel 79 { 80 public: 81 QCamera3Channel(uint32_t cam_handle, 82 uint32_t channel_handle, 83 mm_camera_ops_t *cam_ops, 84 channel_cb_routine cb_routine, 85 channel_cb_buffer_err cb_buf_err, 86 cam_padding_info_t *paddingInfo, 87 cam_feature_mask_t postprocess_mask, 88 void *userData, uint32_t numBuffers); 89 virtual ~QCamera3Channel(); 90 91 virtual int32_t start(); 92 virtual int32_t stop(); 93 virtual int32_t setBatchSize(uint32_t); 94 virtual int32_t queueBatchBuf(); 95 virtual int32_t setPerFrameMapUnmap(bool enable); 96 int32_t bufDone(mm_camera_super_buf_t *recvd_frame); 97 int32_t setBundleInfo(const cam_bundle_config_t &bundleInfo); 98 99 virtual uint32_t getStreamTypeMask(); 100 uint32_t getStreamID(uint32_t streamMask); 101 void destroy(); 102 virtual int32_t initialize(cam_is_type_t isType) = 0; request(buffer_handle_t *,uint32_t,int &)103 virtual int32_t request(buffer_handle_t * /*buffer*/, 104 uint32_t /*frameNumber*/, 105 int &/*indexUsed*/){ return 0;}; 106 virtual int32_t request(buffer_handle_t * /*buffer*/, 107 uint32_t /*frameNumber*/, 108 camera3_stream_buffer_t* /*pInputBuffer*/, 109 metadata_buffer_t* /*metadata*/, 110 int & /*indexUsed*/, 111 __unused bool internalRequest = false, 112 __unused bool meteringOnly = false){ return 0;}; 113 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 114 QCamera3Stream *stream) = 0; 115 116 virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType) = 0; 117 virtual QCamera3StreamMem *getStreamBufs(uint32_t len) = 0; 118 virtual void putStreamBufs() = 0; 119 virtual int32_t flush(); 120 121 QCamera3Stream *getStreamByHandle(uint32_t streamHandle); getMyHandle()122 uint32_t getMyHandle() const {return m_handle;}; getNumOfStreams()123 uint32_t getNumOfStreams() const {return m_numStreams;}; getNumBuffers()124 uint32_t getNumBuffers() const {return mNumBuffers;}; 125 QCamera3Stream *getStreamByIndex(uint32_t index); 126 127 static void streamCbRoutine(mm_camera_super_buf_t *super_frame, 128 QCamera3Stream *stream, void *userdata); 129 void dumpYUV(mm_camera_buf_def_t *frame, cam_dimension_t dim, 130 cam_frame_len_offset_t offset, uint8_t name); 131 bool isUBWCEnabled(); 132 cam_format_t getStreamDefaultFormat(cam_stream_type_t type, 133 uint32_t width, uint32_t height); 134 virtual int32_t timeoutFrame(__unused uint32_t frameNumber) = 0; 135 136 void *mUserData; 137 cam_padding_info_t mPaddingInfo; 138 QCamera3Stream *mStreams[MAX_STREAM_NUM_IN_BUNDLE]; 139 uint32_t m_numStreams; 140 protected: 141 142 int32_t addStream(cam_stream_type_t streamType, 143 cam_format_t streamFormat, 144 cam_dimension_t streamDim, 145 cam_rotation_t streamRotation, 146 uint8_t minStreamBufnum, 147 cam_feature_mask_t postprocessMask, 148 cam_is_type_t isType, 149 uint32_t batchSize = 0); 150 151 int32_t allocateStreamInfoBuf(camera3_stream_t *stream); 152 153 uint32_t m_camHandle; 154 mm_camera_ops_t *m_camOps; 155 bool m_bIsActive; 156 157 uint32_t m_handle; 158 159 160 mm_camera_buf_notify_t mDataCB; 161 162 163 QCamera3HeapMemory *mStreamInfoBuf; 164 channel_cb_routine mChannelCB; 165 channel_cb_buffer_err mChannelCbBufErr; 166 //cam_padding_info_t *mPaddingInfo; 167 cam_feature_mask_t mPostProcMask; 168 uint32_t mYUVDump; 169 cam_is_type_t mIsType; 170 uint32_t mNumBuffers; 171 /* Enable unmapping of buffer before issuing buffer callback. Default value 172 * for this flag is true and is selectively set to false for the usecases 173 * such as HFR to avoid any performance hit due to mapping/unmapping */ 174 bool mPerFrameMapUnmapEnable; 175 uint32_t mFrmNum; 176 uint32_t mDumpFrmCnt; 177 uint32_t mSkipMode; 178 uint32_t mDumpSkipCnt; 179 }; 180 181 /* QCamera3ProcessingChannel is used to handle all streams that are directly 182 * generated by hardware and given to frameworks without any postprocessing at HAL. 183 * It also handles input streams that require reprocessing by hardware and then 184 * returned to frameworks. */ 185 class QCamera3ProcessingChannel : public QCamera3Channel 186 { 187 public: 188 QCamera3ProcessingChannel(uint32_t cam_handle, 189 uint32_t channel_handle, 190 mm_camera_ops_t *cam_ops, 191 channel_cb_routine cb_routine, 192 channel_cb_buffer_err cb_buffer_err, 193 cam_padding_info_t *paddingInfo, 194 void *userData, 195 camera3_stream_t *stream, 196 cam_stream_type_t stream_type, 197 cam_feature_mask_t postprocess_mask, 198 QCamera3Channel *metadataChannel, 199 uint32_t numBuffers = MAX_INFLIGHT_REQUESTS); 200 201 ~QCamera3ProcessingChannel(); 202 203 virtual int32_t initialize(cam_is_type_t isType); 204 virtual int32_t request(buffer_handle_t *buffer, 205 uint32_t frameNumber, 206 camera3_stream_buffer_t* pInputBuffer, 207 metadata_buffer_t* metadata, int &indexUsed, 208 __unused bool internalRequest, __unused bool meteringOnly); 209 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 210 QCamera3Stream *stream); 211 virtual QCamera3StreamMem *getStreamBufs(uint32_t len); 212 virtual void putStreamBufs(); 213 virtual int32_t registerBuffer(buffer_handle_t *buffer, cam_is_type_t isType); 214 215 virtual int32_t stop(); 216 217 virtual reprocess_type_t getReprocessType() = 0; 218 219 virtual void reprocessCbRoutine(buffer_handle_t *resultBuffer, 220 uint32_t resultFrameNumber); 221 222 int32_t queueReprocMetadata(mm_camera_super_buf_t *metadata); 223 int32_t metadataBufDone(mm_camera_super_buf_t *recvd_frame); 224 int32_t translateStreamTypeAndFormat(camera3_stream_t *stream, 225 cam_stream_type_t &streamType, 226 cam_format_t &streamFormat); 227 int32_t setReprocConfig(reprocess_config_t &reproc_cfg, 228 camera3_stream_buffer_t *pInputBuffer, 229 metadata_buffer_t *metadata, 230 cam_format_t streamFormat, cam_dimension_t dim); 231 int32_t setFwkInputPPData(qcamera_fwk_input_pp_data_t *src_frame, 232 camera3_stream_buffer_t *pInputBuffer, 233 reprocess_config_t *reproc_cfg, 234 metadata_buffer_t *metadata, 235 buffer_handle_t *output_buffer, 236 uint32_t frameNumber); 237 int32_t checkStreamCbErrors(mm_camera_super_buf_t *super_frame, 238 QCamera3Stream *stream); 239 int32_t getStreamSize(cam_dimension_t &dim); 240 virtual int32_t timeoutFrame(uint32_t frameNumber); 241 242 QCamera3PostProcessor m_postprocessor; // post processor 243 void showDebugFPS(int32_t streamType); 244 245 protected: 246 uint8_t mDebugFPS; 247 int mFrameCount; 248 int mLastFrameCount; 249 nsecs_t mLastFpsTime; isWNREnabled()250 bool isWNREnabled() {return m_bWNROn;}; 251 void startPostProc(const reprocess_config_t &reproc_cfg); 252 void issueChannelCb(buffer_handle_t *resultBuffer, 253 uint32_t resultFrameNumber); 254 int32_t releaseOfflineMemory(uint32_t resultFrameNumber); 255 256 QCamera3StreamMem mMemory; //output buffer allocated by fwk 257 camera3_stream_t *mCamera3Stream; 258 uint32_t mNumBufs; 259 cam_stream_type_t mStreamType; 260 cam_format_t mStreamFormat; 261 uint8_t mIntent; 262 263 bool mPostProcStarted; 264 bool mInputBufferConfig; // Set when the processing channel is configured 265 // for processing input(framework) buffers 266 267 QCamera3Channel *m_pMetaChannel; 268 mm_camera_super_buf_t *mMetaFrame; 269 QCamera3StreamMem mOfflineMemory; //reprocessing input buffer 270 QCamera3StreamMem mOfflineMetaMemory; //reprocessing metadata buffer 271 List<uint32_t> mFreeOfflineMetaBuffersList; 272 Mutex mFreeOfflineMetaBuffersLock; 273 android::List<mm_camera_super_buf_t *> mOutOfSequenceBuffers; 274 275 private: 276 277 bool m_bWNROn; 278 }; 279 280 /* QCamera3RegularChannel is used to handle all streams that are directly 281 * generated by hardware and given to frameworks without any postprocessing at HAL. 282 * Examples are: all IMPLEMENTATION_DEFINED streams, CPU_READ streams. */ 283 class QCamera3RegularChannel : public QCamera3ProcessingChannel 284 { 285 public: 286 QCamera3RegularChannel(uint32_t cam_handle, 287 uint32_t channel_handle, 288 mm_camera_ops_t *cam_ops, 289 channel_cb_routine cb_routine, 290 channel_cb_buffer_err cb_buffer_err, 291 cam_padding_info_t *paddingInfo, 292 void *userData, 293 camera3_stream_t *stream, 294 cam_stream_type_t stream_type, 295 cam_feature_mask_t postprocess_mask, 296 QCamera3Channel *metadataChannel, 297 uint32_t numBuffers = MAX_INFLIGHT_REQUESTS); 298 299 virtual ~QCamera3RegularChannel(); 300 301 virtual int32_t setBatchSize(uint32_t batchSize); 302 virtual uint32_t getStreamTypeMask(); 303 virtual int32_t queueBatchBuf(); 304 virtual int32_t initialize(cam_is_type_t isType); 305 using QCamera3ProcessingChannel::request; 306 virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber, 307 int &indexUsed); 308 virtual reprocess_type_t getReprocessType(); 309 310 private: 311 int32_t initialize(struct private_handle_t *priv_handle); 312 313 uint32_t mBatchSize; 314 cam_rotation_t mRotation; 315 }; 316 317 /* QCamera3MetadataChannel is for metadata stream generated by camera daemon. */ 318 class QCamera3MetadataChannel : public QCamera3Channel 319 { 320 public: 321 QCamera3MetadataChannel(uint32_t cam_handle, 322 uint32_t channel_handle, 323 mm_camera_ops_t *cam_ops, 324 channel_cb_routine cb_routine, 325 channel_cb_buffer_err cb_buffer_err, 326 cam_padding_info_t *paddingInfo, 327 cam_feature_mask_t postprocess_mask, 328 void *userData, 329 uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM); 330 virtual ~QCamera3MetadataChannel(); 331 332 virtual int32_t initialize(cam_is_type_t isType); 333 334 virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber, 335 int &indexUsed); 336 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 337 QCamera3Stream *stream); 338 339 virtual QCamera3StreamMem *getStreamBufs(uint32_t le); 340 virtual void putStreamBufs(); registerBuffer(buffer_handle_t *,cam_is_type_t)341 virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/) 342 { return NO_ERROR; }; timeoutFrame(__unused uint32_t frameNumber)343 virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR; }; 344 345 private: 346 QCamera3StreamMem *mMemory; 347 }; 348 349 /* QCamera3RawChannel is for opaqueu/cross-platform raw stream containing 350 * vendor specific bayer data or 16-bit unpacked bayer data */ 351 class QCamera3RawChannel : public QCamera3RegularChannel 352 { 353 public: 354 QCamera3RawChannel(uint32_t cam_handle, 355 uint32_t channel_handle, 356 mm_camera_ops_t *cam_ops, 357 channel_cb_routine cb_routine, 358 channel_cb_buffer_err cb_buffer_err, 359 cam_padding_info_t *paddingInfo, 360 void *userData, 361 camera3_stream_t *stream, 362 cam_feature_mask_t postprocess_mask, 363 QCamera3Channel *metadataChannel, 364 bool raw_16 = false, 365 uint32_t numBuffers = MAX_INFLIGHT_REQUESTS); 366 367 virtual ~QCamera3RawChannel(); 368 369 virtual int32_t initialize(cam_is_type_t isType); 370 371 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 372 QCamera3Stream *stream); 373 374 virtual reprocess_type_t getReprocessType(); 375 376 private: 377 bool mRawDump; 378 bool mIsRaw16; 379 380 void dumpRawSnapshot(mm_camera_buf_def_t *frame); 381 void convertLegacyToRaw16(mm_camera_buf_def_t *frame); 382 void convertMipiToRaw16(mm_camera_buf_def_t *frame); 383 }; 384 385 /* 386 * QCamera3RawDumpChannel is for internal use only for Raw dump 387 */ 388 389 class QCamera3RawDumpChannel : public QCamera3Channel 390 { 391 public: 392 QCamera3RawDumpChannel(uint32_t cam_handle, 393 uint32_t channel_handle, 394 mm_camera_ops_t *cam_ops, 395 cam_dimension_t rawDumpSize, 396 cam_padding_info_t *paddingInfo, 397 void *userData, 398 cam_feature_mask_t postprocess_mask, uint32_t numBuffers = 3U); 399 virtual ~QCamera3RawDumpChannel(); 400 virtual int32_t initialize(cam_is_type_t isType); 401 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 402 QCamera3Stream *stream); 403 virtual QCamera3StreamMem *getStreamBufs(uint32_t le); 404 virtual void putStreamBufs(); registerBuffer(buffer_handle_t *,cam_is_type_t)405 virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/) 406 { return NO_ERROR; }; timeoutFrame(__unused uint32_t frameNumber)407 virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;}; 408 virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber, 409 int &indexUsed); 410 void dumpRawSnapshot(mm_camera_buf_def_t *frame); 411 412 public: 413 cam_dimension_t mDim; 414 415 private: 416 bool mRawDump; 417 QCamera3StreamMem *mMemory; 418 }; 419 420 /* QCamera3YUVChannel is used to handle flexible YUV streams that are directly 421 * generated by hardware and given to frameworks without any postprocessing at HAL. 422 * It is also used to handle input buffers that generate YUV outputs */ 423 class QCamera3YUVChannel : public QCamera3ProcessingChannel 424 { 425 public: 426 QCamera3YUVChannel(uint32_t cam_handle, 427 uint32_t channel_handle, 428 mm_camera_ops_t *cam_ops, 429 channel_cb_routine cb_routine, 430 channel_cb_buffer_err cb_buffer_err, 431 cam_padding_info_t *paddingInfo, 432 void *userData, 433 camera3_stream_t *stream, 434 cam_stream_type_t stream_type, 435 cam_feature_mask_t postprocess_mask, 436 QCamera3Channel *metadataChannel); 437 ~QCamera3YUVChannel(); 438 virtual int32_t initialize(cam_is_type_t isType); 439 using QCamera3ProcessingChannel::request; 440 virtual int32_t request(buffer_handle_t *buffer, 441 uint32_t frameNumber, 442 camera3_stream_buffer_t* pInputBuffer, 443 metadata_buffer_t* metadata, bool &needMetadata, 444 int &indexUsed, bool internalRequest, bool meteringOnly); 445 virtual reprocess_type_t getReprocessType(); 446 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 447 QCamera3Stream *stream); 448 virtual void putStreamBufs(); 449 virtual void reprocessCbRoutine(buffer_handle_t *resultBuffer, 450 uint32_t resultFrameNumber); 451 452 private: 453 typedef struct { 454 uint32_t frameNumber; 455 bool offlinePpFlag; 456 buffer_handle_t *output; 457 mm_camera_super_buf_t *callback_buffer; 458 } PpInfo; 459 460 // Whether offline postprocessing is required for this channel 461 bool mBypass; 462 uint32_t mFrameLen; 463 464 // Current edge, noise, and crop region setting 465 cam_edge_application_t mEdgeMode; 466 uint32_t mNoiseRedMode; 467 cam_crop_region_t mCropRegion; 468 469 // Mutex to protect mOfflinePpFlagMap and mFreeHeapBufferList 470 Mutex mOfflinePpLock; 471 // Map between free number and whether the request needs to be 472 // postprocessed. 473 List<PpInfo> mOfflinePpInfoList; 474 // Heap buffer index list 475 List<uint32_t> mFreeHeapBufferList; 476 477 private: 478 bool needsFramePostprocessing(metadata_buffer_t* meta); 479 int32_t handleOfflinePpCallback(uint32_t resultFrameNumber, 480 Vector<mm_camera_super_buf_t *>& pendingCbs); 481 mm_camera_super_buf_t* getNextPendingCbBuffer(); 482 }; 483 484 /* QCamera3PicChannel is for JPEG stream, which contains a YUV stream generated 485 * by the hardware, and encoded to a JPEG stream */ 486 class QCamera3PicChannel : public QCamera3ProcessingChannel 487 { 488 public: 489 QCamera3PicChannel(uint32_t cam_handle, 490 uint32_t channel_handle, 491 mm_camera_ops_t *cam_ops, 492 channel_cb_routine cb_routine, 493 channel_cb_buffer_err cb_buffer_err, 494 cam_padding_info_t *paddingInfo, 495 void *userData, 496 camera3_stream_t *stream, 497 cam_feature_mask_t postprocess_mask, 498 bool is4KVideo, 499 bool isInputStreamConfigured, 500 QCamera3Channel *metadataChannel, 501 uint32_t numBuffers = MAX_INFLIGHT_REQUESTS); 502 ~QCamera3PicChannel(); 503 504 virtual int32_t initialize(cam_is_type_t isType); 505 virtual int32_t flush(); 506 virtual int32_t request(buffer_handle_t *buffer, 507 uint32_t frameNumber, 508 camera3_stream_buffer_t* pInputBuffer, 509 metadata_buffer_t* metadata, 510 int &indexUsed, bool internalRequest, bool meteringOnly); 511 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 512 QCamera3Stream *stream); 513 514 virtual QCamera3StreamMem *getStreamBufs(uint32_t le); 515 virtual void putStreamBufs(); 516 virtual reprocess_type_t getReprocessType(); 517 virtual int32_t timeoutFrame(uint32_t frameNumber); 518 519 QCamera3Exif *getExifData(metadata_buffer_t *metadata, 520 jpeg_settings_t *jpeg_settings); 521 void overrideYuvSize(uint32_t width, uint32_t height); 522 static void jpegEvtHandle(jpeg_job_status_t status, 523 uint32_t /*client_hdl*/, 524 uint32_t jobId, 525 mm_jpeg_output_t *p_output, 526 void *userdata); 527 static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame, 528 void *userdata); 529 530 private: 531 int32_t queueJpegSetting(uint32_t out_buf_index, metadata_buffer_t *metadata); 532 533 public: 534 cam_dimension_t m_max_pic_dim; 535 536 private: 537 uint32_t mNumSnapshotBufs; 538 uint32_t mYuvWidth, mYuvHeight; 539 int32_t mCurrentBufIndex; 540 bool mInputBufferHint; 541 QCamera3StreamMem *mYuvMemory; 542 // Keep a list of free buffers 543 Mutex mFreeBuffersLock; 544 List<uint32_t> mFreeBufferList; 545 uint32_t mFrameLen; 546 }; 547 548 // reprocess channel class 549 class QCamera3ReprocessChannel : public QCamera3Channel 550 { 551 public: 552 QCamera3ReprocessChannel(uint32_t cam_handle, 553 uint32_t channel_handle, 554 mm_camera_ops_t *cam_ops, 555 channel_cb_routine cb_routine, 556 channel_cb_buffer_err cb_buffer_err, 557 cam_padding_info_t *paddingInfo, 558 cam_feature_mask_t postprocess_mask, 559 void *userData, void *ch_hdl); 560 QCamera3ReprocessChannel(); 561 virtual ~QCamera3ReprocessChannel(); 562 // offline reprocess 563 virtual int32_t start(); 564 virtual int32_t stop(); 565 int32_t doReprocessOffline(qcamera_fwk_input_pp_data_t *frame, 566 bool isPriorityFrame = false); 567 int32_t doReprocess(int buf_fd,void *buffer, size_t buf_length, int32_t &ret_val, 568 mm_camera_super_buf_t *meta_buf); 569 int32_t overrideMetadata(qcamera_hal3_pp_buffer_t *pp_buffer, 570 mm_camera_buf_def_t *meta_buffer, 571 jpeg_settings_t *jpeg_settings, 572 qcamera_fwk_input_pp_data_t &fwk_frame); 573 int32_t overrideFwkMetadata(qcamera_fwk_input_pp_data_t *frame); 574 virtual QCamera3StreamMem *getStreamBufs(uint32_t len); 575 virtual void putStreamBufs(); 576 virtual int32_t initialize(cam_is_type_t isType); 577 int32_t unmapOfflineBuffers(bool all); 578 int32_t bufDone(mm_camera_super_buf_t *recvd_frame); 579 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 580 QCamera3Stream *stream); 581 static void dataNotifyCB(mm_camera_super_buf_t *recvd_frame, 582 void* userdata); 583 int32_t addReprocStreamsFromSource(cam_pp_feature_config_t &pp_config, 584 const reprocess_config_t &src_config, 585 cam_is_type_t is_type, 586 QCamera3Channel *pMetaChannel); 587 QCamera3Stream *getStreamBySrcHandle(uint32_t srcHandle); 588 QCamera3Stream *getSrcStreamBySrcHandle(uint32_t srcHandle); 589 virtual int32_t registerBuffer(buffer_handle_t * buffer, cam_is_type_t isType); timeoutFrame(__unused uint32_t frameNumber)590 virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;}; 591 592 public: 593 void *inputChHandle; 594 595 private: 596 typedef struct { 597 QCamera3Stream *stream; 598 cam_mapping_buf_type type; 599 uint32_t index; 600 } OfflineBuffer; 601 602 int32_t resetToCamPerfNormal(uint32_t frameNumber); 603 android::List<OfflineBuffer> mOfflineBuffers; 604 android::List<OfflineBuffer> mOfflineMetaBuffers; 605 int32_t mOfflineBuffersIndex; 606 int32_t mOfflineMetaIndex; 607 uint32_t mFrameLen; 608 Mutex mFreeBuffersLock; // Lock for free heap buffers 609 List<int32_t> mFreeBufferList; // Free heap buffers list 610 reprocess_type_t mReprocessType; 611 uint32_t mSrcStreamHandles[MAX_STREAM_NUM_IN_BUNDLE]; 612 QCamera3ProcessingChannel *m_pSrcChannel; // ptr to source channel for reprocess 613 QCamera3Channel *m_pMetaChannel; 614 QCamera3StreamMem *mMemory; 615 QCamera3StreamMem mGrallocMemory; 616 Vector<uint32_t> mPriorityFrames; 617 Mutex mPriorityFramesLock; 618 bool mReprocessPerfMode; 619 }; 620 621 622 /* QCamera3SupportChannel is for HAL internal consumption only */ 623 class QCamera3SupportChannel : public QCamera3Channel 624 { 625 public: 626 QCamera3SupportChannel(uint32_t cam_handle, 627 uint32_t channel_handle, 628 mm_camera_ops_t *cam_ops, 629 cam_padding_info_t *paddingInfo, 630 cam_feature_mask_t postprocess_mask, 631 cam_stream_type_t streamType, 632 cam_dimension_t *dim, 633 cam_format_t streamFormat, 634 uint8_t hw_analysis_supported, 635 cam_color_filter_arrangement_t color_arrangement, 636 void *userData, 637 uint32_t numBuffers = MIN_STREAMING_BUFFER_NUM 638 ); 639 virtual ~QCamera3SupportChannel(); 640 641 virtual int32_t initialize(cam_is_type_t isType); 642 643 virtual int32_t request(buffer_handle_t *buffer, uint32_t frameNumber, 644 int &indexUsed); 645 virtual void streamCbRoutine(mm_camera_super_buf_t *super_frame, 646 QCamera3Stream *stream); 647 648 virtual QCamera3StreamMem *getStreamBufs(uint32_t le); 649 virtual void putStreamBufs(); registerBuffer(buffer_handle_t *,cam_is_type_t)650 virtual int32_t registerBuffer(buffer_handle_t * /*buffer*/, cam_is_type_t /*isType*/) 651 { return NO_ERROR; }; timeoutFrame(__unused uint32_t frameNumber)652 virtual int32_t timeoutFrame(__unused uint32_t frameNumber) {return NO_ERROR;}; 653 654 static cam_dimension_t kDim; 655 private: 656 QCamera3StreamMem *mMemory; 657 cam_dimension_t mDim; 658 cam_stream_type_t mStreamType; 659 cam_format_t mStreamFormat; 660 }; 661 662 }; // namespace qcamera 663 664 #endif /* __QCAMERA_CHANNEL_H__ */ 665