1/* 2 * Samsung Exynos5 SoC series Camera API 2.0 HAL 3 * 4 * Internal Metadata (controls/dynamic metadata and static metadata) 5 * 6 * Copyright (c) 2012 Samsung Electronics Co., Ltd 7 * Contact: Sungjoong Kang, <sj3.kang@samsung.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14/*2012.04.18 Version 0.1 Initial Release*/ 15/*2012.04.23 Version 0.2 Added static metadata (draft)*/ 16/*2012.07.04 Version 0.3 Applied google's undocumented changes (draft)*/ 17/*2012.07.11 Version 0.4 Added FD parameters */ 18/*2012.07.27 Version 0.5 Modified HSB control and DM */ 19 20 21#ifndef FIMC_IS_METADATA_H_ 22#define FIMC_IS_METADATA_H_ 23 24struct rational { 25 uint32_t num; 26 uint32_t den; 27}; 28 29#define CAMERA2_MAX_AVAILABLE_MODE 21 30#define CAMERA2_MAX_FACES 16 31 32#define CAMERA2_FACE_DETECTION_THRESHOLD 35 33 34/* 35 *controls/dynamic metadata 36*/ 37 38/* android.request */ 39 40enum metadata_mode { 41 METADATA_MODE_NONE, 42 METADATA_MODE_FULL 43}; 44 45struct camera2_request_ctl { 46 uint32_t id; 47 enum metadata_mode metadataMode; 48 uint8_t outputStreams[16]; 49 uint32_t frameCount; 50}; 51 52struct camera2_request_dm { 53 uint32_t id; 54 enum metadata_mode metadataMode; 55 uint32_t frameCount; 56}; 57 58 59 60/* android.lens */ 61 62enum optical_stabilization_mode { 63 OPTICAL_STABILIZATION_MODE_OFF, 64 OPTICAL_STABILIZATION_MODE_ON 65}; 66 67enum lens_facing { 68 LENS_FACING_BACK, 69 LENS_FACING_FRONT 70}; 71 72struct camera2_lens_ctl { 73 uint32_t focusDistance; 74 float aperture; 75 float focalLength; 76 float filterDensity; 77 enum optical_stabilization_mode opticalStabilizationMode; 78 79}; 80 81struct camera2_lens_dm { 82 uint32_t focusDistance; 83 float aperture; 84 float focalLength; 85 float filterDensity; 86 enum optical_stabilization_mode opticalStabilizationMode; 87 float focusRange[2]; 88}; 89 90struct camera2_lens_sm { 91 float minimumFocusDistance; 92 float hyperfocalDistance; 93 float availableFocalLength[2]; 94 float availableApertures; 95 /*assuming 1 aperture*/ 96 float availableFilterDensities; 97 /*assuming 1 ND filter value*/ 98 enum optical_stabilization_mode availableOpticalStabilization; 99 /*assuming 1*/ 100 uint32_t shadingMapSize; 101 float shadingMap[3][40][30]; 102 uint32_t geometricCorrectionMapSize; 103 float geometricCorrectionMap[2][3][40][30]; 104 enum lens_facing facing; 105 float position[2]; 106}; 107 108/* android.sensor */ 109 110enum sensor_colorfilterarrangement { 111 SENSOR_COLORFILTERARRANGEMENT_RGGB, 112 SENSOR_COLORFILTERARRANGEMENT_GRBG, 113 SENSOR_COLORFILTERARRANGEMENT_GBRG, 114 SENSOR_COLORFILTERARRANGEMENT_BGGR, 115 SENSOR_COLORFILTERARRANGEMENT_RGB 116}; 117 118enum sensor_ref_illuminant { 119 SENSOR_ILLUMINANT_DAYLIGHT = 1, 120 SENSOR_ILLUMINANT_FLUORESCENT = 2, 121 SENSOR_ILLUMINANT_TUNGSTEN = 3, 122 SENSOR_ILLUMINANT_FLASH = 4, 123 SENSOR_ILLUMINANT_FINE_WEATHER = 9, 124 SENSOR_ILLUMINANT_CLOUDY_WEATHER = 10, 125 SENSOR_ILLUMINANT_SHADE = 11, 126 SENSOR_ILLUMINANT_DAYLIGHT_FLUORESCENT = 12, 127 SENSOR_ILLUMINANT_DAY_WHITE_FLUORESCENT = 13, 128 SENSOR_ILLUMINANT_COOL_WHITE_FLUORESCENT = 14, 129 SENSOR_ILLUMINANT_WHITE_FLUORESCENT = 15, 130 SENSOR_ILLUMINANT_STANDARD_A = 17, 131 SENSOR_ILLUMINANT_STANDARD_B = 18, 132 SENSOR_ILLUMINANT_STANDARD_C = 19, 133 SENSOR_ILLUMINANT_D55 = 20, 134 SENSOR_ILLUMINANT_D65 = 21, 135 SENSOR_ILLUMINANT_D75 = 22, 136 SENSOR_ILLUMINANT_D50 = 23, 137 SENSOR_ILLUMINANT_ISO_STUDIO_TUNGSTEN = 24 138}; 139 140struct camera2_sensor_ctl { 141 /* unit : nano */ 142 uint64_t exposureTime; 143 /* unit : nano(It's min frame duration */ 144 uint64_t frameDuration; 145 /* unit : percent(need to change ISO value?) */ 146 uint32_t sensitivity; 147}; 148 149struct camera2_sensor_dm { 150 uint64_t exposureTime; 151 uint64_t frameDuration; 152 uint32_t sensitivity; 153 uint64_t timeStamp; 154}; 155 156struct camera2_sensor_sm { 157 uint32_t exposureTimeRange[2]; 158 uint32_t maxFrameDuration; 159 /* list of available sensitivities. */ 160 uint32_t availableSensitivities[10]; 161 enum sensor_colorfilterarrangement colorFilterArrangement; 162 float physicalSize[2]; 163 uint32_t pixelArraySize[2]; 164 uint32_t activeArraySize[4]; 165 uint32_t whiteLevel; 166 uint32_t blackLevelPattern[4]; 167 struct rational colorTransform1[9]; 168 struct rational colorTransform2[9]; 169 enum sensor_ref_illuminant referenceIlluminant1; 170 enum sensor_ref_illuminant referenceIlluminant2; 171 struct rational forwardMatrix1[9]; 172 struct rational forwardMatrix2[9]; 173 struct rational calibrationTransform1[9]; 174 struct rational calibrationTransform2[9]; 175 struct rational baseGainFactor; 176 uint32_t maxAnalogSensitivity; 177 float noiseModelCoefficients[2]; 178 uint32_t orientation; 179}; 180 181 182 183/* android.flash */ 184 185enum flash_mode { 186 CAM2_FLASH_MODE_NOP = 0, 187 CAM2_FLASH_MODE_OFF = 1, 188 CAM2_FLASH_MODE_SINGLE, 189 CAM2_FLASH_MODE_TORCH, 190 CAM2_FLASH_MODE_BEST 191}; 192 193struct camera2_flash_ctl { 194 enum flash_mode flashMode; 195 uint32_t firingPower; 196 uint64_t firingTime; 197}; 198 199struct camera2_flash_dm { 200 enum flash_mode flashMode; 201 /*10 is max power*/ 202 uint32_t firingPower; 203 /*unit : microseconds*/ 204 uint64_t firingTime; 205 /*1 : stable, 0 : unstable*/ 206 uint32_t firingStable; 207 /*1 : flash required, 2 : flash not required */ 208 uint32_t decision; 209}; 210 211struct camera2_flash_sm { 212 uint32_t available; 213 uint64_t chargeDuration; 214}; 215 216 217/* android.hotpixel */ 218 219enum processing_mode { 220 PROCESSING_MODE_OFF = 1, 221 PROCESSING_MODE_FAST, 222 PROCESSING_MODE_HIGH_QUALITY 223}; 224 225 226struct camera2_hotpixel_ctl { 227 enum processing_mode mode; 228}; 229 230struct camera2_hotpixel_dm { 231 enum processing_mode mode; 232}; 233 234 235 236/* android.demosaic */ 237 238struct camera2_demosaic_ctl { 239 enum processing_mode mode; 240}; 241 242struct camera2_demosaic_dm { 243 enum processing_mode mode; 244}; 245 246 247 248/* android.noiseReduction */ 249 250struct camera2_noisereduction_ctl { 251 enum processing_mode mode; 252 uint32_t strength; 253}; 254 255struct camera2_noisereduction_dm { 256 enum processing_mode mode; 257 uint32_t strength; 258}; 259 260 261 262/* android.shading */ 263 264struct camera2_shading_ctl { 265 enum processing_mode mode; 266}; 267 268struct camera2_shading_dm { 269 enum processing_mode mode; 270}; 271 272 273 274/* android.geometric */ 275 276struct camera2_geometric_ctl { 277 enum processing_mode mode; 278}; 279 280struct camera2_geometric_dm { 281 enum processing_mode mode; 282}; 283 284 285 286/* android.colorCorrection */ 287 288enum colorcorrection_mode { 289 COLORCORRECTION_MODE_FAST = 1, 290 COLORCORRECTION_MODE_HIGH_QUALITY, 291 COLORCORRECTION_MODE_TRANSFORM_MATRIX, 292 COLORCORRECTION_MODE_EFFECT_MONO, 293 COLORCORRECTION_MODE_EFFECT_NEGATIVE, 294 COLORCORRECTION_MODE_EFFECT_SOLARIZE, 295 COLORCORRECTION_MODE_EFFECT_SEPIA, 296 COLORCORRECTION_MODE_EFFECT_POSTERIZE, 297 COLORCORRECTION_MODE_EFFECT_WHITEBOARD, 298 COLORCORRECTION_MODE_EFFECT_BLACKBOARD, 299 COLORCORRECTION_MODE_EFFECT_AQUA 300}; 301 302 303struct camera2_colorcorrection_ctl { 304 enum colorcorrection_mode mode; 305 float transform[9]; 306 uint32_t hue; 307 uint32_t saturation; 308 uint32_t brightness; 309}; 310 311struct camera2_colorcorrection_dm { 312 enum colorcorrection_mode mode; 313 float transform[9]; 314 uint32_t hue; 315 uint32_t saturation; 316 uint32_t brightness; 317}; 318 319struct camera2_colorcorrection_sm { 320 /*assuming 10 supported modes*/ 321 uint8_t availableModes[CAMERA2_MAX_AVAILABLE_MODE]; 322 uint32_t hueRange[2]; 323 uint32_t saturationRange[2]; 324 uint32_t brightnessRange[2]; 325}; 326 327 328/* android.tonemap */ 329 330enum tonemap_mode { 331 TONEMAP_MODE_FAST = 1, 332 TONEMAP_MODE_HIGH_QUALITY, 333 TONEMAP_MODE_CONTRAST_CURVE 334}; 335 336struct camera2_tonemap_ctl { 337 enum tonemap_mode mode; 338 /* assuming maxCurvePoints = 64 */ 339 float curveRed[64]; 340 float curveGreen[64]; 341 float curveBlue[64]; 342}; 343 344struct camera2_tonemap_dm { 345 enum tonemap_mode mode; 346 /* assuming maxCurvePoints = 64 */ 347 float curveRed[64]; 348 float curveGreen[64]; 349 float curveBlue[64]; 350}; 351 352struct camera2_tonemap_sm { 353 uint32_t maxCurvePoints; 354}; 355 356/* android.edge */ 357 358struct camera2_edge_ctl { 359 enum processing_mode mode; 360 uint32_t strength; 361}; 362 363struct camera2_edge_dm { 364 enum processing_mode mode; 365 uint32_t strength; 366}; 367 368 369 370/* android.scaler */ 371 372enum scaler_availableformats { 373 SCALER_FORMAT_BAYER_RAW, 374 SCALER_FORMAT_YV12, 375 SCALER_FORMAT_NV21, 376 SCALER_FORMAT_JPEG, 377 SCALER_FORMAT_UNKNOWN 378}; 379 380struct camera2_scaler_ctl { 381 uint32_t cropRegion[3]; 382}; 383 384struct camera2_scaler_dm { 385 uint32_t cropRegion[3]; 386}; 387 388struct camera2_scaler_sm { 389 enum scaler_availableformats availableFormats[4]; 390 /*assuming # of availableFormats = 4*/ 391 uint32_t availableRawSizes; 392 uint64_t availableRawMinDurations; 393 /* needs check */ 394 uint32_t availableProcessedSizes[8]; 395 uint64_t availableProcessedMinDurations[8]; 396 uint32_t availableJpegSizes[8][2]; 397 uint64_t availableJpegMinDurations[8]; 398 uint32_t availableMaxDigitalZoom[8]; 399}; 400 401/* android.jpeg */ 402struct camera2_jpeg_ctl { 403 uint32_t quality; 404 uint32_t thumbnailSize[2]; 405 uint32_t thumbnailQuality; 406 double gpsCoordinates[3]; 407 uint32_t gpsProcessingMethod; 408 uint64_t gpsTimestamp; 409 uint32_t orientation; 410}; 411 412struct camera2_jpeg_dm { 413 uint32_t quality; 414 uint32_t thumbnailSize[2]; 415 uint32_t thumbnailQuality; 416 double gpsCoordinates[3]; 417 uint32_t gpsProcessingMethod; 418 uint64_t gpsTimestamp; 419 uint32_t orientation; 420}; 421 422struct camera2_jpeg_sm { 423 uint32_t availableThumbnailSizes[8][2]; 424 uint32_t maxSize; 425 /*assuming supported size=8*/ 426}; 427 428 429 430/* android.statistics */ 431 432enum facedetect_mode { 433 FACEDETECT_MODE_OFF = 1, 434 FACEDETECT_MODE_SIMPLE, 435 FACEDETECT_MODE_FULL 436}; 437 438enum stats_mode { 439 STATS_MODE_OFF = 1, 440 STATS_MODE_ON 441}; 442 443struct camera2_stats_ctl { 444 enum facedetect_mode faceDetectMode; 445 enum stats_mode histogramMode; 446 enum stats_mode sharpnessMapMode; 447}; 448 449 450struct camera2_stats_dm { 451 enum facedetect_mode faceDetectMode; 452 uint32_t faceRectangles[CAMERA2_MAX_FACES][4]; 453 uint8_t faceScores[CAMERA2_MAX_FACES]; 454 uint32_t faceLandmarks[CAMERA2_MAX_FACES][6]; 455 uint32_t faceIds[CAMERA2_MAX_FACES]; 456/* PAYTON_CHECK_20120712 : histogram_mode -> stats_mode */ 457 enum stats_mode histogramMode; 458/* [hj529.kim, 2012/07/19] androd.statistics.histogram */ 459 uint32_t histogram[3 * 256]; 460/* PAYTON_CHECK_20120712 : sharpnessmap_mode -> stats_mode */ 461 enum stats_mode sharpnessMapMode; 462 /*sharpnessMap*/ 463}; 464 465 466struct camera2_stats_sm { 467 uint8_t availableFaceDetectModes[CAMERA2_MAX_AVAILABLE_MODE]; 468 /*assuming supported modes = 3;*/ 469 uint32_t maxFaceCount; 470 uint32_t histogramBucketCount; 471 uint32_t maxHistogramCount; 472 uint32_t sharpnessMapSize[2]; 473 uint32_t maxSharpnessMapValue; 474}; 475 476/* android.control */ 477 478enum aa_capture_intent { 479 AA_CAPTURE_INTENT_CUSTOM = 0, 480 AA_CAPTURE_INTENT_PREVIEW, 481 AA_CAPTURE_INTENT_STILL_CAPTURE, 482 AA_CAPTURE_INTENT_VIDEO_RECORD, 483 AA_CAPTURE_INTENT_VIDEO_SNAPSHOT, 484 AA_CAPTURE_INTENT_ZERO_SHUTTER_LAG 485}; 486 487enum aa_mode { 488 AA_CONTROL_NONE = 0, 489 AA_CONTROL_OFF, 490 AA_CONTROL_AUTO, 491 AA_CONTROL_USE_SCENE_MODE 492}; 493 494enum aa_scene_mode { 495 AA_SCENE_MODE_UNSUPPORTED = 1, 496 AA_SCENE_MODE_FACE_PRIORITY, 497 AA_SCENE_MODE_ACTION, 498 AA_SCENE_MODE_PORTRAIT, 499 AA_SCENE_MODE_LANDSCAPE, 500 AA_SCENE_MODE_NIGHT, 501 AA_SCENE_MODE_NIGHT_PORTRAIT, 502 AA_SCENE_MODE_THEATRE, 503 AA_SCENE_MODE_BEACH, 504 AA_SCENE_MODE_SNOW, 505 AA_SCENE_MODE_SUNSET, 506 AA_SCENE_MODE_STEADYPHOTO, 507 AA_SCENE_MODE_FIREWORKS, 508 AA_SCENE_MODE_SPORTS, 509 AA_SCENE_MODE_PARTY, 510 AA_SCENE_MODE_CANDLELIGHT, 511 AA_SCENE_MODE_BARCODE, 512 AA_SCENE_MODE_NIGHT_CAPTURE, /* part of night mode */ 513 AA_SCENE_MODE_MAX 514}; 515 516enum aa_effect_mode { 517 AA_EFFECT_OFF = 1, 518 AA_EFFECT_MONO, 519 AA_EFFECT_NEGATIVE, 520 AA_EFFECT_SOLARIZE, 521 AA_EFFECT_SEPIA, 522 AA_EFFECT_POSTERIZE, 523 AA_EFFECT_WHITEBOARD, 524 AA_EFFECT_BLACKBOARD, 525 AA_EFFECT_AQUA 526}; 527 528enum aa_aemode { 529 AA_AEMODE_OFF = 1, 530 AA_AEMODE_LOCKED, 531 AA_AEMODE_ON, 532 AA_AEMODE_ON_AUTO_FLASH, 533 AA_AEMODE_ON_ALWAYS_FLASH, 534 AA_AEMODE_ON_AUTO_FLASH_REDEYE 535}; 536 537enum aa_ae_flashmode { 538 AA_FLASHMODE_NOP = 0, 539 /*all flash control stop*/ 540 AA_FLASHMODE_OFF = 1, 541 /*internal 3A can control flash*/ 542 AA_FLASHMODE_ON, 543 /*internal 3A can do auto flash algorithm*/ 544 AA_FLASHMODE_AUTO, 545 /*internal 3A can fire flash by auto result*/ 546 AA_FLASHMODE_CAPTURE, 547 /*internal 3A can control flash*/ 548 AA_FLASHMODE_ON_ALWAYS 549}; 550 551enum aa_ae_antibanding_mode { 552 AA_AE_ANTIBANDING_OFF = 1, 553 AA_AE_ANTIBANDING_50HZ, 554 AA_AE_ANTIBANDING_60HZ, 555 AA_AE_ANTIBANDING_AUTO 556}; 557 558enum aa_awbmode { 559 AA_AWBMODE_OFF = 1, 560 AA_AWBMODE_LOCKED, 561 AA_AWBMODE_WB_AUTO, 562 AA_AWBMODE_WB_INCANDESCENT, 563 AA_AWBMODE_WB_FLUORESCENT, 564 AA_AWBMODE_WB_WARM_FLUORESCENT, 565 AA_AWBMODE_WB_DAYLIGHT, 566 AA_AWBMODE_WB_CLOUDY_DAYLIGHT, 567 AA_AWBMODE_WB_TWILIGHT, 568 AA_AWBMODE_WB_SHADE 569}; 570 571enum aa_afmode { 572 NO_CHANGE = 0, 573 AA_AFMODE_OFF = 1, 574 AA_AFMODE_AUTO, 575 AA_AFMODE_MACRO, 576 AA_AFMODE_CONTINUOUS_VIDEO, 577 AA_AFMODE_CONTINUOUS_PICTURE, 578 AA_AFMODE_INFINITY, 579 AA_AFMODE_AUTO_FACE, 580 AA_AFMODE_CONTINUOUS_VIDEO_FACE, 581 AA_AFMODE_CONTINUOUS_PICTURE_FACE, 582 AA_AFMODE_MANUAL, 583 AA_AFMODE_EDOF 584}; 585 586enum aa_afstate { 587 AA_AFSTATE_INACTIVE = 1, 588 AA_AFSTATE_PASSIVE_SCAN, 589 AA_AFSTATE_ACTIVE_SCAN, 590 AA_AFSTATE_AF_ACQUIRED_FOCUS, 591 AA_AFSTATE_AF_FAILED_FOCUS 592}; 593 594enum ae_state { 595 AE_STATE_INACTIVE = 1, 596 AE_STATE_SEARCHING, 597 AE_STATE_CONVERGED, 598 AE_STATE_LOCKED, 599 AE_STATE_FLASH_REQUIRED, 600 AE_STATE_PRECAPTURE 601}; 602 603enum awb_state { 604 AWB_STATE_INACTIVE = 1, 605 AWB_STATE_SEARCHING, 606 AWB_STATE_CONVERGED, 607 AWB_STATE_LOCKED 608}; 609 610enum aa_isomode { 611 AA_ISOMODE_AUTO = 1, 612 AA_ISOMODE_MANUAL, 613}; 614 615enum ae_lockmode { 616 AEMODE_LOCK_OFF = 0, 617 AEMODE_LOCK_ON, 618}; 619 620enum awb_lockmode { 621 AWBMODE_LOCK_OFF = 0, 622 AWBMODE_LOCK_ON, 623}; 624 625struct camera2_aa_ctl { 626 enum aa_capture_intent captureIntent; 627 enum aa_mode mode; 628 enum aa_scene_mode sceneMode; 629 uint32_t videoStabilizationMode; 630 enum aa_aemode aeMode; 631 uint32_t aeRegions[5]; 632 /*5 per region(x1,y1,x2,y2,weight). currently assuming 1 region.*/ 633 int32_t aeExpCompensation; 634 uint32_t aeTargetFpsRange[2]; 635 enum aa_ae_antibanding_mode aeAntibandingMode; 636 enum aa_ae_flashmode aeflashMode; 637 enum aa_awbmode awbMode; 638 uint32_t awbRegions[5]; 639 /*5 per region(x1,y1,x2,y2,weight). currently assuming 1 region.*/ 640 enum aa_afmode afMode; 641 uint32_t afRegions[5]; 642 /*5 per region(x1,y1,x2,y2,weight). currently assuming 1 region.*/ 643 uint32_t afTrigger; 644 enum aa_isomode isoMode; 645 uint32_t isoValue; 646 647}; 648 649struct camera2_aa_dm { 650 enum aa_mode mode; 651 enum aa_effect_mode effectMode; 652 enum aa_scene_mode sceneMode; 653 uint32_t videoStabilizationMode; 654 enum aa_aemode aeMode; 655 /*needs check*/ 656 uint32_t aeRegions[5]; 657 /*5 per region(x1,y1,x2,y2,weight). currently assuming 1 region.*/ 658 enum ae_state aeState; 659 enum aa_ae_flashmode aeflashMode; 660 /*needs check*/ 661 enum aa_awbmode awbMode; 662 uint32_t awbRegions[5]; 663 enum awb_state awbState; 664 /*5 per region(x1,y1,x2,y2,weight). currently assuming 1 region.*/ 665 enum aa_afmode afMode; 666 uint32_t afRegions[5]; 667 /*5 per region(x1,y1,x2,y2,weight). currently assuming 1 region*/ 668 enum aa_afstate afState; 669 enum aa_isomode isoMode; 670 uint32_t isoValue; 671}; 672 673struct camera2_aa_sm { 674 uint8_t availableSceneModes[CAMERA2_MAX_AVAILABLE_MODE]; 675 uint8_t availableEffects[CAMERA2_MAX_AVAILABLE_MODE]; 676 /*assuming # of available scene modes = 10*/ 677 uint32_t maxRegions; 678 uint8_t aeAvailableModes[CAMERA2_MAX_AVAILABLE_MODE]; 679 /*assuming # of available ae modes = 8*/ 680 struct rational aeCompensationStep; 681 int32_t aeCompensationRange[2]; 682 uint32_t aeAvailableTargetFpsRanges[CAMERA2_MAX_AVAILABLE_MODE][2]; 683 uint8_t aeAvailableAntibandingModes[CAMERA2_MAX_AVAILABLE_MODE]; 684 uint8_t awbAvailableModes[CAMERA2_MAX_AVAILABLE_MODE]; 685 /*assuming # of awbAvailableModes = 10*/ 686 uint8_t afAvailableModes[CAMERA2_MAX_AVAILABLE_MODE]; 687 /*assuming # of afAvailableModes = 4*/ 688 uint8_t availableVideoStabilizationModes[4]; 689 /*assuming # of availableVideoStabilizationModes = 4*/ 690 uint32_t isoRange[2]; 691}; 692 693struct camera2_lens_usm { 694 /** Frame delay between sending command and applying frame data */ 695 uint32_t focusDistanceFrameDelay; 696}; 697 698struct camera2_sensor_usm { 699 /** Frame delay between sending command and applying frame data */ 700 uint32_t exposureTimeFrameDelay; 701 uint32_t frameDurationFrameDelay; 702 uint32_t sensitivityFrameDelay; 703}; 704 705struct camera2_flash_usm { 706 /** Frame delay between sending command and applying frame data */ 707 uint32_t flashModeFrameDelay; 708 uint32_t firingPowerFrameDelay; 709 uint64_t firingTimeFrameDelay; 710}; 711 712struct camera2_ctl { 713 struct camera2_request_ctl request; 714 struct camera2_lens_ctl lens; 715 struct camera2_sensor_ctl sensor; 716 struct camera2_flash_ctl flash; 717 struct camera2_hotpixel_ctl hotpixel; 718 struct camera2_demosaic_ctl demosaic; 719 struct camera2_noisereduction_ctl noise; 720 struct camera2_shading_ctl shading; 721 struct camera2_geometric_ctl geometric; 722 struct camera2_colorcorrection_ctl color; 723 struct camera2_tonemap_ctl tonemap; 724 struct camera2_edge_ctl edge; 725 struct camera2_scaler_ctl scaler; 726 struct camera2_jpeg_ctl jpeg; 727 struct camera2_stats_ctl stats; 728 struct camera2_aa_ctl aa; 729}; 730 731struct camera2_dm { 732 struct camera2_request_dm request; 733 struct camera2_lens_dm lens; 734 struct camera2_sensor_dm sensor; 735 struct camera2_flash_dm flash; 736 struct camera2_hotpixel_dm hotpixel; 737 struct camera2_demosaic_dm demosaic; 738 struct camera2_noisereduction_dm noise; 739 struct camera2_shading_dm shading; 740 struct camera2_geometric_dm geometric; 741 struct camera2_colorcorrection_dm color; 742 struct camera2_tonemap_dm tonemap; 743 struct camera2_edge_dm edge; 744 struct camera2_scaler_dm scaler; 745 struct camera2_jpeg_dm jpeg; 746 struct camera2_stats_dm stats; 747 struct camera2_aa_dm aa; 748}; 749 750struct camera2_sm { 751 struct camera2_lens_sm lens; 752 struct camera2_sensor_sm sensor; 753 struct camera2_flash_sm flash; 754 struct camera2_colorcorrection_sm color; 755 struct camera2_tonemap_sm tonemap; 756 struct camera2_scaler_sm scaler; 757 struct camera2_jpeg_sm jpeg; 758 struct camera2_stats_sm stats; 759 struct camera2_aa_sm aa; 760 761 /** User-defined(ispfw specific) static metadata. */ 762 struct camera2_lens_usm lensUd; 763 struct camera2_sensor_usm sensorUd; 764 struct camera2_flash_usm flashUd; 765}; 766 767/** \brief 768 User-defined control for lens. 769*/ 770struct camera2_lens_uctl { 771 struct camera2_lens_ctl ctl; 772 773 /** It depends by af algorithm(normally 255 or 1023) */ 774 uint32_t maxPos; 775 /** Some actuator support slew rate control. */ 776 uint32_t slewRate; 777}; 778 779/** \brief 780 User-defined metadata for lens. 781*/ 782struct camera2_lens_udm { 783 /** It depends by af algorithm(normally 255 or 1023) */ 784 uint32_t maxPos; 785 /** Some actuator support slew rate control. */ 786 uint32_t slewRate; 787}; 788 789/** \brief 790 User-defined control for sensor. 791*/ 792struct camera2_sensor_uctl { 793 struct camera2_sensor_ctl ctl; 794 /** Dynamic frame duration. 795 This feature is decided to max. value between 796 'sensor.exposureTime'+alpha and 'sensor.frameDuration'. 797 */ 798 uint64_t dynamicFrameDuration; 799}; 800 801struct camera2_scaler_uctl { 802 /** \brief 803 target address for next frame. 804 \remarks 805 [0] invalid address, stop 806 [others] valid address 807 */ 808 uint32_t sccTargetAddress[4]; 809 uint32_t scpTargetAddress[4]; 810}; 811 812struct camera2_flash_uctl { 813 struct camera2_flash_ctl ctl; 814}; 815 816/** \brief 817 User-defined control area. 818 \remarks 819 sensor, lens, flash category is empty value. 820 It should be filled by a5 for SET_CAM_CONTROL command. 821 Other category is filled already from host. 822*/ 823struct camera2_uctl { 824 /** \brief 825 Set sensor, lens, flash control for next frame. 826 \remarks 827 This flag can be combined. 828 [0 bit] lens 829 [1 bit] sensor 830 [2 bit] flash 831 */ 832 uint32_t uUpdateBitMap; 833 834 /** For debugging */ 835 uint32_t uFrameNumber; 836 837 /** ispfw specific control(user-defined) of lens. */ 838 struct camera2_lens_uctl lensUd; 839 /** ispfw specific control(user-defined) of sensor. */ 840 struct camera2_sensor_uctl sensorUd; 841 /** ispfw specific control(user-defined) of flash. */ 842 struct camera2_flash_uctl flashUd; 843 844 struct camera2_scaler_uctl scalerUd; 845}; 846 847struct camera2_udm { 848 struct camera2_lens_udm lens; 849}; 850 851struct camera2_shot { 852 /*google standard area*/ 853 struct camera2_ctl ctl; 854 struct camera2_dm dm; 855 /*user defined area*/ 856 struct camera2_uctl uctl; 857 struct camera2_udm udm; 858 /*magic : 23456789*/ 859 uint32_t magicNumber; 860}; 861 862/** \brief 863 Structure for interfacing between HAL and driver. 864*/ 865struct camera2_shot_ext { 866 /** \brief 867 setfile change 868 \remarks 869 [x] mode for setfile 870 */ 871 uint32_t setfile; 872 873 /** \brief 874 stream control 875 \remarks 876 [0] disable stream out 877 [1] enable stream out 878 */ 879 uint32_t request_sensor; 880 uint32_t request_scc; 881 uint32_t request_scp; 882 883 /** \brief 884 post processing control(DRC) 885 \remarks 886 [0] bypass off 887 [1] bypass on 888 */ 889 uint32_t drc_bypass; 890 891 /** \brief 892 post processing control(DIS) 893 \remarks 894 [0] bypass off 895 [1] bypass on 896 */ 897 uint32_t dis_bypass; 898 899 /** \brief 900 post processing control(3DNR) 901 \remarks 902 [0] bypass off 903 [1] bypass on 904 */ 905 uint32_t dnr_bypass; 906 907 /** \brief 908 post processing control(FD) 909 \remarks 910 [0] bypass off 911 [1] bypass on 912 */ 913 uint32_t fd_bypass; 914 915 /* reserved for future */ 916 uint32_t reserved[20]; 917 918 /** \brief 919 processing time debugging 920 \remarks 921 taken time(unit : struct timeval) 922 [0][x] flite start 923 [1][x] flite end 924 [2][x] DRV Shot 925 [3][x] DRV Shot done 926 [4][x] DRV Meta done 927 */ 928 uint32_t timeZone[10][2]; 929 930 struct camera2_shot shot; 931 uint8_t gpsProcessingMethod[32]; 932 uint8_t isReprocessing; 933 uint8_t reprocessInput; 934 enum ae_lockmode ae_lock; // this field is used in cameraHAL only 935 enum awb_lockmode awb_lock; // this field is used in cameraHAL only 936 enum aa_awbmode awb_mode_dm; 937}; 938 939/** \brief 940 stream structure for scaler. 941*/ 942struct camera2_stream { 943 /** \brief 944 this address for verifying conincidence of index and address 945 \remarks 946 [X] kernel virtual address for this buffer 947 */ 948 uint32_t address; 949 950 /** \brief 951 this frame count is from FLITE through dm.request.fcount, 952 this count increases every frame end. initial value is 1. 953 \remarks 954 [X] frame count 955 */ 956 uint32_t fcount; 957 958 /** \brief 959 this request count is from HAL through ctl.request.fcount, 960 this count is the unique. 961 \remarks 962 [X] request count 963 */ 964 uint32_t rcount; 965 966 /** \brief 967 frame index of isp framemgr. 968 this value is for driver internal debugging 969 \remarks 970 [X] frame index 971 */ 972 uint32_t findex; 973}; 974 975#define CAM_LENS_CMD (0x1 << 0x0) 976#define CAM_SENSOR_CMD (0x1 << 0x1) 977#define CAM_FLASH_CMD (0x1 << 0x2) 978 979 980#endif 981 982