camera/ICameraClient.cpp

   1 /*
   2 **
   3 ** Copyright 2008, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 //#define LOG_NDEBUG 0
  19 #define LOG_TAG "ICameraClient"
  20 #include <utils/Log.h>
  21 #include <stdint.h>
  22 #include <sys/types.h>
  23 #include <camera/CameraUtils.h>
  24 #include <android/hardware/ICameraClient.h>
  25 #include <media/hardware/HardwareAPI.h>
  26
  27 namespace android {
  28 namespace hardware {
  29
  30 enum {
  31     NOTIFY_CALLBACK = IBinder::FIRST_CALL_TRANSACTION,
  32     DATA_CALLBACK,
  33     DATA_CALLBACK_TIMESTAMP,
  34     RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP,
  35     RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH,
  36 };
  37
  38 class BpCameraClient: public BpInterface<ICameraClient>
  39 {
  40 public:
  41     explicit BpCameraClient(const sp<IBinder>& impl)
  42         : BpInterface<ICameraClient>(impl)
  43     {
  44     }
  45
  46     // generic callback from camera service to app
  47     void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)
  48     {
  49         ALOGV("notifyCallback");
  50         Parcel data, reply;
  51         data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
  52         data.writeInt32(msgType);
  53         data.writeInt32(ext1);
  54         data.writeInt32(ext2);
  55         remote()->transact(NOTIFY_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
  56     }
  57
  58     // generic data callback from camera service to app with image data
  59     void dataCallback(int32_t msgType, const sp<IMemory>& imageData,
  60                       camera_frame_metadata_t *metadata)
  61     {
  62         ALOGV("dataCallback");
  63         Parcel data, reply;
  64         data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
  65         data.writeInt32(msgType);
  66         data.writeStrongBinder(IInterface::asBinder(imageData));
  67         if (metadata) {
  68             data.writeInt32(metadata->number_of_faces);
  69             data.write(metadata->faces, sizeof(camera_face_t) * metadata->number_of_faces);
  70         }
  71         remote()->transact(DATA_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY);
  72     }
  73
  74     // generic data callback from camera service to app with image data
  75     void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& imageData)
  76     {
  77         ALOGV("dataCallback");
  78         Parcel data, reply;
  79         data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
  80         data.writeInt64(timestamp);
  81         data.writeInt32(msgType);
  82         data.writeStrongBinder(IInterface::asBinder(imageData));
  83         remote()->transact(DATA_CALLBACK_TIMESTAMP, data, &reply, IBinder::FLAG_ONEWAY);
  84     }
  85
  86     void recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_handle_t* handle) {
  87         ALOGV("recordingFrameHandleCallbackTimestamp");
  88         Parcel data, reply;
  89         data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
  90         data.writeInt64(timestamp);
  91         data.writeNativeHandle(handle);
  92         remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP, data, &reply,
  93                 IBinder::FLAG_ONEWAY);
  94     }
  95
  96     void recordingFrameHandleCallbackTimestampBatch(
  97             const std::vector<nsecs_t>& timestamps,
  98             const std::vector<native_handle_t*>& handles) {
  99         ALOGV("recordingFrameHandleCallbackTimestampBatch");
 100         Parcel data, reply;
 101         data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
 102         uint32_t n = timestamps.size();
 103         if (n != handles.size()) {
 104             ALOGE("%s: size of timestamps(%zu) and handles(%zu) mismatch!",
 105                     __FUNCTION__, timestamps.size(), handles.size());
 106             return;
 107         }
 108         data.writeUint32(n);
 109         for (auto ts : timestamps) {
 110             data.writeInt64(ts);
 111         }
 112         for (auto& handle : handles) {
 113             data.writeNativeHandle(handle);
 114         }
 115         remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH, data, &reply,
 116                 IBinder::FLAG_ONEWAY);
 117     }
 118 };
 119
 120 IMPLEMENT_META_INTERFACE(CameraClient, "android.hardware.ICameraClient");
 121
 122 // ----------------------------------------------------------------------
 123
 124 status_t BnCameraClient::onTransact(
 125     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 126 {
 127     switch(code) {
 128         case NOTIFY_CALLBACK: {
 129             ALOGV("NOTIFY_CALLBACK");
 130             CHECK_INTERFACE(ICameraClient, data, reply);
 131             int32_t msgType = data.readInt32();
 132             int32_t ext1 = data.readInt32();
 133             int32_t ext2 = data.readInt32();
 134             notifyCallback(msgType, ext1, ext2);
 135             return NO_ERROR;
 136         } break;
 137         case DATA_CALLBACK: {
 138             ALOGV("DATA_CALLBACK");
 139             CHECK_INTERFACE(ICameraClient, data, reply);
 140             int32_t msgType = data.readInt32();
 141             sp<IMemory> imageData = interface_cast<IMemory>(data.readStrongBinder());
 142             camera_frame_metadata_t *metadata = NULL;
 143             if (data.dataAvail() > 0) {
 144                 metadata = new camera_frame_metadata_t;
 145                 metadata->number_of_faces = data.readInt32();
 146                 metadata->faces = (camera_face_t *) data.readInplace(
 147                         sizeof(camera_face_t) * metadata->number_of_faces);
 148             }
 149             dataCallback(msgType, imageData, metadata);
 150             if (metadata) delete metadata;
 151             return NO_ERROR;
 152         } break;
 153         case DATA_CALLBACK_TIMESTAMP: {
 154             ALOGV("DATA_CALLBACK_TIMESTAMP");
 155             CHECK_INTERFACE(ICameraClient, data, reply);
 156             nsecs_t timestamp = data.readInt64();
 157             int32_t msgType = data.readInt32();
 158             sp<IMemory> imageData = interface_cast<IMemory>(data.readStrongBinder());
 159             dataCallbackTimestamp(timestamp, msgType, imageData);
 160             return NO_ERROR;
 161         } break;
 162         case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP: {
 163             ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP");
 164             CHECK_INTERFACE(ICameraClient, data, reply);
 165             nsecs_t timestamp;
 166             status_t res = data.readInt64(&timestamp);
 167             if (res != OK) {
 168                 ALOGE("%s: Failed to read timestamp: %s (%d)", __FUNCTION__, strerror(-res), res);
 169                 return BAD_VALUE;
 170             }
 171             native_handle_t* handle = data.readNativeHandle();
 172             if (handle == nullptr) {
 173                 ALOGE("%s: Received a null native handle", __FUNCTION__);
 174                 return BAD_VALUE;
 175             }
 176
 177             // The native handle will be freed in BpCamera::releaseRecordingFrameHandle.
 178             recordingFrameHandleCallbackTimestamp(timestamp, handle);
 179             return NO_ERROR;
 180         } break;
 181         case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH: {
 182             ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH");
 183             CHECK_INTERFACE(ICameraClient, data, reply);
 184             uint32_t n = 0;
 185             status_t res = data.readUint32(&n);
 186             if (res != OK) {
 187                 ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);
 188                 return BAD_VALUE;
 189             }
 190             std::vector<nsecs_t> timestamps;
 191             std::vector<native_handle_t*> handles;
 192             timestamps.reserve(n);
 193             handles.reserve(n);
 194             for (uint32_t i = 0; i < n; i++) {
 195                 res = data.readInt64(&timestamps[i]);
 196                 if (res != OK) {
 197                     ALOGE("%s: Failed to read timestamp[%d]: %s (%d)",
 198                             __FUNCTION__, i, strerror(-res), res);
 199                     return BAD_VALUE;
 200                 }
 201             }
 202             for (uint32_t i = 0; i < n; i++) {
 203                 native_handle_t* handle = data.readNativeHandle();
 204                 if (handle == nullptr) {
 205                     ALOGE("%s: Received a null native handle at handles[%d]",
 206                             __FUNCTION__, i);
 207                     return BAD_VALUE;
 208                 }
 209                 handles.push_back(handle);
 210             }
 211
 212             // The native handle will be freed in BpCamera::releaseRecordingFrameHandleBatch.
 213             recordingFrameHandleCallbackTimestampBatch(timestamps, handles);
 214             return NO_ERROR;
 215         } break;
 216         default:
 217             return BBinder::onTransact(code, data, reply, flags);
 218     }
 219 }
 220
 221 // ----------------------------------------------------------------------------
 222
 223 } // namespace hardware
 224 } // namespace android