src/FMedia_RecorderUtil.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                        FMedia_RecorderUtil.cpp
  20  * @brief                       This file contains the utility of camcorder.
  21  *
  22  */
  23
  24 #include <FIoFile.h>
  25 #include <FBaseSysLog.h>
  26 #include "FMedia_RecorderUtil.h"
  27
  28 using namespace Tizen::Io;
  29
  30 namespace Tizen { namespace Media
  31 {
  32
  33 typedef struct
  34 {
  35         Tizen::Media::CodecType audioCodec;
  36         Tizen::Media::CodecType videoCodec;
  37         Tizen::Media::MediaContainerType container;
  38 } _CodecContainerTable;
  39
  40 const static _CodecContainerTable _SUPPORTED_CODEC_CONTAINER[] =
  41 {
  42         //Audio
  43         { CODEC_LPCM,           CODEC_NONE,             MEDIA_CONTAINER_WAV},
  44         { CODEC_AMR_NB,         CODEC_NONE,             MEDIA_CONTAINER_AMR},
  45         { CODEC_AMR_NB,         CODEC_NONE,             MEDIA_CONTAINER_3GP},
  46 //      { CODEC_AMR_NB,         CODEC_NONE,             MEDIA_CONTAINER_MP4},
  47         { CODEC_AAC,            CODEC_NONE,             MEDIA_CONTAINER_AAC},
  48         {  CODEC_AAC,           CODEC_NONE,             MEDIA_CONTAINER_3GP},
  49         {  CODEC_AAC,           CODEC_NONE,             MEDIA_CONTAINER_MP4},
  50
  51         // Video
  52         { CODEC_AMR_NB,         CODEC_MPEG4,            MEDIA_CONTAINER_3GP},
  53         { CODEC_AMR_NB,         CODEC_H263,             MEDIA_CONTAINER_3GP},
  54         { CODEC_AMR_NB,         CODEC_H264,             MEDIA_CONTAINER_3GP},
  55 //      { CODEC_AMR_NB,         CODEC_MPEG4,            MEDIA_CONTAINER_MP4},
  56 //      { CODEC_AMR_NB,         CODEC_H263,             MEDIA_CONTAINER_MP4},
  57 //      { CODEC_AMR_NB,         CODEC_H264,             MEDIA_CONTAINER_MP4},
  58
  59         { CODEC_AAC,    CODEC_MPEG4,            MEDIA_CONTAINER_3GP},
  60         { CODEC_AAC,    CODEC_H263,             MEDIA_CONTAINER_3GP},
  61         { CODEC_AAC,    CODEC_H264,             MEDIA_CONTAINER_3GP},
  62         { CODEC_AAC,    CODEC_MPEG4,            MEDIA_CONTAINER_MP4},
  63 //      { CODEC_AAC,    CODEC_H263,             MEDIA_CONTAINER_MP4},
  64         { CODEC_AAC,    CODEC_H264,             MEDIA_CONTAINER_MP4},
  65
  66         { CODEC_NONE,   CODEC_MPEG4,            MEDIA_CONTAINER_3GP},
  67         { CODEC_NONE,   CODEC_H263,             MEDIA_CONTAINER_3GP},
  68         { CODEC_NONE,   CODEC_H264,             MEDIA_CONTAINER_3GP},
  69         { CODEC_NONE,   CODEC_MPEG4,            MEDIA_CONTAINER_MP4},
  70 //      { CODEC_NONE,   CODEC_H263,             MEDIA_CONTAINER_MP4},
  71         { CODEC_NONE,   CODEC_H264,             MEDIA_CONTAINER_MP4},
  72 };
  73
  74
  75 typedef struct
  76 {
  77         recorder_audio_codec_e mmAttr;
  78         CodecType value;
  79 }_AudioCodecTable;
  80
  81 static const _AudioCodecTable _AUDIO_CODEC[] =
  82 {
  83         {::RECORDER_AUDIO_CODEC_DISABLE, CODEC_NONE},
  84         {::RECORDER_AUDIO_CODEC_AMR, CODEC_AMR_NB},
  85         {::RECORDER_AUDIO_CODEC_AAC, CODEC_AAC},
  86 //      {::RECORDER_AUDIO_CODEC_VORBIS, CODEC_VORBIS},//We do not supported VORBIS CODEC TYPE
  87         {::RECORDER_AUDIO_CODEC_PCM, CODEC_LPCM},
  88 };
  89
  90 result
  91 _RecorderUtil::GetMmAudioCodec(CodecType value, recorder_audio_codec_e& mmAttr)
  92 {
  93         bool findFlag = false;
  94         int size = sizeof(_AUDIO_CODEC)/sizeof(_AUDIO_CODEC[0]);
  95
  96         for (int i = 0; i < size; i++)
  97         {
  98                 if (_AUDIO_CODEC[i].value == value)
  99                 {
 100                         mmAttr = _AUDIO_CODEC[i].mmAttr;
 101                         findFlag = true;
 102                         break;
 103                 }
 104         }
 105         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 106 }
 107
 108 result
 109 _RecorderUtil::GetOspAudioCodec(recorder_audio_codec_e mmAttr, CodecType& value)
 110 {
 111         bool findFlag = false;
 112         int size = sizeof(_AUDIO_CODEC)/sizeof(_AUDIO_CODEC[0]);
 113
 114         for (int i = 0; i < size; i++)
 115         {
 116                 if (_AUDIO_CODEC[i].mmAttr == mmAttr)
 117                 {
 118                         value = _AUDIO_CODEC[i].value;
 119                         findFlag = true;
 120                         break;
 121                 }
 122         }
 123         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 124 }
 125
 126 typedef struct
 127 {
 128         recorder_video_codec_e mmAttr;
 129         CodecType value;
 130 }_VideoCodecTable;
 131
 132 static const _VideoCodecTable _VIDEO_CODEC[] =
 133 {
 134         {::RECORDER_VIDEO_CODEC_H263, CODEC_H263},
 135         {::RECORDER_VIDEO_CODEC_H264, CODEC_H264},
 136         {::RECORDER_VIDEO_CODEC_MPEG4, CODEC_MPEG4},
 137 //      {::RECORDER_VIDEO_CODEC_THEORA, CODEC_THEORA},
 138 };
 139
 140 result
 141 _RecorderUtil::GetMmVideoCodec(CodecType value, recorder_video_codec_e& mmAttr)
 142 {
 143         bool findFlag = false;
 144         int size = sizeof(_VIDEO_CODEC)/sizeof(_VIDEO_CODEC[0]);
 145
 146         for (int i = 0; i < size; i++)
 147         {
 148                 if (_VIDEO_CODEC[i].value == value)
 149                 {
 150                         mmAttr = _VIDEO_CODEC[i].mmAttr;
 151                         findFlag = true;
 152                         break;
 153                 }
 154         }
 155         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 156 }
 157
 158 result
 159 _RecorderUtil::GetOspVideoCodec(recorder_video_codec_e mmAttr, CodecType& value)
 160 {
 161         bool findFlag = false;
 162         int size = sizeof(_VIDEO_CODEC)/sizeof(_VIDEO_CODEC[0]);
 163
 164         for (int i = 0; i < size; i++)
 165         {
 166                 if (_VIDEO_CODEC[i].mmAttr == mmAttr)
 167                 {
 168                         value = _VIDEO_CODEC[i].value;
 169                         findFlag = true;
 170                         break;
 171                 }
 172         }
 173         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 174 }
 175
 176 typedef struct
 177 {
 178         recorder_file_format_e mmAttr;
 179         MediaContainerType value;
 180 }_ContainerTable;
 181
 182 static const _ContainerTable _CONTAINER[] =
 183 {
 184         {::RECORDER_FILE_FORMAT_3GP, MEDIA_CONTAINER_3GP},
 185         {::RECORDER_FILE_FORMAT_MP4, MEDIA_CONTAINER_MP4},
 186         {::RECORDER_FILE_FORMAT_AMR, MEDIA_CONTAINER_AMR},
 187         {::RECORDER_FILE_FORMAT_ADTS, MEDIA_CONTAINER_AAC},
 188         {::RECORDER_FILE_FORMAT_WAV, MEDIA_CONTAINER_WAV},
 189 };
 190
 191
 192 typedef struct
 193 {
 194                 recorder_file_format_e mmAttr;
 195                 MediaContainerType value;
 196 }_VideoContainerTable;
 197
 198 static const _VideoContainerTable _VIDEO_CONTAINER[] =
 199 {
 200         {::RECORDER_FILE_FORMAT_3GP, MEDIA_CONTAINER_3GP},
 201         {::RECORDER_FILE_FORMAT_MP4, MEDIA_CONTAINER_MP4},
 202 };
 203
 204 typedef struct
 205 {
 206                 recorder_file_format_e mmAttr;
 207                 MediaContainerType value;
 208 }_ContainerVideoTable;
 209
 210 result
 211 _RecorderUtil::GetMmFileFormat(MediaContainerType value, recorder_file_format_e& mmAttr)
 212 {
 213         bool findFlag = false;
 214         int size = sizeof(_CONTAINER)/sizeof(_CONTAINER[0]);
 215
 216         for (int i = 0; i < size; i++)
 217         {
 218                 if (_CONTAINER[i].value == value)
 219                 {
 220                         mmAttr = _CONTAINER[i].mmAttr;
 221                         findFlag = true;
 222                         break;
 223                 }
 224         }
 225         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 226 }
 227
 228 result
 229 _RecorderUtil::GetOspVideoContainer(recorder_file_format_e mmAttr, MediaContainerType& value)
 230 {
 231         bool findFlag = false;
 232         int size = sizeof(_VIDEO_CONTAINER)/sizeof(_VIDEO_CONTAINER[0]);
 233
 234         for (int i = 0; i < size; i++)
 235         {
 236                 if (_VIDEO_CONTAINER[i].mmAttr == mmAttr)
 237                 {
 238                         value = _VIDEO_CONTAINER[i].value;
 239                         findFlag = true;
 240                         break;
 241                 }
 242         }
 243         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 244 }
 245
 246 result
 247 _RecorderUtil::GetOspAudioContainer(recorder_file_format_e mmAttr, MediaContainerType& value)
 248 {
 249                 bool findFlag = false;
 250                 int size = sizeof(_CONTAINER)/sizeof(_CONTAINER[0]);
 251
 252                 for (int i = 0; i < size; i++)
 253                 {
 254                                 if (_CONTAINER[i].mmAttr == mmAttr)
 255                                 {
 256                                                 value = _CONTAINER[i].value;
 257                                                 findFlag = true;
 258                                                 break;
 259                                 }
 260                 }
 261                 return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 262 }
 263
 264 typedef struct
 265 {
 266         int mmAttrSamplerate;
 267         int mmAttrChannel;
 268         int mmAttrBitrate;
 269         CodecType audioCodec;
 270         RecordingQuality quality;
 271 }_AudioQualityTable;
 272
 273 static const _AudioQualityTable _AUDIO_QUALITY[] =
 274 {
 275         {8000, 1, 256000, CODEC_LPCM, RECORDING_QUALITY_LOW},
 276         {22050, 2, 706000, CODEC_LPCM, RECORDING_QUALITY_MEDIUM},
 277         {44100, 2, 1411000, CODEC_LPCM, RECORDING_QUALITY_HIGH},
 278         {8000, 1, 4750, CODEC_AMR_NB, RECORDING_QUALITY_LOW},
 279         {8000, 1, 7950, CODEC_AMR_NB, RECORDING_QUALITY_MEDIUM},
 280         {8000, 1, 12200, CODEC_AMR_NB, RECORDING_QUALITY_HIGH},
 281         {22050, 2, 120000, CODEC_AAC, RECORDING_QUALITY_LOW},
 282         {44100, 2, 220000, CODEC_AAC, RECORDING_QUALITY_MEDIUM},
 283         {44100, 2, 320000, CODEC_AAC, RECORDING_QUALITY_HIGH},
 284 };
 285
 286 result
 287 _RecorderUtil::GetMmAudioQuality(CodecType audioCodec, RecordingQuality quality, int& mmAttrSamplerate, int& mmAttrChannel, int& mmAttrBitrate)
 288 {
 289         bool findFlag = false;
 290         int size = sizeof(_AUDIO_QUALITY)/sizeof(_AUDIO_QUALITY[0]);
 291
 292         for (int i = 0; i < size; i++)
 293         {
 294                 if (_AUDIO_QUALITY[i].audioCodec == audioCodec && _AUDIO_QUALITY[i].quality == quality)
 295                 {
 296                         mmAttrSamplerate = _AUDIO_QUALITY[i].mmAttrSamplerate;
 297                         mmAttrChannel = _AUDIO_QUALITY[i].mmAttrChannel;
 298                         mmAttrBitrate = _AUDIO_QUALITY[i].mmAttrBitrate;
 299                         findFlag = true;
 300                         break;
 301                 }
 302         }
 303         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 304 }
 305
 306 typedef struct
 307 {
 308         int mmAttrBitrate;
 309         _ResolutionType resolution;
 310         RecordingQuality quality;
 311 }_VideoQualityTable;
 312
 313 static const _VideoQualityTable _VIDEO_QUALITY[] =
 314 {
 315         {48000, _RES_128X96, RECORDING_QUALITY_LOW},
 316         {64000, _RES_128X96, RECORDING_QUALITY_MEDIUM},
 317         {80000, _RES_128X96, RECORDING_QUALITY_HIGH},
 318         {72000, _RES_160X120, RECORDING_QUALITY_LOW},
 319         {97000, _RES_160X120, RECORDING_QUALITY_MEDIUM},
 320         {120000, _RES_160X120, RECORDING_QUALITY_HIGH},
 321         {96000, _RES_176X144, RECORDING_QUALITY_LOW},
 322         {128000, _RES_176X144, RECORDING_QUALITY_MEDIUM},
 323         {160000, _RES_176X144, RECORDING_QUALITY_HIGH},
 324         {96000, _RES_176X176, RECORDING_QUALITY_LOW},
 325         {128000, _RES_176X176, RECORDING_QUALITY_MEDIUM},
 326         {160000, _RES_176X176, RECORDING_QUALITY_HIGH},
 327         {96000, _RES_240X320, RECORDING_QUALITY_LOW},
 328         {128000, _RES_240X320, RECORDING_QUALITY_MEDIUM},
 329         {160000, _RES_240X320, RECORDING_QUALITY_HIGH},
 330         {96000, _RES_320X240, RECORDING_QUALITY_LOW},
 331         {128000, _RES_320X240, RECORDING_QUALITY_MEDIUM},
 332         {160000, _RES_320X240, RECORDING_QUALITY_HIGH},
 333         {96000, _RES_240X400, RECORDING_QUALITY_LOW},
 334         {128000, _RES_240X400, RECORDING_QUALITY_MEDIUM},
 335         {160000, _RES_240X400, RECORDING_QUALITY_HIGH},
 336         {96000, _RES_400X240, RECORDING_QUALITY_LOW},
 337         {128000, _RES_400X240, RECORDING_QUALITY_MEDIUM},
 338         {160000, _RES_400X240, RECORDING_QUALITY_HIGH},
 339         {96000, _RES_352X288, RECORDING_QUALITY_LOW},
 340         {128000, _RES_352X288, RECORDING_QUALITY_MEDIUM},
 341         {160000, _RES_352X288, RECORDING_QUALITY_HIGH},
 342         {96000, _RES_480X360, RECORDING_QUALITY_LOW},
 343         {128000, _RES_480X360, RECORDING_QUALITY_MEDIUM},
 344         {160000, _RES_480X360, RECORDING_QUALITY_HIGH},
 345         {96000, _RES_640X360, RECORDING_QUALITY_LOW},
 346         {128000, _RES_640X360, RECORDING_QUALITY_MEDIUM},
 347         {160000, _RES_640X360, RECORDING_QUALITY_HIGH},
 348
 349         {2000000, _RES_640X480, RECORDING_QUALITY_LOW},
 350         {2500000, _RES_640X480, RECORDING_QUALITY_MEDIUM},
 351         {3000000, _RES_640X480, RECORDING_QUALITY_HIGH},
 352         {2200000, _RES_720X480, RECORDING_QUALITY_LOW},
 353         {2800000, _RES_720X480, RECORDING_QUALITY_MEDIUM},
 354         {3300000, _RES_720X480, RECORDING_QUALITY_HIGH},
 355
 356         {96000, _RES_800X480, RECORDING_QUALITY_LOW},
 357         {128000, _RES_800X480, RECORDING_QUALITY_MEDIUM},
 358         {160000, _RES_800X480, RECORDING_QUALITY_HIGH},
 359         {96000, _RES_800X600, RECORDING_QUALITY_LOW},
 360         {128000, _RES_800X600, RECORDING_QUALITY_MEDIUM},
 361         {160000, _RES_800X600, RECORDING_QUALITY_HIGH},
 362
 363         {2000000, _RES_960X720, RECORDING_QUALITY_LOW},
 364         {2500000, _RES_960X720, RECORDING_QUALITY_MEDIUM},
 365         {3000000, _RES_960X720, RECORDING_QUALITY_HIGH},
 366
 367         {2000000, _RES_1280X720, RECORDING_QUALITY_LOW},
 368         {2500000, _RES_1280X720, RECORDING_QUALITY_MEDIUM},
 369         {3000000, _RES_1280X720, RECORDING_QUALITY_HIGH},
 370
 371         {2000000, _RES_1280X960, RECORDING_QUALITY_LOW},
 372         {2500000, _RES_1280X960, RECORDING_QUALITY_MEDIUM},
 373         {3000000, _RES_1280X960, RECORDING_QUALITY_HIGH},
 374
 375         {2000000, _RES_1392X1392, RECORDING_QUALITY_LOW},
 376         {2500000, _RES_1392X1392, RECORDING_QUALITY_MEDIUM},
 377         {3000000, _RES_1392X1392, RECORDING_QUALITY_HIGH},
 378
 379         {2200000, _RES_1600X1200, RECORDING_QUALITY_LOW},
 380         {2800000, _RES_1600X1200, RECORDING_QUALITY_MEDIUM},
 381         {3300000, _RES_1600X1200, RECORDING_QUALITY_HIGH},
 382         {2200000, _RES_1920X1080, RECORDING_QUALITY_LOW},
 383         {2800000, _RES_1920X1080, RECORDING_QUALITY_MEDIUM},
 384         {3300000, _RES_1920X1080, RECORDING_QUALITY_HIGH},
 385 };
 386
 387 result
 388 _RecorderUtil::GetMmVideoQuality(_ResolutionType resolution, RecordingQuality quality, int& mmAttrBitrate)
 389 {
 390         bool findFlag = false;
 391         int size = sizeof(_VIDEO_QUALITY)/sizeof(_VIDEO_QUALITY[0]);
 392
 393         for (int i = 0; i < size; i++)
 394         {
 395                 if (_VIDEO_QUALITY[i].resolution == resolution && _VIDEO_QUALITY[i].quality == quality)
 396                 {
 397                         mmAttrBitrate = _VIDEO_QUALITY[i].mmAttrBitrate;
 398                         findFlag = true;
 399                         break;
 400                 }
 401         }
 402         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 403 }
 404
 405 typedef struct
 406 {
 407         recorder_rotation_e mmAttr;
 408         RecordingRotation value;
 409 }_RotationTable;
 410
 411 static const _RotationTable _ROTATION[] =
 412 {
 413         {RECORDER_ROTATION_NONE, RECORDING_ROTATION_NONE},
 414         {RECORDER_ROTATION_90, RECORDING_ROTATION_90},
 415         {RECORDER_ROTATION_180, RECORDING_ROTATION_180},
 416         {RECORDER_ROTATION_270, RECORDING_ROTATION_270},
 417 };
 418
 419 result
 420 _RecorderUtil::GetMmRotation(RecordingRotation value, recorder_rotation_e& mmAttr)
 421 {
 422         bool findFlag = false;
 423         int size = sizeof(_ROTATION)/sizeof(_ROTATION[0]);
 424
 425         for (int i = 0; i < size; i++)
 426         {
 427                 if (_ROTATION[i].value == value)
 428                 {
 429                         mmAttr = _ROTATION[i].mmAttr;
 430                         findFlag = true;
 431                         break;
 432                 }
 433         }
 434         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 435 }
 436
 437 result
 438 _RecorderUtil::GetOspRotation(recorder_rotation_e mmAttr, RecordingRotation& value)
 439 {
 440         bool findFlag = false;
 441         int size = sizeof(_ROTATION)/sizeof(_ROTATION[0]);
 442
 443         for (int i = 0; i < size; i++)
 444         {
 445                 if (_ROTATION[i].mmAttr == mmAttr)
 446                 {
 447                         value = _ROTATION[i].value;
 448                         findFlag = true;
 449                         break;
 450                 }
 451         }
 452         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 453 }
 454
 455 typedef struct
 456 {
 457         CameraRotation cameraRotation;
 458         RecordingRotation recorderRotation;
 459 }CameraRecorderRotationTable;
 460
 461 static const CameraRecorderRotationTable _CAM_REC_ROTATION[] =
 462 {
 463         {CAMERA_ROTATION_NONE, RECORDING_ROTATION_NONE},
 464         {CAMERA_ROTATION_90, RECORDING_ROTATION_90},
 465         {CAMERA_ROTATION_180, RECORDING_ROTATION_180},
 466         {CAMERA_ROTATION_270, RECORDING_ROTATION_270},
 467 };
 468
 469 result
 470 _RecorderUtil::GetRecorderRotation(CameraRotation cameraRotation, RecordingRotation& recorderRotation)
 471 {
 472         bool findFlag = false;
 473         int size = sizeof(_CAM_REC_ROTATION)/sizeof(_CAM_REC_ROTATION[0]);
 474
 475         for (int i = 0; i < size; i++)
 476         {
 477                 if (_CAM_REC_ROTATION[i].cameraRotation == cameraRotation)
 478                 {
 479                         recorderRotation = _CAM_REC_ROTATION[i].recorderRotation;
 480                         findFlag = true;
 481                         break;
 482                 }
 483         }
 484         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 485 }
 486
 487 result
 488 _RecorderUtil::GetCameraRotation(RecordingRotation recorderRotation, CameraRotation& cameraRotation)
 489 {
 490         bool findFlag = false;
 491         int size = sizeof(_CAM_REC_ROTATION)/sizeof(_CAM_REC_ROTATION[0]);
 492
 493         for (int i = 0; i < size; i++)
 494         {
 495                 if (_CAM_REC_ROTATION[i].recorderRotation == recorderRotation)
 496                 {
 497                         cameraRotation = _CAM_REC_ROTATION[i].cameraRotation;
 498                         findFlag = true;
 499                         break;
 500                 }
 501         }
 502         return findFlag ? E_SUCCESS : E_UNSUPPORTED_TYPE;
 503 }
 504
 505 bool
 506 _RecorderUtil::CheckFormat(CodecType audioCodec, CodecType videoCodec, MediaContainerType container)
 507 {
 508         bool supported = false;
 509         int tableCount = 0;
 510         tableCount = sizeof(_SUPPORTED_CODEC_CONTAINER) / sizeof(_SUPPORTED_CODEC_CONTAINER[0]);
 511
 512         for (int i = 0; i < tableCount; i++)
 513         {
 514                 if (audioCodec == _SUPPORTED_CODEC_CONTAINER[i].audioCodec && videoCodec == _SUPPORTED_CODEC_CONTAINER[i].videoCodec && container == _SUPPORTED_CODEC_CONTAINER[i].container)
 515                 {
 516                         supported = true;
 517                         break;
 518                 }
 519         }
 520         return supported;
 521 }
 522
 523 result
 524 _RecorderUtil::PrepareFile(const Tizen::Base::String& path, bool overwrite)
 525 {
 526         result r = E_SUCCESS;
 527
 528         if (File::IsFileExist(path))
 529         {
 530                 if (overwrite)
 531                 {
 532                         r = File::Remove(path);
 533                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder remove existing file failed. path:%ls", GetErrorMessage(r), path.GetPointer());
 534                 }
 535                 else
 536                 {
 537                         r = E_FILE_ALREADY_EXIST;
 538                         SysLogException(NID_MEDIA, r, "[E_FILE_ALREADY_EXIST] The file already exists and overwrite is false. path:%ls", path.GetPointer());
 539                         goto CATCH;
 540                 }
 541         }
 542         else
 543         {
 544                 File file;
 545                 r = file.Construct(path, L"w");
 546                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] The file path is not available. path:%ls", path.GetPointer());
 547                 r = File::Remove(path);
 548                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder remove temp file failed. path:%ls", GetErrorMessage(r), path.GetPointer());
 549         }
 550
 551         return r;
 552
 553 CATCH:
 554         return r;
 555 }
 556
 557 }}// Tizen::Media