gst-libs/gst/interfaces/cameracontrol.c

   1 /*
   2  * GStreamer Camera Control Interface
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * This library is free software; you can redistribute it and/or modify it under
   9  * the terms of the GNU Lesser General Public License as published by the
  10  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  11  * any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  14  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  16  * License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  20  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  *
  22  */
  23
  24 /*============================================================================================
  25 EDIT HISTORY FOR MODULE
  26
  27 This section contains comments describing changes made to the module.
  28 Notice that changes are listed in reverse chronological order.
  29
  30 when            who                             what, where, why
  31 ---------       ------------------------        ----------------------------------------------
  32 12/09/08        jm80.yang@samsung.com           Created
  33
  34 ============================================================================================*/
  35
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include "config.h"
  39 #endif
  40
  41 #include "cameracontrol.h"
  42 #include "interfaces-marshal.h"
  43
  44 /**
  45  * SECTION:gstcameracontrol
  46  * @short_description: Interface for camera control
  47  */
  48
  49 enum {
  50         CONTROL_VALUE_CHANGED,
  51         CONTROL_LAST_SIGNAL
  52 };
  53
  54 static void gst_camera_control_class_init(GstCameraControlClass *klass);
  55
  56 static guint gst_camera_control_signals[CONTROL_LAST_SIGNAL] = { 0 };
  57
  58 GType gst_camera_control_get_type(void)
  59 {
  60         static GType gst_camera_control_type = 0;
  61
  62         if (!gst_camera_control_type) {
  63                 static const GTypeInfo gst_camera_control_info =
  64                 {
  65                         sizeof(GstCameraControlClass),
  66                         (GBaseInitFunc)gst_camera_control_class_init,
  67                         NULL,
  68                         NULL,
  69                         NULL,
  70                         NULL,
  71                         0,
  72                         0,
  73                         NULL,
  74                 };
  75
  76                 gst_camera_control_type = g_type_register_static(G_TYPE_INTERFACE,
  77                                                                  "GstCameraControl",
  78                                                                  &gst_camera_control_info,
  79                                                                  0);
  80                 g_type_interface_add_prerequisite(gst_camera_control_type, GST_TYPE_IMPLEMENTS_INTERFACE);
  81         }
  82
  83         return gst_camera_control_type;
  84 }
  85
  86 static void gst_camera_control_class_init(GstCameraControlClass *klass)
  87 {
  88         static gboolean initialized = FALSE;
  89
  90         if (!initialized) {
  91                 gst_camera_control_signals[CONTROL_VALUE_CHANGED] =
  92                         g_signal_new("control-value-changed",
  93                                      GST_TYPE_CAMERA_CONTROL, G_SIGNAL_RUN_LAST,
  94                                      G_STRUCT_OFFSET(GstCameraControlClass, value_changed),
  95                                      NULL, NULL,
  96                                      gst_interfaces_marshal_VOID__OBJECT_INT,
  97                                      G_TYPE_NONE, 2, GST_TYPE_CAMERA_CONTROL_CHANNEL, G_TYPE_INT);
  98
  99                 initialized = TRUE;
 100         }
 101
 102         // TODO :
 103         klass->camera_control_type = 0;
 104
 105         /* defauld virtual functions */
 106         klass->list_channels = NULL;
 107         klass->set_exposure = NULL;
 108         klass->get_exposure = NULL;
 109         klass->set_capture_mode = NULL;
 110         klass->get_capture_mode = NULL;
 111         klass->set_strobe = NULL;
 112         klass->get_strobe = NULL;
 113         klass->set_detect = NULL;
 114         klass->get_detect = NULL;
 115         klass->set_value = NULL;
 116         klass->get_value = NULL;
 117         klass->set_zoom  = NULL;
 118         klass->get_zoom  = NULL;
 119         klass->set_focus = NULL;
 120         klass->get_focus = NULL;
 121         klass->start_auto_focus = NULL;
 122         klass->stop_auto_focus = NULL;
 123         klass->set_focus_level = NULL;
 124         klass->get_focus_level = NULL;
 125         klass->set_auto_focus_area = NULL;
 126         klass->get_auto_focus_area = NULL;
 127         klass->set_wdr = NULL;
 128         klass->get_wdr = NULL;
 129         klass->set_ahs = NULL;
 130         klass->get_ahs = NULL;
 131         klass->set_part_color = NULL;
 132         klass->get_part_color = NULL;
 133         klass->get_exif_info = NULL;
 134         klass->set_capture_command = NULL;
 135         klass->set_record_command = NULL;
 136         klass->start_face_zoom = NULL;
 137         klass->stop_face_zoom = NULL;
 138         klass->set_ae_lock = NULL;
 139         klass->get_ae_lock = NULL;
 140         klass->set_awb_lock = NULL;
 141         klass->get_awb_lock = NULL;
 142 }
 143
 144 const GList* gst_camera_control_list_channels(GstCameraControl *control)
 145 {
 146         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 147
 148         if (klass->list_channels) {
 149                 return klass->list_channels(control);
 150         }
 151
 152         return NULL;
 153 }
 154
 155
 156 gboolean gst_camera_control_set_value(GstCameraControl *control, GstCameraControlChannel *control_channel, gint value)
 157 {
 158         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 159
 160         if (klass->set_value) {
 161                 return klass->set_value(control, control_channel, value);
 162         }
 163
 164         return FALSE;
 165 }
 166
 167 gboolean gst_camera_control_get_value(GstCameraControl *control, GstCameraControlChannel *control_channel, gint *value)
 168 {
 169         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 170
 171         if (klass->get_value) {
 172                 return klass->get_value(control, control_channel, value);
 173         }
 174
 175         return FALSE;
 176 }
 177
 178
 179
 180 gboolean gst_camera_control_set_exposure(GstCameraControl *control, gint type, gint value1, gint value2)
 181 {
 182         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 183
 184         if (klass->set_exposure) {
 185                 return klass->set_exposure(control, type, value1, value2);
 186         }
 187
 188         return FALSE;
 189 }
 190
 191 gboolean gst_camera_control_get_exposure(GstCameraControl *control, gint type, gint *value1, gint *value2)
 192 {
 193         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 194
 195         if (klass->get_exposure) {
 196                 return klass->get_exposure(control, type, value1, value2);
 197         }
 198
 199         return FALSE;
 200 }
 201
 202 gboolean gst_camera_control_set_capture_mode(GstCameraControl *control, gint type, gint value)
 203 {
 204         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 205
 206         if (klass->set_capture_mode) {
 207                 return klass->set_capture_mode(control, type, value);
 208         }
 209
 210         return FALSE;
 211 }
 212
 213 gboolean gst_camera_control_get_capture_mode(GstCameraControl *control, gint type, gint *value)
 214 {
 215         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 216
 217         if (klass->get_capture_mode) {
 218                 return klass->get_capture_mode(control, type, value);
 219         }
 220
 221         return FALSE;
 222 }
 223
 224 gboolean gst_camera_control_set_strobe(GstCameraControl *control, gint type, gint value)
 225 {
 226         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 227
 228         if (klass->set_strobe) {
 229                 return klass->set_strobe(control, type, value);
 230         }
 231
 232         return FALSE;
 233 }
 234
 235 gboolean gst_camera_control_get_strobe(GstCameraControl *control, gint type, gint *value)
 236 {
 237         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 238
 239         if (klass->get_strobe) {
 240                 return klass->get_strobe(control, type, value);
 241         }
 242
 243         return FALSE;
 244 }
 245
 246 gboolean gst_camera_control_set_detect(GstCameraControl *control, gint type, gint value)
 247 {
 248         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 249
 250         if (klass->set_detect) {
 251                 return klass->set_detect(control, type, value);
 252         }
 253
 254         return FALSE;
 255 }
 256
 257 gboolean gst_camera_control_get_detect(GstCameraControl *control, gint type, gint *value)
 258 {
 259         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 260
 261         if (klass->get_detect) {
 262                 return klass->get_detect(control, type, value);
 263         }
 264
 265         return FALSE;
 266 }
 267
 268 gboolean gst_camera_control_set_zoom(GstCameraControl *control, gint type, gint value)
 269 {
 270         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 271
 272         if (klass->set_zoom) {
 273                 return klass->set_zoom(control, type, value);
 274         }
 275
 276         return FALSE;
 277 }
 278
 279 gboolean gst_camera_control_get_zoom(GstCameraControl *control, gint type, gint *value)
 280 {
 281         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 282
 283         if (klass->get_zoom) {
 284                 return klass->get_zoom(control, type, value);
 285         }
 286
 287         return FALSE;
 288 }
 289
 290 gboolean gst_camera_control_set_focus(GstCameraControl *control, gint mode, gint range)
 291 {
 292         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 293
 294         if (klass->set_focus) {
 295                 return klass->set_focus(control, mode, range);
 296         }
 297
 298         return FALSE;
 299 }
 300
 301 gboolean gst_camera_control_get_focus(GstCameraControl *control, gint *mode, gint *range)
 302 {
 303         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 304
 305         if (klass->get_focus) {
 306                 return klass->get_focus(control, mode, range);
 307         }
 308
 309         return FALSE;
 310 }
 311
 312 gboolean gst_camera_control_start_auto_focus(GstCameraControl *control)
 313 {
 314         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 315
 316         if (klass->start_auto_focus) {
 317                 return klass->start_auto_focus(control);
 318         }
 319
 320         return FALSE;
 321 }
 322
 323 gboolean gst_camera_control_stop_auto_focus(GstCameraControl *control)
 324 {
 325         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 326
 327         if (klass->stop_auto_focus) {
 328                 return klass->stop_auto_focus(control);
 329         }
 330
 331         return FALSE;
 332 }
 333
 334 gboolean gst_camera_control_set_focus_level(GstCameraControl *control, gint manual_level)
 335 {
 336         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 337
 338         if (klass->set_focus_level) {
 339                 return klass->set_focus_level(control, manual_level);
 340         }
 341
 342         return FALSE;
 343 }
 344
 345 gboolean gst_camera_control_get_focus_level(GstCameraControl *control, gint *manual_level)
 346 {
 347         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 348
 349         if (klass->get_focus_level) {
 350                 return klass->get_focus_level(control, manual_level);
 351         }
 352
 353         return FALSE;
 354 }
 355
 356 gboolean gst_camera_control_set_auto_focus_area(GstCameraControl *control, GstCameraControlRectType rect)
 357 {
 358         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 359
 360         if (klass->set_auto_focus_area) {
 361                 return klass->set_auto_focus_area(control, rect);
 362         }
 363
 364         return FALSE;
 365 }
 366
 367 gboolean gst_camera_control_get_auto_focus_area(GstCameraControl *control, GstCameraControlRectType *rect)
 368 {
 369         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 370
 371         if (klass->get_auto_focus_area) {
 372                 return klass->get_auto_focus_area(control, rect);
 373         }
 374
 375         return FALSE;
 376 }
 377
 378 gboolean gst_camera_control_set_wdr(GstCameraControl *control, gint value)
 379 {
 380         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 381
 382         if (klass->set_wdr) {
 383                 return klass->set_wdr(control, value);
 384         }
 385
 386         return FALSE;
 387 }
 388
 389 gboolean gst_camera_control_get_wdr(GstCameraControl *control, gint *value)
 390 {
 391         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 392
 393         if (klass->get_wdr) {
 394                 return klass->get_wdr(control, value);
 395         }
 396
 397         return FALSE;
 398 }
 399
 400 gboolean gst_camera_control_set_ahs(GstCameraControl *control, gint value)
 401 {
 402         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 403
 404         if (klass->set_ahs) {
 405                 return klass->set_ahs(control, value);
 406         }
 407
 408         return FALSE;
 409 }
 410
 411 gboolean gst_camera_control_get_ahs(GstCameraControl *control, gint *value)
 412 {
 413         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 414
 415         if (klass->get_ahs) {
 416                 return klass->get_ahs(control, value);
 417         }
 418
 419         return FALSE;
 420 }
 421
 422 gboolean gst_camera_control_set_part_color(GstCameraControl *control, gint type, gint value)
 423 {
 424         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 425
 426         if (klass->set_part_color) {
 427                 return klass->set_part_color(control, type, value);
 428         }
 429
 430         return FALSE;
 431 }
 432
 433 gboolean gst_camera_control_get_part_color(GstCameraControl *control, gint type, gint *value)
 434 {
 435         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 436
 437         if (klass->get_part_color) {
 438                 return klass->get_part_color(control, type, value);
 439         }
 440
 441         return FALSE;
 442 }
 443
 444 gboolean
 445 gst_camera_control_get_exif_info(GstCameraControl *control, GstCameraControlExifInfo *info)
 446 {
 447         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 448
 449         if (klass->get_exif_info) {
 450                 return klass->get_exif_info(control, info);
 451         }
 452
 453         return FALSE;
 454 }
 455
 456
 457 gboolean gst_camera_control_get_basic_dev_info(GstCameraControl *control, gint dev_id, GstCameraControlCapsInfoType *info)
 458 {
 459         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 460
 461         if (klass->get_basic_dev_info) {
 462                 return klass->get_basic_dev_info(control, dev_id, info);
 463         }
 464
 465         return FALSE;
 466 }
 467
 468 gboolean gst_camera_control_get_misc_dev_info(GstCameraControl *control, gint dev_id, GstCameraControlCtrlListInfoType *info)
 469 {
 470         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS( control );
 471
 472         if( klass->get_misc_dev_info )
 473         {
 474                 return klass->get_misc_dev_info( control, dev_id, info );
 475         }
 476
 477         return FALSE;
 478 }
 479
 480 gboolean gst_camera_control_get_extra_dev_info(GstCameraControl *control, gint dev_id, GstCameraControlExtraInfoType *info)
 481 {
 482         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 483
 484         if (klass->get_extra_dev_info) {
 485                 return klass->get_extra_dev_info(control, dev_id, info);
 486         }
 487
 488         return FALSE;
 489 }
 490
 491 void gst_camera_control_set_capture_command(GstCameraControl *control, GstCameraControlCaptureCommand cmd)
 492 {
 493         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 494
 495         if (klass->set_capture_command) {
 496                 klass->set_capture_command(control, cmd);
 497         }
 498
 499         return;
 500 }
 501 void gst_camera_control_set_record_command(GstCameraControl *control, GstCameraControlRecordCommand cmd)
 502 {
 503         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 504
 505         if (klass->set_record_command) {
 506                 klass->set_record_command(control, cmd);
 507         }
 508
 509         return;
 510 }
 511
 512 gboolean gst_camera_control_start_face_zoom(GstCameraControl *control, gint x, gint y, gint zoom_level)
 513 {
 514         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 515
 516         if (klass->start_face_zoom) {
 517                 return klass->start_face_zoom(control, x, y, zoom_level);
 518         }
 519
 520         return FALSE;
 521 }
 522
 523 gboolean gst_camera_control_stop_face_zoom(GstCameraControl *control)
 524 {
 525         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 526
 527         if (klass->stop_face_zoom) {
 528                 return klass->stop_face_zoom(control);
 529         }
 530
 531         return FALSE;
 532 }
 533
 534 gboolean gst_camera_control_set_ae_lock(GstCameraControl *control, gboolean lock)
 535 {
 536         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 537
 538         if (klass->set_ae_lock) {
 539                 return klass->set_ae_lock(control, lock);
 540         }
 541
 542         return FALSE;
 543 }
 544
 545 gboolean gst_camera_control_get_ae_lock(GstCameraControl *control, gboolean *lock)
 546 {
 547         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 548
 549         if (klass->get_ae_lock) {
 550                 return klass->get_ae_lock(control, lock);
 551         }
 552
 553         return FALSE;
 554 }
 555
 556 gboolean gst_camera_control_set_awb_lock(GstCameraControl *control, gboolean lock)
 557 {
 558         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 559
 560         if (klass->set_awb_lock) {
 561                 return klass->set_awb_lock(control, lock);
 562         }
 563
 564         return FALSE;
 565 }
 566
 567 gboolean gst_camera_control_get_awb_lock(GstCameraControl *control, gboolean *lock)
 568 {
 569         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 570
 571         if (klass->get_awb_lock) {
 572                 return klass->get_awb_lock(control, lock);
 573         }
 574
 575         return FALSE;
 576 }
 577
 578 void gst_camera_control_value_changed(GstCameraControl *control, GstCameraControlChannel *control_channel, gint value)
 579 {
 580         g_signal_emit(G_OBJECT(control), gst_camera_control_signals[CONTROL_VALUE_CHANGED], 0, control_channel, value);
 581         g_signal_emit_by_name(G_OBJECT(control_channel), "control-value-changed", value);
 582 }