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