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, NULL);
63    pthread_mutex_init(&mStaticInfoMutex, NULL);
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    pthread_mutex_destroy(&mMutex);
76    pthread_mutex_destroy(&mStaticInfoMutex);
77}
78
79int Camera::open(const hw_module_t *module, hw_device_t **device)
80{
81    ALOGI("%s:%d: Opening camera device", __func__, mId);
82    CAMTRACE_CALL();
83    pthread_mutex_lock(&mMutex);
84    if (mBusy) {
85        pthread_mutex_unlock(&mMutex);
86        ALOGE("%s:%d: Error! Camera device already opened", __func__, mId);
87        return -EBUSY;
88    }
89
90    // TODO: open camera dev nodes, etc
91    mBusy = true;
92    mDevice.common.module = const_cast<hw_module_t*>(module);
93    *device = &mDevice.common;
94
95    pthread_mutex_unlock(&mMutex);
96    return 0;
97}
98
99int Camera::getInfo(struct camera_info *info)
100{
101    info->facing = CAMERA_FACING_FRONT;
102    info->orientation = 0;
103    info->device_version = mDevice.common.version;
104
105    pthread_mutex_lock(&mStaticInfoMutex);
106    if (mStaticInfo == NULL) {
107        mStaticInfo = initStaticInfo();
108    }
109    pthread_mutex_unlock(&mStaticInfoMutex);
110
111    info->static_camera_characteristics = mStaticInfo;
112
113    return 0;
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
164camera_metadata_t *Camera::initStaticInfo()
165{
166    /*
167     * Setup static camera info.  This will have to customized per camera
168     * device.
169     */
170    Metadata m;
171
172    /* android.control */
173    int32_t android_control_ae_available_target_fps_ranges[] = {30, 30};
174    m.addInt32(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
175            ARRAY_SIZE(android_control_ae_available_target_fps_ranges),
176            android_control_ae_available_target_fps_ranges);
177
178    int32_t android_control_ae_compensation_range[] = {-4, 4};
179    m.addInt32(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
180            ARRAY_SIZE(android_control_ae_compensation_range),
181            android_control_ae_compensation_range);
182
183    camera_metadata_rational_t android_control_ae_compensation_step[] = {{2,1}};
184    m.addRational(ANDROID_CONTROL_AE_COMPENSATION_STEP,
185            ARRAY_SIZE(android_control_ae_compensation_step),
186            android_control_ae_compensation_step);
187
188    int32_t android_control_max_regions[] = {1};
189    m.addInt32(ANDROID_CONTROL_MAX_REGIONS,
190            ARRAY_SIZE(android_control_max_regions),
191            android_control_max_regions);
192
193    /* android.jpeg */
194    int32_t android_jpeg_available_thumbnail_sizes[] = {0, 0, 128, 96};
195    m.addInt32(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
196            ARRAY_SIZE(android_jpeg_available_thumbnail_sizes),
197            android_jpeg_available_thumbnail_sizes);
198
199    /* android.lens */
200    float android_lens_info_available_focal_lengths[] = {1.0};
201    m.addFloat(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
202            ARRAY_SIZE(android_lens_info_available_focal_lengths),
203            android_lens_info_available_focal_lengths);
204
205    /* android.request */
206    int32_t android_request_max_num_output_streams[] = {0, 3, 1};
207    m.addInt32(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
208            ARRAY_SIZE(android_request_max_num_output_streams),
209            android_request_max_num_output_streams);
210
211    /* android.scaler */
212    int32_t android_scaler_available_formats[] = {
213            HAL_PIXEL_FORMAT_RAW_SENSOR,
214            HAL_PIXEL_FORMAT_BLOB,
215            HAL_PIXEL_FORMAT_RGBA_8888,
216            HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
217            // These are handled by YCbCr_420_888
218            //        HAL_PIXEL_FORMAT_YV12,
219            //        HAL_PIXEL_FORMAT_YCrCb_420_SP,
220            HAL_PIXEL_FORMAT_YCbCr_420_888};
221    m.addInt32(ANDROID_SCALER_AVAILABLE_FORMATS,
222            ARRAY_SIZE(android_scaler_available_formats),
223            android_scaler_available_formats);
224
225    int64_t android_scaler_available_jpeg_min_durations[] = {1};
226    m.addInt64(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
227            ARRAY_SIZE(android_scaler_available_jpeg_min_durations),
228            android_scaler_available_jpeg_min_durations);
229
230    int32_t android_scaler_available_jpeg_sizes[] = {640, 480};
231    m.addInt32(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
232            ARRAY_SIZE(android_scaler_available_jpeg_sizes),
233            android_scaler_available_jpeg_sizes);
234
235    float android_scaler_available_max_digital_zoom[] = {1};
236    m.addFloat(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
237            ARRAY_SIZE(android_scaler_available_max_digital_zoom),
238            android_scaler_available_max_digital_zoom);
239
240    int64_t android_scaler_available_processed_min_durations[] = {1};
241    m.addInt64(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
242            ARRAY_SIZE(android_scaler_available_processed_min_durations),
243            android_scaler_available_processed_min_durations);
244
245    int32_t android_scaler_available_processed_sizes[] = {640, 480};
246    m.addInt32(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
247            ARRAY_SIZE(android_scaler_available_processed_sizes),
248            android_scaler_available_processed_sizes);
249
250    int64_t android_scaler_available_raw_min_durations[] = {1};
251    m.addInt64(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
252            ARRAY_SIZE(android_scaler_available_raw_min_durations),
253            android_scaler_available_raw_min_durations);
254
255    int32_t android_scaler_available_raw_sizes[] = {640, 480};
256    m.addInt32(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
257            ARRAY_SIZE(android_scaler_available_raw_sizes),
258            android_scaler_available_raw_sizes);
259
260    /* android.sensor */
261
262    int32_t android_sensor_info_active_array_size[] = {0, 0, 640, 480};
263    m.addInt32(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
264            ARRAY_SIZE(android_sensor_info_active_array_size),
265            android_sensor_info_active_array_size);
266
267    int32_t android_sensor_info_sensitivity_range[] =
268            {100, 1600};
269    m.addInt32(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
270            ARRAY_SIZE(android_sensor_info_sensitivity_range),
271            android_sensor_info_sensitivity_range);
272
273    int64_t android_sensor_info_max_frame_duration[] = {30000000000};
274    m.addInt64(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
275            ARRAY_SIZE(android_sensor_info_max_frame_duration),
276            android_sensor_info_max_frame_duration);
277
278    float android_sensor_info_physical_size[] = {3.2, 2.4};
279    m.addFloat(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
280            ARRAY_SIZE(android_sensor_info_physical_size),
281            android_sensor_info_physical_size);
282
283    int32_t android_sensor_info_pixel_array_size[] = {640, 480};
284    m.addInt32(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
285            ARRAY_SIZE(android_sensor_info_pixel_array_size),
286            android_sensor_info_pixel_array_size);
287
288    int32_t android_sensor_orientation[] = {0};
289    m.addInt32(ANDROID_SENSOR_ORIENTATION,
290            ARRAY_SIZE(android_sensor_orientation),
291            android_sensor_orientation);
292
293    /* End of static camera characteristics */
294
295    return clone_camera_metadata(m.generate());
296}
297
298int Camera::configureStreams(camera3_stream_configuration_t *stream_config)
299{
300    camera3_stream_t *astream;
301    Stream **newStreams = NULL;
302
303    CAMTRACE_CALL();
304    ALOGV("%s:%d: stream_config=%p", __func__, mId, stream_config);
305
306    if (stream_config == NULL) {
307        ALOGE("%s:%d: NULL stream configuration array", __func__, mId);
308        return -EINVAL;
309    }
310    if (stream_config->num_streams == 0) {
311        ALOGE("%s:%d: Empty stream configuration array", __func__, mId);
312        return -EINVAL;
313    }
314
315    // Create new stream array
316    newStreams = new Stream*[stream_config->num_streams];
317    ALOGV("%s:%d: Number of Streams: %d", __func__, mId,
318            stream_config->num_streams);
319
320    pthread_mutex_lock(&mMutex);
321
322    // Mark all current streams unused for now
323    for (int i = 0; i < mNumStreams; i++)
324        mStreams[i]->mReuse = false;
325    // Fill new stream array with reused streams and new streams
326    for (unsigned int i = 0; i < stream_config->num_streams; i++) {
327        astream = stream_config->streams[i];
328        if (astream->max_buffers > 0) {
329            ALOGV("%s:%d: Reusing stream %d", __func__, mId, i);
330            newStreams[i] = reuseStream(astream);
331        } else {
332            ALOGV("%s:%d: Creating new stream %d", __func__, mId, i);
333            newStreams[i] = new Stream(mId, astream);
334        }
335
336        if (newStreams[i] == NULL) {
337            ALOGE("%s:%d: Error processing stream %d", __func__, mId, i);
338            goto err_out;
339        }
340        astream->priv = newStreams[i];
341    }
342
343    // Verify the set of streams in aggregate
344    if (!isValidStreamSet(newStreams, stream_config->num_streams)) {
345        ALOGE("%s:%d: Invalid stream set", __func__, mId);
346        goto err_out;
347    }
348
349    // Set up all streams (calculate usage/max_buffers for each)
350    setupStreams(newStreams, stream_config->num_streams);
351
352    // Destroy all old streams and replace stream array with new one
353    destroyStreams(mStreams, mNumStreams);
354    mStreams = newStreams;
355    mNumStreams = stream_config->num_streams;
356
357    // Clear out last seen settings metadata
358    setSettings(NULL);
359
360    pthread_mutex_unlock(&mMutex);
361    return 0;
362
363err_out:
364    // Clean up temporary streams, preserve existing mStreams/mNumStreams
365    destroyStreams(newStreams, stream_config->num_streams);
366    pthread_mutex_unlock(&mMutex);
367    return -EINVAL;
368}
369
370void Camera::destroyStreams(Stream **streams, int count)
371{
372    if (streams == NULL)
373        return;
374    for (int i = 0; i < count; i++) {
375        // Only destroy streams that weren't reused
376        if (streams[i] != NULL && !streams[i]->mReuse)
377            delete streams[i];
378    }
379    delete [] streams;
380}
381
382Stream *Camera::reuseStream(camera3_stream_t *astream)
383{
384    Stream *priv = reinterpret_cast<Stream*>(astream->priv);
385    // Verify the re-used stream's parameters match
386    if (!priv->isValidReuseStream(mId, astream)) {
387        ALOGE("%s:%d: Mismatched parameter in reused stream", __func__, mId);
388        return NULL;
389    }
390    // Mark stream to be reused
391    priv->mReuse = true;
392    return priv;
393}
394
395bool Camera::isValidStreamSet(Stream **streams, int count)
396{
397    int inputs = 0;
398    int outputs = 0;
399
400    if (streams == NULL) {
401        ALOGE("%s:%d: NULL stream configuration streams", __func__, mId);
402        return false;
403    }
404    if (count == 0) {
405        ALOGE("%s:%d: Zero count stream configuration streams", __func__, mId);
406        return false;
407    }
408    // Validate there is at most one input stream and at least one output stream
409    for (int i = 0; i < count; i++) {
410        // A stream may be both input and output (bidirectional)
411        if (streams[i]->isInputType())
412            inputs++;
413        if (streams[i]->isOutputType())
414            outputs++;
415    }
416    ALOGV("%s:%d: Configuring %d output streams and %d input streams",
417            __func__, mId, outputs, inputs);
418    if (outputs < 1) {
419        ALOGE("%s:%d: Stream config must have >= 1 output", __func__, mId);
420        return false;
421    }
422    if (inputs > 1) {
423        ALOGE("%s:%d: Stream config must have <= 1 input", __func__, mId);
424        return false;
425    }
426    // TODO: check for correct number of Bayer/YUV/JPEG/Encoder streams
427    return true;
428}
429
430void Camera::setupStreams(Stream **streams, int count)
431{
432    /*
433     * This is where the HAL has to decide internally how to handle all of the
434     * streams, and then produce usage and max_buffer values for each stream.
435     * Note, the stream array has been checked before this point for ALL invalid
436     * conditions, so it must find a successful configuration for this stream
437     * array.  The HAL may not return an error from this point.
438     *
439     * In this demo HAL, we just set all streams to be the same dummy values;
440     * real implementations will want to avoid USAGE_SW_{READ|WRITE}_OFTEN.
441     */
442    for (int i = 0; i < count; i++) {
443        uint32_t usage = 0;
444
445        if (streams[i]->isOutputType())
446            usage |= GRALLOC_USAGE_SW_WRITE_OFTEN |
447                     GRALLOC_USAGE_HW_CAMERA_WRITE;
448        if (streams[i]->isInputType())
449            usage |= GRALLOC_USAGE_SW_READ_OFTEN |
450                     GRALLOC_USAGE_HW_CAMERA_READ;
451
452        streams[i]->setUsage(usage);
453        streams[i]->setMaxBuffers(1);
454    }
455}
456
457int Camera::registerStreamBuffers(const camera3_stream_buffer_set_t *buf_set)
458{
459    ALOGV("%s:%d: buffer_set=%p", __func__, mId, buf_set);
460    if (buf_set == NULL) {
461        ALOGE("%s:%d: NULL buffer set", __func__, mId);
462        return -EINVAL;
463    }
464    if (buf_set->stream == NULL) {
465        ALOGE("%s:%d: NULL stream handle", __func__, mId);
466        return -EINVAL;
467    }
468    Stream *stream = reinterpret_cast<Stream*>(buf_set->stream->priv);
469    return stream->registerBuffers(buf_set);
470}
471
472const camera_metadata_t* Camera::constructDefaultRequestSettings(int type)
473{
474    ALOGV("%s:%d: type=%d", __func__, mId, type);
475
476    if (type < 1 || type >= CAMERA3_TEMPLATE_COUNT) {
477        ALOGE("%s:%d: Invalid template request type: %d", __func__, mId, type);
478        return NULL;
479    }
480    return mTemplates[type]->generate();
481}
482
483int Camera::processCaptureRequest(camera3_capture_request_t *request)
484{
485    camera3_capture_result result;
486
487    ALOGV("%s:%d: request=%p", __func__, mId, request);
488    CAMTRACE_CALL();
489
490    if (request == NULL) {
491        ALOGE("%s:%d: NULL request recieved", __func__, mId);
492        return -EINVAL;
493    }
494
495    ALOGV("%s:%d: Request Frame:%d Settings:%p", __func__, mId,
496            request->frame_number, request->settings);
497
498    // NULL indicates use last settings
499    if (request->settings == NULL) {
500        if (mSettings == NULL) {
501            ALOGE("%s:%d: NULL settings without previous set Frame:%d Req:%p",
502                    __func__, mId, request->frame_number, request);
503            return -EINVAL;
504        }
505    } else {
506        setSettings(request->settings);
507    }
508
509    if (request->input_buffer != NULL) {
510        ALOGV("%s:%d: Reprocessing input buffer %p", __func__, mId,
511                request->input_buffer);
512
513        if (!isValidReprocessSettings(request->settings)) {
514            ALOGE("%s:%d: Invalid settings for reprocess request: %p",
515                    __func__, mId, request->settings);
516            return -EINVAL;
517        }
518    } else {
519        ALOGV("%s:%d: Capturing new frame.", __func__, mId);
520
521        if (!isValidCaptureSettings(request->settings)) {
522            ALOGE("%s:%d: Invalid settings for capture request: %p",
523                    __func__, mId, request->settings);
524            return -EINVAL;
525        }
526    }
527
528    if (request->num_output_buffers <= 0) {
529        ALOGE("%s:%d: Invalid number of output buffers: %d", __func__, mId,
530                request->num_output_buffers);
531        return -EINVAL;
532    }
533    result.num_output_buffers = request->num_output_buffers;
534    result.output_buffers = new camera3_stream_buffer_t[result.num_output_buffers];
535    for (unsigned int i = 0; i < request->num_output_buffers; i++) {
536        int res = processCaptureBuffer(&request->output_buffers[i],
537                const_cast<camera3_stream_buffer_t*>(&result.output_buffers[i]));
538        if (res)
539            goto err_out;
540    }
541
542    result.frame_number = request->frame_number;
543    // TODO: return actual captured/reprocessed settings
544    result.result = request->settings;
545    // TODO: asynchronously return results
546    notifyShutter(request->frame_number, 0);
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    if (in->acquire_fence != -1) {
586        int res = sync_wait(in->acquire_fence, CAMERA_SYNC_TIMEOUT);
587        if (res == -ETIME) {
588            ALOGE("%s:%d: Timeout waiting on buffer acquire fence",
589                    __func__, mId);
590            return res;
591        } else if (res) {
592            ALOGE("%s:%d: Error waiting on buffer acquire fence: %s(%d)",
593                    __func__, mId, strerror(-res), res);
594            return res;
595        }
596    }
597
598    out->stream = in->stream;
599    out->buffer = in->buffer;
600    out->status = CAMERA3_BUFFER_STATUS_OK;
601    // TODO: use driver-backed release fences
602    out->acquire_fence = -1;
603    out->release_fence = -1;
604
605    // TODO: lock and software-paint buffer
606    return 0;
607}
608
609void Camera::notifyShutter(uint32_t frame_number, uint64_t timestamp)
610{
611    int res;
612    struct timespec ts;
613
614    // If timestamp is 0, get timestamp from right now instead
615    if (timestamp == 0) {
616        ALOGW("%s:%d: No timestamp provided, using CLOCK_BOOTTIME",
617                __func__, mId);
618        res = clock_gettime(CLOCK_BOOTTIME, &ts);
619        if (res == 0) {
620            timestamp = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
621        } else {
622            ALOGE("%s:%d: No timestamp and failed to get CLOCK_BOOTTIME %s(%d)",
623                    __func__, mId, strerror(errno), errno);
624        }
625    }
626    camera3_notify_msg_t m;
627    memset(&m, 0, sizeof(m));
628    m.type = CAMERA3_MSG_SHUTTER;
629    m.message.shutter.frame_number = frame_number;
630    m.message.shutter.timestamp = timestamp;
631    mCallbackOps->notify(mCallbackOps, &m);
632}
633
634void Camera::getMetadataVendorTagOps(vendor_tag_query_ops_t *ops)
635{
636    ALOGV("%s:%d: ops=%p", __func__, mId, ops);
637    // TODO: return vendor tag ops
638}
639
640void Camera::dump(int fd)
641{
642    ALOGV("%s:%d: Dumping to fd %d", __func__, mId, fd);
643    // TODO: dprintf all relevant state to fd
644}
645
646extern "C" {
647// Get handle to camera from device priv data
648static Camera *camdev_to_camera(const camera3_device_t *dev)
649{
650    return reinterpret_cast<Camera*>(dev->priv);
651}
652
653static int initialize(const camera3_device_t *dev,
654        const camera3_callback_ops_t *callback_ops)
655{
656    return camdev_to_camera(dev)->initialize(callback_ops);
657}
658
659static int configure_streams(const camera3_device_t *dev,
660        camera3_stream_configuration_t *stream_list)
661{
662    return camdev_to_camera(dev)->configureStreams(stream_list);
663}
664
665static int register_stream_buffers(const camera3_device_t *dev,
666        const camera3_stream_buffer_set_t *buffer_set)
667{
668    return camdev_to_camera(dev)->registerStreamBuffers(buffer_set);
669}
670
671static const camera_metadata_t *construct_default_request_settings(
672        const camera3_device_t *dev, int type)
673{
674    return camdev_to_camera(dev)->constructDefaultRequestSettings(type);
675}
676
677static int process_capture_request(const camera3_device_t *dev,
678        camera3_capture_request_t *request)
679{
680    return camdev_to_camera(dev)->processCaptureRequest(request);
681}
682
683static void get_metadata_vendor_tag_ops(const camera3_device_t *dev,
684        vendor_tag_query_ops_t *ops)
685{
686    camdev_to_camera(dev)->getMetadataVendorTagOps(ops);
687}
688
689static void dump(const camera3_device_t *dev, int fd)
690{
691    camdev_to_camera(dev)->dump(fd);
692}
693} // extern "C"
694
695const camera3_device_ops_t Camera::sOps = {
696    .initialize              = default_camera_hal::initialize,
697    .configure_streams       = default_camera_hal::configure_streams,
698    .register_stream_buffers = default_camera_hal::register_stream_buffers,
699    .construct_default_request_settings =
700            default_camera_hal::construct_default_request_settings,
701    .process_capture_request = default_camera_hal::process_capture_request,
702    .get_metadata_vendor_tag_ops =
703            default_camera_hal::get_metadata_vendor_tag_ops,
704    .dump                    = default_camera_hal::dump
705};
706
707} // namespace default_camera_hal
708