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
  29 #include <mm_error.h>
  30 #include <mm_ta.h>
  31
  32 #include <mm_attrs_private.h>
  33 #include "mm_camcorder.h"
  34 #include "mm_camcorder_internal.h"
  35
  36
  37 /*===============================================================================
  38 |  FUNCTION DEFINITIONS                                                         |
  39 ===============================================================================*/
  40 /*-------------------------------------------------------------------------------
  41 |    GLOBAL FUNCTION DEFINITIONS:                                               |
  42 -------------------------------------------------------------------------------*/
  43 int mm_camcorder_create(MMHandleType *camcorder, MMCamPreset *info)
  44 {
  45         int error = MM_ERROR_NONE;
  46
  47         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  48         mmf_return_val_if_fail((void *)info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  49
  50         _mmcam_dbg_err("");
  51
  52         MMTA_INIT() ;
  53
  54         __ta__("_mmcamcorder_create",
  55         error = _mmcamcorder_create(camcorder, info);
  56         );
  57
  58         _mmcam_dbg_err("END");
  59
  60         return error;
  61 }
  62
  63
  64 int mm_camcorder_destroy(MMHandleType camcorder)
  65 {
  66         int error = MM_ERROR_NONE;
  67
  68         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  69
  70         _mmcam_dbg_err("");
  71
  72         __ta__("_mmcamcorder_destroy",
  73         error = _mmcamcorder_destroy(camcorder);
  74         );
  75
  76         MMTA_ACUM_ITEM_SHOW_RESULT_TO(MMTA_SHOW_FILE);
  77         MMTA_RELEASE();
  78
  79         _mmcam_dbg_err("END!!!");
  80
  81         return error;
  82 }
  83
  84
  85 int mm_camcorder_realize(MMHandleType camcorder)
  86 {
  87         int error = MM_ERROR_NONE;
  88
  89         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
  90
  91         _mmcam_dbg_err("");
  92
  93         if(((mmf_camcorder_t *)camcorder)->sync_state_change) {
  94                 __ta__("_mmcamcorder_realize",
  95                 error = _mmcamcorder_realize(camcorder);
  96                 );
  97         } else {
  98                 /* After sending command, this function just return immediately. */
  99                 error = _mmcamcorder_append_simple_command(camcorder, _MMCAMCORDER_CMD_REALIZE);
 100         }
 101
 102         _mmcam_dbg_err("END");
 103
 104         return error;
 105 }
 106
 107
 108 int mm_camcorder_unrealize(MMHandleType camcorder)
 109 {
 110         int error = MM_ERROR_NONE;
 111
 112         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 113
 114         _mmcam_dbg_err("");
 115
 116         if(((mmf_camcorder_t *)camcorder)->sync_state_change) {
 117                 __ta__("_mmcamcorder_unrealize",
 118                 error = _mmcamcorder_unrealize(camcorder);
 119                 );
 120         } else {
 121                 /* After sending command, this function just return immediately. */
 122                 error = _mmcamcorder_append_simple_command(camcorder, _MMCAMCORDER_CMD_UNREALIZE);
 123         }
 124
 125         _mmcam_dbg_err("END");
 126
 127         return error;
 128 }
 129
 130
 131 int mm_camcorder_start(MMHandleType camcorder)
 132 {
 133         int error = MM_ERROR_NONE;
 134
 135         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 136
 137         _mmcam_dbg_err("");
 138
 139         if(((mmf_camcorder_t *)camcorder)->sync_state_change) {
 140                 __ta__("_mmcamcorder_start",
 141                 error = _mmcamcorder_start(camcorder);
 142                 );
 143         } else {
 144                 /* After sending command, this function just return immediately. */
 145                 error = _mmcamcorder_append_simple_command(camcorder, _MMCAMCORDER_CMD_START);
 146         }
 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         if(((mmf_camcorder_t *)camcorder)->sync_state_change) {
 163                 __ta__("_mmcamcorder_stop",
 164                 error = _mmcamcorder_stop(camcorder);
 165                 );
 166         } else {
 167                 /* After sending command, this function just return immediately. */
 168                 error = _mmcamcorder_append_simple_command(camcorder, _MMCAMCORDER_CMD_STOP);
 169         }
 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         __ta__("_mmcamcorder_capture_start",
 186         error = _mmcamcorder_capture_start(camcorder);
 187         );
 188
 189         _mmcam_dbg_err("END");
 190
 191         return error;
 192 }
 193
 194
 195 int mm_camcorder_capture_stop(MMHandleType camcorder)
 196 {
 197         int error = MM_ERROR_NONE;
 198
 199         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 200
 201         _mmcam_dbg_err("");
 202
 203         __ta__("_mmcamcorder_capture_stop",
 204         error = _mmcamcorder_capture_stop(camcorder);
 205         );
 206
 207         _mmcam_dbg_err("END");
 208
 209         return error;
 210 }
 211
 212
 213 int mm_camcorder_record(MMHandleType camcorder)
 214 {
 215         int error = MM_ERROR_NONE;
 216
 217         mmf_return_val_if_fail((void*)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 218
 219         _mmcam_dbg_err("");
 220
 221         __ta__("_mmcamcorder_record",
 222         error = _mmcamcorder_record(camcorder);
 223         );
 224
 225         _mmcam_dbg_err("END");
 226
 227         return error;
 228 }
 229
 230
 231 int mm_camcorder_pause(MMHandleType camcorder)
 232 {
 233         int error = MM_ERROR_NONE;
 234
 235         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 236
 237         _mmcam_dbg_err("");
 238
 239         __ta__("_mmcamcorder_pause",
 240         error = _mmcamcorder_pause(camcorder);
 241         );
 242
 243         _mmcam_dbg_err("END");
 244
 245         return error;
 246 }
 247
 248
 249 int mm_camcorder_commit(MMHandleType camcorder)
 250 {
 251         int error = MM_ERROR_NONE;
 252
 253         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 254
 255         _mmcam_dbg_err("");
 256
 257         MMTA_ACUM_ITEM_BEGIN("Real Commit Time", 0);
 258
 259         if(((mmf_camcorder_t *)camcorder)->sync_state_change) {
 260                 __ta__("_mmcamcorder_stop",
 261                 error = _mmcamcorder_commit(camcorder);
 262                 );
 263         } else {
 264                 /* After sending command, this function just return immediately. */
 265                 error = _mmcamcorder_append_simple_command(camcorder, _MMCAMCORDER_CMD_COMMIT);
 266         }
 267
 268         _mmcam_dbg_err("END");
 269
 270         return error;
 271 }
 272
 273
 274 int mm_camcorder_cancel(MMHandleType camcorder)
 275 {
 276         int error = MM_ERROR_NONE;
 277
 278         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 279
 280         _mmcam_dbg_err("");
 281
 282         __ta__("_mmcamcorder_cancel",
 283         error = _mmcamcorder_cancel(camcorder);
 284         );
 285
 286         _mmcam_dbg_err("END");
 287
 288         return error;
 289 }
 290
 291
 292 int mm_camcorder_set_message_callback(MMHandleType  camcorder, MMMessageCallback callback, void *user_data)
 293 {
 294         int error = MM_ERROR_NONE;
 295
 296         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 297
 298         error = _mmcamcorder_set_message_callback(camcorder, callback, user_data);
 299
 300         return error;
 301 }
 302
 303
 304 int mm_camcorder_set_video_stream_callback(MMHandleType camcorder, mm_camcorder_video_stream_callback callback, void* user_data)
 305 {
 306         int error = MM_ERROR_NONE;
 307
 308         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 309
 310         error = _mmcamcorder_set_video_stream_callback(camcorder, callback, user_data);
 311
 312         return error;
 313 }
 314
 315
 316 int mm_camcorder_set_audio_stream_callback(MMHandleType camcorder, mm_camcorder_audio_stream_callback callback, void* user_data)
 317 {
 318         int error = MM_ERROR_NONE;
 319
 320         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 321
 322         error = _mmcamcorder_set_audio_stream_callback(camcorder, callback, user_data);
 323
 324         return error;
 325 }
 326
 327
 328 int mm_camcorder_set_video_capture_callback(MMHandleType camcorder, mm_camcorder_video_capture_callback callback, void* user_data)
 329 {
 330         int error = MM_ERROR_NONE;
 331
 332         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
 333
 334         error = _mmcamcorder_set_video_capture_callback(camcorder, callback, user_data);
 335
 336         return error;
 337 }
 338
 339
 340 int mm_camcorder_get_state(MMHandleType camcorder, MMCamcorderStateType *status)
 341 {
 342         int ret = MM_ERROR_NONE;
 343
 344         if (!camcorder) {
 345                 _mmcam_dbg_warn("Empty handle.");
 346                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 347         }
 348
 349         *status = _mmcamcorder_get_state(camcorder);
 350
 351         return ret;
 352
 353 }
 354
 355
 356 int mm_camcorder_get_attributes(MMHandleType camcorder, char **err_attr_name, const char *attribute_name, ...)
 357 {
 358         va_list var_args;
 359         int ret = MM_ERROR_NONE;
 360
 361         return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 362
 363         va_start(var_args, attribute_name);
 364         ret = _mmcamcorder_get_attributes(camcorder, err_attr_name, attribute_name, var_args);
 365         va_end (var_args);
 366
 367         return ret;
 368 }
 369
 370
 371 int mm_camcorder_set_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         return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 377
 378         va_start (var_args, attribute_name);
 379         ret = _mmcamcorder_set_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_get_attribute_info(MMHandleType camcorder, const char *attribute_name, MMCamAttrsInfo *info)
 387 {
 388         return _mmcamcorder_get_attribute_info(camcorder, attribute_name, info);
 389 }
 390
 391
 392 int mm_camcorder_init_focusing(MMHandleType camcorder)
 393 {
 394         int error = MM_ERROR_NONE;
 395
 396         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 397
 398         error = _mmcamcorder_init_focusing(camcorder);
 399
 400         return error;
 401 }
 402
 403
 404 int mm_camcorder_start_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         /* TODO : Add direction parameter */
 411
 412         error = _mmcamcorder_adjust_focus(camcorder, MM_CAMCORDER_MF_LENS_DIR_FORWARD);
 413
 414         return error;
 415 }
 416
 417
 418 int mm_camcorder_stop_focusing(MMHandleType camcorder)
 419 {
 420         int error = MM_ERROR_NONE;
 421
 422         mmf_return_val_if_fail((void *)camcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 423
 424         error = _mmcamcorder_stop_focusing(camcorder);
 425
 426         return error;
 427 }
 428