diff options
-rw-r--r-- | camera/Android.mk | 10 | ||||
-rw-r--r-- | camera/smdk4210_camera.c (renamed from camera/exynos_camera.c) | 1346 | ||||
-rw-r--r-- | camera/smdk4210_camera.h | 433 | ||||
-rw-r--r-- | camera/smdk4210_exif.c (renamed from camera/exynos_exif.c) | 176 | ||||
-rw-r--r-- | camera/smdk4210_param.c (renamed from camera/exynos_param.c) | 182 | ||||
-rw-r--r-- | camera/smdk4210_v4l2.c | 796 |
6 files changed, 2086 insertions, 857 deletions
diff --git a/camera/Android.mk b/camera/Android.mk index 671edae..95c9701 100644 --- a/camera/Android.mk +++ b/camera/Android.mk @@ -18,10 +18,10 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES := \ - exynos_camera.c \ - exynos_exif.c \ - exynos_param.c \ - exynos_v4l2.c + smdk4210_camera.c \ + smdk4210_exif.c \ + smdk4210_param.c \ + smdk4210_v4l2.c LOCAL_C_INCLUDES := \ hardware/samsung/exynos4/hal/include @@ -29,7 +29,7 @@ LOCAL_C_INCLUDES := \ LOCAL_SHARED_LIBRARIES := libutils libcutils liblog libcamera_client libhardware libs5pjpeg LOCAL_PRELINK_MODULE := false -LOCAL_MODULE := camera.$(TARGET_BOOTLOADER_BOARD_NAME) +LOCAL_MODULE := camera.smdk4210 LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw LOCAL_MODULE_TAGS := optional diff --git a/camera/exynos_camera.c b/camera/smdk4210_camera.c index 98ff74c..55b01a1 100644 --- a/camera/exynos_camera.c +++ b/camera/smdk4210_camera.c @@ -34,17 +34,17 @@ #include <asm/types.h> #include <jpeg_api.h> -#define LOG_TAG "exynos_camera" +#define LOG_TAG "smdk4210_camera" #include <utils/Log.h> #include <utils/Timers.h> -#include "exynos_camera.h" +#include "smdk4210_camera.h" /* * Devices configurations */ -struct exynos_camera_preset exynos_camera_presets_galaxys2[] = { +struct smdk4210_camera_preset smdk4210_camera_presets_galaxys2[] = { { .name = "M5MO", .facing = CAMERA_FACING_BACK, @@ -61,7 +61,7 @@ struct exynos_camera_preset exynos_camera_presets_galaxys2[] = { .preview_size_values = "1280x720,640x480,720x480,800x480,800x450,352x288,320x240,176x144", .preview_size = "640x480", .preview_format_values = "yuv420sp,yuv420p,rgb565", - .preview_format = "rgb565", + .preview_format = "yuv420sp", .preview_frame_rate_values = "30,25,20,15,10,7", .preview_frame_rate = 30, .preview_fps_range_values = "(7000,30000)", @@ -130,7 +130,7 @@ struct exynos_camera_preset exynos_camera_presets_galaxys2[] = { .preview_size_values = "640x480,352x288,320x240,176x144", .preview_size = "640x480", .preview_format_values = "yuv420sp,yuv420p,rgb565", - .preview_format = "rgb565", + .preview_format = "yuv420sp", .preview_frame_rate_values = "30,25,20,15,10,7", .preview_frame_rate = 30, .preview_fps_range_values = "(7000,30000)", @@ -181,7 +181,7 @@ struct exynos_camera_preset exynos_camera_presets_galaxys2[] = { }, }; -struct exynos_v4l2_node exynos_v4l2_nodes_galaxys2[] = { +struct smdk4210_v4l2_node smdk4210_v4l2_nodes_galaxys2[] = { { .id = 0, .node = "/dev/video0", @@ -196,74 +196,74 @@ struct exynos_v4l2_node exynos_v4l2_nodes_galaxys2[] = { }, }; -struct exynox_camera_config exynos_camera_config_galaxys2 = { - .presets = (struct exynos_camera_preset *) &exynos_camera_presets_galaxys2, +struct exynox_camera_config smdk4210_camera_config_galaxys2 = { + .presets = (struct smdk4210_camera_preset *) &smdk4210_camera_presets_galaxys2, .presets_count = 2, - .v4l2_nodes = (struct exynos_v4l2_node *) &exynos_v4l2_nodes_galaxys2, + .v4l2_nodes = (struct smdk4210_v4l2_node *) &smdk4210_v4l2_nodes_galaxys2, .v4l2_nodes_count = 3, }; /* - * Exynos Camera + * SMDK4210 Camera */ -struct exynox_camera_config *exynos_camera_config = - &exynos_camera_config_galaxys2; +struct exynox_camera_config *smdk4210_camera_config = + &smdk4210_camera_config_galaxys2; -int exynos_camera_init(struct exynos_camera *exynos_camera, int id) +int smdk4210_camera_init(struct smdk4210_camera *smdk4210_camera, int id) { char firmware_version[7] = { 0 }; - struct exynos_v4l2_ext_control control; + struct smdk4210_v4l2_ext_control control; int rc; - if (exynos_camera == NULL || id >= exynos_camera->config->presets_count) + if (smdk4210_camera == NULL || id >= smdk4210_camera->config->presets_count) return -EINVAL; // Init FIMC1 - rc = exynos_v4l2_open(exynos_camera, 0); + rc = smdk4210_v4l2_open(smdk4210_camera, 0); if (rc < 0) { ALOGE("Unable to open v4l2 device"); return -1; } - rc = exynos_v4l2_querycap_cap(exynos_camera, 0); + rc = smdk4210_v4l2_querycap_cap(smdk4210_camera, 0); if (rc < 0) { ALOGE("%s: querycap failed", __func__); return -1; } - rc = exynos_v4l2_enum_input(exynos_camera, 0, id); + rc = smdk4210_v4l2_enum_input(smdk4210_camera, 0, id); if (rc < 0) { ALOGE("%s: enum input failed", __func__); return -1; } - rc = exynos_v4l2_s_input(exynos_camera, 0, id); + rc = smdk4210_v4l2_s_input(smdk4210_camera, 0, id); if (rc < 0) { ALOGE("%s: s input failed", __func__); return -1; } // Init FIMC2 - rc = exynos_v4l2_open(exynos_camera, 2); + rc = smdk4210_v4l2_open(smdk4210_camera, 2); if (rc < 0) { ALOGE("Unable to open v4l2 device"); return -1; } - rc = exynos_v4l2_querycap_cap(exynos_camera, 2); + rc = smdk4210_v4l2_querycap_cap(smdk4210_camera, 2); if (rc < 0) { ALOGE("%s: querycap failed", __func__); return -1; } - rc = exynos_v4l2_enum_input(exynos_camera, 2, id); + rc = smdk4210_v4l2_enum_input(smdk4210_camera, 2, id); if (rc < 0) { ALOGE("%s: enum input failed", __func__); return -1; } - rc = exynos_v4l2_s_input(exynos_camera, 2, id); + rc = smdk4210_v4l2_s_input(smdk4210_camera, 2, id); if (rc < 0) { ALOGE("%s: s input failed", __func__); return -1; @@ -274,7 +274,7 @@ int exynos_camera_init(struct exynos_camera *exynos_camera, int id) control.id = V4L2_CID_CAM_SENSOR_FW_VER; control.data.string = firmware_version; - rc = exynos_v4l2_g_ext_ctrls(exynos_camera, 0, (struct v4l2_ext_control *) &control, 1); + rc = smdk4210_v4l2_g_ext_ctrls(smdk4210_camera, 0, (struct v4l2_ext_control *) &control, 1); if (rc < 0) { ALOGE("%s: g ext ctrls failed", __func__); } else { @@ -282,177 +282,177 @@ int exynos_camera_init(struct exynos_camera *exynos_camera, int id) } // Params - rc = exynos_camera_params_init(exynos_camera, id); + rc = smdk4210_camera_params_init(smdk4210_camera, id); if (rc < 0) ALOGE("%s: Unable to init params", __func__); // Gralloc - rc = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const struct hw_module_t **) &exynos_camera->gralloc); + rc = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const struct hw_module_t **) &smdk4210_camera->gralloc); if (rc) ALOGE("%s: Unable to get gralloc module", __func__); return 0; } -void exynos_camera_deinit(struct exynos_camera *exynos_camera) +void smdk4210_camera_deinit(struct smdk4210_camera *smdk4210_camera) { int i; int id; - if (exynos_camera == NULL || exynos_camera->config == NULL) + if (smdk4210_camera == NULL || smdk4210_camera->config == NULL) return; - exynos_v4l2_close(exynos_camera, 0); - exynos_v4l2_close(exynos_camera, 2); + smdk4210_v4l2_close(smdk4210_camera, 0); + smdk4210_v4l2_close(smdk4210_camera, 2); } // Params -int exynos_camera_params_init(struct exynos_camera *exynos_camera, int id) +int smdk4210_camera_params_init(struct smdk4210_camera *smdk4210_camera, int id) { int rc; - if (exynos_camera == NULL || id >= exynos_camera->config->presets_count) + if (smdk4210_camera == NULL || id >= smdk4210_camera->config->presets_count) return -EINVAL; // Camera params - exynos_camera->camera_rotation = exynos_camera->config->presets[id].rotation; - exynos_camera->camera_hflip = exynos_camera->config->presets[id].hflip; - exynos_camera->camera_vflip = exynos_camera->config->presets[id].vflip; - exynos_camera->camera_picture_format = exynos_camera->config->presets[id].picture_format; - exynos_camera->camera_focal_length = (int) (exynos_camera->config->presets[id].focal_length * 100); - exynos_camera->camera_metering = exynos_camera->config->presets[id].metering; + smdk4210_camera->camera_rotation = smdk4210_camera->config->presets[id].rotation; + smdk4210_camera->camera_hflip = smdk4210_camera->config->presets[id].hflip; + smdk4210_camera->camera_vflip = smdk4210_camera->config->presets[id].vflip; + smdk4210_camera->camera_picture_format = smdk4210_camera->config->presets[id].picture_format; + smdk4210_camera->camera_focal_length = (int) (smdk4210_camera->config->presets[id].focal_length * 100); + smdk4210_camera->camera_metering = smdk4210_camera->config->presets[id].metering; // Recording preview - exynos_param_string_set(exynos_camera, "preferred-preview-size-for-video", - exynos_camera->config->presets[id].params.preview_size); + smdk4210_param_string_set(smdk4210_camera, "preferred-preview-size-for-video", + smdk4210_camera->config->presets[id].params.preview_size); // Preview - exynos_param_string_set(exynos_camera, "preview-size-values", - exynos_camera->config->presets[id].params.preview_size_values); - exynos_param_string_set(exynos_camera, "preview-size", - exynos_camera->config->presets[id].params.preview_size); - exynos_param_string_set(exynos_camera, "preview-format-values", - exynos_camera->config->presets[id].params.preview_format_values); - exynos_param_string_set(exynos_camera, "preview-format", - exynos_camera->config->presets[id].params.preview_format); - exynos_param_string_set(exynos_camera, "preview-frame-rate-values", - exynos_camera->config->presets[id].params.preview_frame_rate_values); - exynos_param_int_set(exynos_camera, "preview-frame-rate", - exynos_camera->config->presets[id].params.preview_frame_rate); - exynos_param_string_set(exynos_camera, "preview-fps-range-values", - exynos_camera->config->presets[id].params.preview_fps_range_values); - exynos_param_string_set(exynos_camera, "preview-fps-range", - exynos_camera->config->presets[id].params.preview_fps_range); + smdk4210_param_string_set(smdk4210_camera, "preview-size-values", + smdk4210_camera->config->presets[id].params.preview_size_values); + smdk4210_param_string_set(smdk4210_camera, "preview-size", + smdk4210_camera->config->presets[id].params.preview_size); + smdk4210_param_string_set(smdk4210_camera, "preview-format-values", + smdk4210_camera->config->presets[id].params.preview_format_values); + smdk4210_param_string_set(smdk4210_camera, "preview-format", + smdk4210_camera->config->presets[id].params.preview_format); + smdk4210_param_string_set(smdk4210_camera, "preview-frame-rate-values", + smdk4210_camera->config->presets[id].params.preview_frame_rate_values); + smdk4210_param_int_set(smdk4210_camera, "preview-frame-rate", + smdk4210_camera->config->presets[id].params.preview_frame_rate); + smdk4210_param_string_set(smdk4210_camera, "preview-fps-range-values", + smdk4210_camera->config->presets[id].params.preview_fps_range_values); + smdk4210_param_string_set(smdk4210_camera, "preview-fps-range", + smdk4210_camera->config->presets[id].params.preview_fps_range); // Picture - exynos_param_string_set(exynos_camera, "picture-size-values", - exynos_camera->config->presets[id].params.picture_size_values); - exynos_param_string_set(exynos_camera, "picture-size", - exynos_camera->config->presets[id].params.picture_size); - exynos_param_string_set(exynos_camera, "picture-format-values", - exynos_camera->config->presets[id].params.picture_format_values); - exynos_param_string_set(exynos_camera, "picture-format", - exynos_camera->config->presets[id].params.picture_format); - exynos_param_string_set(exynos_camera, "jpeg-thumbnail-size-values", - exynos_camera->config->presets[id].params.jpeg_thumbnail_size_values); - exynos_param_int_set(exynos_camera, "jpeg-thumbnail-width", - exynos_camera->config->presets[id].params.jpeg_thumbnail_width); - exynos_param_int_set(exynos_camera, "jpeg-thumbnail-height", - exynos_camera->config->presets[id].params.jpeg_thumbnail_height); - exynos_param_int_set(exynos_camera, "jpeg-thumbnail-quality", - exynos_camera->config->presets[id].params.jpeg_thumbnail_quality); - exynos_param_int_set(exynos_camera, "jpeg-quality", - exynos_camera->config->presets[id].params.jpeg_quality); + smdk4210_param_string_set(smdk4210_camera, "picture-size-values", + smdk4210_camera->config->presets[id].params.picture_size_values); + smdk4210_param_string_set(smdk4210_camera, "picture-size", + smdk4210_camera->config->presets[id].params.picture_size); + smdk4210_param_string_set(smdk4210_camera, "picture-format-values", + smdk4210_camera->config->presets[id].params.picture_format_values); + smdk4210_param_string_set(smdk4210_camera, "picture-format", + smdk4210_camera->config->presets[id].params.picture_format); + smdk4210_param_string_set(smdk4210_camera, "jpeg-thumbnail-size-values", + smdk4210_camera->config->presets[id].params.jpeg_thumbnail_size_values); + smdk4210_param_int_set(smdk4210_camera, "jpeg-thumbnail-width", + smdk4210_camera->config->presets[id].params.jpeg_thumbnail_width); + smdk4210_param_int_set(smdk4210_camera, "jpeg-thumbnail-height", + smdk4210_camera->config->presets[id].params.jpeg_thumbnail_height); + smdk4210_param_int_set(smdk4210_camera, "jpeg-thumbnail-quality", + smdk4210_camera->config->presets[id].params.jpeg_thumbnail_quality); + smdk4210_param_int_set(smdk4210_camera, "jpeg-quality", + smdk4210_camera->config->presets[id].params.jpeg_quality); // Recording - exynos_param_string_set(exynos_camera, "video-size", - exynos_camera->config->presets[id].params.recording_size); - exynos_param_string_set(exynos_camera, "video-size-values", - exynos_camera->config->presets[id].params.recording_size_values); - exynos_param_string_set(exynos_camera, "video-frame-format", - exynos_camera->config->presets[id].params.recording_format); + smdk4210_param_string_set(smdk4210_camera, "video-size", + smdk4210_camera->config->presets[id].params.recording_size); + smdk4210_param_string_set(smdk4210_camera, "video-size-values", + smdk4210_camera->config->presets[id].params.recording_size_values); + smdk4210_param_string_set(smdk4210_camera, "video-frame-format", + smdk4210_camera->config->presets[id].params.recording_format); // Focus - exynos_param_string_set(exynos_camera, "focus-mode", - exynos_camera->config->presets[id].params.focus_mode); - exynos_param_string_set(exynos_camera, "focus-mode-values", - exynos_camera->config->presets[id].params.focus_mode_values); - exynos_param_string_set(exynos_camera, "focus-distances", - exynos_camera->config->presets[id].params.focus_distances); - if (exynos_camera->config->presets[id].params.max_num_focus_areas > 0) { - exynos_param_string_set(exynos_camera, "focus-areas", - exynos_camera->config->presets[id].params.focus_areas); - exynos_param_int_set(exynos_camera, "max-num-focus-areas", - exynos_camera->config->presets[id].params.max_num_focus_areas); + smdk4210_param_string_set(smdk4210_camera, "focus-mode", + smdk4210_camera->config->presets[id].params.focus_mode); + smdk4210_param_string_set(smdk4210_camera, "focus-mode-values", + smdk4210_camera->config->presets[id].params.focus_mode_values); + smdk4210_param_string_set(smdk4210_camera, "focus-distances", + smdk4210_camera->config->presets[id].params.focus_distances); + if (smdk4210_camera->config->presets[id].params.max_num_focus_areas > 0) { + smdk4210_param_string_set(smdk4210_camera, "focus-areas", + smdk4210_camera->config->presets[id].params.focus_areas); + smdk4210_param_int_set(smdk4210_camera, "max-num-focus-areas", + smdk4210_camera->config->presets[id].params.max_num_focus_areas); } // Zoom - if (exynos_camera->config->presets[id].params.zoom_supported == 1) { - exynos_param_string_set(exynos_camera, "zoom-supported", "true"); + if (smdk4210_camera->config->presets[id].params.zoom_supported == 1) { + smdk4210_param_string_set(smdk4210_camera, "zoom-supported", "true"); - if (exynos_camera->config->presets[id].params.smooth_zoom_supported == 1) - exynos_param_string_set(exynos_camera, "smooth-zoom-supported", "true"); + if (smdk4210_camera->config->presets[id].params.smooth_zoom_supported == 1) + smdk4210_param_string_set(smdk4210_camera, "smooth-zoom-supported", "true"); - if (exynos_camera->config->presets[id].params.zoom_ratios != NULL) - exynos_param_string_set(exynos_camera, "zoom-ratios", exynos_camera->config->presets[id].params.zoom_ratios); + if (smdk4210_camera->config->presets[id].params.zoom_ratios != NULL) + smdk4210_param_string_set(smdk4210_camera, "zoom-ratios", smdk4210_camera->config->presets[id].params.zoom_ratios); - exynos_param_int_set(exynos_camera, "zoom", exynos_camera->config->presets[id].params.zoom); - exynos_param_int_set(exynos_camera, "max-zoom", exynos_camera->config->presets[id].params.max_zoom); + smdk4210_param_int_set(smdk4210_camera, "zoom", smdk4210_camera->config->presets[id].params.zoom); + smdk4210_param_int_set(smdk4210_camera, "max-zoom", smdk4210_camera->config->presets[id].params.max_zoom); } else { - exynos_param_string_set(exynos_camera, "zoom-supported", "false"); + smdk4210_param_string_set(smdk4210_camera, "zoom-supported", "false"); } // Flash - exynos_param_string_set(exynos_camera, "flash-mode", - exynos_camera->config->presets[id].params.flash_mode); - exynos_param_string_set(exynos_camera, "flash-mode-values", - exynos_camera->config->presets[id].params.flash_mode_values); + smdk4210_param_string_set(smdk4210_camera, "flash-mode", + smdk4210_camera->config->presets[id].params.flash_mode); + smdk4210_param_string_set(smdk4210_camera, "flash-mode-values", + smdk4210_camera->config->presets[id].params.flash_mode_values); // Exposure - exynos_param_int_set(exynos_camera, "exposure-compensation", - exynos_camera->config->presets[id].params.exposure_compensation); - exynos_param_float_set(exynos_camera, "exposure-compensation-step", - exynos_camera->config->presets[id].params.exposure_compensation_step); - exynos_param_int_set(exynos_camera, "min-exposure-compensation", - exynos_camera->config->presets[id].params.min_exposure_compensation); - exynos_param_int_set(exynos_camera, "max-exposure-compensation", - exynos_camera->config->presets[id].params.max_exposure_compensation); + smdk4210_param_int_set(smdk4210_camera, "exposure-compensation", + smdk4210_camera->config->presets[id].params.exposure_compensation); + smdk4210_param_float_set(smdk4210_camera, "exposure-compensation-step", + smdk4210_camera->config->presets[id].params.exposure_compensation_step); + smdk4210_param_int_set(smdk4210_camera, "min-exposure-compensation", + smdk4210_camera->config->presets[id].params.min_exposure_compensation); + smdk4210_param_int_set(smdk4210_camera, "max-exposure-compensation", + smdk4210_camera->config->presets[id].params.max_exposure_compensation); // WB - exynos_param_string_set(exynos_camera, "whitebalance", - exynos_camera->config->presets[id].params.whitebalance); - exynos_param_string_set(exynos_camera, "whitebalance-values", - exynos_camera->config->presets[id].params.whitebalance_values); + smdk4210_param_string_set(smdk4210_camera, "whitebalance", + smdk4210_camera->config->presets[id].params.whitebalance); + smdk4210_param_string_set(smdk4210_camera, "whitebalance-values", + smdk4210_camera->config->presets[id].params.whitebalance_values); // Scene mode - exynos_param_string_set(exynos_camera, "scene-mode", - exynos_camera->config->presets[id].params.scene_mode); - exynos_param_string_set(exynos_camera, "scene-mode-values", - exynos_camera->config->presets[id].params.scene_mode_values); + smdk4210_param_string_set(smdk4210_camera, "scene-mode", + smdk4210_camera->config->presets[id].params.scene_mode); + smdk4210_param_string_set(smdk4210_camera, "scene-mode-values", + smdk4210_camera->config->presets[id].params.scene_mode_values); // Effect - exynos_param_string_set(exynos_camera, "effect", - exynos_camera->config->presets[id].params.effect); - exynos_param_string_set(exynos_camera, "effect-values", - exynos_camera->config->presets[id].params.effect_values); + smdk4210_param_string_set(smdk4210_camera, "effect", + smdk4210_camera->config->presets[id].params.effect); + smdk4210_param_string_set(smdk4210_camera, "effect-values", + smdk4210_camera->config->presets[id].params.effect_values); // ISO - exynos_param_string_set(exynos_camera, "iso", - exynos_camera->config->presets[id].params.iso); - exynos_param_string_set(exynos_camera, "iso-values", - exynos_camera->config->presets[id].params.iso_values); + smdk4210_param_string_set(smdk4210_camera, "iso", + smdk4210_camera->config->presets[id].params.iso); + smdk4210_param_string_set(smdk4210_camera, "iso-values", + smdk4210_camera->config->presets[id].params.iso_values); // Camera - exynos_param_float_set(exynos_camera, "focal-length", - exynos_camera->config->presets[id].focal_length); - exynos_param_float_set(exynos_camera, "horizontal-view-angle", - exynos_camera->config->presets[id].horizontal_view_angle); - exynos_param_float_set(exynos_camera, "vertical-view-angle", - exynos_camera->config->presets[id].vertical_view_angle); - - rc = exynos_camera_params_apply(exynos_camera); + smdk4210_param_float_set(smdk4210_camera, "focal-length", + smdk4210_camera->config->presets[id].focal_length); + smdk4210_param_float_set(smdk4210_camera, "horizontal-view-angle", + smdk4210_camera->config->presets[id].horizontal_view_angle); + smdk4210_param_float_set(smdk4210_camera, "vertical-view-angle", + smdk4210_camera->config->presets[id].vertical_view_angle); + + rc = smdk4210_camera_params_apply(smdk4210_camera); if (rc < 0) { ALOGE("%s: Unable to apply params", __func__); return -1; @@ -461,7 +461,7 @@ int exynos_camera_params_init(struct exynos_camera *exynos_camera, int id) return 0; } -int exynos_camera_params_apply(struct exynos_camera *exynos_camera) +int smdk4210_camera_params_apply(struct smdk4210_camera *smdk4210_camera) { char *recording_hint_string; char *recording_preview_size_string; @@ -528,27 +528,27 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) char *k; int rc; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return -EINVAL; - if (!exynos_camera->preview_params_set) { + if (!smdk4210_camera->preview_params_set) { ALOGE("%s: Setting preview params", __func__); - exynos_camera->preview_params_set = 1; + smdk4210_camera->preview_params_set = 1; force = 1; } // Preview - preview_size_string = exynos_param_string_get(exynos_camera, "preview-size"); + preview_size_string = smdk4210_param_string_get(smdk4210_camera, "preview-size"); if (preview_size_string != NULL) { sscanf(preview_size_string, "%dx%d", &preview_width, &preview_height); - if (preview_width != 0 && preview_width != exynos_camera->preview_width) - exynos_camera->preview_width = preview_width; - if (preview_height != 0 && preview_height != exynos_camera->preview_height) - exynos_camera->preview_height = preview_height; + if (preview_width != 0 && preview_width != smdk4210_camera->preview_width) + smdk4210_camera->preview_width = preview_width; + if (preview_height != 0 && preview_height != smdk4210_camera->preview_height) + smdk4210_camera->preview_height = preview_height; } - preview_format_string = exynos_param_string_get(exynos_camera, "preview-format"); + preview_format_string = smdk4210_param_string_get(smdk4210_camera, "preview-format"); if (preview_format_string != NULL) { if (strcmp(preview_format_string, "yuv420sp") == 0) { preview_format = V4L2_PIX_FMT_NV21; @@ -568,30 +568,30 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) preview_format_bpp = 1.5f; } - if (preview_format != exynos_camera->preview_format) { - exynos_camera->preview_format = preview_format; - exynos_camera->preview_format_bpp = preview_format_bpp; + if (preview_format != smdk4210_camera->preview_format) { + smdk4210_camera->preview_format = preview_format; + smdk4210_camera->preview_format_bpp = preview_format_bpp; } } - preview_fps = exynos_param_int_get(exynos_camera, "preview-frame-rate"); + preview_fps = smdk4210_param_int_get(smdk4210_camera, "preview-frame-rate"); if (preview_fps > 0) - exynos_camera->preview_fps = preview_fps; + smdk4210_camera->preview_fps = preview_fps; else - exynos_camera->preview_fps = 0; + smdk4210_camera->preview_fps = 0; // Picture - picture_size_string = exynos_param_string_get(exynos_camera, "picture-size"); + picture_size_string = smdk4210_param_string_get(smdk4210_camera, "picture-size"); if (picture_size_string != NULL) { sscanf(picture_size_string, "%dx%d", &picture_width, &picture_height); - if (picture_width != 0 && picture_width != exynos_camera->picture_width) - exynos_camera->picture_width = picture_width; - if (picture_height != 0 && picture_height != exynos_camera->picture_height) - exynos_camera->picture_height = picture_height; + if (picture_width != 0 && picture_width != smdk4210_camera->picture_width) + smdk4210_camera->picture_width = picture_width; + if (picture_height != 0 && picture_height != smdk4210_camera->picture_height) + smdk4210_camera->picture_height = picture_height; } - picture_format_string = exynos_param_string_get(exynos_camera, "picture-format"); + picture_format_string = smdk4210_param_string_get(smdk4210_camera, "picture-format"); if (picture_format_string != NULL) { if (strcmp(picture_format_string, "jpeg") == 0) { picture_format = V4L2_PIX_FMT_JPEG; @@ -600,45 +600,45 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) picture_format = V4L2_PIX_FMT_JPEG; } - if (picture_format != exynos_camera->picture_format) - exynos_camera->picture_format = picture_format; + if (picture_format != smdk4210_camera->picture_format) + smdk4210_camera->picture_format = picture_format; } - jpeg_thumbnail_width = exynos_param_int_get(exynos_camera, "jpeg-thumbnail-width"); + jpeg_thumbnail_width = smdk4210_param_int_get(smdk4210_camera, "jpeg-thumbnail-width"); if (jpeg_thumbnail_width > 0) - exynos_camera->jpeg_thumbnail_width = jpeg_thumbnail_width; + smdk4210_camera->jpeg_thumbnail_width = jpeg_thumbnail_width; - jpeg_thumbnail_height = exynos_param_int_get(exynos_camera, "jpeg-thumbnail-height"); + jpeg_thumbnail_height = smdk4210_param_int_get(smdk4210_camera, "jpeg-thumbnail-height"); if (jpeg_thumbnail_height > 0) - exynos_camera->jpeg_thumbnail_height = jpeg_thumbnail_height; + smdk4210_camera->jpeg_thumbnail_height = jpeg_thumbnail_height; - jpeg_thumbnail_quality = exynos_param_int_get(exynos_camera, "jpeg-thumbnail-quality"); + jpeg_thumbnail_quality = smdk4210_param_int_get(smdk4210_camera, "jpeg-thumbnail-quality"); if (jpeg_thumbnail_quality > 0) - exynos_camera->jpeg_thumbnail_quality = jpeg_thumbnail_quality; + smdk4210_camera->jpeg_thumbnail_quality = jpeg_thumbnail_quality; - jpeg_quality = exynos_param_int_get(exynos_camera, "jpeg-quality"); - if (jpeg_quality <= 100 && jpeg_quality >= 0 && (jpeg_quality != exynos_camera->jpeg_quality || force)) { - exynos_camera->jpeg_quality = jpeg_quality; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality); + jpeg_quality = smdk4210_param_int_get(smdk4210_camera, "jpeg-quality"); + if (jpeg_quality <= 100 && jpeg_quality >= 0 && (jpeg_quality != smdk4210_camera->jpeg_quality || force)) { + smdk4210_camera->jpeg_quality = jpeg_quality; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } // Recording - video_size_string = exynos_param_string_get(exynos_camera, "video-size"); + video_size_string = smdk4210_param_string_get(smdk4210_camera, "video-size"); if (video_size_string == NULL) - video_size_string = exynos_param_string_get(exynos_camera, "preview-size"); + video_size_string = smdk4210_param_string_get(smdk4210_camera, "preview-size"); if (video_size_string != NULL) { sscanf(video_size_string, "%dx%d", &recording_width, &recording_height); - if (recording_width != 0 && recording_width != exynos_camera->recording_width) - exynos_camera->recording_width = recording_width; - if (recording_height != 0 && recording_height != exynos_camera->recording_height) - exynos_camera->recording_height = recording_height; + if (recording_width != 0 && recording_width != smdk4210_camera->recording_width) + smdk4210_camera->recording_width = recording_width; + if (recording_height != 0 && recording_height != smdk4210_camera->recording_height) + smdk4210_camera->recording_height = recording_height; } - video_frame_format_string = exynos_param_string_get(exynos_camera, "video-frame-format"); + video_frame_format_string = smdk4210_param_string_get(smdk4210_camera, "video-frame-format"); if (video_frame_format_string != NULL) { if (strcmp(video_frame_format_string, "yuv420sp") == 0) { recording_format = V4L2_PIX_FMT_NV12; @@ -653,15 +653,15 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) recording_format = V4L2_PIX_FMT_NV12; } - if (recording_format != exynos_camera->recording_format) - exynos_camera->recording_format = recording_format; + if (recording_format != smdk4210_camera->recording_format) + smdk4210_camera->recording_format = recording_format; } - recording_hint_string = exynos_param_string_get(exynos_camera, "recording-hint"); + recording_hint_string = smdk4210_param_string_get(smdk4210_camera, "recording-hint"); if (recording_hint_string != NULL && strcmp(recording_hint_string, "true") == 0) { camera_sensor_mode = SENSOR_MOVIE; - k = exynos_param_string_get(exynos_camera, "preview-size-values"); + k = smdk4210_param_string_get(smdk4210_camera, "preview-size-values"); while (recording_width != 0 && recording_height != 0) { if (k == NULL) break; @@ -682,13 +682,13 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) k++; } - if (preview_width != 0 && preview_width != exynos_camera->preview_width) - exynos_camera->preview_width = preview_width; - if (preview_height != 0 && preview_height != exynos_camera->preview_height) - exynos_camera->preview_height = preview_height; + if (preview_width != 0 && preview_width != smdk4210_camera->preview_width) + smdk4210_camera->preview_width = preview_width; + if (preview_height != 0 && preview_height != smdk4210_camera->preview_height) + smdk4210_camera->preview_height = preview_height; camera_sensor_output_size = ((recording_width & 0xffff) << 16) | (recording_height & 0xffff); - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SENSOR_OUTPUT_SIZE, + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_SENSOR_OUTPUT_SIZE, camera_sensor_output_size); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); @@ -697,15 +697,15 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) } // Switching modes - if (camera_sensor_mode != exynos_camera->camera_sensor_mode) { - exynos_camera->camera_sensor_mode = camera_sensor_mode; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SENSOR_MODE, camera_sensor_mode); + if (camera_sensor_mode != smdk4210_camera->camera_sensor_mode) { + smdk4210_camera->camera_sensor_mode = camera_sensor_mode; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_SENSOR_MODE, camera_sensor_mode); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } // Focus - focus_areas_string = exynos_param_string_get(exynos_camera, "focus-areas"); + focus_areas_string = smdk4210_param_string_get(smdk4210_camera, "focus-areas"); if (focus_areas_string != NULL) { focus_left = focus_top = focus_right = focus_bottom = focus_weigth = 0; @@ -717,18 +717,18 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) 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 != exynos_camera->focus_x || force) { - exynos_camera->focus_x = focus_x; + if (focus_x != smdk4210_camera->focus_x || force) { + smdk4210_camera->focus_x = focus_x; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_X, focus_x); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_X, focus_x); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } - if (focus_y != exynos_camera->focus_y || force) { - exynos_camera->focus_y = focus_y; + if (focus_y != smdk4210_camera->focus_y || force) { + smdk4210_camera->focus_y = focus_y; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_Y, focus_y); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_Y, focus_y); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } @@ -737,7 +737,7 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) } } - focus_mode_string = exynos_param_string_get(exynos_camera, "focus-mode"); + focus_mode_string = smdk4210_param_string_get(smdk4210_camera, "focus-mode"); if (focus_mode_string != NULL) { if (focus_mode == 0) { if (strcmp(focus_mode_string, "auto") == 0) @@ -758,33 +758,33 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) focus_mode = FOCUS_MODE_AUTO; } - if (focus_mode != exynos_camera->focus_mode || force) { - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode); + if (focus_mode != smdk4210_camera->focus_mode || force) { + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } if (focus_mode == FOCUS_MODE_TOUCH) { - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, 1); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, 1); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); - } else if (exynos_camera->focus_mode == FOCUS_MODE_TOUCH) { - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, 0); + } else if (smdk4210_camera->focus_mode == FOCUS_MODE_TOUCH) { + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, 0); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } - exynos_camera->focus_mode = focus_mode; + smdk4210_camera->focus_mode = focus_mode; } // Zoom - zoom_supported_string = exynos_param_string_get(exynos_camera, "zoom-supported"); + zoom_supported_string = smdk4210_param_string_get(smdk4210_camera, "zoom-supported"); if (zoom_supported_string != NULL && strcmp(zoom_supported_string, "true") == 0) { - zoom = exynos_param_int_get(exynos_camera, "zoom"); - max_zoom = exynos_param_int_get(exynos_camera, "max-zoom"); - if (zoom <= max_zoom && zoom >= 0 && (zoom != exynos_camera->zoom || force)) { - exynos_camera->zoom = zoom; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_ZOOM, zoom); + zoom = smdk4210_param_int_get(smdk4210_camera, "zoom"); + max_zoom = smdk4210_param_int_get(smdk4210_camera, "max-zoom"); + if (zoom <= max_zoom && zoom >= 0 && (zoom != smdk4210_camera->zoom || force)) { + smdk4210_camera->zoom = zoom; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_ZOOM, zoom); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } @@ -792,7 +792,7 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) } // Flash - flash_mode_string = exynos_param_string_get(exynos_camera, "flash-mode"); + flash_mode_string = smdk4210_param_string_get(smdk4210_camera, "flash-mode"); if (flash_mode_string != NULL) { if (strcmp(flash_mode_string, "off") == 0) flash_mode = FLASH_MODE_OFF; @@ -805,29 +805,29 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) else flash_mode = FLASH_MODE_AUTO; - if (flash_mode != exynos_camera->flash_mode || force) { - exynos_camera->flash_mode = flash_mode; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_FLASH_MODE, flash_mode); + if (flash_mode != smdk4210_camera->flash_mode || force) { + smdk4210_camera->flash_mode = flash_mode; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_FLASH_MODE, flash_mode); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } } // Exposure - exposure_compensation = exynos_param_int_get(exynos_camera, "exposure-compensation"); - min_exposure_compensation = exynos_param_int_get(exynos_camera, "min-exposure-compensation"); - max_exposure_compensation = exynos_param_int_get(exynos_camera, "max-exposure-compensation"); + exposure_compensation = smdk4210_param_int_get(smdk4210_camera, "exposure-compensation"); + min_exposure_compensation = smdk4210_param_int_get(smdk4210_camera, "min-exposure-compensation"); + max_exposure_compensation = smdk4210_param_int_get(smdk4210_camera, "max-exposure-compensation"); if (exposure_compensation <= max_exposure_compensation && exposure_compensation >= min_exposure_compensation && - (exposure_compensation != exynos_camera->exposure_compensation || force)) { - exynos_camera->exposure_compensation = exposure_compensation; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_BRIGHTNESS, exposure_compensation); + (exposure_compensation != smdk4210_camera->exposure_compensation || force)) { + smdk4210_camera->exposure_compensation = exposure_compensation; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_BRIGHTNESS, exposure_compensation); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } // WB - whitebalance_string = exynos_param_string_get(exynos_camera, "whitebalance"); + whitebalance_string = smdk4210_param_string_get(smdk4210_camera, "whitebalance"); if (whitebalance_string != NULL) { if (strcmp(whitebalance_string, "auto") == 0) whitebalance = WHITE_BALANCE_AUTO; @@ -842,16 +842,16 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) else whitebalance = WHITE_BALANCE_AUTO; - if (whitebalance != exynos_camera->whitebalance || force) { - exynos_camera->whitebalance = whitebalance; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_WHITE_BALANCE, whitebalance); + if (whitebalance != smdk4210_camera->whitebalance || force) { + smdk4210_camera->whitebalance = whitebalance; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_WHITE_BALANCE, whitebalance); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } } // Scene mode - scene_mode_string = exynos_param_string_get(exynos_camera, "scene-mode"); + scene_mode_string = smdk4210_param_string_get(smdk4210_camera, "scene-mode"); if (scene_mode_string != NULL) { if (strcmp(scene_mode_string, "auto") == 0) scene_mode = SCENE_MODE_NONE; @@ -886,16 +886,16 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) else scene_mode = SCENE_MODE_NONE; - if (scene_mode != exynos_camera->scene_mode || force) { - exynos_camera->scene_mode = scene_mode; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SCENE_MODE, scene_mode); + if (scene_mode != smdk4210_camera->scene_mode || force) { + smdk4210_camera->scene_mode = scene_mode; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_SCENE_MODE, scene_mode); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } } // Effect - effect_string = exynos_param_string_get(exynos_camera, "effect"); + effect_string = smdk4210_param_string_get(smdk4210_camera, "effect"); if (effect_string != NULL) { if (strcmp(effect_string, "auto") == 0) effect = IMAGE_EFFECT_NONE; @@ -910,16 +910,16 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) else effect = IMAGE_EFFECT_NONE; - if (effect != exynos_camera->effect || force) { - exynos_camera->effect = effect; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EFFECT, effect); + if (effect != smdk4210_camera->effect || force) { + smdk4210_camera->effect = effect; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_EFFECT, effect); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } } // ISO - iso_string = exynos_param_string_get(exynos_camera, "iso"); + iso_string = smdk4210_param_string_get(smdk4210_camera, "iso"); if (iso_string != NULL) { if (strcmp(iso_string, "auto") == 0) iso = ISO_AUTO; @@ -936,9 +936,9 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) else iso = ISO_AUTO; - if (iso != exynos_camera->iso || force) { - exynos_camera->iso = iso; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_ISO, iso); + if (iso != smdk4210_camera->iso || force) { + smdk4210_camera->iso = iso; + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_ISO, iso); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); } @@ -953,7 +953,7 @@ int exynos_camera_params_apply(struct exynos_camera *exynos_camera) // Picture -int exynos_camera_picture(struct exynos_camera *exynos_camera) +int smdk4210_camera_picture(struct smdk4210_camera *smdk4210_camera) { camera_memory_t *data_memory = NULL; camera_memory_t *exif_data_memory = NULL; @@ -994,24 +994,24 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) int index; int rc; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return -EINVAL; - picture_width = exynos_camera->picture_width; - picture_height = exynos_camera->picture_height; - picture_format = exynos_camera->picture_format; - camera_picture_format = exynos_camera->camera_picture_format; - jpeg_thumbnail_width = exynos_camera->jpeg_thumbnail_width; - jpeg_thumbnail_height = exynos_camera->jpeg_thumbnail_height; - jpeg_thumbnail_quality = exynos_camera->jpeg_thumbnail_quality; - jpeg_quality = exynos_camera->jpeg_quality; + picture_width = smdk4210_camera->picture_width; + picture_height = smdk4210_camera->picture_height; + picture_format = smdk4210_camera->picture_format; + camera_picture_format = smdk4210_camera->camera_picture_format; + jpeg_thumbnail_width = smdk4210_camera->jpeg_thumbnail_width; + jpeg_thumbnail_height = smdk4210_camera->jpeg_thumbnail_height; + jpeg_thumbnail_quality = smdk4210_camera->jpeg_thumbnail_quality; + jpeg_quality = smdk4210_camera->jpeg_quality; if (camera_picture_format == 0) camera_picture_format = picture_format; // V4L2 - rc = exynos_v4l2_poll(exynos_camera, 0); + rc = smdk4210_v4l2_poll(smdk4210_camera, 0); if (rc < 0) { ALOGE("%s: poll failed!", __func__); return -1; @@ -1020,13 +1020,13 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) return -1; } - rc = exynos_v4l2_streamoff_cap(exynos_camera, 0); + rc = smdk4210_v4l2_streamoff_cap(smdk4210_camera, 0); if (rc < 0) { ALOGE("%s: streamoff failed!", __func__); return -1; } - index = exynos_v4l2_dqbuf_cap(exynos_camera, 0); + index = smdk4210_v4l2_dqbuf_cap(smdk4210_camera, 0); if (index < 0) { ALOGE("%s: dqbuf failed!", __func__); return -1; @@ -1035,45 +1035,45 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) // This assumes that the output format is JPEG if (camera_picture_format == V4L2_PIX_FMT_JPEG) { - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAM_JPEG_MAIN_SIZE, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAM_JPEG_MAIN_SIZE, &picture_size); if (rc < 0) { ALOGE("%s: g ctrl failed!", __func__); return -1; } - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAM_JPEG_MAIN_OFFSET, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAM_JPEG_MAIN_OFFSET, &offset); if (rc < 0) { ALOGE("%s: g ctrl failed!", __func__); return -1; } - picture_addr = (void *) ((int) exynos_camera->picture_memory->data + offset); + picture_addr = (void *) ((int) smdk4210_camera->picture_memory->data + offset); - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAM_JPEG_THUMB_SIZE, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAM_JPEG_THUMB_SIZE, &jpeg_thumbnail_size); if (rc < 0) { ALOGE("%s: g ctrl failed!", __func__); return -1; } - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAM_JPEG_THUMB_OFFSET, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAM_JPEG_THUMB_OFFSET, &offset); if (rc < 0) { ALOGE("%s: g ctrl failed!", __func__); return -1; } - jpeg_thumbnail_addr = (void *) ((int) exynos_camera->picture_memory->data + offset); + jpeg_thumbnail_addr = (void *) ((int) smdk4210_camera->picture_memory->data + offset); } // Thumbnail if (camera_picture_format == V4L2_PIX_FMT_JPEG && jpeg_thumbnail_addr != NULL && jpeg_thumbnail_size >= 0) { - if (exynos_camera->callbacks.request_memory != NULL) { + if (smdk4210_camera->callbacks.request_memory != NULL) { jpeg_thumbnail_data_memory = - exynos_camera->callbacks.request_memory(-1, + smdk4210_camera->callbacks.request_memory(-1, jpeg_thumbnail_size, 1, 0); if (jpeg_thumbnail_data_memory == NULL) { ALOGE("%s: thumb memory request failed!", __func__); @@ -1148,7 +1148,7 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) goto error; } - memcpy(jpeg_in_buffer, exynos_camera->picture_memory->data, jpeg_in_size); + memcpy(jpeg_in_buffer, smdk4210_camera->picture_memory->data, jpeg_in_size); jpeg_result = api_jpeg_encode_exe(jpeg_fd, &jpeg_enc_params); if (jpeg_result != JPEG_ENCODE_OK) { @@ -1164,9 +1164,9 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) goto error; } - if (exynos_camera->callbacks.request_memory != NULL) { + if (smdk4210_camera->callbacks.request_memory != NULL) { jpeg_thumbnail_data_memory = - exynos_camera->callbacks.request_memory(-1, + smdk4210_camera->callbacks.request_memory(-1, jpeg_out_size, 1, 0); if (jpeg_thumbnail_data_memory == NULL) { ALOGE("%s: thumbnail memory request failed!", __func__); @@ -1188,9 +1188,9 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) // Picture if (camera_picture_format == V4L2_PIX_FMT_JPEG && picture_addr != NULL && picture_size >= 0) { - if (exynos_camera->callbacks.request_memory != NULL) { + if (smdk4210_camera->callbacks.request_memory != NULL) { picture_data_memory = - exynos_camera->callbacks.request_memory(-1, + smdk4210_camera->callbacks.request_memory(-1, picture_size, 1, 0); if (picture_data_memory == NULL) { ALOGE("%s: picture memory request failed!", __func__); @@ -1265,7 +1265,7 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) goto error; } - memcpy(jpeg_in_buffer, exynos_camera->picture_memory->data, jpeg_in_size); + memcpy(jpeg_in_buffer, smdk4210_camera->picture_memory->data, jpeg_in_size); jpeg_result = api_jpeg_encode_exe(jpeg_fd, &jpeg_enc_params); if (jpeg_result != JPEG_ENCODE_OK) { @@ -1281,9 +1281,9 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) goto error; } - if (exynos_camera->callbacks.request_memory != NULL) { + if (smdk4210_camera->callbacks.request_memory != NULL) { picture_data_memory = - exynos_camera->callbacks.request_memory(-1, + smdk4210_camera->callbacks.request_memory(-1, jpeg_out_size, 1, 0); if (picture_data_memory == NULL) { ALOGE("%s: picture memory request failed!", __func__); @@ -1305,10 +1305,10 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) // EXIF memset(&exif_attributes, 0, sizeof(exif_attributes)); - exynos_exif_attributes_create_static(exynos_camera, &exif_attributes); - exynos_exif_attributes_create_params(exynos_camera, &exif_attributes); + smdk4210_exif_attributes_create_static(smdk4210_camera, &exif_attributes); + smdk4210_exif_attributes_create_params(smdk4210_camera, &exif_attributes); - rc = exynos_exif_create(exynos_camera, &exif_attributes, + rc = smdk4210_exif_create(smdk4210_camera, &exif_attributes, jpeg_thumbnail_data_memory, jpeg_thumbnail_size, &exif_data_memory, &exif_size); if (rc < 0 || exif_data_memory == NULL || exif_size <= 0) { @@ -1318,9 +1318,9 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) data_size = exif_size + picture_size; - if (exynos_camera->callbacks.request_memory != NULL) { + if (smdk4210_camera->callbacks.request_memory != NULL) { data_memory = - exynos_camera->callbacks.request_memory(-1, + smdk4210_camera->callbacks.request_memory(-1, data_size, 1, 0); if (data_memory == NULL) { ALOGE("%s: data memory request failed!", __func__); @@ -1344,19 +1344,19 @@ int exynos_camera_picture(struct exynos_camera *exynos_camera) // Callbacks - if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_SHUTTER) && EXYNOS_CAMERA_CALLBACK_DEFINED(notify)) - exynos_camera->callbacks.notify(CAMERA_MSG_SHUTTER, 0, 0, - exynos_camera->callbacks.user); + if (SMDK4210_CAMERA_MSG_ENABLED(CAMERA_MSG_SHUTTER) && SMDK4210_CAMERA_CALLBACK_DEFINED(notify)) + smdk4210_camera->callbacks.notify(CAMERA_MSG_SHUTTER, 0, 0, + smdk4210_camera->callbacks.user); - if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_RAW_IMAGE) && EXYNOS_CAMERA_CALLBACK_DEFINED(data) && + if (SMDK4210_CAMERA_MSG_ENABLED(CAMERA_MSG_RAW_IMAGE) && SMDK4210_CAMERA_CALLBACK_DEFINED(data) && jpeg_thumbnail_data_memory != NULL) - exynos_camera->callbacks.data(CAMERA_MSG_RAW_IMAGE, - jpeg_thumbnail_data_memory, 0, NULL, exynos_camera->callbacks.user); + smdk4210_camera->callbacks.data(CAMERA_MSG_RAW_IMAGE, + jpeg_thumbnail_data_memory, 0, NULL, smdk4210_camera->callbacks.user); - if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_COMPRESSED_IMAGE) && EXYNOS_CAMERA_CALLBACK_DEFINED(data) && + if (SMDK4210_CAMERA_MSG_ENABLED(CAMERA_MSG_COMPRESSED_IMAGE) && SMDK4210_CAMERA_CALLBACK_DEFINED(data) && data_memory != NULL) - exynos_camera->callbacks.data(CAMERA_MSG_COMPRESSED_IMAGE, - data_memory, 0, NULL, exynos_camera->callbacks.user); + smdk4210_camera->callbacks.data(CAMERA_MSG_COMPRESSED_IMAGE, + data_memory, 0, NULL, smdk4210_camera->callbacks.user); // Release memory @@ -1390,46 +1390,46 @@ error: return -1; } -void *exynos_camera_picture_thread(void *data) +void *smdk4210_camera_picture_thread(void *data) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; int rc; int i; if (data == NULL) return NULL; - exynos_camera = (struct exynos_camera *) data; + smdk4210_camera = (struct smdk4210_camera *) data; ALOGE("%s: Starting thread", __func__); - exynos_camera->picture_thread_running = 1; + smdk4210_camera->picture_thread_running = 1; - if (exynos_camera->picture_enabled == 1) { - pthread_mutex_lock(&exynos_camera->picture_mutex); + if (smdk4210_camera->picture_enabled == 1) { + pthread_mutex_lock(&smdk4210_camera->picture_mutex); - rc = exynos_camera_picture(exynos_camera); + rc = smdk4210_camera_picture(smdk4210_camera); if (rc < 0) { ALOGE("%s: picture failed!", __func__); - exynos_camera->picture_enabled = 0; + smdk4210_camera->picture_enabled = 0; } - if (exynos_camera->picture_memory != NULL && exynos_camera->picture_memory->release != NULL) { - exynos_camera->picture_memory->release(exynos_camera->picture_memory); - exynos_camera->picture_memory = NULL; + if (smdk4210_camera->picture_memory != NULL && smdk4210_camera->picture_memory->release != NULL) { + smdk4210_camera->picture_memory->release(smdk4210_camera->picture_memory); + smdk4210_camera->picture_memory = NULL; } - pthread_mutex_unlock(&exynos_camera->picture_mutex); + pthread_mutex_unlock(&smdk4210_camera->picture_mutex); } - exynos_camera->picture_thread_running = 0; - exynos_camera->picture_enabled = 0; + smdk4210_camera->picture_thread_running = 0; + smdk4210_camera->picture_enabled = 0; ALOGE("%s: Exiting thread", __func__); return NULL; } -int exynos_camera_picture_start(struct exynos_camera *exynos_camera) +int smdk4210_camera_picture_start(struct smdk4210_camera *smdk4210_camera) { pthread_attr_t thread_attr; @@ -1438,63 +1438,63 @@ int exynos_camera_picture_start(struct exynos_camera *exynos_camera) int fd; int rc; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return -EINVAL; // Stop preview thread - exynos_camera_preview_stop(exynos_camera); + smdk4210_camera_preview_stop(smdk4210_camera); - width = exynos_camera->picture_width; - height = exynos_camera->picture_height; - format = exynos_camera->picture_format; - camera_format = exynos_camera->camera_picture_format; + width = smdk4210_camera->picture_width; + height = smdk4210_camera->picture_height; + format = smdk4210_camera->picture_format; + camera_format = smdk4210_camera->camera_picture_format; // V4L2 if (camera_format == 0) camera_format = format; - rc = exynos_v4l2_enum_fmt_cap(exynos_camera, 0, camera_format); + rc = smdk4210_v4l2_enum_fmt_cap(smdk4210_camera, 0, camera_format); if (rc < 0) { ALOGE("%s: enum fmt failed!", __func__); return -1; } - rc = exynos_v4l2_s_fmt_pix_cap(exynos_camera, 0, width, height, camera_format, V4L2_PIX_FMT_MODE_CAPTURE); + rc = smdk4210_v4l2_s_fmt_pix_cap(smdk4210_camera, 0, width, height, camera_format, V4L2_PIX_FMT_MODE_CAPTURE); if (rc < 0) { ALOGE("%s: s fmt failed!", __func__); return -1; } // Only use 1 buffer - rc = exynos_v4l2_reqbufs_cap(exynos_camera, 0, 1); + rc = smdk4210_v4l2_reqbufs_cap(smdk4210_camera, 0, 1); if (rc < 0) { ALOGE("%s: reqbufs failed!", __func__); return -1; } - rc = exynos_v4l2_querybuf_cap(exynos_camera, 0, 0); + rc = smdk4210_v4l2_querybuf_cap(smdk4210_camera, 0, 0); if (rc < 0) { ALOGE("%s: querybuf failed!", __func__); return -1; } - exynos_camera->picture_buffer_length = rc; + smdk4210_camera->picture_buffer_length = rc; - if (exynos_camera->callbacks.request_memory != NULL) { - fd = exynos_v4l2_find_fd(exynos_camera, 0); + if (smdk4210_camera->callbacks.request_memory != NULL) { + fd = smdk4210_v4l2_find_fd(smdk4210_camera, 0); if (fd < 0) { ALOGE("%s: Unable to find v4l2 fd", __func__); return -1; } - if (exynos_camera->picture_memory != NULL && exynos_camera->picture_memory->release != NULL) - exynos_camera->picture_memory->release(exynos_camera->picture_memory); + if (smdk4210_camera->picture_memory != NULL && smdk4210_camera->picture_memory->release != NULL) + smdk4210_camera->picture_memory->release(smdk4210_camera->picture_memory); - exynos_camera->picture_memory = - exynos_camera->callbacks.request_memory(fd, - exynos_camera->picture_buffer_length, 1, 0); - if (exynos_camera->picture_memory == NULL) { + smdk4210_camera->picture_memory = + smdk4210_camera->callbacks.request_memory(fd, + smdk4210_camera->picture_buffer_length, 1, 0); + if (smdk4210_camera->picture_memory == NULL) { ALOGE("%s: memory request failed!", __func__); return -1; } @@ -1503,19 +1503,19 @@ int exynos_camera_picture_start(struct exynos_camera *exynos_camera) return -1; } - rc = exynos_v4l2_qbuf_cap(exynos_camera, 0, 0); + rc = smdk4210_v4l2_qbuf_cap(smdk4210_camera, 0, 0); if (rc < 0) { ALOGE("%s: qbuf failed!", __func__); return -1; } - rc = exynos_v4l2_streamon_cap(exynos_camera, 0); + rc = smdk4210_v4l2_streamon_cap(smdk4210_camera, 0); if (rc < 0) { ALOGE("%s: streamon failed!", __func__); return -1; } - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_CAPTURE, 0); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_CAPTURE, 0); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); return -1; @@ -1523,20 +1523,20 @@ int exynos_camera_picture_start(struct exynos_camera *exynos_camera) // Thread - if (exynos_camera->picture_thread_running) { + if (smdk4210_camera->picture_thread_running) { ALOGE("Picture thread is already running!"); return -1; } - pthread_mutex_init(&exynos_camera->picture_mutex, NULL); + pthread_mutex_init(&smdk4210_camera->picture_mutex, NULL); pthread_attr_init(&thread_attr); pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - exynos_camera->picture_enabled = 1; + smdk4210_camera->picture_enabled = 1; - rc = pthread_create(&exynos_camera->picture_thread, &thread_attr, - exynos_camera_picture_thread, (void *) exynos_camera); + rc = pthread_create(&smdk4210_camera->picture_thread, &thread_attr, + smdk4210_camera_picture_thread, (void *) smdk4210_camera); if (rc < 0) { ALOGE("%s: Unable to create thread", __func__); return -1; @@ -1545,42 +1545,42 @@ int exynos_camera_picture_start(struct exynos_camera *exynos_camera) return 0; } -void exynos_camera_picture_stop(struct exynos_camera *exynos_camera) +void smdk4210_camera_picture_stop(struct smdk4210_camera *smdk4210_camera) { int rc; int i; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return; - if (!exynos_camera->picture_enabled) { + if (!smdk4210_camera->picture_enabled) { ALOGE("Picture was already stopped!"); return; } - pthread_mutex_lock(&exynos_camera->picture_mutex); + pthread_mutex_lock(&smdk4210_camera->picture_mutex); // Disable picture to make the thread end - exynos_camera->picture_enabled = 0; + smdk4210_camera->picture_enabled = 0; - pthread_mutex_unlock(&exynos_camera->picture_mutex); + pthread_mutex_unlock(&smdk4210_camera->picture_mutex); // Wait for the thread to end for (i = 0; i < 10; i++) { - if (!exynos_camera->picture_thread_running) + if (!smdk4210_camera->picture_thread_running) break; usleep(500); } - pthread_mutex_destroy(&exynos_camera->picture_mutex); + pthread_mutex_destroy(&smdk4210_camera->picture_mutex); } // Auto-focus -void *exynos_camera_auto_focus_thread(void *data) +void *smdk4210_camera_auto_focus_thread(void *data) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; int auto_focus_status = -1; int auto_focus_result = 0; int rc; @@ -1589,26 +1589,26 @@ void *exynos_camera_auto_focus_thread(void *data) if (data == NULL) return NULL; - exynos_camera = (struct exynos_camera *) data; + smdk4210_camera = (struct smdk4210_camera *) data; ALOGE("%s: Starting thread", __func__); - exynos_camera->auto_focus_thread_running = 1; + smdk4210_camera->auto_focus_thread_running = 1; - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); auto_focus_result = 0; goto thread_exit; } - while (exynos_camera->auto_focus_enabled == 1) { - pthread_mutex_lock(&exynos_camera->auto_focus_mutex); + while (smdk4210_camera->auto_focus_enabled == 1) { + pthread_mutex_lock(&smdk4210_camera->auto_focus_mutex); - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT, &auto_focus_status); + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT, &auto_focus_status); if (rc < 0) { ALOGE("%s: g ctrl failed!", __func__); auto_focus_result = 0; - pthread_mutex_unlock(&exynos_camera->auto_focus_mutex); + pthread_mutex_unlock(&smdk4210_camera->auto_focus_mutex); goto thread_exit; } @@ -1616,58 +1616,58 @@ void *exynos_camera_auto_focus_thread(void *data) usleep(10000); } else if (auto_focus_status == M5MO_AF_STATUS_SUCCESS || auto_focus_status == M5MO_AF_STATUS_1ST_SUCCESS) { auto_focus_result = 1; - pthread_mutex_unlock(&exynos_camera->auto_focus_mutex); + pthread_mutex_unlock(&smdk4210_camera->auto_focus_mutex); goto thread_exit; } else { auto_focus_result = 0; - pthread_mutex_unlock(&exynos_camera->auto_focus_mutex); + pthread_mutex_unlock(&smdk4210_camera->auto_focus_mutex); goto thread_exit; } - pthread_mutex_unlock(&exynos_camera->auto_focus_mutex); + pthread_mutex_unlock(&smdk4210_camera->auto_focus_mutex); } thread_exit: - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF); if (rc < 0) ALOGE("%s: s ctrl failed!", __func__); - if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS) && EXYNOS_CAMERA_CALLBACK_DEFINED(notify)) - exynos_camera->callbacks.notify(CAMERA_MSG_FOCUS, - (int32_t) auto_focus_result, 0, exynos_camera->callbacks.user); + if (SMDK4210_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS) && SMDK4210_CAMERA_CALLBACK_DEFINED(notify)) + smdk4210_camera->callbacks.notify(CAMERA_MSG_FOCUS, + (int32_t) auto_focus_result, 0, smdk4210_camera->callbacks.user); - exynos_camera->auto_focus_thread_running = 0; - exynos_camera->auto_focus_enabled = 0; + smdk4210_camera->auto_focus_thread_running = 0; + smdk4210_camera->auto_focus_enabled = 0; ALOGE("%s: Exiting thread", __func__); return NULL; } -int exynos_camera_auto_focus_start(struct exynos_camera *exynos_camera) +int smdk4210_camera_auto_focus_start(struct smdk4210_camera *smdk4210_camera) { pthread_attr_t thread_attr; int rc; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return -EINVAL; // Thread - if (exynos_camera->auto_focus_thread_running) { + if (smdk4210_camera->auto_focus_thread_running) { ALOGE("Auto-focus thread is already running!"); return -1; } - pthread_mutex_init(&exynos_camera->auto_focus_mutex, NULL); + pthread_mutex_init(&smdk4210_camera->auto_focus_mutex, NULL); pthread_attr_init(&thread_attr); pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - exynos_camera->auto_focus_enabled = 1; + smdk4210_camera->auto_focus_enabled = 1; - rc = pthread_create(&exynos_camera->auto_focus_thread, &thread_attr, - exynos_camera_auto_focus_thread, (void *) exynos_camera); + rc = pthread_create(&smdk4210_camera->auto_focus_thread, &thread_attr, + smdk4210_camera_auto_focus_thread, (void *) smdk4210_camera); if (rc < 0) { ALOGE("%s: Unable to create thread", __func__); return -1; @@ -1676,40 +1676,40 @@ int exynos_camera_auto_focus_start(struct exynos_camera *exynos_camera) return 0; } -void exynos_camera_auto_focus_stop(struct exynos_camera *exynos_camera) +void smdk4210_camera_auto_focus_stop(struct smdk4210_camera *smdk4210_camera) { int rc; int i; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return; - if (!exynos_camera->auto_focus_enabled) { + if (!smdk4210_camera->auto_focus_enabled) { ALOGE("Auto-focus was already stopped!"); return; } - pthread_mutex_lock(&exynos_camera->auto_focus_mutex); + pthread_mutex_lock(&smdk4210_camera->auto_focus_mutex); // Disable auto-focus to make the thread end - exynos_camera->auto_focus_enabled = 0; + smdk4210_camera->auto_focus_enabled = 0; - pthread_mutex_unlock(&exynos_camera->auto_focus_mutex); + pthread_mutex_unlock(&smdk4210_camera->auto_focus_mutex); // Wait for the thread to end for (i = 0; i < 10; i++) { - if (!exynos_camera->auto_focus_thread_running) + if (!smdk4210_camera->auto_focus_thread_running) break; usleep(500); } - pthread_mutex_destroy(&exynos_camera->auto_focus_mutex); + pthread_mutex_destroy(&smdk4210_camera->auto_focus_mutex); } // Preview -int exynos_camera_preview(struct exynos_camera *exynos_camera) +int smdk4210_camera_preview(struct smdk4210_camera *smdk4210_camera) { buffer_handle_t *buffer; int stride; @@ -1725,22 +1725,22 @@ int exynos_camera_preview(struct exynos_camera *exynos_camera) unsigned int recording_y_addr; unsigned int recording_cbcr_addr; nsecs_t timestamp; - struct exynos_camera_addrs *addrs; + struct smdk4210_camera_addrs *addrs; struct timespec ts; int index; int rc; int i; - if (exynos_camera == NULL || exynos_camera->preview_memory == NULL || - exynos_camera->preview_window == NULL) + if (smdk4210_camera == NULL || smdk4210_camera->preview_memory == NULL || + smdk4210_camera->preview_window == NULL) return -EINVAL; timestamp = systemTime(1); // V4L2 - rc = exynos_v4l2_poll(exynos_camera, 0); + rc = smdk4210_v4l2_poll(smdk4210_camera, 0); if (rc < 0) { ALOGE("%s: poll failed!", __func__); return -1; @@ -1749,13 +1749,13 @@ int exynos_camera_preview(struct exynos_camera *exynos_camera) return -1; } - index = exynos_v4l2_dqbuf_cap(exynos_camera, 0); - if (index < 0 || index >= exynos_camera->preview_buffers_count) { + index = smdk4210_v4l2_dqbuf_cap(smdk4210_camera, 0); + if (index < 0 || index >= smdk4210_camera->preview_buffers_count) { ALOGE("%s: dqbuf failed!", __func__); return -1; } - rc = exynos_v4l2_qbuf_cap(exynos_camera, 0, index); + rc = smdk4210_v4l2_qbuf_cap(smdk4210_camera, 0, index); if (rc < 0) { ALOGE("%s: qbuf failed!", __func__); return -1; @@ -1763,13 +1763,13 @@ int exynos_camera_preview(struct exynos_camera *exynos_camera) // Preview window - width = exynos_camera->preview_width; - height = exynos_camera->preview_height; - format_bpp = exynos_camera->preview_format_bpp; + width = smdk4210_camera->preview_width; + height = smdk4210_camera->preview_height; + format_bpp = smdk4210_camera->preview_format_bpp; - exynos_camera->preview_window->dequeue_buffer(exynos_camera->preview_window, + smdk4210_camera->preview_window->dequeue_buffer(smdk4210_camera->preview_window, &buffer, &stride); - exynos_camera->gralloc->lock(exynos_camera->gralloc, *buffer, GRALLOC_USAGE_SW_WRITE_OFTEN, + smdk4210_camera->gralloc->lock(smdk4210_camera->gralloc, *buffer, GRALLOC_USAGE_SW_WRITE_OFTEN, 0, 0, width, height, &window_data); if (window_data == NULL) { @@ -1777,29 +1777,29 @@ int exynos_camera_preview(struct exynos_camera *exynos_camera) return -1; } - frame_size = exynos_camera->preview_frame_size; + frame_size = smdk4210_camera->preview_frame_size; offset = index * frame_size; - preview_data = (void *) ((int) exynos_camera->preview_memory->data + offset); + preview_data = (void *) ((int) smdk4210_camera->preview_memory->data + offset); memcpy(window_data, preview_data, frame_size); - exynos_camera->gralloc->unlock(exynos_camera->gralloc, *buffer); - exynos_camera->preview_window->enqueue_buffer(exynos_camera->preview_window, + smdk4210_camera->gralloc->unlock(smdk4210_camera->gralloc, *buffer); + smdk4210_camera->preview_window->enqueue_buffer(smdk4210_camera->preview_window, buffer); - if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_PREVIEW_FRAME) && EXYNOS_CAMERA_CALLBACK_DEFINED(data)) { - exynos_camera->callbacks.data(CAMERA_MSG_PREVIEW_FRAME, - exynos_camera->preview_memory, index, NULL, exynos_camera->callbacks.user); + if (SMDK4210_CAMERA_MSG_ENABLED(CAMERA_MSG_PREVIEW_FRAME) && SMDK4210_CAMERA_CALLBACK_DEFINED(data)) { + smdk4210_camera->callbacks.data(CAMERA_MSG_PREVIEW_FRAME, + smdk4210_camera->preview_memory, index, NULL, smdk4210_camera->callbacks.user); } // Recording - if (exynos_camera->recording_enabled && exynos_camera->recording_memory != NULL) { - pthread_mutex_lock(&exynos_camera->recording_mutex); + if (smdk4210_camera->recording_enabled && smdk4210_camera->recording_memory != NULL) { + pthread_mutex_lock(&smdk4210_camera->recording_mutex); // V4L2 - rc = exynos_v4l2_poll(exynos_camera, 2); + rc = smdk4210_v4l2_poll(smdk4210_camera, 2); if (rc < 0) { ALOGE("%s: poll failed!", __func__); goto error_recording; @@ -1808,25 +1808,25 @@ int exynos_camera_preview(struct exynos_camera *exynos_camera) goto error_recording; } - index = exynos_v4l2_dqbuf_cap(exynos_camera, 2); + index = smdk4210_v4l2_dqbuf_cap(smdk4210_camera, 2); if (index < 0) { ALOGE("%s: dqbuf failed!", __func__); goto error_recording; } - recording_y_addr = exynos_v4l2_s_ctrl(exynos_camera, 2, V4L2_CID_PADDR_Y, index); + recording_y_addr = smdk4210_v4l2_s_ctrl(smdk4210_camera, 2, V4L2_CID_PADDR_Y, index); if (recording_y_addr == 0xffffffff) { ALOGE("%s: s ctrl failed!", __func__); goto error_recording; } - recording_cbcr_addr = exynos_v4l2_s_ctrl(exynos_camera, 2, V4L2_CID_PADDR_CBCR, index); + recording_cbcr_addr = smdk4210_v4l2_s_ctrl(smdk4210_camera, 2, V4L2_CID_PADDR_CBCR, index); if (recording_cbcr_addr == 0xffffffff) { ALOGE("%s: s ctrl failed!", __func__); goto error_recording; } - addrs = (struct exynos_camera_addrs *) exynos_camera->recording_memory->data; + addrs = (struct smdk4210_camera_addrs *) smdk4210_camera->recording_memory->data; addrs[index].type = 0; // kMetadataBufferTypeCameraSource addrs[index].y = recording_y_addr; @@ -1834,13 +1834,13 @@ int exynos_camera_preview(struct exynos_camera *exynos_camera) addrs[index].index = index; addrs[index].reserved = 0; - pthread_mutex_unlock(&exynos_camera->recording_mutex); + pthread_mutex_unlock(&smdk4210_camera->recording_mutex); - if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_VIDEO_FRAME) && EXYNOS_CAMERA_CALLBACK_DEFINED(data_timestamp)) { - exynos_camera->callbacks.data_timestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, - exynos_camera->recording_memory, index, exynos_camera->callbacks.user); + if (SMDK4210_CAMERA_MSG_ENABLED(CAMERA_MSG_VIDEO_FRAME) && SMDK4210_CAMERA_CALLBACK_DEFINED(data_timestamp)) { + smdk4210_camera->callbacks.data_timestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, + smdk4210_camera->recording_memory, index, smdk4210_camera->callbacks.user); } else { - rc = exynos_v4l2_qbuf_cap(exynos_camera, 2, index); + rc = smdk4210_v4l2_qbuf_cap(smdk4210_camera, 2, index); if (rc < 0) { ALOGE("%s: qbuf failed!", __func__); return -1; @@ -1851,48 +1851,48 @@ int exynos_camera_preview(struct exynos_camera *exynos_camera) return 0; error_recording: - pthread_mutex_lock(&exynos_camera->recording_mutex); + pthread_mutex_lock(&smdk4210_camera->recording_mutex); return -1; } -void *exynos_camera_preview_thread(void *data) +void *smdk4210_camera_preview_thread(void *data) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; int rc; if (data == NULL) return NULL; - exynos_camera = (struct exynos_camera *) data; + smdk4210_camera = (struct smdk4210_camera *) data; ALOGE("%s: Starting thread", __func__); - exynos_camera->preview_thread_running = 1; + smdk4210_camera->preview_thread_running = 1; - if (exynos_camera->preview_window == NULL) { + if (smdk4210_camera->preview_window == NULL) { // Lock preview lock mutex - pthread_mutex_lock(&exynos_camera->preview_lock_mutex); + pthread_mutex_lock(&smdk4210_camera->preview_lock_mutex); } - while (exynos_camera->preview_enabled == 1) { - pthread_mutex_lock(&exynos_camera->preview_mutex); + while (smdk4210_camera->preview_enabled == 1) { + pthread_mutex_lock(&smdk4210_camera->preview_mutex); - rc = exynos_camera_preview(exynos_camera); + rc = smdk4210_camera_preview(smdk4210_camera); if (rc < 0) { ALOGE("%s: preview failed!", __func__); - exynos_camera->preview_enabled = 0; + smdk4210_camera->preview_enabled = 0; } - pthread_mutex_unlock(&exynos_camera->preview_mutex); + pthread_mutex_unlock(&smdk4210_camera->preview_mutex); } - exynos_camera->preview_thread_running = 0; + smdk4210_camera->preview_thread_running = 0; ALOGE("%s: Exiting thread", __func__); return NULL; } -int exynos_camera_preview_start(struct exynos_camera *exynos_camera) +int smdk4210_camera_preview_start(struct smdk4210_camera *smdk4210_camera) { struct v4l2_streamparm streamparm; int width, height, format; @@ -1905,42 +1905,42 @@ int exynos_camera_preview_start(struct exynos_camera *exynos_camera) int rc; int i; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return -EINVAL; - if (exynos_camera->preview_enabled) { + if (smdk4210_camera->preview_enabled) { ALOGE("Preview was already started!"); return 0; } // V4L2 - format = exynos_camera->preview_format; + format = smdk4210_camera->preview_format; - rc = exynos_v4l2_enum_fmt_cap(exynos_camera, 0, format); + rc = smdk4210_v4l2_enum_fmt_cap(smdk4210_camera, 0, format); if (rc < 0) { ALOGE("%s: enum fmt failed!", __func__); return -1; } - width = exynos_camera->preview_width; - height = exynos_camera->preview_height; - format_bpp = exynos_camera->preview_format_bpp; + width = smdk4210_camera->preview_width; + height = smdk4210_camera->preview_height; + format_bpp = smdk4210_camera->preview_format_bpp; - rc = exynos_v4l2_s_fmt_pix_cap(exynos_camera, 0, width, height, format, V4L2_PIX_FMT_MODE_PREVIEW); + rc = smdk4210_v4l2_s_fmt_pix_cap(smdk4210_camera, 0, width, height, format, V4L2_PIX_FMT_MODE_PREVIEW); if (rc < 0) { ALOGE("%s: s fmt failed!", __func__); return -1; } - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CACHEABLE, 1); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_CACHEABLE, 1); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); return -1; } - for (i = EXYNOS_CAMERA_MAX_BUFFERS_COUNT; i >= EXYNOS_CAMERA_MIN_BUFFERS_COUNT; i--) { - rc = exynos_v4l2_reqbufs_cap(exynos_camera, 0, i); + for (i = SMDK4210_CAMERA_MAX_BUFFERS_COUNT; i >= SMDK4210_CAMERA_MIN_BUFFERS_COUNT; i--) { + rc = smdk4210_v4l2_reqbufs_cap(smdk4210_camera, 0, i); if (rc >= 0) break; } @@ -1950,23 +1950,23 @@ int exynos_camera_preview_start(struct exynos_camera *exynos_camera) return -1; } - exynos_camera->preview_buffers_count = rc; - ALOGD("Found %d preview buffers available!", exynos_camera->preview_buffers_count); + smdk4210_camera->preview_buffers_count = rc; + ALOGD("Found %d preview buffers available!", smdk4210_camera->preview_buffers_count); - fps = exynos_camera->preview_fps; + fps = smdk4210_camera->preview_fps; memset(&streamparm, 0, sizeof(streamparm)); streamparm.parm.capture.timeperframe.numerator = 1; streamparm.parm.capture.timeperframe.denominator = fps; - rc = exynos_v4l2_s_parm_cap(exynos_camera, 0, &streamparm); + rc = smdk4210_v4l2_s_parm_cap(smdk4210_camera, 0, &streamparm); if (rc < 0) { ALOGE("%s: s parm failed!", __func__); return -1; } frame_size = (int) ((float) width * (float) height * format_bpp); - for (i = 0; i < exynos_camera->preview_buffers_count; i++) { - rc = exynos_v4l2_querybuf_cap(exynos_camera, 0, i); + for (i = 0; i < smdk4210_camera->preview_buffers_count; i++) { + rc = smdk4210_v4l2_querybuf_cap(smdk4210_camera, 0, i); if (rc < 0) { ALOGE("%s: querybuf failed!", __func__); return -1; @@ -1979,22 +1979,22 @@ int exynos_camera_preview_start(struct exynos_camera *exynos_camera) } frame_size = rc; - exynos_camera->preview_frame_size = frame_size; + smdk4210_camera->preview_frame_size = frame_size; - if (exynos_camera->callbacks.request_memory != NULL) { - fd = exynos_v4l2_find_fd(exynos_camera, 0); + if (smdk4210_camera->callbacks.request_memory != NULL) { + fd = smdk4210_v4l2_find_fd(smdk4210_camera, 0); if (fd < 0) { ALOGE("%s: Unable to find v4l2 fd", __func__); return -1; } - if (exynos_camera->preview_memory != NULL && exynos_camera->preview_memory->release != NULL) - exynos_camera->preview_memory->release(exynos_camera->preview_memory); + if (smdk4210_camera->preview_memory != NULL && smdk4210_camera->preview_memory->release != NULL) + smdk4210_camera->preview_memory->release(smdk4210_camera->preview_memory); - exynos_camera->preview_memory = - exynos_camera->callbacks.request_memory(fd, - frame_size, exynos_camera->preview_buffers_count, 0); - if (exynos_camera->preview_memory == NULL) { + smdk4210_camera->preview_memory = + smdk4210_camera->callbacks.request_memory(fd, + frame_size, smdk4210_camera->preview_buffers_count, 0); + if (smdk4210_camera->preview_memory == NULL) { ALOGE("%s: memory request failed!", __func__); return -1; } @@ -2003,36 +2003,36 @@ int exynos_camera_preview_start(struct exynos_camera *exynos_camera) return -1; } - for (i = 0; i < exynos_camera->preview_buffers_count; i++) { - rc = exynos_v4l2_qbuf_cap(exynos_camera, 0, i); + for (i = 0; i < smdk4210_camera->preview_buffers_count; i++) { + rc = smdk4210_v4l2_qbuf_cap(smdk4210_camera, 0, i); if (rc < 0) { ALOGE("%s: qbuf failed!", __func__); return -1; } } - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_ROTATION, - exynos_camera->camera_rotation); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_ROTATION, + smdk4210_camera->camera_rotation); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); return -1; } - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_HFLIP, - exynos_camera->camera_hflip); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_HFLIP, + smdk4210_camera->camera_hflip); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); return -1; } - rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_VFLIP, - exynos_camera->camera_vflip); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 0, V4L2_CID_VFLIP, + smdk4210_camera->camera_vflip); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); return -1; } - rc = exynos_v4l2_streamon_cap(exynos_camera, 0); + rc = smdk4210_v4l2_streamon_cap(smdk4210_camera, 0); if (rc < 0) { ALOGE("%s: streamon failed!", __func__); return -1; @@ -2040,19 +2040,19 @@ int exynos_camera_preview_start(struct exynos_camera *exynos_camera) // Thread - pthread_mutex_init(&exynos_camera->preview_mutex, NULL); - pthread_mutex_init(&exynos_camera->preview_lock_mutex, NULL); + pthread_mutex_init(&smdk4210_camera->preview_mutex, NULL); + pthread_mutex_init(&smdk4210_camera->preview_lock_mutex, NULL); // Lock preview lock - pthread_mutex_lock(&exynos_camera->preview_lock_mutex); + pthread_mutex_lock(&smdk4210_camera->preview_lock_mutex); pthread_attr_init(&thread_attr); pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - exynos_camera->preview_enabled = 1; + smdk4210_camera->preview_enabled = 1; - rc = pthread_create(&exynos_camera->preview_thread, &thread_attr, - exynos_camera_preview_thread, (void *) exynos_camera); + rc = pthread_create(&smdk4210_camera->preview_thread, &thread_attr, + smdk4210_camera_preview_thread, (void *) smdk4210_camera); if (rc < 0) { ALOGE("%s: Unable to create thread", __func__); return -1; @@ -2061,81 +2061,81 @@ int exynos_camera_preview_start(struct exynos_camera *exynos_camera) return 0; } -void exynos_camera_preview_stop(struct exynos_camera *exynos_camera) +void smdk4210_camera_preview_stop(struct smdk4210_camera *smdk4210_camera) { int rc; int i; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return; - if (!exynos_camera->preview_enabled) { + if (!smdk4210_camera->preview_enabled) { ALOGE("Preview was already stopped!"); return; } - exynos_camera->preview_enabled = 0; + smdk4210_camera->preview_enabled = 0; // Unlock preview lock - pthread_mutex_unlock(&exynos_camera->preview_lock_mutex); + pthread_mutex_unlock(&smdk4210_camera->preview_lock_mutex); - pthread_mutex_lock(&exynos_camera->preview_mutex); + pthread_mutex_lock(&smdk4210_camera->preview_mutex); // Wait for the thread to end for (i = 0; i < 10; i++) { - if (!exynos_camera->preview_thread_running) + if (!smdk4210_camera->preview_thread_running) break; usleep(1000); } - rc = exynos_v4l2_streamoff_cap(exynos_camera, 0); + rc = smdk4210_v4l2_streamoff_cap(smdk4210_camera, 0); if (rc < 0) { ALOGE("%s: streamoff failed!", __func__); } - exynos_camera->preview_params_set = 0; + smdk4210_camera->preview_params_set = 0; - if (exynos_camera->preview_memory != NULL && exynos_camera->preview_memory->release != NULL) { - exynos_camera->preview_memory->release(exynos_camera->preview_memory); - exynos_camera->preview_memory = NULL; + if (smdk4210_camera->preview_memory != NULL && smdk4210_camera->preview_memory->release != NULL) { + smdk4210_camera->preview_memory->release(smdk4210_camera->preview_memory); + smdk4210_camera->preview_memory = NULL; } - exynos_camera->preview_window = NULL; + smdk4210_camera->preview_window = NULL; - pthread_mutex_unlock(&exynos_camera->preview_mutex); + pthread_mutex_unlock(&smdk4210_camera->preview_mutex); - pthread_mutex_destroy(&exynos_camera->preview_lock_mutex); - pthread_mutex_destroy(&exynos_camera->preview_mutex); + pthread_mutex_destroy(&smdk4210_camera->preview_lock_mutex); + pthread_mutex_destroy(&smdk4210_camera->preview_mutex); } // Recording -void exynos_camera_recording_frame_release(struct exynos_camera *exynos_camera, void *data) +void smdk4210_camera_recording_frame_release(struct smdk4210_camera *smdk4210_camera, void *data) { - struct exynos_camera_addrs *addrs; + struct smdk4210_camera_addrs *addrs; int rc; - if (exynos_camera == NULL || data == NULL) + if (smdk4210_camera == NULL || data == NULL) return; - addrs = (struct exynos_camera_addrs *) data; - if (addrs->index >= (unsigned int) exynos_camera->recording_buffers_count) + addrs = (struct smdk4210_camera_addrs *) data; + if (addrs->index >= (unsigned int) smdk4210_camera->recording_buffers_count) return; - pthread_mutex_lock(&exynos_camera->recording_mutex); + pthread_mutex_lock(&smdk4210_camera->recording_mutex); - rc = exynos_v4l2_qbuf_cap(exynos_camera, 2, addrs->index); + rc = smdk4210_v4l2_qbuf_cap(smdk4210_camera, 2, addrs->index); if (rc < 0) { ALOGE("%s: qbuf failed!", __func__); goto error; } error: - pthread_mutex_unlock(&exynos_camera->recording_mutex); + pthread_mutex_unlock(&smdk4210_camera->recording_mutex); } -int exynos_camera_recording_start(struct exynos_camera *exynos_camera) +int smdk4210_camera_recording_start(struct smdk4210_camera *smdk4210_camera) { int width, height, format; int fd; @@ -2143,37 +2143,37 @@ int exynos_camera_recording_start(struct exynos_camera *exynos_camera) int rc; int i; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return -EINVAL; - if (exynos_camera->recording_enabled) { + if (smdk4210_camera->recording_enabled) { ALOGE("Recording was already started!"); return 0; } - pthread_mutex_lock(&exynos_camera->preview_mutex); + pthread_mutex_lock(&smdk4210_camera->preview_mutex); // V4L2 - format = exynos_camera->recording_format; + format = smdk4210_camera->recording_format; - rc = exynos_v4l2_enum_fmt_cap(exynos_camera, 2, format); + rc = smdk4210_v4l2_enum_fmt_cap(smdk4210_camera, 2, format); if (rc < 0) { ALOGE("%s: enum fmt failed!", __func__); goto error; } - width = exynos_camera->recording_width; - height = exynos_camera->recording_height; + width = smdk4210_camera->recording_width; + height = smdk4210_camera->recording_height; - rc = exynos_v4l2_s_fmt_pix_cap(exynos_camera, 2, width, height, format, V4L2_PIX_FMT_MODE_CAPTURE); + rc = smdk4210_v4l2_s_fmt_pix_cap(smdk4210_camera, 2, width, height, format, V4L2_PIX_FMT_MODE_CAPTURE); if (rc < 0) { ALOGE("%s: s fmt failed!", __func__); goto error; } - for (i = EXYNOS_CAMERA_MAX_BUFFERS_COUNT; i >= EXYNOS_CAMERA_MIN_BUFFERS_COUNT; i--) { - rc = exynos_v4l2_reqbufs_cap(exynos_camera, 2, i); + for (i = SMDK4210_CAMERA_MAX_BUFFERS_COUNT; i >= SMDK4210_CAMERA_MIN_BUFFERS_COUNT; i--) { + rc = smdk4210_v4l2_reqbufs_cap(smdk4210_camera, 2, i); if (rc >= 0) break; } @@ -2183,25 +2183,25 @@ int exynos_camera_recording_start(struct exynos_camera *exynos_camera) goto error; } - exynos_camera->recording_buffers_count = rc; - ALOGD("Found %d recording buffers available!", exynos_camera->recording_buffers_count); + smdk4210_camera->recording_buffers_count = rc; + ALOGD("Found %d recording buffers available!", smdk4210_camera->recording_buffers_count); - for (i = 0; i < exynos_camera->recording_buffers_count; i++) { - rc = exynos_v4l2_querybuf_cap(exynos_camera, 2, i); + for (i = 0; i < smdk4210_camera->recording_buffers_count; i++) { + rc = smdk4210_v4l2_querybuf_cap(smdk4210_camera, 2, i); if (rc < 0) { ALOGE("%s: querybuf failed!", __func__); goto error; } } - if (exynos_camera->callbacks.request_memory != NULL) { - if (exynos_camera->recording_memory != NULL && exynos_camera->recording_memory->release != NULL) - exynos_camera->recording_memory->release(exynos_camera->recording_memory); + if (smdk4210_camera->callbacks.request_memory != NULL) { + if (smdk4210_camera->recording_memory != NULL && smdk4210_camera->recording_memory->release != NULL) + smdk4210_camera->recording_memory->release(smdk4210_camera->recording_memory); - exynos_camera->recording_memory = - exynos_camera->callbacks.request_memory(-1, sizeof(struct exynos_camera_addrs), - exynos_camera->recording_buffers_count, 0); - if (exynos_camera->recording_memory == NULL) { + smdk4210_camera->recording_memory = + smdk4210_camera->callbacks.request_memory(-1, sizeof(struct smdk4210_camera_addrs), + smdk4210_camera->recording_buffers_count, 0); + if (smdk4210_camera->recording_memory == NULL) { ALOGE("%s: memory request failed!", __func__); goto error; } @@ -2210,93 +2210,93 @@ int exynos_camera_recording_start(struct exynos_camera *exynos_camera) goto error; } - for (i = 0; i < exynos_camera->recording_buffers_count; i++) { - rc = exynos_v4l2_qbuf_cap(exynos_camera, 2, i); + for (i = 0; i < smdk4210_camera->recording_buffers_count; i++) { + rc = smdk4210_v4l2_qbuf_cap(smdk4210_camera, 2, i); if (rc < 0) { ALOGE("%s: qbuf failed!", __func__); goto error; } } - rc = exynos_v4l2_s_ctrl(exynos_camera, 2, V4L2_CID_ROTATION, - exynos_camera->camera_rotation); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 2, V4L2_CID_ROTATION, + smdk4210_camera->camera_rotation); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); goto error; } - rc = exynos_v4l2_s_ctrl(exynos_camera, 2, V4L2_CID_HFLIP, - exynos_camera->camera_hflip); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 2, V4L2_CID_HFLIP, + smdk4210_camera->camera_hflip); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); goto error; } - rc = exynos_v4l2_s_ctrl(exynos_camera, 2, V4L2_CID_VFLIP, - exynos_camera->camera_vflip); + rc = smdk4210_v4l2_s_ctrl(smdk4210_camera, 2, V4L2_CID_VFLIP, + smdk4210_camera->camera_vflip); if (rc < 0) { ALOGE("%s: s ctrl failed!", __func__); goto error; } - rc = exynos_v4l2_streamon_cap(exynos_camera, 2); + rc = smdk4210_v4l2_streamon_cap(smdk4210_camera, 2); if (rc < 0) { ALOGE("%s: streamon failed!", __func__); goto error; } - pthread_mutex_init(&exynos_camera->recording_mutex, NULL); + pthread_mutex_init(&smdk4210_camera->recording_mutex, NULL); - exynos_camera->recording_enabled = 1; + smdk4210_camera->recording_enabled = 1; - pthread_mutex_unlock(&exynos_camera->preview_mutex); + pthread_mutex_unlock(&smdk4210_camera->preview_mutex); return 0; error: - pthread_mutex_unlock(&exynos_camera->preview_mutex); + pthread_mutex_unlock(&smdk4210_camera->preview_mutex); return -1; } -void exynos_camera_recording_stop(struct exynos_camera *exynos_camera) +void smdk4210_camera_recording_stop(struct smdk4210_camera *smdk4210_camera) { int rc; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return; - if (!exynos_camera->recording_enabled) { + if (!smdk4210_camera->recording_enabled) { ALOGE("Recording was already stopped!"); return; } - exynos_camera->recording_enabled = 0; + smdk4210_camera->recording_enabled = 0; - pthread_mutex_lock(&exynos_camera->preview_mutex); + pthread_mutex_lock(&smdk4210_camera->preview_mutex); - rc = exynos_v4l2_streamoff_cap(exynos_camera, 2); + rc = smdk4210_v4l2_streamoff_cap(smdk4210_camera, 2); if (rc < 0) { ALOGE("%s: streamoff failed!", __func__); } - if (exynos_camera->recording_memory != NULL && exynos_camera->recording_memory->release != NULL) { - exynos_camera->recording_memory->release(exynos_camera->recording_memory); - exynos_camera->recording_memory = NULL; + if (smdk4210_camera->recording_memory != NULL && smdk4210_camera->recording_memory->release != NULL) { + smdk4210_camera->recording_memory->release(smdk4210_camera->recording_memory); + smdk4210_camera->recording_memory = NULL; } - pthread_mutex_unlock(&exynos_camera->preview_mutex); + pthread_mutex_unlock(&smdk4210_camera->preview_mutex); - pthread_mutex_destroy(&exynos_camera->recording_mutex); + pthread_mutex_destroy(&smdk4210_camera->recording_mutex); } /* - * Exynos Camera OPS + * SMDK4210 Camera OPS */ -int exynos_camera_set_preview_window(struct camera_device *dev, +int smdk4210_camera_set_preview_window(struct camera_device *dev, struct preview_stream_ops *w) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; int width, height, format, hal_format; @@ -2311,25 +2311,25 @@ int exynos_camera_set_preview_window(struct camera_device *dev, if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; if (w == NULL) return 0; - exynos_camera->preview_window = w; + smdk4210_camera->preview_window = w; if (w->set_buffer_count == NULL || w->set_usage == NULL || w->set_buffers_geometry == NULL) return -EINVAL; - if (exynos_camera->preview_buffers_count <= 0) { + if (smdk4210_camera->preview_buffers_count <= 0) { ALOGE("%s: Invalid preview buffers count", __func__); - exynos_camera->preview_buffers_count = EXYNOS_CAMERA_MAX_BUFFERS_COUNT; + smdk4210_camera->preview_buffers_count = SMDK4210_CAMERA_MAX_BUFFERS_COUNT; } - rc = w->set_buffer_count(w, exynos_camera->preview_buffers_count); + rc = w->set_buffer_count(w, smdk4210_camera->preview_buffers_count); if (rc) { ALOGE("%s: Unable to set buffer count (%d)", __func__, - exynos_camera->preview_buffers_count); + smdk4210_camera->preview_buffers_count); return -1; } @@ -2339,9 +2339,9 @@ int exynos_camera_set_preview_window(struct camera_device *dev, return -1; } - width = exynos_camera->preview_width; - height = exynos_camera->preview_height; - format = exynos_camera->preview_format; + width = smdk4210_camera->preview_width; + height = smdk4210_camera->preview_height; + format = smdk4210_camera->preview_format; switch (format) { case V4L2_PIX_FMT_NV21: @@ -2368,119 +2368,119 @@ int exynos_camera_set_preview_window(struct camera_device *dev, } // Unlock preview lock - pthread_mutex_unlock(&exynos_camera->preview_lock_mutex); + pthread_mutex_unlock(&smdk4210_camera->preview_lock_mutex); return 0; } -void exynos_camera_set_callbacks(struct camera_device *dev, +void smdk4210_camera_set_callbacks(struct camera_device *dev, 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 exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p, %p)", __func__, dev, user); if (dev == NULL || dev->priv == NULL) return; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - exynos_camera->callbacks.notify = notify_cb; - exynos_camera->callbacks.data = data_cb; - exynos_camera->callbacks.data_timestamp = data_cb_timestamp; - exynos_camera->callbacks.request_memory = get_memory; - exynos_camera->callbacks.user = user; + smdk4210_camera->callbacks.notify = notify_cb; + smdk4210_camera->callbacks.data = data_cb; + smdk4210_camera->callbacks.data_timestamp = data_cb_timestamp; + smdk4210_camera->callbacks.request_memory = get_memory; + smdk4210_camera->callbacks.user = user; } -void exynos_camera_enable_msg_type(struct camera_device *dev, int32_t msg_type) +void smdk4210_camera_enable_msg_type(struct camera_device *dev, int32_t msg_type) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p, %d)", __func__, dev, msg_type); if (dev == NULL || dev->priv == NULL) return; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - exynos_camera->messages_enabled |= msg_type; + smdk4210_camera->messages_enabled |= msg_type; } -void exynos_camera_disable_msg_type(struct camera_device *dev, int32_t msg_type) +void smdk4210_camera_disable_msg_type(struct camera_device *dev, int32_t msg_type) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p, %d)", __func__, dev, msg_type); if (dev == NULL || dev->priv == NULL) return; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - exynos_camera->messages_enabled &= ~msg_type; + smdk4210_camera->messages_enabled &= ~msg_type; } -int exynos_camera_msg_type_enabled(struct camera_device *dev, int32_t msg_type) +int smdk4210_camera_msg_type_enabled(struct camera_device *dev, int32_t msg_type) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p, %d)", __func__, dev, msg_type); if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - return exynos_camera->messages_enabled & msg_type; + return smdk4210_camera->messages_enabled & msg_type; } -int exynos_camera_start_preview(struct camera_device *dev) +int smdk4210_camera_start_preview(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - return exynos_camera_preview_start(exynos_camera); + return smdk4210_camera_preview_start(smdk4210_camera); } -void exynos_camera_stop_preview(struct camera_device *dev) +void smdk4210_camera_stop_preview(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - exynos_camera_preview_stop(exynos_camera); + smdk4210_camera_preview_stop(smdk4210_camera); } -int exynos_camera_preview_enabled(struct camera_device *dev) +int smdk4210_camera_preview_enabled(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - return exynos_camera->preview_enabled; + return smdk4210_camera->preview_enabled; } -int exynos_camera_store_meta_data_in_buffers(struct camera_device *dev, +int smdk4210_camera_store_meta_data_in_buffers(struct camera_device *dev, int enable) { ALOGD("%s(%p, %d)", __func__, dev, enable); @@ -2493,121 +2493,121 @@ int exynos_camera_store_meta_data_in_buffers(struct camera_device *dev, return 0; } -int exynos_camera_start_recording(struct camera_device *dev) +int smdk4210_camera_start_recording(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - return exynos_camera_recording_start(exynos_camera); + return smdk4210_camera_recording_start(smdk4210_camera); } -void exynos_camera_stop_recording(struct camera_device *dev) +void smdk4210_camera_stop_recording(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - exynos_camera_recording_stop(exynos_camera); + smdk4210_camera_recording_stop(smdk4210_camera); } -int exynos_camera_recording_enabled(struct camera_device *dev) +int smdk4210_camera_recording_enabled(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - return exynos_camera->recording_enabled; + return smdk4210_camera->recording_enabled; } -void exynos_camera_release_recording_frame(struct camera_device *dev, +void smdk4210_camera_release_recording_frame(struct camera_device *dev, const void *opaque) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGV("%s(%p, %p)", __func__, dev, opaque); if (dev == NULL || dev->priv == NULL) return; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - exynos_camera_recording_frame_release(exynos_camera, (void *) opaque); + smdk4210_camera_recording_frame_release(smdk4210_camera, (void *) opaque); } -int exynos_camera_auto_focus(struct camera_device *dev) +int smdk4210_camera_auto_focus(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - return exynos_camera_auto_focus_start(exynos_camera); + return smdk4210_camera_auto_focus_start(smdk4210_camera); } -int exynos_camera_cancel_auto_focus(struct camera_device *dev) +int smdk4210_camera_cancel_auto_focus(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - exynos_camera_auto_focus_stop(exynos_camera); + smdk4210_camera_auto_focus_stop(smdk4210_camera); return 0; } -int exynos_camera_take_picture(struct camera_device *dev) +int smdk4210_camera_take_picture(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - return exynos_camera_picture_start(exynos_camera); + return smdk4210_camera_picture_start(smdk4210_camera); } -int exynos_camera_cancel_picture(struct camera_device *dev) +int smdk4210_camera_cancel_picture(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - exynos_camera_picture_stop(exynos_camera); + smdk4210_camera_picture_stop(smdk4210_camera); return 0; } -int exynos_camera_set_parameters(struct camera_device *dev, +int smdk4210_camera_set_parameters(struct camera_device *dev, const char *params) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; int rc; ALOGD("%s(%p, %s)", __func__, dev, params); @@ -2615,15 +2615,15 @@ int exynos_camera_set_parameters(struct camera_device *dev, if (dev == NULL || dev->priv == NULL || params == NULL) return -EINVAL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - rc = exynos_params_string_set(exynos_camera, (char *) params); + rc = smdk4210_params_string_set(smdk4210_camera, (char *) params); if (rc < 0) { ALOGE("%s: Unable to set params string", __func__); return -1; } - rc = exynos_camera_params_apply(exynos_camera); + rc = smdk4210_camera_params_apply(smdk4210_camera); if (rc < 0) { ALOGE("%s: Unable to apply params", __func__); return -1; @@ -2632,9 +2632,9 @@ int exynos_camera_set_parameters(struct camera_device *dev, return 0; } -char *exynos_camera_get_parameters(struct camera_device *dev) +char *smdk4210_camera_get_parameters(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; char *params; ALOGD("%s(%p)", __func__, dev); @@ -2642,9 +2642,9 @@ char *exynos_camera_get_parameters(struct camera_device *dev) if (dev == NULL || dev->priv == NULL) return NULL; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - params = exynos_params_string_get(exynos_camera); + params = smdk4210_params_string_get(smdk4210_camera); if (params == NULL) { ALOGE("%s: Couldn't find any param", __func__); return strdup(""); @@ -2653,7 +2653,7 @@ char *exynos_camera_get_parameters(struct camera_device *dev) return params; } -void exynos_camera_put_parameters(struct camera_device *dev, char *params) +void smdk4210_camera_put_parameters(struct camera_device *dev, char *params) { ALOGD("%s(%p)", __func__, dev); @@ -2661,7 +2661,7 @@ void exynos_camera_put_parameters(struct camera_device *dev, char *params) free(params); } -int exynos_camera_send_command(struct camera_device *dev, +int smdk4210_camera_send_command(struct camera_device *dev, int32_t cmd, int32_t arg1, int32_t arg2) { ALOGD("%s(%p, %d, %d, %d)", __func__, dev, cmd, arg1, arg2); @@ -2669,31 +2669,31 @@ int exynos_camera_send_command(struct camera_device *dev, return 0; } -void exynos_camera_release(struct camera_device *dev) +void smdk4210_camera_release(struct camera_device *dev) { - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, dev); if (dev == NULL || dev->priv == NULL) return; - exynos_camera = (struct exynos_camera *) dev->priv; + smdk4210_camera = (struct smdk4210_camera *) dev->priv; - if (exynos_camera->preview_memory != NULL && exynos_camera->preview_memory->release != NULL) { - exynos_camera->preview_memory->release(exynos_camera->preview_memory); - exynos_camera->preview_memory = NULL; + if (smdk4210_camera->preview_memory != NULL && smdk4210_camera->preview_memory->release != NULL) { + smdk4210_camera->preview_memory->release(smdk4210_camera->preview_memory); + smdk4210_camera->preview_memory = NULL; } - if (exynos_camera->picture_memory != NULL && exynos_camera->picture_memory->release != NULL) { - exynos_camera->picture_memory->release(exynos_camera->picture_memory); - exynos_camera->picture_memory = NULL; + if (smdk4210_camera->picture_memory != NULL && smdk4210_camera->picture_memory->release != NULL) { + smdk4210_camera->picture_memory->release(smdk4210_camera->picture_memory); + smdk4210_camera->picture_memory = NULL; } - exynos_camera_deinit(exynos_camera); + smdk4210_camera_deinit(smdk4210_camera); } -int exynos_camera_dump(struct camera_device *dev, int fd) +int smdk4210_camera_dump(struct camera_device *dev, int fd) { ALOGD("%s(%p, %d)", __func__, dev, fd); @@ -2704,36 +2704,36 @@ int exynos_camera_dump(struct camera_device *dev, int fd) * Interface */ -struct camera_device_ops exynos_camera_ops = { - .set_preview_window = exynos_camera_set_preview_window, - .set_callbacks = exynos_camera_set_callbacks, - .enable_msg_type = exynos_camera_enable_msg_type, - .disable_msg_type = exynos_camera_disable_msg_type, - .msg_type_enabled = exynos_camera_msg_type_enabled, - .start_preview = exynos_camera_start_preview, - .stop_preview = exynos_camera_stop_preview, - .preview_enabled = exynos_camera_preview_enabled, - .store_meta_data_in_buffers = exynos_camera_store_meta_data_in_buffers, - .start_recording = exynos_camera_start_recording, - .stop_recording = exynos_camera_stop_recording, - .recording_enabled = exynos_camera_recording_enabled, - .release_recording_frame = exynos_camera_release_recording_frame, - .auto_focus = exynos_camera_auto_focus, - .cancel_auto_focus = exynos_camera_cancel_auto_focus, - .take_picture = exynos_camera_take_picture, - .cancel_picture = exynos_camera_cancel_picture, - .set_parameters = exynos_camera_set_parameters, - .get_parameters = exynos_camera_get_parameters, - .put_parameters = exynos_camera_put_parameters, - .send_command = exynos_camera_send_command, - .release = exynos_camera_release, - .dump = exynos_camera_dump, +struct camera_device_ops smdk4210_camera_ops = { + .set_preview_window = smdk4210_camera_set_preview_window, + .set_callbacks = smdk4210_camera_set_callbacks, + .enable_msg_type = smdk4210_camera_enable_msg_type, + .disable_msg_type = smdk4210_camera_disable_msg_type, + .msg_type_enabled = smdk4210_camera_msg_type_enabled, + .start_preview = smdk4210_camera_start_preview, + .stop_preview = smdk4210_camera_stop_preview, + .preview_enabled = smdk4210_camera_preview_enabled, + .store_meta_data_in_buffers = smdk4210_camera_store_meta_data_in_buffers, + .start_recording = smdk4210_camera_start_recording, + .stop_recording = smdk4210_camera_stop_recording, + .recording_enabled = smdk4210_camera_recording_enabled, + .release_recording_frame = smdk4210_camera_release_recording_frame, + .auto_focus = smdk4210_camera_auto_focus, + .cancel_auto_focus = smdk4210_camera_cancel_auto_focus, + .take_picture = smdk4210_camera_take_picture, + .cancel_picture = smdk4210_camera_cancel_picture, + .set_parameters = smdk4210_camera_set_parameters, + .get_parameters = smdk4210_camera_get_parameters, + .put_parameters = smdk4210_camera_put_parameters, + .send_command = smdk4210_camera_send_command, + .release = smdk4210_camera_release, + .dump = smdk4210_camera_dump, }; -int exynos_camera_close(hw_device_t *device) +int smdk4210_camera_close(hw_device_t *device) { struct camera_device *camera_device; - struct exynos_camera *exynos_camera; + struct smdk4210_camera *smdk4210_camera; ALOGD("%s(%p)", __func__, device); @@ -2751,11 +2751,11 @@ int exynos_camera_close(hw_device_t *device) return 0; } -int exynos_camera_open(const struct hw_module_t* module, const char *camera_id, +int smdk4210_camera_open(const struct hw_module_t* module, const char *camera_id, struct hw_device_t** device) { struct camera_device *camera_device = NULL; - struct exynos_camera *exynos_camera = NULL; + struct smdk4210_camera *smdk4210_camera = NULL; int id; int rc; @@ -2768,17 +2768,17 @@ int exynos_camera_open(const struct hw_module_t* module, const char *camera_id, if (id < 0) return -EINVAL; - exynos_camera = calloc(1, sizeof(struct exynos_camera)); - exynos_camera->config = exynos_camera_config; + smdk4210_camera = calloc(1, sizeof(struct smdk4210_camera)); + smdk4210_camera->config = smdk4210_camera_config; - if (exynos_camera->config->presets_count > EXYNOS_CAMERA_MAX_PRESETS_COUNT || - exynos_camera->config->v4l2_nodes_count > EXYNOS_CAMERA_MAX_V4L2_NODES_COUNT) + if (smdk4210_camera->config->presets_count > SMDK4210_CAMERA_MAX_PRESETS_COUNT || + smdk4210_camera->config->v4l2_nodes_count > SMDK4210_CAMERA_MAX_V4L2_NODES_COUNT) goto error_preset; - if (id >= exynos_camera->config->presets_count) + if (id >= smdk4210_camera->config->presets_count) goto error_preset; - rc = exynos_camera_init(exynos_camera, id); + rc = smdk4210_camera_init(smdk4210_camera, id); if (rc < 0) { ALOGE("%s: Unable to init camera", __func__); goto error; @@ -2788,66 +2788,66 @@ int exynos_camera_open(const struct hw_module_t* module, const char *camera_id, 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 = exynos_camera_close; + camera_device->common.close = smdk4210_camera_close; - camera_device->ops = &exynos_camera_ops; - camera_device->priv = exynos_camera; + camera_device->ops = &smdk4210_camera_ops; + camera_device->priv = smdk4210_camera; *device = (struct hw_device_t *) &(camera_device->common); return 0; error: - exynos_camera_deinit(exynos_camera); + smdk4210_camera_deinit(smdk4210_camera); error_device: if (camera_device != NULL) free(camera_device); error_preset: - if (exynos_camera != NULL) - free(exynos_camera); + if (smdk4210_camera != NULL) + free(smdk4210_camera); return -1; } -int exynos_camera_get_number_of_cameras(void) +int smdk4210_camera_get_number_of_cameras(void) { ALOGD("%s()", __func__); - if (exynos_camera_config == NULL || exynos_camera_config->presets == NULL) { + if (smdk4210_camera_config == NULL || smdk4210_camera_config->presets == NULL) { ALOGE("%s: Unable to find proper camera config", __func__); return -1; } - return exynos_camera_config->presets_count; + return smdk4210_camera_config->presets_count; } -int exynos_camera_get_camera_info(int id, struct camera_info *info) +int smdk4210_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 (exynos_camera_config == NULL || exynos_camera_config->presets == NULL) { + if (smdk4210_camera_config == NULL || smdk4210_camera_config->presets == NULL) { ALOGE("%s: Unable to find proper camera config", __func__); return -1; } - if (id >= exynos_camera_config->presets_count) + if (id >= smdk4210_camera_config->presets_count) return -EINVAL; - ALOGD("Selected camera: %s", exynos_camera_config->presets[id].name); + ALOGD("Selected camera: %s", smdk4210_camera_config->presets[id].name); - info->facing = exynos_camera_config->presets[id].facing; - info->orientation = exynos_camera_config->presets[id].orientation; + info->facing = smdk4210_camera_config->presets[id].facing; + info->orientation = smdk4210_camera_config->presets[id].orientation; return 0; } -struct hw_module_methods_t exynos_camera_module_methods = { - .open = exynos_camera_open, +struct hw_module_methods_t smdk4210_camera_module_methods = { + .open = smdk4210_camera_open, }; struct camera_module HAL_MODULE_INFO_SYM = { @@ -2856,10 +2856,10 @@ struct camera_module HAL_MODULE_INFO_SYM = { .hal_api_version = HARDWARE_HAL_API_VERSION, .module_api_version = CAMERA_MODULE_API_VERSION_1_0, .id = CAMERA_HARDWARE_MODULE_ID, - .name = "Exynos Camera", + .name = "SMDK4210 Camera", .author = "Paul Kocialkowski", - .methods = &exynos_camera_module_methods, + .methods = &smdk4210_camera_module_methods, }, - .get_number_of_cameras = exynos_camera_get_number_of_cameras, - .get_camera_info = exynos_camera_get_camera_info, + .get_number_of_cameras = smdk4210_camera_get_number_of_cameras, + .get_camera_info = smdk4210_camera_get_camera_info, }; diff --git a/camera/smdk4210_camera.h b/camera/smdk4210_camera.h new file mode 100644 index 0000000..e6cf911 --- /dev/null +++ b/camera/smdk4210_camera.h @@ -0,0 +1,433 @@ +/* + * Copyright (C) 2013 Paul Kocialkowski + * + * 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 <stdlib.h> +#include <stdint.h> +#include <stdbool.h> +#include <pthread.h> + +#include <videodev2.h> +#include <videodev2_exynos_media.h> +#include <videodev2_exynos_camera.h> + +#include <Exif.h> + +#include <hardware/hardware.h> +#include <hardware/camera.h> + +#ifndef _SMDK4210_CAMERA_H_ +#define _SMDK4210_CAMERA_H_ + +#define SMDK4210_CAMERA_MAX_PRESETS_COUNT 2 +#define SMDK4210_CAMERA_MAX_V4L2_NODES_COUNT 4 +#define SMDK4210_CAMERA_MIN_BUFFERS_COUNT 3 +#define SMDK4210_CAMERA_MAX_BUFFERS_COUNT 8 + +#define SMDK4210_CAMERA_MSG_ENABLED(msg) \ + (smdk4210_camera->messages_enabled & msg) +#define SMDK4210_CAMERA_CALLBACK_DEFINED(cb) \ + (smdk4210_camera->callbacks.cb != NULL) + +/* + * Structures + */ + +struct list_head { + struct list_head *next; + struct list_head *prev; +}; + +enum smdk4210_param_type { + SMDK4210_PARAM_INT, + SMDK4210_PARAM_FLOAT, + SMDK4210_PARAM_STRING, +}; + +union smdk4210_param_data { + int integer; + float floating; + char *string; +}; + +struct smdk4210_param { + struct list_head list; + + char *key; + union smdk4210_param_data data; + enum smdk4210_param_type type; +}; + +struct smdk4210_camera_params { + char *preview_size_values; + char *preview_size; + char *preview_format_values; + char *preview_format; + char *preview_frame_rate_values; + int preview_frame_rate; + char *preview_fps_range_values; + char *preview_fps_range; + + char *picture_size_values; + char *picture_size; + char *picture_format_values; + char *picture_format; + char *jpeg_thumbnail_size_values; + int jpeg_thumbnail_width; + int jpeg_thumbnail_height; + int jpeg_thumbnail_quality; + int jpeg_quality; + + char *recording_size; + char *recording_size_values; + char *recording_format; + + char *focus_mode; + char *focus_mode_values; + char *focus_distances; + char *focus_areas; + int max_num_focus_areas; + + int zoom_supported; + int smooth_zoom_supported; + char *zoom_ratios; + int zoom; + int max_zoom; + + char *flash_mode; + char *flash_mode_values; + + int exposure_compensation; + float exposure_compensation_step; + int min_exposure_compensation; + int max_exposure_compensation; + + char *whitebalance; + char *whitebalance_values; + + char *scene_mode; + char *scene_mode_values; + + char *effect; + char *effect_values; + + char *iso; + char *iso_values; +}; + +struct smdk4210_camera_preset { + char *name; + int facing; + int orientation; + + int rotation; + int hflip; + int vflip; + + int picture_format; + + float focal_length; + float horizontal_view_angle; + float vertical_view_angle; + + int metering; + + struct smdk4210_camera_params params; +}; + +struct smdk4210_v4l2_node { + int id; + char *node; +}; + +struct exynox_camera_config { + struct smdk4210_camera_preset *presets; + int presets_count; + + struct smdk4210_v4l2_node *v4l2_nodes; + int v4l2_nodes_count; +}; + +struct smdk4210_camera_callbacks { + camera_notify_callback notify; + camera_data_callback data; + camera_data_timestamp_callback data_timestamp; + camera_request_memory request_memory; + void *user; +}; + +struct smdk4210_camera { + int v4l2_fds[SMDK4210_CAMERA_MAX_V4L2_NODES_COUNT]; + + struct exynox_camera_config *config; + struct smdk4210_param *params; + + struct smdk4210_camera_callbacks callbacks; + int messages_enabled; + + gralloc_module_t *gralloc; + + // Picture + pthread_t picture_thread; + pthread_mutex_t picture_mutex; + int picture_thread_running; + + int picture_enabled; + camera_memory_t *picture_memory; + int picture_buffer_length; + + // Auto-focus + pthread_t auto_focus_thread; + pthread_mutex_t auto_focus_mutex; + int auto_focus_thread_running; + + int auto_focus_enabled; + + // Preview + pthread_t preview_thread; + pthread_mutex_t preview_mutex; + pthread_mutex_t preview_lock_mutex; + int preview_thread_running; + + int preview_enabled; + struct preview_stream_ops *preview_window; + camera_memory_t *preview_memory; + int preview_buffers_count; + int preview_frame_size; + int preview_params_set; + + // Recording + pthread_mutex_t recording_mutex; + + int recording_enabled; + camera_memory_t *recording_memory; + int recording_buffers_count; + + // Camera params + int camera_rotation; + int camera_hflip; + int camera_vflip; + int camera_picture_format; + int camera_focal_length; + int camera_metering; + + int camera_sensor_mode; + + // Params + int preview_width; + int preview_height; + int preview_format; + float preview_format_bpp; + int preview_fps; + int picture_width; + int picture_height; + int picture_format; + int jpeg_thumbnail_width; + int jpeg_thumbnail_height; + int jpeg_thumbnail_quality; + int jpeg_quality; + int recording_width; + int recording_height; + int recording_format; + int focus_mode; + int focus_x; + int focus_y; + int zoom; + int flash_mode; + int exposure_compensation; + int whitebalance; + int scene_mode; + int effect; + int iso; + int metering; +}; + +struct smdk4210_camera_addrs { + unsigned int type; + unsigned int y; + unsigned int cbcr; + unsigned int index; + unsigned int reserved; +}; + +// This is because the linux header uses anonymous union +struct smdk4210_v4l2_ext_control { + __u32 id; + __u32 size; + __u32 reserved2[1]; + union { + __s32 value; + __s64 value64; + char *string; + } data; +} __attribute__ ((packed)); + +enum m5mo_af_status { + M5MO_AF_STATUS_FAIL = 0, + M5MO_AF_STATUS_IN_PROGRESS, + M5MO_AF_STATUS_SUCCESS, + M5MO_AF_STATUS_1ST_SUCCESS = 4, +}; + +/* + * Camera + */ + +int smdk4210_camera_params_init(struct smdk4210_camera *smdk4210_camera, int id); +int smdk4210_camera_params_apply(struct smdk4210_camera *smdk4210_camera); + +int smdk4210_camera_auto_focus_start(struct smdk4210_camera *smdk4210_camera); +void smdk4210_camera_auto_focus_stop(struct smdk4210_camera *smdk4210_camera); + +int smdk4210_camera_picture(struct smdk4210_camera *smdk4210_camera); +int smdk4210_camera_picture_start(struct smdk4210_camera *smdk4210_camera); + +int smdk4210_camera_preview(struct smdk4210_camera *smdk4210_camera); +int smdk4210_camera_preview_start(struct smdk4210_camera *smdk4210_camera); +void smdk4210_camera_preview_stop(struct smdk4210_camera *smdk4210_camera); + +/* + * EXIF + */ + +int smdk4210_exif_attributes_create_static(struct smdk4210_camera *smdk4210_camera, + exif_attribute_t *exif_attributes); +int smdk4210_exif_attributes_create_params(struct smdk4210_camera *smdk4210_camera, + exif_attribute_t *exif_attributes); + +int smdk4210_exif_create(struct smdk4210_camera *smdk4210_camera, + exif_attribute_t *exif_attributes, + camera_memory_t *jpeg_thumbnail_data_memory, int jpeg_thumbnail_size, + camera_memory_t **exif_data_memory_p, int *exif_size_p); + +/* + * Param + */ + +int smdk4210_param_int_get(struct smdk4210_camera *smdk4210_camera, + char *key); +float smdk4210_param_float_get(struct smdk4210_camera *smdk4210_camera, + char *key); +char *smdk4210_param_string_get(struct smdk4210_camera *smdk4210_camera, + char *key); + +int smdk4210_param_int_set(struct smdk4210_camera *smdk4210_camera, + char *key, int integer); +int smdk4210_param_float_set(struct smdk4210_camera *smdk4210_camera, + char *key, float floating); +int smdk4210_param_string_set(struct smdk4210_camera *smdk4210_camera, + char *key, char *string); + +char *smdk4210_params_string_get(struct smdk4210_camera *smdk4210_camera); +int smdk4210_params_string_set(struct smdk4210_camera *smdk4210_camera, char *string); + +/* + * V4L2 + */ + +// Utils +int smdk4210_v4l2_find_index(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_find_fd(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); + +// File ops +int smdk4210_v4l2_open(struct smdk4210_camera *smdk4210_camera, int id); +void smdk4210_v4l2_close(struct smdk4210_camera *smdk4210_camera, int id); +int smdk4210_v4l2_ioctl(struct smdk4210_camera *smdk4210_camera, int id, int request, void *data); +int smdk4210_v4l2_poll(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); + +// VIDIOC +int smdk4210_v4l2_qbuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int memory, int index); +int smdk4210_v4l2_qbuf_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int index); +int smdk4210_v4l2_qbuf_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int index); +int smdk4210_v4l2_dqbuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int memory); +int smdk4210_v4l2_dqbuf_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_dqbuf_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_reqbufs(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int memory, int count); +int smdk4210_v4l2_reqbufs_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int count); +int smdk4210_v4l2_reqbufs_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int count); +int smdk4210_v4l2_querybuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int memory, int index); +int smdk4210_v4l2_querybuf_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int index); +int smdk4210_v4l2_querybuf_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int index); +int smdk4210_v4l2_querycap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int flags); +int smdk4210_v4l2_querycap_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_querycap_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_streamon(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type); +int smdk4210_v4l2_streamon_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_streamon_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_streamoff(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type); +int smdk4210_v4l2_streamoff_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_streamoff_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id); +int smdk4210_v4l2_g_fmt(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int *width, int *height, int *fmt); +int smdk4210_v4l2_g_fmt_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int *width, int *height, int *fmt); +int smdk4210_v4l2_g_fmt_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int *width, int *height, int *fmt); +int smdk4210_v4l2_s_fmt_pix(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int width, int height, int fmt, int priv); +int smdk4210_v4l2_s_fmt_pix_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int width, int height, int fmt, int priv); +int smdk4210_v4l2_s_fmt_pix_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int width, int height, int fmt, int priv); +int smdk4210_v4l2_s_fmt_win(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int left, int top, int width, int height); +int smdk4210_v4l2_enum_fmt(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int fmt); +int smdk4210_v4l2_enum_fmt_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int fmt); +int smdk4210_v4l2_enum_fmt_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int fmt); +int smdk4210_v4l2_enum_input(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int id); +int smdk4210_v4l2_s_input(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int id); +int smdk4210_v4l2_g_ext_ctrls(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + struct v4l2_ext_control *control, int count); +int smdk4210_v4l2_g_ctrl(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int id, int *value); +int smdk4210_v4l2_s_ctrl(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int id, int value); +int smdk4210_v4l2_s_parm(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, struct v4l2_streamparm *streamparm); +int smdk4210_v4l2_s_parm_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + struct v4l2_streamparm *streamparm); +int smdk4210_v4l2_s_parm_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + struct v4l2_streamparm *streamparm); +int smdk4210_v4l2_s_crop(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int left, int top, int width, int height); +int smdk4210_v4l2_s_crop_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int left, int top, int width, int height); +int smdk4210_v4l2_s_crop_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int left, int top, int width, int height); +int smdk4210_v4l2_g_fbuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + void **base, int *width, int *height, int *fmt); +int smdk4210_v4l2_s_fbuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + void *base, int width, int height, int fmt); + +#endif diff --git a/camera/exynos_exif.c b/camera/smdk4210_exif.c index 80f3c8f..8ac8b8c 100644 --- a/camera/exynos_exif.c +++ b/camera/smdk4210_exif.c @@ -33,20 +33,20 @@ #include <Exif.h> -#define LOG_TAG "exynos_camera" +#define LOG_TAG "smdk4210_camera" #include <utils/Log.h> #include <cutils/properties.h> -#include "exynos_camera.h" +#include "smdk4210_camera.h" -int exynos_exif_attributes_create_static(struct exynos_camera *exynos_camera, +int smdk4210_exif_attributes_create_static(struct smdk4210_camera *smdk4210_camera, exif_attribute_t *exif_attributes) { unsigned char gps_version[] = { 0x02, 0x02, 0x00, 0x00 }; char property[PROPERTY_VALUE_MAX]; uint32_t av; - if (exynos_camera == NULL || exif_attributes == NULL) + if (smdk4210_camera == NULL || exif_attributes == NULL) return -EINVAL; // Device @@ -99,7 +99,7 @@ int exynos_exif_attributes_create_static(struct exynos_camera *exynos_camera, return 0; } -int exynos_exif_attributes_create_gps(struct exynos_camera *exynos_camera, +int smdk4210_exif_attributes_create_gps(struct smdk4210_camera *smdk4210_camera, exif_attribute_t *exif_attributes) { float gps_latitude_float, gps_longitude_float, gps_altitude_float; @@ -111,16 +111,16 @@ int exynos_exif_attributes_create_gps(struct exynos_camera *exynos_camera, struct tm time_info; - if (exynos_camera == NULL || exif_attributes == NULL) + if (smdk4210_camera == NULL || exif_attributes == NULL) return -EINVAL; - gps_latitude_float = exynos_param_float_get(exynos_camera, "gps-latitude"); - gps_longitude_float = exynos_param_float_get(exynos_camera, "gps-longitude"); - gps_altitude_float = exynos_param_float_get(exynos_camera, "gps-altitude"); + gps_latitude_float = smdk4210_param_float_get(smdk4210_camera, "gps-latitude"); + gps_longitude_float = smdk4210_param_float_get(smdk4210_camera, "gps-longitude"); + gps_altitude_float = smdk4210_param_float_get(smdk4210_camera, "gps-altitude"); if (gps_altitude_float == -1) - gps_altitude_float = (float) exynos_param_int_get(exynos_camera, "gps-altitude"); - gps_timestamp_int = exynos_param_int_get(exynos_camera, "gps-timestamp"); - gps_processing_method_string = exynos_param_string_get(exynos_camera, "gps-processing-method"); + gps_altitude_float = (float) smdk4210_param_int_get(smdk4210_camera, "gps-altitude"); + gps_timestamp_int = smdk4210_param_int_get(smdk4210_camera, "gps-timestamp"); + gps_processing_method_string = smdk4210_param_string_get(smdk4210_camera, "gps-processing-method"); if (gps_latitude_float == -1 || gps_longitude_float == -1 || gps_altitude_float == -1 || gps_timestamp_int <= 0 || @@ -192,7 +192,7 @@ int exynos_exif_attributes_create_gps(struct exynos_camera *exynos_camera, return 0; } -int exynos_exif_attributes_create_params(struct exynos_camera *exynos_camera, +int smdk4210_exif_attributes_create_params(struct smdk4210_camera *smdk4210_camera, exif_attribute_t *exif_attributes) { uint32_t av, tv, bv, sv, ev; @@ -207,20 +207,20 @@ int exynos_exif_attributes_create_params(struct exynos_camera *exynos_camera, int rc; - if (exynos_camera == NULL || exif_attributes == NULL) + if (smdk4210_camera == NULL || exif_attributes == NULL) return -EINVAL; // Picture size - exif_attributes->width = exynos_camera->picture_width; - exif_attributes->height = exynos_camera->picture_height; + exif_attributes->width = smdk4210_camera->picture_width; + exif_attributes->height = smdk4210_camera->picture_height; // Thumbnail - exif_attributes->widthThumb = exynos_camera->jpeg_thumbnail_width; - exif_attributes->heightThumb = exynos_camera->jpeg_thumbnail_height; + exif_attributes->widthThumb = smdk4210_camera->jpeg_thumbnail_width; + exif_attributes->heightThumb = smdk4210_camera->jpeg_thumbnail_height; exif_attributes->enableThumb = true; // Orientation - rotation = exynos_param_int_get(exynos_camera, "rotation"); + rotation = smdk4210_param_int_get(smdk4210_camera, "rotation"); switch (rotation) { case 90: exif_attributes->orientation = EXIF_ORIENTATION_90; @@ -243,11 +243,11 @@ int exynos_exif_attributes_create_params(struct exynos_camera *exynos_camera, strftime((char *) exif_attributes->date_time, sizeof(exif_attributes->date_time), "%Y:%m:%d %H:%M:%S", time_info); - exif_attributes->focal_length.num = exynos_camera->camera_focal_length; + exif_attributes->focal_length.num = smdk4210_camera->camera_focal_length; exif_attributes->focal_length.den = EXIF_DEF_FOCAL_LEN_DEN; shutter_speed = 100; - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_TV, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_EXIF_TV, &shutter_speed); if (rc < 0) ALOGE("%s: g ctrl failed!", __func__); @@ -258,28 +258,28 @@ int exynos_exif_attributes_create_params(struct exynos_camera *exynos_camera, exif_attributes->exposure_time.num = 1; exif_attributes->exposure_time.den = APEX_SHUTTER_TO_EXPOSURE(shutter_speed); - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_ISO, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_EXIF_ISO, &iso_speed); if (rc < 0) ALOGE("%s: g ctrl failed!", __func__); exif_attributes->iso_speed_rating = iso_speed; - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_FLASH, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_EXIF_FLASH, &flash_results); if (rc < 0) ALOGE("%s: g ctrl failed!", __func__); exif_attributes->flash = flash_results; - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_BV, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_EXIF_BV, (int *) &bv); if (rc < 0) { ALOGE("%s: g ctrl failed!", __func__); goto bv_static; } - rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_EBV, + rc = smdk4210_v4l2_g_ctrl(smdk4210_camera, 0, V4L2_CID_CAMERA_EXIF_EBV, (int *) &ev); if (rc < 0) { ALOGE("%s: g ctrl failed!", __func__); @@ -289,7 +289,7 @@ int exynos_exif_attributes_create_params(struct exynos_camera *exynos_camera, goto bv_ioctl; bv_static: - exposure = exynos_param_int_get(exynos_camera, "exposure-compensation"); + exposure = smdk4210_param_int_get(smdk4210_camera, "exposure-compensation"); if (exposure < 0) exposure = EV_DEFAULT; @@ -305,7 +305,7 @@ bv_ioctl: exif_attributes->brightness.num = bv; exif_attributes->brightness.den = EXIF_DEF_APEX_DEN; - if (exynos_camera->scene_mode == SCENE_MODE_BEACH_SNOW) { + if (smdk4210_camera->scene_mode == SCENE_MODE_BEACH_SNOW) { exif_attributes->exposure_bias.num = EXIF_DEF_APEX_DEN; exif_attributes->exposure_bias.den = EXIF_DEF_APEX_DEN; } else { @@ -313,7 +313,7 @@ bv_ioctl: exif_attributes->exposure_bias.den = EXIF_DEF_APEX_DEN; } - switch (exynos_camera->camera_metering) { + switch (smdk4210_camera->camera_metering) { case METERING_CENTER: exif_attributes->metering_mode = EXIF_METERING_CENTER; break; @@ -328,13 +328,13 @@ bv_ioctl: break; } - if (exynos_camera->whitebalance == WHITE_BALANCE_AUTO || - exynos_camera->whitebalance == WHITE_BALANCE_BASE) + if (smdk4210_camera->whitebalance == WHITE_BALANCE_AUTO || + smdk4210_camera->whitebalance == WHITE_BALANCE_BASE) exif_attributes->white_balance = EXIF_WB_AUTO; else exif_attributes->white_balance = EXIF_WB_MANUAL; - switch (exynos_camera->scene_mode) { + switch (smdk4210_camera->scene_mode) { case SCENE_MODE_PORTRAIT: exif_attributes->scene_capture_type = EXIF_SCENE_PORTRAIT; break; @@ -349,7 +349,7 @@ bv_ioctl: break; } - rc = exynos_exif_attributes_create_gps(exynos_camera, exif_attributes); + rc = smdk4210_exif_attributes_create_gps(smdk4210_camera, exif_attributes); if (rc < 0) { ALOGE("%s: Failed to create GPS attributes", __func__); return -1; @@ -358,7 +358,7 @@ bv_ioctl: return 0; } -int exynos_exif_write_data(void *exif_data, unsigned short tag, +int smdk4210_exif_write_data(void *exif_data, unsigned short tag, unsigned short type, unsigned int count, int *offset, void *start, void *data, int length) { @@ -394,7 +394,7 @@ int exynos_exif_write_data(void *exif_data, unsigned short tag, return size; } -int exynos_exif_create(struct exynos_camera *exynos_camera, +int smdk4210_exif_create(struct smdk4210_camera *smdk4210_camera, exif_attribute_t *exif_attributes, camera_memory_t *jpeg_thumbnail_data_memory, int jpeg_thumbnail_size, camera_memory_t **exif_data_memory_p, int *exif_size_p) @@ -425,15 +425,15 @@ int exynos_exif_create(struct exynos_camera *exynos_camera, unsigned int value; - if (exynos_camera == NULL || exif_attributes == NULL || + if (smdk4210_camera == NULL || exif_attributes == NULL || jpeg_thumbnail_data_memory == NULL || jpeg_thumbnail_size <= 0 || exif_data_memory_p == NULL || exif_size_p == NULL) return -EINVAL; exif_data_size = EXIF_FILE_SIZE + jpeg_thumbnail_size; - if (exynos_camera->callbacks.request_memory != NULL) { - exif_data_memory = exynos_camera->callbacks.request_memory(-1, + if (smdk4210_camera->callbacks.request_memory != NULL) { + exif_data_memory = smdk4210_camera->callbacks.request_memory(-1, exif_data_size, 1, 0); if (exif_data_memory == NULL) { ALOGE("%s: exif memory request failed!", __func__); @@ -473,42 +473,42 @@ int exynos_exif_create(struct exynos_camera *exynos_camera, offset = 8 + NUM_SIZE + value * IFD_SIZE + OFFSET_SIZE; // Write EXIF data - count = exynos_exif_write_data(pointer, EXIF_TAG_IMAGE_WIDTH, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG, 1, NULL, NULL, &exif_attributes->width, sizeof(exif_attributes->width)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_IMAGE_HEIGHT, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG, 1, NULL, NULL, &exif_attributes->height, sizeof(exif_attributes->height)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_MAKE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_MAKE, EXIF_TYPE_ASCII, strlen((char *) exif_attributes->maker) + 1, &offset, exif_ifd_start, &exif_attributes->maker, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_MODEL, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_MODEL, EXIF_TYPE_ASCII, strlen((char *) exif_attributes->model) + 1, &offset, exif_ifd_start, &exif_attributes->model, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_ORIENTATION, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->orientation, sizeof(exif_attributes->orientation)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_SOFTWARE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_SOFTWARE, EXIF_TYPE_ASCII, strlen((char *) exif_attributes->software) + 1, &offset, exif_ifd_start, &exif_attributes->software, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_DATE_TIME, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_DATE_TIME, EXIF_TYPE_ASCII, 20, &offset, exif_ifd_start, &exif_attributes->date_time, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_YCBCR_POSITIONING, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_YCBCR_POSITIONING, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->ycbcr_positioning, sizeof(exif_attributes->ycbcr_positioning)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_EXIF_IFD_POINTER, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_EXIF_IFD_POINTER, EXIF_TYPE_LONG, 1, NULL, NULL, &offset, sizeof(offset)); pointer += count; @@ -529,63 +529,63 @@ int exynos_exif_create(struct exynos_camera *exynos_camera, offset += NUM_SIZE + NUM_0TH_IFD_EXIF * IFD_SIZE + OFFSET_SIZE; - count = exynos_exif_write_data(pointer, EXIF_TAG_EXPOSURE_TIME, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_EXPOSURE_TIME, EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->exposure_time, sizeof(exif_attributes->exposure_time)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_FNUMBER, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_FNUMBER, EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->fnumber, sizeof(exif_attributes->fnumber)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_EXPOSURE_PROGRAM, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_EXPOSURE_PROGRAM, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->exposure_program, sizeof(exif_attributes->exposure_program)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_ISO_SPEED_RATING, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_ISO_SPEED_RATING, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->iso_speed_rating, sizeof(exif_attributes->iso_speed_rating)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_EXIF_VERSION, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_EXIF_VERSION, EXIF_TYPE_UNDEFINED, 4, NULL, NULL, &exif_attributes->exif_version, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_DATE_TIME_ORG, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_DATE_TIME_ORG, EXIF_TYPE_ASCII, 20, &offset, exif_ifd_start, &exif_attributes->date_time, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_DATE_TIME_DIGITIZE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_DATE_TIME_DIGITIZE, EXIF_TYPE_ASCII, 20, &offset, exif_ifd_start, &exif_attributes->date_time, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_SHUTTER_SPEED, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_SHUTTER_SPEED, EXIF_TYPE_SRATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->shutter_speed, sizeof(exif_attributes->shutter_speed)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_APERTURE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_APERTURE, EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->aperture, sizeof(exif_attributes->aperture)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_BRIGHTNESS, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_BRIGHTNESS, EXIF_TYPE_SRATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->brightness, sizeof(exif_attributes->brightness)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_EXPOSURE_BIAS, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_EXPOSURE_BIAS, EXIF_TYPE_SRATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->exposure_bias, sizeof(exif_attributes->exposure_bias)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_MAX_APERTURE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_MAX_APERTURE, EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->max_aperture, sizeof(exif_attributes->max_aperture)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_METERING_MODE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_METERING_MODE, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->metering_mode, sizeof(exif_attributes->metering_mode)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_FLASH, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_FLASH, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->flash, sizeof(exif_attributes->flash)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_FOCAL_LENGTH, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_FOCAL_LENGTH, EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->focal_length, sizeof(exif_attributes->focal_length)); pointer += count; @@ -593,31 +593,31 @@ int exynos_exif_create(struct exynos_camera *exynos_camera, memmove(exif_attributes->user_comment + sizeof(user_comment_code), exif_attributes->user_comment, value); memcpy(exif_attributes->user_comment, user_comment_code, sizeof(user_comment_code)); - count = exynos_exif_write_data(pointer, EXIF_TAG_USER_COMMENT, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_USER_COMMENT, EXIF_TYPE_UNDEFINED, value + sizeof(user_comment_code), &offset, exif_ifd_start, &exif_attributes->user_comment, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_COLOR_SPACE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_COLOR_SPACE, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->color_space, sizeof(exif_attributes->color_space)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_PIXEL_X_DIMENSION, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_PIXEL_X_DIMENSION, EXIF_TYPE_LONG, 1, NULL, NULL, &exif_attributes->width, sizeof(exif_attributes->width)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_PIXEL_Y_DIMENSION, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_PIXEL_Y_DIMENSION, EXIF_TYPE_LONG, 1, NULL, NULL, &exif_attributes->height, sizeof(exif_attributes->height)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_EXPOSURE_MODE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_EXPOSURE_MODE, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->exposure_mode, sizeof(exif_attributes->exposure_mode)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_WHITE_BALANCE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_WHITE_BALANCE, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->white_balance, sizeof(exif_attributes->white_balance)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_SCENCE_CAPTURE_TYPE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_SCENCE_CAPTURE_TYPE, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->scene_capture_type, sizeof(exif_attributes->scene_capture_type)); pointer += count; @@ -628,7 +628,7 @@ int exynos_exif_create(struct exynos_camera *exynos_camera, // GPS if (exif_attributes->enableGps) { pointer = (unsigned char *) exif_ifd_gps; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_IFD_POINTER, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_IFD_POINTER, EXIF_TYPE_LONG, 1, NULL, NULL, &offset, sizeof(offset)); pointer = exif_ifd_start + offset; @@ -643,35 +643,35 @@ int exynos_exif_create(struct exynos_camera *exynos_camera, offset += NUM_SIZE + value * IFD_SIZE + OFFSET_SIZE; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_VERSION_ID, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_VERSION_ID, EXIF_TYPE_BYTE, 4, NULL, NULL, &exif_attributes->gps_version_id, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_LATITUDE_REF, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_LATITUDE_REF, EXIF_TYPE_ASCII, 2, NULL, NULL, &exif_attributes->gps_latitude_ref, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_LATITUDE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_LATITUDE, EXIF_TYPE_RATIONAL, 3, &offset, exif_ifd_start, &exif_attributes->gps_latitude, sizeof(exif_attributes->gps_latitude[0])); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_LONGITUDE_REF, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_LONGITUDE_REF, EXIF_TYPE_ASCII, 2, NULL, NULL, &exif_attributes->gps_longitude_ref, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_LONGITUDE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_LONGITUDE, EXIF_TYPE_RATIONAL, 3, &offset, exif_ifd_start, &exif_attributes->gps_longitude, sizeof(exif_attributes->gps_longitude[0])); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_ALTITUDE_REF, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_ALTITUDE_REF, EXIF_TYPE_BYTE, 1, NULL, NULL, &exif_attributes->gps_altitude_ref, sizeof(char)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_ALTITUDE, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_ALTITUDE, EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->gps_altitude, sizeof(exif_attributes->gps_altitude)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_TIMESTAMP, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_TIMESTAMP, EXIF_TYPE_RATIONAL, 3, &offset, exif_ifd_start, &exif_attributes->gps_timestamp, sizeof(exif_attributes->gps_timestamp[0])); pointer += count; @@ -683,14 +683,14 @@ int exynos_exif_create(struct exynos_camera *exynos_camera, memcpy(data, &exif_ascii_prefix, sizeof(exif_ascii_prefix)); memcpy((void *) ((int) data + (int) sizeof(exif_ascii_prefix)), exif_attributes->gps_processing_method, value); - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_PROCESSING_METHOD, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_PROCESSING_METHOD, EXIF_TYPE_UNDEFINED, value + sizeof(exif_ascii_prefix), &offset, exif_ifd_start, data, sizeof(char)); pointer += count; free(data); } - count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_DATESTAMP, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_GPS_DATESTAMP, EXIF_TYPE_ASCII, 11, &offset, exif_ifd_start, &exif_attributes->gps_datestamp, 1); pointer += count; @@ -714,39 +714,39 @@ int exynos_exif_create(struct exynos_camera *exynos_camera, offset += NUM_SIZE + NUM_1TH_IFD_TIFF * IFD_SIZE + OFFSET_SIZE; - count = exynos_exif_write_data(pointer, EXIF_TAG_IMAGE_WIDTH, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG, 1, NULL, NULL, &exif_attributes->widthThumb, sizeof(exif_attributes->widthThumb)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_IMAGE_HEIGHT, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG, 1, NULL, NULL, &exif_attributes->heightThumb, sizeof(exif_attributes->heightThumb)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_COMPRESSION_SCHEME, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_COMPRESSION_SCHEME, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->compression_scheme, sizeof(exif_attributes->compression_scheme)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_ORIENTATION, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->orientation, sizeof(exif_attributes->orientation)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_X_RESOLUTION, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_X_RESOLUTION, EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->x_resolution, sizeof(exif_attributes->x_resolution)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_Y_RESOLUTION, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_Y_RESOLUTION, EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &exif_attributes->y_resolution, sizeof(exif_attributes->y_resolution)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_RESOLUTION_UNIT, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_RESOLUTION_UNIT, EXIF_TYPE_SHORT, 1, NULL, NULL, &exif_attributes->resolution_unit, sizeof(exif_attributes->resolution_unit)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_JPEG_INTERCHANGE_FORMAT, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_JPEG_INTERCHANGE_FORMAT, EXIF_TYPE_LONG, 1, NULL, NULL, &offset, sizeof(offset)); pointer += count; - count = exynos_exif_write_data(pointer, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN, + count = smdk4210_exif_write_data(pointer, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN, EXIF_TYPE_LONG, 1, NULL, NULL, &exif_thumb_size, sizeof(exif_thumb_size)); pointer += count; diff --git a/camera/exynos_param.c b/camera/smdk4210_param.c index 3de4036..c7745f9 100644 --- a/camera/exynos_param.c +++ b/camera/smdk4210_param.c @@ -22,10 +22,10 @@ #include <malloc.h> #include <ctype.h> -#define LOG_TAG "exynos_param" +#define LOG_TAG "smdk4210_param" #include <utils/Log.h> -#include "exynos_camera.h" +#include "smdk4210_camera.h" int list_head_insert(struct list_head *list, struct list_head *prev, struct list_head *next) @@ -55,29 +55,29 @@ void list_head_remove(struct list_head *list) list->prev->next = list->next; } -int exynos_param_register(struct exynos_camera *exynos_camera, char *key, - union exynos_param_data data, enum exynos_param_type type) +int smdk4210_param_register(struct smdk4210_camera *smdk4210_camera, char *key, + union smdk4210_param_data data, enum smdk4210_param_type type) { struct list_head *list_end; struct list_head *list; - struct exynos_param *param; + struct smdk4210_param *param; - if (exynos_camera == NULL || key == NULL) + if (smdk4210_camera == NULL || key == NULL) return -EINVAL; - param = (struct exynos_param *) calloc(1, sizeof(struct exynos_param)); + param = (struct smdk4210_param *) calloc(1, sizeof(struct smdk4210_param)); if (param == NULL) return -ENOMEM; param->key = strdup(key); switch (type) { - case EXYNOS_PARAM_INT: + case SMDK4210_PARAM_INT: param->data.integer = data.integer; break; - case EXYNOS_PARAM_FLOAT: + case SMDK4210_PARAM_FLOAT: param->data.floating = data.floating; break; - case EXYNOS_PARAM_STRING: + case SMDK4210_PARAM_STRING: param->data.string = strdup(data.string); break; default: @@ -86,15 +86,15 @@ int exynos_param_register(struct exynos_camera *exynos_camera, char *key, } param->type = type; - list_end = (struct list_head *) exynos_camera->params; + list_end = (struct list_head *) smdk4210_camera->params; while (list_end != NULL && list_end->next != NULL) list_end = list_end->next; list = (struct list_head *) param; list_head_insert(list, list_end, NULL); - if (exynos_camera->params == NULL) - exynos_camera->params = param; + if (smdk4210_camera->params == NULL) + smdk4210_camera->params = param; return 0; @@ -109,26 +109,26 @@ error: return -1; } -void exynos_param_unregister(struct exynos_camera *exynos_camera, - struct exynos_param *param) +void smdk4210_param_unregister(struct smdk4210_camera *smdk4210_camera, + struct smdk4210_param *param) { struct list_head *list; - if (exynos_camera == NULL || param == NULL) + if (smdk4210_camera == NULL || param == NULL) return; - list = (struct list_head *) exynos_camera->params; + list = (struct list_head *) smdk4210_camera->params; while (list != NULL) { if ((void *) list == (void *) param) { list_head_remove(list); - if ((void *) list == (void *) exynos_camera->params) - exynos_camera->params = (struct exynos_param *) list->next; + if ((void *) list == (void *) smdk4210_camera->params) + smdk4210_camera->params = (struct smdk4210_param *) list->next; - if (param->type == EXYNOS_PARAM_STRING && param->data.string != NULL) + if (param->type == SMDK4210_PARAM_STRING && param->data.string != NULL) free(param->data.string); - memset(param, 0, sizeof(struct exynos_param)); + memset(param, 0, sizeof(struct smdk4210_param)); free(param); break; @@ -139,18 +139,18 @@ list_continue: } } -struct exynos_param *exynos_param_find_key(struct exynos_camera *exynos_camera, +struct smdk4210_param *smdk4210_param_find_key(struct smdk4210_camera *smdk4210_camera, char *key) { - struct exynos_param *param; + struct smdk4210_param *param; struct list_head *list; - if (exynos_camera == NULL || key == NULL) + if (smdk4210_camera == NULL || key == NULL) return NULL; - list = (struct list_head *) exynos_camera->params; + list = (struct list_head *) smdk4210_camera->params; while (list != NULL) { - param = (struct exynos_param *) list; + param = (struct smdk4210_param *) list; if (param->key == NULL) goto list_continue; @@ -164,42 +164,42 @@ list_continue: return NULL; } -int exynos_param_data_set(struct exynos_camera *exynos_camera, char *key, - union exynos_param_data data, enum exynos_param_type type) +int smdk4210_param_data_set(struct smdk4210_camera *smdk4210_camera, char *key, + union smdk4210_param_data data, enum smdk4210_param_type type) { - struct exynos_param *param; + struct smdk4210_param *param; - if (exynos_camera == NULL || key == NULL) + if (smdk4210_camera == NULL || key == NULL) return -EINVAL; if (strchr(key, '=') || strchr(key, ';')) return -EINVAL; - if (type == EXYNOS_PARAM_STRING && data.string != NULL && + if (type == SMDK4210_PARAM_STRING && data.string != NULL && (strchr(data.string, '=') || strchr(data.string, ';'))) return -EINVAL; - param = exynos_param_find_key(exynos_camera, key); + param = smdk4210_param_find_key(smdk4210_camera, key); if (param == NULL) { // The key isn't in the list yet - exynos_param_register(exynos_camera, key, data, type); + smdk4210_param_register(smdk4210_camera, key, data, type); return 0; } if (param->type != type) ALOGE("%s: Mismatching types for key %s", __func__, key); - if (param->type == EXYNOS_PARAM_STRING && param->data.string != NULL) + if (param->type == SMDK4210_PARAM_STRING && param->data.string != NULL) free(param->data.string); switch (type) { - case EXYNOS_PARAM_INT: + case SMDK4210_PARAM_INT: param->data.integer = data.integer; break; - case EXYNOS_PARAM_FLOAT: + case SMDK4210_PARAM_FLOAT: param->data.floating = data.floating; break; - case EXYNOS_PARAM_STRING: + case SMDK4210_PARAM_STRING: param->data.string = strdup(data.string); break; default: @@ -211,15 +211,15 @@ int exynos_param_data_set(struct exynos_camera *exynos_camera, char *key, return 0; } -int exynos_param_data_get(struct exynos_camera *exynos_camera, char *key, - union exynos_param_data *data, enum exynos_param_type type) +int smdk4210_param_data_get(struct smdk4210_camera *smdk4210_camera, char *key, + union smdk4210_param_data *data, enum smdk4210_param_type type) { - struct exynos_param *param; + struct smdk4210_param *param; - if (exynos_camera == NULL || key == NULL || data == NULL) + if (smdk4210_camera == NULL || key == NULL || data == NULL) return -EINVAL; - param = exynos_param_find_key(exynos_camera, key); + param = smdk4210_param_find_key(smdk4210_camera, key); if (param == NULL || param->type != type) return -1; @@ -228,16 +228,16 @@ int exynos_param_data_get(struct exynos_camera *exynos_camera, char *key, return 0; } -int exynos_param_int_get(struct exynos_camera *exynos_camera, +int smdk4210_param_int_get(struct smdk4210_camera *smdk4210_camera, char *key) { - union exynos_param_data data; + union smdk4210_param_data data; int rc; - if (exynos_camera == NULL || key == NULL) + if (smdk4210_camera == NULL || key == NULL) return -EINVAL; - rc = exynos_param_data_get(exynos_camera, key, &data, EXYNOS_PARAM_INT); + rc = smdk4210_param_data_get(smdk4210_camera, key, &data, SMDK4210_PARAM_INT); if (rc < 0) { ALOGE("%s: Unable to get data for key %s", __func__, key); return -1; @@ -246,16 +246,16 @@ int exynos_param_int_get(struct exynos_camera *exynos_camera, return data.integer; } -float exynos_param_float_get(struct exynos_camera *exynos_camera, +float smdk4210_param_float_get(struct smdk4210_camera *smdk4210_camera, char *key) { - union exynos_param_data data; + union smdk4210_param_data data; int rc; - if (exynos_camera == NULL || key == NULL) + if (smdk4210_camera == NULL || key == NULL) return -EINVAL; - rc = exynos_param_data_get(exynos_camera, key, &data, EXYNOS_PARAM_FLOAT); + rc = smdk4210_param_data_get(smdk4210_camera, key, &data, SMDK4210_PARAM_FLOAT); if (rc < 0) { ALOGE("%s: Unable to get data for key %s", __func__, key); return -1; @@ -264,16 +264,16 @@ float exynos_param_float_get(struct exynos_camera *exynos_camera, return data.floating; } -char *exynos_param_string_get(struct exynos_camera *exynos_camera, +char *smdk4210_param_string_get(struct smdk4210_camera *smdk4210_camera, char *key) { - union exynos_param_data data; + union smdk4210_param_data data; int rc; - if (exynos_camera == NULL || key == NULL) + if (smdk4210_camera == NULL || key == NULL) return NULL; - rc = exynos_param_data_get(exynos_camera, key, &data, EXYNOS_PARAM_STRING); + rc = smdk4210_param_data_get(smdk4210_camera, key, &data, SMDK4210_PARAM_STRING); if (rc < 0) { ALOGE("%s: Unable to get data for key %s", __func__, key); return NULL; @@ -282,18 +282,18 @@ char *exynos_param_string_get(struct exynos_camera *exynos_camera, return data.string; } -int exynos_param_int_set(struct exynos_camera *exynos_camera, +int smdk4210_param_int_set(struct smdk4210_camera *smdk4210_camera, char *key, int integer) { - union exynos_param_data data; + union smdk4210_param_data data; int rc; - if (exynos_camera == NULL || key == NULL) + if (smdk4210_camera == NULL || key == NULL) return -EINVAL; data.integer = integer; - rc = exynos_param_data_set(exynos_camera, key, data, EXYNOS_PARAM_INT); + rc = smdk4210_param_data_set(smdk4210_camera, key, data, SMDK4210_PARAM_INT); if (rc < 0) { ALOGE("%s: Unable to set data for key %s", __func__, key); return -1; @@ -302,18 +302,18 @@ int exynos_param_int_set(struct exynos_camera *exynos_camera, return 0; } -int exynos_param_float_set(struct exynos_camera *exynos_camera, +int smdk4210_param_float_set(struct smdk4210_camera *smdk4210_camera, char *key, float floating) { - union exynos_param_data data; + union smdk4210_param_data data; int rc; - if (exynos_camera == NULL || key == NULL) + if (smdk4210_camera == NULL || key == NULL) return -EINVAL; data.floating = floating; - rc = exynos_param_data_set(exynos_camera, key, data, EXYNOS_PARAM_FLOAT); + rc = smdk4210_param_data_set(smdk4210_camera, key, data, SMDK4210_PARAM_FLOAT); if (rc < 0) { ALOGE("%s: Unable to set data for key %s", __func__, key); return -1; @@ -322,18 +322,18 @@ int exynos_param_float_set(struct exynos_camera *exynos_camera, return 0; } -int exynos_param_string_set(struct exynos_camera *exynos_camera, +int smdk4210_param_string_set(struct smdk4210_camera *smdk4210_camera, char *key, char *string) { - union exynos_param_data data; + union smdk4210_param_data data; int rc; - if (exynos_camera == NULL || key == NULL || string == NULL) + if (smdk4210_camera == NULL || key == NULL || string == NULL) return -EINVAL; data.string = string; - rc = exynos_param_data_set(exynos_camera, key, data, EXYNOS_PARAM_STRING); + rc = smdk4210_param_data_set(smdk4210_camera, key, data, SMDK4210_PARAM_STRING); if (rc < 0) { ALOGE("%s: Unable to set data for key %s", __func__, key); return -1; @@ -342,21 +342,21 @@ int exynos_param_string_set(struct exynos_camera *exynos_camera, return 0; } -char *exynos_params_string_get(struct exynos_camera *exynos_camera) +char *smdk4210_params_string_get(struct smdk4210_camera *smdk4210_camera) { - struct exynos_param *param; + struct smdk4210_param *param; struct list_head *list; char *string = NULL; char *s = NULL; int length = 0; int l = 0; - if (exynos_camera == NULL) + if (smdk4210_camera == NULL) return NULL; - list = (struct list_head *) exynos_camera->params; + list = (struct list_head *) smdk4210_camera->params; while (list != NULL) { - param = (struct exynos_param *) list; + param = (struct smdk4210_param *) list; if (param->key == NULL) goto list_continue_length; @@ -364,11 +364,11 @@ char *exynos_params_string_get(struct exynos_camera *exynos_camera) length++; switch (param->type) { - case EXYNOS_PARAM_INT: - case EXYNOS_PARAM_FLOAT: + case SMDK4210_PARAM_INT: + case SMDK4210_PARAM_FLOAT: length += 16; break; - case EXYNOS_PARAM_STRING: + case SMDK4210_PARAM_STRING: length += strlen(param->data.string); break; default: @@ -388,9 +388,9 @@ list_continue_length: string = calloc(1, length); s = string; - list = (struct list_head *) exynos_camera->params; + list = (struct list_head *) smdk4210_camera->params; while (list != NULL) { - param = (struct exynos_param *) list; + param = (struct smdk4210_param *) list; if (param->key == NULL) goto list_continue; @@ -398,15 +398,15 @@ list_continue_length: s += l; switch (param->type) { - case EXYNOS_PARAM_INT: + case SMDK4210_PARAM_INT: l = snprintf(s, 16, "%d", param->data.integer); s += l; break; - case EXYNOS_PARAM_FLOAT: + case SMDK4210_PARAM_FLOAT: l = snprintf(s, 16, "%g", param->data.floating); s += l; break; - case EXYNOS_PARAM_STRING: + case SMDK4210_PARAM_STRING: l = sprintf(s, "%s", param->data.string); s += l; break; @@ -430,10 +430,10 @@ list_continue: return string; } -int exynos_params_string_set(struct exynos_camera *exynos_camera, char *string) +int smdk4210_params_string_set(struct smdk4210_camera *smdk4210_camera, char *string) { - union exynos_param_data data; - enum exynos_param_type type; + union smdk4210_param_data data; + enum smdk4210_param_type type; char *d = NULL; char *s = NULL; @@ -446,7 +446,7 @@ int exynos_params_string_set(struct exynos_camera *exynos_camera, char *string) int rc; int i; - if (exynos_camera == NULL || string == NULL) + if (smdk4210_camera == NULL || string == NULL) return -1; d = strdup(string); @@ -466,28 +466,28 @@ int exynos_params_string_set(struct exynos_camera *exynos_camera, char *string) k = value; if (isdigit(k[0]) || k[0] == '-') { - type = EXYNOS_PARAM_INT; + type = SMDK4210_PARAM_INT; for (i=1 ; k[i] != '\0' ; i++) { if (k[i] == '.') { - type = EXYNOS_PARAM_FLOAT; + type = SMDK4210_PARAM_FLOAT; } else if (!isdigit(k[i])) { - type = EXYNOS_PARAM_STRING; + type = SMDK4210_PARAM_STRING; break; } } } else { - type = EXYNOS_PARAM_STRING; + type = SMDK4210_PARAM_STRING; } switch (type) { - case EXYNOS_PARAM_INT: + case SMDK4210_PARAM_INT: data.integer = atoi(value); break; - case EXYNOS_PARAM_FLOAT: + case SMDK4210_PARAM_FLOAT: data.floating = atof(value); break; - case EXYNOS_PARAM_STRING: + case SMDK4210_PARAM_STRING: data.string = value; break; default: @@ -495,7 +495,7 @@ int exynos_params_string_set(struct exynos_camera *exynos_camera, char *string) goto error; } - rc = exynos_param_data_set(exynos_camera, key, data, type); + rc = smdk4210_param_data_set(smdk4210_camera, key, data, type); if (rc < 0) { ALOGE("%s: Unable to set data for key %s", __func__, key); goto error; diff --git a/camera/smdk4210_v4l2.c b/camera/smdk4210_v4l2.c new file mode 100644 index 0000000..19e14b7 --- /dev/null +++ b/camera/smdk4210_v4l2.c @@ -0,0 +1,796 @@ +/* + * Copyright (C) 2013 Paul Kocialkowski + * + * 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 <errno.h> +#include <malloc.h> +#include <poll.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 "smdk4210_v4l2" +#include <utils/Log.h> + +#include "smdk4210_camera.h" + +/* + * Utils + */ + +int smdk4210_v4l2_find_index(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + int index; + int i; + + if (smdk4210_camera == NULL || smdk4210_camera->config == NULL || + smdk4210_camera->config->v4l2_nodes == NULL) + return -EINVAL; + + if (smdk4210_v4l2_id > smdk4210_camera->config->v4l2_nodes_count) + return -1; + + index = -1; + for (i = 0; i < smdk4210_camera->config->v4l2_nodes_count; i++) { + if (smdk4210_camera->config->v4l2_nodes[i].id == smdk4210_v4l2_id && + smdk4210_camera->config->v4l2_nodes[i].node != NULL) { + index = i; + } + } + + return index; +} + +int smdk4210_v4l2_find_fd(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + int index; + + if (smdk4210_camera == NULL) + return -EINVAL; + + index = smdk4210_v4l2_find_index(smdk4210_camera, smdk4210_v4l2_id); + if (index < 0) + return -1; + + return smdk4210_camera->v4l2_fds[index]; +} + +/* + * File ops + */ + +int smdk4210_v4l2_open(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + char *node; + int index; + int fd; + + if (smdk4210_camera == NULL || smdk4210_camera->config == NULL || + smdk4210_camera->config->v4l2_nodes == NULL) + return -EINVAL; + + index = smdk4210_v4l2_find_index(smdk4210_camera, smdk4210_v4l2_id); + if (index < 0) { + ALOGE("%s: Unable to find v4l2 node #%d", __func__, smdk4210_v4l2_id); + return -1; + } + + node = smdk4210_camera->config->v4l2_nodes[index].node; + fd = open(node, O_RDWR); + if (fd < 0) { + ALOGE("%s: Unable to open v4l2 node #%d", __func__, smdk4210_v4l2_id); + return -1; + } + + smdk4210_camera->v4l2_fds[index] = fd; + + return 0; +} + +void smdk4210_v4l2_close(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + int index; + + if (smdk4210_camera == NULL || smdk4210_camera->config == NULL || + smdk4210_camera->config->v4l2_nodes == NULL) + return; + + index = smdk4210_v4l2_find_index(smdk4210_camera, smdk4210_v4l2_id); + if (index < 0) { + ALOGE("%s: Unable to find v4l2 node #%d", __func__, smdk4210_v4l2_id); + return; + } + + if (smdk4210_camera->v4l2_fds[index] > 0) + close(smdk4210_camera->v4l2_fds[index]); + + smdk4210_camera->v4l2_fds[index] = -1; +} + +int smdk4210_v4l2_ioctl(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int request, void *data) +{ + int fd; + + if (smdk4210_camera == NULL) + return -EINVAL; + + fd = smdk4210_v4l2_find_fd(smdk4210_camera, smdk4210_v4l2_id); + if (fd < 0) { + ALOGE("%s: Unable to find v4l2 fd #%d", __func__, smdk4210_v4l2_id); + return -1; + } + + return ioctl(fd, request, data); +} + +int smdk4210_v4l2_poll(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + struct pollfd events; + int fd; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + fd = smdk4210_v4l2_find_fd(smdk4210_camera, smdk4210_v4l2_id); + if (fd < 0) { + ALOGE("%s: Unable to find v4l2 fd #%d", __func__, smdk4210_v4l2_id); + return -1; + } + + memset(&events, 0, sizeof(events)); + events.fd = fd; + events.events = POLLIN | POLLERR; + + rc = poll(&events, 1, 1000); + if (rc < 0 || events.revents & POLLERR) { + ALOGE("%s: poll failed", __func__); + return -1; + } + + return rc; +} + +/* + * VIDIOC + */ + +int smdk4210_v4l2_qbuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int memory, int index) +{ + struct v4l2_buffer buffer; + int rc; + + if (smdk4210_camera == NULL || index < 0) + return -EINVAL; + + buffer.type = type; + buffer.memory = memory; + buffer.index = index; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_QBUF, &buffer); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_qbuf_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int index) +{ + return smdk4210_v4l2_qbuf(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + V4L2_MEMORY_MMAP, index); +} + +int smdk4210_v4l2_qbuf_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int index) +{ + return smdk4210_v4l2_qbuf(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + V4L2_MEMORY_USERPTR, index); +} + +int smdk4210_v4l2_dqbuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int memory) +{ + struct v4l2_buffer buffer; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + memset(&buffer, 0, sizeof(buffer)); + buffer.type = type; + buffer.memory = memory; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_DQBUF, &buffer); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return buffer.index; +} + +int smdk4210_v4l2_dqbuf_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + return smdk4210_v4l2_dqbuf(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + V4L2_MEMORY_MMAP); +} + +int smdk4210_v4l2_dqbuf_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + return smdk4210_v4l2_dqbuf(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + V4L2_MEMORY_USERPTR); +} + +int smdk4210_v4l2_reqbufs(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int memory, int count) +{ + struct v4l2_requestbuffers requestbuffers; + int rc; + + if (smdk4210_camera == NULL || count < 0) + return -EINVAL; + + requestbuffers.type = type; + requestbuffers.count = count; + requestbuffers.memory = memory; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_REQBUFS, &requestbuffers); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return requestbuffers.count; +} + +int smdk4210_v4l2_reqbufs_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int count) +{ + return smdk4210_v4l2_reqbufs(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + V4L2_MEMORY_MMAP, count); +} + +int smdk4210_v4l2_reqbufs_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int count) +{ + return smdk4210_v4l2_reqbufs(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + V4L2_MEMORY_USERPTR, count); +} + +int smdk4210_v4l2_querybuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int memory, int index) +{ + struct v4l2_buffer buffer; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + memset(&buffer, 0, sizeof(buffer)); + buffer.type = type; + buffer.memory = memory; + buffer.index = index; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_QUERYBUF, &buffer); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return buffer.length; +} + +int smdk4210_v4l2_querybuf_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int index) +{ + return smdk4210_v4l2_querybuf(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + V4L2_MEMORY_MMAP, index); +} + +int smdk4210_v4l2_querybuf_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int index) +{ + return smdk4210_v4l2_querybuf(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + V4L2_MEMORY_USERPTR, index); +} + +int smdk4210_v4l2_querycap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int flags) +{ + struct v4l2_capability cap; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_QUERYCAP, &cap); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + if (!(cap.capabilities & flags)) + return -1; + + return 0; +} + +int smdk4210_v4l2_querycap_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + return smdk4210_v4l2_querycap(smdk4210_camera, smdk4210_v4l2_id, V4L2_CAP_VIDEO_CAPTURE); +} + +int smdk4210_v4l2_querycap_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + return smdk4210_v4l2_querycap(smdk4210_camera, smdk4210_v4l2_id, V4L2_CAP_VIDEO_OUTPUT); +} + +int smdk4210_v4l2_streamon(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type) +{ + enum v4l2_buf_type buf_type; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + buf_type = type; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_STREAMON, &buf_type); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_streamon_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + return smdk4210_v4l2_streamon(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE); +} + +int smdk4210_v4l2_streamon_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + return smdk4210_v4l2_streamon(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT); +} + +int smdk4210_v4l2_streamoff(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type) +{ + enum v4l2_buf_type buf_type; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + buf_type = type; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_STREAMOFF, &buf_type); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_streamoff_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + return smdk4210_v4l2_streamoff(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE); +} + +int smdk4210_v4l2_streamoff_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id) +{ + return smdk4210_v4l2_streamoff(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT); +} + +int smdk4210_v4l2_g_fmt(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int *width, int *height, int *fmt) +{ + struct v4l2_format format; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + format.type = type; + format.fmt.pix.field = V4L2_FIELD_NONE; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_G_FMT, &format); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + if (width != NULL) + *width = format.fmt.pix.width; + if (height != NULL) + *height = format.fmt.pix.height; + if (fmt != NULL) + *fmt = format.fmt.pix.pixelformat; + + return 0; +} + +int smdk4210_v4l2_g_fmt_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int *width, int *height, int *fmt) +{ + return smdk4210_v4l2_g_fmt(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + width, height, fmt); +} + +int smdk4210_v4l2_g_fmt_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int *width, int *height, int *fmt) +{ + return smdk4210_v4l2_g_fmt(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + width, height, fmt); +} + +int smdk4210_v4l2_s_fmt_pix(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int width, int height, int fmt, int priv) +{ + struct v4l2_format format; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + memset(&format, 0, sizeof(format)); + format.type = type; + format.fmt.pix.width = width; + format.fmt.pix.height = height; + format.fmt.pix.pixelformat = fmt; + format.fmt.pix.field = V4L2_FIELD_NONE; + format.fmt.pix.priv = priv; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_S_FMT, &format); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_s_fmt_pix_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int width, int height, int fmt, int priv) +{ + return smdk4210_v4l2_s_fmt_pix(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + width, height, fmt, priv); +} + +int smdk4210_v4l2_s_fmt_pix_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int width, int height, int fmt, int priv) +{ + return smdk4210_v4l2_s_fmt_pix(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + width, height, fmt, priv); +} + +int smdk4210_v4l2_s_fmt_win(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int left, int top, int width, int height) +{ + struct v4l2_format format; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + memset(&format, 0, sizeof(format)); + format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; + format.fmt.win.w.left = left; + format.fmt.win.w.top = top; + format.fmt.win.w.width = width; + format.fmt.win.w.height = height; + + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_S_FMT, &format); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_enum_fmt(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int fmt) +{ + struct v4l2_fmtdesc fmtdesc; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + fmtdesc.type = type; + fmtdesc.index = 0; + + do { + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_ENUM_FMT, &fmtdesc); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + if (fmtdesc.pixelformat == (unsigned int) fmt) + return 0; + + fmtdesc.index++; + } while (rc >= 0); + + return -1; +} + +int smdk4210_v4l2_enum_fmt_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int fmt) +{ + return smdk4210_v4l2_enum_fmt(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + fmt); +} + +int smdk4210_v4l2_enum_fmt_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int fmt) +{ + return smdk4210_v4l2_enum_fmt(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + fmt); +} + +int smdk4210_v4l2_enum_input(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int id) +{ + struct v4l2_input input; + int rc; + + if (smdk4210_camera == NULL || id < 0) + return -EINVAL; + + input.index = id; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_ENUMINPUT, &input); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + if (input.name[0] == '\0') + return -1; + + return 0; +} + +int smdk4210_v4l2_s_input(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int id) +{ + struct v4l2_input input; + int rc; + + if (smdk4210_camera == NULL || id < 0) + return -EINVAL; + + input.index = id; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_S_INPUT, &input); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_g_ext_ctrls(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + struct v4l2_ext_control *control, int count) +{ + struct v4l2_ext_controls controls; + int rc; + + if (smdk4210_camera == NULL || control == NULL) + return -EINVAL; + + memset(&controls, 0, sizeof(controls)); + controls.ctrl_class = V4L2_CTRL_CLASS_CAMERA; + controls.count = count; + controls.controls = control; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_G_EXT_CTRLS, &controls); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_g_ctrl(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int id, int *value) +{ + struct v4l2_control control; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + control.id = id; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_G_CTRL, &control); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + if (value != NULL) + *value = control.value; + + return 0; +} + +int smdk4210_v4l2_s_ctrl(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int id, int value) +{ + struct v4l2_control control; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + control.id = id; + control.value = value; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_S_CTRL, &control); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return control.value; +} + +int smdk4210_v4l2_s_parm(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, struct v4l2_streamparm *streamparm) +{ + int rc; + + if (smdk4210_camera == NULL || streamparm == NULL) + return -EINVAL; + + streamparm->type = type; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_S_PARM, streamparm); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_s_parm_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + struct v4l2_streamparm *streamparm) +{ + return smdk4210_v4l2_s_parm(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + streamparm); +} + +int smdk4210_v4l2_s_parm_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + struct v4l2_streamparm *streamparm) +{ + return smdk4210_v4l2_s_parm(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + streamparm); +} + +int smdk4210_v4l2_s_crop(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int type, int left, int top, int width, int height) +{ + struct v4l2_crop crop; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + crop.type = type; + crop.c.left = left; + crop.c.top = top; + crop.c.width = width; + crop.c.height = height; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_S_CROP, &crop); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} + +int smdk4210_v4l2_s_crop_cap(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int left, int top, int width, int height) +{ + return smdk4210_v4l2_s_crop(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE, + left, top, width, height); +} + +int smdk4210_v4l2_s_crop_out(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + int left, int top, int width, int height) +{ + return smdk4210_v4l2_s_crop(smdk4210_camera, smdk4210_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT, + left, top, width, height); +} + +int smdk4210_v4l2_g_fbuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + void **base, int *width, int *height, int *fmt) +{ + struct v4l2_framebuffer framebuffer; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_G_FBUF, &framebuffer); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + if (base != NULL) + *base = framebuffer.base; + if (width != NULL) + *width = framebuffer.fmt.width; + if (height != NULL) + *height = framebuffer.fmt.height; + if (fmt != NULL) + *fmt = framebuffer.fmt.pixelformat; + + return 0; +} + +int smdk4210_v4l2_s_fbuf(struct smdk4210_camera *smdk4210_camera, int smdk4210_v4l2_id, + void *base, int width, int height, int fmt) +{ + struct v4l2_framebuffer framebuffer; + int rc; + + if (smdk4210_camera == NULL) + return -EINVAL; + + memset(&framebuffer, 0, sizeof(framebuffer)); + framebuffer.base = base; + framebuffer.fmt.width = width; + framebuffer.fmt.height = height; + framebuffer.fmt.pixelformat = fmt; + + rc = smdk4210_v4l2_ioctl(smdk4210_camera, smdk4210_v4l2_id, VIDIOC_S_FBUF, &framebuffer); + if (rc < 0) { + ALOGE("%s: ioctl failed", __func__); + return -1; + } + + return 0; +} |