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