1 /* 2 * Copyright (C) 2016 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 17 #define LOG_TAG "android.hardware.camera.device (at) 3.2-convert-impl" 18 #include <log/log.h> 19 20 #include "include/convert.h" 21 22 namespace android { 23 namespace hardware { 24 namespace camera { 25 namespace device { 26 namespace V3_2 { 27 namespace implementation { 28 29 using ::android::hardware::graphics::common::V1_0::Dataspace; 30 using ::android::hardware::graphics::common::V1_0::PixelFormat; 31 using ::android::hardware::camera::device::V3_2::BufferUsageFlags; 32 33 bool convertFromHidl(const CameraMetadata &src, const camera_metadata_t** dst) { 34 if (src.size() == 0) { 35 // Special case for null metadata 36 *dst = nullptr; 37 return true; 38 } 39 40 const uint8_t* data = src.data(); 41 // sanity check the size of CameraMetadata match underlying camera_metadata_t 42 if (get_camera_metadata_size((camera_metadata_t*)data) != src.size()) { 43 ALOGE("%s: input CameraMetadata is corrupt!", __FUNCTION__); 44 return false; 45 } 46 *dst = (camera_metadata_t*) data; 47 return true; 48 } 49 50 // Note: existing data in dst will be gone. Caller still owns the memory of src 51 void convertToHidl(const camera_metadata_t *src, CameraMetadata* dst) { 52 if (src == nullptr) { 53 return; 54 } 55 size_t size = get_camera_metadata_size(src); 56 dst->setToExternal((uint8_t *) src, size); 57 return; 58 } 59 60 void convertFromHidl(const Stream &src, Camera3Stream* dst) { 61 dst->mId = src.id; 62 dst->stream_type = (int) src.streamType; 63 dst->width = src.width; 64 dst->height = src.height; 65 dst->format = (int) src.format; 66 dst->data_space = (android_dataspace_t) src.dataSpace; 67 dst->rotation = (int) src.rotation; 68 dst->usage = (uint32_t) src.usage; 69 // Fields to be filled by HAL (max_buffers, priv) are initialized to 0 70 dst->max_buffers = 0; 71 dst->priv = 0; 72 return; 73 } 74 75 void convertToHidl(const Camera3Stream* src, HalStream* dst) { 76 dst->id = src->mId; 77 dst->overrideFormat = (PixelFormat) src->format; 78 dst->maxBuffers = src->max_buffers; 79 if (src->stream_type == CAMERA3_STREAM_OUTPUT) { 80 dst->consumerUsage = (BufferUsageFlags)0; 81 dst->producerUsage = (BufferUsageFlags)src->usage; 82 } else if (src->stream_type == CAMERA3_STREAM_INPUT) { 83 dst->producerUsage = (BufferUsageFlags)0; 84 dst->consumerUsage = (BufferUsageFlags)src->usage; 85 } else { 86 //Should not reach here per current HIDL spec, but we might end up adding 87 // bi-directional stream to HIDL. 88 ALOGW("%s: Stream type %d is not currently supported!", 89 __FUNCTION__, src->stream_type); 90 } 91 } 92 93 void convertToHidl(const camera3_stream_configuration_t& src, HalStreamConfiguration* dst) { 94 dst->streams.resize(src.num_streams); 95 for (uint32_t i = 0; i < src.num_streams; i++) { 96 convertToHidl(static_cast<Camera3Stream*>(src.streams[i]), &dst->streams[i]); 97 } 98 return; 99 } 100 101 void convertFromHidl( 102 buffer_handle_t* bufPtr, BufferStatus status, camera3_stream_t* stream, int acquireFence, 103 camera3_stream_buffer_t* dst) { 104 dst->stream = stream; 105 dst->buffer = bufPtr; 106 dst->status = (int) status; 107 dst->acquire_fence = acquireFence; 108 dst->release_fence = -1; // meant for HAL to fill in 109 } 110 111 void convertToHidl(const camera3_notify_msg* src, NotifyMsg* dst) { 112 dst->type = (MsgType) src->type; 113 switch (src->type) { 114 case CAMERA3_MSG_ERROR: 115 { 116 // The camera3_stream_t* must be the same as what wrapper HAL passed to conventional 117 // HAL, or the ID lookup will return garbage. Caller should validate the ID here is 118 // indeed one of active stream IDs 119 Camera3Stream* stream = static_cast<Camera3Stream*>( 120 src->message.error.error_stream); 121 dst->msg.error.frameNumber = src->message.error.frame_number; 122 dst->msg.error.errorStreamId = (stream != nullptr) ? stream->mId : -1; 123 dst->msg.error.errorCode = (ErrorCode) src->message.error.error_code; 124 } 125 break; 126 case CAMERA3_MSG_SHUTTER: 127 dst->msg.shutter.frameNumber = src->message.shutter.frame_number; 128 dst->msg.shutter.timestamp = src->message.shutter.timestamp; 129 break; 130 default: 131 ALOGE("%s: HIDL type converion failed. Unknown msg type 0x%x", 132 __FUNCTION__, src->type); 133 } 134 return; 135 } 136 137 } // namespace implementation 138 } // namespace V3_2 139 } // namespace device 140 } // namespace camera 141 } // namespace hardware 142 } // namespace android 143
