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
  30 #include "mm_camcorder.h"
  31 #include "mm_camcorder_internal.h"
  32
  33
  34 /*===============================================================================
  35 |  FUNCTION DEFINITIONS                                                         |
  36 ===============================================================================*/
  37 /*-------------------------------------------------------------------------------
  38 |    GLOBAL FUNCTION DEFINITIONS:                                               |
  39 -------------------------------------------------------------------------------*/
  40 int mm_camcorder_create(MMHandleType *camcorder, MMCamPreset *info)
  41 {
  42         int error = MM_ERROR_NONE;
  43
  44         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  45         mmf_return_val_if_fail((void *)info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  46
  47         _mmcam_dbg_err("");
  48
  49         traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE");
  50
  51         error = _mmcamcorder_create(camcorder, info);
  52
  53         traceEnd(TTRACE_TAG_CAMERA);
  54
  55         _mmcam_dbg_err("END");
  56
  57         return error;
  58 }
  59
  60
  61 int mm_camcorder_destroy(MMHandleType camcorder)
  62 {
  63         int error = MM_ERROR_NONE;
  64
  65         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  66
  67         _mmcam_dbg_err("");
  68
  69         traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:DESTROY");
  70
  71         error = _mmcamcorder_destroy(camcorder);
  72
  73         traceEnd(TTRACE_TAG_CAMERA);
  74
  75         _mmcam_dbg_err("END!!!");
  76
  77         return error;
  78 }
  79
  80
  81 int mm_camcorder_realize(MMHandleType camcorder)
  82 {
  83         int error = MM_ERROR_NONE;
  84
  85         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  86
  87         _mmcam_dbg_err("");
  88
  89         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
  90
  91         traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:REALIZE");
  92
  93         error = _mmcamcorder_realize(camcorder);
  94
  95         traceEnd(TTRACE_TAG_CAMERA);
  96
  97         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
  98
  99         _mmcam_dbg_err("END");
 100
 101         return error;
 102 }
 103
 104
 105 int mm_camcorder_unrealize(MMHandleType camcorder)
 106 {
 107         int error = MM_ERROR_NONE;
 108
 109         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 110
 111         _mmcam_dbg_err("");
 112
 113         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 114
 115         traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:UNREALIZE");
 116
 117         error = _mmcamcorder_unrealize(camcorder);
 118
 119         traceEnd(TTRACE_TAG_CAMERA);
 120
 121         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 122
 123         _mmcam_dbg_err("END");
 124
 125         return error;
 126 }
 127
 128
 129 int mm_camcorder_start(MMHandleType camcorder)
 130 {
 131         int error = MM_ERROR_NONE;
 132
 133         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 134
 135         _mmcam_dbg_err("");
 136
 137         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 138
 139         traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:START");
 140
 141         error = _mmcamcorder_start(camcorder);
 142
 143         traceEnd(TTRACE_TAG_CAMERA);
 144
 145         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 146
 147         _mmcam_dbg_err("END");
 148
 149         return error;
 150 }
 151
 152
 153 int mm_camcorder_stop(MMHandleType camcorder)
 154 {
 155         int error = MM_ERROR_NONE;
 156
 157         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 158
 159         _mmcam_dbg_err("");
 160
 161         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 162
 163         traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:STOP");
 164
 165         error = _mmcamcorder_stop(camcorder);
 166
 167         traceEnd(TTRACE_TAG_CAMERA);
 168
 169         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 170
 171         _mmcam_dbg_err("END");
 172
 173         return error;
 174 }
 175
 176
 177 int mm_camcorder_capture_start(MMHandleType camcorder)
 178 {
 179         int error = MM_ERROR_NONE;
 180
 181         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 182
 183         _mmcam_dbg_err("");
 184
 185         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 186
 187         error = _mmcamcorder_capture_start(camcorder);
 188
 189         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 190
 191         _mmcam_dbg_err("END");
 192
 193         return error;
 194 }
 195
 196
 197 int mm_camcorder_capture_stop(MMHandleType camcorder)
 198 {
 199         int error = MM_ERROR_NONE;
 200
 201         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 202
 203         _mmcam_dbg_err("");
 204
 205         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 206
 207         error = _mmcamcorder_capture_stop(camcorder);
 208
 209         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 210
 211         _mmcam_dbg_err("END");
 212
 213         return error;
 214 }
 215
 216
 217 int mm_camcorder_record(MMHandleType camcorder)
 218 {
 219         int error = MM_ERROR_NONE;
 220
 221         mmf_return_val_if_fail((void*)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 222
 223         _mmcam_dbg_err("");
 224
 225         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 226
 227         error = _mmcamcorder_record(camcorder);
 228
 229         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 230
 231         _mmcam_dbg_err("END");
 232
 233         return error;
 234 }
 235
 236
 237 int mm_camcorder_pause(MMHandleType camcorder)
 238 {
 239         int error = MM_ERROR_NONE;
 240
 241         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 242
 243         _mmcam_dbg_err("");
 244
 245         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 246
 247         error = _mmcamcorder_pause(camcorder);
 248
 249         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 250
 251         _mmcam_dbg_err("END");
 252
 253         return error;
 254 }
 255
 256
 257 int mm_camcorder_commit(MMHandleType camcorder)
 258 {
 259         int error = MM_ERROR_NONE;
 260
 261         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 262
 263         _mmcam_dbg_err("");
 264
 265         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 266
 267         error = _mmcamcorder_commit(camcorder);
 268
 269         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 270
 271         _mmcam_dbg_err("END");
 272
 273         return error;
 274 }
 275
 276
 277 int mm_camcorder_cancel(MMHandleType camcorder)
 278 {
 279         int error = MM_ERROR_NONE;
 280
 281         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 282
 283         _mmcam_dbg_err("");
 284
 285         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 286
 287         error = _mmcamcorder_cancel(camcorder);
 288
 289         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 290
 291         _mmcam_dbg_err("END");
 292
 293         return error;
 294 }
 295
 296
 297 int mm_camcorder_set_message_callback(MMHandleType  camcorder, MMMessageCallback callback, void *user_data)
 298 {
 299         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 300
 301         return _mmcamcorder_set_message_callback(camcorder, callback, user_data);
 302 }
 303
 304
 305 int mm_camcorder_set_video_stream_callback(MMHandleType camcorder, mm_camcorder_video_stream_callback callback, void* user_data)
 306 {
 307         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 308
 309         return _mmcamcorder_set_video_stream_callback(camcorder, callback, user_data);
 310 }
 311
 312
 313 int mm_camcorder_set_audio_stream_callback(MMHandleType camcorder, mm_camcorder_audio_stream_callback callback, void* user_data)
 314 {
 315         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 316
 317         return _mmcamcorder_set_audio_stream_callback(camcorder, callback, user_data);
 318 }
 319
 320
 321 int mm_camcorder_set_muxed_stream_callback(MMHandleType camcorder, mm_camcorder_muxed_stream_callback callback, void *user_data)
 322 {
 323         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 324
 325         return _mmcamcorder_set_muxed_stream_callback(camcorder, callback, user_data);
 326 }
 327
 328
 329 int mm_camcorder_set_video_capture_callback(MMHandleType camcorder, mm_camcorder_video_capture_callback callback, void* user_data)
 330 {
 331         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 332
 333         return _mmcamcorder_set_video_capture_callback(camcorder, callback, user_data);
 334 }
 335
 336
 337 int mm_camcorder_get_state(MMHandleType camcorder, MMCamcorderStateType *state)
 338 {
 339         int ret = MM_ERROR_NONE;
 340
 341         if (!camcorder) {
 342                 _mmcam_dbg_warn("Empty handle.");
 343                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 344         }
 345
 346         *state = _mmcamcorder_get_state(camcorder);
 347
 348         return ret;
 349 }
 350
 351
 352 int mm_camcorder_get_state2(MMHandleType camcorder, MMCamcorderStateType *state, MMCamcorderStateType *old_state)
 353 {
 354         if (!camcorder) {
 355                 _mmcam_dbg_warn("Empty handle.");
 356                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 357         }
 358
 359         return _mmcamcorder_get_state2(camcorder, (int *)state, (int *)old_state);
 360 }
 361
 362
 363 int mm_camcorder_get_attributes(MMHandleType camcorder, char **err_attr_name, const char *attribute_name, ...)
 364 {
 365         va_list var_args;
 366         int ret = MM_ERROR_NONE;
 367
 368         mmf_return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 369
 370         va_start(var_args, attribute_name);
 371         ret = _mmcamcorder_get_attributes(camcorder, err_attr_name, attribute_name, var_args);
 372         va_end(var_args);
 373
 374         return ret;
 375 }
 376
 377
 378 int mm_camcorder_set_attributes(MMHandleType camcorder,  char **err_attr_name, const char *attribute_name, ...)
 379 {
 380         va_list var_args;
 381         int ret = MM_ERROR_NONE;
 382
 383         mmf_return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 384
 385         va_start(var_args, attribute_name);
 386         ret = _mmcamcorder_set_attributes(camcorder, err_attr_name, attribute_name, var_args);
 387         va_end(var_args);
 388
 389         return ret;
 390 }
 391
 392
 393 int mm_camcorder_get_attribute_info(MMHandleType camcorder, const char *attribute_name, MMCamAttrsInfo *info)
 394 {
 395         return _mmcamcorder_get_attribute_info(camcorder, attribute_name, info);
 396 }
 397
 398 int mm_camcorder_get_fps_list_by_resolution(MMHandleType camcorder, int width, int height, MMCamAttrsInfo *fps_info)
 399 {
 400         return _mmcamcorder_get_fps_array_by_resolution(camcorder, width, height, fps_info);
 401 }
 402
 403
 404 int mm_camcorder_init_focusing(MMHandleType camcorder)
 405 {
 406         int error = MM_ERROR_NONE;
 407
 408         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 409
 410         error = _mmcamcorder_init_focusing(camcorder);
 411
 412         return error;
 413 }
 414
 415
 416 int mm_camcorder_start_focusing(MMHandleType camcorder)
 417 {
 418         int error = MM_ERROR_NONE;
 419
 420         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 421
 422         /* TODO : Add direction parameter */
 423
 424         error = _mmcamcorder_adjust_focus(camcorder, MM_CAMCORDER_MF_LENS_DIR_FORWARD);
 425
 426         return error;
 427 }
 428
 429
 430 int mm_camcorder_stop_focusing(MMHandleType camcorder)
 431 {
 432         int error = MM_ERROR_NONE;
 433
 434         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 435
 436         error = _mmcamcorder_stop_focusing(camcorder);
 437
 438         return error;
 439 }
 440
 441 void mm_camcorder_emit_signal(MMHandleType camcorder, const char *object_name,
 442         const char *interface_name, const char *signal_name, int value)
 443 {
 444         mmf_return_if_fail((void *)camcorder);
 445
 446         _mmcamcorder_emit_signal(camcorder, object_name, interface_name, signal_name, value);
 447
 448         return;
 449 }
 450
 451 int mm_camcorder_check_codec_fileformat_compatibility(const char *codec_type, int codec, int file_format)
 452 {
 453         mmf_return_val_if_fail(codec_type, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 454
 455         return _mmcamcorder_check_codec_fileformat_compatibility(codec_type, codec, file_format);
 456 }
 457
 458 int mm_camcorder_manage_external_storage_state(MMHandleType camcorder, int storage_state)
 459 {
 460         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 461
 462         return _mmcamcorder_manage_external_storage_state(camcorder, storage_state);
 463 }