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_INTERRUPT(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_INTERRUPT(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_INTERRUPT(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_INTERRUPT(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_INTERRUPT(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_INTERRUPT(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_INTERRUPT(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_INTERRUPT(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_INTERRUPT(camcorder);
 187
 188         error = _mmcamcorder_capture_start(camcorder);
 189
 190         _MMCAMCORDER_UNLOCK_INTERRUPT(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_INTERRUPT(camcorder);
 207
 208         error = _mmcamcorder_capture_stop(camcorder);
 209
 210         _MMCAMCORDER_UNLOCK_INTERRUPT(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_INTERRUPT(camcorder);
 227
 228         error = _mmcamcorder_record(camcorder);
 229
 230         _MMCAMCORDER_UNLOCK_INTERRUPT(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_INTERRUPT(camcorder);
 247
 248         error = _mmcamcorder_pause(camcorder);
 249
 250         _MMCAMCORDER_UNLOCK_INTERRUPT(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_INTERRUPT(camcorder);
 267
 268         error = _mmcamcorder_commit(camcorder);
 269
 270         _MMCAMCORDER_UNLOCK_INTERRUPT(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_INTERRUPT(camcorder);
 287
 288         error = _mmcamcorder_cancel(camcorder);
 289
 290         _MMCAMCORDER_UNLOCK_INTERRUPT(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 *state)
 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         *state = _mmcamcorder_get_state(camcorder);
 348
 349         return ret;
 350 }
 351
 352
 353 int mm_camcorder_get_state2(MMHandleType camcorder, MMCamcorderStateType *state, MMCamcorderStateType *old_state)
 354 {
 355         if (!camcorder) {
 356                 _mmcam_dbg_warn("Empty handle.");
 357                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 358         }
 359
 360         return _mmcamcorder_get_state2(camcorder, (int *)state, (int *)old_state);
 361 }
 362
 363
 364 int mm_camcorder_get_attributes(MMHandleType camcorder, char **err_attr_name, const char *attribute_name, ...)
 365 {
 366         va_list var_args;
 367         int ret = MM_ERROR_NONE;
 368
 369         mmf_return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 370
 371         va_start(var_args, attribute_name);
 372         ret = _mmcamcorder_get_attributes(camcorder, err_attr_name, attribute_name, var_args);
 373         va_end(var_args);
 374
 375         return ret;
 376 }
 377
 378
 379 int mm_camcorder_set_attributes(MMHandleType camcorder,  char **err_attr_name, const char *attribute_name, ...)
 380 {
 381         va_list var_args;
 382         int ret = MM_ERROR_NONE;
 383
 384         mmf_return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 385
 386         va_start(var_args, attribute_name);
 387         ret = _mmcamcorder_set_attributes(camcorder, err_attr_name, attribute_name, var_args);
 388         va_end(var_args);
 389
 390         return ret;
 391 }
 392
 393
 394 int mm_camcorder_get_attribute_info(MMHandleType camcorder, const char *attribute_name, MMCamAttrsInfo *info)
 395 {
 396         return _mmcamcorder_get_attribute_info(camcorder, attribute_name, info);
 397 }
 398
 399 int mm_camcorder_get_fps_list_by_resolution(MMHandleType camcorder, int width, int height, MMCamAttrsInfo *fps_info)
 400 {
 401         return _mmcamcorder_get_fps_array_by_resolution(camcorder, width, height, fps_info);
 402 }
 403
 404
 405 int mm_camcorder_init_focusing(MMHandleType camcorder)
 406 {
 407         int error = MM_ERROR_NONE;
 408
 409         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 410
 411         error = _mmcamcorder_init_focusing(camcorder);
 412
 413         return error;
 414 }
 415
 416
 417 int mm_camcorder_start_focusing(MMHandleType camcorder)
 418 {
 419         int error = MM_ERROR_NONE;
 420
 421         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 422
 423         /* TODO : Add direction parameter */
 424
 425         error = _mmcamcorder_adjust_focus(camcorder, MM_CAMCORDER_MF_LENS_DIR_FORWARD);
 426
 427         return error;
 428 }
 429
 430
 431 int mm_camcorder_stop_focusing(MMHandleType camcorder)
 432 {
 433         int error = MM_ERROR_NONE;
 434
 435         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 436
 437         error = _mmcamcorder_stop_focusing(camcorder);
 438
 439         return error;
 440 }
 441
 442 void mm_camcorder_emit_signal(MMHandleType camcorder, const char *object_name,
 443         const char *interface_name, const char *signal_name, int value)
 444 {
 445         mmf_return_if_fail((void *)camcorder);
 446
 447         _mmcamcorder_emit_signal(camcorder, object_name, interface_name, signal_name, value);
 448
 449         return;
 450 }
 451
 452 int mm_camcorder_check_codec_fileformat_compatibility(const char *codec_type, int codec, int file_format)
 453 {
 454         mmf_return_val_if_fail(codec_type, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 455
 456         return _mmcamcorder_check_codec_fileformat_compatibility(codec_type, codec, file_format);
 457 }
 458
 459 int mm_camcorder_manage_external_storage_state(MMHandleType camcorder, int storage_state)
 460 {
 461         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 462
 463         return _mmcamcorder_manage_external_storage_state(camcorder, storage_state);
 464 }