gst-libs/gst/interfaces/cameracontrol.c

   1 /*
   2  * GStreamer Camera Control Interface
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
   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->start_face_zoom = NULL;
 136         klass->stop_face_zoom = NULL;
 137 }
 138
 139 const GList* gst_camera_control_list_channels(GstCameraControl *control)
 140 {
 141         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 142
 143         if (klass->list_channels) {
 144                 return klass->list_channels(control);
 145         }
 146
 147         return NULL;
 148 }
 149
 150
 151 gboolean gst_camera_control_set_value(GstCameraControl *control, GstCameraControlChannel *control_channel)
 152 {
 153         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 154
 155         if (klass->set_value) {
 156                 return klass->set_value(control, control_channel);
 157         }
 158
 159         return FALSE;
 160 }
 161
 162 gboolean gst_camera_control_get_value(GstCameraControl *control, GstCameraControlChannel *control_channel)
 163 {
 164         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 165
 166         if (klass->get_value) {
 167                 return klass->get_value(control, control_channel);
 168         }
 169
 170         return FALSE;
 171 }
 172
 173
 174
 175 gboolean gst_camera_control_set_exposure(GstCameraControl *control, gint type, gint value1, gint value2)
 176 {
 177         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 178
 179         if (klass->set_exposure) {
 180                 return klass->set_exposure(control, type, value1, value2);
 181         }
 182
 183         return FALSE;
 184 }
 185
 186 gboolean gst_camera_control_get_exposure(GstCameraControl *control, gint type, gint *value1, gint *value2)
 187 {
 188         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 189
 190         if (klass->get_exposure) {
 191                 return klass->get_exposure(control, type, value1, value2);
 192         }
 193
 194         return FALSE;
 195 }
 196
 197 gboolean gst_camera_control_set_capture_mode(GstCameraControl *control, gint type, gint value)
 198 {
 199         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 200
 201         if (klass->set_capture_mode) {
 202                 return klass->set_capture_mode(control, type, value);
 203         }
 204
 205         return FALSE;
 206 }
 207
 208 gboolean gst_camera_control_get_capture_mode(GstCameraControl *control, gint type, gint *value)
 209 {
 210         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 211
 212         if (klass->get_capture_mode) {
 213                 return klass->get_capture_mode(control, type, value);
 214         }
 215
 216         return FALSE;
 217 }
 218
 219 gboolean gst_camera_control_set_strobe(GstCameraControl *control, gint type, gint value)
 220 {
 221         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 222
 223         if (klass->set_strobe) {
 224                 return klass->set_strobe(control, type, value);
 225         }
 226
 227         return FALSE;
 228 }
 229
 230 gboolean gst_camera_control_get_strobe(GstCameraControl *control, gint type, gint *value)
 231 {
 232         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 233
 234         if (klass->get_strobe) {
 235                 return klass->get_strobe(control, type, value);
 236         }
 237
 238         return FALSE;
 239 }
 240
 241 gboolean gst_camera_control_set_detect(GstCameraControl *control, gint type, gint value)
 242 {
 243         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 244
 245         if (klass->set_detect) {
 246                 return klass->set_detect(control, type, value);
 247         }
 248
 249         return FALSE;
 250 }
 251
 252 gboolean gst_camera_control_get_detect(GstCameraControl *control, gint type, gint *value)
 253 {
 254         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 255
 256         if (klass->get_detect) {
 257                 return klass->get_detect(control, type, value);
 258         }
 259
 260         return FALSE;
 261 }
 262
 263 gboolean gst_camera_control_set_zoom(GstCameraControl *control, gint type, gint value)
 264 {
 265         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 266
 267         if (klass->set_zoom) {
 268                 return klass->set_zoom(control, type, value);
 269         }
 270
 271         return FALSE;
 272 }
 273
 274 gboolean gst_camera_control_get_zoom(GstCameraControl *control, gint type, gint *value)
 275 {
 276         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 277
 278         if (klass->get_zoom) {
 279                 return klass->get_zoom(control, type, value);
 280         }
 281
 282         return FALSE;
 283 }
 284
 285 gboolean gst_camera_control_set_focus(GstCameraControl *control, gint mode, gint range)
 286 {
 287         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 288
 289         if (klass->set_focus) {
 290                 return klass->set_focus(control, mode, range);
 291         }
 292
 293         return FALSE;
 294 }
 295
 296 gboolean gst_camera_control_get_focus(GstCameraControl *control, gint *mode, gint *range)
 297 {
 298         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 299
 300         if (klass->get_focus) {
 301                 return klass->get_focus(control, mode, range);
 302         }
 303
 304         return FALSE;
 305 }
 306
 307 gboolean gst_camera_control_start_auto_focus(GstCameraControl *control)
 308 {
 309         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 310
 311         if (klass->start_auto_focus) {
 312                 return klass->start_auto_focus(control);
 313         }
 314
 315         return FALSE;
 316 }
 317
 318 gboolean gst_camera_control_stop_auto_focus(GstCameraControl *control)
 319 {
 320         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 321
 322         if (klass->stop_auto_focus) {
 323                 return klass->stop_auto_focus(control);
 324         }
 325
 326         return FALSE;
 327 }
 328
 329 gboolean gst_camera_control_set_focus_level(GstCameraControl *control, gint manual_level)
 330 {
 331         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 332
 333         if (klass->set_focus_level) {
 334                 return klass->set_focus_level(control, manual_level);
 335         }
 336
 337         return FALSE;
 338 }
 339
 340 gboolean gst_camera_control_get_focus_level(GstCameraControl *control, gint *manual_level)
 341 {
 342         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 343
 344         if (klass->get_focus_level) {
 345                 return klass->get_focus_level(control, manual_level);
 346         }
 347
 348         return FALSE;
 349 }
 350
 351 gboolean gst_camera_control_set_auto_focus_area(GstCameraControl *control, GstCameraControlRectType rect)
 352 {
 353         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 354
 355         if (klass->set_auto_focus_area) {
 356                 return klass->set_auto_focus_area(control, rect);
 357         }
 358
 359         return FALSE;
 360 }
 361
 362 gboolean gst_camera_control_get_auto_focus_area(GstCameraControl *control, GstCameraControlRectType *rect)
 363 {
 364         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 365
 366         if (klass->get_auto_focus_area) {
 367                 return klass->get_auto_focus_area(control, rect);
 368         }
 369
 370         return FALSE;
 371 }
 372
 373 gboolean gst_camera_control_set_wdr(GstCameraControl *control, gint value)
 374 {
 375         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 376
 377         if (klass->set_wdr) {
 378                 return klass->set_wdr(control, value);
 379         }
 380
 381         return FALSE;
 382 }
 383
 384 gboolean gst_camera_control_get_wdr(GstCameraControl *control, gint *value)
 385 {
 386         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 387
 388         if (klass->get_wdr) {
 389                 return klass->get_wdr(control, value);
 390         }
 391
 392         return FALSE;
 393 }
 394
 395 gboolean gst_camera_control_set_ahs(GstCameraControl *control, gint value)
 396 {
 397         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 398
 399         if (klass->set_ahs) {
 400                 return klass->set_ahs(control, value);
 401         }
 402
 403         return FALSE;
 404 }
 405
 406 gboolean gst_camera_control_get_ahs(GstCameraControl *control, gint *value)
 407 {
 408         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 409
 410         if (klass->get_ahs) {
 411                 return klass->get_ahs(control, value);
 412         }
 413
 414         return FALSE;
 415 }
 416
 417 gboolean gst_camera_control_set_part_color(GstCameraControl *control, gint type, gint value)
 418 {
 419         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 420
 421         if (klass->set_part_color) {
 422                 return klass->set_part_color(control, type, value);
 423         }
 424
 425         return FALSE;
 426 }
 427
 428 gboolean gst_camera_control_get_part_color(GstCameraControl *control, gint type, gint *value)
 429 {
 430         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 431
 432         if (klass->get_part_color) {
 433                 return klass->get_part_color(control, type, value);
 434         }
 435
 436         return FALSE;
 437 }
 438
 439 gboolean
 440 gst_camera_control_get_exif_info(GstCameraControl *control, GstCameraControlExifInfo *info)
 441 {
 442         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 443
 444         if (klass->get_exif_info) {
 445                 return klass->get_exif_info(control, info);
 446         }
 447
 448         return FALSE;
 449 }
 450
 451
 452 gboolean gst_camera_control_get_basic_dev_info(GstCameraControl *control, gint dev_id, GstCameraControlCapsInfoType *info)
 453 {
 454         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 455
 456         if (klass->get_basic_dev_info) {
 457                 return klass->get_basic_dev_info(control, dev_id, info);
 458         }
 459
 460         return FALSE;
 461 }
 462
 463 gboolean gst_camera_control_get_misc_dev_info(GstCameraControl *control, gint dev_id, GstCameraControlCtrlListInfoType *info)
 464 {
 465         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS( control );
 466
 467         if( klass->get_misc_dev_info )
 468         {
 469                 return klass->get_misc_dev_info( control, dev_id, info );
 470         }
 471
 472         return FALSE;
 473 }
 474
 475 gboolean gst_camera_control_get_extra_dev_info(GstCameraControl *control, gint dev_id, GstCameraControlExtraInfoType *info)
 476 {
 477         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 478
 479         if (klass->get_extra_dev_info) {
 480                 return klass->get_extra_dev_info(control, dev_id, info);
 481         }
 482
 483         return FALSE;
 484 }
 485
 486 void gst_camera_control_set_capture_command(GstCameraControl *control, GstCameraControlCaptureCommand cmd)
 487 {
 488         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 489
 490         if (klass->set_capture_command) {
 491                 klass->set_capture_command(control, cmd);
 492         }
 493
 494         return;
 495 }
 496
 497 gboolean gst_camera_control_start_face_zoom(GstCameraControl *control, gint x, gint y, gint zoom_level)
 498 {
 499         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 500
 501         if (klass->start_face_zoom) {
 502                 return klass->start_face_zoom(control, x, y, zoom_level);
 503         }
 504
 505         return FALSE;
 506 }
 507
 508 gboolean gst_camera_control_stop_face_zoom(GstCameraControl *control)
 509 {
 510         GstCameraControlClass *klass = GST_CAMERA_CONTROL_GET_CLASS(control);
 511
 512         if (klass->stop_face_zoom) {
 513                 return klass->stop_face_zoom(control);
 514         }
 515
 516         return FALSE;
 517 }
 518
 519 void gst_camera_control_value_changed(GstCameraControl *control, GstCameraControlChannel *control_channel, gint value)
 520 {
 521         g_signal_emit(G_OBJECT(control), gst_camera_control_signals[CONTROL_VALUE_CHANGED], 0, control_channel, value);
 522         g_signal_emit_by_name(G_OBJECT(control_channel), "control-value-changed", value);
 523 }