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