Camera.cpp revision 2b286dab84b2a0524c1deed67fea92200e598c6e 
1/*
2 * Copyright (C) 2012 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#include <cstdlib>
18#include <pthread.h>
19#include <hardware/camera3.h>
20#include <sync/sync.h>
21#include <system/camera_metadata.h>
22#include <system/graphics.h>
23#include "CameraHAL.h"
24#include "Metadata.h"
25#include "Stream.h"
26
27//#define LOG_NDEBUG 0
28#define LOG_TAG "Camera"
29#include <cutils/log.h>
30
31#define ATRACE_TAG (ATRACE_TAG_CAMERA | ATRACE_TAG_HAL)
32#include <cutils/trace.h>
33#include "ScopedTrace.h"
34
35#include "Camera.h"
36
37#define CAMERA_SYNC_TIMEOUT 5000 // in msecs
38
39#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
40
41namespace default_camera_hal {
42
43extern "C" {
44// Shim passed to the framework to close an opened device.
45static int close_device(hw_device_t* dev)
46{
47    camera3_device_t* cam_dev = reinterpret_cast<camera3_device_t*>(dev);
48    Camera* cam = static_cast<Camera*>(cam_dev->priv);
49    return cam->close();
50}
51} // extern "C"
52
53Camera::Camera(int id)
54  : mId(id),
55    mStaticInfo(NULL),
56    mBusy(false),
57    mCallbackOps(NULL),
58    mStreams(NULL),
59    mNumStreams(0),
60    mSettings(NULL)
61{
62    pthread_mutex_init(&mMutex,
63                       NULL); // No pthread mutex attributes.
64
65    memset(&mDevice, 0, sizeof(mDevice));
66    mDevice.common.tag    = HARDWARE_DEVICE_TAG;
67    mDevice.common.version = CAMERA_DEVICE_API_VERSION_3_0;
68    mDevice.common.close  = close_device;
69    mDevice.ops           = const_cast<camera3_device_ops_t*>(&sOps);
70    mDevice.priv          = this;
71}
72
73Camera::~Camera()
74{
75}
76
77int Camera::open(const hw_module_t *module, hw_device_t **device)
78{
79    ALOGI("%s:%d: Opening camera device", __func__, mId);
80    CAMTRACE_CALL();
81    pthread_mutex_lock(&mMutex);
82    if (mBusy) {
83        pthread_mutex_unlock(&mMutex);
84        ALOGE("%s:%d: Error! Camera device already opened", __func__, mId);
85        return -EBUSY;
86    }
87
88    // TODO: open camera dev nodes, etc
89    mBusy = true;
90    mDevice.common.module = const_cast<hw_module_t*>(module);
91    *device = &mDevice.common;
92
93    pthread_mutex_unlock(&mMutex);
94    return 0;
95}
96
97int Camera::getInfo(struct camera_info *info)
98{
99    int ret = 0;
100
101    info->facing = CAMERA_FACING_FRONT;
102    info->orientation = 0;
103    info->device_version = mDevice.common.version;
104
105    pthread_mutex_lock(&mMutex);
106    if (mStaticInfo == NULL) {
107        ret = initStaticInfo();
108    }
109    pthread_mutex_unlock(&mMutex);
110
111    info->static_camera_characteristics = mStaticInfo;
112
113    return ret;
114}
115
116int Camera::close()
117{
118    ALOGI("%s:%d: Closing camera device", __func__, mId);
119    CAMTRACE_CALL();
120    pthread_mutex_lock(&mMutex);
121    if (!mBusy) {
122        pthread_mutex_unlock(&mMutex);
123        ALOGE("%s:%d: Error! Camera device not open", __func__, mId);
124        return -EINVAL;
125    }
126
127    // TODO: close camera dev nodes, etc
128    mBusy = false;
129
130    pthread_mutex_unlock(&mMutex);
131    return 0;
132}
133
134int Camera::initialize(const camera3_callback_ops_t *callback_ops)
135{
136    ALOGV("%s:%d: callback_ops=%p", __func__, mId, callback_ops);
137    mCallbackOps = callback_ops;
138    // Create standard settings templates
139    // 0 is invalid as template
140    mTemplates[0] = NULL;
141    // CAMERA3_TEMPLATE_PREVIEW = 1
142    mTemplates[1] = new Metadata(ANDROID_CONTROL_MODE_OFF,
143            ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW);
144    // CAMERA3_TEMPLATE_STILL_CAPTURE = 2
145    mTemplates[2] = new Metadata(ANDROID_CONTROL_MODE_OFF,
146            ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE);
147    // CAMERA3_TEMPLATE_VIDEO_RECORD = 3
148    mTemplates[3] = new Metadata(ANDROID_CONTROL_MODE_OFF,
149            ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD);
150    // CAMERA3_TEMPLATE_VIDEO_SNAPSHOT = 4
151    mTemplates[4] = new Metadata(ANDROID_CONTROL_MODE_OFF,
152            ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT);
153    // CAMERA3_TEMPLATE_STILL_ZERO_SHUTTER_LAG = 5
154    mTemplates[5] = new Metadata(ANDROID_CONTROL_MODE_OFF,
155            ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG);
156    // Pre-generate metadata structures
157    for (int i = 1; i < CAMERA3_TEMPLATE_COUNT; i++) {
158        mTemplates[i]->generate();
159    }
160    // TODO: create vendor templates
161    return 0;
162}
163
164int Camera::initStaticInfo()
165{
166    /*
167     * Setup static camera info.  This will have to customized per camera
168     * device.
169     */
170
171    /* android.control */
172    int32_t android_control_ae_available_target_fps_ranges[] = {30, 30};
173    mMetadata.addInt32(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
174            ARRAY_SIZE(android_control_ae_available_target_fps_ranges),
175            android_control_ae_available_target_fps_ranges);
176
177    int32_t android_control_ae_compensation_range[] = {-4, 4};
178    mMetadata.addInt32(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
179            ARRAY_SIZE(android_control_ae_compensation_range),
180            android_control_ae_compensation_range);
181
182    camera_metadata_rational_t android_control_ae_compensation_step[] = {{2,1}};
183    mMetadata.addRational(ANDROID_CONTROL_AE_COMPENSATION_STEP,
184            ARRAY_SIZE(android_control_ae_compensation_step),
185            android_control_ae_compensation_step);
186
187    int32_t android_control_max_regions[] = {1};
188    mMetadata.addInt32(ANDROID_CONTROL_MAX_REGIONS,
189            ARRAY_SIZE(android_control_max_regions),
190            android_control_max_regions);
191
192    /* android.jpeg */
193    int32_t android_jpeg_available_thumbnail_sizes[] = {0, 0, 128, 96};
194    mMetadata.addInt32(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
195            ARRAY_SIZE(android_jpeg_available_thumbnail_sizes),
196            android_jpeg_available_thumbnail_sizes);
197
198    /* android.lens */
199    float android_lens_info_available_focal_lengths[] = {1.0};
200    mMetadata.addFloat(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
201            ARRAY_SIZE(android_lens_info_available_focal_lengths),
202            android_lens_info_available_focal_lengths);
203
204    /* android.request */
205    int32_t android_request_max_num_output_streams[] = {0, 3, 1};
206    mMetadata.addInt32(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
207            ARRAY_SIZE(android_request_max_num_output_streams),
208            android_request_max_num_output_streams);
209
210    /* android.scaler */
211    int32_t android_scaler_available_formats[] = {
212            HAL_PIXEL_FORMAT_RAW_SENSOR,
213            HAL_PIXEL_FORMAT_BLOB,
214            HAL_PIXEL_FORMAT_RGBA_8888,
215            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
216            // These are handled by YCbCr_420_888
217            //        HAL_PIXEL_FORMAT_YV12,
218            //        HAL_PIXEL_FORMAT_YCrCb_420_SP,
219            HAL_PIXEL_FORMAT_YCbCr_420_888};
220    mMetadata.addInt32(ANDROID_SCALER_AVAILABLE_FORMATS,
221            ARRAY_SIZE(android_scaler_available_formats),
222            android_scaler_available_formats);
223
224    int64_t android_scaler_available_jpeg_min_durations[] = {1};
225    mMetadata.addInt64(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
226            ARRAY_SIZE(android_scaler_available_jpeg_min_durations),
227            android_scaler_available_jpeg_min_durations);
228
229    int32_t android_scaler_available_jpeg_sizes[] = {640, 480};
230    mMetadata.addInt32(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
231            ARRAY_SIZE(android_scaler_available_jpeg_sizes),
232            android_scaler_available_jpeg_sizes);
233
234    float android_scaler_available_max_digital_zoom[] = {1};
235    mMetadata.addFloat(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
236            ARRAY_SIZE(android_scaler_available_max_digital_zoom),
237            android_scaler_available_max_digital_zoom);
238
239    int64_t android_scaler_available_processed_min_durations[] = {1};
240    mMetadata.addInt64(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
241            ARRAY_SIZE(android_scaler_available_processed_min_durations),
242            android_scaler_available_processed_min_durations);
243
244    int32_t android_scaler_available_processed_sizes[] = {640, 480};
245    mMetadata.addInt32(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
246            ARRAY_SIZE(android_scaler_available_processed_sizes),
247            android_scaler_available_processed_sizes);
248
249    int64_t android_scaler_available_raw_min_durations[] = {1};
250    mMetadata.addInt64(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
251            ARRAY_SIZE(android_scaler_available_raw_min_durations),
252            android_scaler_available_raw_min_durations);
253
254    int32_t android_scaler_available_raw_sizes[] = {640, 480};
255    mMetadata.addInt32(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
256            ARRAY_SIZE(android_scaler_available_raw_sizes),
257            android_scaler_available_raw_sizes);
258
259    /* android.sensor */
260
261    int32_t android_sensor_info_active_array_size[] = {0, 0, 640, 480};
262    mMetadata.addInt32(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
263            ARRAY_SIZE(android_sensor_info_active_array_size),
264            android_sensor_info_active_array_size);
265
266    int32_t android_sensor_info_available_sensitivities[] =
267            {100, 200, 400, 800, 1600};
268    mMetadata.addInt32(ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES,
269            ARRAY_SIZE(android_sensor_info_available_sensitivities),
270            android_sensor_info_available_sensitivities);
271
272    int64_t android_sensor_info_max_frame_duration[] = {30000000000};
273    mMetadata.addInt64(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
274            ARRAY_SIZE(android_sensor_info_max_frame_duration),
275            android_sensor_info_max_frame_duration);
276
277    float android_sensor_info_physical_size[] = {3.2, 2.4};
278    mMetadata.addFloat(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
279            ARRAY_SIZE(android_sensor_info_physical_size),
280            android_sensor_info_physical_size);
281
282    int32_t android_sensor_info_pixel_array_size[] = {640, 480};
283    mMetadata.addInt32(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
284            ARRAY_SIZE(android_sensor_info_pixel_array_size),
285            android_sensor_info_pixel_array_size);
286
287    int32_t android_sensor_orientation[] = {0};
288    mMetadata.addInt32(ANDROID_SENSOR_ORIENTATION,
289            ARRAY_SIZE(android_sensor_orientation),
290            android_sensor_orientation);
291
292    /* End of static camera characteristics */
293
294    mStaticInfo = mMetadata.generate();
295
296    return 0;
297}
298
299int Camera::configureStreams(camera3_stream_configuration_t *stream_config)
300{
301    camera3_stream_t *astream;
302    Stream **newStreams = NULL;
303
304    CAMTRACE_CALL();
305    ALOGV("%s:%d: stream_config=%p", __func__, mId, stream_config);
306
307    if (stream_config == NULL) {
308        ALOGE("%s:%d: NULL stream configuration array", __func__, mId);
309        return -EINVAL;
310    }
311    if (stream_config->num_streams == 0) {
312        ALOGE("%s:%d: Empty stream configuration array", __func__, mId);
313        return -EINVAL;
314    }
315
316    // Create new stream array
317    newStreams = new Stream*[stream_config->num_streams];
318    ALOGV("%s:%d: Number of Streams: %d", __func__, mId,
319            stream_config->num_streams);
320
321    pthread_mutex_lock(&mMutex);
322
323    // Mark all current streams unused for now
324    for (int i = 0; i < mNumStreams; i++)
325        mStreams[i]->mReuse = false;
326    // Fill new stream array with reused streams and new streams
327    for (unsigned int i = 0; i < stream_config->num_streams; i++) {
328        astream = stream_config->streams[i];
329        if (astream->max_buffers > 0) {
330            ALOGV("%s:%d: Reusing stream %d", __func__, mId, i);
331            newStreams[i] = reuseStream(astream);
332        } else {
333            ALOGV("%s:%d: Creating new stream %d", __func__, mId, i);
334            newStreams[i] = new Stream(mId, astream);
335        }
336
337        if (newStreams[i] == NULL) {
338            ALOGE("%s:%d: Error processing stream %d", __func__, mId, i);
339            goto err_out;
340        }
341        astream->priv = newStreams[i];
342    }
343
344    // Verify the set of streams in aggregate
345    if (!isValidStreamSet(newStreams, stream_config->num_streams)) {
346        ALOGE("%s:%d: Invalid stream set", __func__, mId);
347        goto err_out;
348    }
349
350    // Set up all streams (calculate usage/max_buffers for each)
351    setupStreams(newStreams, stream_config->num_streams);
352
353    // Destroy all old streams and replace stream array with new one
354    destroyStreams(mStreams, mNumStreams);
355    mStreams = newStreams;
356    mNumStreams = stream_config->num_streams;
357
358    // Clear out last seen settings metadata
359    setSettings(NULL);
360
361    pthread_mutex_unlock(&mMutex);
362    return 0;
363
364err_out:
365    // Clean up temporary streams, preserve existing mStreams/mNumStreams
366    destroyStreams(newStreams, stream_config->num_streams);
367    pthread_mutex_unlock(&mMutex);
368    return -EINVAL;
369}
370
371void Camera::destroyStreams(Stream **streams, int count)
372{
373    if (streams == NULL)
374        return;
375    for (int i = 0; i < count; i++) {
376        // Only destroy streams that weren't reused
377        if (streams[i] != NULL && !streams[i]->mReuse)
378            delete streams[i];
379    }
380    delete [] streams;
381}
382
383Stream *Camera::reuseStream(camera3_stream_t *astream)
384{
385    Stream *priv = reinterpret_cast<Stream*>(astream->priv);
386    // Verify the re-used stream's parameters match
387    if (!priv->isValidReuseStream(mId, astream)) {
388        ALOGE("%s:%d: Mismatched parameter in reused stream", __func__, mId);
389        return NULL;
390    }
391    // Mark stream to be reused
392    priv->mReuse = true;
393    return priv;
394}
395
396bool Camera::isValidStreamSet(Stream **streams, int count)
397{
398    int inputs = 0;
399    int outputs = 0;
400
401    if (streams == NULL) {
402        ALOGE("%s:%d: NULL stream configuration streams", __func__, mId);
403        return false;
404    }
405    if (count == 0) {
406        ALOGE("%s:%d: Zero count stream configuration streams", __func__, mId);
407        return false;
408    }
409    // Validate there is at most one input stream and at least one output stream
410    for (int i = 0; i < count; i++) {
411        // A stream may be both input and output (bidirectional)
412        if (streams[i]->isInputType())
413            inputs++;
414        if (streams[i]->isOutputType())
415            outputs++;
416    }
417    ALOGV("%s:%d: Configuring %d output streams and %d input streams",
418            __func__, mId, outputs, inputs);
419    if (outputs < 1) {
420        ALOGE("%s:%d: Stream config must have >= 1 output", __func__, mId);
421        return false;
422    }
423    if (inputs > 1) {
424        ALOGE("%s:%d: Stream config must have <= 1 input", __func__, mId);
425        return false;
426    }
427    // TODO: check for correct number of Bayer/YUV/JPEG/Encoder streams
428    return true;
429}
430
431void Camera::setupStreams(Stream **streams, int count)
432{
433    /*
434     * This is where the HAL has to decide internally how to handle all of the
435     * streams, and then produce usage and max_buffer values for each stream.
436     * Note, the stream array has been checked before this point for ALL invalid
437     * conditions, so it must find a successful configuration for this stream
438     * array.  The HAL may not return an error from this point.
439     *
440     * In this demo HAL, we just set all streams to be the same dummy values;
441     * real implementations will want to avoid USAGE_SW_{READ|WRITE}_OFTEN.
442     */
443    for (int i = 0; i < count; i++) {
444        uint32_t usage = 0;
445
446        if (streams[i]->isOutputType())
447            usage |= GRALLOC_USAGE_SW_WRITE_OFTEN |
448                     GRALLOC_USAGE_HW_CAMERA_WRITE;
449        if (streams[i]->isInputType())
450            usage |= GRALLOC_USAGE_SW_READ_OFTEN |
451                     GRALLOC_USAGE_HW_CAMERA_READ;
452
453        streams[i]->setUsage(usage);
454        streams[i]->setMaxBuffers(1);
455    }
456}
457
458int Camera::registerStreamBuffers(const camera3_stream_buffer_set_t *buf_set)
459{
460    ALOGV("%s:%d: buffer_set=%p", __func__, mId, buf_set);
461    if (buf_set == NULL) {
462        ALOGE("%s:%d: NULL buffer set", __func__, mId);
463        return -EINVAL;
464    }
465    if (buf_set->stream == NULL) {
466        ALOGE("%s:%d: NULL stream handle", __func__, mId);
467        return -EINVAL;
468    }
469    Stream *stream = reinterpret_cast<Stream*>(buf_set->stream->priv);
470    return stream->registerBuffers(buf_set);
471}
472
473const camera_metadata_t* Camera::constructDefaultRequestSettings(int type)
474{
475    ALOGV("%s:%d: type=%d", __func__, mId, type);
476
477    if (type < 1 || type >= CAMERA3_TEMPLATE_COUNT) {
478        ALOGE("%s:%d: Invalid template request type: %d", __func__, mId, type);
479        return NULL;
480    }
481    return mTemplates[type]->generate();
482}
483
484int Camera::processCaptureRequest(camera3_capture_request_t *request)
485{
486    camera3_capture_result result;
487
488    ALOGV("%s:%d: request=%p", __func__, mId, request);
489    CAMTRACE_CALL();
490
491    if (request == NULL) {
492        ALOGE("%s:%d: NULL request recieved", __func__, mId);
493        return -EINVAL;
494    }
495
496    ALOGV("%s:%d: Request Frame:%d Settings:%p", __func__, mId,
497            request->frame_number, request->settings);
498
499    // NULL indicates use last settings
500    if (request->settings == NULL) {
501        if (mSettings == NULL) {
502            ALOGE("%s:%d: NULL settings without previous set Frame:%d Req:%p",
503                    __func__, mId, request->frame_number, request);
504            return -EINVAL;
505        }
506    } else {
507        setSettings(request->settings);
508    }
509
510    if (request->input_buffer != NULL) {
511        ALOGV("%s:%d: Reprocessing input buffer %p", __func__, mId,
512                request->input_buffer);
513
514        if (!isValidReprocessSettings(request->settings)) {
515            ALOGE("%s:%d: Invalid settings for reprocess request: %p",
516                    __func__, mId, request->settings);
517            return -EINVAL;
518        }
519    } else {
520        ALOGV("%s:%d: Capturing new frame.", __func__, mId);
521
522        if (!isValidCaptureSettings(request->settings)) {
523            ALOGE("%s:%d: Invalid settings for capture request: %p",
524                    __func__, mId, request->settings);
525            return -EINVAL;
526        }
527    }
528
529    if (request->num_output_buffers <= 0) {
530        ALOGE("%s:%d: Invalid number of output buffers: %d", __func__, mId,
531                request->num_output_buffers);
532        return -EINVAL;
533    }
534    result.num_output_buffers = request->num_output_buffers;
535    result.output_buffers = new camera3_stream_buffer_t[result.num_output_buffers];
536    for (unsigned int i = 0; i < request->num_output_buffers; i++) {
537        int res = processCaptureBuffer(&request->output_buffers[i],
538                const_cast<camera3_stream_buffer_t*>(&result.output_buffers[i]));
539        if (res)
540            goto err_out;
541    }
542
543    result.frame_number = request->frame_number;
544    // TODO: return actual captured/reprocessed settings
545    result.result = request->settings;
546    // TODO: asynchronously return results
547    mCallbackOps->process_capture_result(mCallbackOps, &result);
548
549    return 0;
550
551err_out:
552    delete [] result.output_buffers;
553    // TODO: this should probably be a total device failure; transient for now
554    return -EINVAL;
555}
556
557void Camera::setSettings(const camera_metadata_t *new_settings)
558{
559    if (mSettings != NULL) {
560        free_camera_metadata(mSettings);
561        mSettings = NULL;
562    }
563
564    if (new_settings != NULL)
565        mSettings = clone_camera_metadata(new_settings);
566}
567
568bool Camera::isValidCaptureSettings(const camera_metadata_t* /*settings*/)
569{
570    // TODO: reject settings that cannot be captured
571    return true;
572}
573
574bool Camera::isValidReprocessSettings(const camera_metadata_t* /*settings*/)
575{
576    // TODO: reject settings that cannot be reprocessed
577    // input buffers unimplemented, use this to reject reprocessing requests
578    ALOGE("%s:%d: Input buffer reprocessing not implemented", __func__, mId);
579    return false;
580}
581
582int Camera::processCaptureBuffer(const camera3_stream_buffer_t *in,
583        camera3_stream_buffer_t *out)
584{
585    int res = sync_wait(in->acquire_fence, CAMERA_SYNC_TIMEOUT);
586    if (res == -ETIME) {
587        ALOGE("%s:%d: Timeout waiting on buffer acquire fence", __func__, mId);
588        return res;
589    } else if (res) {
590        ALOGE("%s:%d: Error waiting on buffer acquire fence: %s(%d)",
591                __func__, mId, strerror(-res), res);
592        return res;
593    }
594
595    out->stream = in->stream;
596    out->buffer = in->buffer;
597    out->status = CAMERA3_BUFFER_STATUS_OK;
598    // TODO: use driver-backed release fences
599    out->acquire_fence = -1;
600    out->release_fence = -1;
601
602    // TODO: lock and software-paint buffer
603    return 0;
604}
605
606void Camera::getMetadataVendorTagOps(vendor_tag_query_ops_t *ops)
607{
608    ALOGV("%s:%d: ops=%p", __func__, mId, ops);
609    // TODO: return vendor tag ops
610}
611
612void Camera::dump(int fd)
613{
614    ALOGV("%s:%d: Dumping to fd %d", __func__, mId, fd);
615    // TODO: dprintf all relevant state to fd
616}
617
618extern "C" {
619// Get handle to camera from device priv data
620static Camera *camdev_to_camera(const camera3_device_t *dev)
621{
622    return reinterpret_cast<Camera*>(dev->priv);
623}
624
625static int initialize(const camera3_device_t *dev,
626        const camera3_callback_ops_t *callback_ops)
627{
628    return camdev_to_camera(dev)->initialize(callback_ops);
629}
630
631static int configure_streams(const camera3_device_t *dev,
632        camera3_stream_configuration_t *stream_list)
633{
634    return camdev_to_camera(dev)->configureStreams(stream_list);
635}
636
637static int register_stream_buffers(const camera3_device_t *dev,
638        const camera3_stream_buffer_set_t *buffer_set)
639{
640    return camdev_to_camera(dev)->registerStreamBuffers(buffer_set);
641}
642
643static const camera_metadata_t *construct_default_request_settings(
644        const camera3_device_t *dev, int type)
645{
646    return camdev_to_camera(dev)->constructDefaultRequestSettings(type);
647}
648
649static int process_capture_request(const camera3_device_t *dev,
650        camera3_capture_request_t *request)
651{
652    return camdev_to_camera(dev)->processCaptureRequest(request);
653}
654
655static void get_metadata_vendor_tag_ops(const camera3_device_t *dev,
656        vendor_tag_query_ops_t *ops)
657{
658    camdev_to_camera(dev)->getMetadataVendorTagOps(ops);
659}
660
661static void dump(const camera3_device_t *dev, int fd)
662{
663    camdev_to_camera(dev)->dump(fd);
664}
665} // extern "C"
666
667const camera3_device_ops_t Camera::sOps = {
668    .initialize              = default_camera_hal::initialize,
669    .configure_streams       = default_camera_hal::configure_streams,
670    .register_stream_buffers = default_camera_hal::register_stream_buffers,
671    .construct_default_request_settings =
672            default_camera_hal::construct_default_request_settings,
673    .process_capture_request = default_camera_hal::process_capture_request,
674    .get_metadata_vendor_tag_ops =
675            default_camera_hal::get_metadata_vendor_tag_ops,
676    .dump                    = default_camera_hal::dump
677};
678
679} // namespace default_camera_hal
680