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_LOG_ERROR("");
  48
  49         traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:CREATE");
  50
  51         error = _mmcamcorder_create(camcorder, info);
  52
  53         traceEnd(TTRACE_TAG_CAMERA);
  54
  55         MMCAM_LOG_ERROR("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_LOG_ERROR("");
  68
  69         traceBegin(TTRACE_TAG_CAMERA, "MMCAMCORDER:DESTROY");
  70
  71         error = _mmcamcorder_destroy(camcorder);
  72
  73         traceEnd(TTRACE_TAG_CAMERA);
  74
  75         MMCAM_LOG_ERROR("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_LOG_ERROR("");
  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_LOG_ERROR("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_LOG_ERROR("");
 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_LOG_ERROR("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_LOG_ERROR("");
 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_LOG_ERROR("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_LOG_ERROR("");
 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_LOG_ERROR("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_LOG_ERROR("");
 184
 185         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 186
 187         error = _mmcamcorder_capture_start(camcorder);
 188
 189         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 190
 191         MMCAM_LOG_ERROR("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_LOG_ERROR("");
 204
 205         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 206
 207         error = _mmcamcorder_capture_stop(camcorder);
 208
 209         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 210
 211         MMCAM_LOG_ERROR("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_LOG_ERROR("");
 224
 225         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 226
 227         error = _mmcamcorder_record(camcorder);
 228
 229         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 230
 231         MMCAM_LOG_ERROR("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_LOG_ERROR("");
 244
 245         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 246
 247         error = _mmcamcorder_pause(camcorder);
 248
 249         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 250
 251         MMCAM_LOG_ERROR("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_LOG_ERROR("");
 264
 265         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 266
 267         error = _mmcamcorder_commit(camcorder);
 268
 269         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 270
 271         MMCAM_LOG_ERROR("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_LOG_ERROR("");
 284
 285         _MMCAMCORDER_LOCK_INTERRUPT(camcorder);
 286
 287         error = _mmcamcorder_cancel(camcorder);
 288
 289         _MMCAMCORDER_UNLOCK_INTERRUPT(camcorder);
 290
 291         MMCAM_LOG_ERROR("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_set_video_encode_decision_callback(MMHandleType camcorder, mm_camcorder_video_encode_decision_callback callback, void* user_data)
 338 {
 339         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 340
 341         return _mmcamcorder_set_video_encode_decision_callback(camcorder, callback, user_data);
 342 }
 343
 344
 345 int mm_camcorder_get_state(MMHandleType camcorder, MMCamcorderStateType *state)
 346 {
 347         int ret = MM_ERROR_NONE;
 348
 349         if (!camcorder) {
 350                 MMCAM_LOG_WARNING("Empty handle.");
 351                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 352         }
 353
 354         *state = _mmcamcorder_get_state(camcorder);
 355
 356         return ret;
 357 }
 358
 359
 360 int mm_camcorder_get_state2(MMHandleType camcorder, MMCamcorderStateType *state, MMCamcorderStateType *old_state)
 361 {
 362         if (!camcorder) {
 363                 MMCAM_LOG_WARNING("Empty handle.");
 364                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 365         }
 366
 367         return _mmcamcorder_get_state2(camcorder, (int *)state, (int *)old_state);
 368 }
 369
 370
 371 int mm_camcorder_get_attributes(MMHandleType camcorder, char **err_attr_name, const char *attribute_name, ...)
 372 {
 373         va_list var_args;
 374         int ret = MM_ERROR_NONE;
 375
 376         mmf_return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 377
 378         va_start(var_args, attribute_name);
 379         ret = _mmcamcorder_get_attributes(camcorder, err_attr_name, attribute_name, var_args);
 380         va_end(var_args);
 381
 382         return ret;
 383 }
 384
 385
 386 int mm_camcorder_set_attributes(MMHandleType camcorder,  char **err_attr_name, const char *attribute_name, ...)
 387 {
 388         va_list var_args;
 389         int ret = MM_ERROR_NONE;
 390
 391         mmf_return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 392
 393         va_start(var_args, attribute_name);
 394         ret = _mmcamcorder_set_attributes(camcorder, err_attr_name, attribute_name, var_args);
 395         va_end(var_args);
 396
 397         return ret;
 398 }
 399
 400
 401 int mm_camcorder_get_attribute_info(MMHandleType camcorder, const char *attribute_name, MMCamAttrsInfo *info)
 402 {
 403         return _mmcamcorder_get_attribute_info(camcorder, attribute_name, info);
 404 }
 405
 406 int mm_camcorder_get_fps_list_by_resolution(MMHandleType camcorder, int width, int height, MMCamAttrsInfo *fps_info)
 407 {
 408         return _mmcamcorder_get_fps_array_by_resolution(camcorder, width, height, fps_info);
 409 }
 410
 411
 412 int mm_camcorder_init_focusing(MMHandleType camcorder)
 413 {
 414         int error = MM_ERROR_NONE;
 415
 416         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 417
 418         error = _mmcamcorder_init_focusing(camcorder);
 419
 420         return error;
 421 }
 422
 423
 424 int mm_camcorder_start_focusing(MMHandleType camcorder)
 425 {
 426         int error = MM_ERROR_NONE;
 427
 428         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 429
 430         /* TODO : Add direction parameter */
 431
 432         error = _mmcamcorder_adjust_focus(camcorder, MM_CAMCORDER_MF_LENS_DIR_FORWARD);
 433
 434         return error;
 435 }
 436
 437
 438 int mm_camcorder_stop_focusing(MMHandleType camcorder)
 439 {
 440         int error = MM_ERROR_NONE;
 441
 442         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 443
 444         error = _mmcamcorder_stop_focusing(camcorder);
 445
 446         return error;
 447 }
 448
 449 void mm_camcorder_emit_signal(MMHandleType camcorder, const char *object_name,
 450         const char *interface_name, const char *signal_name, int value)
 451 {
 452         mmf_return_if_fail((void *)camcorder);
 453
 454         _mmcamcorder_emit_signal(camcorder, object_name, interface_name, signal_name, value);
 455
 456         return;
 457 }
 458
 459 int mm_camcorder_check_codec_fileformat_compatibility(const char *codec_type, int codec, int file_format)
 460 {
 461         mmf_return_val_if_fail(codec_type, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 462
 463         return _mmcamcorder_check_codec_fileformat_compatibility(codec_type, codec, file_format);
 464 }
 465
 466 int mm_camcorder_manage_external_storage_state(MMHandleType camcorder, int storage_state)
 467 {
 468         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 469
 470         return _mmcamcorder_manage_external_storage_state(camcorder, storage_state);
 471 }
 472
 473 int mm_camcorder_get_exposure(MMHandleType camcorder, int *exposure)
 474 {
 475         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 476
 477         return _mmcamcorder_get_exposure(camcorder, exposure);
 478 }
 479
 480 int mm_camcorder_get_log_level(void)
 481 {
 482         return _mmcamcorder_get_log_level();
 483 }
 484
 485 int mm_camcorder_set_extra_preview_device_type(MMHandleType camcorder, int stream_id, int device_type)
 486 {
 487         return _mmcamcorder_set_extra_preview_device_type(camcorder, stream_id, device_type);
 488 }
 489
 490 int mm_camcorder_set_extra_preview_stream_format(MMHandleType camcorder, int stream_id, int pixel_format, int width, int height, int fps)
 491 {
 492         return _mmcamcorder_set_extra_preview_stream_format(camcorder, stream_id, pixel_format, width, height, fps);
 493 }
 494
 495 int mm_camcorder_get_extra_preview_stream_format(MMHandleType camcorder, int stream_id, int *pixel_format, int *width, int *height, int *fps)
 496 {
 497         return _mmcamcorder_get_extra_preview_stream_format(camcorder, stream_id, pixel_format, width, height, fps);
 498 }
 499
 500 int mm_camcorder_set_extra_preview_bitrate(MMHandleType camcorder, int stream_id, int bitrate)
 501 {
 502         return _mmcamcorder_set_extra_preview_bitrate(camcorder, stream_id, bitrate);
 503 }
 504
 505 int mm_camcorder_get_extra_preview_bitrate(MMHandleType camcorder, int stream_id, int *bitrate)
 506 {
 507         return _mmcamcorder_get_extra_preview_bitrate(camcorder, stream_id, bitrate);
 508 }
 509
 510 int mm_camcorder_set_extra_preview_gop_interval(MMHandleType camcorder, int stream_id, int interval)
 511 {
 512         return _mmcamcorder_set_extra_preview_gop_interval(camcorder, stream_id, interval);
 513 }
 514
 515 int mm_camcorder_get_extra_preview_gop_interval(MMHandleType camcorder, int stream_id, int *interval)
 516 {
 517         return _mmcamcorder_get_extra_preview_gop_interval(camcorder, stream_id, interval);
 518 }