src/mm_camcorder.c

   1 /*
   2  * libmm-camcorder
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /* ==============================================================================
  23 |  INCLUDE FILES                                                                |
  24 ===============================================================================*/
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include <mm_error.h>
  29 #include <mm_attrs_private.h>
  30
  31 #include "mm_camcorder.h"
  32 #include "mm_camcorder_internal.h"
  33
  34
  35 /*===============================================================================
  36 |  FUNCTION DEFINITIONS                                                         |
  37 ===============================================================================*/
  38 /*-------------------------------------------------------------------------------
  39 |    GLOBAL FUNCTION DEFINITIONS:                                               |
  40 -------------------------------------------------------------------------------*/
  41 int mm_camcorder_create(MMHandleType *camcorder, MMCamPreset *info)
  42 {
  43         int error = MM_ERROR_NONE;
  44
  45         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  46         mmf_return_val_if_fail((void *)info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  47
  48         _mmcam_dbg_err("");
  49
  50         error = _mmcamcorder_create(camcorder, info);
  51
  52         _mmcam_dbg_err("END");
  53
  54         return error;
  55 }
  56
  57
  58 int mm_camcorder_destroy(MMHandleType camcorder)
  59 {
  60         int error = MM_ERROR_NONE;
  61
  62         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  63
  64         _mmcam_dbg_err("");
  65
  66         error = _mmcamcorder_destroy(camcorder);
  67
  68         _mmcam_dbg_err("END!!!");
  69
  70         return error;
  71 }
  72
  73
  74 int mm_camcorder_realize(MMHandleType camcorder)
  75 {
  76         int error = MM_ERROR_NONE;
  77
  78         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  79
  80         _mmcam_dbg_err("");
  81
  82         _MMCAMCORDER_LOCK_ASM(camcorder);
  83
  84         error = _mmcamcorder_realize(camcorder);
  85
  86         _MMCAMCORDER_UNLOCK_ASM(camcorder);
  87
  88         _mmcam_dbg_err("END");
  89
  90         return error;
  91 }
  92
  93
  94 int mm_camcorder_unrealize(MMHandleType camcorder)
  95 {
  96         int error = MM_ERROR_NONE;
  97
  98         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  99
 100         _mmcam_dbg_err("");
 101
 102         _MMCAMCORDER_LOCK_ASM(camcorder);
 103
 104         error = _mmcamcorder_unrealize(camcorder);
 105
 106         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 107
 108         _mmcam_dbg_err("END");
 109
 110         return error;
 111 }
 112
 113
 114 int mm_camcorder_start(MMHandleType camcorder)
 115 {
 116         int error = MM_ERROR_NONE;
 117
 118         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 119
 120         _mmcam_dbg_err("");
 121
 122         _MMCAMCORDER_LOCK_ASM(camcorder);
 123
 124         error = _mmcamcorder_start(camcorder);
 125
 126         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 127
 128         _mmcam_dbg_err("END");
 129
 130         return error;
 131 }
 132
 133
 134 int mm_camcorder_stop(MMHandleType camcorder)
 135 {
 136         int error = MM_ERROR_NONE;
 137
 138         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 139
 140         _mmcam_dbg_err("");
 141
 142         _MMCAMCORDER_LOCK_ASM(camcorder);
 143
 144         error = _mmcamcorder_stop(camcorder);
 145
 146         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 147
 148         _mmcam_dbg_err("END");
 149
 150         return error;
 151 }
 152
 153
 154 int mm_camcorder_capture_start(MMHandleType camcorder)
 155 {
 156         int error = MM_ERROR_NONE;
 157
 158         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 159
 160         _mmcam_dbg_err("");
 161
 162         _MMCAMCORDER_LOCK_ASM(camcorder);
 163
 164         error = _mmcamcorder_capture_start(camcorder);
 165
 166         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 167
 168         _mmcam_dbg_err("END");
 169
 170         return error;
 171 }
 172
 173
 174 int mm_camcorder_capture_stop(MMHandleType camcorder)
 175 {
 176         int error = MM_ERROR_NONE;
 177
 178         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 179
 180         _mmcam_dbg_err("");
 181
 182         _MMCAMCORDER_LOCK_ASM(camcorder);
 183
 184         error = _mmcamcorder_capture_stop(camcorder);
 185
 186         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 187
 188         _mmcam_dbg_err("END");
 189
 190         return error;
 191 }
 192
 193
 194 int mm_camcorder_record(MMHandleType camcorder)
 195 {
 196         int error = MM_ERROR_NONE;
 197
 198         mmf_return_val_if_fail((void*)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 199
 200         _mmcam_dbg_err("");
 201
 202         _MMCAMCORDER_LOCK_ASM(camcorder);
 203
 204         error = _mmcamcorder_record(camcorder);
 205
 206         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 207
 208         _mmcam_dbg_err("END");
 209
 210         return error;
 211 }
 212
 213
 214 int mm_camcorder_pause(MMHandleType camcorder)
 215 {
 216         int error = MM_ERROR_NONE;
 217
 218         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 219
 220         _mmcam_dbg_err("");
 221
 222         _MMCAMCORDER_LOCK_ASM(camcorder);
 223
 224         error = _mmcamcorder_pause(camcorder);
 225
 226         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 227
 228         _mmcam_dbg_err("END");
 229
 230         return error;
 231 }
 232
 233
 234 int mm_camcorder_commit(MMHandleType camcorder)
 235 {
 236         int error = MM_ERROR_NONE;
 237
 238         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 239
 240         _mmcam_dbg_err("");
 241
 242         _MMCAMCORDER_LOCK_ASM(camcorder);
 243
 244         error = _mmcamcorder_commit(camcorder);
 245
 246         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 247
 248         _mmcam_dbg_err("END");
 249
 250         return error;
 251 }
 252
 253
 254 int mm_camcorder_cancel(MMHandleType camcorder)
 255 {
 256         int error = MM_ERROR_NONE;
 257
 258         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 259
 260         _mmcam_dbg_err("");
 261
 262         _MMCAMCORDER_LOCK_ASM(camcorder);
 263
 264         error = _mmcamcorder_cancel(camcorder);
 265
 266         _MMCAMCORDER_UNLOCK_ASM(camcorder);
 267
 268         _mmcam_dbg_err("END");
 269
 270         return error;
 271 }
 272
 273
 274 int mm_camcorder_set_message_callback(MMHandleType  camcorder, MMMessageCallback callback, void *user_data)
 275 {
 276         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 277
 278         return _mmcamcorder_set_message_callback(camcorder, callback, user_data);
 279 }
 280
 281
 282 int mm_camcorder_set_video_stream_callback(MMHandleType camcorder, mm_camcorder_video_stream_callback callback, void* user_data)
 283 {
 284         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 285
 286         return _mmcamcorder_set_video_stream_callback(camcorder, callback, user_data);
 287 }
 288
 289
 290 int mm_camcorder_set_audio_stream_callback(MMHandleType camcorder, mm_camcorder_audio_stream_callback callback, void* user_data)
 291 {
 292         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 293
 294         return _mmcamcorder_set_audio_stream_callback(camcorder, callback, user_data);
 295 }
 296
 297
 298 int mm_camcorder_set_video_capture_callback(MMHandleType camcorder, mm_camcorder_video_capture_callback callback, void* user_data)
 299 {
 300         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
 301
 302         return _mmcamcorder_set_video_capture_callback(camcorder, callback, user_data);
 303 }
 304
 305
 306 int mm_camcorder_get_state(MMHandleType camcorder, MMCamcorderStateType *status)
 307 {
 308         int ret = MM_ERROR_NONE;
 309
 310         if (!camcorder) {
 311                 _mmcam_dbg_warn("Empty handle.");
 312                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 313         }
 314
 315         *status = _mmcamcorder_get_state(camcorder);
 316
 317         return ret;
 318
 319 }
 320
 321
 322 int mm_camcorder_get_attributes(MMHandleType camcorder, char **err_attr_name, const char *attribute_name, ...)
 323 {
 324         va_list var_args;
 325         int ret = MM_ERROR_NONE;
 326
 327         return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 328
 329         va_start(var_args, attribute_name);
 330         ret = _mmcamcorder_get_attributes(camcorder, err_attr_name, attribute_name, var_args);
 331         va_end (var_args);
 332
 333         return ret;
 334 }
 335
 336
 337 int mm_camcorder_set_attributes(MMHandleType camcorder,  char **err_attr_name, const char *attribute_name, ...)
 338 {
 339         va_list var_args;
 340         int ret = MM_ERROR_NONE;
 341
 342         return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 343
 344         va_start (var_args, attribute_name);
 345         ret = _mmcamcorder_set_attributes(camcorder, err_attr_name, attribute_name, var_args);
 346         va_end (var_args);
 347
 348         return ret;
 349 }
 350
 351
 352 int mm_camcorder_get_attribute_info(MMHandleType camcorder, const char *attribute_name, MMCamAttrsInfo *info)
 353 {
 354         return _mmcamcorder_get_attribute_info(camcorder, attribute_name, info);
 355 }
 356
 357 int mm_camcorder_get_fps_list_by_resolution(MMHandleType camcorder, int width, int height, MMCamAttrsInfo *fps_info)
 358 {
 359         return _mmcamcorder_get_fps_array_by_resolution(camcorder, width, height, fps_info);
 360 }
 361
 362
 363 int mm_camcorder_init_focusing(MMHandleType camcorder)
 364 {
 365         int error = MM_ERROR_NONE;
 366
 367         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 368
 369         error = _mmcamcorder_init_focusing(camcorder);
 370
 371         return error;
 372 }
 373
 374
 375 int mm_camcorder_start_focusing( MMHandleType camcorder )
 376 {
 377         int error = MM_ERROR_NONE;
 378
 379         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 380
 381         /* TODO : Add direction parameter */
 382
 383         error = _mmcamcorder_adjust_focus(camcorder, MM_CAMCORDER_MF_LENS_DIR_FORWARD);
 384
 385         return error;
 386 }
 387
 388
 389 int mm_camcorder_stop_focusing(MMHandleType camcorder)
 390 {
 391         int error = MM_ERROR_NONE;
 392
 393         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 394
 395         error = _mmcamcorder_stop_focusing(camcorder);
 396
 397         return error;
 398 }
 399
 400 int mm_camcorder_get_video_caps(MMHandleType handle, char **caps)
 401 {
 402         return _mmcamcorder_get_video_caps(handle, caps);
 403 }