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