src/FMedia_VideoRecorderImpl.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_VideoRecorderImpl.cpp
  20 * @brief                This is the implementation file for the %_VideoRecorderImpl class.
  21 */
  22
  23 #include <unique_ptr.h>
  24 #include <camera.h>
  25 #include <recorder.h>
  26 #include <FBaseInteger.h>
  27 #include <FBaseSysLog.h>
  28 #include <FBase_StringConverter.h>
  29 #include <FMediaVideoRecorder.h>
  30 #include "FMedia_CameraImpl.h"
  31 #include "FMedia_CapabilityImpl.h"
  32 #include "FMedia_CameraCoordinator.h"
  33 #include "FMedia_VideoRecorderImpl.h"
  34 #include "FMedia_VideoRecorderEvent.h"
  35 #include "FMedia_VideoSourceAdapter.h"
  36 #include "FMedia_CameraUtil.h"
  37 #include "FMedia_RecorderUtil.h"
  38 #include "FMedia_RecorderCapability.h"
  39 #include "FMedia_CamPtrUtil.h"
  40 #include "FMedia_AudioStreamCoordinator.h"
  41 #include "FMedia_RecorderRef.h"
  42
  43 //#define _VIDEO_RECORDER_ROTATION_
  44
  45 using namespace Tizen::Base;
  46 using namespace Tizen::Base::Collection;
  47 using namespace Tizen::Graphics;
  48
  49 namespace Tizen { namespace Media
  50 {
  51 static const int _RELOAD_FORMAT = 0x1;
  52 static const int _RELOAD_QUALITY = 0x1 << 1;
  53 static const int _RELOAD_MAX_TIME = 0x1 << 2;
  54 static const int _RELOAD_RECORD_RESOLUTION = 0x1 << 3;
  55 static const int _RELOAD_FILE_PATH = 0x1 << 4;
  56 static const int _RELOAD_INIT = 0x1 << 5;
  57 static const int _RELOAD_CALLBACK = 0x1 << 6;
  58 static const int _RELOAD_MUTE = 0x1 << 7;
  59 static const int _RELOAD_ROTATION = 0x1 << 8;
  60
  61 typedef int (*_VideoRecorderFunc)(_RecorderHandle mmHandle);
  62
  63 typedef struct
  64 {
  65         recorder_state_e preState;
  66         recorder_state_e postState;
  67         _RecorderStateChangeReason reason;
  68         _VideoRecorderFunc pFunc;
  69         RecorderState state;
  70 }_VideoCommandStateTable;
  71
  72 static const _VideoCommandStateTable _VIDEO_COMMAND_STATE[] =
  73 {
  74         {::RECORDER_STATE_CREATED, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, recorder_prepare, (RecorderState)-1 },
  75         {::RECORDER_STATE_READY, ::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL, recorder_start, RECORDER_STATE_STARTING },
  76         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_PAUSED, _RECORDER_STATE_REASON_NORMAL, recorder_pause, RECORDER_STATE_PAUSING },
  77         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, recorder_commit, RECORDER_STATE_STOPPING },
  78         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_CANCEL, recorder_cancel, RECORDER_STATE_STOPPING },
  79         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_SIZE_REACHED, recorder_commit, RECORDER_STATE_STOPPING },
  80         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_TIME_REACHED, recorder_commit, RECORDER_STATE_STOPPING },
  81         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_OUT_OF_STORAGE, recorder_commit, RECORDER_STATE_STOPPING },
  82         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL, recorder_start, RECORDER_STATE_STARTING },
  83         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, recorder_commit, RECORDER_STATE_STOPPING },
  84         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_CANCEL, recorder_cancel, RECORDER_STATE_STOPPING },
  85         {::RECORDER_STATE_READY, ::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL, recorder_unprepare, RECORDER_STATE_CLOSING },
  86 };
  87
  88 typedef struct
  89 {
  90         recorder_state_e prevState;
  91         recorder_state_e postState;
  92         _RecorderStateChangeReason reason;
  93         _RecorderEventType event;
  94         result r;
  95 }_VideoCallbackEventTable;
  96
  97 static const _VideoCallbackEventTable _VIDEO_CALLBACK_EVENT[] =
  98 {
  99         {::RECORDER_STATE_READY, ::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_RECORDING_STARTED, E_SUCCESS },
 100         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_PAUSED, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_PAUSED, E_SUCCESS },
 101         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_STOPPED, E_SUCCESS },
 102         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_CANCEL, _RECORDER_EVENT_CANCELED, E_SUCCESS },
 103         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_SIZE_REACHED, _RECORDER_EVENT_ENDOF_FILESIZE, E_SUCCESS },
 104         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_TIME_REACHED, _RECORDER_EVENT_ENDOF_RECTIME, E_SUCCESS },
 105         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_OUT_OF_STORAGE, _RECORDER_EVENT_STOPPED, E_SUCCESS },
 106         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_RECORDING_STARTED, E_SUCCESS },
 107         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_STOPPED, E_SUCCESS },
 108 //      {::RECORDER_STATE_READY, ::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_CLOSED, E_SUCCESS },
 109 };
 110
 111 typedef struct
 112 {
 113         const wchar_t* pCodecName;
 114         CodecType audioCodec;
 115         CodecType videoCodec;
 116         MediaContainerType container;
 117 }_CodecValTable;
 118
 119 static const _CodecValTable _CODEC_VAL_TABLE[] =
 120 {
 121         {L"VIDEO_CODEC_NONE",           CODEC_NONE,     CODEC_NONE,     MEDIA_CONTAINER_NONE},
 122         {L"VIDEO_CODEC_H263",           CODEC_AMR_NB, CODEC_H263,       MEDIA_CONTAINER_3GP},           //TODO bug reported
 123 //      {L"VIDEO_CODEC_H263",           CODEC_AAC,      CODEC_H263,     MEDIA_CONTAINER_3GP},
 124         {L"VIDEO_CODEC_MPEG4SP",        CODEC_AAC,      CODEC_MPEG4,    MEDIA_CONTAINER_MP4},
 125         {L"VIDEO_CODEC_H264",           CODEC_AAC,      CODEC_H264,     MEDIA_CONTAINER_MP4},
 126         {null,                                          CODEC_NONE,     CODEC_NONE,     MEDIA_CONTAINER_NONE}
 127 };
 128
 129 typedef struct
 130 {
 131         recorder_state_e prevState;
 132         recorder_state_e postState;
 133         result ex;
 134         RecorderErrorReason error;
 135 }_VideoExceptionToErrorTable;
 136
 137 static const _VideoExceptionToErrorTable _VIDEO_EXCEPTION_TO_ERROR[] =
 138 {
 139         {::RECORDER_STATE_READY, ::RECORDER_STATE_RECORDING, E_STORAGE_FULL, RECORDER_ERROR_OUT_OF_STORAGE},
 140         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_RECORDING, E_STORAGE_FULL, RECORDER_ERROR_OUT_OF_STORAGE},
 141 };
 142
 143 _VideoRecorderImpl::_VideoRecorderImpl(void)
 144         : __pCoordinator(null)
 145         , __pRecorderRef(null)
 146         , __pVideoRecorderEvent(null)
 147         , __pVideoRecorderEventListener(null)
 148         , __pVideoSourceAdapter(null)
 149         , __isConstructed(false)
 150         , __state(RECORDER_STATE_INITIALIZED)
 151         , __recTime(-1)
 152         , __recSize(-1)
 153         , __maxTime(DEFAULT_VIDEORECORDING_TIME)
 154         , __format(VIDEORECORDING_FORMAT_DEFAULT)
 155         , __audioCodec(CODEC_AAC)               // TODO
 156         , __videoCodec(CODEC_MPEG4)
 157         , __container(MEDIA_CONTAINER_MP4)
 158         , __mode(VIDEORECORDER_MODE_VIDEO_WITH_AUDIO)
 159         , __quality(RECORDING_QUALITY_MEDIUM)
 160         , __mute(false)
 161         , __rotation(RECORDING_ROTATION_NONE)
 162         , __handle(MM_INVALID_HANDLE)
 163         , __deviceType(_RECORDER_DEVICE_NONE)
 164         , __mmSourceFormat(CAMERA_PIXEL_FORMAT_INVALID)
 165         , __stateChangeReason(_RECORDER_STATE_REASON_NORMAL)
 166         , __pAudioStreamCoordinator(null)
 167         , __audioStreamTimeDuration(0)
 168         , __audioStreamCallback(false)
 169 {
 170         __recordingResolution.width = 0;
 171         __recordingResolution.height = 0;
 172
 173 }
 174
 175 _VideoRecorderImpl::~_VideoRecorderImpl(void)
 176 {
 177         if (__handle != MM_INVALID_HANDLE)
 178         {
 179                 int err = ::RECORDER_ERROR_NONE;
 180                 err = recorder_unset_state_changed_cb(__handle);
 181                 err = recorder_unset_audio_stream_cb(__handle);
 182                 err = recorder_unset_recording_limit_reached_cb(__handle);
 183                 err = recorder_unset_error_cb(__handle);
 184                 err = recorder_unset_recording_status_cb(__handle);
 185                 err = recorder_unset_interrupted_cb(__handle);
 186                 __handle = MM_INVALID_HANDLE;
 187         }
 188         if (__pCoordinator != null)
 189         {
 190                 if (__pVideoSourceAdapter.get() != null)
 191                 {
 192                         if (__pVideoSourceAdapter->GetUserPreviewFormat() != __pCoordinator->GetCameraSourceFormat())
 193                         {
 194                                 __pCoordinator->ChangeFormat(_CAMERA_MODE_IMAGE, true, __pVideoSourceAdapter->GetUserPreviewFormat());
 195                         }
 196                 }
 197                 __pCoordinator->DestroyVideoRecorder();
 198                 __pCoordinator->RemoveCameraCoordinatorListener(*this);
 199
 200                 _CameraCoordinator::Release(__deviceType);
 201         }
 202
 203         SysLog(NID_MEDIA, "video recorder Destroyed");
 204 }
 205
 206 result
 207 _VideoRecorderImpl::Construct(IVideoRecorderEventListener& listener, const Camera& camera)
 208 {
 209         result r = E_SUCCESS;
 210         Tizen::Media::Camera* pCamera = null;
 211         Tizen::Media::_CameraImpl* pCamImpl = null;
 212         int err = MM_SUCCESS;
 213         int streamFps = 0;
 214         _CapabilityImpl* pCapabilityImpl = null;
 215
 216         SysTryReturn(NID_MEDIA, !__isConstructed, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state. A device is already constructed.");
 217         SysLog(NID_MEDIA, "video recorder construct");
 218
 219         pCamera = const_cast<Tizen::Media::Camera*>(&camera);
 220         pCamImpl = _CameraImpl::GetInstance(pCamera);
 221         __deviceType = (pCamImpl->GetSelection() == CAMERA_PRIMARY ? _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA
 222                 : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA);
 223
 224         // Register this object to _RecorderRef
 225         __pRecorderRef.reset(new (std::nothrow) _RecorderRef());
 226         SysTryCatch(NID_MEDIA, __pRecorderRef.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 227
 228         r = __pRecorderRef->Construct(*this, __deviceType);
 229         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 230
 231         // Source Adapter
 232         __pVideoSourceAdapter.reset(new (std::nothrow) _VideoSourceAdapter(*pCamImpl));
 233         SysTryCatch(NID_MEDIA, __pVideoSourceAdapter.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 234
 235         // Create Event
 236         __pVideoRecorderEvent.reset(new (std::nothrow) _VideoRecorderEvent());
 237         SysTryCatch(NID_MEDIA, __pVideoRecorderEvent.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 238
 239         r = __pVideoRecorderEvent->Construct(*this);
 240         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 241
 242         r = __pVideoRecorderEvent->AddListener(listener);
 243         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 244         __pVideoRecorderEventListener = &listener;
 245
 246         // Create audio stream coordinator
 247         __pAudioStreamCoordinator.reset(new (std::nothrow) _AudioStreamCoordinator());
 248         SysTryCatch(NID_MEDIA, __pAudioStreamCoordinator.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 249
 250         r = __pAudioStreamCoordinator->Construct();
 251         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 252
 253         __pCoordinator = _CameraCoordinator::AddInstance(__deviceType);
 254         r = GetLastResult();
 255         SysTryCatch(NID_MEDIA, __pCoordinator != null, , r, "[E_OBJ_NOT_FOUND] _CameraCoordinator instance is not available.");
 256
 257         r = __pCoordinator->AddCameraCoordinatorListener(*this);
 258         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 259
 260         //If the reload flag is true, the __handle will be updated in the OnCameraCoordinatorModeChangePrepared(), otherwise the __handle should be updated manually.
 261         r = __pCoordinator->CreateVideoRecorder();              // Do not reload. The __mmSourceFormat is not set yet.
 262         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] CreateVideoRecorder  failed.", GetErrorMessage(r));
 263
 264         __handle = __pCoordinator->GetRecorderHandle();
 265
 266         // Get the capability
 267         pCapabilityImpl = _CapabilityImpl::GetInstance();
 268         SysTryCatch(NID_MEDIA, pCapabilityImpl != null, r= E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. Capability is not obtained.");
 269
 270         // Get the audio stream fps
 271         r = pCapabilityImpl->GetValue(VIDEORECORDER_DEVICE_FPS, streamFps);
 272         SysTryCatch(NID_MEDIA, r == E_SUCCESS && streamFps > 0, , r, "[%s] Propagating. fps:%d", GetErrorMessage(r), streamFps);
 273         __audioStreamTimeDuration = (1000/streamFps); //Time duration in milisec
 274
 275         err = recorder_set_state_changed_cb(__handle, StateChangedCb, this);
 276         r = ConvertResult(err);
 277         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set message callback failed.", GetErrorMessage(r));
 278
 279         err = recorder_set_recording_limit_reached_cb(__handle, LimitReachedCb, this);
 280         r = ConvertResult(err);
 281         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set limit reached callback failed.", GetErrorMessage(r));
 282
 283         err = recorder_set_recording_status_cb(__handle, RecordingStatusCb, this);
 284         r = ConvertResult(err);
 285         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set recording status callback failed.", GetErrorMessage(r));
 286
 287         err = recorder_set_error_cb(__handle, ErrorCb, this);
 288         r = ConvertResult(err);
 289         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set limit reached callback failed.", GetErrorMessage(r));
 290
 291         err = recorder_set_interrupted_cb(__handle, InterruptedCb, this);
 292         r = ConvertResult(err);
 293         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set limit reached callback failed.", GetErrorMessage(r));
 294
 295         r = LoadDefaultConfiguration(_RELOAD_RECORD_RESOLUTION);
 296         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 297
 298         SetState(RECORDER_STATE_INITIALIZED);
 299         __isConstructed = true;
 300
 301         return r;
 302
 303 CATCH:
 304         if (__handle)
 305         {
 306                 err = recorder_unset_state_changed_cb(__handle);
 307                 err = recorder_unset_recording_limit_reached_cb(__handle);
 308                 err = recorder_unset_error_cb(__handle);
 309                 err = recorder_unset_recording_status_cb(__handle);
 310                 err = recorder_unset_interrupted_cb(__handle);
 311                 __handle = MM_INVALID_HANDLE;
 312         }
 313
 314         if (__pCoordinator != null)
 315         {
 316                 __pCoordinator->RemoveCameraCoordinatorListener(*this);
 317                 _CameraCoordinator::Release(__deviceType);
 318                 __pCoordinator = null;
 319         }
 320
 321         __pRecorderRef.reset(null);
 322         __pVideoSourceAdapter.reset(null);
 323         __pVideoRecorderEvent.reset(null);
 324         __pAudioStreamCoordinator.reset(null);
 325
 326         return r;
 327 }
 328
 329 result
 330 _VideoRecorderImpl::AddAudioStreamFilter(IAudioStreamFilter& filter)
 331 {
 332         result r = E_SUCCESS;
 333
 334         r = __pAudioStreamCoordinator->AddAudioStreamFilter(filter);
 335         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 336
 337         if (__audioStreamCallback != true)
 338         {
 339                 int err = ::RECORDER_ERROR_NONE;
 340                 err = recorder_set_audio_stream_cb(__handle, AudioStreamCb, this);
 341                 r = ConvertResult(err);
 342                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] audio recorder set audio stream callback failed.", GetErrorMessage(r));
 343                 __audioStreamCallback  = true;
 344         }
 345
 346         return r;
 347 }
 348
 349 result
 350 _VideoRecorderImpl::RemoveAudioStreamFilter(IAudioStreamFilter& filter)
 351 {
 352         result r = E_SUCCESS;
 353
 354         r = __pAudioStreamCoordinator->RemoveAudioStreamFilter(filter);
 355         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 356
 357         if (__pAudioStreamCoordinator->GetFilterListCount() == 0)
 358         {
 359                 int err = ::RECORDER_ERROR_NONE;
 360                 err = recorder_unset_audio_stream_cb(__handle);
 361                 r = ConvertResult(err);
 362                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] audio recorder unset recording status callback failed.", GetErrorMessage(r));
 363                 __audioStreamCallback = false;
 364         }
 365
 366         return r;
 367 }
 368
 369 result
 370 _VideoRecorderImpl::CreateVideoFile(const Tizen::Base::String& mediaLocalPath, bool overwrite)
 371 {
 372         result r = E_SUCCESS;
 373         RecorderState state = RECORDER_STATE_ERROR;
 374         int err = MM_SUCCESS;
 375         SysLog(NID_MEDIA, "video recorder create video file");
 376
 377         state = GetState();
 378         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED || state == RECORDER_STATE_CLOSED,
 379                                 E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state(%d).", state);
 380
 381         std::unique_ptr<char[]> pFileName (_StringConverter::CopyToCharArrayN(mediaLocalPath));
 382         SysTryCatch(NID_MEDIA, pFileName.get() != null, r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(mediaLocalPath) is used.  File name is null.");
 383         SysSecureLog(NID_MEDIA, "File Path : %s\n, overwrite:%d", pFileName.get(), overwrite);
 384
 385         r = _RecorderUtil::PrepareFile(mediaLocalPath, overwrite);
 386         SysSecureTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder prepare file failed. mediaLocalPath:%s, overwirte:%d",
 387                            GetErrorMessage(r), pFileName.get(), overwrite);
 388
 389         err = recorder_set_filename(__handle, pFileName.get());
 390         r = ConvertResult(err);
 391         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 392
 393         SetState(RECORDER_STATE_OPENED);
 394
 395         // re-configuration for new recorder handle
 396         r = ReloadConfiguration(_RELOAD_FORMAT | _RELOAD_QUALITY | _RELOAD_MAX_TIME | _RELOAD_INIT | _RELOAD_ROTATION);
 397         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder reload configuration failed", GetErrorMessage(r));
 398
 399         __filePath = mediaLocalPath;
 400         return r;
 401
 402 CATCH:
 403         SetState(state);
 404         return r;
 405 }
 406
 407 result
 408 _VideoRecorderImpl::Close(void)
 409 {
 410         result r = E_SUCCESS;
 411         RecorderState state = RECORDER_STATE_ERROR;
 412         SysLog(NID_MEDIA, "video recorder close");
 413
 414         state = GetState();
 415         SysTryReturn(
 416                 NID_MEDIA, state == RECORDER_STATE_OPENED || state == RECORDER_STATE_STOPPED || state == RECORDER_STATE_STOPPING
 417                 || state == RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_ERROR
 418                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d", state);
 419
 420         // Just send closed event
 421         r = GetEvent()->SendEvent(_RECORDER_EVENT_CLOSED, RECORDER_ERROR_NONE, E_SUCCESS);
 422         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 423         SetStateChangeReason(_RECORDER_STATE_REASON_NORMAL);
 424
 425         return r;
 426
 427 CATCH:
 428         return r;
 429 }
 430
 431 result
 432 _VideoRecorderImpl::Record(void)
 433 {
 434         result r = E_SUCCESS;
 435         RecorderState state = RECORDER_STATE_ERROR;
 436         recorder_state_e mmState = ::RECORDER_STATE_NONE;
 437         SysLog(NID_MEDIA, "video recorder record");
 438
 439         state = GetState();
 440         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_OPENED || state == RECORDER_STATE_PAUSED
 441                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d",     state);
 442
 443         SysTryReturn(NID_MEDIA, __pVideoSourceAdapter.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The source is deleted.");
 444         if (__pVideoSourceAdapter->HasRecordingResolutionRestriction())
 445         {
 446                 SysTryReturn(NID_MEDIA, __recordingResolution == __pVideoSourceAdapter->GetSourceResolution()
 447                         , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  __recordingResolution(%d,%d) is not same VideoSourceResolution.", __recordingResolution.width, __recordingResolution.height);
 448         }
 449
 450         std::unique_ptr<IListT<camera_pixel_format_e>, _ListPtrUtil::Remover> pSupportedMmSourceFormatList (__pVideoSourceAdapter->GetSupportedRecordingFormatListN(), _ListPtrUtil::remover);
 451         SysTryCatch(NID_MEDIA, pSupportedMmSourceFormatList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Source's supported recording format is empty");
 452
 453         // In case of the preview format is not supported to the Video Recorder, regardless of the current mode,
 454         // the recorder should be reset and the preview format should be changed for recording supported one.
 455         if ( !pSupportedMmSourceFormatList->Contains(__pCoordinator->GetCameraSourceFormat()))
 456         {
 457                 SysLog(NID_MEDIA, "Current coordinaotr's mm format(%d) is not supported to record.", __pCoordinator->GetCameraSourceFormat());
 458                 r = pSupportedMmSourceFormatList->GetAt(0, __mmSourceFormat);
 459                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Camera mode change failed.", GetErrorMessage(r));
 460
 461                 // If the preview data format is changed, the properties should be set again.
 462                 r = __pCoordinator->ChangeFormat(_CAMERA_MODE_VIDEO, true, __mmSourceFormat);
 463                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder Mode change failed.", GetErrorMessage(r));
 464         }
 465         else if ( __pCoordinator->GetMode() != _CAMERA_MODE_VIDEO )
 466         {
 467                 SysLog(NID_MEDIA, "Current Preview mm format format is default mm format format (%d). ", __pCoordinator->GetCameraSourceFormat());
 468
 469                 __mmSourceFormat = __pCoordinator->GetCameraSourceFormat();
 470
 471                 r = ReloadConfiguration(_RELOAD_FORMAT | _RELOAD_QUALITY | _RELOAD_MAX_TIME | _RELOAD_FILE_PATH | _RELOAD_CALLBACK | _RELOAD_MUTE | _RELOAD_ROTATION);
 472                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
 473         }
 474
 475         mmState = GetMmState();
 476         switch (mmState)
 477         {
 478         case ::RECORDER_STATE_CREATED:
 479                 r = ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL);
 480                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder init failed.", GetErrorMessage(r));
 481
 482                 r = __pCoordinator->StartRecord();
 483                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder start failed.", GetErrorMessage(r));
 484                 SetStateChangeReason(_RECORDER_STATE_REASON_NORMAL);
 485                 SetState(RECORDER_STATE_STARTING);
 486                 break;
 487
 488         case ::RECORDER_STATE_READY:
 489                 r = __pCoordinator->StartRecord();
 490                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder start failed.", GetErrorMessage(r));
 491                 SetStateChangeReason(_RECORDER_STATE_REASON_NORMAL);
 492                 SetState(RECORDER_STATE_STARTING);
 493                 break;
 494
 495         case ::RECORDER_STATE_PAUSED:
 496                 r = __pCoordinator->StartRecord();
 497                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder resume failed.", GetErrorMessage(r));
 498                 SetStateChangeReason(_RECORDER_STATE_REASON_NORMAL);
 499                 SetState(RECORDER_STATE_STARTING);
 500                 break;
 501
 502         default:
 503                 break;
 504         }
 505
 506
 507 CATCH:
 508         return CheckExceptionToError(mmState, ::RECORDER_STATE_RECORDING, r);
 509 }
 510
 511 result
 512 _VideoRecorderImpl::Stop(void)
 513 {
 514         result r = E_SUCCESS;
 515         RecorderState state = RECORDER_STATE_ERROR;
 516         SysLog(NID_MEDIA, "Enter.");
 517
 518         state = GetState();
 519         SysTryReturn(
 520                 NID_MEDIA, state == RECORDER_STATE_RECORDING || state == RECORDER_STATE_PAUSING || state == RECORDER_STATE_PAUSED
 521                 || state == RECORDER_STATE_STARTING
 522                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d",
 523                 state);
 524
 525         r = ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL);
 526         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder record stop failed.", GetErrorMessage(r));
 527         return r;
 528
 529 CATCH:
 530         return r;
 531 }
 532
 533 result
 534 _VideoRecorderImpl::Pause(void)
 535 {
 536         result r = E_SUCCESS;
 537         RecorderState state = RECORDER_STATE_ERROR;
 538         SysLog(NID_MEDIA, "Enter.");
 539
 540         state = GetState();
 541         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_RECORDING, E_INVALID_STATE, E_INVALID_STATE,
 542                                 "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d",
 543                                 state);
 544
 545         r = ChangeStateTo(::RECORDER_STATE_PAUSED, _RECORDER_STATE_REASON_NORMAL);
 546         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder pause failed.", GetErrorMessage(r));
 547
 548         return r;
 549
 550 CATCH:
 551         return r;
 552 }
 553
 554 result
 555 _VideoRecorderImpl::Cancel(void)
 556 {
 557         result r = E_SUCCESS;
 558         RecorderState state = RECORDER_STATE_ERROR;
 559         SysLog(NID_MEDIA, "Enter.");
 560
 561         state = GetState();
 562         SysTryReturn(
 563                 NID_MEDIA, state == RECORDER_STATE_RECORDING || state == RECORDER_STATE_PAUSING || state == RECORDER_STATE_PAUSED
 564                 || state == RECORDER_STATE_STARTING, E_INVALID_STATE, E_INVALID_STATE,
 565                 "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d", state);
 566
 567         r = ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_CANCEL);
 568         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder cancel failed.", GetErrorMessage(r));
 569
 570         return r;
 571
 572 CATCH:
 573         return r;
 574 }
 575
 576 RecorderState
 577 _VideoRecorderImpl::GetState(void) const
 578 {
 579         return __state;
 580 }
 581
 582 long
 583 _VideoRecorderImpl::GetRecordingTime(void) const
 584 {
 585         return __recTime;
 586 }
 587
 588 long
 589 _VideoRecorderImpl::GetRecordingSize(void) const
 590 {
 591         return __recSize;
 592 }
 593
 594 result
 595 _VideoRecorderImpl::SetMaxRecordingTime(long msTime)
 596 {
 597         result r = E_SUCCESS;
 598         RecorderState state = RECORDER_STATE_ERROR;
 599         SysLog(NID_MEDIA, "Enter. msTime:%d", msTime);
 600
 601         state = GetState();
 602         SysTryReturn(
 603                 NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 604                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
 605                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d.",
 606                 state);
 607
 608         SysTryReturn(NID_MEDIA, msTime > 0, E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] msTime is out of range. msTime:%d must be greater than 0.",
 609                                 msTime);
 610
 611         r = SetMaxRecordingTimeAttr(msTime);
 612         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder set max recording time failed. msTime:%ls", GetErrorMessage(r), msTime);
 613         // For reload and Get the exact value
 614         __maxTime = msTime;
 615
 616         return r;
 617
 618 CATCH:
 619         return r;
 620 }
 621
 622 long
 623 _VideoRecorderImpl::GetMaxRecordingTime(void) const
 624 {
 625         return __maxTime;
 626 }
 627
 628 result
 629 _VideoRecorderImpl::SetCodec(const Tizen::Base::String& codec)
 630 {
 631         result r = E_SUCCESS;
 632         CodecType audioCodec = CODEC_NONE;
 633         CodecType videoCodec = CODEC_NONE;
 634         MediaContainerType container = MEDIA_CONTAINER_NONE;
 635         SysLog(NID_MEDIA, "Enter. codec:%ls", codec.GetPointer());
 636         SysTryReturn(NID_MEDIA, !codec.IsEmpty(), E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC, "[E_UNSUPPORTED_CODEC] The codec is empty.\n");
 637
 638         RecorderState state = GetState();
 639         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 640                                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE
 641                                 || state == RECORDER_STATE_CLOSED
 642                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d", state);
 643
 644         std::unique_ptr<IList, _ListPtrUtil::Remover> pList (GetSupportedCodecListN(), _ListPtrUtil::remover);
 645         SysTryCatch(NID_MEDIA, pList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
 646         SysTryCatch(NID_MEDIA, pList->Contains(codec), r = E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC, "[E_UNSUPPORTED_CODEC]. This codec(%ls) is not supported in the device.\n", codec.GetPointer());
 647
 648         GetMediaType(codec, audioCodec, videoCodec, container);
 649         SysTryCatch(NID_MEDIA, audioCodec != CODEC_NONE && videoCodec != CODEC_NONE, r = E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC
 650                 , "[E_UNSUPPORTED_CODEC]. This codec(%ls) is not supported in the device.\n", codec.GetPointer());
 651
 652         r = SetFormatAttr(audioCodec, videoCodec, container);
 653         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] File format set  failed. audioCodec:0x%x videoCodec:0x%x  container:0x%x",
 654                                 GetErrorMessage(r), audioCodec, videoCodec, videoCodec);
 655         __audioCodec = audioCodec;
 656         __videoCodec = videoCodec;
 657         __container = container;
 658
 659         // Call the dependency function.
 660         r = ReloadConfiguration(_RELOAD_QUALITY);
 661         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder reload configuration.", GetErrorMessage(r));
 662
 663 CATCH:
 664         return r;
 665 }
 666
 667 Tizen::Base::String
 668 _VideoRecorderImpl::GetCodec(void) const
 669 {
 670         String codec;
 671         GetCodecString(__videoCodec, codec);
 672         return codec;
 673 }
 674
 675 Tizen::Base::Collection::IList*
 676 _VideoRecorderImpl::GetSupportedCodecListN(void) const
 677 {
 678         _CapabilityImpl *pCapImpl = null;
 679         result r = E_SUCCESS;
 680
 681         pCapImpl = _CapabilityImpl::GetInstance();
 682         SysTryReturn(NID_MEDIA, pCapImpl != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Get capability information failed.");
 683
 684         std::unique_ptr<ArrayList, _ListPtrUtil::Remover> pCodecList (new (std::nothrow) Tizen::Base::Collection::ArrayList(), _ListPtrUtil::remover);
 685         SysTryCatch(NID_MEDIA, pCodecList.get() !=null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 686
 687         r = pCodecList->Construct();
 688         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder get attribute failed.", GetErrorMessage(r));
 689
 690         r = pCapImpl->GetValueN(VIDEORECORDER_CODEC, *(pCodecList.get()));
 691         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Converted from '%s'.", GetErrorMessage(r));
 692         SysTryCatch(NID_MEDIA, pCodecList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
 693         SysTryCatch(NID_MEDIA, pCodecList->GetCount() > 0, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
 694
 695         return pCodecList.release();
 696
 697 CATCH:
 698         return null;
 699 }
 700
 701 result
 702 _VideoRecorderImpl::SetFormat(VideoRecordingFormat format)
 703 {
 704         result r = E_SUCCESS;
 705         RecorderState state = RECORDER_STATE_ERROR;
 706         CodecType audioCodec = CODEC_NONE;
 707         CodecType videoCodec = CODEC_NONE;
 708         MediaContainerType container = MEDIA_CONTAINER_NONE;
 709         SysLog(NID_MEDIA, "Enter. format:%d", format);
 710
 711         state = GetState();
 712         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 713                                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE
 714                                 || state == RECORDER_STATE_CLOSED
 715                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d.", state);
 716
 717         SysTryReturn(NID_MEDIA, format >= VIDEORECORDING_FORMAT_DEFAULT && format <= VIDEORECORDING_FORMAT_3GP
 718                            , E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] The format(%d) is not supported.\n",
 719                                 format);
 720
 721         GetMediaType(format, audioCodec, videoCodec, container);
 722         SysTryCatch(NID_MEDIA, audioCodec != CODEC_NONE && videoCodec != CODEC_NONE, r = E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC
 723                 , "[E_UNSUPPORTED_CODEC]. This format(%d) is not supported in the device.\n", format);
 724
 725         r = SetFormatAttr(audioCodec, videoCodec, container);
 726         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] File format set  failed. audioCodec:0x%x videoCodec:0x%x  container:0x%x",
 727                         GetErrorMessage(r), audioCodec, videoCodec, videoCodec);
 728
 729         __format = format;
 730         __audioCodec = audioCodec;
 731         __videoCodec = videoCodec;
 732         __container = container;
 733         // Call the dependency function.
 734         r = ReloadConfiguration(_RELOAD_QUALITY);
 735         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder reload configuration.", GetErrorMessage(r));
 736
 737         return r;
 738
 739 CATCH:
 740         return r;
 741 }
 742
 743 VideoRecordingFormat
 744 _VideoRecorderImpl::GetFormat(void) const
 745 {
 746         return __format;
 747 }
 748
 749 result
 750 _VideoRecorderImpl::SetFormat(CodecType audioCodec, CodecType videoCodec, MediaContainerType container)
 751 {
 752         result r = E_SUCCESS;
 753         RecorderState state = RECORDER_STATE_ERROR;
 754         bool supported = false;
 755         SysLog(NID_MEDIA, "Enter. audioCodec:0x%x, videoCodec:0x%x, container:0x%x", audioCodec, videoCodec, container);
 756
 757         state = GetState();
 758         SysTryReturn(
 759                 NID_MEDIA, state == RECORDER_STATE_INITIALIZED || state == RECORDER_STATE_OPENED || state ==
 760                 RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
 761                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d.",
 762                 state);
 763
 764         std::unique_ptr<ArrayListT<CodecType>, _ListPtrUtil::Remover> pAudioCodecListT (GetSupportedAudioCodecListN(), _ListPtrUtil::remover);
 765         SysTryReturn(NID_MEDIA, pAudioCodecListT.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
 766         SysTryReturn(NID_MEDIA, pAudioCodecListT->Contains(audioCodec) || audioCodec == CODEC_NONE, E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC,
 767                 "[E_UNSUPPORTED_CODEC]This AudioCodec(%d) is not supported in the device.\n", audioCodec);
 768
 769         std::unique_ptr<ArrayListT<CodecType>, _ListPtrUtil::Remover> pVideoCodecListT (GetSupportedVideoCodecListN(), _ListPtrUtil::remover);
 770         SysTryReturn(NID_MEDIA, pVideoCodecListT.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
 771         SysTryReturn(NID_MEDIA, pVideoCodecListT->Contains(videoCodec), E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC,
 772                 "[E_UNSUPPORTED_CODEC]This VideoCodec(%d) is not supported in the device.\n", videoCodec);
 773
 774         std::unique_ptr<ArrayListT<MediaContainerType>, _ListPtrUtil::Remover> pContainerCodecListT (GetSupportedContainerListN(), _ListPtrUtil::remover);
 775         SysTryReturn(NID_MEDIA, pContainerCodecListT.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
 776         SysTryReturn(NID_MEDIA, pContainerCodecListT->Contains(container), E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT,
 777                 "[E_UNSUPPORTED_FORMAT]This Container(%d) is not supported in the device.\n", container);
 778
 779         supported = _RecorderUtil::CheckFormat(audioCodec, videoCodec, container);
 780         SysTryCatch(NID_MEDIA, supported, r = E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT,
 781                            "[E_UNSUPPORTED_FORMAT] camcorder check foramt failed. audioCodec:0x%x, videoCodec:0x%x, container:0x%x",
 782                            audioCodec, videoCodec,
 783                            container);
 784
 785         r = SetFormatAttr(audioCodec, videoCodec, container);
 786         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] File format set  failed. audioCodec:0x%x videoCodec:0x%x  container:0x%x",
 787                                 GetErrorMessage(r), audioCodec, videoCodec, videoCodec);
 788
 789         __audioCodec = audioCodec;
 790         __videoCodec = videoCodec;
 791         __container = container;
 792
 793         // Call the dependency function.
 794         r = ReloadConfiguration(_RELOAD_QUALITY);
 795         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder reload configuration.", GetErrorMessage(r));
 796
 797 CATCH:
 798         return r;
 799 }
 800
 801 void
 802 _VideoRecorderImpl::GetFormat(CodecType& audioCodec, CodecType& videoCodec, MediaContainerType& container) const
 803 {
 804         audioCodec = __audioCodec;
 805         videoCodec = __videoCodec;
 806         container = __container;
 807 }
 808
 809 Tizen::Base::Collection::ArrayListT <CodecType>*
 810 _VideoRecorderImpl::GetSupportedAudioCodecListN(void) const
 811 {
 812         result r = E_SUCCESS;
 813         _ResultType itemType = _RESULT_INTEGER_LIST;
 814
 815         std::unique_ptr<IList, _ListPtrUtil::Remover> pIntegerList (_RecorderCapability::GetListN(_VROP_AUDIO_ENCODER, itemType), _ListPtrUtil::remover);
 816         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
 817         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
 818
 819         std::unique_ptr<ArrayListT<CodecType>, _ListPtrUtil::Remover> pAudioCodecList (new (std::nothrow) ArrayListT<CodecType>(), _ListPtrUtil::remover);
 820         SysTryReturn(NID_MEDIA, pAudioCodecList.get() != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 821
 822         r = pAudioCodecList->Construct();
 823         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 824
 825         for (int i = 0; i < pIntegerList->GetCount(); i++)
 826         {
 827                 Object* pObj = null;
 828                 Integer* pInteger = null;
 829                 pObj = pIntegerList->GetAt(i);
 830                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object instance is not available. %d item is not found.", i);
 831
 832                 pInteger = dynamic_cast<Integer*>(pObj);
 833                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's format is invalid.", i);
 834
 835                 r = pAudioCodecList->Add((CodecType)pInteger->ToInt());
 836                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 837                 SysLog(NID_MEDIA, "Pixel format : %d was added.", pInteger->ToInt());
 838         }
 839
 840         return pAudioCodecList.release();
 841
 842 CATCH:
 843         return null;
 844 }
 845
 846 Tizen::Base::Collection::ArrayListT<CodecType>*
 847 _VideoRecorderImpl::GetSupportedVideoCodecListN(void) const
 848 {
 849         result r = E_SUCCESS;
 850         _ResultType itemType = _RESULT_INTEGER_LIST;
 851
 852         std::unique_ptr<IList, _ListPtrUtil::Remover> pIntegerList (_RecorderCapability::GetListN(_VROP_VIDEO_ENCODER, itemType), _ListPtrUtil::remover);
 853         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
 854         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
 855
 856         std::unique_ptr<ArrayListT<CodecType>, _ListPtrUtil::Remover> pVideoCodecList (new (std::nothrow) ArrayListT<CodecType>(), _ListPtrUtil::remover);
 857         SysTryReturn(NID_MEDIA, pVideoCodecList.get() != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 858
 859         r = pVideoCodecList->Construct();
 860         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 861
 862         for (int i = 0; i < pIntegerList->GetCount(); i++)
 863         {
 864                 Object* pObj = null;
 865                 Integer* pInteger = null;
 866                 pObj = pIntegerList->GetAt(i);
 867                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object instance is not available. %d item is not found.", i);
 868
 869                 pInteger = dynamic_cast<Integer*>(pObj);
 870                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's format is invalid.", i);
 871
 872                 r = pVideoCodecList->Add((CodecType)pInteger->ToInt());
 873                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 874                 SysLog(NID_MEDIA, "Pixel format : %d was added.", pInteger->ToInt());
 875         }
 876
 877         return pVideoCodecList.release();
 878
 879 CATCH:
 880         return null;
 881 }
 882
 883
 884 Tizen::Base::Collection::ArrayListT<MediaContainerType>*
 885 _VideoRecorderImpl::GetSupportedContainerListN(void) const
 886 {
 887         result r = E_SUCCESS;
 888         _ResultType itemType = _RESULT_INTEGER_LIST;
 889
 890         std::unique_ptr<IList, _ListPtrUtil::Remover> pIntegerList (_RecorderCapability::GetListN(_VROP_FILE_FORMAT, itemType), _ListPtrUtil::remover);
 891         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
 892         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
 893
 894         std::unique_ptr<ArrayListT<MediaContainerType>, _ListPtrUtil::Remover> pContainerList (new (std::nothrow) ArrayListT<MediaContainerType>(), _ListPtrUtil::remover);
 895         SysTryReturn(NID_MEDIA, pContainerList.get() != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 896
 897         r = pContainerList->Construct();
 898         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 899
 900         for (int i = 0; i < pIntegerList->GetCount(); i++)
 901         {
 902                 Object* pObj = null;
 903                 Integer* pInteger = null;
 904                 pObj = pIntegerList->GetAt(i);
 905                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object instance is not available. %d item is not found.", i);
 906
 907                 pInteger = dynamic_cast<Integer*>(pObj);
 908                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's format is invalid.", i);
 909
 910                 r = pContainerList->Add((MediaContainerType)pInteger->ToInt());
 911                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 912                 SysLog(NID_MEDIA, "Pixel format : %d was added.", pInteger->ToInt());
 913         }
 914
 915         return pContainerList.release();
 916
 917 CATCH:
 918         return null;
 919 }
 920
 921
 922 result
 923 _VideoRecorderImpl::SetMode(VideoRecorderMode mode)
 924 {
 925         result r = E_SUCCESS;
 926         RecorderState state = RECORDER_STATE_ERROR;
 927
 928         SysLog(NID_MEDIA, "Enter. mode:%d", mode);
 929
 930         state = GetState();
 931         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 932                                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE
 933                                 || state == RECORDER_STATE_CLOSED
 934                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d.");
 935
 936         SysTryReturn(NID_MEDIA, mode >= VIDEORECORDER_MODE_VIDEO_WITH_AUDIO && mode <= VIDEORECORDER_MODE_VIDEO_ONLY
 937                            , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(mode) is used. mode=%d.", mode);
 938
 939         r = SetMute(mode == VIDEORECORDER_MODE_VIDEO_ONLY ? true : false);
 940         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. mode:%d", GetErrorMessage(r), mode);
 941
 942         __mode = mode;
 943
 944         return r;
 945 }
 946
 947 VideoRecorderMode
 948 _VideoRecorderImpl::GetMode(void) const
 949 {
 950         return __mode;
 951 }
 952
 953 result
 954 _VideoRecorderImpl::SetQuality(RecordingQuality quality)
 955 {
 956         result r = E_SUCCESS;
 957         RecorderState state = RECORDER_STATE_ERROR;
 958         CodecType audioCodec = CODEC_NONE;
 959         CodecType videoCodec = CODEC_NONE;
 960         MediaContainerType container = MEDIA_CONTAINER_NONE;
 961         SysLog(NID_MEDIA, "Enter. quality:%d", quality);
 962
 963         state = GetState();
 964         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 965                                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
 966                            , E_INVALID_STATE, r, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d.", state);
 967
 968         SysTryReturn(NID_MEDIA, (quality >= RECORDING_QUALITY_LOW && quality <= RECORDING_QUALITY_HIGH)
 969                            , E_INVALID_ARG, r, "[E_INVALID_ARG] Invalid argument(quality) is used. The quality=%d.", quality);
 970
 971         GetFormat(audioCodec, videoCodec, container);
 972
 973         r = SetQualityAttr(quality, audioCodec, videoCodec);
 974         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] set quality failed. quality:%d", GetErrorMessage(r), quality);
 975         __quality = quality;
 976
 977         return r;
 978 CATCH:
 979         return r;
 980 }
 981
 982 RecordingQuality
 983 _VideoRecorderImpl::GetQuality(void) const
 984 {
 985         return __quality;
 986 }
 987
 988 result
 989 _VideoRecorderImpl::SetRecordingResolution(const Tizen::Graphics::Dimension& resolution)
 990 {
 991         result r = E_SUCCESS;
 992         RecorderState state = RECORDER_STATE_ERROR;
 993         SysLog(NID_MEDIA, "Enter. resolution(%d,%d)", resolution.width, resolution.height);
 994
 995         state = GetState();
 996         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 997                                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE
 998                                 || state == RECORDER_STATE_CLOSED
 999                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d.", state);
1000
1001         SysTryReturn(NID_MEDIA, resolution.width >= 0 && resolution.height >= 0
1002                            , E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] resolution is out of range. The resolution(%d,%d) must be greater than (0,0).",
1003                                 resolution.width,
1004                                 resolution.height);
1005
1006         std::unique_ptr<IList, _ListPtrUtil::Remover> pList (GetSupportedRecordingResolutionListN(), _ListPtrUtil::remover);
1007         SysTryReturn(NID_MEDIA, pList.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
1008         SysTryReturn(NID_MEDIA, pList->Contains(resolution), E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE]. resolution is out of range. This resolution(%d,%d) is not supported in the device.\n", resolution.width, resolution.height);
1009
1010         SysTryReturn(NID_MEDIA, __pVideoSourceAdapter.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The source is deleted.");
1011         if ( __pVideoSourceAdapter->HasRecordingResolutionRestriction())
1012         {
1013                 Dimension sourceResolution = __pVideoSourceAdapter->GetSourceResolution();
1014                 SysTryReturn(NID_MEDIA, sourceResolution == resolution, E_SYSTEM, E_SYSTEM,
1015                         "[E_SYSTEM] A system error has been occurred.  The source resolution(%d,%d) should be same as the recording resolution(%d,%d).", sourceResolution.width, sourceResolution.height, resolution.width, resolution.height);
1016         }
1017         else
1018         {
1019                 SysLog(NID_MEDIA, "There is no recording attribute... ");
1020         }
1021
1022         __recordingResolution = resolution;
1023
1024         return r;
1025 }
1026
1027 Tizen::Graphics::Dimension
1028 _VideoRecorderImpl::GetRecordingResolution(void) const
1029 {
1030         return __recordingResolution;
1031 }
1032
1033 Tizen::Base::Collection::IList*
1034 _VideoRecorderImpl::GetSupportedRecordingResolutionListN(void) const
1035 {
1036         SysTryReturn(NID_MEDIA, __pVideoSourceAdapter.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The source is deleted.");
1037
1038         return __pVideoSourceAdapter->GetSupportedRecordingResolutionListN();
1039 }
1040
1041 int
1042 _VideoRecorderImpl::GetSupportedMaxFrameRate(const Tizen::Graphics::Dimension& dim) const
1043 {
1044         result r = E_SUCCESS;
1045         int maxFrameRate = 0;
1046
1047         SysTryReturn(NID_MEDIA, __pVideoSourceAdapter.get() != null, 0, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The source is deleted.");
1048
1049         std::unique_ptr<IListT<int>, _ListPtrUtil::Remover> pListT (__pVideoSourceAdapter->GetSupportedFrameRateListN(dim), _ListPtrUtil::remover);
1050         SysTryCatch(NID_MEDIA, pListT.get() != null, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
1051         SysTryCatch(NID_MEDIA, pListT->GetCount() > 0, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
1052
1053         r = pListT->GetAt(pListT->GetCount()-1, maxFrameRate);
1054         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s]  propogated", GetErrorMessage(r));
1055
1056         return maxFrameRate;
1057
1058 CATCH:
1059         return 0;
1060 }
1061
1062 result
1063 _VideoRecorderImpl::SetMute(bool mute)
1064 {
1065         result r = E_SUCCESS;
1066         RecorderState state = RECORDER_STATE_ERROR;
1067         SysLog(NID_MEDIA, "Enter. mute:%d", mute);
1068
1069         state = GetState();
1070         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
1071                                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
1072                                 || state == RECORDER_STATE_STOPPED || state == RECORDER_STATE_PAUSED || state == RECORDER_STATE_RECORDING
1073                            , E_INVALID_STATE, r, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d.", state);
1074
1075
1076         r = SetMuteAttr(mute);
1077         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. mute:%d", GetErrorMessage(r), mute);
1078         __mute = mute;
1079         return r;
1080 }
1081
1082 bool
1083 _VideoRecorderImpl::IsMuted(void) const
1084 {
1085         return __mute;
1086 }
1087
1088 result
1089 _VideoRecorderImpl::SetRecordingRotation(RecordingRotation rotation)
1090 {
1091         result r = E_SUCCESS;
1092         RecorderState state = RECORDER_STATE_ERROR;
1093         SysLog(NID_MEDIA, "Enter. rotation:%d", rotation);
1094
1095         state = GetState();
1096         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
1097                                 || state == RECORDER_STATE_OPENED  || state == RECORDER_STATE_CLOSED
1098                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] VideoRecorder is in an invalid state:%d.", state);
1099
1100         SysTryReturn(NID_MEDIA, (rotation >= RECORDING_ROTATION_NONE&& rotation <= RECORDING_ROTATION_270)
1101                            , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(rotation) is used. The rotation=%d.", rotation);
1102
1103         r = SetRecordingOrientationAttr(rotation);
1104         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s]  propogated", GetErrorMessage(r));
1105
1106         __rotation = rotation;
1107         return r;
1108 }
1109
1110 RecordingRotation
1111 _VideoRecorderImpl::GetRecordingRotation(void) const
1112 {
1113         return __rotation;
1114 }
1115
1116 result
1117 _VideoRecorderImpl::SetFormatAttr(CodecType audioCodec, CodecType videoCodec, MediaContainerType container)
1118 {
1119         result r = E_SUCCESS;
1120         int err = ::RECORDER_ERROR_NONE;
1121
1122         recorder_audio_codec_e attrAudioCodec = ::RECORDER_AUDIO_CODEC_AAC;
1123         recorder_video_codec_e attrVideoCodec = ::RECORDER_VIDEO_CODEC_MPEG4;
1124         recorder_file_format_e attrFormat = ::RECORDER_FILE_FORMAT_MP4;
1125
1126         r = _RecorderUtil::GetMmAudioCodec(audioCodec, attrAudioCodec);
1127         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audio codec:0x%x", GetErrorMessage(r), audioCodec);
1128
1129         err = recorder_set_audio_encoder(__handle, attrAudioCodec);
1130         r = ConvertResult(err);
1131         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Audio codec set  failed. codec:0x%x", GetErrorMessage(r), audioCodec);
1132
1133         r = _RecorderUtil::GetMmVideoCodec(videoCodec, attrVideoCodec);
1134         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. video codec:0x%x", GetErrorMessage(r), videoCodec);
1135
1136         err = recorder_set_video_encoder(__handle, attrVideoCodec);
1137         r = ConvertResult(err);
1138         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Video codec set  failed. codec:0x%x", GetErrorMessage(r), videoCodec);
1139
1140         r = _RecorderUtil::GetMmFileFormat(container, attrFormat);
1141         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. container:0x%x", GetErrorMessage(r), container);
1142
1143         err = recorder_set_file_format(__handle, attrFormat);
1144         r = ConvertResult(err);
1145         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] File format set  failed. container:0x%x", GetErrorMessage(r), container);
1146
1147         return r;
1148 CATCH:
1149         return r;
1150 }
1151
1152 result
1153 _VideoRecorderImpl::SetQualityAttr(RecordingQuality quality,    CodecType audioCodec, CodecType videoCodec)
1154 {
1155         result r = E_SUCCESS;
1156         int err = ::RECORDER_ERROR_NONE;
1157         int attrVideoBitrate = 0;
1158         if (audioCodec != CODEC_NONE)
1159         {
1160                 int attrAudioSampleate = 0;
1161                 int attrAudioChannel = 0;
1162                 int attrAudioBitrate = 0;
1163
1164                 r = _RecorderUtil::GetMmAudioQuality(audioCodec, quality, attrAudioSampleate, attrAudioChannel, attrAudioBitrate);
1165                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audioCodec:%d, quality:%d", GetErrorMessage(r), audioCodec, quality);
1166
1167                 err = recorder_attr_set_audio_samplerate(__handle, attrAudioSampleate);
1168                 r = ConvertResult(err);
1169                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Sampling-rate set  failed. attr:%d", GetErrorMessage(r), attrAudioSampleate);
1170
1171                 err = recorder_attr_set_audio_channel(__handle, attrAudioChannel);
1172                 r = ConvertResult(err);
1173                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Channel set  failed. attr:%d", GetErrorMessage(r), attrAudioChannel);
1174
1175                 err = recorder_attr_set_audio_encoder_bitrate(__handle, attrAudioBitrate);
1176                 r = ConvertResult(err);
1177                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Bitrate set  failed. attr:%d", GetErrorMessage(r), attrAudioBitrate);
1178         }
1179         r = _RecorderUtil::GetMmVideoQuality(__recordingResolution, quality, attrVideoBitrate);
1180         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. videoCodec:%d, quality:%d", GetErrorMessage(r), videoCodec, quality);
1181
1182         err = recorder_attr_set_video_encoder_bitrate(__handle, attrVideoBitrate);
1183         r = ConvertResult(err);
1184         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Bitrate set  failed. attr:%d", GetErrorMessage(r), attrVideoBitrate);
1185
1186         return r;
1187 CATCH:
1188         return r;
1189 }
1190
1191 result
1192 _VideoRecorderImpl::SetMuteAttr(bool mute)
1193 {
1194         result r = E_SUCCESS;
1195         int err = ::RECORDER_ERROR_NONE;
1196
1197         err = recorder_attr_set_mute(__handle, mute);
1198         r = ConvertResult(err);
1199         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set mute failed", GetErrorMessage(r));
1200         return r;
1201 CATCH:
1202         return r;
1203 }
1204
1205 result
1206 _VideoRecorderImpl::SetMaxRecordingTimeAttr(long msTime)
1207 {
1208         result r = E_SUCCESS;
1209         int err = ::RECORDER_ERROR_NONE;
1210         int secTime = MEDIA_INVALID_VALUE;
1211         // msec max time is not possible to set
1212         secTime = msTime > 1000 ? ((msTime + 500) / 1000) : 1;
1213         err = recorder_attr_set_time_limit(__handle, secTime);
1214         r = ConvertResult(err);
1215         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder set attribute failed. msTime:%ls", GetErrorMessage(r), msTime);
1216         return r;
1217 CATCH:
1218         return r;
1219 }
1220
1221 result
1222 _VideoRecorderImpl::SetRecordingOrientationAttr(RecordingRotation rotation)
1223 {
1224         result r = E_SUCCESS;
1225         int err = MM_SUCCESS;
1226         recorder_rotation_e mmAttr = ::RECORDER_ROTATION_NONE;
1227         r = _RecorderUtil::GetMmRotation(rotation, mmAttr);
1228         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), rotation);
1229
1230 #if _VIDEO_RECORDER_ROTATION_
1231         err = recorder_attr_set_recording_orientation(__handle, mmAttr);
1232         r = ConvertResult(err);
1233         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Camcorder set attribute failed. rotation:%d", GetErrorMessage(r), rotation);
1234 #else
1235         err = recorder_attr_set_orientation_tag(__handle, mmAttr);
1236         r = ConvertResult(err);
1237         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Camcorder set attribute failed. rotation:%d", GetErrorMessage(r), rotation);
1238 #endif
1239
1240         return r;
1241 }
1242
1243 result
1244 _VideoRecorderImpl::SetCallback(void)
1245 {
1246         result r = E_SUCCESS;
1247         int err = ::RECORDER_ERROR_NONE;
1248
1249         err = recorder_set_state_changed_cb(__handle, StateChangedCb, this);
1250         r = ConvertResult(err);
1251         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set message callback failed.", GetErrorMessage(r));
1252
1253         err = recorder_set_recording_limit_reached_cb(__handle, LimitReachedCb, this);
1254         r = ConvertResult(err);
1255         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set limit reached callback failed.", GetErrorMessage(r));
1256
1257         err = recorder_set_recording_status_cb(__handle, RecordingStatusCb, this);
1258         r = ConvertResult(err);
1259         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set recording status callback failed.", GetErrorMessage(r));
1260
1261         err = recorder_set_error_cb(__handle, ErrorCb, this);
1262         r = ConvertResult(err);
1263         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set limit reached callback failed.", GetErrorMessage(r));
1264
1265         err = recorder_set_interrupted_cb(__handle, InterruptedCb, this);
1266         r = ConvertResult(err);
1267         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set limit reached callback failed.", GetErrorMessage(r));
1268
1269         return r;
1270 CATCH:
1271         return r;
1272 }
1273
1274 result
1275 _VideoRecorderImpl::OnCameraCoordinatorModeChangePrepared(_CameraMode mode)
1276 {
1277         result r = E_SUCCESS;
1278         SysLog(NID_MEDIA, "Mode:%d", mode);
1279         __handle = __pCoordinator->GetRecorderHandle(); // update to the new handle. All configuration shuld be updated with this handle after mode changing.
1280
1281         if ( mode == _CAMERA_MODE_VIDEO )
1282         {
1283                 r = ReloadConfiguration(_RELOAD_FORMAT | _RELOAD_QUALITY);
1284                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
1285         }
1286         return r;
1287
1288 CATCH:
1289         return r;
1290 }
1291
1292 result
1293 _VideoRecorderImpl::OnCameraCoordinatorModeChanged(_CameraMode mode)
1294 {
1295         result r = E_SUCCESS;
1296         SysLog(NID_MEDIA, "Mode:%d", mode);
1297
1298         if ( mode == _CAMERA_MODE_VIDEO )
1299         {
1300                 r = ReloadConfiguration(_RELOAD_MAX_TIME | _RELOAD_FILE_PATH | _RELOAD_CALLBACK | _RELOAD_MUTE | _RELOAD_ROTATION);
1301                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
1302         }
1303         return r;
1304
1305 CATCH:
1306         return r;
1307 }
1308
1309 result
1310 _VideoRecorderImpl::OnCameraCoordinatorOtherRemoved(void)
1311 {
1312         result r = E_SUCCESS;
1313         SysLog(NID_MEDIA, "Enter.");
1314         __pVideoSourceAdapter.reset(null);
1315         return r;
1316 }
1317
1318 void
1319 _VideoRecorderImpl::StateChangedCb(recorder_state_e previous, recorder_state_e current, bool byPolicy, void* pUserData)
1320 {
1321         result r = E_SUCCESS;
1322         _VideoRecorderImpl* pImpl = static_cast<_VideoRecorderImpl*>( pUserData);
1323         int tableTotalCount = 0;
1324         int i = 0;
1325         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _VideoRecorderImpl instance is not available. pImpl is null.");
1326         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1327         SysLog(NID_MEDIA, "State previous:%d, current:%d, byPolicy:%d", previous, current, byPolicy);
1328
1329         tableTotalCount = sizeof(_VIDEO_CALLBACK_EVENT) / sizeof(_VIDEO_CALLBACK_EVENT[0]);
1330
1331         for (i = 0; i < tableTotalCount; i++)
1332         {
1333                 if (previous == _VIDEO_CALLBACK_EVENT[i].prevState && current == _VIDEO_CALLBACK_EVENT[i].postState && pImpl->GetStateChangeReason() == _VIDEO_CALLBACK_EVENT[i].reason)                //for cancel
1334                 {
1335                         r = pImpl->GetEvent()->SendEvent(_VIDEO_CALLBACK_EVENT[i].event, RECORDER_ERROR_NONE, _VIDEO_CALLBACK_EVENT[i].r);
1336                         SysLog(NID_MEDIA, "VIDEO_CALLBACK_EVENT(%d) is sent by StateChangedCb", _VIDEO_CALLBACK_EVENT[i].event);
1337                         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1338                         break;
1339                 }
1340         }
1341 }
1342
1343 void
1344 _VideoRecorderImpl::RecordingStatusCb(unsigned long long elapsedTime, unsigned long long fileSize, void *pUserData)
1345 {
1346         _VideoRecorderImpl* pImpl = static_cast<_VideoRecorderImpl*>(pUserData);
1347         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _VideoRecorderImpl instance is not available. pImpl is null.");
1348         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1349
1350         SysLog(NID_MEDIA, "FileSize:%llu,elapsedTime:%llu",fileSize,elapsedTime);
1351
1352         pImpl->SetRecordingTime((long)elapsedTime);
1353         pImpl->SetRecordingSize((long)fileSize);
1354 }
1355
1356 void
1357 _VideoRecorderImpl::AudioStreamCb(void* pStream, int size, audio_sample_type_e format, int channel, unsigned int timeStamp, void *pUserData)
1358 {
1359         _VideoRecorderImpl* pImpl = static_cast<_VideoRecorderImpl*>(pUserData);
1360         int samplingRate =0;
1361         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _VideoRecorderImpl instance is not available. Impl is null.");
1362         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1363         SysTryReturnVoidResult(NID_MEDIA, pStream != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] void instance is not available. pStream is null.");
1364
1365         if (pImpl->__audioStreamCallback == true)
1366         {
1367                 samplingRate = _RecorderUtil::CalculateSampleRate(size, channel, pImpl->__audioStreamTimeDuration, _RecorderUtil::GetOspSampleType(format));
1368                 (pImpl->__pAudioStreamCoordinator)->ProcessAudioStreamData((byte*)pStream, size, samplingRate, _RecorderUtil::GetOspChannelType(channel), _RecorderUtil::GetOspSampleType(format));
1369         }
1370 }
1371
1372 void
1373 _VideoRecorderImpl::LimitReachedCb(recorder_recording_limit_type_e type, void *pUserData)
1374 {
1375         result r = E_SUCCESS;
1376         _VideoRecorderImpl* pImpl = static_cast<_VideoRecorderImpl*>(pUserData);
1377         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _VideoRecorderImpl instance is not available. pImpl is null.");
1378         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1379
1380         SysLog(NID_MEDIA, "Type:%d", type);
1381
1382         switch (type)
1383         {
1384         case ::RECORDER_RECORDING_LIMIT_TIME:
1385                 r = pImpl->ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_TIME_REACHED);
1386                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1387                 break;
1388
1389         case ::RECORDER_RECORDING_LIMIT_SIZE:
1390                 r = pImpl->ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_SIZE_REACHED);
1391                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1392                 break;
1393
1394         case ::RECORDER_RECORDING_LIMIT_FREE_SPACE:
1395                 r = pImpl->ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_OUT_OF_STORAGE);
1396                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1397                 break;
1398
1399         default:
1400                 break;
1401         }
1402
1403 CATCH:
1404         return;
1405 }
1406
1407 void
1408 _VideoRecorderImpl::ErrorCb(recorder_error_e error, recorder_state_e state, void *pUserData)
1409 {
1410         result r = E_SUCCESS;
1411         _VideoRecorderImpl* pImpl = static_cast<_VideoRecorderImpl*>(pUserData);
1412         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _VideoRecorderImpl instance is not available. pImpl is null.");
1413         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1414         SysLog(NID_MEDIA, "Error:%d, state:%d", error, state);
1415
1416         r = pImpl->GetEvent()->SendEvent(_RECORDER_EVENT_ERROR, pImpl->ConvertErrorReason(error), E_SUCCESS);
1417         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1418         pImpl->SetStateChangeReason(_RECORDER_STATE_REASON_ERROR);
1419 CATCH:
1420         return;
1421 }
1422
1423 void
1424 _VideoRecorderImpl::InterruptedCb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *pUserData)
1425 {
1426         _VideoRecorderImpl* pImpl = static_cast<_VideoRecorderImpl*>(pUserData);
1427         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _VideoRecorderImpl instance is not available. pImpl is null.");
1428         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1429
1430         SysLog(NID_MEDIA, "Policy:%d, previous:%d, current:%d", policy, previous, current);
1431 }
1432
1433 _VideoRecorderEvent*
1434 _VideoRecorderImpl::GetEvent(void) const
1435 {
1436         return __pVideoRecorderEvent.get();
1437 }
1438
1439 void
1440 _VideoRecorderImpl::SetState(RecorderState state)
1441 {
1442         __state = state;
1443 }
1444
1445 void
1446 _VideoRecorderImpl::SetRecordingTime(long recTime)
1447 {
1448         __recTime = recTime;
1449 }
1450
1451 void
1452 _VideoRecorderImpl::SetRecordingSize(long recSize)
1453 {
1454         __recSize = recSize;
1455 }
1456
1457 _RecorderDeviceType
1458 _VideoRecorderImpl::GetDeviceType(void) const
1459 {
1460         return __deviceType;
1461 }
1462
1463 result
1464 _VideoRecorderImpl::ConvertResult(int err) const
1465 {
1466         result r = E_SYSTEM;
1467         if (err != ::RECORDER_ERROR_NONE)
1468         {
1469                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
1470         }
1471
1472         // Global error
1473         if (err == ::RECORDER_ERROR_NONE)
1474         {
1475                 r = E_SUCCESS;
1476         }
1477         else if (err == ::RECORDER_ERROR_INVALID_PARAMETER)
1478         {
1479                 r = E_INVALID_ARG;
1480         }
1481         else if (err == ::RECORDER_ERROR_INVALID_STATE)
1482         {
1483                 r = E_INVALID_STATE;
1484         }
1485         else if (err == ::RECORDER_ERROR_OUT_OF_MEMORY)
1486         {
1487                 r = E_OUT_OF_MEMORY;
1488         }
1489         else if (err == ::RECORDER_ERROR_DEVICE
1490                                 || err == ::RECORDER_ERROR_ESD)
1491         {
1492                 r = E_DEVICE_FAILED;
1493         }
1494         else if (err == ::RECORDER_ERROR_INVALID_OPERATION
1495                 || err == ::RECORDER_ERROR_SECURITY_RESTRICTED)
1496         {
1497                 r = E_SYSTEM;
1498         }
1499         else if (err == ::RECORDER_ERROR_SOUND_POLICY)
1500         {
1501                 r = E_DEVICE_BUSY;
1502         }
1503         else if (err == ::RECORDER_ERROR_OUT_OF_STORAGE)
1504         {
1505                 r = E_STORAGE_FULL;
1506         }
1507         else
1508         {
1509                 r = E_UNKNOWN;
1510         }
1511
1512         return r;
1513 }
1514
1515 RecorderErrorReason
1516 _VideoRecorderImpl::ConvertErrorReason(int err) const
1517 {
1518         RecorderErrorReason r = RECORDER_ERROR_NONE;
1519         if (err != ::RECORDER_ERROR_NONE)
1520         {
1521                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
1522         }
1523
1524         // Global error
1525         if (err == ::RECORDER_ERROR_NONE)
1526         {
1527                 r = RECORDER_ERROR_NONE;
1528         }
1529         else if (err == ::RECORDER_ERROR_OUT_OF_STORAGE)
1530         {
1531                 r = RECORDER_ERROR_OUT_OF_STORAGE;
1532         }
1533         else
1534         {
1535                 r = RECORDER_ERROR_DEVICE_FAILED;
1536         }
1537
1538         return r;
1539 }
1540
1541 void
1542 _VideoRecorderImpl::GetCodecString(const CodecType videoCodec, Tizen::Base::String& codec) const
1543 {
1544         int i = 0;
1545
1546         while (_CODEC_VAL_TABLE[i].pCodecName != null)
1547         {
1548                 if (videoCodec == _CODEC_VAL_TABLE[i].videoCodec)
1549                 {
1550                         codec.Clear();
1551                         codec.Append(_CODEC_VAL_TABLE[i].pCodecName);
1552                         break;
1553                 }
1554                 i++;
1555         }
1556 }
1557
1558 result
1559 _VideoRecorderImpl::ChangeStateTo(recorder_state_e mmDestState, _RecorderStateChangeReason reason)
1560 {
1561         result r = E_SUCCESS;
1562         int tableTotalCount = 0;
1563         int i = 0;
1564         int err = MM_SUCCESS;
1565         recorder_state_e preState = ::RECORDER_STATE_NONE;
1566         recorder_state_e postState = ::RECORDER_STATE_NONE;
1567
1568         SysLog(NID_MEDIA, "Enter. mmDestState:%d", mmDestState);
1569         SysTryReturn(NID_MEDIA, __isConstructed == true, E_INVALID_STATE, E_INVALID_STATE,
1570                                 "[E_INVALID_STATE] VideoRecorder is in an invalid state. VideoRecorder is not constructed.");
1571
1572         preState = GetMmState();
1573         tableTotalCount = sizeof(_VIDEO_COMMAND_STATE) / sizeof(_VIDEO_COMMAND_STATE[0]);
1574         SysLog(NID_MEDIA, " preState:%d, mmDestState:%d, tableTotalCount:%d", preState, mmDestState, tableTotalCount);
1575
1576         for (i = 0; i < tableTotalCount; i++)
1577         {
1578                 if (preState == _VIDEO_COMMAND_STATE[i].preState && mmDestState == _VIDEO_COMMAND_STATE[i].postState && reason ==
1579                         _VIDEO_COMMAND_STATE[i].reason)
1580                 {
1581                         if (_VIDEO_COMMAND_STATE[i].pFunc != null)
1582                         {
1583                                 SysLog(NID_MEDIA, "Exist the matching state field. current state:%d, mmState:%d, reason:%d",
1584                                                         preState, mmDestState, reason);
1585                                 err = _VIDEO_COMMAND_STATE[i].pFunc(__handle);
1586                                 r = ConvertResult(err);
1587                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1588
1589                                 // Check whether the retuned states are destinationed states.
1590                                 postState = GetMmState();
1591                                 SysTryCatch(NID_MEDIA, mmDestState == postState, r = E_INVALID_STATE, E_INVALID_STATE,
1592                                                    "[E_INVALID_STATE] VideoRecorder state of CAPI is in an invalid state. result mmState:%d, is different from the desired state:%", postState, mmDestState);
1593                                 SysLog(NID_MEDIA, "[E_SUCCESS] Found. result mmState:%d, param mmDestState:%d", postState,
1594                                                         mmDestState);
1595
1596                                 SetStateChangeReason(reason);           //for distinguish between stop and cancel
1597                         }
1598
1599                         if (_VIDEO_COMMAND_STATE[i].state >= RECORDER_STATE_INITIALIZED && _VIDEO_COMMAND_STATE[i].state <= RECORDER_STATE_ERROR)
1600                         {
1601                                 SysLog(NID_MEDIA, "State set to %d", _VIDEO_COMMAND_STATE[i].state);
1602                                 SetState(_VIDEO_COMMAND_STATE[i].state);
1603                         }
1604                         break;
1605                 }
1606         }
1607         SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
1608         return r;
1609
1610 CATCH:
1611         SysLog(NID_MEDIA, "[%s] Real mmState:%d, param mmState:%d", GetErrorMessage(r), preState, mmDestState);
1612         return CheckExceptionToError(preState, mmDestState, r);
1613 }
1614
1615 result
1616 _VideoRecorderImpl::CheckExceptionToError(recorder_state_e prevState, recorder_state_e postState, result ex)
1617 {
1618         result r = E_SUCCESS;
1619         bool findFlag = false;
1620         int tableTotalCount = sizeof(_VIDEO_EXCEPTION_TO_ERROR) / sizeof(_VIDEO_EXCEPTION_TO_ERROR[0]);
1621         SysLog(NID_MEDIA, "State prev:%d, post:%d, exception:%s", prevState, postState, GetErrorMessage(ex));
1622
1623         for (int i = 0; i < tableTotalCount; i++)
1624         {
1625                 if (prevState == _VIDEO_EXCEPTION_TO_ERROR[i].prevState && postState == _VIDEO_EXCEPTION_TO_ERROR[i].postState && ex == _VIDEO_EXCEPTION_TO_ERROR[i].ex)
1626                 {
1627                         r = GetEvent()->SendEvent(_RECORDER_EVENT_ERROR, _VIDEO_EXCEPTION_TO_ERROR[i].error, E_SUCCESS);
1628                         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1629
1630                         SysLog(NID_MEDIA, "Exception is changed to E_SUCCESS and it sends error event.");
1631                         findFlag = true;
1632                         break;
1633                 }
1634         }
1635         return findFlag == true ? E_SUCCESS : ex;
1636 }
1637
1638 _RecorderStateChangeReason
1639 _VideoRecorderImpl::GetStateChangeReason(void) const
1640 {
1641         return __stateChangeReason;
1642 }
1643
1644 void
1645 _VideoRecorderImpl::SetStateChangeReason(_RecorderStateChangeReason reason)
1646 {
1647         __stateChangeReason = reason;
1648 }
1649
1650 recorder_state_e
1651 _VideoRecorderImpl::GetMmState(void) const
1652 {
1653         result r = E_SUCCESS;
1654         int err = ::RECORDER_ERROR_NONE;
1655         recorder_state_e mmState = ::RECORDER_STATE_NONE;
1656
1657         err = recorder_get_state(__handle, &mmState);
1658         r = ConvertResult(err);
1659         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1660
1661         return mmState;
1662
1663 CATCH:
1664         return ::RECORDER_STATE_NONE;
1665 }
1666
1667 void
1668 _VideoRecorderImpl::GetMediaType(const Base::String& codec, CodecType& audioCodec, CodecType& videoCodec, MediaContainerType& container) const
1669 {
1670         int i = 0;
1671         while (_CODEC_VAL_TABLE[i].pCodecName != null)
1672         {
1673                 if (String(_CODEC_VAL_TABLE[i].pCodecName).Equals(codec))
1674                 {
1675                         videoCodec = _CODEC_VAL_TABLE[i].videoCodec;
1676                         audioCodec = _CODEC_VAL_TABLE[i].audioCodec;
1677                         container = _CODEC_VAL_TABLE[i].container;
1678                         break;
1679                 }
1680                 i++;
1681         }
1682 }
1683
1684 void
1685 _VideoRecorderImpl::GetMediaType(VideoRecordingFormat format, CodecType& audioCodec, CodecType& videoCodec,
1686                                                                  MediaContainerType& container) const
1687 {
1688         switch (format)
1689         {
1690         case VIDEORECORDING_FORMAT_3GP:
1691                 audioCodec = CODEC_AMR_NB;
1692                 videoCodec = CODEC_MPEG4;
1693                 container = MEDIA_CONTAINER_3GP;
1694                 break;
1695
1696         case VIDEORECORDING_FORMAT_DEFAULT:
1697         case VIDEORECORDING_FORMAT_MP4:
1698                 audioCodec = CODEC_AAC;
1699                 videoCodec = CODEC_MPEG4;
1700                 container = MEDIA_CONTAINER_MP4;
1701                 break;
1702
1703         default:
1704                 audioCodec = CODEC_NONE;
1705                 videoCodec = CODEC_NONE;
1706                 container = MEDIA_CONTAINER_NONE;
1707                 break;
1708         }
1709 }
1710
1711 result
1712 _VideoRecorderImpl::ReloadConfiguration(int reload)
1713 {
1714         result r = E_SUCCESS;
1715         int err = MM_SUCCESS;
1716         SysLog(NID_MEDIA, "Enter. reload:0x%x", reload);
1717
1718         if (reload & _RELOAD_FORMAT)
1719         {
1720                 r = SetFormatAttr(__audioCodec, __videoCodec, __container);
1721                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] File format set  failed. audioCodec:0x%x videoCodec:0x%x  container:0x%x",
1722                                 GetErrorMessage(r), __audioCodec, __videoCodec, __videoCodec);
1723         }
1724         if (reload & _RELOAD_QUALITY)
1725         {
1726                 r = SetQualityAttr(__quality, __audioCodec, __videoCodec);
1727                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] set quality failed. quality:%d", GetErrorMessage(r), __quality);
1728         }
1729         if (reload & _RELOAD_MAX_TIME)
1730         {
1731                 r = SetMaxRecordingTimeAttr(__maxTime);
1732                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camcorder set attribute failed. maxTime:%ls", GetErrorMessage(r), __maxTime);
1733         }
1734         if (reload & _RELOAD_FILE_PATH)
1735         {
1736                 result r = E_SUCCESS;
1737                 int err = MM_SUCCESS;
1738                 std::unique_ptr<char[]> pFileName (Tizen::Base::_StringConverter::CopyToCharArrayN(__filePath));
1739                 SysTryCatch(NID_MEDIA, pFileName.get() != null, r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(__filePath) is used. File name is null.");
1740                 SysSecureLog(NID_MEDIA, "File Path : %s\n", pFileName.get());
1741
1742                 err = recorder_set_filename(__handle, pFileName.get());
1743                 r = ConvertResult(err);
1744                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1745         }
1746         if (reload & _RELOAD_INIT)
1747         {
1748                 __recTime = 0;
1749                 __recSize = 0;
1750         }
1751         if (reload & _RELOAD_CALLBACK)
1752         {
1753                 r = SetCallback();
1754                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set callback failed.", GetErrorMessage(r));
1755         }
1756         if (reload & _RELOAD_MUTE)
1757         {
1758                 r = SetMuteAttr(__mute);
1759                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set mute failed", GetErrorMessage(r));
1760         }
1761         if (reload & _RELOAD_ROTATION)
1762         {
1763                 r = SetRecordingOrientationAttr(__rotation);
1764                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] video recorder set orientation failed", GetErrorMessage(r));
1765         }
1766
1767         return r;
1768
1769 CATCH:
1770         if (__handle)
1771         {
1772                 err = recorder_unset_state_changed_cb(__handle);
1773                 err = recorder_unset_recording_limit_reached_cb(__handle);
1774                 err = recorder_unset_error_cb(__handle);
1775                 err = recorder_unset_interrupted_cb(__handle);
1776                 __handle = MM_INVALID_HANDLE;
1777         }
1778
1779         return r;
1780 }
1781
1782 result
1783 _VideoRecorderImpl::LoadDefaultConfiguration(int reload)
1784 {
1785         result r = E_SUCCESS;
1786         SysLog(NID_MEDIA, "Enter.");
1787
1788         // Preview resolution
1789         if (reload & _RELOAD_RECORD_RESOLUTION)
1790         {
1791                 SysTryReturn(NID_MEDIA, __pVideoSourceAdapter.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The source is deleted.");
1792                 __recordingResolution = __pVideoSourceAdapter->GetSourceResolution();
1793         }
1794
1795         return r;
1796 }
1797
1798 _VideoRecorderImpl*
1799 _VideoRecorderImpl::GetInstance(VideoRecorder *pVideoRecorder)
1800 {
1801         if ( pVideoRecorder != null )
1802         {
1803                 return pVideoRecorder->__pImpl;
1804         }
1805         return null;
1806 }
1807
1808 const _VideoRecorderImpl*
1809 _VideoRecorderImpl::GetInstance(const VideoRecorder *pVideoRecorder)
1810 {
1811         if ( pVideoRecorder != null )
1812         {
1813                 return pVideoRecorder->__pImpl;
1814         }
1815         return null;
1816 }
1817
1818 }}// Tizen::Media
1819