diff options
Diffstat (limited to 'camera/smdk4x12_camera.c')
| -rw-r--r-- | camera/smdk4x12_camera.c | 4530 |
1 files changed, 0 insertions, 4530 deletions
diff --git a/camera/smdk4x12_camera.c b/camera/smdk4x12_camera.c deleted file mode 100644 index 53cc16f..0000000 --- a/camera/smdk4x12_camera.c +++ /dev/null @@ -1,4530 +0,0 @@ -/* - * Copyright (C) 2013-2014 Paul Kocialkowski <contact@paulk.fr> - * - * Based on crespo libcamera and exynos4 hal libcamera: - * Copyright 2008, The Android Open Source Project - * Copyright 2010, Samsung Electronics Co. LTD - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <fcntl.h> -#include <unistd.h> -#include <stdlib.h> -#include <time.h> -#include <errno.h> -#include <malloc.h> -#include <sys/stat.h> -#include <sys/types.h> -#include <sys/time.h> -#include <sys/mman.h> -#include <sys/ioctl.h> - -#include <asm/types.h> - -#define LOG_TAG "smdk4x12_camera" -#include <utils/Log.h> -#include <utils/Timers.h> - -#include "smdk4x12_camera.h" - -#define BIG2LITTLE_ENDIAN(big) ((big & 0xff) << 24 | (big & 0xff00) << 8 | (big & 0xff0000) >> 8 | (big & 0xff000000) >> 24) - -/* - * Devices configurations - */ - -struct smdk4x12_camera_mbus_resolution smdk4x12_camera_mbus_resolutions_s5k6a3_galaxys3[] = { - // 16:9 ratio - { 1280, 720, 1344, 756 }, - // 4:3 ratio - { 1280, 960, 1392, 1044 }, - { 960, 720, 1392, 1044 }, - { 640, 480, 1392, 1044 }, - { 320, 240, 1392, 1044 }, - // 1:1 ratio - { 1392, 1392, 1392, 1392 }, - { 704, 704, 1392, 1392 }, - { 320, 320, 1392, 1392 }, -}; - -struct smdk4x12_camera_preset smdk4x12_camera_presets_galaxys3[] = { - { - .name = "S5C73M3", - .facing = CAMERA_FACING_BACK, - .orientation = 90, - .rotation = 0, - .hflip = 0, - .vflip = 0, - .capture_format = V4L2_PIX_FMT_INTERLEAVED, - .picture_format = 0, - .fimc_is = 0, - .focal_length = 3.7f, - .horizontal_view_angle = 63.0f, - .vertical_view_angle = 49.3f, - .metering = METERING_CENTER, - .params = { - .preview_size_values = "960x720,1280x720,1184x666,960x640,704x576,640x480,352x288,320x240", - .preview_size = "960x720", - .preview_format_values = "yuv420sp,yuv420p,rgb565", - .preview_format = "rgb565", - .preview_frame_rate_values = "30,20,15", - .preview_frame_rate = 30, - .preview_fps_range_values = "(15000,15000),(15000,30000),(30000,30000)", - .preview_fps_range = "15000,30000", - - .picture_size_values = "640x480,1024x768,1280x720,1600x1200,2560x1920,3264x2448,2048x1536,3264x1836,2048x1152,3264x2176", - .picture_size = "3264x2448", - .picture_format_values = "jpeg", - .picture_format = "jpeg", - .jpeg_thumbnail_size_values = "160x120,160x90,144x96", - .jpeg_thumbnail_width = 160, - .jpeg_thumbnail_height = 120, - .jpeg_thumbnail_quality = 100, - .jpeg_quality = 90, - - .video_snapshot_supported = 0, - .full_video_snap_supported = 0, - - .recording_size = "1280x720", - .recording_size_values = "1280x720,1920x1080,720x480,640x480,352x288,320x240,176x144", - .recording_format = "yuv420sp", - - .focus_mode = "continuous-picture", - .focus_mode_values = "auto,infinity,macro,fixed,continuous-picture,continuous-video", - .focus_distances = "0.15,1.20,Infinity", - .focus_areas = NULL, - .max_num_focus_areas = 1, - - .zoom_supported = 1, - .smooth_zoom_supported = 0, - .zoom_ratios = "100,102,104,109,111,113,119,121,124,131,134,138,146,150,155,159,165,170,182,189,200,213,222,232,243,255,283,300,319,364,400", - .zoom = 0, - .max_zoom = 30, - - .auto_exposure_lock_supported = 1, - .auto_exposure_lock = 0, - - .auto_white_balance_lock_supported = 1, - .auto_white_balance_lock = 0, - - .flash_mode = "auto", - .flash_mode_values = "auto,on,torch,off", - - .exposure_compensation = 0, - .exposure_compensation_step = 0.5, - .min_exposure_compensation = -4, - .max_exposure_compensation = 4, - - .whitebalance = "auto", - .whitebalance_values = "auto,incandescent,fluorescent,daylight,cloudy-daylight", - - .antibanding = "auto", - .antibanding_values = "auto,60hz,50hz,off", - - .scene_mode = "auto", - .scene_mode_values = "auto,portrait,landscape,night,beach,snow,sunset,fireworks,sports,party,candlelight,dusk-dawn,fall-color,text,back-light", - - .effect = "none", - .effect_values = "none,mono,negative,sepia,solarize,posterize,washed,vintage-warm,vintage-cold,point-blue,point-red-yellow,point-green", - - .iso = "auto", - .iso_values = "auto,ISO100,ISO200,ISO400,ISO800", - - .image_stabilization = "off", - .image_stabilization_values = "on,off", - }, - .mbus_resolutions = NULL, - .mbus_resolutions_count = 0, - }, - { - .name = "S5K6A3", - .facing = CAMERA_FACING_FRONT, - .orientation = 270, - .rotation = 0, - .hflip = 0, - .vflip = 0, - .capture_format = 0, - .picture_format = V4L2_PIX_FMT_YUYV, - .fimc_is = 1, - .focal_length = 2.73f, - .horizontal_view_angle = 52.58f, - .vertical_view_angle = 52.58f, - .metering = METERING_CENTER, - .params = { - .preview_size_values = "1280x720,960x720,640x480,320x240,704x704,320x320", - .preview_size = "960x720", - .preview_format_values = "yuv420sp,yuv420p,rgb565", - .preview_format = "rgb565", - .preview_frame_rate_values = "30,20,15,8", - .preview_frame_rate = 30, - .preview_fps_range_values = "(8000,8000),(15000,15000),(15000,30000),(30000,30000)", - .preview_fps_range = "15000,30000", - - .picture_size_values = "1344x756,1280x720,1392x1044,1280x960,960x720,640x480,1392x1392", - .picture_size = "1280x960", - .picture_format_values = "jpeg", - .picture_format = "jpeg", - .jpeg_thumbnail_size_values = "160x120,160x160,160x90,144x96", - .jpeg_thumbnail_width = 160, - .jpeg_thumbnail_height = 120, - .jpeg_thumbnail_quality = 100, - .jpeg_quality = 90, - - .video_snapshot_supported = 0, - .full_video_snap_supported = 0, - - .recording_size = "1280x720", - .recording_size_values = "1280x720,720x480,640x480,352x288,320x320,320x240,176x144", - .recording_format = "yuv420sp", - - .focus_mode = "fixed", - .focus_mode_values = "infinity,fixed", - .focus_distances = "0.20,0.25,Infinity", - .focus_areas = NULL, - .max_num_focus_areas = 0, - - .zoom_supported = 0, - - .auto_exposure_lock_supported = 0, - .auto_exposure_lock = 0, - - .auto_white_balance_lock_supported = 0, - .auto_white_balance_lock = 0, - - .flash_mode = NULL, - .flash_mode_values = NULL, - - .exposure_compensation = 0, - .exposure_compensation_step = 0.5, - .min_exposure_compensation = -4, - .max_exposure_compensation = 4, - - .whitebalance = "auto", - .whitebalance_values = "auto,incandescent,fluorescent,daylight,cloudy-daylight", - - .antibanding = NULL, - .antibanding_values = NULL, - - .scene_mode = NULL, - .scene_mode_values = NULL, - - .effect = "none", - .effect_values = "none,mono,negative,sepia,solarize,posterize,washed,vintage-warm,vintage-cold,point-blue,point-red-yellow,point-green", - - .iso = "auto", - .iso_values = "auto", - - .image_stabilization = "off", - .image_stabilization_values = "off", - }, - .mbus_resolutions = (struct smdk4x12_camera_mbus_resolution *) &smdk4x12_camera_mbus_resolutions_s5k6a3_galaxys3, - .mbus_resolutions_count = 8, - }, -}; - -struct smdk4x12_v4l2_node smdk4x12_v4l2_nodes_galaxys3[] = { - { // FIMC0 is used for capture - .id = 0, - .node = "/dev/video0", - }, - { // FIMC1 is used for preview output - .id = 1, - .node = "/dev/video1", - }, - { // FIMC2 is used for picture output - .id = 2, - .node = "/dev/video2", - }, - { // FIMC3 is used for recording output - .id = 3, - .node = "/dev/video3", - }, -}; - -struct exynox_camera_config smdk4x12_camera_config_galaxys3 = { - .presets = (struct smdk4x12_camera_preset *) &smdk4x12_camera_presets_galaxys3, - .presets_count = 2, - .v4l2_nodes = (struct smdk4x12_v4l2_node *) &smdk4x12_v4l2_nodes_galaxys3, - .v4l2_nodes_count = 4, -}; - -/* - * SMDK4x12 Camera - */ - -struct exynox_camera_config *smdk4x12_camera_config = - &smdk4x12_camera_config_galaxys3; - -int smdk4x12_camera_start(struct smdk4x12_camera *smdk4x12_camera, int id) -{ - int rc; - - if (smdk4x12_camera == NULL || id >= smdk4x12_camera->config->presets_count) - return -EINVAL; - - // ION - -#ifdef EXYNOS_ION - rc = smdk4x12_ion_init(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to init ION", __func__); - goto error; - } - - rc = smdk4x12_ion_open(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to open ION", __func__); - goto error; - } -#endif - - // V4L2 - - rc = smdk4x12_v4l2_init(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to init v4l2", __func__); - goto error; - } - - // FIMC0 - - rc = smdk4x12_v4l2_open(smdk4x12_camera, 0); - if (rc < 0) { - ALOGE("%s: Unable to open v4l2 device", __func__); - goto error; - } - - rc = smdk4x12_v4l2_querycap_cap(smdk4x12_camera, 0); - if (rc < 0) { - ALOGE("%s: Unable to query capabilities", __func__); - goto error; - } - - rc = smdk4x12_v4l2_enum_input(smdk4x12_camera, 0, id); - if (rc < 0) { - ALOGE("%s: Unable to enumerate input", __func__); - goto error; - } - - rc = smdk4x12_v4l2_s_input(smdk4x12_camera, 0, id); - if (rc < 0) { - ALOGE("%s: Unable to set inputs", __func__); - goto error; - } - - // Recording - - smdk4x12_camera->recording_metadata = 1; - - // Params - - rc = smdk4x12_camera_params_init(smdk4x12_camera, id); - if (rc < 0) { - ALOGE("%s: Unable to init params", __func__); - goto error; - } - - // Gralloc - - rc = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const struct hw_module_t **) &smdk4x12_camera->gralloc); - if (rc) - ALOGE("%s: Unable to get gralloc module", __func__); - - rc = 0; - goto complete; - -error: - smdk4x12_v4l2_close(smdk4x12_camera, 0); - -#ifdef EXYNOS_ION - smdk4x12_ion_close(smdk4x12_camera); -#endif - - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - int i; - int id; - - if (smdk4x12_camera == NULL || smdk4x12_camera->config == NULL) - return; - - smdk4x12_v4l2_close(smdk4x12_camera, 0); - -#ifdef EXYNOS_ION - smdk4x12_ion_close(smdk4x12_camera); -#endif -} - -// Params - -int smdk4x12_camera_params_init(struct smdk4x12_camera *smdk4x12_camera, int id) -{ - int rc; - - if (smdk4x12_camera == NULL || id >= smdk4x12_camera->config->presets_count) - return -EINVAL; - - // Camera params - - smdk4x12_camera->camera_rotation = smdk4x12_camera->config->presets[id].rotation; - smdk4x12_camera->camera_hflip = smdk4x12_camera->config->presets[id].hflip; - smdk4x12_camera->camera_vflip = smdk4x12_camera->config->presets[id].vflip; - smdk4x12_camera->camera_capture_format = smdk4x12_camera->config->presets[id].capture_format; - smdk4x12_camera->camera_picture_format = smdk4x12_camera->config->presets[id].picture_format; - smdk4x12_camera->camera_fimc_is = smdk4x12_camera->config->presets[id].fimc_is; - smdk4x12_camera->camera_focal_length = (int) (smdk4x12_camera->config->presets[id].focal_length * 100); - smdk4x12_camera->camera_metering = smdk4x12_camera->config->presets[id].metering; - - smdk4x12_camera->camera_mbus_resolutions = smdk4x12_camera->config->presets[id].mbus_resolutions; - smdk4x12_camera->camera_mbus_resolutions_count = smdk4x12_camera->config->presets[id].mbus_resolutions_count; - - // Recording preview - - smdk4x12_param_string_set(smdk4x12_camera, "preferred-preview-size-for-video", - smdk4x12_camera->config->presets[id].params.preview_size); - - // Preview - - smdk4x12_param_string_set(smdk4x12_camera, "preview-size-values", - smdk4x12_camera->config->presets[id].params.preview_size_values); - smdk4x12_param_string_set(smdk4x12_camera, "preview-size", - smdk4x12_camera->config->presets[id].params.preview_size); - smdk4x12_param_string_set(smdk4x12_camera, "preview-format-values", - smdk4x12_camera->config->presets[id].params.preview_format_values); - smdk4x12_param_string_set(smdk4x12_camera, "preview-format", - smdk4x12_camera->config->presets[id].params.preview_format); - smdk4x12_param_string_set(smdk4x12_camera, "preview-frame-rate-values", - smdk4x12_camera->config->presets[id].params.preview_frame_rate_values); - smdk4x12_param_int_set(smdk4x12_camera, "preview-frame-rate", - smdk4x12_camera->config->presets[id].params.preview_frame_rate); - smdk4x12_param_string_set(smdk4x12_camera, "preview-fps-range-values", - smdk4x12_camera->config->presets[id].params.preview_fps_range_values); - smdk4x12_param_string_set(smdk4x12_camera, "preview-fps-range", - smdk4x12_camera->config->presets[id].params.preview_fps_range); - - // Picture - - smdk4x12_param_string_set(smdk4x12_camera, "picture-size-values", - smdk4x12_camera->config->presets[id].params.picture_size_values); - smdk4x12_param_string_set(smdk4x12_camera, "picture-size", - smdk4x12_camera->config->presets[id].params.picture_size); - smdk4x12_param_string_set(smdk4x12_camera, "picture-format-values", - smdk4x12_camera->config->presets[id].params.picture_format_values); - smdk4x12_param_string_set(smdk4x12_camera, "picture-format", - smdk4x12_camera->config->presets[id].params.picture_format); - smdk4x12_param_string_set(smdk4x12_camera, "jpeg-thumbnail-size-values", - smdk4x12_camera->config->presets[id].params.jpeg_thumbnail_size_values); - smdk4x12_param_int_set(smdk4x12_camera, "jpeg-thumbnail-width", - smdk4x12_camera->config->presets[id].params.jpeg_thumbnail_width); - smdk4x12_param_int_set(smdk4x12_camera, "jpeg-thumbnail-height", - smdk4x12_camera->config->presets[id].params.jpeg_thumbnail_height); - smdk4x12_param_int_set(smdk4x12_camera, "jpeg-thumbnail-quality", - smdk4x12_camera->config->presets[id].params.jpeg_thumbnail_quality); - smdk4x12_param_int_set(smdk4x12_camera, "jpeg-quality", - smdk4x12_camera->config->presets[id].params.jpeg_quality); - - if (smdk4x12_camera->config->presets[id].params.video_snapshot_supported == 1) - smdk4x12_param_string_set(smdk4x12_camera, "video-snapshot-supported", "true"); - if (smdk4x12_camera->config->presets[id].params.full_video_snap_supported == 1) - smdk4x12_param_string_set(smdk4x12_camera, "full-video-snap-supported", "true"); - - // Recording - - smdk4x12_param_string_set(smdk4x12_camera, "video-size", - smdk4x12_camera->config->presets[id].params.recording_size); - smdk4x12_param_string_set(smdk4x12_camera, "video-size-values", - smdk4x12_camera->config->presets[id].params.recording_size_values); - smdk4x12_param_string_set(smdk4x12_camera, "video-frame-format", - smdk4x12_camera->config->presets[id].params.recording_format); - - // Focus - - smdk4x12_param_string_set(smdk4x12_camera, "focus-mode", - smdk4x12_camera->config->presets[id].params.focus_mode); - smdk4x12_param_string_set(smdk4x12_camera, "focus-mode-values", - smdk4x12_camera->config->presets[id].params.focus_mode_values); - smdk4x12_param_string_set(smdk4x12_camera, "focus-distances", - smdk4x12_camera->config->presets[id].params.focus_distances); - if (smdk4x12_camera->config->presets[id].params.max_num_focus_areas > 0) { - smdk4x12_param_string_set(smdk4x12_camera, "focus-areas", - smdk4x12_camera->config->presets[id].params.focus_areas); - smdk4x12_param_int_set(smdk4x12_camera, "max-num-focus-areas", - smdk4x12_camera->config->presets[id].params.max_num_focus_areas); - } - - // Zoom - - if (smdk4x12_camera->config->presets[id].params.zoom_supported == 1) { - smdk4x12_param_string_set(smdk4x12_camera, "zoom-supported", "true"); - - if (smdk4x12_camera->config->presets[id].params.smooth_zoom_supported == 1) - smdk4x12_param_string_set(smdk4x12_camera, "smooth-zoom-supported", "true"); - - if (smdk4x12_camera->config->presets[id].params.zoom_ratios != NULL) - smdk4x12_param_string_set(smdk4x12_camera, "zoom-ratios", smdk4x12_camera->config->presets[id].params.zoom_ratios); - - smdk4x12_param_int_set(smdk4x12_camera, "zoom", smdk4x12_camera->config->presets[id].params.zoom); - smdk4x12_param_int_set(smdk4x12_camera, "max-zoom", smdk4x12_camera->config->presets[id].params.max_zoom); - - } else { - smdk4x12_param_string_set(smdk4x12_camera, "zoom-supported", "false"); - } - - // AE lock - - if (smdk4x12_camera->config->presets[id].params.auto_exposure_lock_supported == 1) { - smdk4x12_param_string_set(smdk4x12_camera, "auto-exposure-lock-supported", "true"); - - if (smdk4x12_camera->config->presets[id].params.auto_exposure_lock) - smdk4x12_param_string_set(smdk4x12_camera, "auto-exposure-lock", "true"); - else - smdk4x12_param_string_set(smdk4x12_camera, "auto-exposure-lock", "false"); - } - - // AWB lock - - if (smdk4x12_camera->config->presets[id].params.auto_white_balance_lock_supported == 1) { - smdk4x12_param_string_set(smdk4x12_camera, "auto-whitebalance-lock-supported", "true"); - - if (smdk4x12_camera->config->presets[id].params.auto_white_balance_lock) - smdk4x12_param_string_set(smdk4x12_camera, "auto-whitebalance-lock", "true"); - else - smdk4x12_param_string_set(smdk4x12_camera, "auto-whitebalance-lock", "false"); - } - - // Flash - - smdk4x12_param_string_set(smdk4x12_camera, "flash-mode", - smdk4x12_camera->config->presets[id].params.flash_mode); - smdk4x12_param_string_set(smdk4x12_camera, "flash-mode-values", - smdk4x12_camera->config->presets[id].params.flash_mode_values); - - // Exposure - - smdk4x12_param_int_set(smdk4x12_camera, "exposure-compensation", - smdk4x12_camera->config->presets[id].params.exposure_compensation); - smdk4x12_param_float_set(smdk4x12_camera, "exposure-compensation-step", - smdk4x12_camera->config->presets[id].params.exposure_compensation_step); - smdk4x12_param_int_set(smdk4x12_camera, "min-exposure-compensation", - smdk4x12_camera->config->presets[id].params.min_exposure_compensation); - smdk4x12_param_int_set(smdk4x12_camera, "max-exposure-compensation", - smdk4x12_camera->config->presets[id].params.max_exposure_compensation); - - // Antibanding - - smdk4x12_param_string_set(smdk4x12_camera, "antibanding", - smdk4x12_camera->config->presets[id].params.antibanding); - smdk4x12_param_string_set(smdk4x12_camera, "antibanding-values", - smdk4x12_camera->config->presets[id].params.antibanding_values); - - // WB - - smdk4x12_param_string_set(smdk4x12_camera, "whitebalance", - smdk4x12_camera->config->presets[id].params.whitebalance); - smdk4x12_param_string_set(smdk4x12_camera, "whitebalance-values", - smdk4x12_camera->config->presets[id].params.whitebalance_values); - - // Scene mode - - smdk4x12_param_string_set(smdk4x12_camera, "scene-mode", - smdk4x12_camera->config->presets[id].params.scene_mode); - smdk4x12_param_string_set(smdk4x12_camera, "scene-mode-values", - smdk4x12_camera->config->presets[id].params.scene_mode_values); - - // Effect - - smdk4x12_param_string_set(smdk4x12_camera, "effect", - smdk4x12_camera->config->presets[id].params.effect); - smdk4x12_param_string_set(smdk4x12_camera, "effect-values", - smdk4x12_camera->config->presets[id].params.effect_values); - - // ISO - - smdk4x12_param_string_set(smdk4x12_camera, "iso", - smdk4x12_camera->config->presets[id].params.iso); - smdk4x12_param_string_set(smdk4x12_camera, "iso-values", - smdk4x12_camera->config->presets[id].params.iso_values); - - // Image stabilization - - smdk4x12_param_string_set(smdk4x12_camera, "image-stabilization", - smdk4x12_camera->config->presets[id].params.image_stabilization); - smdk4x12_param_string_set(smdk4x12_camera, "image-stabilization-values", - smdk4x12_camera->config->presets[id].params.image_stabilization_values); - - // Camera - - smdk4x12_param_float_set(smdk4x12_camera, "focal-length", - smdk4x12_camera->config->presets[id].focal_length); - smdk4x12_param_float_set(smdk4x12_camera, "horizontal-view-angle", - smdk4x12_camera->config->presets[id].horizontal_view_angle); - smdk4x12_param_float_set(smdk4x12_camera, "vertical-view-angle", - smdk4x12_camera->config->presets[id].vertical_view_angle); - - rc = smdk4x12_camera_params_apply(smdk4x12_camera, 1); - if (rc < 0) { - ALOGE("%s: Unable to apply params", __func__); - return -1; - } - - return 0; -} - -int smdk4x12_camera_params_apply(struct smdk4x12_camera *smdk4x12_camera, int force) -{ - char *recording_hint_string; - char *recording_preview_size_string; - - char *preview_size_string; - int preview_width = 0; - int preview_height = 0; - char *preview_format_string; - int preview_format; - int preview_fps; - - char *picture_size_string; - int picture_width = 0; - int picture_height = 0; - char *picture_format_string; - int picture_format; - - int jpeg_thumbnail_width; - int jpeg_thumbnail_height; - int jpeg_thumbnail_quality; - int jpeg_quality; - - char *video_size_string; - int recording_width = 0; - int recording_height = 0; - char *video_frame_format_string; - int recording_format; - int camera_sensor_mode; - int fimc_is_mode = 0; - - char *focus_mode_string; - int focus_mode = 0; - char *focus_areas_string; - int focus_left, focus_top, focus_right, focus_bottom, focus_weigth; - int focus_x; - int focus_y; - - char *zoom_supported_string; - int zoom, max_zoom; - - char *ae_lock_supported_string; - char *ae_lock_string; - int ae_lock = 0; - - char *awb_lock_supported_string; - char *awb_lock_string; - int awb_lock = 0; - int aeawb = 0; - - char *flash_mode_string; - int flash_mode; - - int exposure_compensation; - int min_exposure_compensation; - int max_exposure_compensation; - - char *antibanding_string; - int antibanding; - - char *whitebalance_string; - int whitebalance; - - char *scene_mode_string; - int scene_mode; - - char *effect_string; - int effect; - - char *iso_string; - int iso; - - char *image_stabilization_string; - int image_stabilization; - - int w, h; - char *k; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - // Preview - - preview_size_string = smdk4x12_param_string_get(smdk4x12_camera, "preview-size"); - if (preview_size_string != NULL) { - sscanf(preview_size_string, "%dx%d", &preview_width, &preview_height); - - if (preview_width != 0 && preview_width != smdk4x12_camera->preview_width) - smdk4x12_camera->preview_width = preview_width; - if (preview_height != 0 && preview_height != smdk4x12_camera->preview_height) - smdk4x12_camera->preview_height = preview_height; - } - - preview_format_string = smdk4x12_param_string_get(smdk4x12_camera, "preview-format"); - if (preview_format_string != NULL) { - if (strcmp(preview_format_string, "yuv420sp") == 0) { - preview_format = V4L2_PIX_FMT_NV21; - } else if (strcmp(preview_format_string, "yuv420p") == 0) { - preview_format = V4L2_PIX_FMT_YUV420; - } else if (strcmp(preview_format_string, "rgb565") == 0) { - preview_format = V4L2_PIX_FMT_RGB565; - } else if (strcmp(preview_format_string, "rgb8888") == 0) { - preview_format = V4L2_PIX_FMT_RGB32; - } else { - ALOGE("%s: Unsupported preview format: %s", __func__, preview_format_string); - preview_format = V4L2_PIX_FMT_NV21; - } - - if (preview_format != smdk4x12_camera->preview_format) - smdk4x12_camera->preview_format = preview_format; - } - - preview_fps = smdk4x12_param_int_get(smdk4x12_camera, "preview-frame-rate"); - if (preview_fps > 0) - smdk4x12_camera->preview_fps = preview_fps; - else - smdk4x12_camera->preview_fps = 0; - - // Picture - - picture_size_string = smdk4x12_param_string_get(smdk4x12_camera, "picture-size"); - if (picture_size_string != NULL) { - sscanf(picture_size_string, "%dx%d", &picture_width, &picture_height); - - if (picture_width != 0 && picture_height != 0 && (picture_width != smdk4x12_camera->picture_width || picture_height != smdk4x12_camera->picture_height)) { - smdk4x12_camera->picture_width = picture_width; - smdk4x12_camera->picture_height = picture_height; - - if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED) { - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_JPEG_RESOLUTION, (picture_width & 0xffff) << 16 | (picture_height & 0xffff)); - if (rc < 0) - ALOGE("%s: Unablet to set jpeg resolution", __func__); - } - } - } - - picture_format_string = smdk4x12_param_string_get(smdk4x12_camera, "picture-format"); - if (picture_format_string != NULL) { - if (strcmp(picture_format_string, "jpeg") == 0) { - picture_format = V4L2_PIX_FMT_JPEG; - } else { - ALOGE("%s: Unsupported picture format: %s", __func__, picture_format_string); - picture_format = V4L2_PIX_FMT_JPEG; - } - - if (picture_format != smdk4x12_camera->picture_format) - smdk4x12_camera->picture_format = picture_format; - } - - jpeg_thumbnail_width = smdk4x12_param_int_get(smdk4x12_camera, "jpeg-thumbnail-width"); - if (jpeg_thumbnail_width > 0) - smdk4x12_camera->jpeg_thumbnail_width = jpeg_thumbnail_width; - - jpeg_thumbnail_height = smdk4x12_param_int_get(smdk4x12_camera, "jpeg-thumbnail-height"); - if (jpeg_thumbnail_height > 0) - smdk4x12_camera->jpeg_thumbnail_height = jpeg_thumbnail_height; - - jpeg_thumbnail_quality = smdk4x12_param_int_get(smdk4x12_camera, "jpeg-thumbnail-quality"); - if (jpeg_thumbnail_quality > 0) - smdk4x12_camera->jpeg_thumbnail_quality = jpeg_thumbnail_quality; - - jpeg_quality = smdk4x12_param_int_get(smdk4x12_camera, "jpeg-quality"); - if (jpeg_quality <= 100 && jpeg_quality >= 0 && (jpeg_quality != smdk4x12_camera->jpeg_quality || force)) { - smdk4x12_camera->jpeg_quality = jpeg_quality; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality); - if (rc < 0) - ALOGE("%s: Unable to set jpeg quality", __func__); - } - - // Recording - - video_size_string = smdk4x12_param_string_get(smdk4x12_camera, "video-size"); - if (video_size_string == NULL) - video_size_string = smdk4x12_param_string_get(smdk4x12_camera, "preview-size"); - - if (video_size_string != NULL) { - sscanf(video_size_string, "%dx%d", &recording_width, &recording_height); - - if (recording_width != 0 && recording_width != smdk4x12_camera->recording_width) - smdk4x12_camera->recording_width = recording_width; - if (recording_height != 0 && recording_height != smdk4x12_camera->recording_height) - smdk4x12_camera->recording_height = recording_height; - } - - video_frame_format_string = smdk4x12_param_string_get(smdk4x12_camera, "video-frame-format"); - if (video_frame_format_string != NULL) { - if (strcmp(video_frame_format_string, "yuv420sp") == 0) { - recording_format = V4L2_PIX_FMT_NV12; - } else if (strcmp(video_frame_format_string, "yuv420p") == 0) { - recording_format = V4L2_PIX_FMT_YUV420; - } else if (strcmp(video_frame_format_string, "rgb565") == 0) { - recording_format = V4L2_PIX_FMT_RGB565; - } else if (strcmp(video_frame_format_string, "rgb8888") == 0) { - recording_format = V4L2_PIX_FMT_RGB32; - } else { - ALOGE("%s: Unsupported recording format: %s", __func__, video_frame_format_string); - recording_format = V4L2_PIX_FMT_NV12; - } - - if (recording_format != smdk4x12_camera->recording_format) - smdk4x12_camera->recording_format = recording_format; - } - - recording_hint_string = smdk4x12_param_string_get(smdk4x12_camera, "recording-hint"); - if (recording_hint_string != NULL && strcmp(recording_hint_string, "true") == 0) { - camera_sensor_mode = SENSOR_MOVIE; - - k = smdk4x12_param_string_get(smdk4x12_camera, "preview-size-values"); - while (recording_width != 0 && recording_height != 0) { - if (k == NULL) - break; - - sscanf(k, "%dx%d", &w, &h); - - // Look for same aspect ratio - if ((recording_width * h) / recording_height == w) { - preview_width = w; - preview_height = h; - break; - } - - k = strchr(k, ','); - if (k == NULL) - break; - - k++; - } - - if (preview_width != 0 && preview_width != smdk4x12_camera->preview_width) - smdk4x12_camera->preview_width = preview_width; - if (preview_height != 0 && preview_height != smdk4x12_camera->preview_height) - smdk4x12_camera->preview_height = preview_height; - - if (smdk4x12_camera->camera_fimc_is) - fimc_is_mode = IS_MODE_PREVIEW_VIDEO; - } else { - camera_sensor_mode = SENSOR_CAMERA; - - if (smdk4x12_camera->camera_fimc_is) - fimc_is_mode = IS_MODE_PREVIEW_STILL; - } - - // Switching modes - - if (camera_sensor_mode != smdk4x12_camera->camera_sensor_mode) { - smdk4x12_camera->camera_sensor_mode = camera_sensor_mode; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SENSOR_MODE, camera_sensor_mode); - if (rc < 0) - ALOGE("%s: Unable to set sensor mode", __func__); - } - - if (smdk4x12_camera->camera_fimc_is && fimc_is_mode != smdk4x12_camera->fimc_is_mode) { - smdk4x12_camera->fimc_is_mode = fimc_is_mode; - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_IS_S_FORMAT_SCENARIO, smdk4x12_camera->fimc_is_mode); - if (rc < 0) - ALOGE("%s: Unable to set FIMC-IS scenario", __func__); - } - - // Focus - - focus_areas_string = smdk4x12_param_string_get(smdk4x12_camera, "focus-areas"); - if (focus_areas_string != NULL) { - focus_left = focus_top = focus_right = focus_bottom = focus_weigth = 0; - - rc = sscanf(focus_areas_string, "(%d,%d,%d,%d,%d)", - &focus_left, &focus_top, &focus_right, &focus_bottom, &focus_weigth); - if (rc != 5) { - ALOGE("%s: Unable to scan focus areas", __func__); - } else if (focus_left != 0 && focus_top != 0 && focus_right != 0 && focus_bottom != 0) { - focus_x = (((focus_left + focus_right) / 2) + 1000) * preview_width / 2000; - focus_y = (((focus_top + focus_bottom) / 2) + 1000) * preview_height / 2000; - - if (focus_x != smdk4x12_camera->focus_x || force) { - smdk4x12_camera->focus_x = focus_x; - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_X, focus_x); - if (rc < 0) - ALOGE("%s: Unable to set object x position", __func__); - } - - if (focus_y != smdk4x12_camera->focus_y || force) { - smdk4x12_camera->focus_y = focus_y; - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_Y, focus_y); - if (rc < 0) - ALOGE("%s: Unable to set object y position", __func__); - } - - focus_mode = FOCUS_MODE_TOUCH; - } - } - - focus_mode_string = smdk4x12_param_string_get(smdk4x12_camera, "focus-mode"); - if (focus_mode_string != NULL) { - if (focus_mode == 0) { - if (strcmp(focus_mode_string, "auto") == 0) - focus_mode = FOCUS_MODE_AUTO; - else if (strcmp(focus_mode_string, "infinity") == 0) - focus_mode = FOCUS_MODE_INFINITY; - else if (strcmp(focus_mode_string, "macro") == 0) - focus_mode = FOCUS_MODE_MACRO; - else if (strcmp(focus_mode_string, "fixed") == 0) - focus_mode = FOCUS_MODE_FIXED; - else if (strcmp(focus_mode_string, "facedetect") == 0) - focus_mode = FOCUS_MODE_FACEDETECT; - else if (strcmp(focus_mode_string, "continuous-video") == 0) - focus_mode = FOCUS_MODE_CONTINOUS_VIDEO; - else if (strcmp(focus_mode_string, "continuous-picture") == 0) - focus_mode = FOCUS_MODE_CONTINOUS_PICTURE; - else - focus_mode = FOCUS_MODE_AUTO; - } - - if (focus_mode != smdk4x12_camera->focus_mode || force) { - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode); - if (rc < 0) - ALOGE("%s: Unable to set focus mode", __func__); - } - - smdk4x12_camera->focus_mode = focus_mode; - } - - // Zoom - - zoom_supported_string = smdk4x12_param_string_get(smdk4x12_camera, "zoom-supported"); - if (zoom_supported_string != NULL && strcmp(zoom_supported_string, "true") == 0) { - zoom = smdk4x12_param_int_get(smdk4x12_camera, "zoom"); - max_zoom = smdk4x12_param_int_get(smdk4x12_camera, "max-zoom"); - if (zoom <= max_zoom && zoom >= 0 && (zoom != smdk4x12_camera->zoom || force)) { - smdk4x12_camera->zoom = zoom; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_ZOOM, zoom); - if (rc < 0) - ALOGE("%s: Unable to set camera zoom", __func__); - } - - } - - // AE lock - - ae_lock_supported_string = smdk4x12_param_string_get(smdk4x12_camera, "auto-exposure-lock-supported"); - ae_lock_string = smdk4x12_param_string_get(smdk4x12_camera, "auto-exposure-lock"); - if (ae_lock_supported_string != NULL && ae_lock_string != NULL && strcmp(ae_lock_supported_string, "true") == 0 && strcmp(ae_lock_string, "true") == 0) - ae_lock = 1; - else - ae_lock = 0; - - // AWB lock - - awb_lock_supported_string = smdk4x12_param_string_get(smdk4x12_camera, "auto-whitebalance-lock-supported"); - awb_lock_string = smdk4x12_param_string_get(smdk4x12_camera, "auto-whitebalance-lock"); - if (awb_lock_supported_string != NULL && awb_lock_string != NULL && strcmp(awb_lock_supported_string, "true") == 0 && strcmp(awb_lock_string, "true") == 0) - awb_lock = 1; - else - awb_lock = 0; - - if (ae_lock != smdk4x12_camera->ae_lock || awb_lock != smdk4x12_camera->awb_lock || force) { - smdk4x12_camera->ae_lock = ae_lock; - smdk4x12_camera->awb_lock = awb_lock; - aeawb = (ae_lock ? 0x1 : 0x0) | (awb_lock ? 0x2 : 0x0); - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, aeawb); - if (rc < 0) - ALOGE("%s: Unable to set AEAWB lock", __func__); - } - - // Flash - - flash_mode_string = smdk4x12_param_string_get(smdk4x12_camera, "flash-mode"); - if (flash_mode_string != NULL) { - if (strcmp(flash_mode_string, "off") == 0) - flash_mode = FLASH_MODE_OFF; - else if (strcmp(flash_mode_string, "auto") == 0) - flash_mode = FLASH_MODE_AUTO; - else if (strcmp(flash_mode_string, "on") == 0) - flash_mode = FLASH_MODE_ON; - else if (strcmp(flash_mode_string, "torch") == 0) - flash_mode = FLASH_MODE_TORCH; - else - flash_mode = FLASH_MODE_AUTO; - - if (flash_mode != smdk4x12_camera->flash_mode || force) { - smdk4x12_camera->flash_mode = flash_mode; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_FLASH_MODE, flash_mode); - if (rc < 0) - ALOGE("%s:Unable to set flash mode", __func__); - } - } - - // Exposure - - exposure_compensation = smdk4x12_param_int_get(smdk4x12_camera, "exposure-compensation"); - min_exposure_compensation = smdk4x12_param_int_get(smdk4x12_camera, "min-exposure-compensation"); - max_exposure_compensation = smdk4x12_param_int_get(smdk4x12_camera, "max-exposure-compensation"); - - if (exposure_compensation <= max_exposure_compensation && exposure_compensation >= min_exposure_compensation && - (exposure_compensation != smdk4x12_camera->exposure_compensation || force)) { - smdk4x12_camera->exposure_compensation = exposure_compensation; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_BRIGHTNESS, exposure_compensation); - if (rc < 0) - ALOGE("%s: Unable to set exposure", __func__); - } - - // Antibanding - - antibanding_string = smdk4x12_param_string_get(smdk4x12_camera, "antibanding"); - if (antibanding_string != NULL) { - if (strcmp(antibanding_string, "auto") == 0) - antibanding = ANTI_BANDING_AUTO; - else if (strcmp(antibanding_string, "50hz") == 0) - antibanding = ANTI_BANDING_50HZ; - else if (strcmp(antibanding_string, "60hz") == 0) - antibanding = ANTI_BANDING_60HZ; - else if (strcmp(antibanding_string, "off") == 0) - antibanding = ANTI_BANDING_OFF; - else - antibanding = ANTI_BANDING_AUTO; - - if (antibanding != smdk4x12_camera->antibanding || force) { - smdk4x12_camera->antibanding = antibanding; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_ANTI_BANDING, antibanding); - if (rc < 0) - ALOGE("%s: Unable to set antibanding", __func__); - } - } - - // WB - - whitebalance_string = smdk4x12_param_string_get(smdk4x12_camera, "whitebalance"); - if (whitebalance_string != NULL) { - if (strcmp(whitebalance_string, "auto") == 0) - whitebalance = WHITE_BALANCE_AUTO; - else if (strcmp(whitebalance_string, "incandescent") == 0) - whitebalance = WHITE_BALANCE_TUNGSTEN; - else if (strcmp(whitebalance_string, "fluorescent") == 0) - whitebalance = WHITE_BALANCE_FLUORESCENT; - else if (strcmp(whitebalance_string, "daylight") == 0) - whitebalance = WHITE_BALANCE_SUNNY; - else if (strcmp(whitebalance_string, "cloudy-daylight") == 0) - whitebalance = WHITE_BALANCE_CLOUDY; - else - whitebalance = WHITE_BALANCE_AUTO; - - if (whitebalance != smdk4x12_camera->whitebalance || force) { - smdk4x12_camera->whitebalance = whitebalance; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_WHITE_BALANCE, whitebalance); - if (rc < 0) - ALOGE("%s: Unable to set whitebalance", __func__); - } - } - - // Scene mode - - scene_mode_string = smdk4x12_param_string_get(smdk4x12_camera, "scene-mode"); - if (scene_mode_string != NULL) { - if (strcmp(scene_mode_string, "auto") == 0) - scene_mode = SCENE_MODE_NONE; - else if (strcmp(scene_mode_string, "portrait") == 0) - scene_mode = SCENE_MODE_PORTRAIT; - else if (strcmp(scene_mode_string, "landscape") == 0) - scene_mode = SCENE_MODE_LANDSCAPE; - else if (strcmp(scene_mode_string, "night") == 0) - scene_mode = SCENE_MODE_NIGHTSHOT; - else if (strcmp(scene_mode_string, "beach") == 0) - scene_mode = SCENE_MODE_BEACH_SNOW; - else if (strcmp(scene_mode_string, "snow") == 0) - scene_mode = SCENE_MODE_BEACH_SNOW; - else if (strcmp(scene_mode_string, "sunset") == 0) - scene_mode = SCENE_MODE_SUNSET; - else if (strcmp(scene_mode_string, "fireworks") == 0) - scene_mode = SCENE_MODE_FIREWORKS; - else if (strcmp(scene_mode_string, "sports") == 0) - scene_mode = SCENE_MODE_SPORTS; - else if (strcmp(scene_mode_string, "party") == 0) - scene_mode = SCENE_MODE_PARTY_INDOOR; - else if (strcmp(scene_mode_string, "candlelight") == 0) - scene_mode = SCENE_MODE_CANDLE_LIGHT; - else if (strcmp(scene_mode_string, "dusk-dawn") == 0) - scene_mode = SCENE_MODE_DUSK_DAWN; - else if (strcmp(scene_mode_string, "fall-color") == 0) - scene_mode = SCENE_MODE_FALL_COLOR; - else if (strcmp(scene_mode_string, "back-light") == 0) - scene_mode = SCENE_MODE_BACK_LIGHT; - else if (strcmp(scene_mode_string, "text") == 0) - scene_mode = SCENE_MODE_TEXT; - else - scene_mode = SCENE_MODE_NONE; - - if (scene_mode != smdk4x12_camera->scene_mode || force) { - smdk4x12_camera->scene_mode = scene_mode; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SCENE_MODE, scene_mode); - if (rc < 0) - ALOGE("%s: Unable to set scene mode", __func__); - } - } - - // Effect - - effect_string = smdk4x12_param_string_get(smdk4x12_camera, "effect"); - if (effect_string != NULL) { - if (strcmp(effect_string, "auto") == 0) - effect = IMAGE_EFFECT_NONE; - if (strcmp(effect_string, "none") == 0) - effect = IMAGE_EFFECT_NONE; - else if (strcmp(effect_string, "mono") == 0) - effect = IMAGE_EFFECT_BNW; - else if (strcmp(effect_string, "negative") == 0) - effect = IMAGE_EFFECT_NEGATIVE; - else if (strcmp(effect_string, "sepia") == 0) - effect = IMAGE_EFFECT_SEPIA; - else if (strcmp(effect_string, "aqua") == 0) - effect = IMAGE_EFFECT_AQUA; - else if (strcmp(effect_string, "solarize") == 0) - effect = IMAGE_EFFECT_SOLARIZE; - else if (strcmp(effect_string, "posterize") == 0) - effect = IMAGE_EFFECT_POSTERIZE; - else if (strcmp(effect_string, "washed") == 0) - effect = IMAGE_EFFECT_WASHED; - else if (strcmp(effect_string, "sketch") == 0) - effect = IMAGE_EFFECT_SKETCH; - else if (strcmp(effect_string, "vintage-warm") == 0) - effect = IMAGE_EFFECT_VINTAGE_WARM; - else if (strcmp(effect_string, "vintage-cold") == 0) - effect = IMAGE_EFFECT_VINTAGE_COLD; - else if (strcmp(effect_string, "point-blue") == 0) - effect = IMAGE_EFFECT_POINT_BLUE; - else if (strcmp(effect_string, "point-red-yellow") == 0) - effect = IMAGE_EFFECT_POINT_RED_YELLOW; - else if (strcmp(effect_string, "point-green") == 0) - effect = IMAGE_EFFECT_POINT_GREEN; - else - effect = IMAGE_EFFECT_NONE; - - if (effect != smdk4x12_camera->effect || force) { - smdk4x12_camera->effect = effect; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_EFFECT, effect); - if (rc < 0) - ALOGE("%s: Unable to set effect", __func__); - } - } - - // ISO - - iso_string = smdk4x12_param_string_get(smdk4x12_camera, "iso"); - if (iso_string != NULL) { - if (strcmp(iso_string, "auto") == 0) - iso = ISO_AUTO; - else if (strcmp(iso_string, "ISO50") == 0) - iso = ISO_50; - else if (strcmp(iso_string, "ISO100") == 0) - iso = ISO_100; - else if (strcmp(iso_string, "ISO200") == 0) - iso = ISO_200; - else if (strcmp(iso_string, "ISO400") == 0) - iso = ISO_400; - else if (strcmp(iso_string, "ISO800") == 0) - iso = ISO_800; - else - iso = ISO_AUTO; - - if (iso != smdk4x12_camera->iso || force) { - smdk4x12_camera->iso = iso; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_ISO, iso); - if (rc < 0) - ALOGE("%s: Unable to set iso", __func__); - } - } - - // Image stabilization - - image_stabilization_string = smdk4x12_param_string_get(smdk4x12_camera, "image-stabilization"); - if (image_stabilization_string != NULL) { - if (strcmp(image_stabilization_string, "on") == 0) - image_stabilization = ANTI_SHAKE_STILL_ON; - else - image_stabilization = ANTI_SHAKE_OFF; - - if (image_stabilization != smdk4x12_camera->image_stabilization || force) { - smdk4x12_camera->image_stabilization = image_stabilization; - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_ANTI_SHAKE, image_stabilization); - if (rc < 0) - ALOGE("%s: Unable to set image-stabilization", __func__); - } - } - - ALOGD("%s: Preview size: %dx%d, picture size: %dx%d, recording size: %dx%d", __func__, preview_width, preview_height, picture_width, picture_height, recording_width, recording_height); - - return 0; -} - -// Capture - -int s5c73m3_interleaved_decode(void *data, int size, - void *yuv_data, int *yuv_size, int yuv_width, int yuv_height, - void *jpeg_data, int *jpeg_size, int *decoded, int *auto_focus_result, - int *exif_flash, int *exif_iso, int *exif_exposure, - int *exif_exposure_bias, int *exif_exposure_time) -{ - int yuv_length; - int jpeg_length; - unsigned char *yuv_p; - unsigned char *jpeg_p; - unsigned char *data_p; - unsigned int *offset_p; - unsigned int pointers_array_offset; - unsigned int pointers_array_size; - unsigned int interleaved_size; - unsigned char s5c73m3_auto_focus_result; - unsigned int yuv_offset_last; - unsigned int yuv_offset; - unsigned int yuv_line_size; - unsigned short *jpeg_start_p; - int gap; - unsigned int i; - - if (data == NULL || size <= 0 || yuv_data == NULL || yuv_size == NULL || yuv_width <= 0 || yuv_height <= 0 || jpeg_data == NULL || jpeg_size == NULL || decoded == NULL || auto_focus_result == NULL || exif_flash == NULL || exif_iso == NULL || exif_exposure == NULL || exif_exposure_bias == NULL || exif_exposure_time == NULL) - return -EINVAL; - - yuv_length = 0; - jpeg_length = 0; - - data_p = (unsigned char *) data; - data_p += size - 0x1000; // End of the first plane (interleaved buffer) - data_p += 4046; // Experimental offset for decoded - - *decoded = (int) *data_p; - - data_p = (unsigned char *) data; - data_p += size - 0x1000; // End of the first plane (interleaved buffer) - data_p += 50; // Experimental offset for auto-focus result - - s5c73m3_auto_focus_result = *data_p; - switch (s5c73m3_auto_focus_result) { - case S5C73M3_AF_STATUS_FOCUSING: - case S5C73M3_CAF_STATUS_FOCUSING: - *auto_focus_result = CAMERA_AF_STATUS_IN_PROGRESS; - break; - case S5C73M3_AF_STATUS_FOCUSED: - case S5C73M3_CAF_STATUS_FOCUSED: - *auto_focus_result = CAMERA_AF_STATUS_SUCCESS; - break; - case S5C73M3_AF_STATUS_INVALID: - case S5C73M3_CAF_STATUS_FIND_SEARCHING_DIR: - case S5C73M3_AF_STATUS_UNFOCUSED: - case S5C73M3_CAF_STATUS_UNFOCUSED: - default: - *auto_focus_result = CAMERA_AF_STATUS_FAIL; - break; - } - - data_p = (unsigned char *) data; - data_p += size - 0x1000; // End of the first plane (interleaved buffer) - data_p += 4; // EXIF flash offset - *exif_flash = (int) *data_p; - - data_p += 4; // EXIF ISO offset - *exif_iso = (int) ((data_p[1] << 8) | (data_p[0] & 0xff)); - - data_p += 4; // EXIF exposure offset - *exif_exposure = (int) *data_p; - - data_p += 4; // EXIF exposure bias offset - *exif_exposure_bias = (int) ((data_p[1] << 8) | (data_p[0] & 0xff)); - - data_p += 8; // EXIF exposure time offset - *exif_exposure_time = (int) ((data_p[1] << 8) | (data_p[0] & 0xff)); - - data_p = (unsigned char *) data; - data_p += size - 0x1000; // End of the first plane (interleaved buffer) - data_p += 4084; // Experimental offset for interleaved size - - // Read the pointers array offset - offset_p = (unsigned int *) data_p; - pointers_array_offset = BIG2LITTLE_ENDIAN(*offset_p); - interleaved_size = pointers_array_offset; - - // Read the pointers array size, it should be 4 * yuv_height - data_p += sizeof(pointers_array_offset); - offset_p = (unsigned int *) data_p; - pointers_array_size = BIG2LITTLE_ENDIAN(*offset_p); - - if (!*decoded) - return 0; - - ALOGD("%s: Interleaved pointers array is at offset 0x%x, 0x%x bytes long\n", __func__, pointers_array_offset, pointers_array_size); - - if ((int) pointers_array_offset > size || (int) pointers_array_size > size || (int) pointers_array_size < yuv_height * (int) sizeof(unsigned int)) { - ALOGE("%s: Invalid informations", __func__); - return -1; - } - - data_p = (unsigned char *) data; - data_p += pointers_array_offset; - yuv_p = (unsigned char *) yuv_data; - jpeg_p = (unsigned char *) jpeg_data; - jpeg_start_p = NULL; - - yuv_line_size = yuv_width * 2; - yuv_offset_last = 0; - yuv_offset = 0; - i = 0; - - while (i < pointers_array_size) { - offset_p = (unsigned int *) data_p; - yuv_offset = BIG2LITTLE_ENDIAN(*offset_p); - - if (yuv_offset > size - yuv_line_size) - return -1; - - gap = yuv_offset - yuv_offset_last - yuv_line_size; - - if (gap > 0) { - data_p = (unsigned char *) data + yuv_offset_last + yuv_line_size; - - if (jpeg_start_p == NULL) { - jpeg_start_p = (unsigned short *) data_p; - if (*jpeg_start_p != 0xd8ff) { - ALOGE("%s: Invalid jpeg start", __func__); - return -1; - } - } - - memcpy(jpeg_p, data_p, gap); - jpeg_p += gap; - jpeg_length += gap; - } - - yuv_offset_last = yuv_offset; - - data_p = (unsigned char *) data + yuv_offset; - memcpy(yuv_p, data_p, yuv_line_size); - yuv_p += yuv_line_size; - yuv_length += yuv_line_size; - - data_p = (unsigned char *) offset_p; - data_p += sizeof(yuv_offset); - i += sizeof(yuv_offset); - } - - gap = interleaved_size - yuv_offset_last - yuv_line_size; - - if (gap > 0) { - data_p = (unsigned char *) data + yuv_offset_last + yuv_line_size; - - memcpy(jpeg_p, data_p, gap); - jpeg_p += gap; - jpeg_length += gap; - } - - *yuv_size = yuv_length; - *jpeg_size = jpeg_length; - - return 0; -} - -int smdk4x12_camera_capture(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_camera_capture_listener *listener; - struct smdk4x12_camera_buffer *buffers = NULL; - struct smdk4x12_camera_buffer *buffer; - struct list_head *list; - int width, height, format; - int yuv_length, jpeg_length; - int jpeg_offset, jpeg_size; - int jpeg_thumbnail_offset, jpeg_thumbnail_size; - int buffers_count; - int buffer_length; - int auto_focus_result; - int decoded; - int busy; - void *pointer; - int address; - int offset; - int index; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - width = smdk4x12_camera->capture_width; - height = smdk4x12_camera->capture_height; - format = smdk4x12_camera->capture_format; - - buffers_count = smdk4x12_camera->capture_buffers_count; - buffer_length = smdk4x12_camera->capture_buffer_length; - - // V4L2 - - index = smdk4x12_v4l2_dqbuf_cap(smdk4x12_camera, 0); - if (index < 0 || index >= buffers_count) { - rc = smdk4x12_v4l2_poll(smdk4x12_camera, 0); - if (rc < 0) { - ALOGE("%s Unable to poll", __func__); - goto error; - } else if (rc == 0) { - // Timeout - rc = 0; - goto complete; - } - - index = smdk4x12_v4l2_dqbuf_cap(smdk4x12_camera, 0); - if (index < 0 || index >= buffers_count) { - ALOGE("%s: Unable to dequeue buffer", __func__); - goto error; - } - } - - smdk4x12_camera->capture_memory_index = index; - - address = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_PADDR_Y, index); - if (address == 0 || address == (int) 0xffffffff) { - ALOGE("%s: Unable to get address", __func__); - goto error; - } - - offset = address - smdk4x12_camera->capture_memory_address; - if (offset != index * buffer_length) - ALOGE("%s: Inconsistent memory offset (0x%x/0x%x)", __func__, offset, index * buffer_length); - - pointer = (void *) ((unsigned char *) smdk4x12_camera->capture_memory->data + offset); - - // Buffers - - switch (format) { - case V4L2_PIX_FMT_INTERLEAVED: - yuv_length = jpeg_length = 0; - auto_focus_result = decoded = 0; - - rc = s5c73m3_interleaved_decode(pointer, buffer_length, smdk4x12_camera->capture_yuv_buffer, &yuv_length, width, height, smdk4x12_camera->capture_jpeg_buffer, &jpeg_length, &decoded, &auto_focus_result, &smdk4x12_camera->capture_exif_flash, &smdk4x12_camera->capture_exif_iso, &smdk4x12_camera->capture_exif_exposure, &smdk4x12_camera->capture_exif_exposure_bias, &smdk4x12_camera->capture_exif_exposure_time); - if (rc < 0) { - ALOGE("%s: Unable to decode S5C73M3 interleaved", __func__); - goto error; - } - - if (auto_focus_result != smdk4x12_camera->auto_focus_result) { - if (!smdk4x12_camera->auto_focus_thread_enabled) { - smdk4x12_camera->auto_focus_result = auto_focus_result; - - rc = smdk4x12_camera_auto_focus(smdk4x12_camera, auto_focus_result); - if (rc < 0) { - ALOGE("%s: Unable to auto focus", __func__); - goto error; - } - } - } - - if (!decoded) { - buffers_count = 1; - buffers = (struct smdk4x12_camera_buffer *) calloc(buffers_count, sizeof(struct smdk4x12_camera_buffer)); - - buffer = buffers; - - buffer->pointer = pointer; - buffer->address = address; - buffer->length = smdk4x12_camera_buffer_length(width, height, V4L2_PIX_FMT_UYVY); - buffer->width = width; - buffer->height = height; - buffer->format = V4L2_PIX_FMT_UYVY; - } else { - buffers_count = 2; - buffers = (struct smdk4x12_camera_buffer *) calloc(buffers_count, sizeof(struct smdk4x12_camera_buffer)); - - buffer = buffers; - - memcpy(pointer, smdk4x12_camera->capture_yuv_buffer, yuv_length); - - buffer->pointer = pointer; - buffer->address = address; - buffer->length = yuv_length; - buffer->width = width; - buffer->height = height; - buffer->format = V4L2_PIX_FMT_UYVY; - - pointer = (void *) ((unsigned char *) pointer + yuv_length); - address += yuv_length; - buffer = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffer + sizeof(struct smdk4x12_camera_buffer)); - - memcpy(pointer, smdk4x12_camera->capture_jpeg_buffer, jpeg_length); - - buffer->pointer = pointer; - buffer->address = address; - buffer->length = jpeg_length; - buffer->width = smdk4x12_camera->picture_width; - buffer->height = smdk4x12_camera->picture_height; - buffer->format = V4L2_PIX_FMT_JPEG; - - smdk4x12_camera->capture_hybrid = 0; - } - break; - case V4L2_PIX_FMT_JPEG: - jpeg_size = jpeg_offset = 0; - jpeg_thumbnail_size = jpeg_thumbnail_offset = 0; - - rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_MAIN_SIZE, &jpeg_size); - if (rc < 0 || jpeg_size <= 0) { - ALOGE("%s: Unable to get jpeg size", __func__); - goto error; - } - - rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_MAIN_OFFSET, &jpeg_offset); - if (rc < 0) { - ALOGE("%s: Unable to get jpeg offset", __func__); - goto error; - } - - rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_THUMB_SIZE, &jpeg_thumbnail_size); - if (rc < 0 || jpeg_thumbnail_size <= 0) { - ALOGE("%s: Unable to get jpeg thumbnail size", __func__); - goto error; - } - - rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_THUMB_OFFSET, &jpeg_thumbnail_offset); - if (rc < 0) { - ALOGE("%s: Unable to get jpeg thumbnail offset", __func__); - goto error; - } - - buffers_count = 2; - buffers = (struct smdk4x12_camera_buffer *) calloc(buffers_count, sizeof(struct smdk4x12_camera_buffer)); - - buffer = buffers; - - buffer->pointer = (void *) ((unsigned char *) pointer + jpeg_offset); - buffer->address = address + jpeg_offset; - buffer->length = jpeg_size; - buffer->width = smdk4x12_camera->picture_width; - buffer->height = smdk4x12_camera->picture_height; - buffer->format = V4L2_PIX_FMT_JPEG; - - buffer = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffer + sizeof(struct smdk4x12_camera_buffer)); - - buffer->pointer = (void *) ((unsigned char *) pointer + jpeg_thumbnail_offset); - buffer->address = address + jpeg_thumbnail_offset; - buffer->length = jpeg_thumbnail_size; - buffer->width = smdk4x12_camera->jpeg_thumbnail_width; - buffer->height = smdk4x12_camera->jpeg_thumbnail_height; - buffer->format = V4L2_PIX_FMT_JPEG; - break; - default: - buffers_count = 1; - buffers = (struct smdk4x12_camera_buffer *) calloc(buffers_count, sizeof(struct smdk4x12_camera_buffer)); - - buffer = buffers; - - buffer->pointer = pointer; - buffer->address = address; - buffer->length = buffer_length; - buffer->width = width; - buffer->height = height; - buffer->format = format; - break; - } - - // Listeners - - list = (struct list_head *) smdk4x12_camera->capture_listeners; - while (list != NULL) { - listener = (struct smdk4x12_camera_capture_listener *) list; - - if (listener->callback == NULL) - goto list_continue_callback; - - /* - * Callback must never call a capture-locked function or it will - * block. Hence, do not unregister the listener in callback. - */ - - listener->callback(smdk4x12_camera, buffers, buffers_count); - -list_continue_callback: - list = list->next; - } - - do { - busy = 0; - - list = (struct list_head *) smdk4x12_camera->capture_listeners; - while (list != NULL) { - listener = (struct smdk4x12_camera_capture_listener *) list; - - if (listener->callback == NULL) - goto list_continue_busy; - - busy |= listener->busy; - -list_continue_busy: - list = list->next; - } - - if (busy) - usleep(1000); - } while (busy); - - rc = smdk4x12_v4l2_qbuf_cap(smdk4x12_camera, 0, index); - if (rc < 0) { - ALOGE("%s: Unable to queue buffer", __func__); - goto error; - } - - rc = 0; - goto complete; - -error: - rc = -1; - -complete: - if (buffers != NULL) - free(buffers); - - return rc; -} - -void *smdk4x12_camera_capture_thread(void *data) -{ - struct smdk4x12_camera *smdk4x12_camera; - int rc; - - if (data == NULL) - return NULL; - - smdk4x12_camera = (struct smdk4x12_camera *) data; - - ALOGE("%s: Starting thread", __func__); - smdk4x12_camera->capture_thread_running = 1; - - while (smdk4x12_camera->capture_thread_enabled) { - pthread_mutex_lock(&smdk4x12_camera->capture_lock_mutex); - - while (smdk4x12_camera->capture_enabled) { - pthread_mutex_lock(&smdk4x12_camera->capture_mutex); - - if (!smdk4x12_camera->capture_enabled) { - pthread_mutex_unlock(&smdk4x12_camera->capture_mutex); - break; - } - - rc = smdk4x12_camera_capture(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to capture", __func__); - pthread_mutex_unlock(&smdk4x12_camera->capture_mutex); - break; - } - - pthread_mutex_unlock(&smdk4x12_camera->capture_mutex); - - // Wait a bit to let others lock the mutex if they need to - usleep(10); - } - } - - smdk4x12_camera->capture_thread_running = 0; - ALOGE("%s: Exiting thread", __func__); - - return NULL; -} - -int smdk4x12_camera_capture_thread_start(struct smdk4x12_camera *smdk4x12_camera) -{ - pthread_attr_t thread_attr; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - if (smdk4x12_camera->capture_thread_enabled) { - ALOGE("Capture thread was already started!"); - return -1; - } - - pthread_mutex_init(&smdk4x12_camera->capture_mutex, NULL); - pthread_mutex_init(&smdk4x12_camera->capture_lock_mutex, NULL); - - // Initial lock - pthread_mutex_lock(&smdk4x12_camera->capture_lock_mutex); - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - - smdk4x12_camera->capture_thread_enabled = 1; - - rc = pthread_create(&smdk4x12_camera->capture_thread, &thread_attr, smdk4x12_camera_capture_thread, (void *) smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to create thread", __func__); - goto error; - } - - rc = 0; - goto complete; - -error: - pthread_mutex_destroy(&smdk4x12_camera->capture_mutex); - pthread_mutex_destroy(&smdk4x12_camera->capture_lock_mutex); - - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_capture_thread_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - int i; - - if (smdk4x12_camera == NULL) - return; - - ALOGD("%s()", __func__); - - if (!smdk4x12_camera->capture_thread_enabled) { - ALOGE("Capture thread was already stopped!"); - return; - } - - smdk4x12_camera->capture_enabled = 0; - smdk4x12_camera->capture_thread_enabled = 0; - - pthread_mutex_unlock(&smdk4x12_camera->capture_lock_mutex); - - // Wait for the thread to end - i = 0; - while (smdk4x12_camera->capture_thread_running) { - if (i++ > 10000) { - ALOGE("Capture thread is taking too long to end, something is going wrong"); - break; - } - usleep(100); - } - - if (smdk4x12_camera->capture_enabled) { - pthread_mutex_lock(&smdk4x12_camera->capture_mutex); - smdk4x12_camera_capture_stop(smdk4x12_camera); - pthread_mutex_unlock(&smdk4x12_camera->capture_mutex); - } - - pthread_mutex_destroy(&smdk4x12_camera->capture_mutex); - pthread_mutex_destroy(&smdk4x12_camera->capture_lock_mutex); -} - -int smdk4x12_camera_capture_start(struct smdk4x12_camera *smdk4x12_camera) -{ - struct v4l2_streamparm fps_param; - int width, height, format; - int mbus_width, mbus_height; - int buffers_count, buffer_length; - camera_memory_t *memory = NULL; - int value; - int fd; - int rc; - int i; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - if (smdk4x12_camera->capture_enabled) { - ALOGE("Capture was already started!"); - return -1; - } - - width = smdk4x12_camera->capture_width; - height = smdk4x12_camera->capture_height; - format = smdk4x12_camera->capture_format; - - // V4L2 - - if (format == V4L2_PIX_FMT_INTERLEAVED) { - ALOGD("Enabling hybrid capture"); - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_HYBRID, 1); - if (rc < 0) { - ALOGE("%s: Unable to set hybrid", __func__); - goto error; - } - } - - if (smdk4x12_camera->camera_fimc_is) { - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_IS_S_FORMAT_SCENARIO, smdk4x12_camera->fimc_is_mode); - if (rc < 0) { - ALOGE("%s: Unable to set FIMC-IS scenario", __func__); - goto error; - } - } - - rc = smdk4x12_v4l2_enum_fmt_cap(smdk4x12_camera, 0, format); - if (rc < 0) { - ALOGE("%s: Unable to enumerate formats", __func__); - goto error; - } - - mbus_width = width; - mbus_height = height; - - if (smdk4x12_camera->camera_mbus_resolutions != NULL) { - for (i = 0; i < smdk4x12_camera->camera_mbus_resolutions_count; i++) { - if (smdk4x12_camera->camera_mbus_resolutions[i].width == width && smdk4x12_camera->camera_mbus_resolutions[i].height == height) { - mbus_width = smdk4x12_camera->camera_mbus_resolutions[i].mbus_width; - mbus_height = smdk4x12_camera->camera_mbus_resolutions[i].mbus_height; - break; - } - } - } - - if (smdk4x12_camera->camera_fimc_is) { - // Set MBUS width/height/format - rc = smdk4x12_v4l2_s_fmt_pix(smdk4x12_camera, 0, V4L2_BUF_TYPE_PRIVATE, mbus_width, mbus_height, format, smdk4x12_camera->fimc_is_mode, V4L2_PIX_FMT_MODE_PREVIEW); - if (rc < 0) { - ALOGE("%s: Unable to set MBUS capture pixel format", __func__); - goto error; - } - } - - rc = smdk4x12_v4l2_s_fmt_pix_cap(smdk4x12_camera, 0, width, height, format, V4L2_PIX_FMT_MODE_PREVIEW); - if (rc < 0) { - ALOGE("%s: Unable to set capture pixel format", __func__); - goto error; - } - - if (!smdk4x12_camera->camera_fimc_is) { - // Set MBUS width/height/format - rc = smdk4x12_v4l2_s_fmt_pix(smdk4x12_camera, 0, V4L2_BUF_TYPE_PRIVATE, mbus_width, mbus_height, format, V4L2_FIELD_NONE, V4L2_PIX_FMT_MODE_PREVIEW); - if (rc < 0) { - ALOGE("%s: Unable to set MBUS capture pixel format", __func__); - goto error; - } - } - - if (format == V4L2_PIX_FMT_INTERLEAVED) - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CACHEABLE, 0); - else - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CACHEABLE, 1); - if (rc < 0) { - ALOGE("%s: Unable to set cacheable", __func__); - goto error; - } - - if (smdk4x12_camera->camera_fimc_is) { - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_IS_S_SCENARIO_MODE, smdk4x12_camera->fimc_is_mode); - if (rc < 0) { - ALOGE("%s: Unable to set FIMC-IS scenario mode", __func__); - goto error; - } - } - - if (format == V4L2_PIX_FMT_INTERLEAVED) { - // This must be set to 1 for interleaved data decoding - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_EMBEDDEDDATA_ENABLE, 1); - if (rc < 0) { - ALOGE("%s: Unable to set embdedded data enable", __func__); - goto error; - } - } - - // Let's assume FIMC0 has memory available through mmap - - for (i = SMDK4x12_CAMERA_CAPTURE_BUFFERS_COUNT; i > 0; i--) { - rc = smdk4x12_v4l2_reqbufs_cap(smdk4x12_camera, 0, i); - if (rc >= 0) - break; - } - - if (rc < 0) { - ALOGE("%s: Unable to request buffers", __func__); - goto error; - } - - buffers_count = rc; - ALOGD("Found %d buffers available for capture!", buffers_count); - - memset(&fps_param, 0, sizeof(fps_param)); - fps_param.parm.capture.timeperframe.numerator = 1; - fps_param.parm.capture.timeperframe.denominator = smdk4x12_camera->preview_fps; - - rc = smdk4x12_v4l2_s_parm_cap(smdk4x12_camera, 0, &fps_param); - if (rc < 0) { - ALOGE("%s: Unable to set fps", __func__); - goto error; - } - - for (i = 0; i < buffers_count; i++) { - rc = smdk4x12_v4l2_querybuf_cap(smdk4x12_camera, 0, i); - if (rc < 0) { - ALOGE("%s: Unable to query buffers", __func__); - goto error; - } - } - - buffer_length = rc; - - value = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_PADDR_Y, 0); - if (value == 0 || value == (int) 0xffffffff) { - ALOGE("%s: Unable to get address", __func__); - goto error; - } - - smdk4x12_camera->capture_memory_address = value; - - if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) { - fd = smdk4x12_v4l2_fd(smdk4x12_camera, 0); - if (fd < 0) { - ALOGE("%s: Unable to get v4l2 fd for id %d", __func__, 0); - goto error; - } - - smdk4x12_camera->capture_memory = NULL; - - memory = smdk4x12_camera->callbacks.request_memory(fd, buffer_length, buffers_count, smdk4x12_camera->callbacks.user); - if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) { - ALOGE("%s: Unable to request memory", __func__); - goto error; - } - - smdk4x12_camera->capture_memory = memory; - } else { - ALOGE("%s: No memory request function!", __func__); - goto error; - } - - if (format == V4L2_PIX_FMT_INTERLEAVED) { - smdk4x12_camera->capture_yuv_buffer = malloc(buffer_length); - smdk4x12_camera->capture_jpeg_buffer = malloc(buffer_length); - } - - for (i = 0; i < buffers_count; i++) { - rc = smdk4x12_v4l2_qbuf_cap(smdk4x12_camera, 0, i); - if (rc < 0) { - ALOGE("%s: Unable to queue buffer", __func__); - goto error; - } - } - - smdk4x12_camera->capture_buffers_count = buffers_count; - smdk4x12_camera->capture_buffer_length = buffer_length; - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_ROTATION, - smdk4x12_camera->camera_rotation); - if (rc < 0) { - ALOGE("%s: Unable to set rotation", __func__); - goto error; - } - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_HFLIP, - smdk4x12_camera->camera_hflip); - if (rc < 0) { - ALOGE("%s: Unable to set hflip", __func__); - goto error; - } - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_VFLIP, - smdk4x12_camera->camera_vflip); - if (rc < 0) { - ALOGE("%s: Unable to set vflip", __func__); - goto error; - } - - rc = smdk4x12_v4l2_streamon_cap(smdk4x12_camera, 0); - if (rc < 0) { - ALOGE("%s: Unable to start stream", __func__); - goto error; - } - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SCENE_MODE, smdk4x12_camera->scene_mode); - if (rc < 0) { - ALOGE("%s: Unable to set scene mode", __func__); - goto error; - } - - smdk4x12_camera->capture_enabled = 1; - pthread_mutex_unlock(&smdk4x12_camera->capture_lock_mutex); - - rc = 0; - goto complete; - -error: - if (smdk4x12_camera->capture_memory != NULL && smdk4x12_camera->capture_memory->release != NULL) { - smdk4x12_camera->capture_memory->release(smdk4x12_camera->capture_memory); - smdk4x12_camera->capture_memory = NULL; - } - - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_capture_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - int rc; - int i; - - if (smdk4x12_camera == NULL) - return; - - ALOGD("%s()", __func__); - - if (!smdk4x12_camera->capture_enabled) { - ALOGE("Capture was already stopped!"); - return; - } - - if (smdk4x12_camera->capture_format == V4L2_PIX_FMT_INTERLEAVED) { - ALOGD("Disabling hybrid capture"); - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_HYBRID, 0); - if (rc < 0) - ALOGE("%s: Unable to set hybrid", __func__); - } - - rc = smdk4x12_v4l2_streamoff_cap(smdk4x12_camera, 0); - if (rc < 0) { - ALOGE("%s: Unable to stop stream", __func__); - } - - if (smdk4x12_camera->capture_memory != NULL && smdk4x12_camera->capture_memory->release != NULL) { - smdk4x12_camera->capture_memory->release(smdk4x12_camera->capture_memory); - smdk4x12_camera->capture_memory = NULL; - } - - if (smdk4x12_camera->capture_yuv_buffer != NULL) { - free(smdk4x12_camera->capture_yuv_buffer); - smdk4x12_camera->capture_yuv_buffer = NULL; - } - - if (smdk4x12_camera->capture_jpeg_buffer != NULL) { - free(smdk4x12_camera->capture_jpeg_buffer); - smdk4x12_camera->capture_jpeg_buffer = NULL; - } - - smdk4x12_camera->capture_enabled = 0; -} - -int smdk4x12_camera_capture_setup(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_camera_capture_listener *listener; - struct list_head *list; - int width, height, format; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - // No listener left - if (smdk4x12_camera->capture_listeners == NULL && smdk4x12_camera->capture_enabled) { - smdk4x12_camera_capture_stop(smdk4x12_camera); - return 0; - } - - width = height = format = 0; - - list = (struct list_head *) smdk4x12_camera->capture_listeners; - while (list != NULL) { - listener = (struct smdk4x12_camera_capture_listener *) list; - - // Interleaved format already has the correct width and height for picture set through ioctl - if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED) - if (listener->format == V4L2_PIX_FMT_JPEG || listener->format == V4L2_PIX_FMT_INTERLEAVED) - goto list_continue; - - if (listener->width >= width && listener->height >= height) { - width = listener->width; - height = listener->height; - format = listener->format; - } - -list_continue: - list = list->next; - } - - // Override the capture format - if (smdk4x12_camera->camera_capture_format) - format = smdk4x12_camera->camera_capture_format; - - // Only picture is listening, but we need some preview size anyway - if (format == V4L2_PIX_FMT_INTERLEAVED && (width == 0 || height == 0)) { - width = smdk4x12_camera->preview_width; - height = smdk4x12_camera->preview_height; - } - - ALOGD("%s: Selected width: %d, height: %d, format: 0x%x", __func__, width, height, format); - - if (!smdk4x12_camera->capture_enabled) { - smdk4x12_camera->capture_width = width; - smdk4x12_camera->capture_height = height; - smdk4x12_camera->capture_format = format; - - rc = smdk4x12_camera_capture_start(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to start capture", __func__); - return -1; - } - } else if (smdk4x12_camera->capture_width != width || smdk4x12_camera->capture_height != height || smdk4x12_camera->capture_format != format) { - smdk4x12_camera_capture_stop(smdk4x12_camera); - - smdk4x12_camera->capture_width = width; - smdk4x12_camera->capture_height = height; - smdk4x12_camera->capture_format = format; - - rc = smdk4x12_camera_capture_start(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to start capture", __func__); - return -1; - } - } - - return 0; -} - -struct smdk4x12_camera_capture_listener *smdk4x12_camera_capture_listener_register( - struct smdk4x12_camera *smdk4x12_camera, int width, int height, int format, - int (*callback)(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_camera_buffer *buffers, int buffers_count)) -{ - struct smdk4x12_camera_capture_listener *listener = NULL; - struct list_head *list_end; - struct list_head *list; - int rc; - - if (smdk4x12_camera == NULL || callback == NULL) - return NULL; - - pthread_mutex_lock(&smdk4x12_camera->capture_mutex); - - listener = calloc(1, sizeof(struct smdk4x12_camera_capture_listener)); - if (listener == NULL) - goto error; - - listener->width = width; - listener->height = height; - listener->format = format; - listener->callback = callback; - listener->busy = 0; - - list_end = (struct list_head *) smdk4x12_camera->capture_listeners; - while (list_end != NULL && list_end->next != NULL) - list_end = list_end->next; - - list = (struct list_head *) listener; - list_head_insert(list, list_end, NULL); - - if (smdk4x12_camera->capture_listeners == NULL) - smdk4x12_camera->capture_listeners = listener; - - rc = smdk4x12_camera_capture_setup(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to setup capture", __func__); - goto error; - } - - rc = 0; - goto complete; - -error: - listener = NULL; - -complete: - pthread_mutex_unlock(&smdk4x12_camera->capture_mutex); - - return listener; -} - -void smdk4x12_camera_capture_listener_unregister( - struct smdk4x12_camera *smdk4x12_camera, - struct smdk4x12_camera_capture_listener *listener) -{ - struct list_head *list; - int rc; - - if (smdk4x12_camera == NULL || listener == NULL) - return; - - pthread_mutex_lock(&smdk4x12_camera->capture_mutex); - - list = (struct list_head *) smdk4x12_camera->capture_listeners; - while (list != NULL) { - if ((void *) list == (void *) listener) { - list_head_remove(list); - - if ((void *) list == (void *) smdk4x12_camera->capture_listeners) - smdk4x12_camera->capture_listeners = (struct smdk4x12_camera_capture_listener *) list->next; - - memset(listener, 0, sizeof(struct smdk4x12_camera_capture_listener)); - free(listener); - - break; - } -list_continue: - list = list->next; - } - - rc = smdk4x12_camera_capture_setup(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to setup capture", __func__); - goto complete; - } - -complete: - pthread_mutex_unlock(&smdk4x12_camera->capture_mutex); -} - -// Preview - -int smdk4x12_camera_preview_output_start(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_v4l2_output *output; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - if (smdk4x12_camera->preview_output_enabled) { - ALOGE("Preview was already started!"); - return -1; - } - - output = &smdk4x12_camera->preview_output; - - memset(output, 0, sizeof(struct smdk4x12_v4l2_output)); - output->v4l2_id = 1; - output->width = smdk4x12_camera->preview_width; - output->height = smdk4x12_camera->preview_height; - output->format = smdk4x12_camera->preview_format; - output->buffer_width = smdk4x12_camera->preview_buffer.width; - output->buffer_height = smdk4x12_camera->preview_buffer.height; - output->buffer_format = smdk4x12_camera->preview_buffer.format; - output->buffers_count = SMDK4x12_CAMERA_PREVIEW_BUFFERS_COUNT; - - rc = smdk4x12_v4l2_output_start(smdk4x12_camera, output); - if (rc < 0) { - ALOGE("%s: Unable to start preview output", __func__); - goto error; - } - - smdk4x12_camera->preview_output_enabled = 1; - - rc = 0; - goto complete; - -error: - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_preview_output_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_v4l2_output *output; - - if (smdk4x12_camera == NULL) - return; - - ALOGD("%s()", __func__); - - if (!smdk4x12_camera->preview_output_enabled) { - ALOGE("Preview was already stopped!"); - return; - } - - output = &smdk4x12_camera->preview_output; - - smdk4x12_v4l2_output_stop(smdk4x12_camera, output); - - smdk4x12_camera->preview_output_enabled = 0; -} - -int smdk4x12_camera_preview_callback(struct smdk4x12_camera *smdk4x12_camera, - struct smdk4x12_camera_buffer *buffers, int buffers_count) -{ - struct smdk4x12_camera_buffer *buffer = NULL; - int width, height, format; - int buffer_width, buffer_height, buffer_format; - int rc; - int i; - - if (smdk4x12_camera == NULL || buffers == NULL || buffers_count <= 0) - return -EINVAL; - -// ALOGD("%s()", __func__); - - if (smdk4x12_camera->preview_listener == NULL) - return -1; - - if (smdk4x12_camera->preview_listener->busy) { - ALOGE("%s: Dropping buffer", __func__); - return 0; - } - - if (smdk4x12_camera->preview_listener->width != smdk4x12_camera->preview_width || smdk4x12_camera->preview_listener->height != smdk4x12_camera->preview_height || smdk4x12_camera->preview_listener->format != smdk4x12_camera->preview_format) { - ALOGD("%s: Waiting for preview listener update", __func__); - pthread_mutex_unlock(&smdk4x12_camera->preview_lock_mutex); - return 0; - } - - smdk4x12_camera->preview_listener->busy = 1; - - width = smdk4x12_camera->preview_width; - height = smdk4x12_camera->preview_height; - format = smdk4x12_camera->preview_format; - - for (i = 0; i < buffers_count; i++) { - if (buffers->format == V4L2_PIX_FMT_JPEG) - goto buffers_continue; - - if (buffers->format == V4L2_PIX_FMT_INTERLEAVED) - goto buffers_continue; - - // Optimal buffer - if (buffers->width == width && buffers->height == height) { - buffer = buffers; - break; - } - - // Might-work buffer, but not optimal - buffer = buffers; - -buffers_continue: - buffers = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffers + sizeof(struct smdk4x12_camera_buffer)); - } - - if (buffer == NULL) { - ALOGE("%s: Unable to find an appropriate buffer for preview", __func__); - smdk4x12_camera->preview_listener->busy = 0; - return 0; - } - - buffer_width = buffer->width; - buffer_height = buffer->height; - buffer_format = buffer->format; - - pthread_mutex_lock(&smdk4x12_camera->preview_mutex); - - if (buffer_width != width || buffer_height != height || buffer_format != format) { - if (!smdk4x12_camera->preview_output_enabled) { - memcpy(&smdk4x12_camera->preview_buffer, buffer, sizeof(struct smdk4x12_camera_buffer)); - - rc = smdk4x12_camera_preview_output_start(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to start preview", __func__); - goto error; - } - } else if (smdk4x12_camera->preview_buffer.width != buffer_width || smdk4x12_camera->preview_buffer.height != buffer_height || smdk4x12_camera->preview_buffer.format != buffer_format) { - smdk4x12_camera_preview_output_stop(smdk4x12_camera); - - memcpy(&smdk4x12_camera->preview_buffer, buffer, sizeof(struct smdk4x12_camera_buffer)); - - rc = smdk4x12_camera_preview_output_start(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to start preview", __func__); - goto error; - } - } else { - memcpy(&smdk4x12_camera->preview_buffer, buffer, sizeof(struct smdk4x12_camera_buffer)); - } - } else { - // The buffer format exactly matches our expectations - - if (smdk4x12_camera->preview_output_enabled) - smdk4x12_camera_preview_output_stop(smdk4x12_camera); - - memcpy(&smdk4x12_camera->preview_buffer, buffer, sizeof(struct smdk4x12_camera_buffer)); - } - - pthread_mutex_unlock(&smdk4x12_camera->preview_lock_mutex); - - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - - rc = 0; - goto complete; - -error: - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - - smdk4x12_camera->preview_listener->busy = 0; - - rc = -1; - -complete: - return rc; -} - -int smdk4x12_camera_preview(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_v4l2_output *output; - int width, height, format; - buffer_handle_t *window_buffer; - void *window_data; - int window_stride; - camera_memory_t *memory; - void *memory_pointer; - int memory_index; - int memory_size; - int rc; - - if (smdk4x12_camera == NULL) - goto error; - -// ALOGD("%s()", __func__); - - width = smdk4x12_camera->preview_width; - height = smdk4x12_camera->preview_height; - format = smdk4x12_camera->preview_format; - - output = &smdk4x12_camera->preview_output; - - if (smdk4x12_camera->preview_output_enabled) { - rc = smdk4x12_v4l2_output(smdk4x12_camera, output, smdk4x12_camera->preview_buffer.address); - if (rc < 0) { - ALOGE("%s: Unable to output preview", __func__); - goto error; - } - - memory = output->memory; - memory_index = output->memory_index; - memory_pointer = (void *) ((unsigned char *) memory->data + output->buffer_length * memory_index); - memory_size = output->buffer_length; - } else { - // In that case, we can directly use the capture memory - memory = smdk4x12_camera->capture_memory; - memory_index = smdk4x12_camera->capture_memory_index; - memory_pointer = smdk4x12_camera->preview_buffer.pointer; - memory_size = smdk4x12_camera->preview_buffer.length; - } - - if (smdk4x12_camera->preview_window != NULL && smdk4x12_camera->gralloc != NULL) { - smdk4x12_camera->preview_window->dequeue_buffer(smdk4x12_camera->preview_window, &window_buffer, &window_stride); - smdk4x12_camera->gralloc->lock(smdk4x12_camera->gralloc, *window_buffer, GRALLOC_USAGE_SW_WRITE_OFTEN, 0, 0, width, height, &window_data); - - if (window_data == NULL) { - ALOGE("%s: Unable to lock gralloc", __func__); - goto error; - } - - memcpy(window_data, memory_pointer, memory_size); - - smdk4x12_camera->gralloc->unlock(smdk4x12_camera->gralloc, *window_buffer); - smdk4x12_camera->preview_window->enqueue_buffer(smdk4x12_camera->preview_window, window_buffer); - } - - if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_PREVIEW_FRAME) && SMDK4x12_CAMERA_CALLBACK_DEFINED(data) && !smdk4x12_camera->callback_lock) { - smdk4x12_camera->callbacks.data(CAMERA_MSG_PREVIEW_FRAME, memory, memory_index, NULL, smdk4x12_camera->callbacks.user); - } - - if (smdk4x12_camera->preview_output_enabled) { - rc = smdk4x12_v4l2_output_release(smdk4x12_camera, output); - if (rc < 0) { - ALOGE("%s: Unable to release preview output", __func__); - goto error; - } - } - - rc = 0; - goto complete; - -error: - rc = -1; - -complete: - smdk4x12_camera->preview_listener->busy = 0; - - return rc; -} - -void *smdk4x12_camera_preview_thread(void *data) -{ - struct smdk4x12_camera *smdk4x12_camera; - struct smdk4x12_camera_capture_listener *listener; - int gralloc_format; - int rc; - - if (data == NULL) - return NULL; - - smdk4x12_camera = (struct smdk4x12_camera *) data; - - ALOGE("%s: Starting thread", __func__); - smdk4x12_camera->preview_thread_running = 1; - - while (smdk4x12_camera->preview_thread_enabled) { - pthread_mutex_lock(&smdk4x12_camera->preview_lock_mutex); - - pthread_mutex_lock(&smdk4x12_camera->preview_mutex); - - if (smdk4x12_camera->preview_listener == NULL) { - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - break; - } - - if (smdk4x12_camera->preview_listener->busy) { - rc = smdk4x12_camera_preview(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to preview", __func__); - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - break; - } - } - - if (smdk4x12_camera->preview_listener->width != smdk4x12_camera->preview_width || smdk4x12_camera->preview_listener->height != smdk4x12_camera->preview_height || smdk4x12_camera->preview_listener->format != smdk4x12_camera->preview_format) { - if (smdk4x12_camera->preview_output_enabled) - smdk4x12_camera_preview_output_stop(smdk4x12_camera); - - smdk4x12_camera_capture_listener_unregister(smdk4x12_camera, smdk4x12_camera->preview_listener); - - smdk4x12_camera->preview_listener = NULL; - - listener = smdk4x12_camera_capture_listener_register(smdk4x12_camera, smdk4x12_camera->preview_width, smdk4x12_camera->preview_height, smdk4x12_camera->preview_format, smdk4x12_camera_preview_callback); - if (listener == NULL) { - ALOGE("%s: Unable to register preview capture listener", __func__); - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - break; - } - - smdk4x12_camera->preview_listener = listener; - - gralloc_format = smdk4x12_gralloc_format(smdk4x12_camera->preview_format); - - rc = smdk4x12_camera->preview_window->set_buffers_geometry(smdk4x12_camera->preview_window, smdk4x12_camera->preview_width, smdk4x12_camera->preview_height, gralloc_format); - if (rc) { - ALOGE("%s: Unable to set buffers geometry", __func__); - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - break; - } - } - - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - } - - smdk4x12_camera->preview_thread_running = 0; - ALOGE("%s: Exiting thread", __func__); - - return NULL; -} - -int smdk4x12_camera_preview_thread_start(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_camera_capture_listener *listener; - pthread_attr_t thread_attr; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - if (smdk4x12_camera->preview_thread_enabled) { - ALOGE("Preview thread was already started!"); - return -1; - } - - pthread_mutex_init(&smdk4x12_camera->preview_mutex, NULL); - pthread_mutex_init(&smdk4x12_camera->preview_lock_mutex, NULL); - - // Initial lock - pthread_mutex_lock(&smdk4x12_camera->preview_lock_mutex); - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - - smdk4x12_camera->preview_thread_enabled = 1; - - rc = pthread_create(&smdk4x12_camera->preview_thread, &thread_attr, smdk4x12_camera_preview_thread, (void *) smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to create thread", __func__); - goto error; - } - - listener = smdk4x12_camera_capture_listener_register(smdk4x12_camera, smdk4x12_camera->preview_width, smdk4x12_camera->preview_height, smdk4x12_camera->preview_format, smdk4x12_camera_preview_callback); - if (listener == NULL) { - ALOGE("%s: Unable to register preview capture listener", __func__); - goto error; - } - - smdk4x12_camera->preview_listener = listener; - - rc = 0; - goto complete; - -error: - pthread_mutex_destroy(&smdk4x12_camera->preview_mutex); - pthread_mutex_destroy(&smdk4x12_camera->preview_lock_mutex); - - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_preview_thread_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - int i; - - if (smdk4x12_camera == NULL) - return; - - ALOGD("%s()", __func__); - - if (!smdk4x12_camera->preview_thread_enabled) { - ALOGE("Preview thread was already stopped!"); - return; - } - - if (smdk4x12_camera->preview_listener != NULL) { - smdk4x12_camera_capture_listener_unregister(smdk4x12_camera, smdk4x12_camera->preview_listener); - smdk4x12_camera->preview_listener = NULL; - } - - smdk4x12_camera->preview_thread_enabled = 0; - - pthread_mutex_unlock(&smdk4x12_camera->preview_lock_mutex); - - // Wait for the thread to end - i = 0; - while (smdk4x12_camera->preview_thread_running) { - if (i++ > 10000) { - ALOGE("Preview thread is taking too long to end, something is going wrong"); - break; - } - usleep(100); - } - - if (smdk4x12_camera->preview_output_enabled) { - pthread_mutex_lock(&smdk4x12_camera->preview_mutex); - smdk4x12_camera_preview_output_stop(smdk4x12_camera); - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - } - - pthread_mutex_destroy(&smdk4x12_camera->preview_mutex); - pthread_mutex_destroy(&smdk4x12_camera->preview_lock_mutex); - - // Invalidate the preview window - smdk4x12_camera->preview_window = NULL; -} - -// Picture - -int smdk4x12_camera_picture_callback(struct smdk4x12_camera *smdk4x12_camera, - struct smdk4x12_camera_buffer *buffers, int buffers_count) -{ - struct smdk4x12_camera_buffer *jpeg_buffer = NULL; - struct smdk4x12_camera_buffer *jpeg_thumbnail_buffer = NULL; - struct smdk4x12_camera_buffer *yuv_buffer = NULL; - struct smdk4x12_camera_buffer *yuv_thumbnail_buffer = NULL; - int width, height; - int thumbnail_width, thumbnail_height; - time_t timestamp; - int rc; - int i; - - if (smdk4x12_camera == NULL || buffers == NULL || buffers_count <= 0) - return -EINVAL; - - ALOGD("%s()", __func__); - - width = smdk4x12_camera->picture_width; - height = smdk4x12_camera->picture_height; - thumbnail_width = smdk4x12_camera->jpeg_thumbnail_width; - thumbnail_height = smdk4x12_camera->jpeg_thumbnail_height; - - if (smdk4x12_camera->picture_completed) - return -1; - - if (smdk4x12_camera->picture_listener == NULL) - return -1; - - if (smdk4x12_camera->picture_listener->busy) { - ALOGE("%s: Dropping buffer", __func__); - return 0; - } - - ALOGE("%s: locking picture_mutex", __func__); - pthread_mutex_lock(&smdk4x12_camera->picture_mutex); - ALOGE("%s: locked picture_mutex", __func__); - - if (!smdk4x12_camera->picture_enabled && !smdk4x12_camera->camera_fimc_is) { - if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED && smdk4x12_camera->zoom == 0 && smdk4x12_camera->focus_mode == FOCUS_MODE_CONTINOUS_PICTURE) { - if (smdk4x12_camera->auto_focus_result == CAMERA_AF_STATUS_FAIL) { - // We don't want to take a picture out of focus, so wait a bit - timestamp = time(NULL); - - if (smdk4x12_camera->picture_focus_timestamp > 0) { - if ((timestamp - smdk4x12_camera->picture_focus_timestamp) > 2) { - ALOGE("%s: Picture will be taken out of focus", __func__); - } else { - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - return 0; - } - } else { - smdk4x12_camera->picture_focus_timestamp = timestamp; - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - return 0; - } - } else if (smdk4x12_camera->auto_focus_result == CAMERA_AF_STATUS_IN_PROGRESS) { - ALOGD("%s: Not asking for picture until auto focus is done", __func__); - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - return 0; - } - } - - smdk4x12_camera->picture_focus_timestamp = 0; - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_CAPTURE, 0); - if (rc < 0) { - ALOGE("%s: Unable to set capture", __func__); - goto error; - } - - if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED && !smdk4x12_camera->capture_hybrid) { - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_HYBRID_CAPTURE, 1); - if (rc < 0) { - ALOGE("%s: Unable to set hybrid capture", __func__); - goto error; - } - - smdk4x12_camera->capture_hybrid = 1; - } - - smdk4x12_camera->picture_enabled = 1; - - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - return 0; - } - - ALOGE("%s: unlocking picture_mutex", __func__); - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - ALOGE("%s: unlocked picture_mutex", __func__); - - smdk4x12_camera->picture_listener->busy = 1; - - // Let's assume the picture format is JPEG - - for (i = 0; i < buffers_count; i++) { - if (buffers->format == V4L2_PIX_FMT_JPEG) { - if (buffers->width == width && buffers->height == height) - jpeg_buffer = buffers; - else if (buffers->width == thumbnail_width && buffers->height == thumbnail_height) - jpeg_thumbnail_buffer = buffers; - } else { - if (buffers->width >= width && buffers->height >= height) - yuv_buffer = buffers; - if (buffers->width >= thumbnail_width && buffers->height >= thumbnail_height) - yuv_thumbnail_buffer = buffers; - } - -buffers_continue: - buffers = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffers + sizeof(struct smdk4x12_camera_buffer)); - } - - if (jpeg_buffer == NULL && yuv_buffer == NULL) { - ALOGE("%s: Unable to find an appropriate buffer for picture", __func__); - smdk4x12_camera->picture_listener->busy = 0; - return 0; - } - - // Interleaved must not use a preview frame as picture - if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED && jpeg_buffer == NULL) { - smdk4x12_camera->picture_listener->busy = 0; - return 0; - } - - pthread_mutex_lock(&smdk4x12_camera->picture_mutex); - - if (jpeg_buffer == NULL) - memset(&smdk4x12_camera->picture_jpeg_buffer, 0, sizeof(smdk4x12_camera->picture_jpeg_buffer)); - else - memcpy(&smdk4x12_camera->picture_jpeg_buffer, jpeg_buffer, sizeof(struct smdk4x12_camera_buffer)); - - if (jpeg_thumbnail_buffer == NULL) - memset(&smdk4x12_camera->picture_jpeg_thumbnail_buffer, 0, sizeof(smdk4x12_camera->picture_jpeg_thumbnail_buffer)); - else - memcpy(&smdk4x12_camera->picture_jpeg_thumbnail_buffer, jpeg_thumbnail_buffer, sizeof(struct smdk4x12_camera_buffer)); - - if (yuv_buffer == NULL) - memset(&smdk4x12_camera->picture_yuv_buffer, 0, sizeof(smdk4x12_camera->picture_yuv_buffer)); - else - memcpy(&smdk4x12_camera->picture_yuv_buffer, yuv_buffer, sizeof(struct smdk4x12_camera_buffer)); - - if (yuv_thumbnail_buffer == NULL) - memset(&smdk4x12_camera->picture_yuv_thumbnail_buffer, 0, sizeof(smdk4x12_camera->picture_yuv_thumbnail_buffer)); - else - memcpy(&smdk4x12_camera->picture_yuv_thumbnail_buffer, yuv_thumbnail_buffer, sizeof(struct smdk4x12_camera_buffer)); - - pthread_mutex_unlock(&smdk4x12_camera->picture_lock_mutex); - - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - - rc = 0; - goto complete; - -error: - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - - smdk4x12_camera->picture_listener->busy = 0; - - rc = -1; - -complete: - return rc; -} - -int smdk4x12_camera_picture(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_camera_buffer *jpeg_buffer; - struct smdk4x12_camera_buffer *jpeg_thumbnail_buffer; - struct smdk4x12_camera_buffer *yuv_buffer; - struct smdk4x12_camera_buffer *yuv_thumbnail_buffer; - struct smdk4x12_v4l2_output output; - struct smdk4x12_jpeg jpeg; - struct smdk4x12_exif exif; - int output_enabled = 0; - int width, height, format; - int buffer_width, buffer_height, buffer_format, buffer_address; - camera_memory_t *memory = NULL; - int memory_size; - unsigned char *p; - camera_memory_t *jpeg_memory = NULL; - void *jpeg_data = NULL; - int jpeg_size = 0; - camera_memory_t *jpeg_thumbnail_memory = NULL; - void *jpeg_thumbnail_data = NULL; - int jpeg_thumbnail_size = 0; - void *yuv_data = NULL; - int yuv_address; - int yuv_size = 0; - void *yuv_thumbnail_data = NULL; - int yuv_thumbnail_address; - int yuv_thumbnail_size = 0; - int rc; - - if (smdk4x12_camera == NULL) - goto error; - -// ALOGD("%s()", __func__); - - jpeg_buffer = &smdk4x12_camera->picture_jpeg_buffer; - jpeg_thumbnail_buffer = &smdk4x12_camera->picture_jpeg_thumbnail_buffer; - yuv_buffer = &smdk4x12_camera->picture_yuv_buffer; - yuv_thumbnail_buffer = &smdk4x12_camera->picture_yuv_thumbnail_buffer; - - if (jpeg_buffer->pointer != NULL && jpeg_buffer->length > 0) { - jpeg_data = jpeg_buffer->pointer; - jpeg_size = jpeg_buffer->length; - } - - if (jpeg_thumbnail_buffer->pointer != NULL && jpeg_thumbnail_buffer->length > 0) { - jpeg_thumbnail_data = jpeg_thumbnail_buffer->pointer; - jpeg_thumbnail_size = jpeg_thumbnail_buffer->length; - } - - if (yuv_buffer->pointer != NULL && yuv_buffer->length > 0) { - yuv_data = yuv_buffer->pointer; - yuv_address = yuv_buffer->address; - yuv_size = yuv_buffer->length; - } - - if (yuv_thumbnail_buffer->pointer != NULL && yuv_thumbnail_buffer->length > 0) { - yuv_thumbnail_data = yuv_thumbnail_buffer->pointer; - yuv_thumbnail_address = yuv_thumbnail_buffer->address; - yuv_thumbnail_size = yuv_thumbnail_buffer->length; - } - - // JPEG - - if (jpeg_data == NULL) { - if (yuv_data == NULL || yuv_size <= 0) { - ALOGE("%s: Unable to create jpeg without an YUV buffer", __func__); - goto error; - } - - width = smdk4x12_camera->picture_width; - height = smdk4x12_camera->picture_height; - format = yuv_buffer->format; - - buffer_width = yuv_buffer->width; - buffer_height = yuv_buffer->height; - buffer_format = yuv_buffer->format; - buffer_address = yuv_buffer->address; - - if (width != buffer_width && height != buffer_height) { - format = SMDK4x12_CAMERA_PICTURE_OUTPUT_FORMAT; - - memset(&output, 0, sizeof(output)); - output.v4l2_id = 2; - output.width = width; - output.height = height; - output.format = format; - output.buffer_width = buffer_width; - output.buffer_height = buffer_height; - output.buffer_format = buffer_format; - output.buffers_count = 1; - - rc = smdk4x12_v4l2_output_start(smdk4x12_camera, &output); - if (rc < 0) { - ALOGE("%s: Unable to start picture output", __func__); - goto error; - } - - rc = smdk4x12_v4l2_output(smdk4x12_camera, &output, buffer_address); - if (rc < 0) { - ALOGE("%s: Unable to output picture", __func__); - goto error; - } - - output_enabled = 1; - - yuv_data = output.memory->data; - yuv_address = output.memory_address; - yuv_size = output.buffer_length; - } - - memset(&jpeg, 0, sizeof(jpeg)); - jpeg.width = width; - jpeg.height = height; - jpeg.format = format; - jpeg.quality = smdk4x12_camera->jpeg_quality; - - rc = smdk4x12_jpeg_start(smdk4x12_camera, &jpeg); - if (rc < 0) { - ALOGE("%s: Unable to start jpeg", __func__); - goto error; - } - - if (jpeg.memory_in_pointer == NULL) { - ALOGE("%s: Invalid memory input pointer", __func__); - goto error; - } - - memcpy(jpeg.memory_in_pointer, yuv_data, yuv_size); - - rc = smdk4x12_jpeg(smdk4x12_camera, &jpeg); - if (rc < 0) { - ALOGE("%s: Unable to jpeg", __func__); - goto error; - } - - jpeg_size = jpeg.memory_out_size; - if (jpeg_size <= 0) { - ALOGE("%s: Invalid jpeg size", __func__); - goto error; - } - - if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) { - jpeg_memory = smdk4x12_camera->callbacks.request_memory(-1, jpeg_size, 1, smdk4x12_camera->callbacks.user); - if (jpeg_memory == NULL || jpeg_memory->data == NULL || jpeg_memory->data == MAP_FAILED) { - ALOGE("%s: Unable to request memory", __func__); - goto error; - } - } else { - ALOGE("%s: No memory request function!", __func__); - goto error; - } - - jpeg_data = jpeg_memory->data; - - memcpy(jpeg_data, jpeg.memory_out_pointer, jpeg_size); - - smdk4x12_jpeg_stop(smdk4x12_camera, &jpeg); - - if (output_enabled) { - smdk4x12_v4l2_output_stop(smdk4x12_camera, &output); - output_enabled = 0; - } - } - - ALOGE("%s: finished jpeg", __func__); - - // Thumbnail - - if (jpeg_thumbnail_data == NULL) { - if (yuv_thumbnail_data == NULL || yuv_thumbnail_size <= 0) { - ALOGE("%s: Unable to create jpeg thumbnail without an YUV buffer", __func__); - goto error; - } - - width = smdk4x12_camera->jpeg_thumbnail_width; - height = smdk4x12_camera->jpeg_thumbnail_height; - format = yuv_thumbnail_buffer->format; - - buffer_width = yuv_thumbnail_buffer->width; - buffer_height = yuv_thumbnail_buffer->height; - buffer_format = yuv_thumbnail_buffer->format; - buffer_address = yuv_thumbnail_buffer->address; - - if (width != buffer_width && height != buffer_height) { - format = SMDK4x12_CAMERA_PICTURE_OUTPUT_FORMAT; - - memset(&output, 0, sizeof(output)); - output.v4l2_id = 2; - output.width = width; - output.height = height; - output.format = format; - output.buffer_width = buffer_width; - output.buffer_height = buffer_height; - output.buffer_format = buffer_format; - output.buffers_count = 1; - - rc = smdk4x12_v4l2_output_start(smdk4x12_camera, &output); - if (rc < 0) { - ALOGE("%s: Unable to start thumbnail picture output", __func__); - goto error; - } - - output_enabled = 1; - - rc = smdk4x12_v4l2_output(smdk4x12_camera, &output, buffer_address); - if (rc < 0) { - ALOGE("%s: Unable to output thumbnail picture", __func__); - goto error; - } - - yuv_thumbnail_data = output.memory->data; - yuv_thumbnail_address = output.memory_address; - yuv_thumbnail_size = output.buffer_length; - } - - memset(&jpeg, 0, sizeof(jpeg)); - jpeg.width = width; - jpeg.height = height; - jpeg.format = format; - jpeg.quality = smdk4x12_camera->jpeg_thumbnail_quality; - - rc = smdk4x12_jpeg_start(smdk4x12_camera, &jpeg); - if (rc < 0) { - ALOGE("%s: Unable to start jpeg", __func__); - goto error; - } - - if (jpeg.memory_in_pointer == NULL) { - ALOGE("%s: Invalid memory input pointer", __func__); - goto error; - } - - memcpy(jpeg.memory_in_pointer, yuv_thumbnail_data, yuv_thumbnail_size); - - rc = smdk4x12_jpeg(smdk4x12_camera, &jpeg); - if (rc < 0) { - ALOGE("%s: Unable to jpeg", __func__); - goto error; - } - - jpeg_thumbnail_size = jpeg.memory_out_size; - if (jpeg_thumbnail_size <= 0) { - ALOGE("%s: Invalid jpeg size", __func__); - goto error; - } - - if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) { - jpeg_thumbnail_memory = smdk4x12_camera->callbacks.request_memory(-1, jpeg_thumbnail_size, 1, smdk4x12_camera->callbacks.user); - if (jpeg_thumbnail_memory == NULL || jpeg_thumbnail_memory->data == NULL || jpeg_thumbnail_memory->data == MAP_FAILED) { - ALOGE("%s: Unable to request memory", __func__); - goto error; - } - } else { - ALOGE("%s: No memory request function!", __func__); - goto error; - } - - jpeg_thumbnail_data = jpeg_thumbnail_memory->data; - - memcpy(jpeg_thumbnail_data, jpeg.memory_out_pointer, jpeg_thumbnail_size); - - smdk4x12_jpeg_stop(smdk4x12_camera, &jpeg); - - if (output_enabled) { - smdk4x12_v4l2_output_stop(smdk4x12_camera, &output); - output_enabled = 0; - } - } - - ALOGE("%s: Thumbnail finished", __func__); - - // EXIF - - memset(&exif, 0, sizeof(exif)); - exif.jpeg_thumbnail_data = jpeg_thumbnail_data; - exif.jpeg_thumbnail_size = jpeg_thumbnail_size; - - rc = smdk4x12_exif_start(smdk4x12_camera, &exif); - if (rc < 0) { - ALOGE("%s: Unable to start exif", __func__); - goto error; - } - - rc = smdk4x12_exif(smdk4x12_camera, &exif); - if (rc < 0) { - ALOGE("%s: Unable to exif", __func__); - goto error; - } - - memory_size = exif.memory_size + jpeg_size; - - if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) { - memory = smdk4x12_camera->callbacks.request_memory(-1, memory_size, 1, smdk4x12_camera->callbacks.user); - if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) { - ALOGE("%s: Unable to request memory", __func__); - goto error; - } - } else { - ALOGE("%s: No memory request function!", __func__); - goto error; - } - - ALOGE("%s: exif finished", __func__); - - p = (unsigned char *) memory->data; - - // Copy the first two bytes of the JPEG picture - memcpy(p, jpeg_data, 2); - p += 2; - - // Copy the EXIF data - memcpy(p, exif.memory->data, exif.memory_size); - p += exif.memory_size; - - // Copy the JPEG picture - memcpy(p, (void *) ((unsigned char *) jpeg_data + 2), jpeg_size - 2); - - smdk4x12_exif_stop(smdk4x12_camera, &exif); - - smdk4x12_camera->picture_memory = memory; - - rc = 0; - goto complete; - -error: - if (output_enabled) - smdk4x12_v4l2_output_stop(smdk4x12_camera, &output); - - if (memory != NULL && memory->release != NULL) { - memory->release(memory); - smdk4x12_camera->picture_memory = NULL; - } - - if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_ERROR) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock) - smdk4x12_camera->callbacks.notify(CAMERA_MSG_ERROR, -1, 0, smdk4x12_camera->callbacks.user); - - rc = -1; - -complete: - if (jpeg_memory != NULL && jpeg_memory->release != NULL) - jpeg_memory->release(jpeg_memory); - - if (jpeg_thumbnail_memory != NULL && jpeg_thumbnail_memory->release != NULL) - jpeg_thumbnail_memory->release(jpeg_thumbnail_memory); - - smdk4x12_camera->picture_completed = 1; - smdk4x12_camera->picture_listener->busy = 0; - - return rc; -} - -void *smdk4x12_camera_picture_thread(void *data) -{ - struct smdk4x12_camera *smdk4x12_camera; - int rc; - - if (data == NULL) - return NULL; - - smdk4x12_camera = (struct smdk4x12_camera *) data; - - ALOGE("%s: Starting thread", __func__); - smdk4x12_camera->picture_thread_running = 1; - - while (smdk4x12_camera->picture_thread_enabled) { - ALOGE("%s: in while loop", __func__); - pthread_mutex_lock(&smdk4x12_camera->picture_lock_mutex); - ALOGE("%s: lock_mutex locked", __func__); - pthread_mutex_lock(&smdk4x12_camera->picture_mutex); - ALOGE("%s: picture_mutex locked", __func__); - - if (smdk4x12_camera->picture_listener == NULL) { - ALOGE("%s: no listener", __func__); - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - break; - } - - if (smdk4x12_camera->picture_listener->busy) { - ALOGE("%s: listener busy", __func__); - rc = smdk4x12_camera_picture(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to take picture", __func__); - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - break; - } - } - - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - ALOGE("%s: picture_mutex unlocked", __func__); - - if (smdk4x12_camera->picture_completed) { - ALOGE("%s: picture completed", __func__); - smdk4x12_camera->picture_thread_running = 0; - smdk4x12_camera_picture_thread_stop(smdk4x12_camera); - break; - } - ALOGE("%s: still while loop", __func__); - } - - smdk4x12_camera->picture_thread_running = 0; - ALOGE("%s: Exiting thread", __func__); - - return NULL; -} - -int smdk4x12_camera_picture_thread_start(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_camera_capture_listener *listener; - pthread_attr_t thread_attr; - int format; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - if (smdk4x12_camera->picture_thread_enabled) { - ALOGE("Picture thread was already started!"); - return -1; - } - - if (smdk4x12_camera->camera_picture_format) - format = smdk4x12_camera->camera_picture_format; - else - format = smdk4x12_camera->picture_format; - - pthread_mutex_init(&smdk4x12_camera->picture_mutex, NULL); - pthread_mutex_init(&smdk4x12_camera->picture_lock_mutex, NULL); - - // Initial lock - pthread_mutex_lock(&smdk4x12_camera->picture_lock_mutex); - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - - smdk4x12_camera->picture_thread_enabled = 1; - - rc = pthread_create(&smdk4x12_camera->picture_thread, &thread_attr, smdk4x12_camera_picture_thread, (void *) smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to create thread", __func__); - goto error; - } - - smdk4x12_camera->picture_completed = 0; - - listener = smdk4x12_camera_capture_listener_register(smdk4x12_camera, smdk4x12_camera->picture_width, smdk4x12_camera->picture_height, format, smdk4x12_camera_picture_callback); - if (listener == NULL) { - ALOGE("%s: Unable to register picture capture listener", __func__); - goto error; - } - - smdk4x12_camera->picture_listener = listener; - - rc = 0; - goto complete; - -error: - pthread_mutex_destroy(&smdk4x12_camera->picture_mutex); - pthread_mutex_destroy(&smdk4x12_camera->picture_lock_mutex); - - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_picture_thread_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - camera_memory_t *memory; - int i; - - if (smdk4x12_camera == NULL) - return; - - ALOGD("%s()", __func__); - - if (!smdk4x12_camera->picture_thread_enabled) { - ALOGE("Picture thread was already stopped!"); - return; - } - - memory = smdk4x12_camera->picture_memory; - - if (smdk4x12_camera->picture_listener != NULL) { - smdk4x12_camera_capture_listener_unregister(smdk4x12_camera, smdk4x12_camera->picture_listener); - smdk4x12_camera->picture_listener = NULL; - } - - smdk4x12_camera->picture_thread_enabled = 0; - - pthread_mutex_unlock(&smdk4x12_camera->picture_lock_mutex); - - // Wait for the thread to end - i = 0; - while (smdk4x12_camera->picture_thread_running) { - if (i++ > 10000) { - ALOGE("Picture thread is taking too long to end, something is going wrong"); - break; - } - usleep(100); - } - - if (smdk4x12_camera->picture_enabled) { - pthread_mutex_lock(&smdk4x12_camera->picture_mutex); - smdk4x12_camera->picture_enabled = 0; - pthread_mutex_unlock(&smdk4x12_camera->picture_mutex); - } - - pthread_mutex_destroy(&smdk4x12_camera->picture_mutex); - pthread_mutex_destroy(&smdk4x12_camera->picture_lock_mutex); - - if (smdk4x12_camera->picture_completed && memory != NULL) { - // It is important to return at this point (and not before) for burst - - if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_SHUTTER) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock) - smdk4x12_camera->callbacks.notify(CAMERA_MSG_SHUTTER, 0, 0, smdk4x12_camera->callbacks.user); - - if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_COMPRESSED_IMAGE) && SMDK4x12_CAMERA_CALLBACK_DEFINED(data) && !smdk4x12_camera->callback_lock) - smdk4x12_camera->callbacks.data(CAMERA_MSG_COMPRESSED_IMAGE, memory, 0, NULL, smdk4x12_camera->callbacks.user); - - if (memory->release != NULL) { - memory->release(memory); - smdk4x12_camera->picture_memory = NULL; - } - } -} - -// Recording - -int smdk4x12_camera_recording_output_start(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_v4l2_output *output; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - if (smdk4x12_camera->recording_output_enabled) { - ALOGE("Recording was already started!"); - return -1; - } - - output = &smdk4x12_camera->recording_output; - - memset(output, 0, sizeof(struct smdk4x12_v4l2_output)); - output->v4l2_id = 3; - output->width = smdk4x12_camera->recording_width; - output->height = smdk4x12_camera->recording_height; - output->format = smdk4x12_camera->recording_format; - output->buffer_width = smdk4x12_camera->recording_buffer.width; - output->buffer_height = smdk4x12_camera->recording_buffer.height; - output->buffer_format = smdk4x12_camera->recording_buffer.format; - output->buffers_count = SMDK4x12_CAMERA_RECORDING_BUFFERS_COUNT; - - rc = smdk4x12_v4l2_output_start(smdk4x12_camera, output); - if (rc < 0) { - ALOGE("%s: Unable to start recording output", __func__); - goto error; - } - - smdk4x12_camera->recording_output_enabled = 1; - - rc = 0; - goto complete; - -error: - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_recording_output_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_v4l2_output *output; - - if (smdk4x12_camera == NULL) - return; - - ALOGD("%s()", __func__); - - if (!smdk4x12_camera->recording_output_enabled) { - ALOGE("Recording was already stopped!"); - return; - } - - output = &smdk4x12_camera->recording_output; - - smdk4x12_v4l2_output_stop(smdk4x12_camera, output); - - smdk4x12_camera->recording_output_enabled = 0; -} - -int smdk4x12_camera_recording_callback(struct smdk4x12_camera *smdk4x12_camera, - struct smdk4x12_camera_buffer *buffers, int buffers_count) -{ - struct smdk4x12_camera_buffer *buffer = NULL; - int width, height, format; - int buffer_width, buffer_height, buffer_format; - int rc; - int i; - - if (smdk4x12_camera == NULL || buffers == NULL || buffers_count <= 0) - return -EINVAL; - -// ALOGD("%s()", __func__); - - if (smdk4x12_camera->recording_listener == NULL) - return -1; - - if (smdk4x12_camera->recording_listener->busy) { - ALOGE("%s: Dropping buffer", __func__); - return 0; - } - - smdk4x12_camera->recording_listener->busy = 1; - - width = smdk4x12_camera->recording_width; - height = smdk4x12_camera->recording_height; - format = smdk4x12_camera->recording_format; - - for (i = 0; i < buffers_count; i++) { - if (buffers->format == V4L2_PIX_FMT_JPEG) - goto buffers_continue; - - if (buffers->format == V4L2_PIX_FMT_INTERLEAVED) - goto buffers_continue; - - // Optimal buffer - if (buffers->width == width && buffers->height == height) { - buffer = buffers; - break; - } - - // Might-work buffer, but not optimal - buffer = buffers; - -buffers_continue: - buffers = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffers + sizeof(struct smdk4x12_camera_buffer)); - } - - if (buffer == NULL) { - ALOGE("%s: Unable to find an appropriate buffer for recording", __func__); - smdk4x12_camera->recording_listener->busy = 0; - return 0; - } - - buffer_width = buffer->width; - buffer_height = buffer->height; - buffer_format = buffer->format; - - pthread_mutex_lock(&smdk4x12_camera->recording_mutex); - - if (!smdk4x12_camera->recording_output_enabled) { - memcpy(&smdk4x12_camera->recording_buffer, buffer, sizeof(struct smdk4x12_camera_buffer)); - - rc = smdk4x12_camera_recording_output_start(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to start recording", __func__); - goto error; - } - } else if (smdk4x12_camera->recording_buffer.width != buffer_width || smdk4x12_camera->recording_buffer.height != buffer_height || smdk4x12_camera->recording_buffer.format != buffer_format) { - smdk4x12_camera_recording_output_stop(smdk4x12_camera); - - memcpy(&smdk4x12_camera->recording_buffer, buffer, sizeof(struct smdk4x12_camera_buffer)); - - rc = smdk4x12_camera_recording_output_start(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to start recording", __func__); - goto error; - } - } else { - memcpy(&smdk4x12_camera->recording_buffer, buffer, sizeof(struct smdk4x12_camera_buffer)); - } - - pthread_mutex_unlock(&smdk4x12_camera->recording_lock_mutex); - - pthread_mutex_unlock(&smdk4x12_camera->recording_mutex); - - rc = 0; - goto complete; - -error: - pthread_mutex_unlock(&smdk4x12_camera->recording_mutex); - - smdk4x12_camera->recording_listener->busy = 0; - - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_recording_frame_release(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_v4l2_output *output; - int rc; - - if (smdk4x12_camera == NULL) - return; - -// ALOGD("%s()", __func__); - - output = &smdk4x12_camera->recording_output; - - if (!smdk4x12_camera->recording_output_enabled) { - ALOGE("%s: Recording output should always be enabled", __func__); - return; - } - - rc = smdk4x12_v4l2_output_release(smdk4x12_camera, output); - if (rc < 0) { - ALOGE("%s: Unable to release recording output", __func__); - return; - } -} - -int smdk4x12_camera_recording(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_v4l2_output *output; - struct smdk4x12_camera_addrs *addrs; - int width, height, format; - camera_memory_t *memory; - int memory_address; - int memory_index; - int buffer_length; - int buffers_count; - nsecs_t timestamp; - int rc; - - if (smdk4x12_camera == NULL) - goto error; - -// ALOGD("%s()", __func__); - - width = smdk4x12_camera->recording_width; - height = smdk4x12_camera->recording_height; - format = smdk4x12_camera->recording_format; - - output = &smdk4x12_camera->recording_output; - - buffer_length = smdk4x12_camera->recording_buffer_length; - buffers_count = smdk4x12_camera->recording_buffers_count; - - timestamp = systemTime(1); - - if (!smdk4x12_camera->recording_output_enabled) { - ALOGE("%s: Recording output should always be enabled", __func__); - goto error; - } - - rc = smdk4x12_v4l2_output(smdk4x12_camera, output, smdk4x12_camera->recording_buffer.address); - if (rc < 0) { - ALOGE("%s: Unable to output recording", __func__); - goto error; - } - - if (smdk4x12_camera->recording_metadata) { - memory = smdk4x12_camera->recording_memory; - memory_index = smdk4x12_camera->recording_memory_index; - memory_address = output->memory_address + output->buffer_length * output->memory_index; - - addrs = (struct smdk4x12_camera_addrs *) ((unsigned char *) memory->data + buffer_length * memory_index); - memset(addrs, 0, sizeof(struct smdk4x12_camera_addrs)); - addrs->type = 0; // kMetadataBufferTypeCameraSource - addrs->index = memory_index; - - smdk4x12_camera_yuv_planes(width, height, format, memory_address, (int *) &addrs->y, (int *) &addrs->cbcr, NULL); - } else { - memory = output->memory; - memory_index = output->memory_index; - } - - if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_VIDEO_FRAME) && SMDK4x12_CAMERA_CALLBACK_DEFINED(data_timestamp) && !smdk4x12_camera->callback_lock) - smdk4x12_camera->callbacks.data_timestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, memory, memory_index, smdk4x12_camera->callbacks.user); - else - smdk4x12_camera_recording_frame_release(smdk4x12_camera); - - if (smdk4x12_camera->recording_metadata) { - memory_index++; - smdk4x12_camera->recording_memory_index = memory_index % buffers_count; - } - - rc = 0; - goto complete; - -error: - rc = -1; - -complete: - smdk4x12_camera->recording_listener->busy = 0; - - return rc; -} - -void *smdk4x12_camera_recording_thread(void *data) -{ - struct smdk4x12_camera *smdk4x12_camera; - int rc; - - if (data == NULL) - return NULL; - - smdk4x12_camera = (struct smdk4x12_camera *) data; - - ALOGE("%s: Starting thread", __func__); - smdk4x12_camera->recording_thread_running = 1; - - while (smdk4x12_camera->recording_thread_enabled) { - pthread_mutex_lock(&smdk4x12_camera->recording_lock_mutex); - - pthread_mutex_lock(&smdk4x12_camera->recording_mutex); - - if (smdk4x12_camera->recording_listener == NULL) { - pthread_mutex_unlock(&smdk4x12_camera->recording_mutex); - break; - } - - if (smdk4x12_camera->recording_listener->busy) { - rc = smdk4x12_camera_recording(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to record", __func__); - pthread_mutex_unlock(&smdk4x12_camera->recording_mutex); - break; - } - } - - pthread_mutex_unlock(&smdk4x12_camera->recording_mutex); - } - - smdk4x12_camera->recording_thread_running = 0; - ALOGE("%s: Exiting thread", __func__); - - return NULL; -} - -int smdk4x12_camera_recording_thread_start(struct smdk4x12_camera *smdk4x12_camera) -{ - struct smdk4x12_camera_capture_listener *listener; - pthread_attr_t thread_attr; - camera_memory_t *memory = NULL; - int buffer_length; - int buffers_count; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - if (smdk4x12_camera->recording_thread_enabled) { - ALOGE("Recording thread was already started!"); - return -1; - } - - pthread_mutex_init(&smdk4x12_camera->recording_mutex, NULL); - pthread_mutex_init(&smdk4x12_camera->recording_lock_mutex, NULL); - - // Initial lock - pthread_mutex_lock(&smdk4x12_camera->recording_lock_mutex); - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - - smdk4x12_camera->recording_thread_enabled = 1; - - rc = pthread_create(&smdk4x12_camera->recording_thread, &thread_attr, smdk4x12_camera_recording_thread, (void *) smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to create thread", __func__); - goto error; - } - - if (smdk4x12_camera->recording_metadata) { - buffer_length = sizeof(struct smdk4x12_camera_addrs); - buffers_count = SMDK4x12_CAMERA_RECORDING_BUFFERS_COUNT; - - if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) { - memory = smdk4x12_camera->callbacks.request_memory(-1, buffer_length, buffers_count, smdk4x12_camera->callbacks.user); - if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) { - ALOGE("%s: Unable to request memory", __func__); - goto error; - } - } else { - ALOGE("%s: No memory request function!", __func__); - goto error; - } - - smdk4x12_camera->recording_memory = memory; - smdk4x12_camera->recording_buffer_length = buffer_length; - smdk4x12_camera->recording_buffers_count = buffers_count; - } - - listener = smdk4x12_camera_capture_listener_register(smdk4x12_camera, smdk4x12_camera->recording_width, smdk4x12_camera->recording_height, smdk4x12_camera->recording_format, smdk4x12_camera_recording_callback); - if (listener == NULL) { - ALOGE("%s: Unable to register recording capture listener", __func__); - goto error; - } - - smdk4x12_camera->recording_listener = listener; - - rc = 0; - goto complete; - -error: - if (memory != NULL && memory->release != NULL) { - memory->release(memory); - smdk4x12_camera->recording_memory = NULL; - } - - pthread_mutex_destroy(&smdk4x12_camera->recording_mutex); - pthread_mutex_destroy(&smdk4x12_camera->recording_lock_mutex); - - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_recording_thread_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - camera_memory_t *memory; - int i; - - if (smdk4x12_camera == NULL) - return; - - ALOGD("%s()", __func__); - - if (!smdk4x12_camera->recording_thread_enabled) { - ALOGE("Recording thread was already stopped!"); - return; - } - - memory = smdk4x12_camera->recording_memory; - - if (smdk4x12_camera->recording_listener != NULL) { - smdk4x12_camera_capture_listener_unregister(smdk4x12_camera, smdk4x12_camera->recording_listener); - smdk4x12_camera->recording_listener = NULL; - } - - smdk4x12_camera->recording_thread_enabled = 0; - - pthread_mutex_unlock(&smdk4x12_camera->recording_lock_mutex); - - // Wait for the thread to end - i = 0; - while (smdk4x12_camera->recording_thread_running) { - if (i++ > 10000) { - ALOGE("Recording thread is taking too long to end, something is going wrong"); - break; - } - usleep(100); - } - - if (smdk4x12_camera->recording_output_enabled) { - pthread_mutex_lock(&smdk4x12_camera->recording_mutex); - smdk4x12_camera_recording_output_stop(smdk4x12_camera); - pthread_mutex_unlock(&smdk4x12_camera->recording_mutex); - } - - pthread_mutex_destroy(&smdk4x12_camera->recording_mutex); - pthread_mutex_destroy(&smdk4x12_camera->recording_lock_mutex); - - if (memory != NULL && memory->release != NULL) { - memory->release(memory); - smdk4x12_camera->recording_memory = NULL; - } -} - -// Auto-focus - -int smdk4x12_camera_auto_focus(struct smdk4x12_camera *smdk4x12_camera, int auto_focus_status) -{ - if (smdk4x12_camera == NULL) - return -EINVAL; - -// ALOGD("%s()", __func__); - - switch (auto_focus_status) { - case CAMERA_AF_STATUS_IN_PROGRESS: - if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS_MOVE) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock) - smdk4x12_camera->callbacks.notify(CAMERA_MSG_FOCUS_MOVE, 1, 0, smdk4x12_camera->callbacks.user); - break; - case CAMERA_AF_STATUS_SUCCESS: - if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock) - smdk4x12_camera->callbacks.notify(CAMERA_MSG_FOCUS, 1, 0, smdk4x12_camera->callbacks.user); - break; - case CAMERA_AF_STATUS_FAIL: - default: - if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock) - smdk4x12_camera->callbacks.notify(CAMERA_MSG_FOCUS, 0, 0, smdk4x12_camera->callbacks.user); - break; - } - - return 0; -} - -void *smdk4x12_camera_auto_focus_thread(void *data) -{ - struct smdk4x12_camera *smdk4x12_camera; - int auto_focus_result = CAMERA_AF_STATUS_FAIL; - int auto_focus_completed = 0; - int rc; - - if (data == NULL) - return NULL; - - smdk4x12_camera = (struct smdk4x12_camera *) data; - - ALOGE("%s: Starting thread", __func__); - smdk4x12_camera->auto_focus_thread_running = 1; - - if (smdk4x12_camera->focus_mode == FOCUS_MODE_CONTINOUS_PICTURE) { - rc = smdk4x12_camera_auto_focus(smdk4x12_camera, smdk4x12_camera->auto_focus_result); - if (rc < 0) - ALOGE("%s: Unable to auto-focus", __func__); - - smdk4x12_camera->auto_focus_thread_enabled = 0; - } - - while (smdk4x12_camera->auto_focus_thread_enabled) { - pthread_mutex_lock(&smdk4x12_camera->auto_focus_mutex); - - rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT, &auto_focus_result); - if (rc < 0) { - ALOGE("%s: Unable to get auto-focus result", __func__); - auto_focus_result = CAMERA_AF_STATUS_FAIL; - } - - smdk4x12_camera->auto_focus_result = auto_focus_result; - - rc = smdk4x12_camera_auto_focus(smdk4x12_camera, auto_focus_result); - if (rc < 0) { - ALOGE("%s: Unable to auto-focus", __func__); - auto_focus_result = CAMERA_AF_STATUS_FAIL; - } - - if (auto_focus_result == CAMERA_AF_STATUS_IN_PROGRESS) - usleep(10000); - else - auto_focus_completed = 1; - - pthread_mutex_unlock(&smdk4x12_camera->auto_focus_mutex); - - if (auto_focus_completed) { - smdk4x12_camera->auto_focus_thread_running = 0; - smdk4x12_camera_auto_focus_thread_stop(smdk4x12_camera); - } - } - - smdk4x12_camera->auto_focus_thread_running = 0; - ALOGE("%s: Exiting thread", __func__); - - return NULL; -} - -int smdk4x12_camera_auto_focus_thread_start(struct smdk4x12_camera *smdk4x12_camera) -{ - pthread_attr_t thread_attr; - int auto_focus; - int rc; - - if (smdk4x12_camera == NULL) - return -EINVAL; - - ALOGD("%s()", __func__); - - if (smdk4x12_camera->auto_focus_thread_enabled) { - ALOGE("Auto-focus thread was already started!"); - return -1; - } - - pthread_mutex_init(&smdk4x12_camera->auto_focus_mutex, NULL); - - if (smdk4x12_camera->focus_mode != FOCUS_MODE_CONTINOUS_PICTURE) { - auto_focus = AUTO_FOCUS_ON | (smdk4x12_camera->preview_width & 0xfff) << 20 | (smdk4x12_camera->preview_height & 0xfff) << 8; - - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, auto_focus); - if (rc < 0) { - ALOGE("%s: Unable to set auto-focus on", __func__); - goto error; - } - } - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - - smdk4x12_camera->auto_focus_thread_enabled = 1; - - rc = pthread_create(&smdk4x12_camera->auto_focus_thread, &thread_attr, smdk4x12_camera_auto_focus_thread, (void *) smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to create thread", __func__); - goto error; - } - - rc = 0; - goto complete; - -error: - pthread_mutex_destroy(&smdk4x12_camera->auto_focus_mutex); - - rc = -1; - -complete: - return rc; -} - -void smdk4x12_camera_auto_focus_thread_stop(struct smdk4x12_camera *smdk4x12_camera) -{ - int rc; - int i; - - if (smdk4x12_camera == NULL) - return; - - ALOGD("%s()", __func__); - - if (!smdk4x12_camera->auto_focus_thread_enabled) { - ALOGE("Auto-focus thread was already stopped!"); - return; - } - - smdk4x12_camera->auto_focus_thread_enabled = 0; - - // Wait for the thread to end - i = 0; - while (smdk4x12_camera->auto_focus_thread_running) { - if (i++ > 10000) { - ALOGE("Auto-focus thread is taking too long to end, something is going wrong"); - break; - } - usleep(100); - } - if (smdk4x12_camera->focus_mode != FOCUS_MODE_CONTINOUS_PICTURE) { - rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF); - if (rc < 0) - ALOGE("%s: Unable to set auto-focus off", __func__); - } - - pthread_mutex_destroy(&smdk4x12_camera->auto_focus_mutex); -} - -/* - * SMDK4x12 Camera OPS - */ - -int smdk4x12_camera_set_preview_window(struct camera_device *device, - struct preview_stream_ops *w) -{ - struct smdk4x12_camera *smdk4x12_camera; - - int width, height, format, gralloc_format; - - buffer_handle_t *buffer; - int stride; - void *addr = NULL; - - int rc; - - ALOGD("%s(%p, %p)", __func__, device, w); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - if (smdk4x12_camera->preview_thread_enabled) - pthread_mutex_lock(&smdk4x12_camera->preview_mutex); - - if (w == NULL) { - smdk4x12_camera->preview_window = NULL; - return 0; - } - - if (w->set_buffer_count == NULL || w->set_usage == NULL || w->set_buffers_geometry == NULL) - goto error; - - rc = w->set_buffer_count(w, SMDK4x12_CAMERA_GRALLOC_BUFFERS_COUNT); - if (rc) { - ALOGE("%s: Unable to set buffer count: %d", __func__, SMDK4x12_CAMERA_GRALLOC_BUFFERS_COUNT); - goto error; - } - - rc = w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN); - if (rc) { - ALOGE("%s: Unable to set usage", __func__); - goto error; - } - - width = smdk4x12_camera->preview_width; - height = smdk4x12_camera->preview_height; - format = smdk4x12_camera->preview_format; - - gralloc_format = smdk4x12_gralloc_format(format); - - rc = w->set_buffers_geometry(w, width, height, gralloc_format); - if (rc) { - ALOGE("%s: Unable to set buffers geometry", __func__); - goto error; - } - - smdk4x12_camera->preview_window = w; - - rc = 0; - goto complete; - -error: - smdk4x12_camera->preview_window = NULL; - rc = -1; - -complete: - if (smdk4x12_camera->preview_thread_enabled) - pthread_mutex_unlock(&smdk4x12_camera->preview_mutex); - - return rc; -} - -void smdk4x12_camera_set_callbacks(struct camera_device *device, - camera_notify_callback notify_cb, - camera_data_callback data_cb, - camera_data_timestamp_callback data_cb_timestamp, - camera_request_memory get_memory, - void *user) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p, %p)", __func__, device, user); - - if (device == NULL || device->priv == NULL) - return; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->callbacks.notify = notify_cb; - smdk4x12_camera->callbacks.data = data_cb; - smdk4x12_camera->callbacks.data_timestamp = data_cb_timestamp; - smdk4x12_camera->callbacks.request_memory = get_memory; - smdk4x12_camera->callbacks.user = user; -} - -void smdk4x12_camera_enable_msg_type(struct camera_device *device, - int32_t msg_type) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p, %d)", __func__, device, msg_type); - - if (device == NULL || device->priv == NULL) - return; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->messages_enabled |= msg_type; -} - -void smdk4x12_camera_disable_msg_type(struct camera_device *device, - int32_t msg_type) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p, %d)", __func__, device, msg_type); - - if (device == NULL || device->priv == NULL) - return; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->messages_enabled &= ~msg_type; -} - -int smdk4x12_camera_msg_type_enabled(struct camera_device *device, - int32_t msg_type) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p, %d)", __func__, device, msg_type); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - return smdk4x12_camera->messages_enabled & msg_type; -} - -int smdk4x12_camera_start_preview(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - int rc; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->callback_lock = 1; - rc = smdk4x12_camera_preview_thread_start(smdk4x12_camera); - smdk4x12_camera->callback_lock = 0; - - return rc; -} - -void smdk4x12_camera_stop_preview(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->callback_lock = 1; - smdk4x12_camera_preview_thread_stop(smdk4x12_camera); - smdk4x12_camera->callback_lock = 0; -} - -int smdk4x12_camera_preview_enabled(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - return smdk4x12_camera->preview_thread_enabled; -} - -int smdk4x12_camera_store_meta_data_in_buffers(struct camera_device *device, - int enable) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p, %d)", __func__, device, enable); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - if (!smdk4x12_camera->recording_thread_enabled) - smdk4x12_camera->recording_metadata = enable; - else - ALOGE("%s: Recording is running!", __func__); - - return 0; -} - -int smdk4x12_camera_start_recording(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - int rc; - - ALOGD("%s(%p)", __func__, device); - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->callback_lock = 1; - rc = smdk4x12_camera_recording_thread_start(smdk4x12_camera); - smdk4x12_camera->callback_lock = 0; - - return rc; -} - -void smdk4x12_camera_stop_recording(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p)", __func__, device); - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->callback_lock = 1; - smdk4x12_camera_recording_thread_stop(smdk4x12_camera); - smdk4x12_camera->callback_lock = 0; -} - -int smdk4x12_camera_recording_enabled(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - return smdk4x12_camera->recording_thread_enabled; -} - -void smdk4x12_camera_release_recording_frame(struct camera_device *device, - const void *opaque) -{ - struct smdk4x12_camera *smdk4x12_camera; - -// ALOGD("%s(%p, %p)", __func__, device, opaque); - - if (device == NULL || device->priv == NULL) - return; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera_recording_frame_release(smdk4x12_camera); -} - -int smdk4x12_camera_start_auto_focus(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - return smdk4x12_camera_auto_focus_thread_start(smdk4x12_camera); -} - -int smdk4x12_camera_cancel_auto_focus(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera_auto_focus_thread_stop(smdk4x12_camera); - - return 0; -} - -int smdk4x12_camera_take_picture(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - int rc; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->callback_lock = 1; - rc = smdk4x12_camera_picture_thread_start(smdk4x12_camera); - smdk4x12_camera->callback_lock = 0; - - return rc; -} - -int smdk4x12_camera_cancel_picture(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - int rc; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera->callback_lock = 1; - smdk4x12_camera_picture_thread_stop(smdk4x12_camera); - smdk4x12_camera->callback_lock = 0; - - return 0; -} - -int smdk4x12_camera_set_parameters(struct camera_device *device, - const char *params) -{ - struct smdk4x12_camera *smdk4x12_camera; - int rc; - - ALOGD("%s(%p, %s)", __func__, device, params); - - if (device == NULL || device->priv == NULL || params == NULL) - return -EINVAL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - rc = smdk4x12_params_string_set(smdk4x12_camera, (char *) params); - if (rc < 0) { - ALOGE("%s: Unable to set params string", __func__); - return -1; - } - - rc = smdk4x12_camera_params_apply(smdk4x12_camera, 0); - if (rc < 0) { - ALOGE("%s: Unable to apply params", __func__); - return -1; - } - - return 0; -} - -char *smdk4x12_camera_get_parameters(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - char *params; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return NULL; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - params = smdk4x12_params_string_get(smdk4x12_camera); - if (params == NULL) { - ALOGE("%s: Couldn't find any param", __func__); - return strdup(""); - } - - return params; -} - -void smdk4x12_camera_put_parameters(struct camera_device *device, char *params) -{ - ALOGD("%s(%p)", __func__, device); - - if (params != NULL) - free(params); -} - -int smdk4x12_camera_send_command(struct camera_device *device, - int32_t cmd, int32_t arg1, int32_t arg2) -{ - ALOGD("%s(%p, %d, %d, %d)", __func__, device, cmd, arg1, arg2); - - return 0; -} - -void smdk4x12_camera_release(struct camera_device *device) -{ - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL || device->priv == NULL) - return; - - smdk4x12_camera = (struct smdk4x12_camera *) device->priv; - - smdk4x12_camera_capture_thread_stop(smdk4x12_camera); - - smdk4x12_camera_stop(smdk4x12_camera); -} - -int smdk4x12_camera_dump(struct camera_device *device, int fd) -{ - ALOGD("%s(%p, %d)", __func__, device, fd); - - return 0; -} - -/* - * Interface - */ - -struct camera_device_ops smdk4x12_camera_ops = { - .set_preview_window = smdk4x12_camera_set_preview_window, - .set_callbacks = smdk4x12_camera_set_callbacks, - .enable_msg_type = smdk4x12_camera_enable_msg_type, - .disable_msg_type = smdk4x12_camera_disable_msg_type, - .msg_type_enabled = smdk4x12_camera_msg_type_enabled, - .start_preview = smdk4x12_camera_start_preview, - .stop_preview = smdk4x12_camera_stop_preview, - .preview_enabled = smdk4x12_camera_preview_enabled, - .store_meta_data_in_buffers = smdk4x12_camera_store_meta_data_in_buffers, - .start_recording = smdk4x12_camera_start_recording, - .stop_recording = smdk4x12_camera_stop_recording, - .recording_enabled = smdk4x12_camera_recording_enabled, - .release_recording_frame = smdk4x12_camera_release_recording_frame, - .auto_focus = smdk4x12_camera_start_auto_focus, - .cancel_auto_focus = smdk4x12_camera_cancel_auto_focus, - .take_picture = smdk4x12_camera_take_picture, - .cancel_picture = smdk4x12_camera_cancel_picture, - .set_parameters = smdk4x12_camera_set_parameters, - .get_parameters = smdk4x12_camera_get_parameters, - .put_parameters = smdk4x12_camera_put_parameters, - .send_command = smdk4x12_camera_send_command, - .release = smdk4x12_camera_release, - .dump = smdk4x12_camera_dump, -}; - -int smdk4x12_camera_close(hw_device_t *device) -{ - struct camera_device *camera_device; - struct smdk4x12_camera *smdk4x12_camera; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL) - return -EINVAL; - - camera_device = (struct camera_device *) device; - - if (camera_device->priv != NULL) { - free(camera_device->priv); - } - - free(camera_device); - - return 0; -} - -int smdk4x12_camera_open(const struct hw_module_t* module, const char *camera_id, - struct hw_device_t** device) -{ - struct camera_device *camera_device = NULL; - struct smdk4x12_camera *smdk4x12_camera = NULL; - int id; - int rc; - - ALOGD("%s(%p, %s, %p)", __func__, module, camera_id, device); - - if (module == NULL || camera_id == NULL || device == NULL) - return -EINVAL; - - id = atoi(camera_id); - if (id < 0) - return -EINVAL; - - smdk4x12_camera = calloc(1, sizeof(struct smdk4x12_camera)); - smdk4x12_camera->config = smdk4x12_camera_config; - - if (smdk4x12_camera->config->v4l2_nodes_count > SMDK4x12_CAMERA_MAX_V4L2_NODES_COUNT) - goto error_preset; - - if (id >= smdk4x12_camera->config->presets_count) - goto error_preset; - - rc = smdk4x12_camera_start(smdk4x12_camera, id); - if (rc < 0) { - ALOGE("%s: Unable to start camera", __func__); - goto error; - } - - rc = smdk4x12_camera_capture_thread_start(smdk4x12_camera); - if (rc < 0) { - ALOGE("%s: Unable to start capture thread", __func__); - goto error; - } - - camera_device = calloc(1, sizeof(struct camera_device)); - camera_device->common.tag = HARDWARE_DEVICE_TAG; - camera_device->common.version = 0; - camera_device->common.module = (struct hw_module_t *) module; - camera_device->common.close = smdk4x12_camera_close; - - camera_device->ops = &smdk4x12_camera_ops; - camera_device->priv = smdk4x12_camera; - - *device = (struct hw_device_t *) &(camera_device->common); - - return 0; - -error: - smdk4x12_camera_stop(smdk4x12_camera); - -error_device: - if (camera_device != NULL) - free(camera_device); - -error_preset: - if (smdk4x12_camera != NULL) - free(smdk4x12_camera); - - return -1; -} - -int smdk4x12_camera_get_number_of_cameras(void) -{ - ALOGD("%s()", __func__); - - if (smdk4x12_camera_config == NULL || smdk4x12_camera_config->presets == NULL) { - ALOGE("%s: Unable to find proper camera config", __func__); - return -1; - } - - return smdk4x12_camera_config->presets_count; -} - -int smdk4x12_camera_get_camera_info(int id, struct camera_info *info) -{ - ALOGD("%s(%d, %p)", __func__, id, info); - - if (id < 0 || info == NULL) - return -EINVAL; - - if (smdk4x12_camera_config == NULL || smdk4x12_camera_config->presets == NULL) { - ALOGE("%s: Unable to find proper camera config", __func__); - return -1; - } - - if (id >= smdk4x12_camera_config->presets_count) - return -EINVAL; - - ALOGD("Selected camera: %s", smdk4x12_camera_config->presets[id].name); - - info->facing = smdk4x12_camera_config->presets[id].facing; - info->orientation = smdk4x12_camera_config->presets[id].orientation; - - return 0; -} - -struct hw_module_methods_t smdk4x12_camera_module_methods = { - .open = smdk4x12_camera_open, -}; - -struct camera_module HAL_MODULE_INFO_SYM = { - .common = { - .tag = HARDWARE_MODULE_TAG, - .version_major = 1, - .version_minor = 0, - .id = CAMERA_HARDWARE_MODULE_ID, - .name = "SMDK4x12 Camera", - .author = "Paul Kocialkowski", - .methods = &smdk4x12_camera_module_methods, - }, - .get_number_of_cameras = smdk4x12_camera_get_number_of_cameras, - .get_camera_info = smdk4x12_camera_get_camera_info, -}; |