#include "gstv4l2camvidorient.h"
#include <mfld_cam.h>
-#include "exifmakernote_main.h"
-#include "exifmakernote_util.h"
-
#define MFLD_ADVCI_PATH "/usr/lib/"
-#define MFLD_V4L2CAMSRC_VERSION "c0b0c2804fa1e21f68ade84a5b403e4cb7f990bd"
+#define MFLD_V4L2CAMSRC_VERSION "85de990a519ae021f0bf4ec89c0e352ec76f6965"
+#define FOCUS_POSITION_MIN 0
+#define FOCUS_POSITION_MAX 512
GST_DEBUG_CATEGORY (gst_v4l2camsrc_debug);
#define GST_CAT_DEFAULT gst_v4l2camsrc_debug
static gboolean gst_v4l2camsrc_unlock (GstCameraSrc * src);
static gboolean gst_v4l2camsrc_unlock_stop (GstCameraSrc * src);
static gboolean gst_v4l2camsrc_set_zoom (GstCameraSrc * camsrc, gfloat zoom);
+static gboolean gst_v4l2camsrc_set_ae_mode (GstCameraSrc * camsrc, int mode);
+static gboolean gst_v4l2camsrc_get_ae_mode (GstCameraSrc * camsrc, int *mode);
+
static gboolean gst_v4l2camsrc_iface_supported (GstImplementsInterface * iface,
GType iface_type);
-static gboolean gst_v4l2camsrc_get_makernote (GstCameraSrc * camsrc, void *buf);
+static gboolean gst_v4l2camsrc_get_makernote (GstCameraSrc * camsrc, unsigned char *buf, unsigned size);
static gboolean gst_v4l2camsrc_makernote_init(GstCameraSrc * camsrc,
unsigned * buf_size,
unsigned num_afwindows,
PROP_USE_COPY,
PROP_AE,
PROP_AE_METERING_MODE,
+ PROP_AE_WINDOW,
+ PROP_AE_MODE,
PROP_AF,
+ PROP_AF_METERING_MODE,
+ PROP_AF_WINDOW,
PROP_AWB,
PROP_STILL_AF,
PROP_FOCUS_POSITION,
+ PROP_VFLIP,
+ PROP_HFLIP,
PROP_BAYER_DOWNSCALING,
PROP_CAPTURE_CORRECTION_GDC,
PROP_CAPTURE_CORRECTION_CAC,
PROP_CAPTURE_CORRECTION_BRIGHTNESS,
PROP_DUMP_RAW,
PROP_DUMP_IMAGE,
+ PROP_DEBUG_FLAGS,
+ PROP_DISABLE_LOW_RES_CROP,
+ PROP_DRAW_CORNER_MARKERS,
} GstV4L2CamSrcProperties;
#define DEFAULT_PROP_DEVICE_NAME NULL
#define DEFAULT_PROP_DEVICE "/dev/video0"
#define DEFAULT_PROP_DEVICE_FD -1
+#define DEFAULT_PROP_AE_WINDOW "x_left=0,x_right=0,y_bottom=0,y_top=0"
+#define DEFAULT_PROP_AF_WINDOW "x_left=0,x_right=0,y_bottom=0,y_top=0"
+#define DEFAULT_DEBUG_FLAGS 0
+#define C_FLAGS(v) ((guint) v)
+
+
+static const char* surface_string =
+ "video/x-vaapi-sharing, "
+ "type = vaapi, "
+ "width = (int) [ 1, MAX ], "
+ "height = (int) [ 1, MAX ], "
+ "framerate = (fraction) [ 0, MAX ]";
+
GType
gst_camera_input_sensor_get_type (void)
return gst_camera_ae_metering_mode_type;
}
+GType
+gst_camera_ae_mode_get_type(void)
+{
+ static GType gst_camera_ae_mode_type = 0;
+ static GEnumValue gst_camera_ae_mode[] = {
+ {GST_CAMERA_AE_MODE_AUTO, "AE auto", "auto"},
+ {GST_CAMERA_AE_MODE_MANUAL, "AE manual", "manual"},
+ {GST_CAMERA_AE_MODE_SHUTTER_PRIORITY, "AE shutter priority", "shutter"},
+ {GST_CAMERA_AE_MODE_APERTURE_PRIORITY, "AE aperture priority", "aperture"},
+ {0, NULL, NULL},
+ };
+
+ if (G_UNLIKELY (!gst_camera_ae_mode_type)) {
+ gst_camera_ae_mode_type=
+ g_enum_register_static ("GstCameraAEMode",
+ gst_camera_ae_mode);
+ }
+ return gst_camera_ae_mode_type;
+}
+
+GType
+gst_camera_af_metering_mode_get_type(void)
+{
+ static GType gst_camera_af_metering_mode_type = 0;
+ static GEnumValue gst_camera_af_metering_mode[] = {
+ {GST_CAMERA_AF_METERING_AUTO, "AF auto metering", "auto"},
+ {GST_CAMERA_AF_METERING_SPOT, "AF spot metering", "spot"},
+ {GST_CAMERA_AF_METERING_CENTER, "AF center metering", "center"},
+ {GST_CAMERA_AF_METERING_CUSTOMIZED, "AF customized metering", "customized"},
+ {0, NULL, NULL},
+ };
+
+ if (G_UNLIKELY (!gst_camera_af_metering_mode_type)) {
+ gst_camera_af_metering_mode_type=
+ g_enum_register_static ("GstCameraAFMeteringMode",
+ gst_camera_af_metering_mode);
+ }
+ return gst_camera_af_metering_mode_type;
+}
+
+GType
+gst_camerasrc_debug_flags_get_type (void)
+{
+ static GType gst_camerasrc_debug_flags = 0;
+ static const GFlagsValue values [] = {
+ {C_FLAGS (GST_CAMERASRC_DEBUG_FLAGS_PERFORMANCE), "Debug flags for performance tuning",
+ "performance"},
+ {C_FLAGS (GST_CAMERASRC_DEBUG_FLAGS_MAKER_NOTE), "Debug flags for maker note",
+ "maker-note"},
+ {C_FLAGS (GST_CAMERASRC_DEBUG_FLAGS_AUTO_FOCUS), "Debug flags for auto focus",
+ "auto-focus"},
+ {0, NULL, NULL},
+ };
+
+ if (G_UNLIKELY (!gst_camerasrc_debug_flags)) {
+ gst_camerasrc_debug_flags =
+ g_flags_register_static ("GstCameraSrcDebugFlags", values);
+ }
+ return gst_camerasrc_debug_flags;
+}
+
+
GST_IMPLEMENT_V4L2CAMSRC_VIDORIENT_METHODS (GstMFLDV4l2CamSrc, gst_v4l2camsrc);
}
}
+ GstStructure * structure = gst_structure_from_string(surface_string, NULL);
+ gst_caps_append_structure (ret, structure);
+
v4l2camsrc->probed_caps = gst_caps_ref (ret);
- GST_INFO_OBJECT (v4l2camsrc, "probed caps: %" GST_PTR_FORMAT, ret);
+ GST_INFO_OBJECT(v4l2camsrc, "use GST_DEBUG >= 5 for probed caps");
+ GST_LOG_OBJECT (v4l2camsrc, "probed caps: %" GST_PTR_FORMAT, ret);
return ret;
}
gst_caps_append_structure (caps, structure);
}
}
+ structure = gst_structure_from_string(surface_string, NULL);
+ gst_caps_append_structure (caps, structure);
}
return gst_caps_ref (caps);
GstPhotoSettings * photoconf);
gboolean gst_v4l2camsrc_write_settings (GstCameraSrc * camsrc,
GstPhotoSettings * photoconf, gboolean scene_override);
+gboolean
+gst_v4l2camsrc_set_flash_mode (GstCameraSrc *camsrc, int value);
+gboolean
+gst_v4l2camsrc_read_exif (GstCameraSrc *camsrc,
+ GstCameraControlExifInfo *exif_info);
+gboolean
+gst_v4l2camsrc_set_strobe_state (GstCameraSrc *camsrc, gboolean state);
+
+gboolean
+gst_v4l2camsrc_set_AeAafwindow (GstCameraSrc * camsrc, GstCameraSrc3a_window window);
/*
* gst_v4l2camsrc_class_init:
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_INPUT_SENSOR,
- g_param_spec_enum ("input-sensor", "Input Sensor",
+ g_param_spec_enum ("camera-id", "Camera Id",
"Which sensor is the input of the ISP",
GST_TYPE_CAMERA_INPUT_SENSOR,
GST_CAMERA_INPUT_SENSOR_PRIMARY,
GST_CAMERA_AE_METERING_AUTO,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+ g_object_class_install_property (gobject_class, PROP_AE_MODE,
+ g_param_spec_enum ("ae-mode", "AE Mode",
+ "Select AE Mode",
+ GST_TYPE_CAMERA_AE_MODE,
+ GST_CAMERA_AE_MODE_AUTO,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class, PROP_AE_WINDOW,
+ g_param_spec_string("ae-window", "AE Window",
+ "Set AE Window Coordinates in format: x_left=value,x_right=value,"
+ "y_bottom=value,y_top=value",
+ DEFAULT_PROP_AE_WINDOW,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ));
+
g_object_class_install_property (gobject_class, PROP_AF,
g_param_spec_boolean ("af", "Auto Focus",
"Auto Focus is On or Off", TRUE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
+
+ g_object_class_install_property (gobject_class, PROP_AF_METERING_MODE,
+ g_param_spec_enum ("af-metering-mode", "AF Metering Mode",
+ "Select AF Metering Mode",
+ GST_TYPE_CAMERA_AF_METERING_MODE,
+ GST_CAMERA_AF_METERING_AUTO,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class, PROP_AF_WINDOW,
+ g_param_spec_string("af-window", "AF Window",
+ "Set AF Window Coordinates in format: x_left=value,x_right=value,"
+ "y_bottom=value,y_top=value",
+ DEFAULT_PROP_AF_WINDOW,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ));
+
g_object_class_install_property (gobject_class, PROP_AWB,
g_param_spec_boolean ("awb", "White Balance",
"White Balance is On or Off",
g_object_class_install_property (gobject_class, PROP_FOCUS_POSITION,
g_param_spec_int ("focus-posi", "Focus Position",
- "Focus abosolute position set to Sensor.", G_MININT, G_MAXINT, 0,
+ "Focus absolute position set to Sensor.", FOCUS_POSITION_MIN,
+ FOCUS_POSITION_MAX, 0,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_CONTROLLABLE));
g_object_class_install_property (gobject_class, PROP_BAYER_DOWNSCALING,
g_object_class_install_property (gobject_class, PROP_DUMP_IMAGE,
g_param_spec_boolean ("dump-image", "Dump images simultanious in pipeline",
- "Whether dump the images as output when pipeline, debug only,"
+ "Whether dump the images as output in pipeline, debug only,"
"output the image in current directory",
FALSE, G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class, PROP_DEBUG_FLAGS,
+ g_param_spec_flags ("debug-flags", "debug flags",
+ "debug flags for development and performance tuning usage",
+ GST_TYPE_CAMERASRC_DEBUG_FLAGS, DEFAULT_DEBUG_FLAGS,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class,
+ PROP_VFLIP,
+ g_param_spec_boolean ("vflip", "Vertical Flip",
+ "Vertical flip", FALSE,
+ G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
+
+ g_object_class_install_property (gobject_class,
+ PROP_HFLIP,
+ g_param_spec_boolean ("hflip", "Horisontal Flip",
+ "Horisontal flip", FALSE,
+ G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
+
+ g_object_class_install_property (gobject_class,
+ PROP_DISABLE_LOW_RES_CROP,
+ g_param_spec_boolean ("disable-low-res-crop", "disable low resolution crop",
+ "disable software crop on unsupported low resolution frame size", FALSE,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class,
+ PROP_DRAW_CORNER_MARKERS,
+ g_param_spec_boolean ("draw-corner-markers", "draw markers in frame corners",
+ "draw markers in frame corners", FALSE,
+ G_PARAM_READWRITE));
+
camera_class->is_open = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_is_open);
camera_class->open = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_open);
camera_class->close = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_close);
camera_class->get_capabilities =
GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_capabilities);
camera_class->set_zoom = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_zoom);
+ camera_class->set_AeAafwindow = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_AeAafwindow);
+ camera_class->set_ae_mode = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_ae_mode);
+ camera_class->get_ae_mode = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_ae_mode);
+
camera_class->get_makernote = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_makernote);
camera_class->makernote_init = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_makernote_init);
camera_class->makernote_deal = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_makernote_deal);
camera_class->makernote_uninit = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_makernote_uninit);
+ camera_class->set_flash_mode = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_set_flash_mode);
+ camera_class->read_exif = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_read_exif);
+
+ camera_class->set_strobe_state = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_set_strobe_state);
+
//camera_class->fill_image_tags = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_fill_image_tags);
//camera_class->get_preview_image = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_get_preview_image);
}
GstV4l2MFLDAdvCI *mfldadvci;
mfldadvci = g_new0 (GstV4l2MFLDAdvCI, 1);
+ wrapper_default_link_functions_init(mfldadvci);
- int (*init_function) (GstV4l2MFLDAdvCI * mfldadvci);
-
- wrapper_default_functions_init (mfldadvci);
-
+#ifdef USE_DYNAMIC_3A
if (g_module_supported ()) {
gchar *module_file;
-
module_file = g_module_build_path (MFLD_ADVCI_PATH, "libmfldadvci.so.0");
-
GST_DEBUG_OBJECT (v4l2camsrc, "Loading %s", module_file);
v4l2camsrc->module = g_module_open (module_file, G_MODULE_BIND_LOCAL);
v4l2camsrc->module = g_module_open (module_file, G_MODULE_BIND_LOCAL);
GST_DEBUG_OBJECT (v4l2camsrc, "Loading %s", module_file);
}
-
+ GST_DEBUG_OBJECT(v4l2camsrc, "Camera Source Interface version is %d\n", LIBMFLDADVCI_VERSION);
if (v4l2camsrc->module) {
- gboolean ret;
-
- ret = g_module_symbol (v4l2camsrc->module, "libmfldadvci_init",
- (gpointer) & init_function);
-
- if (ret) {
- if (init_function (mfldadvci) < 0) {
- GST_WARNING_OBJECT (v4l2camsrc, "Failed to init libmfldadvci symbol");
- g_module_close (v4l2camsrc->module);
- v4l2camsrc->module = NULL;
- }
- } else {
- GST_WARNING_OBJECT (v4l2camsrc, "libmfldadvci: Init symbol not found");
- g_module_close (v4l2camsrc->module);
- v4l2camsrc->module = NULL;
- }
- } else {
- GST_DEBUG_OBJECT (v4l2camsrc,
- "libmfldadvci: Opening the module failed: %s", g_module_error ());
+ lib_3a_link_functions_init(mfldadvci, v4l2camsrc->module);
}
- g_free (module_file);
- GST_DEBUG_OBJECT (v4l2camsrc, "libmfldadvci: initialized");
}
+#endif /* USE_DYNAMIC_3A */
return mfldadvci;
}
{
GstV4l2MFLDAdvCI *mfldadvci = v4l2camsrc->mfldadvci;
- if (v4l2camsrc->module) {
- void (*deinit_function) (GstV4l2MFLDAdvCI * mfldadvci);
- gboolean ret;
+ GST_DEBUG ("mfldadvci unload");
+ g_module_close (v4l2camsrc->module);
+ v4l2camsrc->module = NULL;
- GST_DEBUG_OBJECT (v4l2camsrc, "Unloading libmfldadvci");
-
- ret = g_module_symbol (v4l2camsrc->module, "libmfdladvci_deinit",
- (gpointer) & deinit_function);
- if (ret) {
- deinit_function (mfldadvci);
- }
- g_module_close (v4l2camsrc->module);
- v4l2camsrc->module = NULL;
- }
g_free (mfldadvci);
+
}
v4l2camsrc->sc_enabled = TRUE;
v4l2camsrc->cc_updated = FALSE;
v4l2camsrc->gamma_updated = FALSE;
- v4l2camsrc->ae_enabled = FALSE;
- v4l2camsrc->af_enabled = FALSE;
- v4l2camsrc->awb_enabled = FALSE;
+ v4l2camsrc->ae_enabled = TRUE;
+ v4l2camsrc->af_enabled = TRUE;
+ v4l2camsrc->awb_enabled = TRUE;
v4l2camsrc->still_af = FALSE;
v4l2camsrc->bayer_downscaling = FALSE;
v4l2camsrc->tone.gamma = 2.2;
v4l2camsrc->dump_raw = FALSE;
v4l2camsrc->dump_image = FALSE;
v4l2camsrc->raw_output_size = 0;
+ v4l2camsrc->debug_flags = DEFAULT_DEBUG_FLAGS;
+ v4l2camsrc->disable_low_res_crop = FALSE;
+ v4l2camsrc->draw_corner_markers = FALSE;
v4l2camsrc->device_mutex = g_mutex_new ();
v4l2camsrc->mfldadvci = gst_v4l2camsrc_mfldadvci_wrapper_load (v4l2camsrc);
v4l2camsrc->input_sensor = GST_CAMERA_INPUT_SENSOR_PRIMARY;
+ v4l2camsrc->ae_metering_mode = GST_CAMERA_AE_METERING_AUTO;
+ v4l2camsrc->ae_mode = GST_CAMERA_AE_MODE_AUTO;
+ v4l2camsrc->af_metering_mode = GST_CAMERA_AF_METERING_AUTO;
+
+ v4l2camsrc->ae_window.x_left = 0;
+ v4l2camsrc->ae_window.x_right = 0;
+ v4l2camsrc->ae_window.y_bottom = 0;
+ v4l2camsrc->ae_window.y_top = 0;
+ v4l2camsrc->ae_window.weight= 0x8000;
+ v4l2camsrc->af_window.x_left = 0;
+ v4l2camsrc->af_window.x_right = 0;
+ v4l2camsrc->af_window.y_bottom = 0;
+ v4l2camsrc->af_window.y_top = 0;
+ v4l2camsrc->af_window.weight= 0x8000;
libmfld_cam_init (v4l2camsrc->mfldadvci);
G_OBJECT_CLASS (parent_class)->dispose (object);
libmfld_cam_dispose ();
+ gst_v4l2camsrc_mfldadvci_wrapper_unload(v4l2camsrc);
}
case PROP_AE:
v4l2camsrc->ae_enabled = g_value_get_boolean (value);
break;
+ case PROP_AE_WINDOW:
+ {
+ GstStructure *ae_window_param = NULL;
+ char * ctmp = NULL;
+ gboolean parsed = TRUE;
+
+ ctmp = g_malloc0 (60);
+ if (ctmp == NULL)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc, "alloc string mem failed.\n");
+ break;
+ }
+ strncpy (ctmp,"ae,",3);
+ strncat (ctmp,g_value_get_string (value),55);
+ ae_window_param = gst_structure_from_string (ctmp, NULL);
+ if(ae_window_param == NULL)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc,"wrong string format is entered. stop setting ae window.\n");
+ g_free (ctmp);
+ break;
+ }
+
+ parsed = gst_structure_get_int(ae_window_param, "x_left",
+ &v4l2camsrc->ae_window.x_left);
+ parsed |= gst_structure_get_int(ae_window_param, "x_right",
+ &v4l2camsrc->ae_window.x_right);
+ parsed |= gst_structure_get_int(ae_window_param, "y_top",
+ &v4l2camsrc->ae_window.y_top);
+ parsed |= gst_structure_get_int(ae_window_param, "y_bottom",
+ &v4l2camsrc->ae_window.y_bottom);
+
+ if (parsed == FALSE)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc,"cannot parse ae window parameter. \n");
+ gst_structure_free (ae_window_param);
+ g_free (ctmp);
+ break;
+ }
+
+ parsed = gst_structure_get_int(ae_window_param, "weight",
+ &v4l2camsrc->ae_window.weight);
+
+ if (parsed == FALSE)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc,
+ "set ae window weight to default value 0x8000.\n");
+ v4l2camsrc->ae_window.weight = 0x8000;
+ }
+
+ GST_DEBUG_OBJECT(v4l2camsrc,"ae-window-setting: x_left:%d, x_right:%d,"
+ "y_bottom:%d, y_top:%d, weight:%d.\n",
+ v4l2camsrc->ae_window.x_left,v4l2camsrc->ae_window.x_right,
+ v4l2camsrc->ae_window.y_bottom, v4l2camsrc->ae_window.y_top,
+ v4l2camsrc->ae_window.weight);
+
+
+ if (v4l2camsrc->ae_metering_mode != GST_CAMERA_AE_METERING_SPOT)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc,"wrong ae metering mode. set it to spot mode automaticly.\n");
+ v4l2camsrc->ae_metering_mode = GST_CAMERA_AE_METERING_SPOT;
+ v4l2camsrc->mfldadvci->AeSetMeteringMode
+ ( (advci_ae_metering_mode) v4l2camsrc->ae_metering_mode);
+
+ }
+ v4l2camsrc->mfldadvci->AeSetWindow ((advci_window *) (&(v4l2camsrc->ae_window)));
+
+ gst_structure_free (ae_window_param);
+ g_free (ctmp);
+ break;
+ }
+
case PROP_AE_METERING_MODE:
{
v4l2camsrc->ae_metering_mode = g_value_get_enum (value);
- v4l2camsrc->mfldadvci->AeSetMeteringMode((ci_adv_AeMeteringMode)v4l2camsrc->ae_metering_mode);
+ v4l2camsrc->mfldadvci->AeSetMeteringMode((advci_ae_metering_mode)v4l2camsrc->ae_metering_mode);
+ break;
+ }
+ case PROP_AE_MODE:
+ {
+ v4l2camsrc->ae_mode = g_value_get_enum (value);
+ v4l2camsrc->mfldadvci->AeSetMode((advci_ae_mode)v4l2camsrc->ae_mode);
+ break;
+ }
+ case PROP_AF_METERING_MODE:
+ {
+ v4l2camsrc->af_metering_mode = g_value_get_enum (value);
+ v4l2camsrc->mfldadvci->AfSetMeteringMode((advci_af_metering_mode)v4l2camsrc->af_metering_mode);
+ break;
+ }
+ case PROP_AF_WINDOW:
+ {
+ GstStructure *af_window_param = NULL;
+ char * ctmp = NULL;
+ gboolean parsed = TRUE;
+
+ ctmp = g_malloc0 (60);
+ if (ctmp == NULL)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc, "alloc string mem failed.\n");
+ break;
+ }
+ strncpy (ctmp,"af,",3);
+ strncat (ctmp,g_value_get_string (value),55);
+ af_window_param = gst_structure_from_string (ctmp, NULL);
+ if(af_window_param == NULL)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc,"wrong string format is entered. stop setting af window.\n");
+ g_free (ctmp);
+ break;
+ }
+
+ parsed = gst_structure_get_int(af_window_param, "x_left",
+ &v4l2camsrc->af_window.x_left);
+ parsed |= gst_structure_get_int(af_window_param, "x_right",
+ &v4l2camsrc->af_window.x_right);
+ parsed |= gst_structure_get_int(af_window_param, "y_top",
+ &v4l2camsrc->af_window.y_top);
+ parsed |= gst_structure_get_int(af_window_param, "y_bottom",
+ &v4l2camsrc->af_window.y_bottom);
+
+ if (parsed == FALSE)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc,"cannot parse af window parameter. \n");
+ gst_structure_free (af_window_param);
+ g_free (ctmp);
+ break;
+ }
+
+ parsed = gst_structure_get_int(af_window_param, "weight",
+ &v4l2camsrc->af_window.weight);
+
+ if (parsed == FALSE)
+ {
+ GST_DEBUG_OBJECT(v4l2camsrc,
+ "set af window weight to default value 0x8000.\n");
+ v4l2camsrc->af_window.weight = 0x8000;
+ }
+
+ GST_DEBUG_OBJECT(v4l2camsrc,"af-window-setting: x_left:%d, x_right:%d,"
+ "y_bottom:%d, y_top:%d, weight:%d.\n",
+ v4l2camsrc->af_window.x_left,v4l2camsrc->af_window.x_right,
+ v4l2camsrc->af_window.y_bottom, v4l2camsrc->af_window.y_top,
+ v4l2camsrc->af_window.y_top);
+
+
+ v4l2camsrc->mfldadvci->AfSetWindows (1, (advci_window *) (&(v4l2camsrc->af_window)));
+
+ gst_structure_free (af_window_param);
+ g_free (ctmp);
break;
}
+
case PROP_AF:
v4l2camsrc->af_enabled = g_value_get_boolean (value);
break;
+
case PROP_AWB:
v4l2camsrc->awb_enabled = g_value_get_boolean (value);
break;
else
v4l2camsrc->focus_updated = TRUE;
break;
+ case PROP_VFLIP:
+ v4l2camsrc->vflip = g_value_get_boolean(value);
+ if (gst_v4l2camsrc_is_open (GST_CAMERA_SRC (v4l2camsrc)))
+ gst_v4l2camsrc_set_attribute (GST_CAMERA_SRC (v4l2camsrc),V4L2_CID_VFLIP,v4l2camsrc->vflip);
+ break;
+ case PROP_HFLIP:
+ v4l2camsrc->hflip = g_value_get_boolean(value);
+ if (gst_v4l2camsrc_is_open (GST_CAMERA_SRC (v4l2camsrc)))
+ gst_v4l2camsrc_set_attribute (GST_CAMERA_SRC (v4l2camsrc),V4L2_CID_HFLIP,v4l2camsrc->hflip);
+ break;
case PROP_BAYER_DOWNSCALING:
v4l2camsrc->bayer_downscaling = g_value_get_boolean (value);
break;
case PROP_DUMP_IMAGE:
v4l2camsrc->dump_image = g_value_get_boolean (value);
break;
+ case PROP_DEBUG_FLAGS:
+ v4l2camsrc->debug_flags = g_value_get_flags (value);
+ break;
+ case PROP_DISABLE_LOW_RES_CROP:
+ v4l2camsrc->disable_low_res_crop = g_value_get_boolean (value);
+ break;
+ case PROP_DRAW_CORNER_MARKERS:
+ v4l2camsrc->draw_corner_markers = g_value_get_boolean (value);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
case PROP_AE_METERING_MODE:
g_value_set_enum (value, v4l2camsrc->ae_metering_mode);
break;
+ case PROP_AE_MODE:
+ g_value_set_enum (value, v4l2camsrc->ae_mode);
+ break;
+ case PROP_AE_WINDOW:
+ {
+ GstStructure *tmp = NULL;
+ tmp = gst_structure_empty_new("ae-window");
+ if(tmp == NULL)
+ {
+ GST_DEBUG ("wrong default ae window setting.\n");
+ break;
+ }
+ gst_structure_set (tmp,"x_left", G_TYPE_INT,
+ v4l2camsrc->ae_window.x_left,NULL);
+ gst_structure_set (tmp,"x_right", G_TYPE_INT,
+ v4l2camsrc->ae_window.x_right,NULL);
+ gst_structure_set (tmp,"y_bottom", G_TYPE_INT,
+ v4l2camsrc->ae_window.y_bottom,NULL);
+ gst_structure_set (tmp,"y_top", G_TYPE_INT,
+ v4l2camsrc->ae_window.y_top,NULL);
+ g_value_set_string(value, gst_structure_to_string(tmp));
+ gst_structure_free(tmp);
+ break;
+ }
+
case PROP_AF:
g_value_set_boolean (value, v4l2camsrc->af_enabled);
break;
+ case PROP_AF_METERING_MODE:
+ g_value_set_enum (value, v4l2camsrc->af_metering_mode);
+ break;
+ case PROP_AF_WINDOW:
+ {
+ GstStructure *tmp = NULL;
+ tmp = gst_structure_empty_new("af-window");
+ if(tmp == NULL)
+ {
+ GST_DEBUG ("wrong default af window setting.\n");
+ break;
+ }
+ gst_structure_set (tmp,"x_left", G_TYPE_INT,
+ v4l2camsrc->af_window.x_left,NULL);
+ gst_structure_set (tmp,"x_right", G_TYPE_INT,
+ v4l2camsrc->af_window.x_right,NULL);
+ gst_structure_set (tmp,"y_bottom", G_TYPE_INT,
+ v4l2camsrc->af_window.y_bottom,NULL);
+ gst_structure_set (tmp,"y_top", G_TYPE_INT,
+ v4l2camsrc->af_window.y_top,NULL);
+ g_value_set_string(value, gst_structure_to_string(tmp));
+ gst_structure_free(tmp);
+ break;
+ }
+
case PROP_AWB:
g_value_set_boolean (value, v4l2camsrc->awb_enabled);
break;
case PROP_FOCUS_POSITION:
g_value_set_int (value, v4l2camsrc->focus_posi);
break;
+ case PROP_VFLIP:
+ g_value_set_boolean (value, v4l2camsrc->vflip);
+ break;
+ case PROP_HFLIP:
+ g_value_set_boolean (value, v4l2camsrc->hflip);
+ break;
case PROP_BAYER_DOWNSCALING:
g_value_set_boolean (value, v4l2camsrc->bayer_downscaling);
break;
case PROP_DUMP_IMAGE:
g_value_set_boolean (value, v4l2camsrc->dump_image);
break;
+ case PROP_DEBUG_FLAGS:
+ g_value_set_flags (value, v4l2camsrc->debug_flags);
+ break;
+ case PROP_DISABLE_LOW_RES_CROP:
+ g_value_set_boolean (value, v4l2camsrc->disable_low_res_crop);
+ break;
+ case PROP_DRAW_CORNER_MARKERS:
+ g_value_set_boolean (value, v4l2camsrc->draw_corner_markers);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
return ret;
}
+static gboolean
+gst_v4l2camsrc_set_ae_mode(GstCameraSrc * camsrc, int mode)
+{
+ GstMFLDV4l2CamSrc *v4l2camsrc;
+ gboolean ret = TRUE;
+
+ v4l2camsrc = GST_V4L2CAMSRC (camsrc);
+
+ if (v4l2camsrc->is_active) {
+ g_mutex_lock (v4l2camsrc->device_mutex);
+ v4l2camsrc->ae_metering_mode = *(GstCameraAEMeteringMode *)&mode;
+ v4l2camsrc->mfldadvci->AeSetMeteringMode((advci_ae_metering_mode)v4l2camsrc->ae_metering_mode);
+ g_mutex_unlock (v4l2camsrc->device_mutex);
+ }
+
+ return ret;
+}
+static gboolean
+gst_v4l2camsrc_get_ae_mode(GstCameraSrc * camsrc, int *mode)
+{
+ GstMFLDV4l2CamSrc *v4l2camsrc;
+ gboolean ret = TRUE;
+
+ v4l2camsrc = GST_V4L2CAMSRC (camsrc);
+
+ if (v4l2camsrc->is_active) {
+ g_mutex_lock (v4l2camsrc->device_mutex);
+ *mode = v4l2camsrc->ae_metering_mode;
+ g_mutex_unlock (v4l2camsrc->device_mutex);
+ }
+
+ return ret;
+}
static gboolean
-gst_v4l2camsrc_get_makernote (GstCameraSrc * camsrc, void *buf)
+gst_v4l2camsrc_get_makernote (GstCameraSrc * camsrc, unsigned char *buf, unsigned size)
{
GstMFLDV4l2CamSrc *v4l2camsrc;
gboolean ret = TRUE;
if (v4l2camsrc->is_active) {
g_mutex_lock (v4l2camsrc->device_mutex);
- ret = gst_v4l2camsrc_libmfldcam_get_makernote(v4l2camsrc, buf);
+ ret = gst_v4l2camsrc_libmfldcam_get_makernote(v4l2camsrc, buf, size);
g_mutex_unlock (v4l2camsrc->device_mutex);
}
int *handle)
{
GstMFLDV4l2CamSrc *v4l2camsrc;
- ENUM_MAKERNOTE_RET_VAL ret;
v4l2camsrc = GST_V4L2CAMSRC (camsrc);
GST_DEBUG_OBJECT (v4l2camsrc, "%s, !!!!!!line:%d\n", __func__, __LINE__);
num_afwindows = num_grid = 1;
num_faces = num_eyes = 0;
- ret = makernote_nokia_init(num_afwindows, num_faces,
- num_eyes, num_grid, handle, buf_size);
- if(ENUM_MAKERNOTE_RET_TRUE != ret)
- return FALSE;
+ return FALSE;
- return TRUE;
}
static gboolean gst_v4l2camsrc_makernote_deal(GstCameraSrc * camsrc,
int handle)
{
GstMFLDV4l2CamSrc *v4l2camsrc;
- ENUM_MAKERNOTE_RET_VAL ret;
v4l2camsrc = GST_V4L2CAMSRC (camsrc);
GST_DEBUG_OBJECT (v4l2camsrc, "%s, !!!!!!line:%d\n", __func__, __LINE__);
- makernote_util_create(handle, num_afwindows, num_grid, camsrc); // af windows is one, grid for awb is one
-
- ret = makernote_nokia_copy_buffer(handle, GST_BUFFER_DATA(pmakerbuf),
- GST_BUFFER_SIZE(pmakerbuf));
- if(ENUM_MAKERNOTE_RET_TRUE != ret)
- return FALSE;
+ return FALSE;
- return TRUE;
}
static gboolean gst_v4l2camsrc_makernote_uninit(GstCameraSrc * camsrc,
v4l2camsrc = GST_V4L2CAMSRC (camsrc);
GST_DEBUG_OBJECT (v4l2camsrc, "%s, !!!!!!line:%d\n", __func__, __LINE__);
- if(makernote_nokia_uninit(handle) != ENUM_MAKERNOTE_RET_TRUE)
- return FALSE;
-
- return TRUE;
+ return FALSE;
}
static gboolean
plugin_init (GstPlugin * plugin)
{
- GST_DEBUG_CATEGORY_INIT (gst_v4l2camsrc_debug, "mfldv4l2camsrc", 0,
+ GST_DEBUG_CATEGORY_INIT (gst_v4l2camsrc_debug, "camerasrc", 0,
"Medfield V4L2 camera source");
- return gst_element_register (plugin, "mfldv4l2camsrc",
+ return gst_element_register (plugin, "camerasrc",
GST_RANK_NONE, GST_TYPE_V4L2CAMSRC);
}
projects / adaptation / intel_mfld / gst-plugins-atomisp.git / blobdiff