1/*
2 * Copyright (C) 2017 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#define LOG_TAG "CameraHardwareInterface"
17//#define LOG_NDEBUG 0
18
19#include <inttypes.h>
20#include <media/hardware/HardwareAPI.h> // For VideoNativeHandleMetadata
21#include "CameraHardwareInterface.h"
22
23namespace android {
24
25using namespace hardware::camera::device::V1_0;
26using namespace hardware::camera::common::V1_0;
27using hardware::hidl_handle;
28
29CameraHardwareInterface::~CameraHardwareInterface()
30{
31    ALOGI("Destroying camera %s", mName.string());
32    if (mDevice) {
33        int rc = mDevice->common.close(&mDevice->common);
34        if (rc != OK)
35            ALOGE("Could not close camera %s: %d", mName.string(), rc);
36    }
37    if (mHidlDevice != nullptr) {
38        mHidlDevice->close();
39        mHidlDevice.clear();
40        cleanupCirculatingBuffers();
41    }
42}
43
44status_t CameraHardwareInterface::initialize(sp<CameraProviderManager> manager) {
45    if (mDevice) {
46        ALOGE("%s: camera hardware interface has been initialized to libhardware path!",
47                __FUNCTION__);
48        return INVALID_OPERATION;
49    }
50
51    ALOGI("Opening camera %s", mName.string());
52
53    status_t ret = manager->openSession(mName.string(), this, &mHidlDevice);
54    if (ret != OK) {
55        ALOGE("%s: openSession failed! %s (%d)", __FUNCTION__, strerror(-ret), ret);
56    }
57    return ret;
58}
59
60status_t CameraHardwareInterface::setPreviewScalingMode(int scalingMode)
61{
62    int rc = OK;
63    mPreviewScalingMode = scalingMode;
64    if (mPreviewWindow != nullptr) {
65        rc = native_window_set_scaling_mode(mPreviewWindow.get(),
66                scalingMode);
67    }
68    return rc;
69}
70
71status_t CameraHardwareInterface::setPreviewTransform(int transform) {
72    int rc = OK;
73    mPreviewTransform = transform;
74    if (mPreviewWindow != nullptr) {
75        rc = native_window_set_buffers_transform(mPreviewWindow.get(),
76                mPreviewTransform);
77    }
78    return rc;
79}
80
81/**
82 * Implementation of android::hardware::camera::device::V1_0::ICameraDeviceCallback
83 */
84hardware::Return<void> CameraHardwareInterface::notifyCallback(
85        NotifyCallbackMsg msgType, int32_t ext1, int32_t ext2) {
86    sNotifyCb((int32_t) msgType, ext1, ext2, (void*) this);
87    return hardware::Void();
88}
89
90hardware::Return<uint32_t> CameraHardwareInterface::registerMemory(
91        const hardware::hidl_handle& descriptor,
92        uint32_t bufferSize, uint32_t bufferCount) {
93    if (descriptor->numFds != 1) {
94        ALOGE("%s: camera memory descriptor has numFds %d (expect 1)",
95                __FUNCTION__, descriptor->numFds);
96        return 0;
97    }
98    if (descriptor->data[0] < 0) {
99        ALOGE("%s: camera memory descriptor has FD %d (expect >= 0)",
100                __FUNCTION__, descriptor->data[0]);
101        return 0;
102    }
103
104    camera_memory_t* mem = sGetMemory(descriptor->data[0], bufferSize, bufferCount, this);
105    sp<CameraHeapMemory> camMem(static_cast<CameraHeapMemory *>(mem->handle));
106    int memPoolId = camMem->mHeap->getHeapID();
107    if (memPoolId < 0) {
108        ALOGE("%s: CameraHeapMemory has FD %d (expect >= 0)", __FUNCTION__, memPoolId);
109        return 0;
110    }
111    mHidlMemPoolMap.insert(std::make_pair(memPoolId, mem));
112    return memPoolId;
113}
114
115hardware::Return<void> CameraHardwareInterface::unregisterMemory(uint32_t memId) {
116    if (mHidlMemPoolMap.count(memId) == 0) {
117        ALOGE("%s: memory pool ID %d not found", __FUNCTION__, memId);
118        return hardware::Void();
119    }
120    camera_memory_t* mem = mHidlMemPoolMap.at(memId);
121    sPutMemory(mem);
122    mHidlMemPoolMap.erase(memId);
123    return hardware::Void();
124}
125
126hardware::Return<void> CameraHardwareInterface::dataCallback(
127        DataCallbackMsg msgType, uint32_t data, uint32_t bufferIndex,
128        const hardware::camera::device::V1_0::CameraFrameMetadata& metadata) {
129    if (mHidlMemPoolMap.count(data) == 0) {
130        ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data);
131        return hardware::Void();
132    }
133    camera_frame_metadata_t md;
134    md.number_of_faces = metadata.faces.size();
135    md.faces = (camera_face_t*) metadata.faces.data();
136    sDataCb((int32_t) msgType, mHidlMemPoolMap.at(data), bufferIndex, &md, this);
137    return hardware::Void();
138}
139
140hardware::Return<void> CameraHardwareInterface::dataCallbackTimestamp(
141        DataCallbackMsg msgType, uint32_t data,
142        uint32_t bufferIndex, int64_t timestamp) {
143    if (mHidlMemPoolMap.count(data) == 0) {
144        ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data);
145        return hardware::Void();
146    }
147    sDataCbTimestamp(timestamp, (int32_t) msgType, mHidlMemPoolMap.at(data), bufferIndex, this);
148    return hardware::Void();
149}
150
151hardware::Return<void> CameraHardwareInterface::handleCallbackTimestamp(
152        DataCallbackMsg msgType, const hidl_handle& frameData, uint32_t data,
153        uint32_t bufferIndex, int64_t timestamp) {
154    if (mHidlMemPoolMap.count(data) == 0) {
155        ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data);
156        return hardware::Void();
157    }
158    sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(mHidlMemPoolMap.at(data)->handle));
159    VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
160            mem->mBuffers[bufferIndex]->pointer();
161    md->pHandle = const_cast<native_handle_t*>(frameData.getNativeHandle());
162    sDataCbTimestamp(timestamp, (int32_t) msgType, mHidlMemPoolMap.at(data), bufferIndex, this);
163    return hardware::Void();
164}
165
166hardware::Return<void> CameraHardwareInterface::handleCallbackTimestampBatch(
167        DataCallbackMsg msgType,
168        const hardware::hidl_vec<hardware::camera::device::V1_0::HandleTimestampMessage>& messages) {
169    std::vector<android::HandleTimestampMessage> msgs;
170    msgs.reserve(messages.size());
171
172    for (const auto& hidl_msg : messages) {
173        if (mHidlMemPoolMap.count(hidl_msg.data) == 0) {
174            ALOGE("%s: memory pool ID %d not found", __FUNCTION__, hidl_msg.data);
175            return hardware::Void();
176        }
177        sp<CameraHeapMemory> mem(
178                static_cast<CameraHeapMemory *>(mHidlMemPoolMap.at(hidl_msg.data)->handle));
179
180        if (hidl_msg.bufferIndex >= mem->mNumBufs) {
181            ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
182                 hidl_msg.bufferIndex, mem->mNumBufs);
183            return hardware::Void();
184        }
185        VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
186                mem->mBuffers[hidl_msg.bufferIndex]->pointer();
187        md->pHandle = const_cast<native_handle_t*>(hidl_msg.frameData.getNativeHandle());
188
189        msgs.push_back({hidl_msg.timestamp, mem->mBuffers[hidl_msg.bufferIndex]});
190    }
191
192    mDataCbTimestampBatch((int32_t) msgType, msgs, mCbUser);
193    return hardware::Void();
194}
195
196std::pair<bool, uint64_t> CameraHardwareInterface::getBufferId(
197        ANativeWindowBuffer* anb) {
198    std::lock_guard<std::mutex> lock(mBufferIdMapLock);
199
200    buffer_handle_t& buf = anb->handle;
201    auto it = mBufferIdMap.find(buf);
202    if (it == mBufferIdMap.end()) {
203        uint64_t bufId = mNextBufferId++;
204        mBufferIdMap[buf] = bufId;
205        mReversedBufMap[bufId] = anb;
206        return std::make_pair(true, bufId);
207    } else {
208        return std::make_pair(false, it->second);
209    }
210}
211
212void CameraHardwareInterface::cleanupCirculatingBuffers() {
213    std::lock_guard<std::mutex> lock(mBufferIdMapLock);
214    mBufferIdMap.clear();
215    mReversedBufMap.clear();
216}
217
218hardware::Return<void>
219CameraHardwareInterface::dequeueBuffer(dequeueBuffer_cb _hidl_cb) {
220    ANativeWindow *a = mPreviewWindow.get();
221    if (a == nullptr) {
222        ALOGE("%s: preview window is null", __FUNCTION__);
223        return hardware::Void();
224    }
225    ANativeWindowBuffer* anb;
226    int rc = native_window_dequeue_buffer_and_wait(a, &anb);
227    Status s = Status::INTERNAL_ERROR;
228    uint64_t bufferId = 0;
229    uint32_t stride = 0;
230    hidl_handle buf = nullptr;
231    if (rc == OK) {
232        s = Status::OK;
233        auto pair = getBufferId(anb);
234        buf = (pair.first) ? anb->handle : nullptr;
235        bufferId = pair.second;
236        stride = anb->stride;
237    }
238
239    _hidl_cb(s, bufferId, buf, stride);
240    return hardware::Void();
241}
242
243hardware::Return<Status>
244CameraHardwareInterface::enqueueBuffer(uint64_t bufferId) {
245    ANativeWindow *a = mPreviewWindow.get();
246    if (a == nullptr) {
247        ALOGE("%s: preview window is null", __FUNCTION__);
248        return Status::INTERNAL_ERROR;
249    }
250    if (mReversedBufMap.count(bufferId) == 0) {
251        ALOGE("%s: bufferId %" PRIu64 " not found", __FUNCTION__, bufferId);
252        return Status::ILLEGAL_ARGUMENT;
253    }
254    int rc = a->queueBuffer(a, mReversedBufMap.at(bufferId), -1);
255    if (rc == 0) {
256        return Status::OK;
257    }
258    return Status::INTERNAL_ERROR;
259}
260
261hardware::Return<Status>
262CameraHardwareInterface::cancelBuffer(uint64_t bufferId) {
263    ANativeWindow *a = mPreviewWindow.get();
264    if (a == nullptr) {
265        ALOGE("%s: preview window is null", __FUNCTION__);
266        return Status::INTERNAL_ERROR;
267    }
268    if (mReversedBufMap.count(bufferId) == 0) {
269        ALOGE("%s: bufferId %" PRIu64 " not found", __FUNCTION__, bufferId);
270        return Status::ILLEGAL_ARGUMENT;
271    }
272    int rc = a->cancelBuffer(a, mReversedBufMap.at(bufferId), -1);
273    if (rc == 0) {
274        return Status::OK;
275    }
276    return Status::INTERNAL_ERROR;
277}
278
279hardware::Return<Status>
280CameraHardwareInterface::setBufferCount(uint32_t count) {
281    ANativeWindow *a = mPreviewWindow.get();
282    if (a != nullptr) {
283        // Workaround for b/27039775
284        // Previously, setting the buffer count would reset the buffer
285        // queue's flag that allows for all buffers to be dequeued on the
286        // producer side, instead of just the producer's declared max count,
287        // if no filled buffers have yet been queued by the producer.  This
288        // reset no longer happens, but some HALs depend on this behavior,
289        // so it needs to be maintained for HAL backwards compatibility.
290        // Simulate the prior behavior by disconnecting/reconnecting to the
291        // window and setting the values again.  This has the drawback of
292        // actually causing memory reallocation, which may not have happened
293        // in the past.
294        native_window_api_disconnect(a, NATIVE_WINDOW_API_CAMERA);
295        native_window_api_connect(a, NATIVE_WINDOW_API_CAMERA);
296        if (mPreviewScalingMode != NOT_SET) {
297            native_window_set_scaling_mode(a, mPreviewScalingMode);
298        }
299        if (mPreviewTransform != NOT_SET) {
300            native_window_set_buffers_transform(a, mPreviewTransform);
301        }
302        if (mPreviewWidth != NOT_SET) {
303            native_window_set_buffers_dimensions(a,
304                    mPreviewWidth, mPreviewHeight);
305            native_window_set_buffers_format(a, mPreviewFormat);
306        }
307        if (mPreviewUsage != 0) {
308            native_window_set_usage(a, mPreviewUsage);
309        }
310        if (mPreviewSwapInterval != NOT_SET) {
311            a->setSwapInterval(a, mPreviewSwapInterval);
312        }
313        if (mPreviewCrop.left != NOT_SET) {
314            native_window_set_crop(a, &(mPreviewCrop));
315        }
316    }
317    int rc = native_window_set_buffer_count(a, count);
318    if (rc == OK) {
319        cleanupCirculatingBuffers();
320        return Status::OK;
321    }
322    return Status::INTERNAL_ERROR;
323}
324
325hardware::Return<Status>
326CameraHardwareInterface::setBuffersGeometry(
327        uint32_t w, uint32_t h, hardware::graphics::common::V1_0::PixelFormat format) {
328    Status s = Status::INTERNAL_ERROR;
329    ANativeWindow *a = mPreviewWindow.get();
330    if (a == nullptr) {
331        ALOGE("%s: preview window is null", __FUNCTION__);
332        return s;
333    }
334    mPreviewWidth = w;
335    mPreviewHeight = h;
336    mPreviewFormat = (int) format;
337    int rc = native_window_set_buffers_dimensions(a, w, h);
338    if (rc == OK) {
339        rc = native_window_set_buffers_format(a, mPreviewFormat);
340    }
341    if (rc == OK) {
342        cleanupCirculatingBuffers();
343        s = Status::OK;
344    }
345    return s;
346}
347
348hardware::Return<Status>
349CameraHardwareInterface::setCrop(int32_t left, int32_t top, int32_t right, int32_t bottom) {
350    Status s = Status::INTERNAL_ERROR;
351    ANativeWindow *a = mPreviewWindow.get();
352    if (a == nullptr) {
353        ALOGE("%s: preview window is null", __FUNCTION__);
354        return s;
355    }
356    mPreviewCrop.left = left;
357    mPreviewCrop.top = top;
358    mPreviewCrop.right = right;
359    mPreviewCrop.bottom = bottom;
360    int rc = native_window_set_crop(a, &mPreviewCrop);
361    if (rc == OK) {
362        s = Status::OK;
363    }
364    return s;
365}
366
367hardware::Return<Status>
368CameraHardwareInterface::setUsage(hardware::graphics::common::V1_0::BufferUsage usage) {
369    Status s = Status::INTERNAL_ERROR;
370    ANativeWindow *a = mPreviewWindow.get();
371    if (a == nullptr) {
372        ALOGE("%s: preview window is null", __FUNCTION__);
373        return s;
374    }
375    mPreviewUsage = (int) usage;
376    int rc = native_window_set_usage(a, mPreviewUsage);
377    if (rc == OK) {
378        cleanupCirculatingBuffers();
379        s = Status::OK;
380    }
381    return s;
382}
383
384hardware::Return<Status>
385CameraHardwareInterface::setSwapInterval(int32_t interval) {
386    Status s = Status::INTERNAL_ERROR;
387    ANativeWindow *a = mPreviewWindow.get();
388    if (a == nullptr) {
389        ALOGE("%s: preview window is null", __FUNCTION__);
390        return s;
391    }
392    mPreviewSwapInterval = interval;
393    int rc = a->setSwapInterval(a, interval);
394    if (rc == OK) {
395        s = Status::OK;
396    }
397    return s;
398}
399
400hardware::Return<void>
401CameraHardwareInterface::getMinUndequeuedBufferCount(getMinUndequeuedBufferCount_cb _hidl_cb) {
402    ANativeWindow *a = mPreviewWindow.get();
403    if (a == nullptr) {
404        ALOGE("%s: preview window is null", __FUNCTION__);
405        return hardware::Void();
406    }
407    int count = 0;
408    int rc = a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &count);
409    Status s = Status::INTERNAL_ERROR;
410    if (rc == OK) {
411        s = Status::OK;
412    }
413    _hidl_cb(s, count);
414    return hardware::Void();
415}
416
417hardware::Return<Status>
418CameraHardwareInterface::setTimestamp(int64_t timestamp) {
419    Status s = Status::INTERNAL_ERROR;
420    ANativeWindow *a = mPreviewWindow.get();
421    if (a == nullptr) {
422        ALOGE("%s: preview window is null", __FUNCTION__);
423        return s;
424    }
425    int rc = native_window_set_buffers_timestamp(a, timestamp);
426    if (rc == OK) {
427        s = Status::OK;
428    }
429    return s;
430}
431
432status_t CameraHardwareInterface::setPreviewWindow(const sp<ANativeWindow>& buf)
433{
434    ALOGV("%s(%s) buf %p", __FUNCTION__, mName.string(), buf.get());
435    if (CC_LIKELY(mHidlDevice != nullptr)) {
436        mPreviewWindow = buf;
437        if (buf != nullptr) {
438            if (mPreviewScalingMode != NOT_SET) {
439                setPreviewScalingMode(mPreviewScalingMode);
440            }
441            if (mPreviewTransform != NOT_SET) {
442                setPreviewTransform(mPreviewTransform);
443            }
444        }
445        return CameraProviderManager::mapToStatusT(
446                mHidlDevice->setPreviewWindow(buf.get() ? this : nullptr));
447    } else if (mDevice) {
448        if (mDevice->ops->set_preview_window) {
449            mPreviewWindow = buf;
450            if (buf != nullptr) {
451                if (mPreviewScalingMode != NOT_SET) {
452                    setPreviewScalingMode(mPreviewScalingMode);
453                }
454                if (mPreviewTransform != NOT_SET) {
455                    setPreviewTransform(mPreviewTransform);
456                }
457            }
458            mHalPreviewWindow.user = this;
459            ALOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p",__FUNCTION__,
460                    &mHalPreviewWindow, mHalPreviewWindow.user);
461            return mDevice->ops->set_preview_window(mDevice,
462                    buf.get() ? &mHalPreviewWindow.nw : 0);
463        }
464    }
465    return INVALID_OPERATION;
466}
467
468void CameraHardwareInterface::setCallbacks(notify_callback notify_cb,
469        data_callback data_cb,
470        data_callback_timestamp data_cb_timestamp,
471        data_callback_timestamp_batch data_cb_timestamp_batch,
472        void* user)
473{
474    mNotifyCb = notify_cb;
475    mDataCb = data_cb;
476    mDataCbTimestamp = data_cb_timestamp;
477    mDataCbTimestampBatch = data_cb_timestamp_batch;
478    mCbUser = user;
479
480    ALOGV("%s(%s)", __FUNCTION__, mName.string());
481
482    if (mDevice && mDevice->ops->set_callbacks) {
483        mDevice->ops->set_callbacks(mDevice,
484                               sNotifyCb,
485                               sDataCb,
486                               sDataCbTimestamp,
487                               sGetMemory,
488                               this);
489    }
490}
491
492void CameraHardwareInterface::enableMsgType(int32_t msgType)
493{
494    ALOGV("%s(%s)", __FUNCTION__, mName.string());
495    if (CC_LIKELY(mHidlDevice != nullptr)) {
496        mHidlDevice->enableMsgType(msgType);
497    } else if (mDevice && mDevice->ops->enable_msg_type) {
498        mDevice->ops->enable_msg_type(mDevice, msgType);
499    }
500}
501
502void CameraHardwareInterface::disableMsgType(int32_t msgType)
503{
504    ALOGV("%s(%s)", __FUNCTION__, mName.string());
505    if (CC_LIKELY(mHidlDevice != nullptr)) {
506        mHidlDevice->disableMsgType(msgType);
507    } else if (mDevice && mDevice->ops->disable_msg_type) {
508        mDevice->ops->disable_msg_type(mDevice, msgType);
509    }
510}
511
512int CameraHardwareInterface::msgTypeEnabled(int32_t msgType)
513{
514    ALOGV("%s(%s)", __FUNCTION__, mName.string());
515    if (CC_LIKELY(mHidlDevice != nullptr)) {
516        return mHidlDevice->msgTypeEnabled(msgType);
517    } else if (mDevice && mDevice->ops->msg_type_enabled) {
518        return mDevice->ops->msg_type_enabled(mDevice, msgType);
519    }
520    return false;
521}
522
523status_t CameraHardwareInterface::startPreview()
524{
525    ALOGV("%s(%s)", __FUNCTION__, mName.string());
526    if (CC_LIKELY(mHidlDevice != nullptr)) {
527        return CameraProviderManager::mapToStatusT(
528                mHidlDevice->startPreview());
529    } else if (mDevice && mDevice->ops->start_preview) {
530        return mDevice->ops->start_preview(mDevice);
531    }
532    return INVALID_OPERATION;
533}
534
535void CameraHardwareInterface::stopPreview()
536{
537    ALOGV("%s(%s)", __FUNCTION__, mName.string());
538    if (CC_LIKELY(mHidlDevice != nullptr)) {
539        mHidlDevice->stopPreview();
540    } else if (mDevice && mDevice->ops->stop_preview) {
541        mDevice->ops->stop_preview(mDevice);
542    }
543}
544
545int CameraHardwareInterface::previewEnabled()
546{
547    ALOGV("%s(%s)", __FUNCTION__, mName.string());
548    if (CC_LIKELY(mHidlDevice != nullptr)) {
549        return mHidlDevice->previewEnabled();
550    } else if (mDevice && mDevice->ops->preview_enabled) {
551        return mDevice->ops->preview_enabled(mDevice);
552    }
553    return false;
554}
555
556status_t CameraHardwareInterface::storeMetaDataInBuffers(int enable)
557{
558    ALOGV("%s(%s)", __FUNCTION__, mName.string());
559    if (CC_LIKELY(mHidlDevice != nullptr)) {
560        return CameraProviderManager::mapToStatusT(
561                mHidlDevice->storeMetaDataInBuffers(enable));
562    } else if (mDevice && mDevice->ops->store_meta_data_in_buffers) {
563        return mDevice->ops->store_meta_data_in_buffers(mDevice, enable);
564    }
565    return enable ? INVALID_OPERATION: OK;
566}
567
568status_t CameraHardwareInterface::startRecording()
569{
570    ALOGV("%s(%s)", __FUNCTION__, mName.string());
571    if (CC_LIKELY(mHidlDevice != nullptr)) {
572        return CameraProviderManager::mapToStatusT(
573                mHidlDevice->startRecording());
574    } else if (mDevice && mDevice->ops->start_recording) {
575        return mDevice->ops->start_recording(mDevice);
576    }
577    return INVALID_OPERATION;
578}
579
580/**
581 * Stop a previously started recording.
582 */
583void CameraHardwareInterface::stopRecording()
584{
585    ALOGV("%s(%s)", __FUNCTION__, mName.string());
586    if (CC_LIKELY(mHidlDevice != nullptr)) {
587        mHidlDevice->stopRecording();
588    } else if (mDevice && mDevice->ops->stop_recording) {
589        mDevice->ops->stop_recording(mDevice);
590    }
591}
592
593/**
594 * Returns true if recording is enabled.
595 */
596int CameraHardwareInterface::recordingEnabled()
597{
598    ALOGV("%s(%s)", __FUNCTION__, mName.string());
599    if (CC_LIKELY(mHidlDevice != nullptr)) {
600        return mHidlDevice->recordingEnabled();
601    } else if (mDevice && mDevice->ops->recording_enabled) {
602        return mDevice->ops->recording_enabled(mDevice);
603    }
604    return false;
605}
606
607void CameraHardwareInterface::releaseRecordingFrame(const sp<IMemory>& mem)
608{
609    ALOGV("%s(%s)", __FUNCTION__, mName.string());
610    ssize_t offset;
611    size_t size;
612    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
613    int heapId = heap->getHeapID();
614    int bufferIndex = offset / size;
615    if (CC_LIKELY(mHidlDevice != nullptr)) {
616        if (size == sizeof(VideoNativeHandleMetadata)) {
617            VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) mem->pointer();
618            // Caching the handle here because md->pHandle will be subject to HAL's edit
619            native_handle_t* nh = md->pHandle;
620            hidl_handle frame = nh;
621            mHidlDevice->releaseRecordingFrameHandle(heapId, bufferIndex, frame);
622            native_handle_close(nh);
623            native_handle_delete(nh);
624        } else {
625            mHidlDevice->releaseRecordingFrame(heapId, bufferIndex);
626        }
627    } else if (mDevice && mDevice->ops->release_recording_frame) {
628        void *data = ((uint8_t *)heap->base()) + offset;
629        return mDevice->ops->release_recording_frame(mDevice, data);
630    }
631}
632
633void CameraHardwareInterface::releaseRecordingFrameBatch(const std::vector<sp<IMemory>>& frames)
634{
635    ALOGV("%s(%s)", __FUNCTION__, mName.string());
636    size_t n = frames.size();
637    std::vector<VideoFrameMessage> msgs;
638    msgs.reserve(n);
639    for (auto& mem : frames) {
640        if (CC_LIKELY(mHidlDevice != nullptr)) {
641            ssize_t offset;
642            size_t size;
643            sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
644            if (size == sizeof(VideoNativeHandleMetadata)) {
645                uint32_t heapId = heap->getHeapID();
646                uint32_t bufferIndex = offset / size;
647                VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) mem->pointer();
648                // Caching the handle here because md->pHandle will be subject to HAL's edit
649                native_handle_t* nh = md->pHandle;
650                VideoFrameMessage msg;
651                msgs.push_back({nh, heapId, bufferIndex});
652            } else {
653                ALOGE("%s only supports VideoNativeHandleMetadata mode", __FUNCTION__);
654                return;
655            }
656        } else {
657            ALOGE("Non HIDL mode do not support %s", __FUNCTION__);
658            return;
659        }
660    }
661
662    mHidlDevice->releaseRecordingFrameHandleBatch(msgs);
663
664    for (auto& msg : msgs) {
665        native_handle_t* nh = const_cast<native_handle_t*>(msg.frameData.getNativeHandle());
666        native_handle_close(nh);
667        native_handle_delete(nh);
668    }
669}
670
671status_t CameraHardwareInterface::autoFocus()
672{
673    ALOGV("%s(%s)", __FUNCTION__, mName.string());
674    if (CC_LIKELY(mHidlDevice != nullptr)) {
675        return CameraProviderManager::mapToStatusT(
676                mHidlDevice->autoFocus());
677    } else if (mDevice && mDevice->ops->auto_focus) {
678        return mDevice->ops->auto_focus(mDevice);
679    }
680    return INVALID_OPERATION;
681}
682
683status_t CameraHardwareInterface::cancelAutoFocus()
684{
685    ALOGV("%s(%s)", __FUNCTION__, mName.string());
686    if (CC_LIKELY(mHidlDevice != nullptr)) {
687        return CameraProviderManager::mapToStatusT(
688                mHidlDevice->cancelAutoFocus());
689    } else if (mDevice && mDevice->ops->cancel_auto_focus) {
690        return mDevice->ops->cancel_auto_focus(mDevice);
691    }
692    return INVALID_OPERATION;
693}
694
695status_t CameraHardwareInterface::takePicture()
696{
697    ALOGV("%s(%s)", __FUNCTION__, mName.string());
698    if (CC_LIKELY(mHidlDevice != nullptr)) {
699        return CameraProviderManager::mapToStatusT(
700                mHidlDevice->takePicture());
701    } else if (mDevice && mDevice->ops->take_picture) {
702        return mDevice->ops->take_picture(mDevice);
703    }
704    return INVALID_OPERATION;
705}
706
707status_t CameraHardwareInterface::cancelPicture()
708{
709    ALOGV("%s(%s)", __FUNCTION__, mName.string());
710    if (CC_LIKELY(mHidlDevice != nullptr)) {
711        return CameraProviderManager::mapToStatusT(
712                mHidlDevice->cancelPicture());
713    } else if (mDevice && mDevice->ops->cancel_picture) {
714        return mDevice->ops->cancel_picture(mDevice);
715    }
716    return INVALID_OPERATION;
717}
718
719status_t CameraHardwareInterface::setParameters(const CameraParameters &params)
720{
721    ALOGV("%s(%s)", __FUNCTION__, mName.string());
722    if (CC_LIKELY(mHidlDevice != nullptr)) {
723        return CameraProviderManager::mapToStatusT(
724                mHidlDevice->setParameters(params.flatten().string()));
725    } else if (mDevice && mDevice->ops->set_parameters) {
726        return mDevice->ops->set_parameters(mDevice, params.flatten().string());
727    }
728    return INVALID_OPERATION;
729}
730
731CameraParameters CameraHardwareInterface::getParameters() const
732{
733    ALOGV("%s(%s)", __FUNCTION__, mName.string());
734    CameraParameters parms;
735    if (CC_LIKELY(mHidlDevice != nullptr)) {
736        hardware::hidl_string outParam;
737        mHidlDevice->getParameters(
738                [&outParam](const auto& outStr) {
739                    outParam = outStr;
740                });
741        String8 tmp(outParam.c_str());
742        parms.unflatten(tmp);
743    } else if (mDevice && mDevice->ops->get_parameters) {
744        char *temp = mDevice->ops->get_parameters(mDevice);
745        String8 str_parms(temp);
746        if (mDevice->ops->put_parameters)
747            mDevice->ops->put_parameters(mDevice, temp);
748        else
749            free(temp);
750        parms.unflatten(str_parms);
751    }
752    return parms;
753}
754
755status_t CameraHardwareInterface::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
756{
757    ALOGV("%s(%s)", __FUNCTION__, mName.string());
758    if (CC_LIKELY(mHidlDevice != nullptr)) {
759        return CameraProviderManager::mapToStatusT(
760                mHidlDevice->sendCommand((CommandType) cmd, arg1, arg2));
761    } else if (mDevice && mDevice->ops->send_command) {
762        return mDevice->ops->send_command(mDevice, cmd, arg1, arg2);
763    }
764    return INVALID_OPERATION;
765}
766
767/**
768 * Release the hardware resources owned by this object.  Note that this is
769 * *not* done in the destructor.
770 */
771void CameraHardwareInterface::release() {
772    ALOGV("%s(%s)", __FUNCTION__, mName.string());
773    if (CC_LIKELY(mHidlDevice != nullptr)) {
774        mHidlDevice->close();
775        mHidlDevice.clear();
776    } else if (mDevice && mDevice->ops->release) {
777        mDevice->ops->release(mDevice);
778    }
779}
780
781/**
782 * Dump state of the camera hardware
783 */
784status_t CameraHardwareInterface::dump(int fd, const Vector<String16>& /*args*/) const
785{
786    ALOGV("%s(%s)", __FUNCTION__, mName.string());
787    if (CC_LIKELY(mHidlDevice != nullptr)) {
788        native_handle_t* handle = native_handle_create(1,0);
789        handle->data[0] = fd;
790        Status s = mHidlDevice->dumpState(handle);
791        native_handle_delete(handle);
792        return CameraProviderManager::mapToStatusT(s);
793    } else if (mDevice && mDevice->ops->dump) {
794        return mDevice->ops->dump(mDevice, fd);
795    }
796    return OK; // It's fine if the HAL doesn't implement dump()
797}
798
799/**
800 * Methods for legacy (non-HIDL) path follows
801 */
802void CameraHardwareInterface::sNotifyCb(int32_t msg_type, int32_t ext1,
803                        int32_t ext2, void *user)
804{
805    ALOGV("%s", __FUNCTION__);
806    CameraHardwareInterface *object =
807            static_cast<CameraHardwareInterface *>(user);
808    object->mNotifyCb(msg_type, ext1, ext2, object->mCbUser);
809}
810
811void CameraHardwareInterface::sDataCb(int32_t msg_type,
812                      const camera_memory_t *data, unsigned int index,
813                      camera_frame_metadata_t *metadata,
814                      void *user)
815{
816    ALOGV("%s", __FUNCTION__);
817    CameraHardwareInterface *object =
818            static_cast<CameraHardwareInterface *>(user);
819    sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
820    if (index >= mem->mNumBufs) {
821        ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
822             index, mem->mNumBufs);
823        return;
824    }
825    object->mDataCb(msg_type, mem->mBuffers[index], metadata, object->mCbUser);
826}
827
828void CameraHardwareInterface::sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type,
829                         const camera_memory_t *data, unsigned index,
830                         void *user)
831{
832    ALOGV("%s", __FUNCTION__);
833    CameraHardwareInterface *object =
834            static_cast<CameraHardwareInterface *>(user);
835    // Start refcounting the heap object from here on.  When the clients
836    // drop all references, it will be destroyed (as well as the enclosed
837    // MemoryHeapBase.
838    sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
839    if (index >= mem->mNumBufs) {
840        ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
841             index, mem->mNumBufs);
842        return;
843    }
844    object->mDataCbTimestamp(timestamp, msg_type, mem->mBuffers[index], object->mCbUser);
845}
846
847camera_memory_t* CameraHardwareInterface::sGetMemory(
848        int fd, size_t buf_size, uint_t num_bufs,
849        void *user __attribute__((unused)))
850{
851    CameraHeapMemory *mem;
852    if (fd < 0) {
853        mem = new CameraHeapMemory(buf_size, num_bufs);
854    } else {
855        mem = new CameraHeapMemory(fd, buf_size, num_bufs);
856    }
857    mem->incStrong(mem);
858    return &mem->handle;
859}
860
861void CameraHardwareInterface::sPutMemory(camera_memory_t *data)
862{
863    if (!data) {
864        return;
865    }
866
867    CameraHeapMemory *mem = static_cast<CameraHeapMemory *>(data->handle);
868    mem->decStrong(mem);
869}
870
871ANativeWindow* CameraHardwareInterface::sToAnw(void *user)
872{
873    CameraHardwareInterface *object =
874            reinterpret_cast<CameraHardwareInterface *>(user);
875    return object->mPreviewWindow.get();
876}
877#define anw(n) sToAnw(((struct camera_preview_window *)(n))->user)
878#define hwi(n) reinterpret_cast<CameraHardwareInterface *>(\
879    ((struct camera_preview_window *)(n))->user)
880
881int CameraHardwareInterface::sDequeueBuffer(struct preview_stream_ops* w,
882                            buffer_handle_t** buffer, int *stride)
883{
884    int rc;
885    ANativeWindow *a = anw(w);
886    ANativeWindowBuffer* anb;
887    rc = native_window_dequeue_buffer_and_wait(a, &anb);
888    if (rc == OK) {
889        *buffer = &anb->handle;
890        *stride = anb->stride;
891    }
892    return rc;
893}
894
895#ifndef container_of
896#define container_of(ptr, type, member) ({                      \
897    const __typeof__(((type *) 0)->member) *__mptr = (ptr);     \
898    (type *) ((char *) __mptr - (char *)(&((type *)0)->member)); })
899#endif
900
901int CameraHardwareInterface::sLockBuffer(struct preview_stream_ops* w,
902                  buffer_handle_t* /*buffer*/)
903{
904    ANativeWindow *a = anw(w);
905    (void)a;
906    return 0;
907}
908
909int CameraHardwareInterface::sEnqueueBuffer(struct preview_stream_ops* w,
910                  buffer_handle_t* buffer)
911{
912    ANativeWindow *a = anw(w);
913    return a->queueBuffer(a,
914              container_of(buffer, ANativeWindowBuffer, handle), -1);
915}
916
917int CameraHardwareInterface::sCancelBuffer(struct preview_stream_ops* w,
918                  buffer_handle_t* buffer)
919{
920    ANativeWindow *a = anw(w);
921    return a->cancelBuffer(a,
922              container_of(buffer, ANativeWindowBuffer, handle), -1);
923}
924
925int CameraHardwareInterface::sSetBufferCount(struct preview_stream_ops* w, int count)
926{
927    ANativeWindow *a = anw(w);
928
929    if (a != nullptr) {
930        // Workaround for b/27039775
931        // Previously, setting the buffer count would reset the buffer
932        // queue's flag that allows for all buffers to be dequeued on the
933        // producer side, instead of just the producer's declared max count,
934        // if no filled buffers have yet been queued by the producer.  This
935        // reset no longer happens, but some HALs depend on this behavior,
936        // so it needs to be maintained for HAL backwards compatibility.
937        // Simulate the prior behavior by disconnecting/reconnecting to the
938        // window and setting the values again.  This has the drawback of
939        // actually causing memory reallocation, which may not have happened
940        // in the past.
941        CameraHardwareInterface *hw = hwi(w);
942        native_window_api_disconnect(a, NATIVE_WINDOW_API_CAMERA);
943        native_window_api_connect(a, NATIVE_WINDOW_API_CAMERA);
944        if (hw->mPreviewScalingMode != NOT_SET) {
945            native_window_set_scaling_mode(a, hw->mPreviewScalingMode);
946        }
947        if (hw->mPreviewTransform != NOT_SET) {
948            native_window_set_buffers_transform(a, hw->mPreviewTransform);
949        }
950        if (hw->mPreviewWidth != NOT_SET) {
951            native_window_set_buffers_dimensions(a,
952                    hw->mPreviewWidth, hw->mPreviewHeight);
953            native_window_set_buffers_format(a, hw->mPreviewFormat);
954        }
955        if (hw->mPreviewUsage != 0) {
956            native_window_set_usage(a, hw->mPreviewUsage);
957        }
958        if (hw->mPreviewSwapInterval != NOT_SET) {
959            a->setSwapInterval(a, hw->mPreviewSwapInterval);
960        }
961        if (hw->mPreviewCrop.left != NOT_SET) {
962            native_window_set_crop(a, &(hw->mPreviewCrop));
963        }
964    }
965
966    return native_window_set_buffer_count(a, count);
967}
968
969int CameraHardwareInterface::sSetBuffersGeometry(struct preview_stream_ops* w,
970                  int width, int height, int format)
971{
972    int rc;
973    ANativeWindow *a = anw(w);
974    CameraHardwareInterface *hw = hwi(w);
975    hw->mPreviewWidth = width;
976    hw->mPreviewHeight = height;
977    hw->mPreviewFormat = format;
978    rc = native_window_set_buffers_dimensions(a, width, height);
979    if (rc == OK) {
980        rc = native_window_set_buffers_format(a, format);
981    }
982    return rc;
983}
984
985int CameraHardwareInterface::sSetCrop(struct preview_stream_ops *w,
986                  int left, int top, int right, int bottom)
987{
988    ANativeWindow *a = anw(w);
989    CameraHardwareInterface *hw = hwi(w);
990    hw->mPreviewCrop.left = left;
991    hw->mPreviewCrop.top = top;
992    hw->mPreviewCrop.right = right;
993    hw->mPreviewCrop.bottom = bottom;
994    return native_window_set_crop(a, &(hw->mPreviewCrop));
995}
996
997int CameraHardwareInterface::sSetTimestamp(struct preview_stream_ops *w,
998                           int64_t timestamp) {
999    ANativeWindow *a = anw(w);
1000    return native_window_set_buffers_timestamp(a, timestamp);
1001}
1002
1003int CameraHardwareInterface::sSetUsage(struct preview_stream_ops* w, int usage)
1004{
1005    ANativeWindow *a = anw(w);
1006    CameraHardwareInterface *hw = hwi(w);
1007    hw->mPreviewUsage = usage;
1008    return native_window_set_usage(a, usage);
1009}
1010
1011int CameraHardwareInterface::sSetSwapInterval(struct preview_stream_ops *w, int interval)
1012{
1013    ANativeWindow *a = anw(w);
1014    CameraHardwareInterface *hw = hwi(w);
1015    hw->mPreviewSwapInterval = interval;
1016    return a->setSwapInterval(a, interval);
1017}
1018
1019int CameraHardwareInterface::sGetMinUndequeuedBufferCount(
1020                  const struct preview_stream_ops *w,
1021                  int *count)
1022{
1023    ANativeWindow *a = anw(w);
1024    return a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, count);
1025}
1026
1027void CameraHardwareInterface::initHalPreviewWindow()
1028{
1029    mHalPreviewWindow.nw.cancel_buffer = sCancelBuffer;
1030    mHalPreviewWindow.nw.lock_buffer = sLockBuffer;
1031    mHalPreviewWindow.nw.dequeue_buffer = sDequeueBuffer;
1032    mHalPreviewWindow.nw.enqueue_buffer = sEnqueueBuffer;
1033    mHalPreviewWindow.nw.set_buffer_count = sSetBufferCount;
1034    mHalPreviewWindow.nw.set_buffers_geometry = sSetBuffersGeometry;
1035    mHalPreviewWindow.nw.set_crop = sSetCrop;
1036    mHalPreviewWindow.nw.set_timestamp = sSetTimestamp;
1037    mHalPreviewWindow.nw.set_usage = sSetUsage;
1038    mHalPreviewWindow.nw.set_swap_interval = sSetSwapInterval;
1039
1040    mHalPreviewWindow.nw.get_min_undequeued_buffer_count =
1041            sGetMinUndequeuedBufferCount;
1042}
1043
1044}; // namespace android
1045