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