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