src/video_util.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <stdbool.h>
  20 #include <dlog.h>
  21 #include <mm_transcode.h>
  22 #include <mm_error.h>
  23 #include <video_util.h>
  24 #include <video_util_private.h>
  25 #include <system_info.h>
  26
  27 #ifdef LOG_TAG
  28 #undef LOG_TAG
  29 #endif
  30
  31 #define LOG_TAG "CAPI_MEDIA_VIDEO_UTIL"
  32
  33 #define UTIL_SAFE_FREE(src)     \
  34         do {                                    \
  35                 if (src) {                      \
  36                         free(src);              \
  37                         src = NULL;             \
  38                 }                                       \
  39         } while (0)
  40
  41 #define UTIL_STRING_VALID(str) \
  42         ((str != NULL && strlen(str) > 0) ? true : false)
  43
  44 #define VIDEO_UTIL_MINIMUM_WIDTH                        128
  45 #define VIDEO_UTIL_MINIMUM_HEIGHT               96
  46 #define VIDEO_UTIL_MINIMUM_DURATION             1000    /* 1 sec */
  47 #define VIDEO_UTIL_MINIMUM_FPS                  5
  48 #define VIDEO_UTIL_MAXIMUM_FPS                  30
  49 #define VIDEO_UTIL_MAXIMUM_BPS                  4294967295UL
  50
  51 static int __video_util_create_transcode_handle(video_util_s *handle);
  52 static int __video_util_destroy_transcode_handle(video_util_s *handle);
  53 static int __video_util_check_transcode_is_busy(video_util_s * handle, bool *is_busy);
  54 static bool __video_util_check_video_codec(video_util_video_codec_e video_codec);
  55 static bool __video_util_check_audio_codec(video_util_audio_codec_e audio_codec);
  56 static bool __video_util_check_file_format(video_util_file_format_e file_format);
  57 static bool __video_util_check_resolution(int width, int height);
  58 static bool __video_util_check_duration(int duration);
  59 static bool __video_util_check_fps(int fps);
  60 static video_util_error_e __video_util_error_convert(int error);
  61 static void __video_util_transcode_progress_cb(unsigned long current_position, unsigned long duration, void *user_data);
  62 static void __video_util_transcode_completed_cb(int error, void *user_data);
  63 static bool __video_util_type_callback(int codec_type, void *user_data);
  64 static int __video_util_foreach_supported_type(video_util_type_e type, video_util_supported_type_cb callback, void *user_data);
  65
  66 static int __video_util_create_transcode_handle(video_util_s *handle)
  67 {
  68         int ret = VIDEO_UTIL_ERROR_NONE;
  69         MMHandleType transcode_h = 0;
  70
  71         ret = mm_transcode_create(&transcode_h);
  72         if (ret != MM_ERROR_NONE) {
  73                 if (ret == MM_ERROR_TRANSCODE_INVALID_VALUE) {
  74                         video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
  75                         return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
  76                 } else if (ret == MM_ERROR_TRANSCODE_NOT_SUPPORT_FORMAT) {
  77                         video_util_error("NOT_SUPPORTED_FORMAT(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED_FORMAT);
  78                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
  79                 } else {
  80                         video_util_error("INVALID_OPERATION(0x%08x)", ret);
  81                         return VIDEO_UTIL_ERROR_INVALID_OPERATION;
  82                 }
  83         }
  84
  85         ret = mm_transcode_prepare(transcode_h, handle->input_path, handle->file_format, handle->video_codec, handle->audio_codec);
  86         if (ret != MM_ERROR_NONE) {
  87                 if (ret == MM_ERROR_TRANSCODE_INVALID_VALUE) {
  88                         video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
  89                         ret = VIDEO_UTIL_ERROR_INVALID_PARAMETER;
  90                 } else if (ret == MM_ERROR_TRANSCODE_NOT_SUPPORT_FORMAT) {
  91                         video_util_error("NOT_SUPPORTED_FORMAT(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED_FORMAT);
  92                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
  93                 } else {
  94                         video_util_error("INVALID_OPERATION(0x%08x)", ret);
  95                         ret = VIDEO_UTIL_ERROR_INVALID_OPERATION;
  96                 }
  97         }
  98
  99         if (ret == MM_ERROR_NONE)
 100                 handle->transcode_h = transcode_h;
 101         else
 102                 __video_util_destroy_transcode_handle(handle);
 103
 104         return ret;
 105 }
 106
 107 /* when should make new trandcode handle? input_filepath or file_format or video_codec or audio_codec is modified */
 108 static int __video_util_destroy_transcode_handle(video_util_s *handle)
 109 {
 110         int ret = VIDEO_UTIL_ERROR_NONE;
 111
 112         if (handle->transcode_h) {
 113                 ret = mm_transcode_destroy(handle->transcode_h);
 114                 if (ret != MM_ERROR_NONE) {
 115                         video_util_error("INVALID_OPERATION (0x%08x)", ret);
 116                         return VIDEO_UTIL_ERROR_INVALID_OPERATION;
 117                 }
 118         }
 119
 120         handle->transcode_h = 0;
 121
 122         return ret;
 123 }
 124
 125 int __video_util_check_transcode_is_busy(video_util_s *handle, bool *is_busy)
 126 {
 127         int ret = VIDEO_UTIL_ERROR_NONE;
 128
 129         if (handle->transcode_h) {
 130                 ret = mm_transcode_is_busy(handle->transcode_h, is_busy);
 131                 if (ret != MM_ERROR_NONE) {
 132                         video_util_error("INVALID_OPERATION(0x%08x)", ret);
 133                         return VIDEO_UTIL_ERROR_INVALID_OPERATION;
 134                 }
 135         } else {
 136                 *is_busy = false;
 137         }
 138
 139         return ret;
 140 }
 141
 142 static bool __video_util_check_video_codec(video_util_video_codec_e video_codec)
 143 {
 144         if (video_codec > VIDEO_UTIL_VIDEO_CODEC_NONE) {
 145                 video_util_error("invalid video_codec [%d]", video_codec);
 146                 return false;
 147         }
 148
 149         return true;
 150 }
 151
 152 static bool __video_util_check_audio_codec(video_util_audio_codec_e audio_codec)
 153 {
 154         if (audio_codec > VIDEO_UTIL_AUDIO_CODEC_NONE) {
 155                 video_util_error("invalid audio_codec [%d]", audio_codec);
 156                 return false;
 157         }
 158
 159         return true;
 160 }
 161
 162 static bool __video_util_check_file_format(video_util_file_format_e file_format)
 163 {
 164         if (file_format >= VIDEO_UTIL_FILE_FORMAT_MAX) {
 165                 video_util_error("invalid file_format [%d]", file_format);
 166                 return false;
 167         }
 168
 169         return true;
 170 }
 171
 172 static bool __video_util_check_resolution(int width, int height)
 173 {
 174         if (((width > 0) && (width < VIDEO_UTIL_MINIMUM_WIDTH)) || (width < 0)) {
 175                 video_util_error("invalid width [%d]", width);
 176                 return false;
 177         }
 178
 179         if (((height > 0) && (height < VIDEO_UTIL_MINIMUM_HEIGHT)) || (height < 0)) {
 180                 video_util_error("invalid height [%d]", height);
 181                 return false;
 182         }
 183
 184         return true;
 185 }
 186
 187 static bool __video_util_check_duration(int duration)
 188 {
 189         if (((duration > 0) && (duration < VIDEO_UTIL_MINIMUM_DURATION)) || (duration < 0)) {
 190                 video_util_error("invalid duration [%d]", duration);
 191                 return false;
 192         }
 193
 194         return true;
 195 }
 196
 197 static bool __video_util_check_fps(int fps)
 198 {
 199         if ((fps < 0) || ((fps > 0) && (fps < VIDEO_UTIL_MINIMUM_FPS)) || (fps > VIDEO_UTIL_MAXIMUM_FPS)) {
 200                 video_util_error("invalid fps [%d]", fps);
 201                 return false;
 202         }
 203
 204         return true;
 205 }
 206
 207 static video_util_error_e __video_util_error_convert(int error)
 208 {
 209         if (error == MM_ERROR_NONE) {
 210                 video_util_debug("Error None");
 211                 return VIDEO_UTIL_ERROR_NONE;
 212         } else if (error == MM_ERROR_TRANSCODE_INVALID_VALUE) {
 213                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 214                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 215         } else if (error == MM_ERROR_TRANSCODE_NOT_SUPPORT_FORMAT) {
 216                 video_util_error("NOT_SUPPORTED_FORMAT(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED_FORMAT);
 217                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
 218         } else {
 219                 video_util_error("INVALID_OPERATION(0x%08x)", error);
 220                 return VIDEO_UTIL_ERROR_INVALID_OPERATION;
 221         }
 222 }
 223
 224 static void __video_util_transcode_progress_cb(unsigned long current_position, unsigned long duration, void *user_data)
 225 {
 226         video_util_s *_handle = (video_util_s *)user_data;
 227
 228         if ((_handle != NULL) && (_handle->_util_cb != NULL)
 229                 && (_handle->_util_cb->transcode_progress_cb != NULL))
 230                 _handle->_util_cb->transcode_progress_cb(current_position, duration, _handle->_util_cb->user_data);
 231
 232         return;
 233 }
 234
 235 static void __video_util_transcode_completed_cb(int error, void *user_data)
 236 {
 237         int error_value = VIDEO_UTIL_ERROR_NONE;
 238         video_util_s *_handle = (video_util_s *)user_data;
 239
 240         if (_handle == NULL) {
 241                 video_util_error("INVALID_PARAMETER");
 242                 return;
 243         }
 244
 245         if ((_handle->_util_cb != NULL) && (_handle->_util_cb->transcode_completed_cb != NULL)) {
 246                 error_value = __video_util_error_convert(error);
 247                 _handle->_util_cb->transcode_completed_cb(error_value, _handle->_util_cb->user_data);
 248         }
 249
 250         UTIL_SAFE_FREE(_handle->_util_cb);
 251
 252         return;
 253 }
 254
 255 static bool __video_util_type_callback(int codec_type, void *user_data)
 256 {
 257         video_util_type_cb_s *codec_cb = (video_util_type_cb_s *)user_data;
 258
 259         if (codec_cb != NULL) {
 260                 if (codec_cb->supported_type_cb)
 261                         codec_cb->supported_type_cb(codec_type, codec_cb->user_data);
 262         }
 263
 264         return true;
 265 }
 266
 267 static int __video_util_foreach_supported_type(video_util_type_e type, video_util_supported_type_cb callback, void *user_data)
 268 {
 269         int ret = VIDEO_UTIL_ERROR_NONE;
 270
 271         video_util_type_cb_s *codec_cb = (video_util_type_cb_s *)calloc(1, sizeof(video_util_type_cb_s));
 272         if (!codec_cb) {
 273                 video_util_error("Fail to allocate internal callback");
 274                 return VIDEO_UTIL_ERROR_OUT_OF_MEMORY;
 275         }
 276
 277         codec_cb->user_data = user_data;
 278         codec_cb->supported_type_cb = (video_util_supported_type_cb)callback;
 279
 280         if (type == VIDEO_UTIL_TYPE_FORMAT)
 281                 ret = mm_transcode_get_supported_container_format((mm_transcode_support_type_callback)__video_util_type_callback, (void *)codec_cb);
 282         else if (type == VIDEO_UTIL_TYPE_VIDEO_ENC)
 283                 ret = mm_transcode_get_supported_video_encoder((mm_transcode_support_type_callback)__video_util_type_callback, (void *)codec_cb);
 284         else if (type == VIDEO_UTIL_TYPE_AUDIO_ENC)
 285                 ret = mm_transcode_get_supported_audio_encoder((mm_transcode_support_type_callback)__video_util_type_callback, (void *)codec_cb);
 286         else {
 287                 video_util_error("Invalid type (%d)", type);
 288                 ret = VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 289         }
 290
 291         UTIL_SAFE_FREE(codec_cb);
 292
 293         return ret;
 294 }
 295
 296 int video_util_create(video_util_h *handle)
 297 {
 298         int ret = VIDEO_UTIL_ERROR_NONE;
 299         bool transcoder_supported = false;
 300
 301         video_util_deprecated_log(__FUNCTION__);
 302
 303         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 304                 if (false == transcoder_supported) {
 305                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 306                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 307                 }
 308         } else {
 309                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 310                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 311         }
 312
 313         if (handle == NULL) {
 314                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 315                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 316         }
 317
 318         video_util_s *_handle = (video_util_s *)calloc(1, sizeof(video_util_s));
 319         if (_handle == NULL) {
 320                 video_util_error("OUT_OF_MEMORY(0x%08x)", VIDEO_UTIL_ERROR_OUT_OF_MEMORY);
 321                 return VIDEO_UTIL_ERROR_OUT_OF_MEMORY;
 322         }
 323
 324         _handle->input_path = NULL;
 325         _handle->accurate_mode = false;
 326         _handle->video_codec = 0;
 327         _handle->audio_codec = 0;
 328         _handle->file_format = 0;
 329         _handle->width = 0;
 330         _handle->height = 0;
 331         _handle->fps = 0;
 332         _handle->transcode_h = 0;
 333         _handle->_util_cb = NULL;
 334
 335         *handle = (video_util_h)_handle;
 336
 337         return ret;
 338 }
 339
 340 int video_util_destroy(video_util_h handle)
 341 {
 342         int ret = VIDEO_UTIL_ERROR_NONE;
 343         video_util_s *_handle = NULL;
 344         bool transcoder_supported = false;
 345
 346         video_util_deprecated_log(__FUNCTION__);
 347
 348         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 349                 if (false == transcoder_supported) {
 350                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 351                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 352                 }
 353         } else {
 354                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 355                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 356         }
 357
 358         _handle = (video_util_s *)handle;
 359         if (_handle == NULL) {
 360                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 361                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 362         }
 363
 364         ret = __video_util_destroy_transcode_handle(_handle);
 365
 366         UTIL_SAFE_FREE(_handle->_util_cb);
 367         video_util_debug("FREE(_handle->_util_cb)");
 368         UTIL_SAFE_FREE(_handle->input_path);
 369         UTIL_SAFE_FREE(_handle);
 370
 371         return ret;
 372 }
 373
 374 int video_util_set_file_path(video_util_h handle, const char *file_path)
 375 {
 376         int ret = VIDEO_UTIL_ERROR_NONE;
 377         video_util_s *_handle = NULL;
 378         bool is_busy = false;
 379         bool transcoder_supported = false;
 380
 381         video_util_deprecated_log(__FUNCTION__);
 382
 383         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 384                 if (false == transcoder_supported) {
 385                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 386                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 387                 }
 388         } else {
 389                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 390                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 391         }
 392
 393         _handle = (video_util_s *)handle;
 394         if ((_handle != NULL) && (UTIL_STRING_VALID(file_path))) {
 395                 video_util_secure_info("file_path [%s]\n", file_path);
 396
 397                 if (_handle->input_path != NULL) {
 398                         ret = __video_util_check_transcode_is_busy(_handle, &is_busy);
 399                         if (ret != VIDEO_UTIL_ERROR_NONE)
 400                                 return ret;
 401
 402                         if (is_busy) {
 403                                 video_util_error("BUSY!! Transcoding is already running.\n");
 404                                 return VIDEO_UTIL_ERROR_BUSY;
 405                         } else {
 406                                 ret = __video_util_destroy_transcode_handle(_handle);
 407                                 if (ret != VIDEO_UTIL_ERROR_NONE)
 408                                         return ret;
 409
 410                                 UTIL_SAFE_FREE(_handle->input_path);
 411                         }
 412                 }
 413
 414                 _handle->input_path = strdup(file_path);
 415                 if (_handle->input_path == NULL) {
 416                         video_util_error("OUT_OF_MEMORY(0x%08x)", VIDEO_UTIL_ERROR_OUT_OF_MEMORY);
 417                         return VIDEO_UTIL_ERROR_OUT_OF_MEMORY;
 418                 }
 419         } else {
 420                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 421                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 422         }
 423
 424         return ret;
 425 }
 426
 427 int video_util_set_accurate_mode(video_util_h handle, bool accurate_mode)
 428 {
 429         int ret = VIDEO_UTIL_ERROR_NONE;
 430         video_util_s *_handle = NULL;
 431         bool transcoder_supported = false;
 432
 433         video_util_deprecated_log(__FUNCTION__);
 434
 435         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 436                 if (false == transcoder_supported) {
 437                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 438                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 439                 }
 440         } else {
 441                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 442                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 443         }
 444
 445         _handle = (video_util_s *)handle;
 446         if (_handle != NULL) {
 447                 _handle->accurate_mode = accurate_mode;
 448         } else {
 449                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 450                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 451         }
 452
 453         return ret;
 454 }
 455
 456 int video_util_set_video_codec(video_util_h handle, video_util_video_codec_e codec)
 457 {
 458         int ret = VIDEO_UTIL_ERROR_NONE;
 459         video_util_s *_handle = NULL;
 460         bool is_busy = false;
 461         bool transcoder_supported = false;
 462
 463         video_util_deprecated_log(__FUNCTION__);
 464
 465         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 466                 if (false == transcoder_supported) {
 467                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 468                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 469                 }
 470         } else {
 471                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 472                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 473         }
 474
 475         _handle = (video_util_s *)handle;
 476         if ((_handle != NULL) && (__video_util_check_video_codec(codec))) {
 477                 ret = __video_util_check_transcode_is_busy(_handle, &is_busy);
 478                 if (ret != VIDEO_UTIL_ERROR_NONE)
 479                         return ret;
 480
 481                 if (is_busy) {
 482                         video_util_error("BUSY!! Transcoding is already running.\n");
 483                         return VIDEO_UTIL_ERROR_BUSY;
 484                 } else {
 485                         ret = __video_util_destroy_transcode_handle(_handle);
 486                         if (ret != VIDEO_UTIL_ERROR_NONE)
 487                                 return ret;
 488                 }
 489
 490                 _handle->video_codec = codec;
 491         } else {
 492                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 493                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 494         }
 495
 496         return ret;
 497 }
 498
 499 int video_util_set_audio_codec(video_util_h handle, video_util_audio_codec_e codec)
 500 {
 501         int ret = VIDEO_UTIL_ERROR_NONE;
 502         video_util_s *_handle = NULL;
 503         bool is_busy = false;
 504         bool transcoder_supported = false;
 505
 506         video_util_deprecated_log(__FUNCTION__);
 507
 508         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 509                 if (false == transcoder_supported) {
 510                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 511                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 512                 }
 513         } else {
 514                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 515                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 516         }
 517
 518         _handle = (video_util_s *)handle;
 519         if ((_handle != NULL) && (__video_util_check_audio_codec(codec))) {
 520                 ret = __video_util_check_transcode_is_busy(_handle, &is_busy);
 521                 if (ret != VIDEO_UTIL_ERROR_NONE)
 522                         return ret;
 523
 524                 if (is_busy) {
 525                         video_util_error("BUSY!! Transcoding is already running.\n");
 526                         return VIDEO_UTIL_ERROR_BUSY;
 527                 } else {
 528                         ret = __video_util_destroy_transcode_handle(_handle);
 529                         if (ret != VIDEO_UTIL_ERROR_NONE)
 530                                 return ret;
 531                 }
 532
 533                 _handle->audio_codec = codec;
 534         } else {
 535                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 536                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 537         }
 538
 539         return ret;
 540 }
 541
 542 int video_util_set_file_format(video_util_h handle, video_util_file_format_e format)
 543 {
 544         int ret = VIDEO_UTIL_ERROR_NONE;
 545         video_util_s *_handle = NULL;
 546         bool is_busy = false;
 547         bool transcoder_supported = false;
 548
 549         video_util_deprecated_log(__FUNCTION__);
 550
 551         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 552                 if (false == transcoder_supported) {
 553                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 554                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 555                 }
 556         } else {
 557                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 558                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 559         }
 560
 561         _handle = (video_util_s *)handle;
 562         if ((_handle != NULL) && (__video_util_check_file_format(format))) {
 563                 ret = __video_util_check_transcode_is_busy(_handle, &is_busy);
 564                 if (ret != VIDEO_UTIL_ERROR_NONE)
 565                         return ret;
 566
 567                 if (is_busy) {
 568                         video_util_error("BUSY!! Transcoding is already running.\n");
 569                         return VIDEO_UTIL_ERROR_BUSY;
 570                 } else {
 571                         ret = __video_util_destroy_transcode_handle(_handle);
 572                         if (ret != VIDEO_UTIL_ERROR_NONE)
 573                                 return ret;
 574                 }
 575
 576                 _handle->file_format = format;
 577         } else {
 578                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 579                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 580         }
 581
 582         return ret;
 583 }
 584
 585 int video_util_set_resolution(video_util_h handle, int width, int height)
 586 {
 587         int ret = VIDEO_UTIL_ERROR_NONE;
 588         video_util_s *_handle = NULL;
 589         bool transcoder_supported = false;
 590
 591         video_util_deprecated_log(__FUNCTION__);
 592
 593         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 594                 if (false == transcoder_supported) {
 595                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 596                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 597                 }
 598         } else {
 599                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 600                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 601         }
 602
 603         _handle = (video_util_s *)handle;
 604         if ((_handle != NULL) && (__video_util_check_resolution(width, height))) {
 605                 _handle->width = width;
 606                 _handle->height = height;
 607         } else {
 608                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 609                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 610         }
 611
 612         return ret;
 613 }
 614
 615 int video_util_set_fps(video_util_h handle, int fps)
 616 {
 617         int ret = VIDEO_UTIL_ERROR_NONE;
 618         video_util_s *_handle = NULL;
 619         bool transcoder_supported = false;
 620
 621         video_util_deprecated_log(__FUNCTION__);
 622
 623         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 624                 if (false == transcoder_supported) {
 625                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 626                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 627                 }
 628         } else {
 629                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 630                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 631         }
 632
 633         _handle = (video_util_s *)handle;
 634         if (_handle && __video_util_check_fps(fps)) {
 635                 _handle->fps = fps;
 636         } else {
 637                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 638                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 639         }
 640
 641         return ret;
 642 }
 643
 644 int video_util_start_transcoding(video_util_h handle, unsigned long start, unsigned long duration, const char *out_path, video_util_transcoding_progress_cb progress_cb, video_util_transcoding_completed_cb completed_cb, void *user_data)
 645 {
 646         int ret = VIDEO_UTIL_ERROR_NONE;
 647         video_util_s *_handle = NULL;
 648         mm_seek_mode_e accurate_mode = MM_SEEK_NUM;
 649         bool is_busy = false;
 650         bool transcoder_supported = false;
 651
 652         video_util_deprecated_log(__FUNCTION__);
 653
 654         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 655                 if (false == transcoder_supported) {
 656                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 657                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 658                 }
 659         } else {
 660                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 661                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 662         }
 663
 664         _handle = (video_util_s *)handle;
 665         video_util_debug("start [%lu] duration [%lu]\n", start, duration);
 666
 667         if (_handle && (__video_util_check_duration(duration)) && (UTIL_STRING_VALID(_handle->input_path)) && (UTIL_STRING_VALID(out_path)) && completed_cb) {
 668                 if (!_handle->transcode_h) {
 669                         ret = __video_util_create_transcode_handle(_handle);
 670                         if (ret != MM_ERROR_NONE)
 671                                 return ret;
 672
 673                         if (!_handle->transcode_h) {
 674                                 video_util_error("INVALID_OPERATION(0x%08x)", VIDEO_UTIL_ERROR_INVALID_OPERATION);
 675                                 return VIDEO_UTIL_ERROR_INVALID_OPERATION;
 676                         }
 677                 } else {
 678                         ret = __video_util_check_transcode_is_busy(_handle, &is_busy);
 679                         if (ret != VIDEO_UTIL_ERROR_NONE)
 680                                 return ret;
 681
 682                         if (is_busy) {
 683                                 video_util_error("BUSY!! Transcoding is already running.\n");
 684                                 return VIDEO_UTIL_ERROR_BUSY;
 685                         }
 686                 }
 687
 688                 video_util_debug("width [%d] height [%d] fps [%d]v_codec [%d] a_codec [%d] file_format [%d] accurate [%d]\n", _handle->width, _handle->height, _handle->fps, _handle->video_codec, _handle->audio_codec, _handle->file_format, _handle->accurate_mode);
 689
 690                 _handle->_util_cb = (video_util_cb_s *)calloc(1, sizeof(video_util_cb_s));
 691                 if (!_handle->_util_cb) {
 692                         video_util_error("Error _util_cb");
 693                         return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 694                 }
 695                 _handle->_util_cb->user_data = user_data;
 696                 _handle->_util_cb->transcode_completed_cb = completed_cb;
 697                 _handle->_util_cb->transcode_progress_cb = progress_cb;
 698
 699                 if (_handle->accurate_mode)
 700                         accurate_mode = MM_SEEK_ACCURATE;
 701                 else
 702                         accurate_mode = MM_SEEK_INACCURATE;
 703
 704                 ret = mm_transcode(_handle->transcode_h, _handle->width, _handle->height, _handle->fps, start, duration, accurate_mode, out_path, (mm_transcode_progress_callback)__video_util_transcode_progress_cb, (mm_transcode_completed_callback)__video_util_transcode_completed_cb, (void *)_handle);
 705
 706                 if (ret != MM_ERROR_NONE) {
 707                         UTIL_SAFE_FREE(_handle->_util_cb);
 708
 709                         if (ret == MM_ERROR_TRANSCODE_INVALID_VALUE) {
 710                                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 711                                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 712                         } else if (ret == MM_ERROR_TRANSCODE_NOT_SUPPORT_FORMAT) {
 713                                 video_util_error("NOT_SUPPORTED_FORMAT(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED_FORMAT);
 714                                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
 715                         } else {
 716                                 video_util_error("INVALID_OPERATION(0x%08x)", ret);
 717                                 return VIDEO_UTIL_ERROR_INVALID_OPERATION;
 718                         }
 719                 }
 720         } else {
 721                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 722                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 723         }
 724
 725         return ret;
 726 }
 727
 728 int video_util_cancel_transcoding(video_util_h handle)
 729 {
 730         int ret = VIDEO_UTIL_ERROR_NONE;
 731         video_util_s *_handle = NULL;
 732         bool transcoder_supported = false;
 733
 734         video_util_deprecated_log(__FUNCTION__);
 735
 736         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 737                 if (false == transcoder_supported) {
 738                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 739                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 740                 }
 741         } else {
 742                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 743                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 744         }
 745
 746         _handle = (video_util_s *)handle;
 747         if (_handle && (_handle->transcode_h)) {
 748                 ret = mm_transcode_cancel(_handle->transcode_h);
 749                 if (ret != MM_ERROR_NONE) {
 750                         video_util_error("INVALID_OPERATION(0x%08x)", ret);
 751                         return VIDEO_UTIL_ERROR_INVALID_OPERATION;
 752                 }
 753         } else {
 754                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 755                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 756         }
 757
 758         UTIL_SAFE_FREE(_handle->_util_cb);
 759         video_util_debug("FREE(_handle->_util_cb)");
 760
 761         return ret;
 762 }
 763
 764 int video_util_get_progress_transcoding(video_util_h handle, unsigned long *current_position, unsigned long *duration)
 765 {
 766         int ret = VIDEO_UTIL_ERROR_NONE;
 767         video_util_s *_handle = NULL;
 768         int value = 0;
 769         bool transcoder_supported = false;
 770
 771         video_util_deprecated_log(__FUNCTION__);
 772
 773         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 774                 if (false == transcoder_supported) {
 775                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 776                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 777                 }
 778         } else {
 779                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 780                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 781         }
 782
 783         _handle = (video_util_s *)handle;
 784         if (_handle && current_position && duration) {
 785                 if (_handle->transcode_h) {
 786                         ret = mm_transcode_get_attrs(_handle->transcode_h, (mm_containerformat_e *)&value, (mm_videoencoder_e *)&value, (mm_audioencoder_e *)&value, current_position, duration, (unsigned int *)&value, (unsigned int *)&value);
 787                         if (ret != MM_ERROR_NONE) {
 788                                 video_util_error("INVALID_OPERATION(0x%08x)", ret);
 789                                 return VIDEO_UTIL_ERROR_INVALID_OPERATION;
 790                         }
 791                 } else {
 792                         video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 793                         return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 794                 }
 795         } else {
 796                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 797                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 798         }
 799
 800         return ret;
 801 }
 802
 803 int video_util_foreach_supported_file_format(video_util_h handle, video_util_supported_file_format_cb callback, void *user_data)
 804 {
 805         int ret = VIDEO_UTIL_ERROR_NONE;
 806         video_util_s *_handle = NULL;
 807         bool transcoder_supported = false;
 808
 809         video_util_deprecated_log(__FUNCTION__);
 810
 811         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 812                 if (false == transcoder_supported) {
 813                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 814                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 815                 }
 816         } else {
 817                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 818                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 819         }
 820
 821         _handle = (video_util_s *)handle;
 822         if (_handle && callback) {
 823                 ret = __video_util_foreach_supported_type(VIDEO_UTIL_TYPE_FORMAT, (video_util_supported_type_cb)callback, user_data);
 824         } else {
 825                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 826                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 827         }
 828
 829         return ret;
 830 }
 831
 832 int video_util_foreach_supported_video_codec(video_util_h handle, video_util_supported_video_encoder_cb callback, void *user_data)
 833 {
 834         int ret = VIDEO_UTIL_ERROR_NONE;
 835         video_util_s *_handle = NULL;
 836         bool transcoder_supported = false;
 837
 838         video_util_deprecated_log(__FUNCTION__);
 839
 840         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 841                 if (false == transcoder_supported) {
 842                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 843                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 844                 }
 845         }
 846         _handle = (video_util_s *)handle;
 847         if (_handle && callback) {
 848                 ret = __video_util_foreach_supported_type(VIDEO_UTIL_TYPE_VIDEO_ENC, (video_util_supported_type_cb)callback, user_data);
 849         } else {
 850                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 851                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 852         }
 853
 854         return ret;
 855 }
 856
 857 int video_util_foreach_supported_audio_codec(video_util_h handle, video_util_supported_audio_encoder_cb callback, void *user_data)
 858 {
 859         int ret = VIDEO_UTIL_ERROR_NONE;
 860         video_util_s *_handle = NULL;
 861         bool transcoder_supported = false;
 862
 863         video_util_deprecated_log(__FUNCTION__);
 864
 865         if (0 == system_info_get_platform_bool(TRANSCODER_FEATURE_PATH, &transcoder_supported)) {
 866                 if (false == transcoder_supported) {
 867                         video_util_error("VIDEO_UTIL_ERROR_NOT_SUPPORTED(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 868                         return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 869                 }
 870         } else {
 871                 video_util_error("Error - System Info of Platform(0x%08x)", VIDEO_UTIL_ERROR_NOT_SUPPORTED);
 872                 return VIDEO_UTIL_ERROR_NOT_SUPPORTED;
 873         }
 874
 875         _handle = (video_util_s *)handle;
 876         if (_handle && callback) {
 877                 ret = __video_util_foreach_supported_type(VIDEO_UTIL_TYPE_AUDIO_ENC, (video_util_supported_type_cb)callback, user_data);
 878         } else {
 879                 video_util_error("INVALID_PARAMETER(0x%08x)", VIDEO_UTIL_ERROR_INVALID_PARAMETER);
 880                 return VIDEO_UTIL_ERROR_INVALID_PARAMETER;
 881         }
 882
 883         return ret;
 884 }