Commit | Line | Data |
---|---|---|
d42e7319 JB |
1 | /* |
2 | * Copyright (C) 2013 Canonical Ltd | |
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 | * Authored by: Thomas Voß <thomas.voss@canonical.com> | |
17 | * Ricardo Salveti de Araujo <ricardo.salveti@canonical.com> | |
18 | */ | |
19 | ||
20 | #include <hybris/internal/camera_control.h> | |
21 | #include <hybris/camera/camera_compatibility_layer.h> | |
22 | #include <hybris/camera/camera_compatibility_layer_capabilities.h> | |
23 | #include <hybris/camera/camera_compatibility_layer_configuration_translator.h> | |
24 | ||
25 | #include <hybris/internal/surface_flinger_compatibility_layer_internal.h> | |
26 | ||
27 | #include <binder/ProcessState.h> | |
28 | #include <camera/Camera.h> | |
29 | #include <camera/CameraParameters.h> | |
30 | #include <gui/SurfaceTexture.h> | |
31 | #include <ui/GraphicBuffer.h> | |
32 | ||
33 | #undef LOG_TAG | |
34 | #define LOG_TAG "CameraCompatibilityLayer" | |
35 | #include <utils/KeyedVector.h> | |
36 | #include <utils/Log.h> | |
37 | ||
38 | #define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__) | |
39 | ||
40 | // From android::SurfaceTexture::FrameAvailableListener | |
41 | void CameraControl::onFrameAvailable() | |
42 | { | |
43 | REPORT_FUNCTION(); | |
44 | if (listener) | |
45 | listener->on_preview_texture_needs_update_cb(listener->context); | |
46 | } | |
47 | ||
48 | // From android::CameraListener | |
49 | void CameraControl::notify(int32_t msg_type, int32_t ext1, int32_t ext2) | |
50 | { | |
51 | REPORT_FUNCTION(); | |
52 | printf("\text1: %d, ext2: %d \n", ext1, ext2); | |
53 | ||
54 | if (!listener) | |
55 | return; | |
56 | ||
57 | switch (msg_type) { | |
58 | case CAMERA_MSG_ERROR: | |
59 | if (listener->on_msg_error_cb) | |
60 | listener->on_msg_error_cb(listener->context); | |
61 | break; | |
62 | case CAMERA_MSG_SHUTTER: | |
63 | if (listener->on_msg_shutter_cb) | |
64 | listener->on_msg_shutter_cb(listener->context); | |
65 | break; | |
66 | case CAMERA_MSG_ZOOM: | |
67 | if (listener->on_msg_zoom_cb) | |
68 | listener->on_msg_zoom_cb(listener->context, ext1); | |
69 | break; | |
70 | case CAMERA_MSG_FOCUS: | |
71 | if (listener->on_msg_focus_cb) | |
72 | listener->on_msg_focus_cb(listener->context); | |
73 | break; | |
74 | default: | |
75 | break; | |
76 | } | |
77 | } | |
78 | ||
79 | void CameraControl::postData( | |
80 | int32_t msg_type, | |
81 | const android::sp<android::IMemory>& data, | |
82 | camera_frame_metadata_t* metadata) | |
83 | { | |
84 | REPORT_FUNCTION(); | |
85 | ||
86 | if (!listener) | |
87 | return; | |
88 | ||
89 | switch (msg_type) { | |
90 | case CAMERA_MSG_RAW_IMAGE: | |
91 | if (listener->on_data_raw_image_cb) | |
92 | listener->on_data_raw_image_cb(data->pointer(), data->size(), listener->context); | |
93 | break; | |
94 | case CAMERA_MSG_COMPRESSED_IMAGE: | |
95 | if (listener->on_data_compressed_image_cb) | |
96 | listener->on_data_compressed_image_cb(data->pointer(), data->size(), listener->context); | |
97 | break; | |
98 | default: | |
99 | break; | |
100 | } | |
101 | } | |
102 | ||
103 | void CameraControl::postDataTimestamp( | |
104 | nsecs_t timestamp, | |
105 | int32_t msg_type, | |
106 | const android::sp<android::IMemory>& data) | |
107 | { | |
108 | REPORT_FUNCTION(); | |
109 | (void) timestamp; | |
110 | (void) msg_type; | |
111 | (void) data; | |
112 | } | |
113 | ||
114 | namespace android | |
115 | { | |
116 | NativeBufferAlloc::NativeBufferAlloc() { | |
117 | } | |
118 | ||
119 | NativeBufferAlloc::~NativeBufferAlloc() { | |
120 | } | |
121 | ||
122 | sp<GraphicBuffer> NativeBufferAlloc::createGraphicBuffer(uint32_t w, uint32_t h, | |
123 | PixelFormat format, uint32_t usage, status_t* error) { | |
124 | sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(w, h, format, usage)); | |
125 | status_t err = graphicBuffer->initCheck(); | |
126 | *error = err; | |
127 | if (err != 0 || graphicBuffer->handle == 0) { | |
128 | if (err == NO_MEMORY) { | |
129 | GraphicBuffer::dumpAllocationsToSystemLog(); | |
130 | } | |
131 | ALOGI("GraphicBufferAlloc::createGraphicBuffer(w=%d, h=%d) " | |
132 | "failed (%s), handle=%p", | |
133 | w, h, strerror(-err), graphicBuffer->handle); | |
134 | return 0; | |
135 | } | |
136 | return graphicBuffer; | |
137 | } | |
138 | } | |
139 | ||
140 | namespace | |
141 | { | |
142 | ||
143 | android::sp<CameraControl> camera_control_instance; | |
144 | ||
145 | } | |
146 | ||
147 | int android_camera_get_number_of_devices() | |
148 | { | |
149 | REPORT_FUNCTION(); | |
150 | return android::Camera::getNumberOfCameras(); | |
151 | } | |
152 | ||
153 | CameraControl* android_camera_connect_to(CameraType camera_type, CameraControlListener* listener) | |
154 | { | |
155 | REPORT_FUNCTION(); | |
156 | ||
157 | int32_t camera_id; | |
158 | int32_t camera_count = camera_id = android::Camera::getNumberOfCameras(); | |
159 | ||
160 | for (camera_id = 0; camera_id < camera_count; camera_id++) { | |
161 | android::CameraInfo ci; | |
162 | android::Camera::getCameraInfo(camera_id, &ci); | |
163 | ||
164 | if (ci.facing == camera_type) | |
165 | break; | |
166 | } | |
167 | ||
168 | if (camera_id == camera_count) | |
169 | return NULL; | |
170 | ||
171 | CameraControl* cc = new CameraControl(); | |
172 | cc->listener = listener; | |
173 | cc->camera = android::Camera::connect(camera_id); | |
174 | ||
175 | if (cc->camera == NULL) | |
176 | return NULL; | |
177 | ||
178 | cc->camera_parameters = android::CameraParameters(cc->camera->getParameters()); | |
179 | ||
180 | camera_control_instance = cc; | |
181 | cc->camera->setListener(camera_control_instance); | |
182 | cc->camera->lock(); | |
183 | ||
184 | // TODO: Move this to a more generic component | |
185 | android::ProcessState::self()->startThreadPool(); | |
186 | ||
187 | return cc; | |
188 | } | |
189 | ||
190 | void android_camera_disconnect(CameraControl* control) | |
191 | { | |
192 | REPORT_FUNCTION(); | |
193 | assert(control); | |
194 | ||
195 | android::Mutex::Autolock al(control->guard); | |
196 | ||
197 | if (control->preview_texture != NULL) | |
198 | control->preview_texture->abandon(); | |
199 | ||
200 | control->camera->disconnect(); | |
201 | control->camera->unlock(); | |
202 | } | |
203 | ||
204 | int android_camera_lock(CameraControl* control) | |
205 | { | |
206 | android::Mutex::Autolock al(control->guard); | |
207 | return control->camera->lock(); | |
208 | } | |
209 | ||
210 | int android_camera_unlock(CameraControl* control) | |
211 | { | |
212 | android::Mutex::Autolock al(control->guard); | |
213 | return control->camera->unlock(); | |
214 | } | |
215 | ||
216 | void android_camera_delete(CameraControl* control) | |
217 | { | |
218 | delete control; | |
219 | } | |
220 | ||
221 | void android_camera_dump_parameters(CameraControl* control) | |
222 | { | |
223 | REPORT_FUNCTION(); | |
224 | assert(control); | |
225 | ||
226 | printf("%s \n", control->camera->getParameters().string()); | |
227 | } | |
228 | ||
229 | void android_camera_set_flash_mode(CameraControl* control, FlashMode mode) | |
230 | { | |
231 | REPORT_FUNCTION(); | |
232 | assert(control); | |
233 | ||
234 | android::Mutex::Autolock al(control->guard); | |
235 | control->camera_parameters.set( | |
236 | android::CameraParameters::KEY_FLASH_MODE, | |
237 | flash_modes[mode]); | |
238 | control->camera->setParameters(control->camera_parameters.flatten()); | |
239 | } | |
240 | ||
241 | void android_camera_get_flash_mode(CameraControl* control, FlashMode* mode) | |
242 | { | |
243 | REPORT_FUNCTION(); | |
244 | assert(control); | |
245 | ||
246 | android::Mutex::Autolock al(control->guard); | |
247 | static const char* flash_mode = control->camera_parameters.get( | |
248 | android::CameraParameters::KEY_FLASH_MODE); | |
249 | if (flash_mode) | |
250 | *mode = flash_modes_lut.valueFor(android::String8(flash_mode)); | |
251 | else | |
252 | *mode = FLASH_MODE_OFF; | |
253 | } | |
254 | ||
255 | void android_camera_set_white_balance_mode(CameraControl* control, WhiteBalanceMode mode) | |
256 | { | |
257 | REPORT_FUNCTION(); | |
258 | assert(control); | |
259 | ||
260 | android::Mutex::Autolock al(control->guard); | |
261 | ||
262 | control->camera_parameters.set( | |
263 | android::CameraParameters::KEY_WHITE_BALANCE, | |
264 | white_balance_modes[mode]); | |
265 | control->camera->setParameters(control->camera_parameters.flatten()); | |
266 | } | |
267 | ||
268 | void android_camera_get_white_balance_mode(CameraControl* control, WhiteBalanceMode* mode) | |
269 | { | |
270 | REPORT_FUNCTION(); | |
271 | assert(control); | |
272 | ||
273 | android::Mutex::Autolock al(control->guard); | |
274 | ||
275 | *mode = white_balance_modes_lut.valueFor( | |
276 | android::String8( | |
277 | control->camera_parameters.get( | |
278 | android::CameraParameters::KEY_WHITE_BALANCE))); | |
279 | } | |
280 | ||
281 | void android_camera_set_scene_mode(CameraControl* control, SceneMode mode) | |
282 | { | |
283 | REPORT_FUNCTION(); | |
284 | assert(control); | |
285 | ||
286 | android::Mutex::Autolock al(control->guard); | |
287 | ||
288 | control->camera_parameters.set( | |
289 | android::CameraParameters::KEY_SCENE_MODE, | |
290 | scene_modes[mode]); | |
291 | control->camera->setParameters(control->camera_parameters.flatten()); | |
292 | } | |
293 | ||
294 | void android_camera_get_scene_mode(CameraControl* control, SceneMode* mode) | |
295 | { | |
296 | REPORT_FUNCTION(); | |
297 | assert(control); | |
298 | ||
299 | android::Mutex::Autolock al(control->guard); | |
300 | ||
301 | *mode = scene_modes_lut.valueFor( | |
302 | android::String8( | |
303 | control->camera_parameters.get( | |
304 | android::CameraParameters::KEY_SCENE_MODE))); | |
305 | } | |
306 | ||
307 | void android_camera_set_auto_focus_mode(CameraControl* control, AutoFocusMode mode) | |
308 | { | |
309 | REPORT_FUNCTION(); | |
310 | assert(control); | |
311 | ||
312 | android::Mutex::Autolock al(control->guard); | |
313 | ||
314 | control->camera_parameters.set( | |
315 | android::CameraParameters::KEY_FOCUS_MODE, | |
316 | auto_focus_modes[mode]); | |
317 | control->camera->setParameters(control->camera_parameters.flatten()); | |
318 | } | |
319 | ||
320 | void android_camera_get_auto_focus_mode(CameraControl* control, AutoFocusMode* mode) | |
321 | { | |
322 | REPORT_FUNCTION(); | |
323 | assert(control); | |
324 | ||
325 | android::Mutex::Autolock al(control->guard); | |
326 | ||
327 | *mode = auto_focus_modes_lut.valueFor( | |
328 | android::String8( | |
329 | control->camera_parameters.get( | |
330 | android::CameraParameters::KEY_FOCUS_MODE))); | |
331 | } | |
332 | ||
333 | ||
334 | void android_camera_set_effect_mode(CameraControl* control, EffectMode mode) | |
335 | { | |
336 | REPORT_FUNCTION(); | |
337 | assert(control); | |
338 | ||
339 | android::Mutex::Autolock al(control->guard); | |
340 | ||
341 | control->camera_parameters.set( | |
342 | android::CameraParameters::KEY_EFFECT, | |
343 | effect_modes[mode]); | |
344 | control->camera->setParameters(control->camera_parameters.flatten()); | |
345 | } | |
346 | ||
347 | void android_camera_get_effect_mode(CameraControl* control, EffectMode* mode) | |
348 | { | |
349 | REPORT_FUNCTION(); | |
350 | assert(control); | |
351 | ||
352 | android::Mutex::Autolock al(control->guard); | |
353 | ||
354 | *mode = effect_modes_lut.valueFor( | |
355 | android::String8( | |
356 | control->camera_parameters.get( | |
357 | android::CameraParameters::KEY_EFFECT))); | |
358 | } | |
359 | ||
360 | void android_camera_get_preview_fps_range(CameraControl* control, int* min, int* max) | |
361 | { | |
362 | REPORT_FUNCTION(); | |
363 | assert(control); | |
364 | ||
365 | android::Mutex::Autolock al(control->guard); | |
366 | ||
367 | control->camera_parameters.getPreviewFpsRange(min, max); | |
368 | } | |
369 | ||
370 | void android_camera_set_preview_fps(CameraControl* control, int fps) | |
371 | { | |
372 | REPORT_FUNCTION(); | |
373 | assert(control); | |
374 | ||
375 | android::Mutex::Autolock al(control->guard); | |
376 | control->camera_parameters.setPreviewFrameRate(fps); | |
377 | control->camera->setParameters(control->camera_parameters.flatten()); | |
378 | } | |
379 | ||
380 | void android_camera_get_preview_fps(CameraControl* control, int* fps) | |
381 | { | |
382 | REPORT_FUNCTION(); | |
383 | assert(control); | |
384 | ||
385 | android::Mutex::Autolock al(control->guard); | |
386 | *fps = control->camera_parameters.getPreviewFrameRate(); | |
387 | } | |
388 | ||
389 | void android_camera_enumerate_supported_preview_sizes(CameraControl* control, size_callback cb, void* ctx) | |
390 | { | |
391 | REPORT_FUNCTION(); | |
392 | assert(control); | |
393 | ||
394 | android::Mutex::Autolock al(control->guard); | |
395 | android::Vector<android::Size> sizes; | |
396 | control->camera_parameters.getSupportedPreviewSizes(sizes); | |
397 | ||
398 | for (unsigned int i = 0; i < sizes.size(); i++) { | |
399 | cb(ctx, sizes[i].width, sizes[i].height); | |
400 | } | |
401 | } | |
402 | ||
403 | void android_camera_enumerate_supported_picture_sizes(CameraControl* control, size_callback cb, void* ctx) | |
404 | { | |
405 | REPORT_FUNCTION(); | |
406 | assert(control); | |
407 | ||
408 | android::Mutex::Autolock al(control->guard); | |
409 | android::Vector<android::Size> sizes; | |
410 | control->camera_parameters.getSupportedPictureSizes(sizes); | |
411 | ||
412 | for (unsigned int i = 0; i < sizes.size(); i++) { | |
413 | cb(ctx, sizes[i].width, sizes[i].height); | |
414 | } | |
415 | } | |
416 | ||
417 | void android_camera_get_preview_size(CameraControl* control, int* width, int* height) | |
418 | { | |
419 | REPORT_FUNCTION(); | |
420 | assert(control); | |
421 | ||
422 | android::Mutex::Autolock al(control->guard); | |
423 | ||
424 | control->camera_parameters.getPreviewSize(width, height); | |
425 | } | |
426 | ||
427 | void android_camera_set_preview_size(CameraControl* control, int width, int height) | |
428 | { | |
429 | REPORT_FUNCTION(); | |
430 | assert(control); | |
431 | ||
432 | android::Mutex::Autolock al(control->guard); | |
433 | ||
434 | control->camera_parameters.setPreviewSize(width, height); | |
435 | control->camera->setParameters(control->camera_parameters.flatten()); | |
436 | } | |
437 | ||
438 | void android_camera_get_picture_size(CameraControl* control, int* width, int* height) | |
439 | { | |
440 | REPORT_FUNCTION(); | |
441 | assert(control); | |
442 | ||
443 | android::Mutex::Autolock al(control->guard); | |
444 | ||
445 | control->camera_parameters.getPictureSize(width, height); | |
446 | } | |
447 | ||
448 | void android_camera_set_picture_size(CameraControl* control, int width, int height) | |
449 | { | |
450 | REPORT_FUNCTION(); | |
451 | assert(control); | |
452 | ||
453 | android::Mutex::Autolock al(control->guard); | |
454 | ||
455 | control->camera_parameters.setPictureSize(width, height); | |
456 | control->camera->setParameters(control->camera_parameters.flatten()); | |
457 | } | |
458 | ||
459 | void android_camera_get_current_zoom(CameraControl* control, int* zoom) | |
460 | { | |
461 | REPORT_FUNCTION(); | |
462 | assert(control); | |
463 | ||
464 | android::Mutex::Autolock al(control->guard); | |
465 | ||
466 | *zoom = control->camera_parameters.getInt(android::CameraParameters::KEY_ZOOM); | |
467 | } | |
468 | ||
469 | void android_camera_get_max_zoom(CameraControl* control, int* zoom) | |
470 | { | |
471 | REPORT_FUNCTION(); | |
472 | assert(control); | |
473 | ||
474 | android::Mutex::Autolock al(control->guard); | |
475 | ||
476 | *zoom = control->camera_parameters.getInt(android::CameraParameters::KEY_MAX_ZOOM); | |
477 | } | |
478 | ||
479 | void android_camera_set_display_orientation(CameraControl* control, int32_t clockwise_rotation_degree) | |
480 | { | |
481 | REPORT_FUNCTION(); | |
482 | assert(control); | |
483 | ||
484 | android::Mutex::Autolock al(control->guard); | |
485 | static const int32_t ignored_parameter = 0; | |
486 | control->camera->sendCommand(CAMERA_CMD_SET_DISPLAY_ORIENTATION, clockwise_rotation_degree, ignored_parameter); | |
487 | } | |
488 | ||
489 | void android_camera_get_preview_texture_transformation(CameraControl* control, float m[16]) | |
490 | { | |
491 | REPORT_FUNCTION(); | |
492 | assert(control); | |
493 | ||
494 | if (control->preview_texture == NULL) | |
495 | return; | |
496 | ||
497 | control->preview_texture->getTransformMatrix(m); | |
498 | } | |
499 | ||
500 | void android_camera_update_preview_texture(CameraControl* control) | |
501 | { | |
502 | REPORT_FUNCTION(); | |
503 | assert(control); | |
504 | ||
505 | control->preview_texture->updateTexImage(); | |
506 | } | |
507 | ||
508 | void android_camera_set_preview_texture(CameraControl* control, int texture_id) | |
509 | { | |
510 | REPORT_FUNCTION(); | |
511 | assert(control); | |
512 | ||
513 | static const bool allow_synchronous_mode = false; | |
514 | ||
515 | android::sp<android::NativeBufferAlloc> native_alloc( | |
516 | new android::NativeBufferAlloc() | |
517 | ); | |
518 | ||
519 | android::sp<android::BufferQueue> buffer_queue( | |
520 | new android::BufferQueue(false, NULL, native_alloc) | |
521 | ); | |
522 | ||
523 | if (control->preview_texture == NULL) { | |
524 | control->preview_texture = android::sp<android::SurfaceTexture>( | |
525 | new android::SurfaceTexture( | |
526 | texture_id, | |
527 | allow_synchronous_mode, | |
528 | GL_TEXTURE_EXTERNAL_OES, | |
529 | true, | |
530 | buffer_queue)); | |
531 | } | |
532 | ||
533 | control->preview_texture->setFrameAvailableListener( | |
534 | android::sp<android::SurfaceTexture::FrameAvailableListener>(control)); | |
535 | control->camera->setPreviewTexture(control->preview_texture->getBufferQueue()); | |
536 | } | |
537 | ||
538 | void android_camera_set_preview_surface(CameraControl* control, SfSurface* surface) | |
539 | { | |
540 | REPORT_FUNCTION(); | |
541 | assert(control); | |
542 | assert(surface); | |
543 | ||
544 | android::Mutex::Autolock al(control->guard); | |
545 | control->camera->setPreviewDisplay(surface->surface); | |
546 | } | |
547 | ||
548 | void android_camera_start_preview(CameraControl* control) | |
549 | { | |
550 | REPORT_FUNCTION(); | |
551 | assert(control); | |
552 | ||
553 | android::Mutex::Autolock al(control->guard); | |
554 | control->camera->startPreview(); | |
555 | } | |
556 | ||
557 | void android_camera_stop_preview(CameraControl* control) | |
558 | { | |
559 | REPORT_FUNCTION(); | |
560 | assert(control); | |
561 | ||
562 | android::Mutex::Autolock al(control->guard); | |
563 | control->camera->stopPreview(); | |
564 | } | |
565 | ||
566 | void android_camera_start_autofocus(CameraControl* control) | |
567 | { | |
568 | REPORT_FUNCTION(); | |
569 | assert(control); | |
570 | ||
571 | android::Mutex::Autolock al(control->guard); | |
572 | control->camera->autoFocus(); | |
573 | } | |
574 | ||
575 | void android_camera_stop_autofocus(CameraControl* control) | |
576 | { | |
577 | REPORT_FUNCTION(); | |
578 | assert(control); | |
579 | ||
580 | android::Mutex::Autolock al(control->guard); | |
581 | control->camera->cancelAutoFocus(); | |
582 | } | |
583 | ||
584 | void android_camera_start_zoom(CameraControl* control, int32_t zoom) | |
585 | { | |
586 | REPORT_FUNCTION(); | |
587 | assert(control); | |
588 | ||
589 | static const int ignored_argument = 0; | |
590 | ||
591 | android::Mutex::Autolock al(control->guard); | |
592 | control->camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, | |
593 | zoom, | |
594 | ignored_argument); | |
595 | } | |
596 | ||
597 | // Adjust the zoom level immediately as opposed to smoothly zoomin gin. | |
598 | void android_camera_set_zoom(CameraControl* control, int32_t zoom) | |
599 | { | |
600 | REPORT_FUNCTION(); | |
601 | assert(control); | |
602 | ||
603 | android::Mutex::Autolock al(control->guard); | |
604 | ||
605 | control->camera_parameters.set( | |
606 | android::CameraParameters::KEY_ZOOM, | |
607 | zoom); | |
608 | ||
609 | control->camera->setParameters(control->camera_parameters.flatten()); | |
610 | } | |
611 | ||
612 | void android_camera_stop_zoom(CameraControl* control) | |
613 | { | |
614 | REPORT_FUNCTION(); | |
615 | assert(control); | |
616 | ||
617 | static const int ignored_argument = 0; | |
618 | ||
619 | android::Mutex::Autolock al(control->guard); | |
620 | control->camera->sendCommand(CAMERA_CMD_STOP_SMOOTH_ZOOM, | |
621 | ignored_argument, | |
622 | ignored_argument); | |
623 | } | |
624 | ||
625 | void android_camera_take_snapshot(CameraControl* control) | |
626 | { | |
627 | REPORT_FUNCTION(); | |
628 | assert(control); | |
629 | android::Mutex::Autolock al(control->guard); | |
630 | control->camera->takePicture(CAMERA_MSG_SHUTTER | CAMERA_MSG_COMPRESSED_IMAGE); | |
631 | } | |
632 | ||
633 | void android_camera_set_preview_format(CameraControl* control, CameraPixelFormat pf) | |
634 | { | |
635 | REPORT_FUNCTION(); | |
636 | assert(control); | |
637 | ||
638 | android::Mutex::Autolock al(control->guard); | |
639 | ||
640 | control->camera_parameters.set( | |
641 | android::CameraParameters::KEY_PREVIEW_FORMAT, | |
642 | camera_pixel_formats[pf]); | |
643 | ||
644 | control->camera->setParameters(control->camera_parameters.flatten()); | |
645 | } | |
646 | ||
647 | void android_camera_get_preview_format(CameraControl* control, CameraPixelFormat* pf) | |
648 | { | |
649 | REPORT_FUNCTION(); | |
650 | assert(control); | |
651 | ||
652 | android::Mutex::Autolock al(control->guard); | |
653 | ||
654 | *pf = pixel_formats_lut.valueFor( | |
655 | android::String8( | |
656 | control->camera_parameters.get( | |
657 | android::CameraParameters::KEY_PREVIEW_FORMAT))); | |
658 | } | |
659 | ||
660 | void android_camera_set_focus_region( | |
661 | CameraControl* control, | |
662 | FocusRegion* region) | |
663 | { | |
664 | REPORT_FUNCTION(); | |
665 | assert(control); | |
666 | ||
667 | android::Mutex::Autolock al(control->guard); | |
668 | static const char* focus_region_pattern = "(%d,%d,%d,%d,%d)"; | |
669 | static char focus_region[256]; | |
670 | snprintf(focus_region, | |
671 | sizeof(focus_region), | |
672 | focus_region_pattern, | |
673 | region->left, | |
674 | region->top, | |
675 | region->right, | |
676 | region->bottom, | |
677 | region->weight); | |
678 | ||
679 | control->camera_parameters.set( | |
680 | android::CameraParameters::KEY_FOCUS_AREAS, | |
681 | focus_region); | |
682 | ||
683 | control->camera->setParameters(control->camera_parameters.flatten()); | |
684 | } | |
685 | ||
686 | void android_camera_reset_focus_region(CameraControl* control) | |
687 | { | |
688 | static FocusRegion region = { 0, 0, 0, 0, 0 }; | |
689 | ||
690 | android_camera_set_focus_region(control, ®ion); | |
691 | } | |
692 | ||
693 | void android_camera_set_rotation(CameraControl* control, int rotation) | |
694 | { | |
695 | REPORT_FUNCTION(); | |
696 | assert(control); | |
697 | ||
698 | android::Mutex::Autolock al(control->guard); | |
699 | control->camera_parameters.set( | |
700 | android::CameraParameters::KEY_ROTATION, | |
701 | rotation); | |
702 | control->camera->setParameters(control->camera_parameters.flatten()); | |
703 | } | |
704 | ||
705 | void android_camera_enumerate_supported_video_sizes(CameraControl* control, size_callback cb, void* ctx) | |
706 | { | |
707 | REPORT_FUNCTION(); | |
708 | assert(control); | |
709 | assert(cb); | |
710 | ||
711 | android::Mutex::Autolock al(control->guard); | |
712 | android::Vector<android::Size> sizes; | |
713 | control->camera_parameters.getSupportedVideoSizes(sizes); | |
714 | ||
715 | for (unsigned int i = 0; i < sizes.size(); i++) { | |
716 | cb(ctx, sizes[i].width, sizes[i].height); | |
717 | } | |
718 | } | |
719 | ||
720 | void android_camera_get_video_size(CameraControl* control, int* width, int* height) | |
721 | { | |
722 | REPORT_FUNCTION(); | |
723 | assert(control); | |
724 | ||
725 | android::Mutex::Autolock al(control->guard); | |
726 | ||
727 | control->camera_parameters.getVideoSize(width, height); | |
728 | } | |
729 | ||
730 | void android_camera_set_video_size(CameraControl* control, int width, int height) | |
731 | { | |
732 | REPORT_FUNCTION(); | |
733 | assert(control); | |
734 | ||
735 | android::Mutex::Autolock al(control->guard); | |
736 | ||
737 | control->camera_parameters.setVideoSize(width, height); | |
738 | control->camera->setParameters(control->camera_parameters.flatten()); | |
739 | } |