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/*
18 * Contains implementation of a class EmulatedCamera that encapsulates
19 * functionality common to all version 2.0 emulated camera devices.  Instances
20 * of this class (for each emulated camera) are created during the construction
21 * of the EmulatedCameraFactory instance.  This class serves as an entry point
22 * for all camera API calls that defined by camera2_device_ops_t API.
23 */
24
25#define LOG_NDEBUG 0
26#define LOG_TAG "EmulatedCamera2_Camera"
27#include <cutils/log.h>
28
29#include "EmulatedCamera2.h"
30#include "system/camera_metadata.h"
31
32namespace android {
33
34/* Constructs EmulatedCamera2 instance.
35 * Param:
36 *  cameraId - Zero based camera identifier, which is an index of the camera
37 *      instance in camera factory's array.
38 *  module - Emulated camera HAL module descriptor.
39 */
40EmulatedCamera2::EmulatedCamera2(int cameraId,
41        struct hw_module_t* module):
42        EmulatedBaseCamera(cameraId,
43                CAMERA_DEVICE_API_VERSION_2_0,
44                &common,
45                module)
46{
47    common.close = EmulatedCamera2::close;
48    ops = &sDeviceOps;
49    priv = this;
50
51    mRequestQueueDstOps.notify_queue_not_empty =
52            EmulatedCamera2::request_queue_notify_queue_not_empty;
53    mRequestQueueDstOps.parent                 = this;
54
55    mRequestQueueDstOps.notify_queue_not_empty =
56            EmulatedCamera2::reprocess_queue_notify_queue_not_empty;
57    mReprocessQueueDstOps.parent               = this;
58
59    mFrameQueueSrcOps.buffer_count = EmulatedCamera2::frame_queue_buffer_count;
60    mFrameQueueSrcOps.dequeue      = EmulatedCamera2::frame_queue_dequeue;
61    mFrameQueueSrcOps.free         = EmulatedCamera2::frame_queue_free;
62    mFrameQueueSrcOps.parent       = this;
63
64    mReprocessStreamOps.dequeue_buffer =
65            EmulatedCamera2::reprocess_stream_dequeue_buffer;
66    mReprocessStreamOps.enqueue_buffer =
67            EmulatedCamera2::reprocess_stream_enqueue_buffer;
68    mReprocessStreamOps.cancel_buffer =
69            EmulatedCamera2::reprocess_stream_cancel_buffer;
70    mReprocessStreamOps.set_buffer_count =
71            EmulatedCamera2::reprocess_stream_set_buffer_count;
72    mReprocessStreamOps.set_crop = EmulatedCamera2::reprocess_stream_set_crop;
73    mReprocessStreamOps.set_timestamp =
74            EmulatedCamera2::reprocess_stream_set_timestamp;
75    mReprocessStreamOps.set_usage = EmulatedCamera2::reprocess_stream_set_usage;
76    mReprocessStreamOps.get_min_undequeued_buffer_count =
77            EmulatedCamera2::reprocess_stream_get_min_undequeued_buffer_count;
78    mReprocessStreamOps.lock_buffer =
79            EmulatedCamera2::reprocess_stream_lock_buffer;
80    mReprocessStreamOps.parent   = this;
81
82    mVendorTagOps.get_camera_vendor_section_name =
83            EmulatedCamera2::get_camera_vendor_section_name;
84    mVendorTagOps.get_camera_vendor_tag_name =
85            EmulatedCamera2::get_camera_vendor_tag_name;
86    mVendorTagOps.get_camera_vendor_tag_type =
87            EmulatedCamera2::get_camera_vendor_tag_type;
88    mVendorTagOps.parent = this;
89}
90
91/* Destructs EmulatedCamera2 instance. */
92EmulatedCamera2::~EmulatedCamera2() {
93}
94
95/****************************************************************************
96 * Abstract API
97 ***************************************************************************/
98
99/****************************************************************************
100 * Public API
101 ***************************************************************************/
102
103status_t EmulatedCamera2::Initialize() {
104    return NO_ERROR;
105}
106
107/****************************************************************************
108 * Camera API implementation
109 ***************************************************************************/
110
111status_t EmulatedCamera2::connectCamera(hw_device_t** device) {
112    return NO_ERROR;
113}
114
115status_t EmulatedCamera2::closeCamera() {
116    return NO_ERROR;
117}
118
119status_t EmulatedCamera2::getCameraInfo(struct camera_info* info) {
120
121    return EmulatedBaseCamera::getCameraInfo(info);
122}
123
124/****************************************************************************
125 * Camera API implementation.
126 * These methods are called from the camera API callback routines.
127 ***************************************************************************/
128
129/** Request input queue */
130
131int EmulatedCamera2::setRequestQueueSrcOps(
132    camera2_metadata_queue_src_ops *request_queue_src_ops) {
133    return NO_ERROR;
134}
135
136int EmulatedCamera2::requestQueueNotifyNotEmpty() {
137    return NO_ERROR;
138}
139
140/** Reprocessing input queue */
141
142int EmulatedCamera2::setReprocessQueueSrcOps(
143    camera2_metadata_queue_src_ops *reprocess_queue_src_ops) {
144    return NO_ERROR;
145}
146
147int EmulatedCamera2::reprocessQueueNotifyNotEmpty() {
148    return NO_ERROR;
149}
150
151/** Frame output queue */
152
153int EmulatedCamera2::setFrameQueueDstOps(camera2_metadata_queue_dst_ops *frame_queue_dst_ops) {
154    return NO_ERROR;
155}
156
157int EmulatedCamera2::frameQueueBufferCount() {
158    return NO_ERROR;
159}
160int EmulatedCamera2::frameQueueDequeue(camera_metadata_t **buffer) {
161    return NO_ERROR;
162}
163int EmulatedCamera2::frameQueueFree(camera_metadata_t *old_buffer) {
164    return NO_ERROR;
165}
166
167/** Notifications to application */
168int EmulatedCamera2::setNotifyCallback(camera2_notify_callback notify_cb) {
169    return NO_ERROR;
170}
171
172/** Count of requests in flight */
173int EmulatedCamera2::getInProgressCount() {
174    return NO_ERROR;
175}
176
177/** Cancel all captures in flight */
178int EmulatedCamera2::flushCapturesInProgress() {
179    return NO_ERROR;
180}
181
182/** Reprocessing input stream management */
183int EmulatedCamera2::reprocessStreamDequeueBuffer(buffer_handle_t** buffer,
184        int *stride) {
185    return NO_ERROR;
186}
187
188int EmulatedCamera2::reprocessStreamEnqueueBuffer(buffer_handle_t* buffer) {
189    return NO_ERROR;
190}
191
192int EmulatedCamera2::reprocessStreamCancelBuffer(buffer_handle_t* buffer) {
193    return NO_ERROR;
194}
195
196int EmulatedCamera2::reprocessStreamSetBufferCount(int count) {
197    return NO_ERROR;
198}
199
200int EmulatedCamera2::reprocessStreamSetCrop(int left, int top, int right, int bottom) {
201    return NO_ERROR;
202}
203
204int EmulatedCamera2::reprocessStreamSetTimestamp(int64_t timestamp) {
205    return NO_ERROR;
206}
207
208int EmulatedCamera2::reprocessStreamSetUsage(int usage) {
209    return NO_ERROR;
210}
211
212int EmulatedCamera2::reprocessStreamSetSwapInterval(int interval) {
213    return NO_ERROR;
214}
215
216int EmulatedCamera2::reprocessStreamGetMinUndequeuedBufferCount(int *count) {
217    return NO_ERROR;
218}
219
220int EmulatedCamera2::reprocessStreamLockBuffer(buffer_handle_t *buffer) {
221    return NO_ERROR;
222}
223
224/** Output stream creation and management */
225
226int EmulatedCamera2::getStreamSlotCount() {
227    return NO_ERROR;
228}
229
230int EmulatedCamera2::allocateStream(uint32_t stream_slot,
231        uint32_t width,
232        uint32_t height,
233        int format,
234        camera2_stream_ops_t *stream_ops) {
235    return NO_ERROR;
236}
237
238int EmulatedCamera2::releaseStream(uint32_t stream_slot) {
239    return NO_ERROR;
240}
241
242/** Custom tag query methods */
243
244const char* EmulatedCamera2::getVendorSectionName(uint32_t tag) {
245    return NULL;
246}
247
248const char* EmulatedCamera2::getVendorTagName(uint32_t tag) {
249    return NULL;
250}
251
252int EmulatedCamera2::getVendorTagType(uint32_t tag) {
253    return -1;
254}
255
256/** Shutdown and debug methods */
257
258int EmulatedCamera2::release() {
259    return NO_ERROR;
260}
261
262int EmulatedCamera2::dump(int fd) {
263    return NO_ERROR;
264}
265
266/****************************************************************************
267 * Private API.
268 ***************************************************************************/
269
270/****************************************************************************
271 * Camera API callbacks as defined by camera2_device_ops structure.  See
272 * hardware/libhardware/include/hardware/camera2.h for information on each
273 * of these callbacks. Implemented in this class, these callbacks simply
274 * dispatch the call into an instance of EmulatedCamera2 class defined by the
275 * 'camera_device2' parameter.
276 ***************************************************************************/
277
278int EmulatedCamera2::set_request_queue_src_ops(struct camera2_device *d,
279        camera2_metadata_queue_src_ops *queue_src_ops) {
280    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
281    return ec->setRequestQueueSrcOps(queue_src_ops);
282}
283
284int EmulatedCamera2::get_request_queue_dst_ops(struct camera2_device *d,
285        camera2_metadata_queue_dst_ops **queue_dst_ops) {
286    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
287    *queue_dst_ops = static_cast<camera2_metadata_queue_dst_ops*>(
288        &ec->mRequestQueueDstOps);
289    return NO_ERROR;
290}
291
292int EmulatedCamera2::request_queue_notify_queue_not_empty(
293        camera2_metadata_queue_dst_ops *q) {
294    EmulatedCamera2* ec = static_cast<QueueDstOps*>(q)->parent;
295    return ec->requestQueueNotifyNotEmpty();
296}
297
298int EmulatedCamera2::set_reprocess_queue_src_ops(struct camera2_device *d,
299        camera2_metadata_queue_src_ops *queue_src_ops) {
300    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
301    return ec->setReprocessQueueSrcOps(queue_src_ops);
302}
303
304int EmulatedCamera2::get_reprocess_queue_dst_ops(struct camera2_device *d,
305        camera2_metadata_queue_dst_ops **queue_dst_ops) {
306    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
307    *queue_dst_ops = static_cast<camera2_metadata_queue_dst_ops*>(
308        &ec->mReprocessQueueDstOps);
309    return NO_ERROR;
310}
311
312int EmulatedCamera2::reprocess_queue_notify_queue_not_empty(
313        camera2_metadata_queue_dst_ops *q) {
314    EmulatedCamera2* ec = static_cast<QueueDstOps*>(q)->parent;
315    return ec->reprocessQueueNotifyNotEmpty();
316}
317
318int EmulatedCamera2::set_frame_queue_dst_ops(struct camera2_device *d,
319        camera2_metadata_queue_dst_ops *queue_dst_ops) {
320    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
321    return ec->setFrameQueueDstOps(queue_dst_ops);
322}
323
324int EmulatedCamera2::get_frame_queue_src_ops(struct camera2_device *d,
325        camera2_metadata_queue_src_ops **queue_src_ops) {
326    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
327    *queue_src_ops = static_cast<camera2_metadata_queue_src_ops*>(
328        &ec->mFrameQueueSrcOps);
329    return NO_ERROR;
330}
331
332int EmulatedCamera2::frame_queue_buffer_count(camera2_metadata_queue_src_ops *q) {
333    EmulatedCamera2 *ec = static_cast<QueueSrcOps*>(q)->parent;
334    return ec->frameQueueBufferCount();
335}
336
337int EmulatedCamera2::frame_queue_dequeue(camera2_metadata_queue_src_ops *q,
338        camera_metadata_t **buffer) {
339    EmulatedCamera2 *ec = static_cast<QueueSrcOps*>(q)->parent;
340    return ec->frameQueueDequeue(buffer);
341}
342
343int EmulatedCamera2::frame_queue_free(camera2_metadata_queue_src_ops *q,
344        camera_metadata_t *old_buffer) {
345    EmulatedCamera2 *ec = static_cast<QueueSrcOps*>(q)->parent;
346    return ec->frameQueueFree(old_buffer);
347}
348
349int EmulatedCamera2::set_notify_callback(struct camera2_device *d,
350        camera2_notify_callback notify_cb) {
351    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
352    return ec->setNotifyCallback(notify_cb);
353}
354
355int EmulatedCamera2::get_in_progress_count(struct camera2_device *d) {
356    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
357    return ec->getInProgressCount();
358}
359
360int EmulatedCamera2::flush_captures_in_progress(struct camera2_device *d) {
361    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
362    return ec->flushCapturesInProgress();
363}
364
365int EmulatedCamera2::get_reprocess_stream_ops(camera2_device_t *d,
366        camera2_stream_ops **stream) {
367    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
368    *stream = static_cast<camera2_stream_ops*>(&ec->mReprocessStreamOps);
369    return NO_ERROR;
370}
371
372int EmulatedCamera2::reprocess_stream_dequeue_buffer(camera2_stream_ops *s,
373        buffer_handle_t** buffer, int *stride) {
374    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
375    return ec->reprocessStreamDequeueBuffer(buffer, stride);
376}
377
378int EmulatedCamera2::reprocess_stream_enqueue_buffer(camera2_stream_ops *s,
379        buffer_handle_t* buffer) {
380    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
381    return ec->reprocessStreamEnqueueBuffer(buffer);
382}
383
384int EmulatedCamera2::reprocess_stream_cancel_buffer(camera2_stream_ops *s,
385        buffer_handle_t* buffer) {
386    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
387    return ec->reprocessStreamCancelBuffer(buffer);
388}
389
390int EmulatedCamera2::reprocess_stream_set_buffer_count(camera2_stream_ops *s,
391        int count) {
392    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
393    return ec->reprocessStreamSetBufferCount(count);
394}
395
396int EmulatedCamera2::reprocess_stream_set_crop(camera2_stream_ops *s,
397        int left, int top, int right, int bottom) {
398    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
399    return ec->reprocessStreamSetCrop(left, top, right, bottom);
400}
401
402int EmulatedCamera2::reprocess_stream_set_timestamp(camera2_stream_ops *s,
403        int64_t timestamp) {
404    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
405    return ec->reprocessStreamSetTimestamp(timestamp);
406}
407
408int EmulatedCamera2::reprocess_stream_set_usage(camera2_stream_ops *s,
409        int usage) {
410    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
411    return ec->reprocessStreamSetUsage(usage);
412}
413
414int EmulatedCamera2::reprocess_stream_set_swap_interval(camera2_stream_ops *s,
415        int interval) {
416    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
417    return ec->reprocessStreamSetSwapInterval(interval);
418}
419
420int EmulatedCamera2::reprocess_stream_get_min_undequeued_buffer_count(
421        const camera2_stream_ops *s,
422        int *count) {
423    EmulatedCamera2* ec = static_cast<const StreamOps*>(s)->parent;
424    return ec->reprocessStreamGetMinUndequeuedBufferCount(count);
425}
426
427int EmulatedCamera2::reprocess_stream_lock_buffer(camera2_stream_ops *s,
428        buffer_handle_t* buffer) {
429    EmulatedCamera2* ec = static_cast<StreamOps*>(s)->parent;
430    return ec->reprocessStreamLockBuffer(buffer);
431}
432
433int EmulatedCamera2::get_stream_slot_count(struct camera2_device *d) {
434    EmulatedCamera2* ec =
435            static_cast<EmulatedCamera2*>(d);
436    return ec->getStreamSlotCount();
437}
438
439int EmulatedCamera2::allocate_stream(struct camera2_device *d,
440        uint32_t stream_slot,
441        uint32_t width,
442        uint32_t height,
443        uint32_t format,
444        camera2_stream_ops_t *stream_ops) {
445    EmulatedCamera2* ec =
446            static_cast<EmulatedCamera2*>(d);
447    return ec->allocateStream(stream_slot, width, height, format, stream_ops);
448}
449
450int EmulatedCamera2::release_stream(struct camera2_device *d,
451        uint32_t stream_slot) {
452    EmulatedCamera2* ec =
453            static_cast<EmulatedCamera2*>(d);
454    return ec->releaseStream(stream_slot);
455}
456
457void EmulatedCamera2::release(struct camera2_device *d) {
458    EmulatedCamera2* ec =
459            static_cast<EmulatedCamera2*>(d);
460    ec->release();
461}
462
463int EmulatedCamera2::dump(struct camera2_device *d, int fd) {
464    EmulatedCamera2* ec =
465            static_cast<EmulatedCamera2*>(d);
466    return ec->dump(fd);
467}
468
469int EmulatedCamera2::close(struct hw_device_t* device) {
470    EmulatedCamera2* ec =
471            static_cast<EmulatedCamera2*>(
472                reinterpret_cast<struct camera2_device*>(device) );
473    if (ec == NULL) {
474        ALOGE("%s: Unexpected NULL camera2 device", __FUNCTION__);
475        return -EINVAL;
476    }
477    return ec->closeCamera();
478}
479
480int EmulatedCamera2::get_metadata_vendor_tag_ops(struct camera2_device *d,
481        vendor_tag_query_ops_t **ops) {
482    EmulatedCamera2* ec = static_cast<EmulatedCamera2*>(d);
483    *ops = static_cast<vendor_tag_query_ops_t*>(
484            &ec->mVendorTagOps);
485    return NO_ERROR;
486}
487
488const char* EmulatedCamera2::get_camera_vendor_section_name(
489        const vendor_tag_query_ops_t *v,
490        uint32_t tag) {
491    EmulatedCamera2* ec = static_cast<const TagOps*>(v)->parent;
492    return ec->getVendorSectionName(tag);
493}
494
495const char* EmulatedCamera2::get_camera_vendor_tag_name(
496        const vendor_tag_query_ops_t *v,
497        uint32_t tag) {
498    EmulatedCamera2* ec = static_cast<const TagOps*>(v)->parent;
499    return ec->getVendorTagName(tag);
500}
501
502int EmulatedCamera2::get_camera_vendor_tag_type(
503        const vendor_tag_query_ops_t *v,
504        uint32_t tag)  {
505    EmulatedCamera2* ec = static_cast<const TagOps*>(v)->parent;
506    return ec->getVendorTagType(tag);
507}
508
509camera2_device_ops_t EmulatedCamera2::sDeviceOps = {
510    EmulatedCamera2::set_request_queue_src_ops,
511    EmulatedCamera2::get_request_queue_dst_ops,
512    EmulatedCamera2::set_reprocess_queue_src_ops,
513    EmulatedCamera2::get_reprocess_queue_dst_ops,
514    EmulatedCamera2::set_frame_queue_dst_ops,
515    EmulatedCamera2::get_frame_queue_src_ops,
516    EmulatedCamera2::set_notify_callback,
517    EmulatedCamera2::get_in_progress_count,
518    EmulatedCamera2::flush_captures_in_progress,
519    EmulatedCamera2::get_reprocess_stream_ops,
520    EmulatedCamera2::get_stream_slot_count,
521    EmulatedCamera2::allocate_stream,
522    EmulatedCamera2::release_stream,
523    EmulatedCamera2::get_metadata_vendor_tag_ops,
524    EmulatedCamera2::release,
525    EmulatedCamera2::dump
526};
527
528}; /* namespace android */
529