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