gst/mfldv4l2cam/gstv4l2camsrc.c

   1 /* GStreamer V4L2 camera source
   2  * Copyright (C) 2010 Nokia Corporation <multimedia@maemo.org>
   3  *               2010 Intel Corporation
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-mfldcamsrc
  23  * @short_description: Medfield V4L2 camera source
  24  * @see_also: #GstCameraSrc
  25  *
  26  * <refsect2>
  27  * <para>
  28  * Bla bla...
  29  * </para>
  30  * <para>
  31  * Foo bar
  32  * </para>
  33  * <title>Example launch line</title>
  34  * <para>
  35  * <programlisting>
  36  * gst-launch mfldv4l2camsrc ! xvimagesink
  37  * </programlisting>
  38  * </para>
  39  * </refsect2>
  40  */
  41
  42 #include <string.h>
  43
  44 #ifdef HAVE_CONFIG_H
  45 #include "config.h"
  46 #endif
  47
  48 #include <linux/videodev2.h>
  49 #include "gstv4l2camsrc.h"
  50 #include "v4l2camsrc_calls.h"
  51 #include "gstv4l2camvidorient.h"
  52 #include <mfld_cam.h>
  53
  54 #define MFLD_ADVCI_PATH "/usr/lib/"
  55 #define MFLD_V4L2CAMSRC_VERSION "85de990a519ae021f0bf4ec89c0e352ec76f6965"
  56 #define FOCUS_POSITION_MIN      0
  57 #define FOCUS_POSITION_MAX      512
  58
  59 GST_DEBUG_CATEGORY (gst_v4l2camsrc_debug);
  60 #define GST_CAT_DEFAULT gst_v4l2camsrc_debug
  61
  62 static gboolean gst_v4l2camsrc_is_open (GstCameraSrc * camsrc);
  63 static void gst_v4l2camsrc_finalize (GObject * object);
  64 static void gst_v4l2camsrc_dispose (GObject * object);
  65 static void gst_v4l2camsrc_set_property (GObject * object,
  66     guint prop_id, const GValue * value, GParamSpec * pspec);
  67 static void gst_v4l2camsrc_get_property (GObject * object,
  68     guint prop_id, GValue * value, GParamSpec * pspec);
  69 static gboolean gst_v4l2camsrc_unlock (GstCameraSrc * src);
  70 static gboolean gst_v4l2camsrc_unlock_stop (GstCameraSrc * src);
  71 static gboolean gst_v4l2camsrc_set_zoom (GstCameraSrc * camsrc, gfloat zoom);
  72 static gboolean gst_v4l2camsrc_set_ae_mode (GstCameraSrc * camsrc, int mode);
  73 static gboolean gst_v4l2camsrc_get_ae_mode (GstCameraSrc * camsrc, int *mode);
  74
  75 static gboolean gst_v4l2camsrc_iface_supported (GstImplementsInterface * iface,
  76     GType iface_type);
  77 static gboolean gst_v4l2camsrc_get_makernote (GstCameraSrc * camsrc, unsigned char *buf, unsigned size);
  78 static gboolean gst_v4l2camsrc_makernote_init(GstCameraSrc * camsrc,
  79                                                       unsigned * buf_size,
  80                                                       unsigned num_afwindows,
  81                                                       unsigned num_faces,
  82                                                       unsigned num_eyes,
  83                                                       unsigned num_grid,
  84                                                       int *handle);
  85 static gboolean gst_v4l2camsrc_makernote_deal(GstCameraSrc * camsrc,
  86                                                       GstBuffer *pmakerbuf,
  87                                                       unsigned num_afwindows,
  88                                                       unsigned num_grid,
  89                                                       int handle);
  90 static gboolean gst_v4l2camsrc_makernote_uninit(GstCameraSrc * camsrc,
  91                                                         int handle);
  92
  93 typedef enum
  94 {
  95   PROP_0,
  96   PROP_DEVICE,
  97   PROP_DEVICE_FD,
  98   PROP_DEVICE_NAME,
  99   PROP_QUEUE_SIZE,
 100   PROP_INPUT_SENSOR,
 101   PROP_USE_MMAP,
 102   PROP_USE_COPY,
 103   PROP_3A,
 104   PROP_AE_METERING_MODE,
 105   PROP_AE_WINDOW,
 106   PROP_AE_MODE,
 107   PROP_AF_METERING_MODE,
 108   PROP_AF_WINDOW,
 109   PROP_STILL_AF,
 110   PROP_FOCUS_POSITION,
 111   PROP_VFLIP,
 112   PROP_HFLIP,
 113   PROP_BAYER_DOWNSCALING,
 114   PROP_CAPTURE_CORRECTION_GDC,
 115   PROP_CAPTURE_CORRECTION_CAC,
 116   PROP_CAPTURE_CORRECTION_RER,
 117   PROP_CAPTURE_CORRECTION_DIS,
 118   PROP_CAPTURE_CORRECTION_DVS,
 119   PROP_CAPTURE_CORRECTION_EDGE_ENHANCEMENT,
 120   PROP_CAPTURE_CORRECTION_SHADING_CORRECTION,
 121   PROP_CAPTURE_CORRECTION_BLACK_LEVEL_COMPENSATION,
 122   PROP_CAPTURE_CORRECTION_BAD_PIXEL_DETECTION,
 123   PROP_CAPTURE_CORRECTION_GAMMA,
 124   PROP_CAPTURE_CORRECTION_CONTRAST,
 125   PROP_CAPTURE_CORRECTION_BRIGHTNESS,
 126   PROP_DUMP_RAW,
 127   PROP_DUMP_IMAGE,
 128   PROP_DEBUG_FLAGS,
 129   PROP_DISABLE_LOW_RES_CROP,
 130   PROP_DRAW_CORNER_MARKERS,
 131 } GstV4L2CamSrcProperties;
 132
 133
 134 static GstStaticPadTemplate gst_v4l2camsrc_template =
 135   GST_STATIC_PAD_TEMPLATE ("src",
 136   GST_PAD_SRC,
 137   GST_PAD_ALWAYS,
 138   GST_STATIC_CAPS ("video/x-raw-yuv, "
 139     "format = (fourcc) NV12, "
 140     "framerate = (fraction) [ 0, 200 ], "
 141     "width = (int) [ 1, MAX ], "
 142     "height = (int) [ 1, MAX ];"
 143     "video/x-raw-yuv, "
 144     "format = (fourcc) I420, "
 145     "framerate = (fraction) [ 0, 200 ], "
 146     "width = (int) [ 1, MAX ], "
 147     "height = (int) [ 1, MAX ];"
 148     "video/x-raw-bayer, "
 149     "format = (fourcc) BA10, "
 150     "framerate = (fraction) [ 0, 200 ], "
 151     "width = (int) [ 1, MAX ], "
 152     "height = (int) [ 1, MAX ];"
 153     "video/x-vaapi-sharing, "
 154     "type = vaapi, "
 155     "width  = (int) [ 1, MAX ], "
 156     "height = (int) [ 1, MAX ], "
 157     "framerate = (fraction) [ 0, MAX ]"));
 158
 159 #define DEFAULT_PROP_DEVICE_NAME  NULL
 160 #define DEFAULT_PROP_DEVICE       "/dev/video0"
 161 #define DEFAULT_PROP_DEVICE_FD    -1
 162 #define DEFAULT_PROP_AE_WINDOW  "x_left=0,x_right=0,y_bottom=0,y_top=0"
 163 #define DEFAULT_PROP_AF_WINDOW  "x_left=0,x_right=0,y_bottom=0,y_top=0"
 164 #define DEFAULT_DEBUG_FLAGS     0
 165 #define C_FLAGS(v) ((guint) v)
 166
 167
 168 static const char* surface_string =
 169     "video/x-vaapi-sharing, "
 170     "type = vaapi, "
 171     "width  = (int) [ 1, MAX ], "
 172     "height = (int) [ 1, MAX ], "
 173     "framerate = (fraction) [ 0, MAX ]";
 174
 175
 176 GType
 177 gst_camera_input_sensor_get_type (void)
 178 {
 179   static GType gst_camera_input_sensor_type = 0;
 180   static GEnumValue gst_camera_input_sensors[] = {
 181     {GST_CAMERA_INPUT_SENSOR_PRIMARY, "Primary Sensor", "primary"},
 182     {GST_CAMERA_INPUT_SENSOR_SECONDARY, "Sencondary Sensor", "second"},
 183     {0, NULL, NULL},
 184   };
 185
 186   if (G_UNLIKELY (!gst_camera_input_sensor_type)) {
 187     gst_camera_input_sensor_type =
 188         g_enum_register_static ("GstCameraInputSensor",
 189         gst_camera_input_sensors);
 190   }
 191   return gst_camera_input_sensor_type;
 192 }
 193
 194 GType
 195 gst_camera_ae_metering_mode_get_type(void)
 196 {
 197   static GType gst_camera_ae_metering_mode_type = 0;
 198   static GEnumValue gst_camera_ae_metering_mode[] = {
 199     {GST_CAMERA_AE_METERING_AUTO, "AE auto metering", "auto"},
 200     {GST_CAMERA_AE_METERING_SPOT, "AE spot metering", "spot"},
 201     {GST_CAMERA_AE_METERING_CENTER, "AE center metering", "center"},
 202     {GST_CAMERA_AE_METERING_CUSTOMIZED, "AE customized metering", "customized"},
 203     {0, NULL, NULL},
 204   };
 205
 206   if (G_UNLIKELY (!gst_camera_ae_metering_mode_type)) {
 207     gst_camera_ae_metering_mode_type=
 208         g_enum_register_static ("GstCameraAEMeteringMode",
 209         gst_camera_ae_metering_mode);
 210   }
 211   return  gst_camera_ae_metering_mode_type;
 212 }
 213
 214 GType
 215 gst_camera_ae_mode_get_type(void)
 216 {
 217   static GType gst_camera_ae_mode_type = 0;
 218   static GEnumValue gst_camera_ae_mode[] = {
 219     {GST_CAMERA_AE_MODE_AUTO, "AE auto", "auto"},
 220     {GST_CAMERA_AE_MODE_MANUAL, "AE manual", "manual"},
 221     {GST_CAMERA_AE_MODE_SHUTTER_PRIORITY, "AE shutter priority", "shutter"},
 222     {GST_CAMERA_AE_MODE_APERTURE_PRIORITY, "AE aperture priority", "aperture"},
 223     {0, NULL, NULL},
 224   };
 225
 226   if (G_UNLIKELY (!gst_camera_ae_mode_type)) {
 227     gst_camera_ae_mode_type=
 228         g_enum_register_static ("GstCameraAEMode",
 229         gst_camera_ae_mode);
 230   }
 231   return  gst_camera_ae_mode_type;
 232 }
 233
 234 GType
 235 gst_camera_af_metering_mode_get_type(void)
 236 {
 237   static GType gst_camera_af_metering_mode_type = 0;
 238   static GEnumValue gst_camera_af_metering_mode[] = {
 239     {GST_CAMERA_AF_METERING_AUTO, "AF auto metering", "auto"},
 240     {GST_CAMERA_AF_METERING_SPOT, "AF spot metering", "spot"},
 241     {GST_CAMERA_AF_METERING_CENTER, "AF center metering", "center"},
 242     {GST_CAMERA_AF_METERING_CUSTOMIZED, "AF customized metering", "customized"},
 243     {0, NULL, NULL},
 244   };
 245
 246   if (G_UNLIKELY (!gst_camera_af_metering_mode_type)) {
 247     gst_camera_af_metering_mode_type=
 248         g_enum_register_static ("GstCameraAFMeteringMode",
 249         gst_camera_af_metering_mode);
 250   }
 251   return  gst_camera_af_metering_mode_type;
 252 }
 253
 254 GType
 255 gst_camerasrc_debug_flags_get_type (void)
 256 {
 257   static GType gst_camerasrc_debug_flags = 0;
 258   static const GFlagsValue values [] = {
 259     {C_FLAGS (GST_CAMERASRC_DEBUG_FLAGS_PERFORMANCE), "Debug flags for performance tuning",
 260       "performance"},
 261     {C_FLAGS (GST_CAMERASRC_DEBUG_FLAGS_MAKER_NOTE), "Debug flags for maker note",
 262       "maker-note"},
 263     {C_FLAGS (GST_CAMERASRC_DEBUG_FLAGS_AUTO_FOCUS), "Debug flags for auto focus",
 264       "auto-focus"},
 265     {0, NULL, NULL},
 266   };
 267
 268   if (G_UNLIKELY (!gst_camerasrc_debug_flags)) {
 269     gst_camerasrc_debug_flags =
 270         g_flags_register_static ("GstCameraSrcDebugFlags", values);
 271   }
 272   return  gst_camerasrc_debug_flags;
 273 }
 274
 275
 276
 277 GST_IMPLEMENT_V4L2CAMSRC_VIDORIENT_METHODS (GstMFLDV4l2CamSrc, gst_v4l2camsrc);
 278
 279
 280 static void
 281 gst_v4l2camsrc_interface_init (GstImplementsInterfaceClass * klass)
 282 {
 283   /*
 284    * default virtual functions
 285    */
 286   klass->supported = gst_v4l2camsrc_iface_supported;
 287 }
 288
 289 void
 290 gst_v4l2camsrc_init_interfaces (GType type)
 291 {
 292   static const GInterfaceInfo v4l2camsrc_iface_info = {
 293     (GInterfaceInitFunc) gst_v4l2camsrc_interface_init,
 294     NULL,
 295     NULL,
 296   };
 297   static const GInterfaceInfo v4l2camsrc_videoorientation_info = {
 298     (GInterfaceInitFunc) gst_v4l2camsrc_video_orientation_interface_init,
 299     NULL,
 300     NULL,
 301   };
 302
 303   g_type_add_interface_static (type,
 304       GST_TYPE_IMPLEMENTS_INTERFACE, &v4l2camsrc_iface_info);
 305   g_type_add_interface_static (type,
 306       GST_TYPE_VIDEO_ORIENTATION, &v4l2camsrc_videoorientation_info);
 307 }
 308
 309
 310 GST_BOILERPLATE_FULL (GstMFLDV4l2CamSrc, gst_v4l2camsrc, GstCameraSrc,
 311     GST_TYPE_CAMERA_SRC, gst_v4l2camsrc_init_interfaces);
 312
 313
 314
 315 static gboolean
 316 gst_v4l2camsrc_iface_supported (GstImplementsInterface * iface,
 317     GType iface_type)
 318 {
 319   GstCameraSrc *camsrc = GST_CAMERA_SRC (iface);
 320
 321   if (gst_v4l2camsrc_is_open (camsrc) &&
 322       iface_type == GST_TYPE_VIDEO_ORIENTATION) {
 323     return TRUE;
 324   }
 325
 326   else if (GST_IS_IMPLEMENTS_INTERFACE (camsrc)) {
 327     GstImplementsInterfaceClass *parent_klass;
 328
 329     parent_klass =
 330         g_type_interface_peek (parent_class, GST_TYPE_IMPLEMENTS_INTERFACE);
 331     return parent_klass->supported (iface, iface_type);
 332   }
 333
 334   return FALSE;
 335 }
 336
 337
 338 /*
 339  * gst_v4l2camsrc_is_open:
 340  *
 341  */
 342 static gboolean
 343 gst_v4l2camsrc_is_open (GstCameraSrc * camsrc)
 344 {
 345   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (camsrc);
 346
 347   return GST_V4L2CAMSRC_IS_OPEN (v4l2camsrc);
 348 }
 349
 350 /*
 351  * gst_v4l2camsrc_is_active:
 352  *
 353  */
 354 static gboolean
 355 gst_v4l2camsrc_is_active (GstCameraSrc * camsrc)
 356 {
 357   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (camsrc);
 358
 359   return GST_V4L2CAMSRC_IS_ACTIVE (v4l2camsrc);
 360 }
 361
 362 static gint caps_cache_cmp(struct cached_gst_caps *a, struct cached_gst_caps *b)
 363 {
 364   int r;
 365   r = a->input - b->input;
 366   if(r)
 367     return r;
 368   r = a->mode - b->mode;
 369   if(r)
 370     return r;
 371   return (long)(a->pixelformat) - (long)(b->pixelformat);
 372 }
 373
 374 /*
 375  * gst_v4l2camsrc_v4l2fourcc_to_structure:
 376  *
 377  */
 378 static GstStructure *
 379 gst_v4l2camsrc_v4l2fourcc_to_structure (guint32 fourcc)
 380 {
 381   GstStructure *structure = NULL;
 382
 383   switch (fourcc) {
 384     case V4L2_PIX_FMT_MJPEG:   /* Motion-JPEG */
 385     case V4L2_PIX_FMT_JPEG:    /* JFIF JPEG */
 386       structure = gst_structure_new ("image/jpeg", NULL);
 387       break;
 388     case V4L2_PIX_FMT_RGB332:
 389     case V4L2_PIX_FMT_RGB555:
 390     case V4L2_PIX_FMT_RGB555X:
 391     case V4L2_PIX_FMT_RGB565:
 392     case V4L2_PIX_FMT_RGB565X:
 393     case V4L2_PIX_FMT_RGB24:
 394     case V4L2_PIX_FMT_BGR24:
 395     case V4L2_PIX_FMT_RGB32:
 396     case V4L2_PIX_FMT_BGR32:{
 397       guint depth = 0, bpp = 0;
 398
 399       gint endianness = 0;
 400
 401       guint32 r_mask = 0, b_mask = 0, g_mask = 0;
 402
 403       switch (fourcc) {
 404         case V4L2_PIX_FMT_RGB332:
 405           bpp = depth = 8;
 406           endianness = G_BYTE_ORDER;    /* 'like, whatever' */
 407           r_mask = 0xe0;
 408           g_mask = 0x1c;
 409           b_mask = 0x03;
 410           break;
 411         case V4L2_PIX_FMT_RGB555:
 412         case V4L2_PIX_FMT_RGB555X:
 413           bpp = 16;
 414           depth = 15;
 415           endianness =
 416               fourcc == V4L2_PIX_FMT_RGB555X ? G_BIG_ENDIAN : G_LITTLE_ENDIAN;
 417           r_mask = 0x7c00;
 418           g_mask = 0x03e0;
 419           b_mask = 0x001f;
 420           break;
 421         case V4L2_PIX_FMT_RGB565:
 422         case V4L2_PIX_FMT_RGB565X:
 423           bpp = depth = 16;
 424           endianness =
 425               fourcc == V4L2_PIX_FMT_RGB565X ? G_BIG_ENDIAN : G_LITTLE_ENDIAN;
 426           r_mask = 0xf800;
 427           g_mask = 0x07e0;
 428           b_mask = 0x001f;
 429           break;
 430         case V4L2_PIX_FMT_RGB24:
 431           bpp = depth = 24;
 432           endianness = G_BIG_ENDIAN;
 433           r_mask = 0xff0000;
 434           g_mask = 0x00ff00;
 435           b_mask = 0x0000ff;
 436           break;
 437         case V4L2_PIX_FMT_BGR24:
 438           bpp = depth = 24;
 439           endianness = G_BIG_ENDIAN;
 440           r_mask = 0x0000ff;
 441           g_mask = 0x00ff00;
 442           b_mask = 0xff0000;
 443           break;
 444         case V4L2_PIX_FMT_RGB32:
 445           bpp = depth = 32;
 446           endianness = G_BIG_ENDIAN;
 447           r_mask = 0xff000000;
 448           g_mask = 0x00ff0000;
 449           b_mask = 0x0000ff00;
 450           break;
 451         case V4L2_PIX_FMT_BGR32:
 452           bpp = depth = 32;
 453           endianness = G_BIG_ENDIAN;
 454           r_mask = 0x000000ff;
 455           g_mask = 0x0000ff00;
 456           b_mask = 0x00ff0000;
 457           break;
 458         default:
 459           g_assert_not_reached ();
 460           break;
 461       }
 462       structure = gst_structure_new ("video/x-raw-rgb",
 463           "bpp", G_TYPE_INT, bpp,
 464           "depth", G_TYPE_INT, depth,
 465           "red_mask", G_TYPE_INT, r_mask,
 466           "green_mask", G_TYPE_INT, g_mask,
 467           "blue_mask", G_TYPE_INT, b_mask,
 468           "endianness", G_TYPE_INT, endianness, NULL);
 469       break;
 470     }
 471     case V4L2_PIX_FMT_GREY:    /*  8  Greyscale     */
 472       structure = gst_structure_new ("video/x-raw-gray",
 473           "bpp", G_TYPE_INT, 8, NULL);
 474       break;
 475     case V4L2_PIX_FMT_YYUV:    /* 16  YUV 4:2:2     */
 476     case V4L2_PIX_FMT_HI240:   /*  8  8-bit color   */
 477       /* FIXME: get correct fourccs here */
 478       break;
 479     case V4L2_PIX_FMT_NV12:    /* 12  Y/CbCr 4:2:0  */
 480     case V4L2_PIX_FMT_NV21:    /* 12  Y/CrCb 4:2:0  */
 481     case V4L2_PIX_FMT_NV61:
 482     case V4L2_PIX_FMT_NV16:
 483     case V4L2_PIX_FMT_YVU410:
 484     case V4L2_PIX_FMT_YUV410:
 485     case V4L2_PIX_FMT_YUV420:  /* I420/IYUV */
 486     case V4L2_PIX_FMT_YUYV:
 487     case V4L2_PIX_FMT_YVU420:
 488     case V4L2_PIX_FMT_UYVY:
 489     case V4L2_PIX_FMT_Y41P:
 490     case V4L2_PIX_FMT_YUV422P:
 491     case V4L2_PIX_FMT_YUV444:
 492 #ifdef V4L2_PIX_FMT_YVYU
 493     case V4L2_PIX_FMT_YVYU:
 494 #endif
 495     case V4L2_PIX_FMT_YUV411P:{
 496       guint32 fcc = 0;
 497
 498       switch (fourcc) {
 499         case V4L2_PIX_FMT_NV12:
 500           fcc = GST_MAKE_FOURCC ('N', 'V', '1', '2');
 501           break;
 502         case V4L2_PIX_FMT_NV21:
 503           fcc = GST_MAKE_FOURCC ('N', 'V', '2', '1');
 504           break;
 505         case V4L2_PIX_FMT_NV16:
 506           fcc = GST_MAKE_FOURCC ('N', 'V', '1', '6');
 507           break;
 508         case V4L2_PIX_FMT_NV61:
 509           fcc = GST_MAKE_FOURCC ('N', 'V', '6', '1');
 510           break;
 511         case V4L2_PIX_FMT_YVU410:
 512           fcc = GST_MAKE_FOURCC ('Y', 'V', 'U', '9');
 513           break;
 514         case V4L2_PIX_FMT_YUV410:
 515           fcc = GST_MAKE_FOURCC ('Y', 'U', 'V', '9');
 516           break;
 517         case V4L2_PIX_FMT_YUV420:
 518           fcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
 519           break;
 520         case V4L2_PIX_FMT_YUYV:
 521           fcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
 522           break;
 523         case V4L2_PIX_FMT_YVU420:
 524           fcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2');
 525           break;
 526         case V4L2_PIX_FMT_UYVY:
 527           fcc = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');
 528           break;
 529         case V4L2_PIX_FMT_Y41P:
 530           fcc = GST_MAKE_FOURCC ('Y', '4', '1', 'P');
 531           break;
 532         case V4L2_PIX_FMT_YUV411P:
 533           fcc = GST_MAKE_FOURCC ('Y', '4', '1', 'B');
 534           break;
 535         case V4L2_PIX_FMT_YUV422P:
 536           fcc = GST_MAKE_FOURCC ('Y', '4', '2', 'B');
 537           break;
 538         case V4L2_PIX_FMT_YUV444:
 539           fcc = GST_MAKE_FOURCC ('Y', '4', '4', '4');
 540           break;
 541 #ifdef V4L2_PIX_FMT_YVYU
 542         case V4L2_PIX_FMT_YVYU:
 543           fcc = GST_MAKE_FOURCC ('Y', 'V', 'Y', 'U');
 544           break;
 545 #endif
 546         default:
 547           g_assert_not_reached ();
 548           break;
 549       }
 550       structure = gst_structure_new ("video/x-raw-yuv",
 551           "format", GST_TYPE_FOURCC, fcc, NULL);
 552       break;
 553     }
 554     case V4L2_PIX_FMT_SBGGR8:
 555     case V4L2_PIX_FMT_SGBRG8:
 556     case V4L2_PIX_FMT_SGRBG8:
 557     case V4L2_PIX_FMT_SRGGB8:
 558     case V4L2_PIX_FMT_SBGGR10:
 559     case V4L2_PIX_FMT_SGBRG10:
 560     case V4L2_PIX_FMT_SGRBG10:
 561     case V4L2_PIX_FMT_SRGGB10:
 562 #ifdef V4L2_PIX_FMT_SBGGR16
 563     case V4L2_PIX_FMT_SBGGR16:{
 564 #endif
 565       guint32 fcc = 0;
 566       switch (fourcc) {
 567         case V4L2_PIX_FMT_SBGGR8:
 568           fcc = GST_MAKE_FOURCC ('B', 'A', '8', '1');
 569           break;
 570         case V4L2_PIX_FMT_SGBRG8:
 571           fcc = GST_MAKE_FOURCC ('G', 'B', 'R', 'G');
 572           break;
 573         case V4L2_PIX_FMT_SGRBG8:
 574           fcc = GST_MAKE_FOURCC ('G', 'R', 'B', 'G');
 575           break;
 576         case V4L2_PIX_FMT_SRGGB8:
 577           fcc = GST_MAKE_FOURCC ('R', 'G', 'G', 'B');
 578           break;
 579         case V4L2_PIX_FMT_SBGGR10:
 580           fcc = GST_MAKE_FOURCC ('B', 'G', '1', '0');
 581           break;
 582         case V4L2_PIX_FMT_SGBRG10:
 583           fcc = GST_MAKE_FOURCC ('G', 'B', '1', '0');
 584           break;
 585         case V4L2_PIX_FMT_SGRBG10:
 586           fcc = GST_MAKE_FOURCC ('B', 'A', '1', '0');
 587           break;
 588         case V4L2_PIX_FMT_SRGGB10:
 589           fcc = GST_MAKE_FOURCC ('R', 'G', '1', '0');
 590           break;
 591         case V4L2_PIX_FMT_SBGGR16:
 592           fcc = GST_MAKE_FOURCC ('B', 'Y', 'R', '2');
 593           break;
 594         default:
 595           g_assert_not_reached ();
 596           break;
 597       }
 598       structure = gst_structure_new ("video/x-raw-bayer",
 599           "format", GST_TYPE_FOURCC, fcc, NULL);
 600       break;
 601     }
 602     default:
 603       GST_DEBUG ("Unknown fourcc 0x%08x %" GST_FOURCC_FORMAT,
 604           fourcc, GST_FOURCC_ARGS (fourcc));
 605       break;
 606   }
 607
 608   return structure;
 609 }
 610
 611 /*
 612  * gst_v4l2camsrc_get_caps:
 613  *
 614  */
 615 static GstCaps *
 616 gst_v4l2camsrc_get_caps (GstCameraSrc * camsrc)
 617 {
 618   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (camsrc);
 619   GstStructure *template;
 620   GstCaps *ret;
 621   GSList *walk;
 622
 623   if (!gst_v4l2camsrc_is_open (camsrc)) {
 624     /* FIXME: should it probe the device? */
 625     return NULL;
 626   }
 627
 628   if (!v4l2camsrc->formats)
 629     gst_v4l2camsrc_fill_format_list (v4l2camsrc);
 630
 631   ret = gst_caps_new_empty ();
 632
 633   for (walk = v4l2camsrc->formats; walk; walk = walk->next) {
 634     struct v4l2_fmtdesc *format;
 635     GSList *it;
 636
 637     /* FIXME: Introduce own format structure */
 638     format = (struct v4l2_fmtdesc *) walk->data;
 639
 640     struct cached_gst_caps *val, key = {
 641       .input = v4l2camsrc->input_sensor,
 642       .mode = v4l2camsrc->capture_mode,
 643       .pixelformat = format->pixelformat
 644     };
 645
 646     it = g_slist_find_custom(v4l2camsrc->caps_cache, &key, (GCompareFunc)caps_cache_cmp);
 647     if(it) {
 648       val = (struct cached_gst_caps *) it->data;
 649       gst_caps_append(ret, gst_caps_ref(val->caps));
 650       GST_DEBUG_OBJECT(v4l2camsrc, "Using cached caps for (sensor=%d,mode=%d,format=%0.4s)",
 651                          val->input,val->mode,(char*)&val->pixelformat);
 652       continue;
 653     }
 654
 655     GST_DEBUG_OBJECT(v4l2camsrc, "Now probing for (sensor=%d,mode=%d,format=%0.4s)",
 656       key.input,key.mode,(char*)&key.pixelformat);
 657     template = gst_v4l2camsrc_v4l2fourcc_to_structure (format->pixelformat);
 658
 659     if (template) {
 660       GstCaps *tmp;
 661
 662       tmp = gst_v4l2camsrc_probe_caps_for_format (v4l2camsrc,
 663           format->pixelformat, template);
 664       if (tmp) {
 665         val = malloc(sizeof *val);
 666         memcpy(val, &key, sizeof *val);
 667         val->caps = gst_caps_ref(tmp);
 668         v4l2camsrc->caps_cache = g_slist_prepend(v4l2camsrc->caps_cache, val);
 669         gst_caps_append (ret, tmp);
 670       }
 671
 672       gst_structure_free (template);
 673     } else {
 674       GST_DEBUG_OBJECT (v4l2camsrc, "unknown format %u", format->pixelformat);
 675     }
 676   }
 677
 678   GstStructure * structure = gst_structure_from_string(surface_string, NULL);
 679   gst_caps_append_structure (ret, structure);
 680
 681   v4l2camsrc->probed_caps = gst_caps_ref (ret);
 682
 683   GST_INFO_OBJECT (v4l2camsrc, "caps: %" GST_PTR_FORMAT, ret);
 684
 685   return ret;
 686 }
 687
 688 /*
 689  * gst_v4l2camsrc_get_num_buffers:
 690  *
 691  */
 692 static guint
 693 gst_v4l2camsrc_get_num_buffers (GstCameraSrc * camsrc)
 694 {
 695   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (camsrc);
 696
 697   return v4l2camsrc->num_buffers;
 698 }
 699
 700
 701 /*
 702  * gst_v4l2camsrc_base_init:
 703  * @klass: #GstElementClass.
 704  *
 705  */
 706 static void
 707 gst_v4l2camsrc_base_init (gpointer klass)
 708 {
 709   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 710
 711   gst_element_class_set_details_simple (element_class,
 712       "V4L2 camera source",
 713       "Video/Src",
 714       "Video4Linux2 camera source element",
 715       "Maemo Multimedia <multimedia@maemo.org>");
 716
 717   gst_element_class_add_pad_template (element_class,
 718        gst_static_pad_template_get (&gst_v4l2camsrc_template));
 719 }
 720
 721 gboolean gst_v4l2camsrc_set_autofocus (GstCameraSrc * camsrc, gboolean on);
 722 GstPhotoCaps gst_v4l2camsrc_get_capabilities (GstCameraSrc * camsrc);
 723 gboolean gst_v4l2camsrc_set_capture_mode (GstCameraSrc * camsrc,
 724     GstCameraSrcCaptureMode mode);
 725 gboolean
 726 gst_v4l2camsrc_read_settings (GstCameraSrc * camsrc,
 727     GstPhotoSettings * photoconf);
 728 gboolean gst_v4l2camsrc_write_settings (GstCameraSrc * camsrc,
 729     GstPhotoSettings * photoconf, gboolean scene_override);
 730 gboolean
 731 gst_v4l2camsrc_set_flash_mode (GstCameraSrc *camsrc, int value);
 732 gboolean
 733 gst_v4l2camsrc_read_exif (GstCameraSrc *camsrc,
 734     GstCameraControlExifInfo *exif_info);
 735 gboolean
 736 gst_v4l2camsrc_set_strobe_state (GstCameraSrc *camsrc, gboolean state);
 737
 738 gboolean
 739 gst_v4l2camsrc_set_AeAafwindow (GstCameraSrc * camsrc, GstCameraSrc3a_window window);
 740
 741 /*
 742  * gst_v4l2camsrc_class_init:
 743  * @klass: #GstMFLDV4l2CamSrcClass.
 744  *
 745  */
 746 static void
 747 gst_v4l2camsrc_class_init (GstMFLDV4l2CamSrcClass * klass)
 748 {
 749   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 750   GstCameraSrcClass *camera_class = GST_CAMERA_SRC_CLASS (klass);
 751
 752   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_property);
 753   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_property);
 754   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_dispose);
 755   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_finalize);
 756
 757   g_object_class_install_property (gobject_class, PROP_DEVICE,
 758       g_param_spec_string ("device", "Device", "Device location",
 759           DEFAULT_PROP_DEVICE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 760
 761   g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
 762       g_param_spec_string ("device-name", "Device name",
 763           "Name of the device", DEFAULT_PROP_DEVICE_NAME,
 764           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 765
 766   g_object_class_install_property (gobject_class, PROP_DEVICE_FD,
 767       g_param_spec_int ("device-fd", "File descriptor",
 768           "File descriptor of the device", -1, G_MAXINT, DEFAULT_PROP_DEVICE_FD,
 769           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 770
 771   g_object_class_install_property (gobject_class, PROP_QUEUE_SIZE,
 772       g_param_spec_uint ("queue-size", "Queue size",
 773           "Number of buffers to be enqueud in the driver",
 774           GST_V4L2CAMSRC_MIN_BUFFERS, GST_V4L2CAMSRC_MAX_BUFFERS,
 775           GST_V4L2CAMSRC_DEFAULT_BUFFERS,
 776           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 777
 778   g_object_class_install_property (gobject_class, PROP_INPUT_SENSOR,
 779       g_param_spec_enum ("camera-id", "Camera Id",
 780           "Which sensor is the input of the ISP",
 781           GST_TYPE_CAMERA_INPUT_SENSOR,
 782           GST_CAMERA_INPUT_SENSOR_PRIMARY,
 783           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 784
 785   g_object_class_install_property (gobject_class, PROP_USE_MMAP,
 786       g_param_spec_boolean ("use-mmap", "Use Mmap",
 787           "Whether use mmap memory method", FALSE, G_PARAM_READWRITE));
 788
 789   g_object_class_install_property (gobject_class, PROP_USE_COPY,
 790       g_param_spec_boolean ("use-copy", "Use Copy",
 791           "Whether copy the buffer from driver, debug only", FALSE, G_PARAM_READWRITE));
 792
 793   /* AE, AF, and AWB settings */
 794   g_object_class_install_property (gobject_class, PROP_3A,
 795       g_param_spec_boolean ("use-3a", "Use 3A",
 796           "3A processsing is On or Off", TRUE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 797
 798   g_object_class_install_property (gobject_class, PROP_AE_METERING_MODE,
 799       g_param_spec_enum ("ae-metering-mode", "AE Metering Mode",
 800           "Select AE Metering Mode",
 801           GST_TYPE_CAMERA_AE_METERING_MODE,
 802           GST_CAMERA_AE_METERING_AUTO,
 803           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 804
 805   g_object_class_install_property (gobject_class, PROP_AE_MODE,
 806       g_param_spec_enum ("ae-mode", "AE Mode",
 807           "Select AE Mode",
 808           GST_TYPE_CAMERA_AE_MODE,
 809           GST_CAMERA_AE_MODE_AUTO,
 810           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 811
 812  g_object_class_install_property (gobject_class, PROP_AE_WINDOW,
 813       g_param_spec_string("ae-window", "AE Window",
 814           "Set AE Window Coordinates in format: x_left=value,x_right=value,"
 815           "y_bottom=value,y_top=value",
 816           DEFAULT_PROP_AE_WINDOW,
 817           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ));
 818
 819   g_object_class_install_property (gobject_class, PROP_AF_METERING_MODE,
 820       g_param_spec_enum ("af-metering-mode", "AF Metering Mode",
 821           "Select AF Metering Mode",
 822           GST_TYPE_CAMERA_AF_METERING_MODE,
 823           GST_CAMERA_AF_METERING_AUTO,
 824           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 825
 826  g_object_class_install_property (gobject_class, PROP_AF_WINDOW,
 827       g_param_spec_string("af-window", "AF Window",
 828           "Set AF Window Coordinates in format: x_left=value,x_right=value,"
 829           "y_bottom=value,y_top=value",
 830           DEFAULT_PROP_AF_WINDOW,
 831           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ));
 832
 833   g_object_class_install_property (gobject_class, PROP_STILL_AF,
 834       g_param_spec_boolean ("still-af", "still image slow focus",
 835           "Turn On or Off slow focus when doing the still image capture",
 836           TRUE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 837
 838   g_object_class_install_property (gobject_class, PROP_FOCUS_POSITION,
 839       g_param_spec_int ("focus-posi", "Focus Position",
 840           "Focus absolute position set to Sensor.", FOCUS_POSITION_MIN,
 841           FOCUS_POSITION_MAX, 0,
 842           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_CONTROLLABLE));
 843
 844   g_object_class_install_property (gobject_class, PROP_BAYER_DOWNSCALING,
 845       g_param_spec_boolean ("bayer-downscaling", "Bayer Downscaling crop",
 846           "Turn On or Off Bayer Downscaling", TRUE, G_PARAM_READWRITE));
 847
 848   /* These are advanced ISP features for MFLD camera only */
 849   g_object_class_install_property (gobject_class, PROP_CAPTURE_CORRECTION_GDC,
 850       g_param_spec_boolean ("GDC", "GDC",
 851           "Capture Correction for Lens Geometry Distortion Correction",
 852           FALSE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 853
 854   g_object_class_install_property (gobject_class, PROP_CAPTURE_CORRECTION_CAC,
 855       g_param_spec_boolean ("CAC", "CAC",
 856           "Capture Correction for Chromatic Aberration Correction",
 857           FALSE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 858
 859   g_object_class_install_property (gobject_class, PROP_CAPTURE_CORRECTION_RER,
 860       g_param_spec_boolean ("redeye-reduction", "Redeye reduction",
 861           "Capture Correction for Redeye reduction",
 862           FALSE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 863
 864   g_object_class_install_property (gobject_class, PROP_CAPTURE_CORRECTION_DIS,
 865       g_param_spec_boolean ("still-stable", "Still stabilization",
 866           "Capture Correction for still image stabilization", FALSE,
 867           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 868
 869   g_object_class_install_property (gobject_class, PROP_CAPTURE_CORRECTION_DVS,
 870       g_param_spec_boolean ("video-stable", "Video stabilization",
 871           "Capture Correction for video capture stabilization", FALSE,
 872           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 873
 874   g_object_class_install_property (gobject_class,
 875       PROP_CAPTURE_CORRECTION_EDGE_ENHANCEMENT,
 876       g_param_spec_boolean ("edge-enhancement", "Edge Enhancement",
 877           "Capture Correction for edge enhancement", TRUE, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 878
 879   g_object_class_install_property (gobject_class,
 880       PROP_CAPTURE_CORRECTION_SHADING_CORRECTION,
 881       g_param_spec_boolean ("shading-correction", "Shading Correction",
 882           "Capture Correction for shading correction", TRUE,
 883           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 884
 885   g_object_class_install_property (gobject_class,
 886       PROP_CAPTURE_CORRECTION_BLACK_LEVEL_COMPENSATION,
 887       g_param_spec_boolean ("black-level-compensation", "Black Level Compensation",
 888           "Capture Correction for Black Level Compensation", FALSE,
 889           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 890
 891   g_object_class_install_property (gobject_class,
 892       PROP_CAPTURE_CORRECTION_BAD_PIXEL_DETECTION,
 893       g_param_spec_boolean ("bad-pixel-detection", "Bad Pixel Detection",
 894           "Capture Correction for Bad Pixel Detection", TRUE,
 895           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 896
 897   g_object_class_install_property (gobject_class, PROP_CAPTURE_CORRECTION_GAMMA,
 898       g_param_spec_float ("gamma", "Gamma",
 899           "Gamma Values", 1.0, 2.4, 2.2,
 900           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_CONTROLLABLE));
 901
 902   g_object_class_install_property (gobject_class,
 903       PROP_CAPTURE_CORRECTION_CONTRAST, g_param_spec_int ("contrast",
 904           "Contrast", "Contrast Values", 0, 2048, 256,
 905           G_PARAM_READWRITE |G_PARAM_STATIC_STRINGS | GST_PARAM_CONTROLLABLE));
 906
 907   g_object_class_install_property (gobject_class,
 908       PROP_CAPTURE_CORRECTION_BRIGHTNESS, g_param_spec_int ("brightness",
 909           "Brightness", "Brightness Values", -255, 255, 0,
 910           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_CONTROLLABLE));
 911
 912   g_object_class_install_property (gobject_class, PROP_DUMP_RAW,
 913       g_param_spec_boolean ("dump-raw", "Dump RAW images simultanious",
 914           "Whether dump the raw images as output when during the jpeg capture",
 915           FALSE, G_PARAM_READWRITE));
 916
 917   g_object_class_install_property (gobject_class, PROP_DUMP_IMAGE,
 918       g_param_spec_boolean ("dump-image", "Dump images simultanious in pipeline",
 919           "Whether dump the  images as output in pipeline, debug only,"
 920           "output the image in current directory",
 921           FALSE, G_PARAM_READWRITE));
 922
 923   g_object_class_install_property (gobject_class, PROP_DEBUG_FLAGS,
 924       g_param_spec_flags ("debug-flags", "debug flags",
 925           "debug flags for development and performance tuning usage",
 926           GST_TYPE_CAMERASRC_DEBUG_FLAGS, DEFAULT_DEBUG_FLAGS,
 927           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 928
 929   g_object_class_install_property (gobject_class,
 930       PROP_VFLIP,
 931       g_param_spec_boolean ("vflip", "Vertical Flip",
 932           "Vertical flip", FALSE,
 933           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 934
 935   g_object_class_install_property (gobject_class,
 936       PROP_HFLIP,
 937       g_param_spec_boolean ("hflip", "Horisontal Flip",
 938           "Horisontal flip", FALSE,
 939           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
 940
 941   g_object_class_install_property (gobject_class,
 942       PROP_DISABLE_LOW_RES_CROP,
 943       g_param_spec_boolean ("disable-low-res-crop", "disable low resolution crop",
 944           "disable software crop on unsupported low resolution frame size", FALSE,
 945           G_PARAM_READWRITE));
 946
 947   g_object_class_install_property (gobject_class,
 948       PROP_DRAW_CORNER_MARKERS,
 949       g_param_spec_boolean ("draw-corner-markers", "draw markers in frame corners",
 950           "draw markers in frame corners", FALSE,
 951           G_PARAM_READWRITE));
 952
 953   camera_class->is_open = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_is_open);
 954   camera_class->open = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_open);
 955   camera_class->close = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_close);
 956   camera_class->get_attribute =
 957       GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_attribute);
 958   camera_class->set_attribute =
 959       GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_attribute);
 960   camera_class->set_capture = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_capture);
 961   camera_class->start = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_capture_start);
 962   camera_class->is_active = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_is_active);
 963   camera_class->grab_frame = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_grab_frame);
 964   camera_class->stop = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_capture_stop);
 965   camera_class->get_caps = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_caps);
 966   camera_class->get_num_buffers =
 967       GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_num_buffers);
 968   camera_class->unlock = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_unlock);
 969   camera_class->unlock_stop = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_unlock_stop);
 970
 971   camera_class->set_capture_mode =
 972       GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_capture_mode);
 973 //  camera_class->set_vfinder_mode = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_set_viewfinder_mode);
 974   camera_class->set_autofocus =
 975       GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_autofocus);
 976   camera_class->read_settings =
 977       GST_DEBUG_FUNCPTR (gst_v4l2camsrc_read_settings);
 978   camera_class->write_settings =
 979       GST_DEBUG_FUNCPTR (gst_v4l2camsrc_write_settings);
 980   camera_class->get_capabilities =
 981       GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_capabilities);
 982   camera_class->set_zoom = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_zoom);
 983   camera_class->set_AeAafwindow = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_AeAafwindow);
 984   camera_class->set_ae_mode = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_set_ae_mode);
 985   camera_class->get_ae_mode = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_ae_mode);
 986
 987   camera_class->get_makernote = GST_DEBUG_FUNCPTR (gst_v4l2camsrc_get_makernote);
 988   camera_class->makernote_init = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_makernote_init);
 989   camera_class->makernote_deal = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_makernote_deal);
 990   camera_class->makernote_uninit = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_makernote_uninit);
 991   camera_class->set_flash_mode = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_set_flash_mode);
 992   camera_class->read_exif = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_read_exif);
 993
 994   camera_class->set_strobe_state = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_set_strobe_state);
 995
 996 //camera_class->fill_image_tags = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_fill_image_tags);
 997 //camera_class->get_preview_image = GST_DEBUG_FUNCPTR(gst_v4l2camsrc_get_preview_image);
 998 }
 999
1000 /*
1001  * gst_v4l2camsrc_driver_wrapper_load:
1002  * Create the mfldadvci object. The function in libmfldadvci can
1003  * be called from this source element now
1004  */
1005 GstV4l2MFLDAdvCI *
1006 gst_v4l2camsrc_mfldadvci_wrapper_load (GstMFLDV4l2CamSrc * v4l2camsrc)
1007 {
1008   GstV4l2MFLDAdvCI *mfldadvci;
1009
1010   mfldadvci = g_new0 (GstV4l2MFLDAdvCI, 1);
1011   wrapper_default_link_functions_init(mfldadvci);
1012
1013 #ifdef USE_DYNAMIC_3A
1014   if (g_module_supported ()) {
1015     gchar *module_file;
1016     module_file = g_module_build_path (MFLD_ADVCI_PATH, "libmfldadvci.so.0");
1017     GST_DEBUG_OBJECT (v4l2camsrc, "Loading %s", module_file);
1018
1019     v4l2camsrc->module = g_module_open (module_file, G_MODULE_BIND_LOCAL);
1020
1021     /* Open again if libmfldadvci.so.0 doesn't exist */
1022     if (!v4l2camsrc->module) {
1023       module_file = g_module_build_path (MFLD_ADVCI_PATH, "libmfldadvci.so");
1024       v4l2camsrc->module = g_module_open (module_file, G_MODULE_BIND_LOCAL);
1025       GST_DEBUG_OBJECT (v4l2camsrc, "Loading %s", module_file);
1026     }
1027     GST_DEBUG_OBJECT(v4l2camsrc, "Camera Source Interface version is %d\n", LIBMFLDADVCI_VERSION);
1028     if (v4l2camsrc->module) {
1029       lib_3a_link_functions_init(mfldadvci, v4l2camsrc->module);
1030     }
1031   }
1032 #endif /* USE_DYNAMIC_3A */
1033
1034   return mfldadvci;
1035 }
1036
1037 /*
1038  * gst_v4l2camsrc_mfldadvci_wrapper_unload:
1039  * Unload the libmfldadvci and free its resource
1040  */
1041 void
1042 gst_v4l2camsrc_mfldadvci_wrapper_unload (GstMFLDV4l2CamSrc * v4l2camsrc)
1043 {
1044   GstV4l2MFLDAdvCI *mfldadvci = v4l2camsrc->mfldadvci;
1045
1046   GST_DEBUG ("mfldadvci unload");
1047   g_module_close (v4l2camsrc->module);
1048   v4l2camsrc->module = NULL;
1049
1050   g_free (mfldadvci);
1051
1052 }
1053
1054
1055
1056 /*
1057  * gst_v4l2camsrc_init:
1058  * @v4l2camsrc: #GstMFLDV4l2CamSrc.
1059  * @klass: #GstMFLDV4l2CamSrcClass.
1060  *
1061  */
1062 static void
1063 gst_v4l2camsrc_init (GstMFLDV4l2CamSrc * v4l2camsrc,
1064     GstMFLDV4l2CamSrcClass * klass)
1065 {
1066   v4l2camsrc->num_buffers = GST_V4L2CAMSRC_DEFAULT_BUFFERS;
1067   v4l2camsrc->tmp_num_buffers = v4l2camsrc->num_buffers;
1068   v4l2camsrc->videodev = g_strdup (DEFAULT_PROP_DEVICE);
1069   v4l2camsrc->video_fd = DEFAULT_PROP_DEVICE_FD;
1070   v4l2camsrc->poll = gst_poll_new (TRUE);
1071   v4l2camsrc->buffer = NULL;
1072   v4l2camsrc->crop_supported = FALSE;
1073   v4l2camsrc->max_zoom_factor = MAX_RESIZER_FACTOR;
1074   v4l2camsrc->zoom_factor = DEFAULT_RESIZER_FACTOR;
1075   v4l2camsrc->use_mmap = TRUE;
1076   v4l2camsrc->use_copy = FALSE;
1077   v4l2camsrc->capture_mode = GST_CAMERA_SRC_CAPTURE_MODE_VIEWFINDER;
1078   /* MFLD camera Advanced features status */
1079   v4l2camsrc->gdc_enabled = FALSE;
1080   v4l2camsrc->rer_enabled = FALSE;
1081   v4l2camsrc->cac_enabled = FALSE;
1082   v4l2camsrc->dvs_enabled = FALSE;
1083   v4l2camsrc->dis_enabled = FALSE;
1084   v4l2camsrc->ee_enabled = TRUE;
1085   v4l2camsrc->sc_enabled = TRUE;
1086   v4l2camsrc->cc_updated = FALSE;
1087   v4l2camsrc->gamma_updated = FALSE;
1088   v4l2camsrc->ae_awb_af_enabled = TRUE;
1089   v4l2camsrc->still_af = FALSE;
1090   v4l2camsrc->bayer_downscaling = FALSE;
1091   v4l2camsrc->tone.gamma = 2.2;
1092   v4l2camsrc->tone.brightness = 0;
1093   v4l2camsrc->tone.contrast = 256;
1094
1095   v4l2camsrc->preflash_enabled = FALSE;
1096   v4l2camsrc->capflash_enabled = FALSE;
1097   v4l2camsrc->preflash_analoggain = 0;
1098
1099   v4l2camsrc->dump_raw = FALSE;
1100   v4l2camsrc->dump_image = FALSE;
1101   v4l2camsrc->raw_output_size = 0;
1102   v4l2camsrc->debug_flags = DEFAULT_DEBUG_FLAGS;
1103   v4l2camsrc->disable_low_res_crop = FALSE;
1104   v4l2camsrc->draw_corner_markers = FALSE;
1105
1106   v4l2camsrc->device_mutex = g_mutex_new ();
1107
1108   v4l2camsrc->caps_cache = NULL;
1109
1110   v4l2camsrc->mfldadvci = gst_v4l2camsrc_mfldadvci_wrapper_load (v4l2camsrc);
1111
1112   v4l2camsrc->input_sensor = GST_CAMERA_INPUT_SENSOR_PRIMARY;
1113   v4l2camsrc->ae_metering_mode = GST_CAMERA_AE_METERING_AUTO;
1114   v4l2camsrc->ae_mode = GST_CAMERA_AE_MODE_AUTO;
1115   v4l2camsrc->af_metering_mode = GST_CAMERA_AF_METERING_AUTO;
1116
1117   v4l2camsrc->ae_window.x_left = 0;
1118   v4l2camsrc->ae_window.x_right = 0;
1119   v4l2camsrc->ae_window.y_bottom = 0;
1120   v4l2camsrc->ae_window.y_top = 0;
1121   v4l2camsrc->ae_window.weight= 0x8000;
1122   v4l2camsrc->af_window.x_left = 0;
1123   v4l2camsrc->af_window.x_right = 0;
1124   v4l2camsrc->af_window.y_bottom = 0;
1125   v4l2camsrc->af_window.y_top = 0;
1126   v4l2camsrc->af_window.weight= 0x8000;
1127
1128   libmfld_cam_init (v4l2camsrc->mfldadvci);
1129
1130   GST_DEBUG ("initialized to commit %s", MFLD_V4L2CAMSRC_VERSION);
1131 }
1132
1133 static void caps_cache_destroy_value(struct cached_gst_caps *val)
1134 {
1135   if(!val)
1136     return;
1137   if(val->caps)
1138     gst_caps_unref(val->caps);
1139   free(val);
1140 }
1141
1142 static void
1143 gst_v4l2camsrc_dispose (GObject * object)
1144 {
1145   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (object);
1146
1147   if (v4l2camsrc->caps_cache)
1148     g_slist_free_full(v4l2camsrc->caps_cache, (GDestroyNotify) caps_cache_destroy_value);
1149   v4l2camsrc->caps_cache = NULL;
1150
1151   if (v4l2camsrc->formats) {
1152     gst_v4l2camsrc_clear_format_list (v4l2camsrc);
1153   }
1154
1155   if (v4l2camsrc->probed_caps) {
1156     gst_caps_unref (v4l2camsrc->probed_caps);
1157     v4l2camsrc->probed_caps = NULL;
1158   }
1159
1160   /* FIXME: driver cleanup function */
1161   if (v4l2camsrc->videodev) {
1162     g_free (v4l2camsrc->videodev);
1163     v4l2camsrc->videodev = NULL;
1164   }
1165
1166   if (v4l2camsrc->poll) {
1167     gst_poll_free (v4l2camsrc->poll);
1168   }
1169
1170   g_mutex_free (v4l2camsrc->device_mutex);
1171
1172   G_OBJECT_CLASS (parent_class)->dispose (object);
1173   libmfld_cam_dispose ();
1174   gst_v4l2camsrc_mfldadvci_wrapper_unload(v4l2camsrc);
1175 }
1176
1177
1178 /*
1179  * gst_v4l2camsrc_finalize:
1180  * @object:
1181  *
1182  */
1183 static void
1184 gst_v4l2camsrc_finalize (GObject * object)
1185 {
1186   G_OBJECT_CLASS (parent_class)->finalize (object);
1187 }
1188
1189
1190
1191 /*
1192  */
1193 static void
1194 gst_v4l2camsrc_set_property (GObject * object,
1195     guint prop_id, const GValue * value, GParamSpec * pspec)
1196 {
1197   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (object);
1198   gboolean opened = GST_V4L2CAMSRC_IS_OPEN (v4l2camsrc);
1199
1200   switch (prop_id) {
1201     case PROP_DEVICE:
1202       g_free (v4l2camsrc->videodev);
1203       v4l2camsrc->videodev = g_value_dup_string (value);
1204       break;
1205     case PROP_QUEUE_SIZE:
1206       v4l2camsrc->num_buffers = g_value_get_uint (value);
1207       v4l2camsrc->tmp_num_buffers = v4l2camsrc->num_buffers;
1208       break;
1209     case PROP_INPUT_SENSOR:
1210       v4l2camsrc->input_sensor = g_value_get_enum (value);
1211       break;
1212     case PROP_USE_MMAP:
1213       v4l2camsrc->use_mmap = g_value_get_boolean (value);
1214       break;
1215     case PROP_USE_COPY:
1216       v4l2camsrc->use_copy = g_value_get_boolean (value);
1217       break;
1218     case PROP_3A:
1219       v4l2camsrc->ae_awb_af_enabled = g_value_get_boolean (value);
1220       break;
1221     case PROP_AE_WINDOW:
1222     {
1223       GstStructure *ae_window_param = NULL;
1224       char * ctmp = NULL;
1225       gboolean parsed = TRUE;
1226
1227       ctmp = g_malloc0 (60);
1228       if (ctmp == NULL)
1229       {
1230              GST_DEBUG_OBJECT(v4l2camsrc, "alloc string mem failed.\n");
1231              break;
1232       }
1233       strncpy (ctmp,"ae,",3);
1234       strncat (ctmp,g_value_get_string (value),55);
1235       ae_window_param = gst_structure_from_string (ctmp, NULL);
1236       if(ae_window_param == NULL)
1237       {
1238               GST_DEBUG_OBJECT(v4l2camsrc,"wrong string format is entered. stop setting ae window.\n");
1239               g_free (ctmp);
1240               break;
1241       }
1242
1243       parsed = gst_structure_get_int(ae_window_param, "x_left",
1244                       &v4l2camsrc->ae_window.x_left);
1245       parsed |= gst_structure_get_int(ae_window_param, "x_right",
1246                       &v4l2camsrc->ae_window.x_right);
1247       parsed |= gst_structure_get_int(ae_window_param, "y_top",
1248                       &v4l2camsrc->ae_window.y_top);
1249       parsed |= gst_structure_get_int(ae_window_param, "y_bottom",
1250                       &v4l2camsrc->ae_window.y_bottom);
1251
1252       if (parsed == FALSE)
1253       {
1254                 GST_DEBUG_OBJECT(v4l2camsrc,"cannot parse ae window parameter. \n");
1255                 gst_structure_free (ae_window_param);
1256                 g_free (ctmp);
1257                 break;
1258       }
1259
1260       parsed = gst_structure_get_int(ae_window_param, "weight",
1261                       &v4l2camsrc->ae_window.weight);
1262
1263       if (parsed == FALSE)
1264       {
1265         GST_DEBUG_OBJECT(v4l2camsrc,
1266                              "set ae window weight to default value 0x8000.\n");
1267         v4l2camsrc->ae_window.weight = 0x8000;
1268       }
1269
1270       GST_DEBUG_OBJECT(v4l2camsrc,"ae-window-setting: x_left:%d, x_right:%d,"
1271                      "y_bottom:%d, y_top:%d, weight:%d.\n",
1272                       v4l2camsrc->ae_window.x_left,v4l2camsrc->ae_window.x_right,
1273                       v4l2camsrc->ae_window.y_bottom, v4l2camsrc->ae_window.y_top,
1274                      v4l2camsrc->ae_window.weight);
1275
1276
1277       if (v4l2camsrc->ae_metering_mode != GST_CAMERA_AE_METERING_SPOT)
1278       {
1279                 GST_DEBUG_OBJECT(v4l2camsrc,"wrong ae metering mode. set it to spot mode automaticly.\n");
1280                v4l2camsrc->ae_metering_mode = GST_CAMERA_AE_METERING_SPOT;
1281                 v4l2camsrc->mfldadvci->AeSetMeteringMode
1282                         ( (advci_ae_metering_mode) v4l2camsrc->ae_metering_mode);
1283
1284       }
1285       v4l2camsrc->mfldadvci->AeSetWindow ((advci_window *) (&(v4l2camsrc->ae_window)));
1286
1287       gst_structure_free (ae_window_param);
1288       g_free (ctmp);
1289       break;
1290     }
1291
1292     case PROP_AE_METERING_MODE:
1293     {
1294       v4l2camsrc->ae_metering_mode = g_value_get_enum (value);
1295       v4l2camsrc->mfldadvci->AeSetMeteringMode((advci_ae_metering_mode)v4l2camsrc->ae_metering_mode);
1296       break;
1297     }
1298     case PROP_AE_MODE:
1299     {
1300       v4l2camsrc->ae_mode = g_value_get_enum (value);
1301       v4l2camsrc->mfldadvci->AeSetMode((advci_ae_mode)v4l2camsrc->ae_mode);
1302       break;
1303     }
1304     case PROP_AF_METERING_MODE:
1305     {
1306       v4l2camsrc->af_metering_mode = g_value_get_enum (value);
1307       v4l2camsrc->mfldadvci->AfSetMeteringMode((advci_af_metering_mode)v4l2camsrc->af_metering_mode);
1308       break;
1309     }
1310     case PROP_AF_WINDOW:
1311     {
1312       GstStructure *af_window_param = NULL;
1313       char * ctmp = NULL;
1314       gboolean parsed = TRUE;
1315
1316       ctmp = g_malloc0 (60);
1317       if (ctmp == NULL)
1318       {
1319              GST_DEBUG_OBJECT(v4l2camsrc, "alloc string mem failed.\n");
1320              break;
1321       }
1322       strncpy (ctmp,"af,",3);
1323       strncat (ctmp,g_value_get_string (value),55);
1324       af_window_param = gst_structure_from_string (ctmp, NULL);
1325       if(af_window_param == NULL)
1326       {
1327               GST_DEBUG_OBJECT(v4l2camsrc,"wrong string format is entered. stop setting af window.\n");
1328               g_free (ctmp);
1329               break;
1330       }
1331
1332       parsed = gst_structure_get_int(af_window_param, "x_left",
1333                       &v4l2camsrc->af_window.x_left);
1334       parsed |= gst_structure_get_int(af_window_param, "x_right",
1335                       &v4l2camsrc->af_window.x_right);
1336       parsed |= gst_structure_get_int(af_window_param, "y_top",
1337                       &v4l2camsrc->af_window.y_top);
1338       parsed |= gst_structure_get_int(af_window_param, "y_bottom",
1339                       &v4l2camsrc->af_window.y_bottom);
1340
1341       if (parsed == FALSE)
1342       {
1343                 GST_DEBUG_OBJECT(v4l2camsrc,"cannot parse af window parameter. \n");
1344                 gst_structure_free (af_window_param);
1345                 g_free (ctmp);
1346                 break;
1347       }
1348
1349       parsed = gst_structure_get_int(af_window_param, "weight",
1350                       &v4l2camsrc->af_window.weight);
1351
1352       if (parsed == FALSE)
1353       {
1354              GST_DEBUG_OBJECT(v4l2camsrc,
1355                              "set af window weight to default value 0x8000.\n");
1356              v4l2camsrc->af_window.weight = 0x8000;
1357       }
1358
1359       GST_DEBUG_OBJECT(v4l2camsrc,"af-window-setting: x_left:%d, x_right:%d,"
1360                      "y_bottom:%d, y_top:%d, weight:%d.\n",
1361                       v4l2camsrc->af_window.x_left,v4l2camsrc->af_window.x_right,
1362                       v4l2camsrc->af_window.y_bottom, v4l2camsrc->af_window.y_top,
1363                      v4l2camsrc->af_window.y_top);
1364
1365
1366       v4l2camsrc->mfldadvci->AfSetWindows (1, (advci_window *) (&(v4l2camsrc->af_window)));
1367
1368       gst_structure_free (af_window_param);
1369       g_free (ctmp);
1370       break;
1371     }
1372
1373     case PROP_STILL_AF:
1374       v4l2camsrc->still_af = g_value_get_boolean (value);
1375       cam_set_autofocus (v4l2camsrc->still_af);
1376       break;
1377     case PROP_FOCUS_POSITION:
1378       v4l2camsrc->focus_posi = g_value_get_int(value);
1379       if (opened)
1380         cam_driver_set_focus_posi (v4l2camsrc->video_fd, v4l2camsrc->focus_posi);
1381       else
1382         v4l2camsrc->focus_updated = TRUE;
1383       break;
1384     case PROP_VFLIP:
1385       v4l2camsrc->vflip = g_value_get_boolean(value);
1386       if (gst_v4l2camsrc_is_open (GST_CAMERA_SRC (v4l2camsrc)))
1387         gst_v4l2camsrc_set_attribute (GST_CAMERA_SRC (v4l2camsrc),V4L2_CID_VFLIP,v4l2camsrc->vflip);
1388       break;
1389     case  PROP_HFLIP:
1390       v4l2camsrc->hflip = g_value_get_boolean(value);
1391       if (gst_v4l2camsrc_is_open (GST_CAMERA_SRC (v4l2camsrc)))
1392         gst_v4l2camsrc_set_attribute (GST_CAMERA_SRC (v4l2camsrc),V4L2_CID_HFLIP,v4l2camsrc->hflip);
1393       break;
1394     case PROP_BAYER_DOWNSCALING:
1395       v4l2camsrc->bayer_downscaling = g_value_get_boolean (value);
1396       break;
1397     case PROP_CAPTURE_CORRECTION_GDC:
1398       v4l2camsrc->gdc_enabled = g_value_get_boolean (value);
1399       if (opened)
1400         cam_set_capture_correction (v4l2camsrc->video_fd,
1401             CAM_CAPTURE_CORRECTION_GDC, v4l2camsrc->gdc_enabled);
1402       else
1403         v4l2camsrc->cc_updated = TRUE;
1404       break;
1405     case PROP_CAPTURE_CORRECTION_CAC:
1406       v4l2camsrc->cac_enabled = g_value_get_boolean (value);
1407       if (opened)
1408         cam_set_capture_correction (v4l2camsrc->video_fd,
1409             CAM_CAPTURE_CORRECTION_CAC, v4l2camsrc->cac_enabled);
1410       else
1411         v4l2camsrc->cc_updated = TRUE;
1412       break;
1413     case PROP_CAPTURE_CORRECTION_RER:
1414       v4l2camsrc->rer_enabled = g_value_get_boolean (value);
1415       cam_set_capture_correction (v4l2camsrc->video_fd,
1416           CAM_CAPTURE_CORRECTION_RER, v4l2camsrc->rer_enabled);
1417       break;
1418     case PROP_CAPTURE_CORRECTION_DIS:
1419       v4l2camsrc->dis_enabled = g_value_get_boolean (value);
1420       cam_set_capture_correction (v4l2camsrc->video_fd,
1421           CAM_CAPTURE_CORRECTION_DIS, v4l2camsrc->dis_enabled);
1422       break;
1423     case PROP_CAPTURE_CORRECTION_DVS:
1424       v4l2camsrc->dvs_enabled = g_value_get_boolean (value);
1425       if (opened)
1426         cam_set_capture_correction (v4l2camsrc->video_fd,
1427             CAM_CAPTURE_CORRECTION_DVS, v4l2camsrc->dvs_enabled);
1428       else
1429         v4l2camsrc->cc_updated = TRUE;
1430       break;
1431     case PROP_CAPTURE_CORRECTION_EDGE_ENHANCEMENT:
1432       v4l2camsrc->ee_enabled = g_value_get_boolean (value);
1433       if (opened)
1434         cam_set_capture_correction (v4l2camsrc->video_fd,
1435             CAM_CAPTURE_CORRECTION_EE, v4l2camsrc->ee_enabled);
1436       else
1437         v4l2camsrc->cc_updated = TRUE;
1438       break;
1439     case PROP_CAPTURE_CORRECTION_SHADING_CORRECTION:
1440       v4l2camsrc->sc_enabled = g_value_get_boolean (value);
1441       if (opened)
1442         cam_set_capture_correction (v4l2camsrc->video_fd,
1443             CAM_CAPTURE_CORRECTION_SC, v4l2camsrc->sc_enabled);
1444       else
1445         v4l2camsrc->cc_updated = TRUE;
1446       break;
1447     case PROP_CAPTURE_CORRECTION_BLACK_LEVEL_COMPENSATION:
1448       v4l2camsrc->blc_enabled = g_value_get_boolean (value);
1449       if (opened)
1450         cam_set_capture_correction (v4l2camsrc->video_fd,
1451             CAM_CAPTURE_CORRECTION_BLC, v4l2camsrc->blc_enabled);
1452       else
1453         v4l2camsrc->cc_updated = TRUE;
1454       break;
1455     case PROP_CAPTURE_CORRECTION_BAD_PIXEL_DETECTION:
1456       v4l2camsrc->bpd_enabled = g_value_get_boolean (value);
1457       if (opened)
1458         cam_set_capture_correction (v4l2camsrc->video_fd,
1459             CAM_CAPTURE_CORRECTION_BPD, v4l2camsrc->bpd_enabled);
1460       else
1461         v4l2camsrc->cc_updated = TRUE;
1462       break;
1463     case PROP_CAPTURE_CORRECTION_GAMMA:
1464       v4l2camsrc->tone.gamma = g_value_get_float (value);
1465       if (opened)
1466         cam_set_tone_control (v4l2camsrc->video_fd, CAM_GAMMA_VALUE,
1467             &v4l2camsrc->tone);
1468       else
1469         v4l2camsrc->gamma_updated = TRUE;
1470       break;
1471     case PROP_CAPTURE_CORRECTION_CONTRAST:
1472       v4l2camsrc->tone.contrast = g_value_get_int (value);
1473       if (opened)
1474         cam_set_tone_control (v4l2camsrc->video_fd, CAM_CONTRAST_VALUE,
1475             &v4l2camsrc->tone);
1476       else
1477         v4l2camsrc->gamma_updated = TRUE;
1478       break;
1479     case PROP_CAPTURE_CORRECTION_BRIGHTNESS:
1480       v4l2camsrc->tone.brightness = g_value_get_int (value);
1481       if (opened)
1482         cam_set_tone_control (v4l2camsrc->video_fd, CAM_BRIGHTNESS_VALUE,
1483             &v4l2camsrc->tone);
1484       else
1485         v4l2camsrc->gamma_updated = TRUE;
1486       break;
1487     case PROP_DUMP_RAW:
1488       v4l2camsrc->dump_raw = g_value_get_boolean (value);
1489       break;
1490     case PROP_DUMP_IMAGE:
1491       v4l2camsrc->dump_image = g_value_get_boolean (value);
1492       break;
1493     case PROP_DEBUG_FLAGS:
1494       v4l2camsrc->debug_flags = g_value_get_flags (value);
1495       break;
1496     case PROP_DISABLE_LOW_RES_CROP:
1497       v4l2camsrc->disable_low_res_crop = g_value_get_boolean (value);
1498       break;
1499     case PROP_DRAW_CORNER_MARKERS:
1500       v4l2camsrc->draw_corner_markers = g_value_get_boolean (value);
1501       break;
1502     default:
1503       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1504       break;
1505
1506
1507   }
1508 }
1509
1510 /*
1511  */
1512 static void
1513 gst_v4l2camsrc_get_property (GObject * object,
1514     guint prop_id, GValue * value, GParamSpec * pspec)
1515 {
1516   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (object);
1517
1518   switch (prop_id) {
1519     case PROP_DEVICE:
1520       g_value_set_string (value, v4l2camsrc->videodev);
1521       break;
1522     case PROP_DEVICE_NAME:
1523     {
1524       const guchar *new = NULL;
1525
1526       if (gst_v4l2camsrc_is_open (GST_CAMERA_SRC (v4l2camsrc))) {
1527         new = v4l2camsrc->vcap.card;
1528       } else if (gst_v4l2camsrc_open (GST_CAMERA_SRC (v4l2camsrc))) {
1529         new = v4l2camsrc->vcap.card;
1530         gst_v4l2camsrc_close (GST_CAMERA_SRC (v4l2camsrc));
1531         gst_camerasrc_clear_color_channels (GST_CAMERA_SRC (v4l2camsrc));
1532       }
1533       g_value_set_string (value, (gchar *) new);
1534       break;
1535     }
1536     case PROP_DEVICE_FD:
1537     {
1538       if (gst_v4l2camsrc_is_open (GST_CAMERA_SRC (v4l2camsrc)))
1539         g_value_set_int (value, v4l2camsrc->video_fd);
1540       else
1541         g_value_set_int (value, DEFAULT_PROP_DEVICE_FD);
1542       break;
1543     }
1544     case PROP_QUEUE_SIZE:
1545       g_value_set_uint (value, v4l2camsrc->num_buffers);
1546       break;
1547     case PROP_INPUT_SENSOR:
1548       g_value_set_enum (value, v4l2camsrc->input_sensor);
1549       break;
1550     case PROP_USE_MMAP:
1551       g_value_set_boolean (value, v4l2camsrc->use_mmap);
1552       break;
1553     case PROP_USE_COPY:
1554       g_value_set_boolean (value, v4l2camsrc->use_copy);
1555       break;
1556     case PROP_3A:
1557       g_value_set_boolean (value, v4l2camsrc->ae_awb_af_enabled);
1558       break;
1559     case PROP_AE_METERING_MODE:
1560       g_value_set_enum (value, v4l2camsrc->ae_metering_mode);
1561       break;
1562     case PROP_AE_MODE:
1563       g_value_set_enum (value, v4l2camsrc->ae_mode);
1564       break;
1565     case PROP_AE_WINDOW:
1566     {
1567       GstStructure *tmp = NULL;
1568       tmp = gst_structure_empty_new("ae-window");
1569       if(tmp == NULL)
1570       {
1571               GST_DEBUG ("wrong default ae window setting.\n");
1572               break;
1573       }
1574       gst_structure_set (tmp,"x_left", G_TYPE_INT,
1575                       v4l2camsrc->ae_window.x_left,NULL);
1576       gst_structure_set (tmp,"x_right", G_TYPE_INT,
1577                       v4l2camsrc->ae_window.x_right,NULL);
1578       gst_structure_set (tmp,"y_bottom", G_TYPE_INT,
1579                       v4l2camsrc->ae_window.y_bottom,NULL);
1580       gst_structure_set (tmp,"y_top", G_TYPE_INT,
1581                       v4l2camsrc->ae_window.y_top,NULL);
1582       g_value_set_string(value, gst_structure_to_string(tmp));
1583       gst_structure_free(tmp);
1584       break;
1585     }
1586     case PROP_AF_METERING_MODE:
1587       g_value_set_enum (value, v4l2camsrc->af_metering_mode);
1588       break;
1589     case PROP_AF_WINDOW:
1590     {
1591       GstStructure *tmp = NULL;
1592       tmp = gst_structure_empty_new("af-window");
1593       if(tmp == NULL)
1594       {
1595               GST_DEBUG ("wrong default af window setting.\n");
1596               break;
1597       }
1598       gst_structure_set (tmp,"x_left", G_TYPE_INT,
1599                       v4l2camsrc->af_window.x_left,NULL);
1600       gst_structure_set (tmp,"x_right", G_TYPE_INT,
1601                       v4l2camsrc->af_window.x_right,NULL);
1602       gst_structure_set (tmp,"y_bottom", G_TYPE_INT,
1603                       v4l2camsrc->af_window.y_bottom,NULL);
1604       gst_structure_set (tmp,"y_top", G_TYPE_INT,
1605                       v4l2camsrc->af_window.y_top,NULL);
1606       g_value_set_string(value, gst_structure_to_string(tmp));
1607       gst_structure_free(tmp);
1608       break;
1609     }
1610     case PROP_STILL_AF:
1611       g_value_set_boolean (value, v4l2camsrc->still_af);
1612       break;
1613     case PROP_FOCUS_POSITION:
1614       g_value_set_int (value, v4l2camsrc->focus_posi);
1615       break;
1616     case PROP_VFLIP:
1617       g_value_set_boolean (value, v4l2camsrc->vflip);
1618       break;
1619     case PROP_HFLIP:
1620       g_value_set_boolean (value,  v4l2camsrc->hflip);
1621       break;
1622     case PROP_BAYER_DOWNSCALING:
1623       g_value_set_boolean (value, v4l2camsrc->bayer_downscaling);
1624       break;
1625     case PROP_CAPTURE_CORRECTION_GDC:
1626       g_value_set_boolean (value, v4l2camsrc->gdc_enabled);
1627       break;
1628     case PROP_CAPTURE_CORRECTION_CAC:
1629       g_value_set_boolean (value, v4l2camsrc->cac_enabled);
1630       break;
1631     case PROP_CAPTURE_CORRECTION_RER:
1632       g_value_set_boolean (value, v4l2camsrc->rer_enabled);
1633       break;
1634     case PROP_CAPTURE_CORRECTION_DIS:
1635       g_value_set_boolean (value, v4l2camsrc->dis_enabled);
1636       break;
1637     case PROP_CAPTURE_CORRECTION_DVS:
1638       g_value_set_boolean (value, v4l2camsrc->dvs_enabled);
1639       break;
1640     case PROP_CAPTURE_CORRECTION_EDGE_ENHANCEMENT:
1641       g_value_set_boolean (value, v4l2camsrc->ee_enabled);
1642       break;
1643     case PROP_CAPTURE_CORRECTION_SHADING_CORRECTION:
1644       g_value_set_boolean (value, v4l2camsrc->sc_enabled);
1645       break;
1646     case PROP_CAPTURE_CORRECTION_BLACK_LEVEL_COMPENSATION:
1647       g_value_set_boolean (value, v4l2camsrc->blc_enabled);
1648       break;
1649     case PROP_CAPTURE_CORRECTION_BAD_PIXEL_DETECTION:
1650       g_value_set_boolean (value, v4l2camsrc->bpd_enabled);
1651       break;
1652     case PROP_CAPTURE_CORRECTION_GAMMA:
1653       g_value_set_float (value, v4l2camsrc->tone.gamma);
1654       break;
1655     case PROP_CAPTURE_CORRECTION_CONTRAST:
1656       g_value_set_int (value, v4l2camsrc->tone.contrast);
1657       break;
1658     case PROP_CAPTURE_CORRECTION_BRIGHTNESS:
1659       g_value_set_int (value, v4l2camsrc->tone.brightness);
1660       break;
1661     case PROP_DUMP_RAW:
1662       g_value_set_boolean (value, v4l2camsrc->dump_raw);
1663       break;
1664     case PROP_DUMP_IMAGE:
1665       g_value_set_boolean (value, v4l2camsrc->dump_image);
1666       break;
1667     case PROP_DEBUG_FLAGS:
1668       g_value_set_flags (value, v4l2camsrc->debug_flags);
1669       break;
1670     case PROP_DISABLE_LOW_RES_CROP:
1671       g_value_set_boolean (value, v4l2camsrc->disable_low_res_crop);
1672       break;
1673     case PROP_DRAW_CORNER_MARKERS:
1674       g_value_set_boolean (value, v4l2camsrc->draw_corner_markers);
1675       break;
1676     default:
1677       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1678       break;
1679   }
1680 }
1681
1682
1683
1684 static gboolean
1685 gst_v4l2camsrc_unlock (GstCameraSrc * src)
1686 {
1687   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (src);
1688
1689   GST_LOG_OBJECT (v4l2camsrc, "Flushing");
1690   gst_poll_set_flushing (v4l2camsrc->poll, TRUE);
1691
1692   return TRUE;
1693 }
1694
1695 static gboolean
1696 gst_v4l2camsrc_unlock_stop (GstCameraSrc * src)
1697 {
1698   GstMFLDV4l2CamSrc *v4l2camsrc = GST_V4L2CAMSRC (src);
1699
1700   GST_LOG_OBJECT (v4l2camsrc, "No longer flushing");
1701   gst_poll_set_flushing (v4l2camsrc->poll, FALSE);
1702
1703   return TRUE;
1704 }
1705
1706 /*
1707  * gst_v4l2camsrc_set_zoom:
1708  * @camsrc: @GstCameraSrc object.
1709  * @zoom: zoom factor to be set.
1710  *
1711  * Set the zoom factor for outputted video.
1712  *
1713  * Returns: TRUE on success.
1714  */
1715 static gboolean
1716 gst_v4l2camsrc_set_zoom (GstCameraSrc * camsrc, gfloat zoom)
1717 {
1718   GstMFLDV4l2CamSrc *v4l2camsrc;
1719   gboolean ret = TRUE;
1720
1721   v4l2camsrc = GST_V4L2CAMSRC (camsrc);
1722
1723   GST_DEBUG_OBJECT (v4l2camsrc, "ZOOM: %f", zoom);
1724
1725   v4l2camsrc->zoom_factor = zoom;
1726   if (v4l2camsrc->is_active) {
1727     g_mutex_lock (v4l2camsrc->device_mutex);
1728     ret = gst_v4l2camsrc_libmfldcam_set_zoom (v4l2camsrc, zoom);
1729     g_mutex_unlock (v4l2camsrc->device_mutex);
1730   } else
1731     v4l2camsrc->zoom_updated = TRUE;
1732
1733   return ret;
1734 }
1735 static gboolean
1736 gst_v4l2camsrc_set_ae_mode(GstCameraSrc * camsrc, int mode)
1737 {
1738   GstMFLDV4l2CamSrc *v4l2camsrc;
1739   gboolean ret = TRUE;
1740
1741   v4l2camsrc = GST_V4L2CAMSRC (camsrc);
1742
1743   if (v4l2camsrc->is_active) {
1744     g_mutex_lock (v4l2camsrc->device_mutex);
1745     v4l2camsrc->ae_metering_mode = *(GstCameraAEMeteringMode *)&mode;
1746     v4l2camsrc->mfldadvci->AeSetMeteringMode((advci_ae_metering_mode)v4l2camsrc->ae_metering_mode);
1747     g_mutex_unlock (v4l2camsrc->device_mutex);
1748   }
1749
1750   return ret;
1751 }
1752 static gboolean
1753 gst_v4l2camsrc_get_ae_mode(GstCameraSrc * camsrc, int *mode)
1754 {
1755   GstMFLDV4l2CamSrc *v4l2camsrc;
1756   gboolean ret = TRUE;
1757
1758   v4l2camsrc = GST_V4L2CAMSRC (camsrc);
1759
1760   if (v4l2camsrc->is_active) {
1761     g_mutex_lock (v4l2camsrc->device_mutex);
1762     *mode = v4l2camsrc->ae_metering_mode;
1763     g_mutex_unlock (v4l2camsrc->device_mutex);
1764   }
1765
1766   return ret;
1767 }
1768
1769 static gboolean
1770 gst_v4l2camsrc_get_makernote (GstCameraSrc * camsrc, unsigned char *buf, unsigned size)
1771 {
1772   GstMFLDV4l2CamSrc *v4l2camsrc;
1773   gboolean ret = TRUE;
1774
1775   v4l2camsrc = GST_V4L2CAMSRC (camsrc);
1776   GST_DEBUG_OBJECT (v4l2camsrc, "%s, !!!!!!line:%d\n", __func__, __LINE__);
1777
1778   if (v4l2camsrc->is_active) {
1779     g_mutex_lock (v4l2camsrc->device_mutex);
1780     ret = gst_v4l2camsrc_libmfldcam_get_makernote(v4l2camsrc, buf, size);
1781     g_mutex_unlock (v4l2camsrc->device_mutex);
1782   }
1783
1784   return ret;
1785 }
1786
1787 static gboolean gst_v4l2camsrc_makernote_init(GstCameraSrc * camsrc,
1788                                                       unsigned * buf_size,
1789                                                       unsigned num_afwindows,
1790                                                       unsigned num_faces,
1791                                                       unsigned num_eyes,
1792                                                       unsigned num_grid,
1793                                                       int *handle)
1794 {
1795   GstMFLDV4l2CamSrc *v4l2camsrc;
1796
1797   v4l2camsrc = GST_V4L2CAMSRC (camsrc);
1798   GST_DEBUG_OBJECT (v4l2camsrc, "%s, !!!!!!line:%d\n", __func__, __LINE__);
1799
1800   num_afwindows = num_grid = 1;
1801   num_faces = num_eyes = 0;
1802   return FALSE;
1803
1804 }
1805
1806 static gboolean gst_v4l2camsrc_makernote_deal(GstCameraSrc * camsrc,
1807                                                       GstBuffer *pmakerbuf,
1808                                                       unsigned num_afwindows,
1809                                                       unsigned num_grid,
1810                                                       int handle)
1811 {
1812   GstMFLDV4l2CamSrc *v4l2camsrc;
1813
1814   v4l2camsrc = GST_V4L2CAMSRC (camsrc);
1815   GST_DEBUG_OBJECT (v4l2camsrc, "%s, !!!!!!line:%d\n", __func__, __LINE__);
1816
1817   return FALSE;
1818
1819 }
1820
1821 static gboolean gst_v4l2camsrc_makernote_uninit(GstCameraSrc * camsrc,
1822                                                         int handle)
1823 {
1824   GstMFLDV4l2CamSrc *v4l2camsrc;
1825
1826   v4l2camsrc = GST_V4L2CAMSRC (camsrc);
1827   GST_DEBUG_OBJECT (v4l2camsrc, "%s, !!!!!!line:%d\n", __func__, __LINE__);
1828
1829   return FALSE;
1830 }
1831
1832
1833 /*
1834  * plugin_init:
1835  * @plugin: GstPlugin
1836  *
1837  * Returns: TRUE on success.
1838  */
1839 static gboolean
1840 plugin_init (GstPlugin * plugin)
1841 {
1842   GST_DEBUG_CATEGORY_INIT (gst_v4l2camsrc_debug, "camerasrc", 0,
1843       "Medfield V4L2 camera source");
1844
1845   return gst_element_register (plugin, "camerasrc",
1846       GST_RANK_NONE, GST_TYPE_V4L2CAMSRC);
1847 }
1848
1849 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1850     GST_VERSION_MINOR,
1851     "mfldv4l2cam",
1852     "V4L2 camera image capturing element",
1853     plugin_init, VERSION, "LGPL", "Intel", "www.intel.com")