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