1 /* 2 * Copyright (C) 2015 The Android Open Source Project 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 #ifndef _ACAMERA_METADATA_H 17 #define _ACAMERA_METADATA_H 18 19 #include <unordered_set> 20 #include <vector> 21 #include <memory> 22 23 #include <sys/types.h> 24 #include <utils/Mutex.h> 25 #include <utils/RefBase.h> 26 #include <utils/Vector.h> 27 28 #ifdef __ANDROID_VNDK__ 29 #include <CameraMetadata.h> 30 using CameraMetadata = android::hardware::camera::common::V1_0::helper::CameraMetadata; 31 #else 32 #include <camera/CameraMetadata.h> 33 #endif 34 35 #include <camera/NdkCameraMetadata.h> 36 37 using namespace android; 38 39 /** 40 * ACameraMetadata is an opaque struct definition. 41 * It is intentionally left outside of the android namespace because it's NDK struct. 42 */ 43 struct ACameraMetadata : public RefBase { 44 public: 45 typedef enum { 46 ACM_CHARACTERISTICS, // Read only 47 ACM_REQUEST, // Read/Write 48 ACM_RESULT, // Read only 49 } ACAMERA_METADATA_TYPE; 50 51 // Constructs a ACameraMetadata that takes ownership of `buffer`. 52 ACameraMetadata(camera_metadata_t* buffer, ACAMERA_METADATA_TYPE type); 53 54 // Constructs a ACameraMetadata that shares its data with something else, like a Java object 55 ACameraMetadata(const std::shared_ptr<CameraMetadata>& cameraMetadata, 56 ACAMERA_METADATA_TYPE type); 57 58 // Copy constructor. 59 // 60 // Always makes a deep copy. 61 ACameraMetadata(const ACameraMetadata& other); 62 63 ~ACameraMetadata(); 64 65 camera_status_t getConstEntry(uint32_t tag, ACameraMetadata_const_entry* entry) const; 66 67 camera_status_t update(uint32_t tag, uint32_t count, const uint8_t* data); 68 camera_status_t update(uint32_t tag, uint32_t count, const int32_t* data); 69 camera_status_t update(uint32_t tag, uint32_t count, const float* data); 70 camera_status_t update(uint32_t tag, uint32_t count, const double* data); 71 camera_status_t update(uint32_t tag, uint32_t count, const int64_t* data); 72 camera_status_t update(uint32_t tag, uint32_t count, const ACameraMetadata_rational* data); 73 74 camera_status_t getTags(/*out*/int32_t* numTags, 75 /*out*/const uint32_t** tags) const; 76 77 const CameraMetadata& getInternalData() const; 78 bool isLogicalMultiCamera(size_t* count, const char* const** physicalCameraIds) const; 79 80 private: 81 82 // Common code called by constructors. 83 void init(); 84 85 // This function does not check whether the capability passed to it is valid. 86 // The caller must make sure that it is. 87 bool isNdkSupportedCapability(const int32_t capability); 88 static inline bool isVendorTag(const uint32_t tag); 89 static bool isCaptureRequestTag(const uint32_t tag); 90 void filterUnsupportedFeatures(); // Hide features not yet supported by NDK 91 void filterStreamConfigurations(); // Hide input streams, translate hal format to NDK formats 92 void filterDurations(uint32_t tag); // translate hal format to NDK formats 93 void derivePhysicalCameraIds(); // Derive array of physical ids. 94 95 template<typename INTERNAL_T, typename NDK_T> updateImplACameraMetadata96 camera_status_t updateImpl(uint32_t tag, uint32_t count, const NDK_T* data) { 97 if (mType != ACM_REQUEST) { 98 ALOGE("Error: Write to metadata is only allowed for capture request!"); 99 return ACAMERA_ERROR_INVALID_PARAMETER; 100 } 101 if (!isCaptureRequestTag(tag)) { 102 ALOGE("Error: tag %d is not writable!", tag); 103 return ACAMERA_ERROR_INVALID_PARAMETER; 104 } 105 106 Mutex::Autolock _l(mLock); 107 108 status_t ret = OK; 109 if (count == 0 && data == nullptr) { 110 ret = mData->erase(tag); 111 } else { 112 // Here we have to use reinterpret_cast because the NDK data type is 113 // exact copy of internal data type but they do not inherit from each other 114 ret = mData->update(tag, reinterpret_cast<const INTERNAL_T*>(data), count); 115 } 116 117 if (ret == OK) { 118 mTags.clear(); 119 return ACAMERA_OK; 120 } else { 121 return ACAMERA_ERROR_INVALID_PARAMETER; 122 } 123 } 124 125 // Guard access of public APIs: get/update/getTags. 126 mutable Mutex mLock; 127 128 std::shared_ptr<CameraMetadata> mData; 129 130 mutable Vector<uint32_t> mTags; // Updated by `getTags()`, cleared by `update()`. 131 const ACAMERA_METADATA_TYPE mType; 132 133 static std::unordered_set<uint32_t> sSystemTags; 134 135 std::vector<const char*> mStaticPhysicalCameraIds; 136 std::vector<String8> mStaticPhysicalCameraIdValues; 137 }; 138 139 #endif // _ACAMERA_METADATA_H 140