gst-libs/gst/camera/gstmfldcameracontroliface.c

   1 /* GStreamer
   2  *
   3  * @author: Marko Ollonen <marko.ollonen@ixonos.com>
   4  *
   5  * gstmfldcameracontroliface.c: Camera control interface implementation
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27 #include <gst/gst.h>
  28 #include "gstmfldcameracontroliface.h"
  29 #include "gstmfldcamerasrc.h"
  30
  31 GST_DEBUG_CATEGORY_EXTERN (gst_camerasrc_debug);
  32 #define GST_CAT_DEFAULT gst_camerasrc_debug
  33
  34
  35 GST_BOILERPLATE (GstCameraSrcCameraControlChannel,
  36     gst_camerasrc_camera_control_channel,
  37     GstCameraControlChannel, GST_TYPE_CAMERA_CONTROL_CHANNEL);
  38
  39
  40 static void
  41 gst_camerasrc_camera_control_channel_base_init (gpointer g_class)
  42 {
  43
  44 }
  45
  46 static void
  47 gst_camerasrc_camera_control_channel_class_init
  48     (GstCameraSrcCameraControlChannelClass * klass)
  49 {
  50
  51 }
  52
  53 static void
  54 gst_camerasrc_camera_control_channel_init (GstCameraSrcCameraControlChannel *
  55     channel, GstCameraSrcCameraControlChannelClass * klass)
  56 {
  57   channel->id = (guint32) - 1;
  58
  59 }
  60
  61 static G_GNUC_UNUSED gboolean
  62 gst_camerasrc_camera_control_contains_channel (GstCameraSrc * camerasrc,
  63     GstCameraSrcCameraControlChannelClass * channel)
  64 {
  65   const GList *item;
  66
  67
  68   for (item = camerasrc->camera_controls; item != NULL; item = item->next)
  69     if (item->data == channel)
  70       return TRUE;
  71
  72   return FALSE;
  73 }
  74 const GList *
  75 gst_camerasrc_camera_control_list_channels (GstCameraSrc * camerasrc)
  76 {
  77   return camerasrc->camera_controls;
  78 }
  79
  80 gboolean
  81 gst_camerasrc_camera_control_set_value( GstCameraSrc * camerasrc,
  82     GstCameraControlChannel *control_channel )
  83 {
  84   GstCameraSrcClass *bclass;
  85   gboolean opened;
  86
  87   GstCameraSrcCameraControlChannel *camchannel =
  88       GST_CAMERA_SRC_CAMERA_CONTROL_CHANNEL(control_channel);
  89
  90   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
  91   opened = bclass->is_open (camerasrc);
  92
  93   /* assert that we're opened and that we're using a known item */
  94   g_return_val_if_fail (opened, FALSE);
  95
  96   return FALSE;
  97 }
  98
  99 gboolean
 100 gst_camerasrc_camera_control_get_value( GstCameraSrc * camerasrc,
 101     GstCameraControlChannel *control_channel )
 102 {
 103   GstCameraSrcClass *bclass;
 104   gboolean opened;
 105
 106   GstCameraSrcCameraControlChannel *camchannel =
 107       GST_CAMERA_SRC_CAMERA_CONTROL_CHANNEL(control_channel);
 108   gint value;
 109   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 110   opened = bclass->is_open (camerasrc);
 111
 112   return FALSE;
 113 }
 114 gboolean
 115 gst_camerasrc_camera_control_set_exposure(  GstCameraSrc * camerasrc,
 116                                                                                         gint type, gint value1, gint value2 )
 117 {
 118         gboolean ret = FALSE;
 119         GstCameraSrcClass *bclass;
 120         gboolean opened;
 121         gboolean write = FALSE;
 122         gboolean scene_override = FALSE;
 123         guint32 val;
 124
 125         GST_DEBUG_OBJECT (camerasrc, "%s",__func__);
 126
 127         bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 128         opened = bclass->is_open (camerasrc);
 129         g_return_val_if_fail (opened, FALSE);
 130
 131         GST_OBJECT_LOCK (camerasrc);
 132         switch( type ) {
 133         case GST_CAMERA_CONTROL_F_NUMBER:
 134                 GST_DEBUG_OBJECT (camerasrc, "GST_CAMERA_CONTROL_F_NUMBER value1:%d , value2:%d - set not supported", value1, value2);
 135                 break;
 136         case GST_CAMERA_CONTROL_SHUTTER_SPEED:
 137                 GST_DEBUG_OBJECT (camerasrc, "GST_CAMERA_CONTROL_SHUTTER_SPEED value1:%d , value2:%d - manual exposure not supported", value1, value2);
 138                 break;
 139         case GST_CAMERA_CONTROL_ISO:
 140                 GST_DEBUG_OBJECT (camerasrc, "GST_CAMERA_CONTROL_ISO value:%d", value1);
 141                 camerasrc->photoconf.iso_speed = value1;
 142                 write = TRUE;
 143                 break;
 144         case GST_CAMERA_CONTROL_PROGRAM_MODE:
 145                 GST_DEBUG_OBJECT (camerasrc, "GST_CAMERA_CONTROL_PROGRAM_MODE value:%d", value1);
 146                 camerasrc->photoconf.scene_mode = value1;
 147                 write = scene_override = TRUE;
 148                 break;
 149         case GST_CAMERA_CONTROL_EXPOSURE_MODE:
 150                 GST_DEBUG_OBJECT (camerasrc, "GST_CAMERA_CONTROL_EXPOSURE_MODE value:%d", value1);
 151                 ret = bclass->set_ae_mode(camerasrc, value1);
 152                 break;
 153         case GST_CAMERA_CONTROL_EXPOSURE_VALUE:
 154                 val = ((value1 << 16) | value2);
 155                 GST_DEBUG_OBJECT (camerasrc, "GST_CAMERA_CONTROL_EXPOSURE_VALUE value1:%d , value2:%d -> val:%d", value1, value2, val);
 156                 camerasrc->photoconf.exposure = val;
 157                 write = TRUE;
 158                 break;
 159         default:
 160                 GST_DEBUG_OBJECT (camerasrc, "%s",__func__);
 161         }
 162         GST_OBJECT_UNLOCK (camerasrc);
 163
 164         if (write && bclass->is_active (camerasrc)) {
 165                 ret = bclass->write_settings (camerasrc, &camerasrc->photoconf, scene_override);
 166         }
 167         GST_DEBUG_OBJECT (camerasrc, "%s ret:%d",__func__, ret);
 168
 169         return ret;
 170 }
 171 gboolean
 172 gst_camerasrc_camera_control_get_exposure( GstCameraSrc* camerasrc,
 173     gint type, gint* value1, gint* value2 )
 174 {
 175   gboolean ret = FALSE;
 176   GstCameraSrcClass *bclass;
 177   gboolean opened;
 178
 179   GST_DEBUG_OBJECT (camerasrc, "%s",__func__);
 180
 181   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 182   opened = bclass->is_open (camerasrc);
 183   g_return_val_if_fail (opened, FALSE);
 184
 185   GST_OBJECT_LOCK (camerasrc);
 186   switch( type ) {
 187   case GST_CAMERA_CONTROL_F_NUMBER:
 188           *value1 = *value2 = 0;
 189           break;
 190   case GST_CAMERA_CONTROL_SHUTTER_SPEED:
 191           *value1 = *value2 = 0;
 192           break;
 193   case GST_CAMERA_CONTROL_ISO:
 194           *value1 = camerasrc->photoconf.iso_speed;
 195           ret = TRUE;
 196           break;
 197   case GST_CAMERA_CONTROL_PROGRAM_MODE:
 198           *value1 = camerasrc->photoconf.scene_mode;
 199           ret = TRUE;
 200           break;
 201   case GST_CAMERA_CONTROL_EXPOSURE_MODE:
 202           ret = bclass->get_ae_mode(camerasrc, value1);
 203           ret = TRUE;
 204           break;
 205   case GST_CAMERA_CONTROL_EXPOSURE_VALUE:
 206           *value1 = gst_value_get_fraction_numerator (camerasrc->photoconf.exposure);
 207           *value2 = gst_value_get_fraction_denominator (camerasrc->photoconf.exposure);
 208           ret = TRUE;
 209           break;
 210   default:
 211           GST_DEBUG_OBJECT (camerasrc, "%s",__func__);
 212   }
 213   GST_OBJECT_UNLOCK (camerasrc);
 214
 215   GST_DEBUG_OBJECT (camerasrc, "%d -> value1:%d , value2:%d", type, value1, value2);
 216   return ret;
 217 }
 218 gboolean
 219 gst_camerasrc_camera_control_set_capture_mode( GstCameraSrc* camerasrc,
 220     gint type, gint value )
 221 {
 222   return FALSE;
 223 }
 224 gboolean
 225 gst_camerasrc_camera_control_get_capture_mode( GstCameraSrc* camerasrc,
 226     gint type, gint* value )
 227 {
 228   return FALSE;
 229 }
 230 gboolean
 231 gst_camerasrc_camera_control_set_strobe( GstCameraSrc* camerasrc,
 232     gint type, gint value )
 233 {
 234   GstCameraSrcClass *bclass;
 235   gboolean opened;
 236   gboolean ret = FALSE;
 237
 238
 239   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 240   opened = bclass->is_open (camerasrc);
 241   g_return_val_if_fail (opened, FALSE);
 242
 243
 244   if (type  == GST_CAMERA_CONTROL_STROBE_MODE ) {
 245   /* using GstFlashMode enumeration
 246    * typedef enum
 247    * {
 248    * GST_PHOTOGRAPHY_FLASH_MODE_AUTO = 0,
 249    * GST_PHOTOGRAPHY_FLASH_MODE_OFF,
 250    * GST_PHOTOGRAPHY_FLASH_MODE_ON,
 251    * GST_PHOTOGRAPHY_FLASH_MODE_FILL_IN,
 252    * GST_PHOTOGRAPHY_FLASH_MODE_RED_EYE
 253    * } GstFlashMode;
 254   */
 255     GST_OBJECT_LOCK (camerasrc);
 256     camerasrc->photoconf.flash_mode = value;
 257     GST_OBJECT_UNLOCK (camerasrc);
 258     if (bclass->is_active (camerasrc)) {
 259       ret = bclass->write_settings (camerasrc, &camerasrc->photoconf, FALSE);
 260     }
 261   }
 262   else if (type  == GST_CAMERA_CONTROL_STROBE_CONTROL) {
 263     GST_OBJECT_LOCK (camerasrc);
 264     if( value < 2)
 265       camerasrc->enable_torch = value;
 266     else
 267       camerasrc->enable_torch = FALSE;
 268     if (bclass->set_strobe_state)
 269       bclass->set_strobe_state(camerasrc, camerasrc->enable_torch);
 270     GST_OBJECT_UNLOCK (camerasrc);
 271   }
 272
 273   return ret;
 274 }
 275 gboolean
 276 gst_camerasrc_camera_control_get_strobe( GstCameraSrc* camerasrc,
 277     gint type, gint *value )
 278 {
 279   GstCameraSrcClass *bclass;
 280   gboolean opened;
 281
 282   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 283   opened = bclass->is_open (camerasrc);
 284   g_return_val_if_fail (opened, FALSE);
 285
 286
 287   if (type  == GST_CAMERA_CONTROL_STROBE_MODE ) {
 288     GST_OBJECT_LOCK (camerasrc);
 289     *value =  camerasrc->photoconf.flash_mode;
 290     GST_OBJECT_UNLOCK (camerasrc);
 291   }
 292   else if (type  == GST_CAMERA_CONTROL_STROBE_CONTROL) {
 293     GST_OBJECT_LOCK (camerasrc);
 294     *value = camerasrc->enable_torch;
 295     GST_OBJECT_UNLOCK (camerasrc);
 296   }
 297
 298   return TRUE;
 299 }
 300
 301 gboolean
 302 gst_camerasrc_camera_control_set_detect( GstCameraSrc* camerasrc,
 303     gint type, gint value )
 304 {
 305   return FALSE;
 306 }
 307
 308 gboolean
 309 gst_camerasrc_camera_control_get_detect( GstCameraSrc* camerasrc,
 310     gint type, gint* value )
 311 {
 312   return FALSE;
 313 }
 314
 315 gboolean
 316 gst_camerasrc_camera_control_set_zoom( GstCameraSrc* camerasrc,
 317     gint type, gint value )
 318 {
 319   GstCameraSrcClass *bclass;
 320   gboolean ret = FALSE;
 321
 322   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 323
 324   if ((type == GST_CAMERA_CONTROL_DIGITAL_ZOOM) && (value >= 100)) {
 325     GST_OBJECT_LOCK (camerasrc);
 326     /* use 2 desimals to get accurate(smooth) enough zoom */
 327     /* photography interface zoom is used  */
 328     camerasrc->photoconf.zoom = (gfloat)(value/100);
 329     GST_OBJECT_UNLOCK (camerasrc);
 330
 331     GST_DEBUG_OBJECT (camerasrc, "setting zoom to %f", camerasrc->photoconf.zoom);
 332
 333     if (bclass->set_zoom) {
 334       ret = bclass->set_zoom (camerasrc, camerasrc->photoconf.zoom);
 335     }
 336     GST_DEBUG_OBJECT (camerasrc, "setting zoom %s", ret ? "success" : "failed");
 337   }
 338   else
 339     GST_DEBUG_OBJECT (camerasrc, "Invalid Zoom control, type: %d value: %d",type,value);
 340
 341   return ret;
 342 }
 343
 344 gboolean
 345 gst_camerasrc_camera_control_get_zoom( GstCameraSrc* camerasrc,
 346     gint type, gint* value )
 347 {
 348   gboolean ret = FALSE;
 349
 350   if (type == GST_CAMERA_CONTROL_DIGITAL_ZOOM) {
 351     GST_OBJECT_LOCK (camerasrc);
 352     *value = (gint)(camerasrc->photoconf.zoom * 100);
 353     GST_OBJECT_UNLOCK (camerasrc);
 354     GST_DEBUG_OBJECT (camerasrc, "current zoom = %f", *value);
 355     ret = TRUE;
 356   }
 357   return ret;
 358 }
 359
 360 gboolean
 361 gst_camerasrc_camera_control_set_focus( GstCameraSrc* camerasrc,
 362     gint mode, gint range )
 363 {
 364   GstCameraSrcClass *bclass;
 365   gboolean opened;
 366   GstFocusMode focus_mode;
 367   GST_DEBUG_OBJECT (camerasrc, "gst_camerasrc_camera_control_set_focus");
 368
 369   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 370   opened = bclass->is_open (camerasrc);
 371   g_return_val_if_fail (opened, FALSE);
 372
 373   // Map focus to photography definitions
 374   switch (mode) {
 375     case MM_CAMCORDER_FOCUS_MODE_NONE:
 376       focus_mode = GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY;
 377       break;
 378     case MM_CAMCORDER_FOCUS_MODE_AUTO:
 379     case MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO:
 380       focus_mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO;
 381       break;
 382     case MM_CAMCORDER_FOCUS_MODE_PAN:
 383       focus_mode = GST_PHOTOGRAPHY_FOCUS_MODE_HYPERFOCAL;
 384       break;
 385     case MM_CAMCORDER_FOCUS_MODE_MANUAL:
 386       focus_mode = GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY;
 387       break;
 388     case MM_CAMCORDER_FOCUS_MODE_CONTINUOUS:
 389       focus_mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL ;
 390       break;
 391     default:
 392       focus_mode = GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY;
 393       break;
 394    }
 395   GST_OBJECT_LOCK (camerasrc);
 396   camerasrc->photoconf.focus_mode = focus_mode;
 397   GST_OBJECT_UNLOCK (camerasrc);
 398
 399   return TRUE;
 400 }
 401
 402 gboolean
 403 gst_camerasrc_camera_control_get_focus( GstCameraSrc* camerasrc,
 404     gint* mode, gint* range )
 405 {
 406   GstCameraSrcClass *bclass;
 407   gboolean opened;
 408   GST_DEBUG_OBJECT (camerasrc, "gst_camerasrc_camera_control_get_focus");
 409
 410   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 411   opened = bclass->is_open (camerasrc);
 412   g_return_val_if_fail (opened, FALSE);
 413   // Map focus from photography definitions
 414   GST_OBJECT_LOCK (camerasrc);
 415   switch (camerasrc->photoconf.focus_mode) {
 416     case GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY:
 417       *mode = MM_CAMCORDER_FOCUS_MODE_NONE;
 418       break;
 419     case GST_PHOTOGRAPHY_FOCUS_MODE_AUTO:
 420       *mode = MM_CAMCORDER_FOCUS_MODE_AUTO;
 421       break;
 422     case GST_PHOTOGRAPHY_FOCUS_MODE_HYPERFOCAL:
 423       *mode = MM_CAMCORDER_FOCUS_MODE_PAN;
 424       break;
 425     case GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL:
 426       *mode = MM_CAMCORDER_FOCUS_MODE_CONTINUOUS;
 427       break;
 428     default:
 429       *mode = MM_CAMCORDER_FOCUS_MODE_NONE;
 430       break;
 431    }
 432   GST_OBJECT_UNLOCK (camerasrc);
 433   *range = 0;
 434
 435   return TRUE;
 436 }
 437
 438 gboolean
 439 gst_camerasrc_camera_control_start_auto_focus( GstCameraSrc* camerasrc)
 440 {
 441   GstCameraSrcClass *bclass;
 442   gboolean opened;
 443
 444   GST_DEBUG_OBJECT (camerasrc, "setting autofocus ON");
 445
 446   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 447   opened = bclass->is_open (camerasrc);
 448   g_return_val_if_fail (opened, FALSE);
 449
 450   g_mutex_lock (camerasrc->af_lock);
 451   camerasrc->requested_af_mode = AF_ON_REQUESTED;
 452   g_mutex_unlock (camerasrc->af_lock);
 453
 454   return TRUE;
 455 }
 456
 457 gboolean
 458 gst_camerasrc_camera_control_stop_auto_focus( GstCameraSrc* camerasrc)
 459 {
 460   GstCameraSrcClass *bclass;
 461   gboolean opened;
 462
 463   GST_DEBUG_OBJECT (camerasrc, "setting autofocus OFF");
 464
 465   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 466   opened = bclass->is_open (camerasrc);
 467   g_return_val_if_fail (opened, FALSE);
 468
 469   g_mutex_lock (camerasrc->af_lock);
 470   camerasrc->requested_af_mode = AF_OFF_REQUESTED;
 471   g_mutex_unlock (camerasrc->af_lock);
 472
 473  return TRUE;
 474 }
 475 gboolean
 476 gst_camerasrc_camera_control_set_focus_level( GstCameraSrc* camerasrc,
 477     gint manual_level )
 478 {
 479   // Manual focus not supported atm
 480   return FALSE;
 481 }
 482
 483 gboolean
 484 gst_camerasrc_camera_control_get_focus_level( GstCameraSrc* camerasrc,
 485     gint* manual_level )
 486 {
 487   // Manual focus not supported atm
 488   return FALSE;
 489 }
 490
 491 gboolean
 492 gst_camerasrc_camera_control_set_auto_focus_area( GstCameraSrc* camerasrc,
 493     GstCameraControlRectType rect )
 494 {
 495   GstCameraSrcClass *bclass;
 496   gboolean opened;
 497   int ret = FALSE;
 498
 499   GST_DEBUG_OBJECT (camerasrc, "setting autofocus area");
 500
 501   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 502   opened = bclass->is_open (camerasrc);
 503   g_return_val_if_fail (opened, FALSE);
 504
 505   g_mutex_lock (camerasrc->af_lock);
 506   camerasrc->requested_af_mode = AF_OFF_REQUESTED;
 507   // camcorder just gives a pixel not area.
 508   // from camcorder x = 0...width  y = 0 ...height
 509
 510   GST_DEBUG_OBJECT (camerasrc, "Current width height (%dx%d)",
 511       camerasrc->current_w, camerasrc->current_h);
 512
 513   camerasrc->cam_ctrl.aaa_window.x_left   = (rect.x - 20)  < 0 ? rect.x : (rect.x - 20);
 514   camerasrc->cam_ctrl.aaa_window.x_right  = (rect.width + rect. x + 20)  > camerasrc->current_w ? rect. x : (rect.width + rect. x + 20);
 515   camerasrc->cam_ctrl.aaa_window.y_top    = (rect.y - 20)  < 0 ? rect.y : (rect.y - 20);
 516   camerasrc->cam_ctrl.aaa_window.y_bottom = (rect.height + rect.y + 20)  > camerasrc->current_h ? rect.y : (rect.height + rect.y + 20);
 517   camerasrc->cam_ctrl.aaa_window.weight   = 400;
 518
 519
 520   if (bclass->set_AeAafwindow) {
 521       ret = bclass->set_AeAafwindow(camerasrc, camerasrc->cam_ctrl.aaa_window);
 522    }
 523   g_mutex_unlock (camerasrc->af_lock);
 524
 525   return ret;
 526 }
 527
 528 gboolean
 529 gst_camerasrc_camera_control_get_auto_focus_area( GstCameraSrc* camerasrc,
 530     GstCameraControlRectType* rect )
 531 {
 532   GstCameraSrcClass *bclass;
 533   gboolean opened;
 534
 535   GST_DEBUG_OBJECT (camerasrc, "getting  autofocus area");
 536
 537   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 538   opened = bclass->is_open (camerasrc);
 539   g_return_val_if_fail (opened, FALSE);
 540
 541   g_mutex_lock (camerasrc->af_lock);
 542   camerasrc->requested_af_mode = AF_OFF_REQUESTED;
 543   rect->x = camerasrc->cam_ctrl.aaa_window.x_left;
 544   rect->width = camerasrc->cam_ctrl.aaa_window.x_right - camerasrc->cam_ctrl.aaa_window.x_left;
 545   rect->y = camerasrc->cam_ctrl.aaa_window.y_top;
 546   rect->height = camerasrc->cam_ctrl.aaa_window.y_bottom  - camerasrc->cam_ctrl.aaa_window.y_top;
 547   g_mutex_unlock (camerasrc->af_lock);
 548
 549   return TRUE;
 550 }
 551
 552 gboolean
 553 gst_camerasrc_camera_control_set_wdr( GstCameraSrc* camerasrc, gint value)
 554 {
 555   return FALSE;
 556 }
 557
 558 gboolean
 559 gst_camerasrc_camera_control_get_wdr( GstCameraSrc* camerasrc, gint* value)
 560 {
 561   return FALSE;
 562 }
 563
 564 gboolean
 565 gst_camerasrc_camera_control_set_ahs( GstCameraSrc* camerasrc, gint value)
 566 {
 567   return FALSE;
 568 }
 569
 570 gboolean
 571 gst_camerasrc_camera_control_get_ahs( GstCameraSrc* camerasrc, gint* value)
 572 {
 573   return FALSE;
 574 }
 575
 576 gboolean
 577 gst_camerasrc_camera_control_set_part_color( GstCameraSrc* camerasrc,
 578     gint type, gint value)
 579 {
 580   return FALSE;
 581 }
 582
 583 gboolean
 584 gst_camerasrc_camera_control_get_part_color( GstCameraSrc* camerasrc,
 585     gint type, gint* value)
 586 {
 587   return FALSE;
 588 }
 589
 590 gboolean
 591 gst_camerasrc_camera_control_get_exif_info( GstCameraSrc* camerasrc,
 592     GstCameraControlExifInfo* info)
 593 {
 594
 595   GstCameraSrcClass *bclass;
 596   gboolean ret = FALSE;
 597   gboolean opened;
 598   GstCameraControlExifInfo read_info;
 599
 600   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 601   opened = bclass->is_open (camerasrc);
 602   g_return_val_if_fail (opened, FALSE);
 603
 604   ret = bclass->read_exif (camerasrc, &read_info);
 605
 606   GST_OBJECT_LOCK (camerasrc);
 607   camerasrc->cam_ctrl.exif_info = read_info;
 608   *info = camerasrc->cam_ctrl.exif_info;
 609   GST_OBJECT_UNLOCK (camerasrc);
 610
 611   GST_DEBUG_OBJECT (camerasrc, "got exif info, ret = %d", ret);
 612
 613   return ret;
 614 }
 615
 616 gboolean
 617 gst_camerasrc_camera_control_get_basic_dev_info( GstCameraSrc* camerasrc,
 618     gint dev_id, GstCameraControlCapsInfoType* info)
 619 {
 620   return FALSE;
 621 }
 622
 623 gboolean
 624 gst_camerasrc_camera_control_get_misc_dev_info( GstCameraSrc* camerasrc,
 625     gint dev_id, GstCameraControlCtrlListInfoType* info)
 626 {
 627   return FALSE;
 628 }
 629
 630 gboolean
 631 gst_camerasrc_camera_control_get_extra_dev_info( GstCameraSrc* camerasrc,
 632     gint dev_id, GstCameraControlExtraInfoType* info)
 633 {
 634   return FALSE;
 635 }
 636
 637 void
 638 gst_camerasrc_camera_control_set_capture_command( GstCameraSrc* camerasrc,
 639     GstCameraControlCaptureCommand cmd )
 640 {
 641   GstCameraSrcClass *bclass;
 642   gboolean opened;
 643   GstCaps *CaptureCaps = NULL;
 644
 645   bclass = GST_CAMERA_SRC_GET_CLASS (camerasrc);
 646   opened = bclass->is_open (camerasrc);
 647   g_return_val_if_fail (opened, FALSE);
 648
 649   GST_DEBUG_OBJECT (camerasrc, "set_capture_command: %d", cmd);
 650
 651   /* FIXME */
 652   /* no capture command for video (in the interface) */
 653   if (cmd == GST_CAMERA_CONTROL_CAPTURE_COMMAND_START) {
 654     g_mutex_lock (camerasrc->state_lock);
 655     /* Tell subclass to interrupt frame grabbing */
 656     if (bclass->unlock) {
 657        bclass->unlock (camerasrc);
 658     }
 659     camerasrc->capture_mode = GST_CAMERA_SRC_CAPTURE_MODE_STILL;
 660     camerasrc->photo_capture_phase = GST_PHOTOGRAPHY_OPERATION_MODE_IMAGE_CAPTURE;
 661     bclass->set_capture_mode (camerasrc, camerasrc->capture_mode);
 662     camerasrc->capture_fps_n = camerasrc->fps_n;
 663     camerasrc->capture_fps_d = camerasrc->fps_d;
 664
 665     camerasrc->preview_fourcc = camerasrc->current_fourcc;
 666     camerasrc->preview_w = camerasrc->current_w;
 667     camerasrc->preview_h = camerasrc->current_h;
 668
 669     GST_DEBUG_OBJECT (camerasrc, "Current reso (%dx%d @ %f)",
 670     camerasrc->current_w, camerasrc->current_h,
 671     (gfloat) camerasrc->capture_fps_n / camerasrc->capture_fps_d);
 672
 673     GST_DEBUG_OBJECT (camerasrc, "starting preparations for capture (%dx%d @ %f)",
 674     camerasrc->capture_w, camerasrc->capture_h,
 675     (gfloat) camerasrc->capture_fps_n / camerasrc->capture_fps_d);
 676     GST_DEBUG ("capture fourcc 0x%08x %" GST_FOURCC_FORMAT,
 677           camerasrc->capture_fourcc, GST_FOURCC_ARGS (camerasrc->capture_fourcc));
 678
 679     CaptureCaps = gst_caps_new_simple ("video/x-raw-yuv",
 680         "format", GST_TYPE_FOURCC, camerasrc->capture_fourcc,
 681         "width", G_TYPE_INT, camerasrc->capture_w,
 682         "height", G_TYPE_INT, camerasrc->capture_h,
 683         "framerate", GST_TYPE_FRACTION, camerasrc->capture_fps_n,
 684          camerasrc->capture_fps_d, NULL);
 685
 686      camerasrc->photo_capture_phase = GST_CAMERA_CAPTURE_START;
 687      g_mutex_unlock (camerasrc->state_lock);
 688   }
 689   else {
 690     g_mutex_lock (camerasrc->state_lock);
 691     camerasrc->capture_mode = GST_CAMERA_SRC_CAPTURE_MODE_VIEWFINDER;
 692     bclass->set_capture_mode (camerasrc, camerasrc->capture_mode);
 693     g_mutex_unlock (camerasrc->state_lock);
 694   }
 695 }