src/FMedia_PlayerImpl.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 #include <FBase_StringConverter.h>
  18 #include <FBaseSysLog.h>
  19 #include <FGrpBitmapCommon.h>
  20 #include <FGrpDimension.h>
  21 #include <FIoFile.h>
  22 #include <FBaseCol.h>
  23 #include <FSys_SystemInfoImpl.h>
  24 #include <FGrp_VideoTextureImpl.h>
  25 #include <FMediaMediaStreamInfo.h>
  26 #include <FMediaCapability.h>
  27 #include "FMedia_ColorConverter.h"
  28 #include "FMedia_PlayerEvent.h"
  29 #include "FMedia_PlayerEventTypes.h"
  30 #include "FMedia_PlayerEventArg.h"
  31 #include "FMedia_PlayerVideoEvent.h"
  32 #include "FMedia_PlayerVideoEventTypes.h"
  33 #include "FMedia_PlayerVideoEventArg.h"
  34 #include <Evas.h>
  35 #include <pthread.h>
  36 #include "FMedia_PlayerImpl.h"
  37 #include "FMedia_AudioManagerConvert.h"
  38 #include "FMedia_PlayerProgressiveDownloadEvent.h"
  39 #include "FMedia_PlayerProgressiveDownloadEventArg.h"
  40 #include "FMedia_CamPtrUtil.h"
  41
  42 using namespace Tizen::Base;
  43 using namespace Tizen::Base::Runtime;
  44 using namespace Tizen::Graphics;
  45 using namespace Tizen::Net;
  46 using namespace Tizen::Io;
  47 using namespace Tizen::Base::Collection;
  48 using namespace Tizen::Graphics::Opengl;
  49
  50 namespace Tizen { namespace Media
  51 {
  52 int _PlayerImpl::__playerCount = 0;
  53 int _PlayerImpl::__maxInstanceCount = 0;
  54 std::unique_ptr<Tizen::Base::Runtime::Mutex> _PlayerImpl::__pMutex;
  55 std::unique_ptr<Tizen::Base::Collection::ArrayList> _PlayerImpl::__pPlayerImplList;
  56 bool _PlayerImpl::__isInstanceMutexInitialized = false;
  57
  58 _PlayerImpl::_PlayerImpl(void)
  59         : __hPlayer(null)
  60         , __corePlayerCurState(::PLAYER_STATE_NONE)
  61         , __hCanvas(0)
  62         , __handleType(_BufferInfoImpl::HANDLE_TYPE_NONE)
  63         , __pPlayerEventListener(null)
  64         , __pPlayerVideoEventListener(null)
  65         , __pPlayerProgressiveDownloadListener(null)
  66
  67         // For Triple buffering & Video Only Mode
  68         , __pUserData(null)
  69         , __displayMode(::PLAYER_DISPLAY_MODE_FULL_SCREEN)
  70         , __displayRotation(::PLAYER_DISPLAY_ROTATION_NONE)
  71         , __displayBounds(Rectangle(0, 0, -1, -1))
  72
  73         , __orientation(ORIENTATION_PORTRAIT)
  74         , __currentVolume(DEFAULT_PLAYER_VOLUME)
  75         , __currentState(PLAYER_STATE_INITIALIZED)
  76         , __preState(PLAYER_STATE_INITIALIZED)
  77         , __videoPixelFormat(BITMAP_PIXEL_FORMAT_MIN)
  78         , __bufferDataSize(0)
  79         , __decodedFrameWidth(0)
  80         , __decodedFrameHeight(0)
  81         , __decodedFrameSize(0)
  82         , __pdCallbackRate(10)
  83         , __pVideoTextureImpl(null)
  84         , __isOpenBuffer(false)
  85         , __isMuted(false)
  86         , __isLooped(false)
  87         , __isLocalData(true)
  88         , __checkCallbackForReadyState(false)
  89         , __isStreamingContent(false)
  90         , __videoEventCreated(false)
  91         , __isPlayerConstructed(false)
  92         , __isStateChangeForVideoCapture(false)
  93         , __isProgressiveContent(false)
  94         , __isProgressiveTimerStarted(false)
  95         , __interruptFlag(false)
  96         , __isAsync(false)
  97 {
  98
  99 }
 100
 101 _PlayerImpl::~_PlayerImpl(void)
 102 {
 103         // Destruct only if player is constructed.
 104         if (__isPlayerConstructed == false )
 105         {
 106                 return;
 107         }
 108         SysTryLog(NID_MEDIA, false, "Destroy player");
 109         result r = E_SUCCESS;
 110
 111         EventDrivenThread::Quit();
 112         EventDrivenThread::Join();
 113
 114         r = __pMutex->Acquire();
 115         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 116         if (__playerCount)
 117         {
 118                 __pPlayerImplList->Remove(*this);
 119                 // Decrease a number of player instance
 120                 __playerCount--;
 121                 SysLog(NID_MEDIA, "_~PlayerImpl Instance number is %d", __playerCount);
 122         }
 123         r = __pMutex->Release();
 124         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 125
 126         int ret = ::PLAYER_ERROR_NONE;
 127         __isOpenBuffer = false;
 128         __isStreamingContent = false;
 129         __bufferDataSize = 0;
 130         __isPlayerConstructed = false;
 131         __isLocalData = true;
 132
 133         if (__hPlayer)
 134         {
 135                 ret = player_get_state(__hPlayer, &__corePlayerCurState );
 136                 if (ret == 0)
 137                 {
 138                         if ( __corePlayerCurState == ::PLAYER_STATE_PAUSED || __corePlayerCurState == ::PLAYER_STATE_PLAYING )
 139                         {
 140                                 ret = player_stop(__hPlayer);
 141                                 r = MapExceptionToResult(ret);
 142                                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 143                                 ret = player_get_state(__hPlayer, &__corePlayerCurState );
 144                                 r = MapExceptionToResult(ret);
 145                                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 146                         }
 147                         if ( __corePlayerCurState == ::PLAYER_STATE_READY )
 148                         {
 149
 150                                 ret = player_unprepare(__hPlayer);
 151                                 r = MapExceptionToResult(ret);
 152                                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 153                                 ret = player_get_state(__hPlayer, &__corePlayerCurState );
 154                                 r = MapExceptionToResult(ret);
 155                                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 156                         }
 157                         //un-set the callbacks
 158                         player_unset_completed_cb(__hPlayer);
 159                         player_unset_interrupted_cb(__hPlayer);
 160                         player_unset_error_cb(__hPlayer);
 161                         if (__videoEventCreated)
 162                         {
 163                                 player_unset_video_frame_decoded_cb(__hPlayer);
 164                         }
 165
 166                         if (__corePlayerCurState == ::PLAYER_STATE_IDLE )
 167                         {
 168                                 ret = player_destroy(__hPlayer);
 169                                 r = MapExceptionToResult(ret);
 170                                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 171                         }
 172                 }
 173                 __hPlayer = null;
 174         }
 175         //No Event should reach application after destructor returns
 176         __pPlayerEvent.reset(null);
 177         __pPlayerVideoEvent.reset(null);
 178         __pPlayerProgressiveDownloadEvent.reset(null);
 179         __pVideoTextureImpl = null;
 180 }
 181
 182 void
 183 _PlayerImpl::InitInstanceMutex(void)
 184 {
 185         result r = E_SUCCESS;
 186         __pMutex.reset(new (std::nothrow) Tizen::Base::Runtime::Mutex);
 187         SysTryReturn(NID_MEDIA, __pMutex.get() != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] no memory to create instance Mutex");
 188         r = __pMutex->Create("FMEDIA_PLAYER");
 189         SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Mutex::Create failed.");
 190         __pPlayerImplList.reset(new (std::nothrow) Tizen::Base::Collection::ArrayList);
 191         SysTryReturn(NID_MEDIA, __pPlayerImplList.get() != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] no memory to create instance ArrayList");
 192         r = __pPlayerImplList->Construct();
 193         SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] ArrayList::Create failed.");
 194         __isInstanceMutexInitialized  = true;
 195 }
 196
 197 _PlayerImpl*
 198 _PlayerImpl::GetInstance(Player* pPlayer)
 199 {
 200         if (pPlayer != null)
 201         {
 202                 return pPlayer->__pPlayerImpl;
 203         }
 204
 205         return null;
 206 }
 207
 208 const _PlayerImpl*
 209 _PlayerImpl::GetInstance(const Player* pPlayer)
 210 {
 211         if (pPlayer != null)
 212         {
 213                 return pPlayer->__pPlayerImpl;
 214         }
 215
 216         return null;
 217 }
 218
 219
 220 result
 221 _PlayerImpl::Construct(IPlayerEventListener& listener, const Tizen::Graphics::BufferInfo* pBufferInfo)
 222 {
 223         result r = E_SUCCESS;
 224         const _BufferInfoImpl *pbufferInfoImpl = null;
 225         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 226         if (!__isInstanceMutexInitialized)
 227         {
 228                 pthread_once(&onceBlock, InitInstanceMutex);
 229         }
 230         SysTryCatch(NID_MEDIA, __isInstanceMutexInitialized == true, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] memory allocation for Instance Mutex failed");
 231
 232         //if the __maxInstanceCount is not initialized do so using Capability
 233         if (!__maxInstanceCount)
 234         {
 235                 r = MediaCapability::GetValue(PLAYER_COUNT_MAX, __maxInstanceCount);
 236                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s]Propagating", GetErrorMessage(r));
 237                 SysTryCatch(NID_MEDIA, __maxInstanceCount > 0, , r, "[%s]Propagating", GetErrorMessage(r));
 238         }
 239
 240         // Check the instance maximum
 241         SysTryReturn(NID_MEDIA, __playerCount < __maxInstanceCount, E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE,
 242                 "__playerCount count -%d failed can only create - %d Player Instances ",__playerCount,  __maxInstanceCount);
 243
 244         r = EventDrivenThread::Construct();
 245         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Thread::Construct failed", GetErrorMessage(r));
 246         r = EventDrivenThread::Start();
 247         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Thread::Start failed", GetErrorMessage(r));
 248
 249         // Create Event
 250         __pPlayerEvent.reset(new (std::nothrow) _PlayerEvent);
 251         SysTryCatch(NID_MEDIA, __pPlayerEvent.get() != null , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. __pPlayerEvent is null.");
 252
 253         r = __pPlayerEvent->Construct();
 254         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE , E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] Failed to construct _PlayerEvent.");
 255
 256         r = __pPlayerEvent->AddListener(listener);
 257         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] Failed to perform AddListener operation.");
 258
 259         __pPlayerEventListener = &listener;
 260
 261         r = CreatePlayerAndSetCallBack();
 262         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform CreateMMPlayerInstanceAndSetMsgCallBack operation.", GetErrorMessage(r));
 263
 264         r = SetVolume(DEFAULT_PLAYER_VOLUME);
 265         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform SetVolume operation.", GetErrorMessage(r));
 266
 267         r = SetMute(false);
 268         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform SetMute operation.", GetErrorMessage(r));
 269
 270         r = SetLooping(false);
 271         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform SetLooping operation.", GetErrorMessage(r));
 272
 273         // Set the canvas to subsystem's player
 274         if (pBufferInfo)
 275         {
 276                 pbufferInfoImpl = _BufferInfoImpl::GetInstance(*pBufferInfo);
 277                 SysTryCatch(NID_MEDIA, pbufferInfoImpl != NULL, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pbufferInfoImpl instance must not be null.");
 278                 __orientation = (Orientation)(pbufferInfoImpl->GetOrientation());
 279
 280                 // Set an available handler even if handler is not available.
 281                 if (pbufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION))
 282                 {
 283                         __hCanvas = pbufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION);
 284                         __handleType = _BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION;
 285
 286                         _BufferInfoImpl::Rotation rotation = pbufferInfoImpl->GetRotation();
 287                         switch(rotation)
 288                         {
 289                                 case _BufferInfoImpl::ROTATION_0:
 290                                         __displayRotation = ::PLAYER_DISPLAY_ROTATION_NONE;
 291                                         break;
 292                                 case _BufferInfoImpl::ROTATION_90:
 293                                         __displayRotation = ::PLAYER_DISPLAY_ROTATION_90;
 294                                         break;
 295                                 case _BufferInfoImpl::ROTATION_180:
 296                                         __displayRotation = ::PLAYER_DISPLAY_ROTATION_180;
 297                                         break;
 298                                 case _BufferInfoImpl::ROTATION_270:
 299                                         __displayRotation = ::PLAYER_DISPLAY_ROTATION_270;
 300                                         break;
 301                         }
 302
 303                         __pUserData = static_cast<Tizen::Ui::Controls::_UserData*>(pbufferInfoImpl->GetUserData(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION));
 304                         if (__pUserData != NULL)
 305                         {
 306                                 __displayMode = static_cast<player_display_mode_e>(__pUserData->__userProperties.__displayMode);
 307
 308                                 if (__displayMode == ::PLAYER_DISPLAY_MODE_ROI)
 309                                 {
 310                                         __displayBounds = __pUserData->__userProperties.__displayBounds;
 311                                 }
 312                         }
 313                 }
 314                 else if (pbufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_VE_SURFACE))
 315                 {
 316                         __hCanvas = pbufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_VE_SURFACE);
 317                         __handleType = _BufferInfoImpl::HANDLE_TYPE_VE_SURFACE;
 318                 }else
 319                 {
 320                         // handle is invalid
 321                         __hCanvas = 0;
 322                         __handleType = _BufferInfoImpl::HANDLE_TYPE_NONE;
 323                 }
 324
 325                 SysTryCatch(NID_MEDIA, __hCanvas != 0, r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used.  __hCanvas = %d", __hCanvas);
 326         }
 327
 328         __pMutex->Acquire();
 329         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 330         __playerCount++;
 331         __pPlayerImplList->Add(this);
 332         r = __pMutex->Release();
 333         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 334         SysLog(NID_MEDIA, "Instance number is %d.", __playerCount);
 335
 336         __currentState = PLAYER_STATE_INITIALIZED;
 337         __isPlayerConstructed = true;
 338
 339         return r;
 340 CATCH:
 341         if (__hPlayer)
 342         {
 343                 player_destroy(__hPlayer);
 344                 __hPlayer = null;
 345         }
 346         __pPlayerEventListener = null;
 347         return r;
 348 }
 349
 350 result
 351 _PlayerImpl::Construct(IPlayerEventListener& listener, IPlayerVideoEventListener& videoListener, void* pPlayerObj)
 352 {
 353         result r = E_SUCCESS;
 354         String key(L"http://tizen.org/feature/screen.bpp");
 355         int bit = 0;
 356         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 357         if (!__isInstanceMutexInitialized)
 358         {
 359                 pthread_once(&onceBlock, InitInstanceMutex);
 360         }
 361         SysTryCatch(NID_MEDIA, __isInstanceMutexInitialized == true, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] memory allocation for Instance Mutex failed");
 362
 363         if (!__maxInstanceCount)
 364         {
 365                 r = MediaCapability::GetValue(PLAYER_COUNT_MAX, __maxInstanceCount);
 366                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
 367                 SysTryCatch(NID_MEDIA, __maxInstanceCount > 0, , r, "[%s] Propagating", GetErrorMessage(r));
 368         }
 369
 370         // Check the instance maximum
 371         SysTryReturn(NID_MEDIA, __playerCount < __maxInstanceCount, r = E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE,
 372                 "[E_RESOURCE_UNAVAILABLE] __playerCount count -%d failed can only create - %d Player Instances ",__playerCount,  __maxInstanceCount);
 373
 374         r = EventDrivenThread::Construct();
 375         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Thread::Construct failed", GetErrorMessage(r));
 376         r = EventDrivenThread::Start();
 377         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Thread::Start failed", GetErrorMessage(r));
 378
 379         // Create Event
 380         __pPlayerEvent.reset(new (std::nothrow) _PlayerEvent);
 381         SysTryCatch(NID_MEDIA, __pPlayerEvent, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. __pPlayerEvent is null.");
 382
 383         r = __pPlayerEvent->Construct();
 384         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE , E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] Failed to construct _PlayerEvent");
 385
 386         r = __pPlayerEvent->AddListener(listener);
 387         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE , E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] Failed to perform AddListner operation");
 388
 389         __pPlayerEventListener = &listener;
 390
 391         // Create Video Event
 392         __pPlayerVideoEvent.reset(new (std::nothrow) _PlayerVideoEvent);
 393         SysTryCatch(NID_MEDIA, __pPlayerVideoEvent, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. pPlayerVideoEvent is null");
 394
 395         r = __pPlayerVideoEvent->Construct(pPlayerObj);
 396         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] Failed to construct _PlayerVideoEvent.");
 397
 398         r = __pPlayerVideoEvent->AddListener(videoListener);
 399         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] Failed to perform AddListner operation.");
 400
 401         __pPlayerVideoEventListener = &videoListener;
 402
 403         // Set the bit per pixel of system
 404         r = Tizen::System::_SystemInfoImpl::GetSysInfo(key, bit);
 405
 406         SetSystemBitPerPixel(bit);
 407         __videoEventCreated = true;
 408         // Set Canvas for surface in platform
 409
 410         r = CreatePlayerAndSetCallBack();
 411         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform CreateMMPlayerInstanceAndSetMsgCallBack operation.", GetErrorMessage(r));
 412
 413         r = SetVolume(DEFAULT_PLAYER_VOLUME);
 414         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform SetVolume operation.", GetErrorMessage(r));
 415
 416         r = SetMute(false);
 417         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform SetMute operation.", GetErrorMessage(r));
 418
 419         r = SetLooping(false);
 420         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform SetLooping operation.", GetErrorMessage(r));
 421
 422         __pMutex->Acquire();
 423         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 424         __playerCount++;
 425         __pPlayerImplList->Add(this);
 426         r = __pMutex->Release();
 427         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 428         SysLog(NID_MEDIA, "Instance number is %d", __playerCount);
 429
 430         __currentState = PLAYER_STATE_INITIALIZED;
 431         __isPlayerConstructed = true;
 432
 433         return r;
 434 CATCH:
 435         if (__hPlayer)
 436         {
 437                 player_destroy(__hPlayer);
 438                 __hPlayer = null;
 439         }
 440         __pPlayerEventListener = null;
 441         __pPlayerVideoEventListener=null;
 442
 443         return r;
 444
 445 }
 446
 447 result
 448 _PlayerImpl::Construct(IPlayerEventListener& listener, Tizen::Graphics::Opengl::VideoTexture& videoTexture)
 449 {
 450         result r = E_SUCCESS;
 451         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 452         if (!__isInstanceMutexInitialized)
 453         {
 454                 pthread_once(&onceBlock, InitInstanceMutex);
 455         }
 456         SysTryCatch(NID_MEDIA, __isInstanceMutexInitialized == true, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] memory allocation for Instance Mutex failed");
 457
 458         //if the __maxInstanceCount is not initialized do so using Capability
 459         if (!__maxInstanceCount)
 460         {
 461                 r = MediaCapability::GetValue(PLAYER_COUNT_MAX, __maxInstanceCount);
 462                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s]Propagating", GetErrorMessage(r));
 463                 SysTryCatch(NID_MEDIA, __maxInstanceCount > 0, , r, "[%s]Propagating", GetErrorMessage(r));
 464         }
 465
 466         // Check the instance maximum
 467         SysTryReturn(NID_MEDIA, __playerCount < __maxInstanceCount, E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE,
 468                 "__playerCount count -%d failed can only create - %d Player Instances ",__playerCount,  __maxInstanceCount);
 469
 470         r = EventDrivenThread::Construct();
 471         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Thread::Construct failed", GetErrorMessage(r));
 472         r = EventDrivenThread::Start();
 473         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Thread::Start failed", GetErrorMessage(r));
 474
 475         __pVideoTextureImpl = _VideoTextureImpl::GetInstance(videoTexture);
 476         SysTryReturn(NID_MEDIA, __pVideoTextureImpl != null, E_INVALID_ARG, E_INVALID_ARG, "videoTexture argument passes is wrong");
 477
 478         // Create Event
 479         __pPlayerEvent.reset(new (std::nothrow) _PlayerEvent);
 480         SysTryCatch(NID_MEDIA, __pPlayerEvent != null , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. __pPlayerEvent is null.");
 481
 482         r = __pPlayerEvent->Construct();
 483         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] Failed to construct _PlayerEvent.");
 484
 485         r = __pPlayerEvent->AddListener(listener);
 486         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_RESOURCE_UNAVAILABLE, E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] Failed to perform AddListener operation.");
 487
 488         __pPlayerEventListener = &listener;
 489
 490         r = CreatePlayerAndSetCallBack();
 491         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform CreateMMPlayerInstanceAndSetMsgCallBack operation.", GetErrorMessage(r));
 492
 493         r = SetVolume(DEFAULT_PLAYER_VOLUME);
 494         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform SetVolume operation.", GetErrorMessage(r));
 495
 496         r = SetMute(false);
 497         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform SetMute operation.", GetErrorMessage(r));
 498
 499         r = SetLooping(false);
 500         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform SetLooping operation.", GetErrorMessage(r));
 501
 502         __pMutex->Acquire();
 503         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 504         __playerCount++;
 505         __pPlayerImplList->Add(this);
 506         r = __pMutex->Release();
 507         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 508         SysLog(NID_MEDIA, "Instance number is %d.", __playerCount);
 509
 510         __currentState = PLAYER_STATE_INITIALIZED;
 511         __isPlayerConstructed = true;
 512
 513         return r;
 514 CATCH:
 515         if (__hPlayer)
 516         {
 517                 player_destroy(__hPlayer);
 518                 __hPlayer = null;
 519         }
 520         __pPlayerEventListener = null;
 521         return r;
 522 }
 523
 524 result
 525 _PlayerImpl::OpenFile(const Tizen::Base::String& mediaLocalPath, bool isAsync)
 526 {
 527         result r = E_SUCCESS;
 528         int err = ::PLAYER_ERROR_NONE;
 529         Tizen::Base::String strFileName;
 530         std::unique_ptr<char[]> pInputFilePath;
 531         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 532
 533         err = player_get_state(__hPlayer, &__corePlayerCurState);
 534         r = MapExceptionToResult(err);
 535         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred in player_get_state", GetErrorMessage(r));
 536
 537         SysTryReturn(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_IDLE,
 538                         E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. State is %d", __corePlayerCurState);
 539
 540         strFileName = Tizen::Io::File::GetFileName(mediaLocalPath);
 541
 542         SysTryReturn(NID_MEDIA, ((mediaLocalPath.GetLength() > 0) && !strFileName.IsEmpty()), E_FILE_NOT_FOUND, E_FILE_NOT_FOUND,
 543                                 "[E_FILE_NOT_FOUND] mediaLocalPath's length is (%d).", mediaLocalPath.GetLength());
 544
 545         pInputFilePath.reset(_StringConverter::CopyToCharArrayN(mediaLocalPath));
 546         SysTryCatch(NID_MEDIA, pInputFilePath.get() , r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pInputFilePath is null");
 547         SysSecureLog(NID_MEDIA, "Input file path after conversion is [%s]", pInputFilePath.get());
 548
 549         __preState = __currentState;
 550         __currentState = PLAYER_STATE_OPENING;
 551         __isAsync = isAsync;
 552
 553         r = OpenInputData(std::move(pInputFilePath));
 554         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform OpenInputData operation.", GetErrorMessage(r));
 555         return r;
 556
 557 CATCH:
 558         __currentState = PLAYER_STATE_INITIALIZED;
 559         return r;
 560 }
 561
 562 result
 563 _PlayerImpl::OpenBuffer(const Tizen::Base::ByteBuffer& mediaBuffer, bool isAsync)
 564 {
 565         result r = E_SUCCESS;
 566         int err = ::PLAYER_ERROR_NONE;
 567         std::unique_ptr<char[]> pInputFilePath;
 568
 569         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 570
 571         err = player_get_state(__hPlayer, &__corePlayerCurState);
 572         r = MapExceptionToResult(err);
 573         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_getstate operation with - 0x%x", GetErrorMessage(r), err);
 574
 575         SysTryReturn(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_IDLE,
 576                 E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. State is %d ", __corePlayerCurState);
 577
 578         __pTargetByteBuffer.reset(new (std::nothrow) ByteBuffer);
 579         SysTryCatch(NID_MEDIA, __pTargetByteBuffer , r = E_OUT_OF_MEMORY, r, "[E_OUT_OF_MEMORY] Memory allocation failed. pTargetByteBuffer is null");
 580
 581         r = __pTargetByteBuffer->Construct(mediaBuffer);
 582
 583         __isOpenBuffer = true;
 584         __bufferDataSize = __pTargetByteBuffer->GetCapacity();
 585
 586         SysTryCatch(NID_MEDIA, __bufferDataSize > 0, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Buffer instance is not available.");
 587         SysTryCatch(NID_MEDIA, __pTargetByteBuffer->GetPointer() , r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Buffer instance is not available.");
 588
 589         __preState = __currentState;
 590         __currentState = PLAYER_STATE_OPENING;
 591         __isAsync = isAsync;
 592
 593         r = OpenInputData(std::move(pInputFilePath));
 594         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform OpenInputData operation.", GetErrorMessage(r));
 595         return r;
 596
 597 CATCH:
 598         __isOpenBuffer = false;
 599         __currentState = PLAYER_STATE_INITIALIZED;
 600         return r;
 601 }
 602
 603 result
 604 _PlayerImpl::OpenUrl(const Tizen::Base::Utility::Uri& mediaUri, bool isAync)
 605 {
 606         result r = E_SUCCESS;
 607
 608         Tizen::Base::String urlStr;
 609         Tizen::Base::String scheme;
 610         std::unique_ptr<char[]> pInputFilePath;
 611
 612         int err = ::PLAYER_ERROR_NONE;
 613
 614         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 615
 616         err = player_get_state(__hPlayer, &__corePlayerCurState);
 617         r = MapExceptionToResult(err);
 618         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), err);
 619
 620         SysTryReturn(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_IDLE,
 621                  E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. State is %d", __corePlayerCurState);
 622
 623         SysTryReturn(NID_MEDIA, !mediaUri.GetEncodedString().IsEmpty(), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. Input url is empty");
 624
 625         urlStr = mediaUri.GetEncodedString();
 626
 627         r = urlStr.SubString(0, 4, scheme);
 628         SysTryReturn(NID_MEDIA, r == E_SUCCESS, E_UNSUPPORTED_PROTOCOL , E_UNSUPPORTED_PROTOCOL, "[%s] Failed to perform SubString operation", GetErrorMessage(E_UNSUPPORTED_PROTOCOL));
 629         SysTryReturn(NID_MEDIA, (scheme.Equals(L"rtsp", false) || scheme.Equals(L"http", false)), r = E_UNSUPPORTED_PROTOCOL,
 630         E_UNSUPPORTED_PROTOCOL, "[E_UNSUPPORTED_PROTOCOL] error has been occurred.");
 631
 632         pInputFilePath.reset(_StringConverter::CopyToCharArrayN(mediaUri.GetEncodedString()));
 633         __isAsync = isAync;
 634         __isStreamingContent = true;
 635         __preState = __currentState;
 636         __currentState = PLAYER_STATE_OPENING;
 637
 638         r = OpenInputData(std::move(pInputFilePath));
 639         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. Failed to perform OpenInputData operation.", GetErrorMessage(r));
 640         __isLocalData = false;
 641
 642         return r;
 643 CATCH:
 644         __isStreamingContent = false;
 645         __currentState = PLAYER_STATE_INITIALIZED;
 646         return r;
 647 }
 648
 649 result
 650 _PlayerImpl::OpenInputData(std::unique_ptr<char[]> pStrInputFilePath)
 651 {
 652         result r = E_SUCCESS;
 653         int err = ::PLAYER_ERROR_NONE;
 654         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 655
 656         if (__isOpenBuffer)
 657         {
 658                 err = player_set_memory_buffer(__hPlayer, (void *) __pTargetByteBuffer->GetPointer(), __bufferDataSize);
 659         }
 660         else
 661         {
 662                 SysTryReturn(NID_MEDIA, pStrInputFilePath.get() , r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. StrInputFilePath is null.");
 663                 err = player_set_uri(__hPlayer, pStrInputFilePath.get());
 664         }
 665         r = MapExceptionToResult(err);
 666         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred.", GetErrorMessage(r));
 667
 668         if (__hCanvas)
 669         {
 670                 if (__handleType != _BufferInfoImpl::HANDLE_TYPE_VE_SURFACE)
 671                 {
 672                         SysLog(NID_MEDIA, "PLAYER_DISPLAY_TYPE_X11");
 673                         err = player_set_display(__hPlayer, PLAYER_DISPLAY_TYPE_X11, (player_display_h) __hCanvas);
 674                 }else
 675                 {
 676                         SysLog(NID_MEDIA, "PLAYER_DISPLAY_TYPE_EVAS");
 677                         err = player_set_display(__hPlayer, PLAYER_DISPLAY_TYPE_EVAS, (player_display_h) __hCanvas);
 678                 }
 679                 r = MapExceptionToResult(err);
 680                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_display operation with - 0x%x", GetErrorMessage(r), err);
 681
 682                 err = player_set_display_mode(__hPlayer, __displayMode);
 683                 r = MapExceptionToResult(err);
 684                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_display_mode operation with - 0x%x", GetErrorMessage(r), err);
 685
 686                 if (__displayMode == ::PLAYER_DISPLAY_MODE_ROI)
 687                 {
 688                         err = player_set_x11_display_roi(__hPlayer, __displayBounds.x, __displayBounds.y, __displayBounds.width, __displayBounds.height);
 689                         r = MapExceptionToResult(err);
 690                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_x11_display_roi operation with - 0x%x", GetErrorMessage(r), err);
 691                 }
 692
 693                 err = player_set_x11_display_rotation(__hPlayer, __displayRotation);
 694                 r = MapExceptionToResult(err);
 695                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_x11_display_rotation operation with - 0x%x", GetErrorMessage(r), err);
 696         }
 697         if (__pVideoTextureImpl)
 698         {
 699                 err = player_set_display_mode(__hPlayer, PLAYER_DISPLAY_MODE_FULL_SCREEN);
 700                 r = MapExceptionToResult(err);
 701                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_display_mode operation with - 0x%x", GetErrorMessage(r), err);
 702
 703                 err = player_set_x11_display_pixmap(__hPlayer, _VideoTextureImpl::GetPixmap, (void*)__pVideoTextureImpl);
 704                 r = MapExceptionToResult(err);
 705                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_x11_display_pixmap with - 0x%x", GetErrorMessage(r), err);
 706
 707                 err = player_set_x11_display_pixmap_error_cb(__hPlayer, _VideoTextureImpl::PixmapErrorCallback, (void*)__pVideoTextureImpl);
 708                 r = MapExceptionToResult(err);
 709                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_x11_display_pixmap_error_cb with 0x%x", GetErrorMessage(r), err);
 710         }
 711         if (__videoEventCreated)
 712         {
 713                 err = player_set_display(__hPlayer, PLAYER_DISPLAY_TYPE_X11, (player_display_h) null);
 714                 r = MapExceptionToResult(err);
 715                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] error has been occurred. Failed to perform player_set_display operation with - 0x%x", GetErrorMessage(r), err);
 716
 717                 err = player_set_x11_display_visible(__hPlayer, false);
 718                 r = MapExceptionToResult(err);
 719                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] error has been occurred. Failed to perform player_set_x11_display_visible operation with - 0x%x", GetErrorMessage(r), err);
 720         }
 721         if (__isAsync == false)
 722         {
 723                 // Sync call
 724                 err = player_prepare(__hPlayer);
 725                 SysTryCatch(NID_MEDIA, err != ::PLAYER_ERROR_INVALID_OPERATION, r = E_SYSTEM, E_SYSTEM,
 726                                 "[E_SYSTEM] The device has moved to invalid state as it has run out of system resources : 0x%x", err);
 727                 r = MapExceptionToResult(err);
 728                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] error has been occurred. Failed to perform player_prepare operation with 0x%x", GetErrorMessage(r), err);
 729
 730                 err = player_get_state(__hPlayer, &__corePlayerCurState);
 731                 r = MapExceptionToResult(err);
 732                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] error has been occurred. Failed to perform player_get_state operation with - 0x%x",GetErrorMessage(r), err);
 733                 SysTryCatch(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_READY , , r = E_SYSTEM, "[E_SYSTEM] A system error has been occurred. wrong sync state is [%d]", __corePlayerCurState);
 734                 __currentState = PLAYER_STATE_OPENED;
 735         }
 736         else
 737         {
 738                 // Async call
 739                 err = player_prepare_async(__hPlayer,PlayerPreparedCallBack,(void*)this);
 740                 SysTryCatch(NID_MEDIA, err != ::PLAYER_ERROR_INVALID_OPERATION, r = E_INVALID_STATE, E_INVALID_STATE,
 741                                 "[E_INVALID_STATE] The device has moved to invalid state as it has run out of system resources : 0x%x", err);
 742                 r = MapExceptionToResult(err);
 743                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] error has been occured. Failed to perform player_prepare_async operation with 0x%x", GetErrorMessage(r), err);
 744         }
 745
 746         if (__isStreamingContent)
 747         {
 748                 err = player_set_buffering_cb(__hPlayer, PlayerBufferingCallBack, (void*)this);
 749                 r = MapExceptionToResult(err);
 750                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] error has been occurred. Failed to perform player_set_buffering_cb with - 0x%x",GetErrorMessage(r), err);
 751         }
 752         return r;
 753 CATCH:
 754         return r;
 755 }
 756
 757 //Basic Functionalities of Tizen::Media::Player
 758
 759 result
 760 _PlayerImpl::Close(void)
 761 {
 762         result r = E_SUCCESS;
 763         int ret = ::PLAYER_ERROR_NONE;
 764
 765         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 766
 767         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 768         r = MapExceptionToResult(ret);
 769         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), ret);
 770         SysTryReturn(NID_MEDIA, (__corePlayerCurState == ::PLAYER_STATE_READY ),
 771                 E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. State is %d", __corePlayerCurState);
 772
 773         ret = player_unprepare(__hPlayer);
 774         r = MapExceptionToResult(ret);
 775         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Failed to perform player_unprepare operation with - 0x%x", GetErrorMessage(r), ret);
 776
 777         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 778         r = MapExceptionToResult(ret);
 779         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_getstate operation with - 0x%x", GetErrorMessage(r), ret);
 780         SysTryCatch(NID_MEDIA, (__corePlayerCurState == ::PLAYER_STATE_IDLE ), r = E_INVALID_STATE, r, "[E_INVALID_STATE] Player state is in an invalid state - %d ",__corePlayerCurState);
 781
 782         //because player_unrealize is sync we can directly make the state as PLAYER_STATE_CLOSED
 783         __currentState = PLAYER_STATE_CLOSED;
 784         __isOpenBuffer = false;
 785         __bufferDataSize = 0;
 786         __isLocalData = true;
 787
 788         if (__isProgressiveContent)
 789         {
 790                 if (__pPlayerProgressiveDownloadEvent)
 791                 {
 792                         __pPlayerProgressiveDownloadEvent->RemoveListener(*__pPlayerProgressiveDownloadListener);
 793                         __pPlayerProgressiveDownloadListener = null;
 794                 }
 795                 ret = player_unset_progressive_download_message_cb(__hPlayer);
 796                 r = MapExceptionToResult(ret);
 797                 if (r != E_SUCCESS)
 798                 {
 799                         SysLogException(NID_MEDIA, r == E_SUCCESS, "Failed to perform player_unset_progressive_download_message_cb operation with 0x%x", ret);
 800                 }
 801                 if (__pPdTimer)
 802                 {
 803                         __pPdTimer->Cancel();
 804                         __isProgressiveTimerStarted = false;
 805                 }
 806                 __isProgressiveContent = false;
 807         }
 808
 809         if (__isStreamingContent)
 810         {
 811                 ret = player_unset_buffering_cb(__hPlayer);
 812                 r = MapExceptionToResult(ret);
 813                 if (r != E_SUCCESS)
 814                 {
 815                         SysLogException(NID_MEDIA, r == E_SUCCESS, "Failed to perform player_unset_buffering_cb operation with 0x%x", ret);
 816                 }
 817         }
 818
 819         __isStreamingContent = false;
 820         return r;
 821
 822 CATCH:
 823         __currentState = PLAYER_STATE_ERROR;
 824         return r;
 825 }
 826
 827 result
 828 _PlayerImpl::Play(void)
 829 {
 830         result r = E_SUCCESS;
 831         int ret = ::PLAYER_ERROR_NONE;
 832
 833         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 834
 835         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 836         r = MapExceptionToResult(ret);
 837         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] player_getstate failed with - 0x%x", GetErrorMessage(r), ret);
 838         SysTryReturn(NID_MEDIA, ((__corePlayerCurState == ::PLAYER_STATE_READY ) || (__corePlayerCurState == ::PLAYER_STATE_PAUSED )),
 839                          E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. State is %d", __corePlayerCurState);
 840
 841         ret = player_start(__hPlayer);
 842         r = MapExceptionToResult(ret);
 843         SysTryReturn(NID_MEDIA,r == E_SUCCESS, r, r, "[%s] Failed to perform player_start operation with - 0x%x", GetErrorMessage(r), ret);
 844
 845         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 846         r = MapExceptionToResult(ret);
 847         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with- 0x%x", GetErrorMessage(r), ret);
 848         SysTryCatch(NID_MEDIA, (__corePlayerCurState == ::PLAYER_STATE_PLAYING),
 849                         r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. State change was not proper returned state is - %d", __corePlayerCurState);
 850         __isStateChangeForVideoCapture = false;
 851
 852         if (__isProgressiveContent)
 853         {
 854                 if ((__pPdTimer != null) && (__isProgressiveTimerStarted == false))
 855                 {
 856                         r = __pPdTimer->Start(_PLAYER_PROGRESSIVE_DOWNLOAD_TIMER_100_MS);
 857                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform Timer start operation.", GetErrorMessage(r));
 858                         SysLog(NID_MEDIA, "Progressive Timer has started");
 859                         __isProgressiveTimerStarted = true;
 860                 }
 861         }
 862         __currentState = PLAYER_STATE_PLAYING;
 863         return r;
 864 CATCH:
 865         __currentState = PLAYER_STATE_ERROR;
 866         return r;
 867 }
 868
 869 result
 870 _PlayerImpl::Stop(void)
 871 {
 872
 873         result r = E_SUCCESS;
 874         int ret = ::PLAYER_ERROR_NONE;
 875
 876         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 877
 878         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 879         r = MapExceptionToResult(ret);
 880         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), ret);
 881         SysTryReturn(NID_MEDIA, ((__corePlayerCurState == ::PLAYER_STATE_PLAYING ) || (__corePlayerCurState == ::PLAYER_STATE_PAUSED )),
 882                            E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. State is %d", __corePlayerCurState);
 883
 884         ret = player_stop(__hPlayer);
 885         r = MapExceptionToResult(ret);
 886         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Failed to perform player_stop operation with - 0x%x", GetErrorMessage(r), ret);
 887
 888         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 889         r = MapExceptionToResult(ret);
 890         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), ret);
 891         SysTryCatch(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_READY,
 892                            r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occured. State change was not proper returned state is %d", __corePlayerCurState);
 893
 894         __currentState = PLAYER_STATE_STOPPED;
 895         return r;
 896
 897 CATCH:
 898         __currentState = PLAYER_STATE_ERROR;
 899         return r;
 900 }
 901
 902 result
 903 _PlayerImpl::Pause(void)
 904 {
 905         result r = E_SUCCESS;
 906         int ret = ::PLAYER_ERROR_NONE;
 907
 908         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 909
 910         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 911         r = MapExceptionToResult(ret);
 912         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), ret);
 913         SysTryReturn(NID_MEDIA, (__corePlayerCurState == ::PLAYER_STATE_PLAYING ), E_INVALID_STATE, E_INVALID_STATE,
 914                                                                                                                                                                                                                                                         "[E_INVALID_STATE] Player state is in an invalid state. State is %d", __corePlayerCurState);
 915
 916         ret = player_pause(__hPlayer);
 917         r = MapExceptionToResult(ret);
 918         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Failed to perform player_pause operation with - 0x%x", GetErrorMessage(r), ret);
 919
 920         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 921         r = MapExceptionToResult(ret);
 922         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), ret);
 923         SysTryCatch(NID_MEDIA, (__corePlayerCurState == ::PLAYER_STATE_PAUSED ),
 924                         r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. State change was not proper returned state is %d", __corePlayerCurState);
 925
 926         __currentState = PLAYER_STATE_PAUSED;
 927         return r;
 928
 929 CATCH:
 930         __currentState = PLAYER_STATE_ERROR;
 931         return r;
 932 }
 933
 934 //Gets of Tizen::Media::Player
 935
 936 PlayerState
 937 _PlayerImpl::GetState(void)
 938 {
 939         result r = E_SUCCESS;
 940         int ret = ::PLAYER_ERROR_NONE;
 941
 942         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 943
 944         if (__currentState == PLAYER_STATE_ERROR)
 945         {
 946                 return PLAYER_STATE_ERROR;
 947         }
 948         ret = player_get_state(__hPlayer, &__corePlayerCurState);
 949         r = MapExceptionToResult(ret);
 950         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), ret);
 951
 952         if (__corePlayerCurState == ::PLAYER_STATE_PAUSED)
 953         {
 954                 __currentState = PLAYER_STATE_PAUSED;
 955                 return PLAYER_STATE_PAUSED;
 956         }
 957         if (__corePlayerCurState == ::PLAYER_STATE_IDLE)
 958         {
 959                 if (__currentState == PLAYER_STATE_INITIALIZED)
 960                 {
 961                         return PLAYER_STATE_INITIALIZED;
 962                 }
 963                 else if (__currentState == PLAYER_STATE_OPENING)
 964                 {
 965                         return PLAYER_STATE_OPENING;
 966                 }
 967                 else if(__currentState == PLAYER_STATE_CLOSED)
 968                 {
 969                         return PLAYER_STATE_CLOSED;
 970                 }
 971         }
 972         return __currentState;
 973 CATCH:
 974         return (PlayerState) - 1;
 975 }
 976
 977 long
 978 _PlayerImpl::GetPosition(void) const
 979 {
 980         int ret = ::PLAYER_ERROR_NONE;
 981         int pos = 0;
 982         result r = E_SUCCESS;
 983
 984         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
 985
 986         ret = player_get_position(__hPlayer, &pos);
 987         r = MapExceptionToResult(ret);
 988         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_position operation with 0x%x", GetErrorMessage(r), ret);
 989
 990         return((long) pos);
 991 CATCH:
 992         return -1;
 993 }
 994
 995 long
 996 _PlayerImpl::GetDuration(void)
 997 {
 998         int err = ::PLAYER_ERROR_NONE;
 999         result r = E_SUCCESS;
1000         int duration = 0;
1001
1002         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1003
1004         SysTryCatch(NID_MEDIA, (
1005                         (__currentState == PLAYER_STATE_PLAYING) ||
1006                         (__currentState == PLAYER_STATE_PAUSED) ||
1007                         (__currentState == PLAYER_STATE_OPENED) ||
1008                         (__currentState == PLAYER_STATE_STOPPED)),
1009                         r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. State is %d", __currentState);
1010
1011         //As a last resort try with palyer_get_duration
1012         err = player_get_duration(__hPlayer, &duration);
1013         r = MapExceptionToResult(err);
1014         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_duration operation with 0x%x", GetErrorMessage(r), err);
1015         SysLog(NID_MEDIA, "Duration is %d after player_get_duration.",duration);
1016         return duration;
1017
1018 CATCH:
1019         return -1;
1020 }
1021
1022 int
1023 _PlayerImpl::GetVolume(void) const
1024 {
1025         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1026         return __currentVolume;
1027 }
1028
1029 bool
1030 _PlayerImpl::IsMute(void) const
1031 {
1032         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1033         return __isMuted;
1034 }
1035
1036 bool
1037 _PlayerImpl::IsLooping(void) const
1038 {
1039         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1040         return __isLooped;
1041 }
1042
1043 result
1044 _PlayerImpl::SeekTo(long msTime)
1045 {
1046         result r = E_SUCCESS;
1047         int ret = ::PLAYER_ERROR_NONE;
1048
1049         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1050
1051         ret = player_get_state(__hPlayer, &__corePlayerCurState);
1052         r = MapExceptionToResult(ret);
1053         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with 0x%x", GetErrorMessage(r), ret);
1054
1055         SysTryReturn(NID_MEDIA, ((__corePlayerCurState == ::PLAYER_STATE_PLAYING ) || (__corePlayerCurState == ::PLAYER_STATE_PAUSED )
1056                         || (__corePlayerCurState == ::PLAYER_STATE_READY )),    E_INVALID_STATE, E_INVALID_STATE
1057                         , "[E_INVALID_STATE] Player state is in an invalid state. Current state is %d", __corePlayerCurState);
1058
1059         SysTryReturn(NID_MEDIA, msTime >= 0, r = E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The msTime is not greater than 0");
1060
1061         ret = player_set_position(__hPlayer, (int)msTime, PlayerSeekCompletedCallBack, (void *)this);
1062         SysTryReturn(NID_MEDIA, ret != ::PLAYER_ERROR_INVALID_PARAMETER, r = E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The msTime is out of range");
1063         r = MapExceptionToResult(ret);
1064         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_position operation with [0x%x]", GetErrorMessage(r), ret);
1065         return r;
1066
1067 CATCH:
1068         return r;
1069 }
1070
1071 result
1072 _PlayerImpl::SeekTo(long msTime, bool accurate)
1073 {
1074         result r = E_SUCCESS;
1075         int ret = ::PLAYER_ERROR_NONE;
1076
1077         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1078
1079         ret = player_get_state(__hPlayer, &__corePlayerCurState);
1080         r = MapExceptionToResult(ret);
1081         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with 0x%x", GetErrorMessage(r), ret);
1082
1083         SysTryReturn(NID_MEDIA, ((__corePlayerCurState == ::PLAYER_STATE_PLAYING ) || (__corePlayerCurState == ::PLAYER_STATE_PAUSED )
1084                         || (__corePlayerCurState == ::PLAYER_STATE_READY )),    E_INVALID_STATE, E_INVALID_STATE
1085                         , "[E_INVALID_STATE] Player state is in an invalid state. Current state is %d", __corePlayerCurState);
1086
1087         SysTryReturn(NID_MEDIA, msTime >= 0, r = E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The msTime is not greater than 0");
1088
1089         ret = player_seek(__hPlayer, (int)msTime, accurate, PlayerSeekCompletedCallBack, (void *)this);
1090         SysTryReturn(NID_MEDIA, ret != ::PLAYER_ERROR_INVALID_PARAMETER, r = E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The msTime is out of range");
1091         r = MapExceptionToResult(ret);
1092         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_seek operation with [0x%x]", GetErrorMessage(r), ret);
1093         return r;
1094
1095 CATCH:
1096         return r;
1097 }
1098
1099 result
1100 _PlayerImpl::SetVolume(int volume)
1101 {
1102         result r = E_SUCCESS;
1103         int ret = ::PLAYER_ERROR_NONE;
1104         float mmVolumeVal = 0;
1105
1106         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1107
1108         SysTryReturn(NID_MEDIA, volume >= MIN_PLAYER_VOLUME && volume <= MAX_PLAYER_VOLUME, E_OUT_OF_RANGE, E_OUT_OF_RANGE,
1109                                                                                                 "[E_OUT_OF_RANGE] Player volume (%d) is out of range.", volume);
1110
1111         mmVolumeVal = (float) volume / 100;
1112
1113         SysLog(NID_MEDIA, "Converted volume is [%f]", mmVolumeVal);
1114         if ((mmVolumeVal < _PLAYER_MIN_VOLUME) || (mmVolumeVal > _PLAYER_MAX_VOLUME))
1115         {
1116                 SysLog(NID_MEDIA, "[E_OUT_OF_RANGE] Player volume(%d) is out of range", volume);
1117                 return E_OUT_OF_RANGE;
1118         }
1119
1120         ret = player_set_volume(__hPlayer, mmVolumeVal, mmVolumeVal);
1121         r = MapExceptionToResult(ret);
1122         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Failed to perform player_set_volume operation with - 0x%x", GetErrorMessage(r), ret);
1123
1124         __currentVolume = volume;
1125         return r;
1126 }
1127
1128 result
1129 _PlayerImpl::SetMute(bool mute)
1130 {
1131         result r = E_SUCCESS;
1132         int ret = ::PLAYER_ERROR_NONE;
1133
1134         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1135
1136         ret = player_set_mute(__hPlayer, mute);
1137         r = MapExceptionToResult(ret);
1138         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Failed to perform player_set_mute operation with 0x%x", GetErrorMessage(r), ret);
1139
1140         __isMuted = mute;
1141         return r;
1142 }
1143
1144 result
1145 _PlayerImpl::SetLooping(bool looping)
1146 {
1147         result r = E_SUCCESS;
1148         int err = ::PLAYER_ERROR_NONE;
1149
1150         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1151
1152         err = player_set_looping(__hPlayer, looping);
1153         r = MapExceptionToResult(err);
1154         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_looping operation with 0x%x", GetErrorMessage(r), err);
1155         __isLooped = looping;
1156 CATCH:
1157         return r;
1158 }
1159
1160
1161 result
1162 _PlayerImpl::SetRenderingBuffer(const Tizen::Graphics::BufferInfo& bufferInfo)
1163 {
1164         result r = E_SUCCESS;
1165         int err = ::PLAYER_ERROR_NONE;
1166         const _BufferInfoImpl* pbufferInfoImpl = NULL;
1167
1168         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1169
1170         PlayerState checkPlayerState = GetState();
1171         SysTryReturn(
1172                 NID_MEDIA, checkPlayerState == PLAYER_STATE_PLAYING || checkPlayerState == PLAYER_STATE_OPENED
1173                 || checkPlayerState == PLAYER_STATE_ENDOFCLIP || checkPlayerState == PLAYER_STATE_STOPPED
1174                 || checkPlayerState == PLAYER_STATE_PAUSED , E_INVALID_STATE, E_INVALID_STATE,
1175                 "[E_INVALID_STATE] Player state is in an invalid state.");
1176
1177         // Set the canvas to subsystem's player
1178         pbufferInfoImpl = _BufferInfoImpl::GetInstance(bufferInfo);
1179         SysTryCatch(NID_MEDIA, pbufferInfoImpl != NULL, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pbufferInfoImpl is not valid");
1180         __orientation = (Orientation)(pbufferInfoImpl->GetOrientation());
1181
1182         // Set an available handler.
1183         if (pbufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION))
1184         {
1185                 __hCanvas = pbufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION);
1186                 __handleType = _BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION;
1187
1188                 _BufferInfoImpl::Rotation rotation = pbufferInfoImpl->GetRotation();
1189                 switch(rotation)
1190                 {
1191                         case _BufferInfoImpl::ROTATION_0:
1192                                 __displayRotation = ::PLAYER_DISPLAY_ROTATION_NONE;
1193                                 break;
1194                         case _BufferInfoImpl::ROTATION_90:
1195                                 __displayRotation = ::PLAYER_DISPLAY_ROTATION_90;
1196                                 break;
1197                         case _BufferInfoImpl::ROTATION_180:
1198                                 __displayRotation = ::PLAYER_DISPLAY_ROTATION_180;
1199                                 break;
1200                         case _BufferInfoImpl::ROTATION_270:
1201                                 __displayRotation = ::PLAYER_DISPLAY_ROTATION_270;
1202                                 break;
1203                 }
1204
1205                 __pUserData = static_cast<Tizen::Ui::Controls::_UserData*>(pbufferInfoImpl->GetUserData(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION));
1206                 if (__pUserData != NULL)
1207                 {
1208                         __displayMode = static_cast<player_display_mode_e>(__pUserData->__userProperties.__displayMode);
1209
1210                         if (__displayMode == ::PLAYER_DISPLAY_MODE_ROI)
1211                         {
1212                                 __displayBounds = __pUserData->__userProperties.__displayBounds;
1213                         }
1214                 }
1215         }
1216         else if (pbufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_VE_SURFACE))
1217         {
1218                 __hCanvas = pbufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_VE_SURFACE);
1219                 __handleType = _BufferInfoImpl::HANDLE_TYPE_VE_SURFACE;
1220         }else
1221         {
1222                 // handle is invalid
1223                 __hCanvas = 0;
1224                 __handleType = _BufferInfoImpl::HANDLE_TYPE_NONE;
1225         }
1226
1227         SysTryCatch(NID_MEDIA, __hCanvas != 0, r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. BufferInfo is not valid.");
1228
1229         if (__handleType != _BufferInfoImpl::HANDLE_TYPE_VE_SURFACE)
1230         {
1231                 SysLog(NID_MEDIA, "PLAYER_DISPLAY_TYPE_X11");
1232                 err = player_set_display(__hPlayer, PLAYER_DISPLAY_TYPE_X11, (player_display_h) __hCanvas);
1233         }else
1234         {
1235                 SysLog(NID_MEDIA, "PLAYER_DISPLAY_TYPE_EVAS");
1236                 err = player_set_display(__hPlayer, PLAYER_DISPLAY_TYPE_EVAS, (player_display_h) __hCanvas);
1237         }
1238
1239         r = MapExceptionToResult(err);
1240         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_display operation with 0x%x", GetErrorMessage(r), err);
1241
1242         err = player_set_display_mode(__hPlayer, __displayMode);
1243         r = MapExceptionToResult(err);
1244         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_display_mode operation with - 0x%x", GetErrorMessage(r), err);
1245
1246         if (__displayMode == ::PLAYER_DISPLAY_MODE_ROI)
1247         {
1248                 err = player_set_x11_display_roi(__hPlayer, __displayBounds.x, __displayBounds.y, __displayBounds.width, __displayBounds.height);
1249                 r = MapExceptionToResult(err);
1250                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_x11_display_roi operation with - 0x%x", GetErrorMessage(r), err);
1251         }
1252
1253         err = player_set_x11_display_rotation(__hPlayer, __displayRotation);
1254         r = MapExceptionToResult(err);
1255         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "%s error has been occurred. Failed to perform player_set_x11_display_rotation operation with - 0x%x", GetErrorMessage(r), err);
1256
1257 CATCH:
1258         return r;
1259 }
1260
1261 result
1262 _PlayerImpl::CaptureVideo(void)
1263 {
1264         result r = E_SUCCESS;
1265         result res = E_SUCCESS;
1266         int ret = ::PLAYER_ERROR_NONE;
1267         bool playbackFlag = false;
1268
1269         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
1270
1271         SysTryReturn(NID_MEDIA, __videoEventCreated == true , E_INVALID_STATE, E_INVALID_STATE,
1272                                 "[E_INVALID_STATE] Player state is in an invalid without the video event listener");
1273
1274         ret = player_get_state(__hPlayer, &__corePlayerCurState);
1275         r = MapExceptionToResult(ret);
1276         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x state - %d", GetErrorMessage(r), ret, __corePlayerCurState);
1277         SysTryReturn(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_READY , E_INVALID_STATE, E_INVALID_STATE,
1278                                 "mmPlayer state is in an invalid state. Current state is %d", __corePlayerCurState);
1279
1280         __isStateChangeForVideoCapture = true;
1281
1282         ret = player_set_volume(__hPlayer,0.0,0.0);
1283         r = MapExceptionToResult(ret);
1284         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_volume operation with - 0x%x", GetErrorMessage(r), ret);
1285
1286         ret = player_start(__hPlayer);
1287         r = MapExceptionToResult(ret);
1288         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_start operation with - 0x%x", GetErrorMessage(r), ret);
1289         playbackFlag = true;
1290
1291         ret = player_get_state(__hPlayer, &__corePlayerCurState);
1292         r = MapExceptionToResult(ret);
1293         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x ", GetErrorMessage(r), ret);
1294         SysTryReturn(NID_MEDIA, (__corePlayerCurState == ::PLAYER_STATE_PLAYING),       E_INVALID_STATE, E_INVALID_STATE,
1295                                 "[E_INVALID_STATE] mmPlayer state is in an invalid state. Current state is %d", __corePlayerCurState);
1296         SysLog(NID_MEDIA, "player_state is %d ", __corePlayerCurState);
1297
1298         ret = player_capture_video(__hPlayer, PlayerVideoCapturedCallBack, (void*)this);
1299         r = MapExceptionToResult(ret);
1300         if (r == E_DISPLAY_RIGHT_VIOLATED)
1301         {
1302                 SysLog(NID_MEDIA, "Failed to perform player_capture_video with E_DISPLAY_RIGHT_VIOLATED");
1303                 r = E_INVALID_OPERATION;
1304         }
1305         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform CaptureVideoInternal operation with 0x%x", GetErrorMessage(r), ret);
1306         return r;
1307 CATCH:
1308         if (playbackFlag)
1309         {
1310                 ret = player_stop(__hPlayer);
1311                 res = MapExceptionToResult(ret);
1312                 SysTryLog(NID_MEDIA,res == E_SUCCESS, "[%s] Failed to perform player_stop operation with - 0x%x ", GetErrorMessage(res), ret);
1313
1314                 res = SetVolume(__currentVolume);
1315                 SysTryLog(NID_MEDIA,res == E_SUCCESS, "[%s] Propagating ", GetErrorMessage(res));
1316
1317                 playbackFlag = false;
1318         }
1319         __isStateChangeForVideoCapture = false;
1320         SysLog(NID_MEDIA, "__isStateChangeForVideoCapture is %d",__isStateChangeForVideoCapture);
1321         return r;
1322 }
1323
1324 //Internal Functions
1325
1326 void
1327 _PlayerImpl::SetSystemBitPerPixel(int PixelFormat)
1328 {
1329         if (PixelFormat == _PLAYER_IMPL_VIDEO_PIXEL_SIZE_RGB565)
1330         {
1331                 __videoPixelFormat = BITMAP_PIXEL_FORMAT_RGB565;
1332         }
1333         else
1334         {
1335                 __videoPixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
1336         }
1337         return;
1338 }
1339
1340 bool
1341 _PlayerImpl::SendEvent(_PlayerEventType eventType, int value)
1342 {
1343         result r = E_SUCCESS;
1344         if (eventType == _PLAYER_EVENT_BUFFERING )
1345         {
1346                 _PlayerStreamingEventArg* pPlayerStreamingEventArg = new (std::nothrow) _PlayerStreamingEventArg;
1347                 if (pPlayerStreamingEventArg == null)
1348                 {
1349                         return false;
1350                 }
1351                 pPlayerStreamingEventArg->SetEventType(_PLAYER_EVENT_BUFFERING);
1352                 pPlayerStreamingEventArg->SetPercent(value);
1353
1354
1355                 r = __pPlayerEvent->FireAsync(*pPlayerStreamingEventArg);
1356                 SysLog(NID_MEDIA, "eventType is %d in _PlayerImpl::SendEvent.", eventType);
1357                 if (IsFailed(r))
1358                 {
1359                         delete pPlayerStreamingEventArg;
1360                         return false;
1361                 }
1362         }
1363         else if (eventType == _PLAYER_EVENT_ERROR )
1364         {
1365                 _PlayerErrorArg* pPlayerErrorArg = new (std::nothrow) _PlayerErrorArg;
1366                 if (pPlayerErrorArg == null)
1367                 {
1368                         return false;
1369                 }
1370                 pPlayerErrorArg->SetEventType(_PLAYER_EVENT_ERROR);
1371                 pPlayerErrorArg->SetError((PlayerErrorReason) value);
1372
1373                 r = __pPlayerEvent->FireAsync(*pPlayerErrorArg);
1374                 SysLog(NID_MEDIA, "eventType is %d in PlayInternaler::SendEvent.", eventType);
1375                 if (IsFailed(r))
1376                 {
1377                         delete pPlayerErrorArg;
1378                         return false;
1379                 }
1380
1381         }
1382         else
1383         {
1384                 _PlayerEventArg* pPlayerEventArg = new (std::nothrow) _PlayerEventArg;
1385                 if (pPlayerEventArg == null)
1386                 {
1387                         return false;
1388                 }
1389                 pPlayerEventArg->SetEventType(eventType);
1390                 pPlayerEventArg->SetResult((result) value);
1391
1392                 r = __pPlayerEvent->FireAsync(*pPlayerEventArg);
1393                 SysLog(NID_MEDIA, "eventType is %d in PlayInternaler::SendEvent.", eventType);
1394                 if (IsFailed(r))
1395                 {
1396                         delete pPlayerEventArg;
1397                         return false;
1398                 }
1399         }
1400         return true;
1401 }
1402
1403 result
1404 _PlayerImpl::SendCapturedVideoFrame(_PlayerVideoEventType event, void* pStream, int streamSize, int width, int height, result r)
1405 {
1406         result result = E_SUCCESS;
1407         Tizen::Graphics::Dimension dimension(0, 0);
1408         byte* pData = null;
1409         _PlayerVideoEventArg* pPlayerVideoEventArg = new (std::nothrow) _PlayerVideoEventArg;
1410         SysTryReturn(NID_MEDIA, pPlayerVideoEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. pPlayerVideoEventArg is null.");
1411
1412         if (event == _PLAYER_VIDEO_EVENT_DECODED)
1413         {
1414                 dimension.width = width;
1415                 dimension.height = height;
1416
1417 //              pData = new (std::nothrow) byte[streamSize];
1418 //              SysTryCatch(NID_MEDIA, pData != null, , r = E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. pData is null.");
1419 //              memcpy(pData, pStream, streamSize);
1420                 pData = (byte *) pStream;
1421
1422                 pPlayerVideoEventArg->SetVideoEventType(_PLAYER_VIDEO_EVENT_DECODED);
1423                 pPlayerVideoEventArg->SetBuffer((byte*) pData);
1424                 pPlayerVideoEventArg->SetSizeOfBuffer((int) streamSize);
1425                 pPlayerVideoEventArg->SetDim(dimension);
1426                 pPlayerVideoEventArg->SetPixelFormat(__videoPixelFormat);
1427                 pPlayerVideoEventArg->SetResult(r);
1428                 result = __pPlayerVideoEvent->FireAsync(*pPlayerVideoEventArg);
1429                 SysTryCatch(NID_MEDIA, result == E_SUCCESS, , result, "[%s] Propagating", GetErrorMessage(r));
1430         }
1431         else if (event == _PLAYER_VIDEO_EVENT_ERROR )
1432         {
1433                 pPlayerVideoEventArg->SetVideoEventType(_PLAYER_VIDEO_EVENT_ERROR);
1434                 pPlayerVideoEventArg->SetResult(r);
1435                 result = __pPlayerVideoEvent->FireAsync(*pPlayerVideoEventArg);
1436                 SysTryCatch(NID_MEDIA, result == E_SUCCESS, , result, "[%s] Propagating", GetErrorMessage(r));
1437         }
1438         else if (event == _PLAYER_VIDEO_EVENT_DECODED_WITHOUT_DATA )
1439         {
1440                 pPlayerVideoEventArg->SetVideoEventType(_PLAYER_VIDEO_EVENT_DECODED_WITHOUT_DATA);
1441                 pPlayerVideoEventArg->SetResult(r);
1442                 result = __pPlayerVideoEvent->FireAsync(*pPlayerVideoEventArg);
1443                 SysTryCatch(NID_MEDIA, result == E_SUCCESS, , result, "[%s] Propagating", GetErrorMessage(r));
1444         }
1445         else
1446         {
1447                 SysTryCatch(NID_MEDIA, false, , E_SYSTEM, "[E_SYSTEM] A system error has been occured.");
1448         }
1449         return E_SUCCESS;
1450 CATCH:
1451         if (pData)
1452         {
1453                 delete[] pData;
1454                 pData = null;
1455         }
1456         if (pPlayerVideoEventArg)
1457         {
1458                 delete pPlayerVideoEventArg;
1459                 pPlayerVideoEventArg = null;
1460         }
1461         return result;
1462 }
1463
1464
1465 //Tizen Calls
1466 result
1467 _PlayerImpl::CreatePlayerAndSetCallBack(void)
1468 {
1469         result r = E_SUCCESS;
1470         int err = ::PLAYER_ERROR_NONE;
1471
1472         err = player_create(&__hPlayer);
1473         r = MapExceptionToResult(err);
1474
1475         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "player_create failed");
1476
1477         err = player_set_completed_cb(__hPlayer, PlayerCompletedCallBack, (void *)this);
1478         SysTryCatch(NID_MEDIA, err == ::PLAYER_ERROR_NONE, r = E_SYSTEM,E_SYSTEM,
1479                                                                 "[E_SYSTEM] A system error has been occurred. Failed to perform player_set_completed_cb operation.");
1480
1481         err = player_set_interrupted_cb(__hPlayer, PlayerInterruptedCallBack, (void *)this);
1482         SysTryCatch(NID_MEDIA, err == ::PLAYER_ERROR_NONE, r = E_SYSTEM, E_SYSTEM,
1483                         "[E_SYSTEM] A system error has been occurred. Failed to perform player_set_interrupted_cb operation.");
1484
1485         err = player_set_error_cb(__hPlayer, PlayerErrorCallBack, (void *)this);
1486         SysTryCatch(NID_MEDIA, err == ::PLAYER_ERROR_NONE, r = E_SYSTEM, E_SYSTEM,
1487                         "[E_SYSTEM] A system error has been occurred. Failed to perform player_set_error_cb operation.");
1488
1489         if (__videoEventCreated)
1490         {
1491                 err = player_set_video_frame_decoded_cb(__hPlayer, PlayerVideoFrameDecodedCallBack, (void *)this);
1492                 SysTryCatch(NID_MEDIA, err == ::PLAYER_ERROR_NONE, r = E_SYSTEM, E_SYSTEM,
1493                                 "[E_SYSTEM] A system error has been occurred. Failed to perform player_video_frame_decoded_cb operation");
1494         }
1495         return E_SUCCESS;
1496 CATCH:
1497         player_destroy(__hPlayer);
1498         __hPlayer = null;
1499         return r;
1500 }
1501
1502 //Tizen->Osp Error Code conversion
1503 PlayerErrorReason
1504 _PlayerImpl::MapExceptionToPlayerErrorReason(int reason)
1505 {
1506         //All the fall through are intentional
1507         switch (reason)
1508         {
1509         //Successful
1510         case ::PLAYER_ERROR_NONE:
1511                 return PLAYER_ERROR_NONE;
1512                 break;
1513
1514         //Out of memory
1515         case ::PLAYER_ERROR_OUT_OF_MEMORY:
1516                 return PLAYER_ERROR_OUT_OF_MEMORY;
1517                 break;
1518
1519         //Invalid parameter
1520         case ::PLAYER_ERROR_INVALID_PARAMETER:
1521         //fall through
1522         //Invalid URI
1523         case ::PLAYER_ERROR_INVALID_URI:
1524         //fall through
1525         //Not supported file format
1526         case ::PLAYER_ERROR_NOT_SUPPORTED_FILE:
1527         //fall through
1528         //No such file or directory
1529         case ::PLAYER_ERROR_NO_SUCH_FILE:
1530                 return PLAYER_ERROR_INVALID_DATA;
1531                 break;
1532
1533         //Streaming connection failed
1534         case ::PLAYER_ERROR_CONNECTION_FAILED:
1535                 return PLAYER_ERROR_CONNECTION_LOST;
1536                 break;
1537
1538         case ::PLAYER_ERROR_DRM_EXPIRED:
1539                 return PLAYER_ERROR_RIGHT_EXPIRED;
1540                 break;
1541
1542         case ::PLAYER_ERROR_DRM_NO_LICENSE:
1543                 return PLAYER_ERROR_RIGHT_NO_LICENSE;
1544                 break;
1545
1546         case ::PLAYER_ERROR_DRM_FUTURE_USE:
1547                 return PLAYER_ERROR_RIGHT_FUTURE_USE;
1548                 break;
1549
1550         case ::PLAYER_ERROR_DRM_NOT_PERMITTED:
1551                 return PLAYER_ERROR_DISPLAY_RIGHT_VIOLATED;
1552                 break;
1553
1554         //Sound policy error
1555         case ::PLAYER_ERROR_SOUND_POLICY:
1556         //fall through
1557         //Video capture failure
1558         case ::PLAYER_ERROR_VIDEO_CAPTURE_FAILED:
1559         //fall through
1560         //Invalid operation
1561         case ::PLAYER_ERROR_INVALID_OPERATION:
1562         //fall through
1563         //Seek operation failure
1564         case ::PLAYER_ERROR_SEEK_FAILED:
1565         //fall through
1566         //Invalid state
1567         case ::PLAYER_ERROR_INVALID_STATE:
1568         //fall through
1569         default:
1570                 return PLAYER_ERROR_DEVICE_FAILED;
1571                 break;
1572         }
1573 }
1574
1575 result
1576 _PlayerImpl::MapExceptionToResult(int reason)
1577 {
1578         //All the fall through are intentional
1579         switch (reason)
1580         {
1581         //Successful
1582         case ::PLAYER_ERROR_NONE:
1583                 return E_SUCCESS;
1584                 break;
1585         //Out of memory
1586         case ::PLAYER_ERROR_OUT_OF_MEMORY:
1587                 return E_OUT_OF_MEMORY;
1588                 break;
1589         //Invalid parameter
1590         case ::PLAYER_ERROR_INVALID_PARAMETER:
1591                 return E_INVALID_ARG;
1592                 break;
1593         //No such file or directory
1594         case ::PLAYER_ERROR_NO_SUCH_FILE:
1595                 return E_FILE_NOT_FOUND;
1596                 break;
1597         //Invalid operation
1598         case ::PLAYER_ERROR_INVALID_OPERATION:
1599                 return E_SYSTEM;
1600                 break;
1601         //Invalid state
1602         case ::PLAYER_ERROR_INVALID_STATE:
1603                 return E_INVALID_STATE;
1604                 break;
1605         //Not supported file format
1606         case ::PLAYER_ERROR_NOT_SUPPORTED_FILE:
1607                 return E_UNSUPPORTED_FORMAT;
1608                 break;
1609         //Invalid URI
1610         case ::PLAYER_ERROR_INVALID_URI:
1611                 return E_FILE_NOT_FOUND;
1612                 break;
1613         //Sound policy error
1614         case ::PLAYER_ERROR_SOUND_POLICY:
1615                 return E_DEVICE_BUSY;
1616                 break;
1617         //Streaming connection failed
1618         case ::PLAYER_ERROR_CONNECTION_FAILED:
1619                 return E_CONNECTION_FAILED;
1620                 break;
1621
1622         //Seek operation failure
1623         case ::PLAYER_ERROR_SEEK_FAILED:
1624                 return E_INVALID_DATA;
1625                 break;
1626         //Video capture failure
1627         case ::PLAYER_ERROR_VIDEO_CAPTURE_FAILED:
1628                 return E_OPERATION_FAILED;
1629                 break;
1630
1631         case ::PLAYER_ERROR_DRM_EXPIRED:
1632                 return E_RIGHT_EXPIRED;
1633                 break;
1634
1635         case ::PLAYER_ERROR_DRM_NO_LICENSE:
1636                 return E_RIGHT_NO_LICENSE;
1637                 break;
1638
1639         case ::PLAYER_ERROR_DRM_FUTURE_USE:
1640                 return E_RIGHT_FUTURE_USE;
1641                 break;
1642
1643         case ::PLAYER_ERROR_DRM_NOT_PERMITTED:
1644                 return E_DISPLAY_RIGHT_VIOLATED;
1645                 break;
1646
1647         default:
1648                 return E_SYSTEM;
1649                 break;
1650         }
1651 }
1652
1653 //Tizen Callbacks
1654 void
1655 _PlayerImpl::PlayerPreparedCallBack(void *pUserData)
1656 {
1657         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
1658         _PlayerImpl *pPlayerImpl = (_PlayerImpl *)pUserData;
1659         std::unique_ptr<ArrayList, _ListPtrUtil::Remover> pList(new (std::nothrow) ArrayList, _ListPtrUtil::remover);
1660         SysTryReturn(NID_MEDIA, pList.get() != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] cannot create memory for ArrayList");
1661         pList->Add(new (std::nothrow) Integer(0));
1662         __pMutex->Acquire();
1663         if (__pPlayerImplList->Contains(*pPlayerImpl) == true)
1664         {
1665                         pPlayerImpl->SendUserEvent(PLAYER_IMPL_OPEN_ASYNC_CB, static_cast<IList*>(pList.release()));
1666         }
1667         __pMutex->Release();
1668 }
1669
1670 void
1671 _PlayerImpl::PlayerCompletedCallBack(void *pUserData)
1672 {
1673         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
1674         _PlayerImpl *pPlayerImpl = (_PlayerImpl *)pUserData;
1675         __pMutex->Acquire();
1676         if (__pPlayerImplList->Contains(*pPlayerImpl) == true)
1677         {
1678                 pPlayerImpl->SendUserEvent(PLAYER_IMPL_EOS_CB, null);
1679         }
1680         __pMutex->Release();
1681 }
1682
1683 void
1684 _PlayerImpl::PlayerInterruptedCallBack(player_interrupted_code_e code, void *pUserData)
1685 {
1686         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
1687         SysLog(NID_MEDIA, "Interrupt callback with code - %d", code);
1688         _PlayerImpl *pPlayerImpl = (_PlayerImpl *)pUserData;
1689         std::unique_ptr<ArrayList, _ListPtrUtil::Remover> pList(new (std::nothrow) ArrayList, _ListPtrUtil::remover);
1690         SysTryReturn(NID_MEDIA, pList.get() != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] cannot create memory for ArrayList");
1691         pList->Add(new (std::nothrow) Integer(code));
1692         __pMutex->Acquire();
1693         if (__pPlayerImplList->Contains(*pPlayerImpl) == true)
1694         {
1695                         pPlayerImpl->SendUserEvent(PLAYER_IMPL_INTERRUPTED_CB, static_cast<IList*>(pList.release()));
1696         }
1697         __pMutex->Release();
1698 }
1699
1700 void
1701 _PlayerImpl::PlayerErrorCallBack(int errorCode, void *pUserData)
1702 {
1703         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
1704         _PlayerImpl *pPlayerImpl = (_PlayerImpl *)pUserData;
1705         std::unique_ptr<ArrayList, _ListPtrUtil::Remover> pList(new (std::nothrow) ArrayList, _ListPtrUtil::remover);
1706         SysTryReturn(NID_MEDIA, pList.get() != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] cannot create memory for ArrayList");
1707         pList->Add(new (std::nothrow) Integer(errorCode));
1708         __pMutex->Acquire();
1709         if (__pPlayerImplList->Contains(*pPlayerImpl) == true)
1710         {
1711                 if (
1712                                 ((errorCode == ::PLAYER_ERROR_DRM_EXPIRED) ||
1713                                 (errorCode == ::PLAYER_ERROR_DRM_NO_LICENSE) ||
1714                                 (errorCode == ::PLAYER_ERROR_DRM_FUTURE_USE) ||
1715                                 (errorCode == ::PLAYER_ERROR_NOT_SUPPORTED_FILE) ||
1716                                 (errorCode == ::PLAYER_ERROR_INVALID_URI) ||
1717                                 (errorCode == ::PLAYER_ERROR_NO_SUCH_FILE) ||
1718                                 (errorCode == ::PLAYER_ERROR_CONNECTION_FAILED) ||
1719                                 (errorCode == ::PLAYER_ERROR_DRM_NOT_PERMITTED))
1720                                 &&
1721                                 (pPlayerImpl->__isAsync == true)
1722                                 &&
1723                                 (pPlayerImpl->__currentState == PLAYER_STATE_OPENING)
1724                                 )
1725                 {
1726                         pPlayerImpl->SendUserEvent(PLAYER_IMPL_OPEN_ASYNC_CB, static_cast<IList*>(pList.release()));
1727                         //pPlayerImpl->HandlePlayerPrepared(errorCode);
1728                 }
1729                 else
1730                 {
1731                         pPlayerImpl->SendUserEvent(PLAYER_IMPL_ERROR_CB, static_cast<IList*>(pList.release()));
1732                         //pPlayerImpl->HandlePlayerError(errorCode);
1733                 }
1734         }
1735         __pMutex->Release();
1736 }
1737
1738 void
1739 _PlayerImpl::PlayerBufferingCallBack(int percent, void *pUserData)
1740 {
1741         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
1742         SysTryReturn(NID_MEDIA, percent >= 0 && percent <= 100, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. percent (%d) is out of range- %d",percent);
1743         _PlayerImpl *pPlayerImpl = (_PlayerImpl *)pUserData;
1744         std::unique_ptr<ArrayList, _ListPtrUtil::Remover> pList(new (std::nothrow) ArrayList, _ListPtrUtil::remover);
1745         SysTryReturn(NID_MEDIA, pList.get() != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] cannot create memory for ArrayList");
1746         pList->Add(new (std::nothrow) Integer(percent));
1747         __pMutex->Acquire();
1748         if (__pPlayerImplList->Contains(*pPlayerImpl) == true)
1749         {
1750                         pPlayerImpl->SendUserEvent(PLAYER_IMPL_BUFFERING_CB, static_cast<IList*>(pList.release()));
1751         }
1752         __pMutex->Release();
1753         //pPlyarImpl->HandlePlayerBuffering();
1754 }
1755
1756 void
1757 _PlayerImpl::PlayerSubtitleUpdatedCallBack(unsigned long duration, char *pText, void *pUserData)
1758 {
1759         SysLog(NID_MEDIA, "PlayerSubtitleUpdatedCallBack has started.");
1760 }
1761
1762 void
1763 _PlayerImpl::PlayerVideoCapturedCallBack(unsigned char *pData, int width, int height, unsigned int size, void *pUserData)
1764 {
1765         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
1766         SysTryReturn(NID_MEDIA, pData, , E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. pData is null.");
1767         SysTryReturn(NID_MEDIA, width && height && size, , E_INVALID_ARG,
1768                                         "[E_INVALID_ARG] Invalid argument is used. hieght = %d or width = %d size = %d", width, height, size);
1769         _PlayerImpl *pPlayerImpl = (_PlayerImpl *)pUserData;
1770         std::unique_ptr<ArrayList, _ListPtrUtil::Remover> pList(new (std::nothrow) ArrayList, _ListPtrUtil::remover);
1771         SysTryReturn(NID_MEDIA, pList.get() != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] cannot create memory for ArrayList");
1772         unsigned char* pStream = new (std::nothrow) unsigned char[size];
1773         SysTryReturn(NID_MEDIA, pStream != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. pData is null.");
1774         memcpy(pStream, pData, size);
1775         pList->Add(new (std::nothrow) Integer((int)pStream));
1776         pList->Add(new (std::nothrow) Integer(width));
1777         pList->Add(new (std::nothrow) Integer(height));
1778         pList->Add(new (std::nothrow) Integer(size));
1779         __pMutex->Acquire();
1780         if (__pPlayerImplList->Contains(*pPlayerImpl) == true)
1781         {
1782                         pPlayerImpl->SendUserEvent(PLAYER_IMPL_CAPTURE_VIDEO_CB, static_cast<IList*>(pList.release()));
1783         }
1784         else
1785         {
1786                 delete[] pStream;
1787         }
1788         __pMutex->Release();
1789
1790         //pPlyarImpl->HandlePlayerVideoCaptured(pData, width , height, size);
1791 }
1792
1793 void
1794 _PlayerImpl::PlayerVideoFrameDecodedCallBack(unsigned char *pData, int width, int height, unsigned int size, void *pUserData)
1795 {
1796         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
1797         SysTryReturn(NID_MEDIA, pData, , E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. pData is null.");
1798         SysTryReturn(NID_MEDIA, width && height && size, , E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. height = %d width = %d size = %d", width, height, size);
1799         _PlayerImpl *pPlayerImpl = (_PlayerImpl *)pUserData;
1800         std::unique_ptr<ArrayList, _ListPtrUtil::Remover> pList(new (std::nothrow) ArrayList, _ListPtrUtil::remover);
1801         SysTryReturn(NID_MEDIA, pList.get() != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] cannot create memory for ArrayList");
1802         unsigned char* pStream = new (std::nothrow) unsigned char[size];
1803         SysTryReturn(NID_MEDIA, pStream != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. pData is null.");
1804         memcpy(pStream, pData, size);
1805         pList->Add(new (std::nothrow) Integer((int)pStream));
1806         pList->Add(new (std::nothrow) Integer(width));
1807         pList->Add(new (std::nothrow) Integer(height));
1808         pList->Add(new (std::nothrow) Integer(size));
1809         __pMutex->Acquire();
1810         if (__pPlayerImplList->Contains(*pPlayerImpl) == true)
1811         {
1812                         pPlayerImpl->SendUserEvent(PLAYER_IMPL_VIDEO_DECODED_CB, static_cast<IList*>(pList.release()));
1813         }
1814         else
1815         {
1816                 delete[] pStream;
1817         }
1818         __pMutex->Release();
1819         //pPlyarImpl->HandlePlayerVideoFrameDecoded(pData, width , height, size);
1820 }
1821 void
1822 _PlayerImpl::PlayerAudioFrameDecodedCallBack(unsigned char *pData, unsigned int size, void *pUserData)
1823 {
1824 }
1825
1826 void
1827 _PlayerImpl::PlayerSeekCompletedCallBack(void *pUserData)
1828 {
1829         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pUserData is null.");
1830         _PlayerImpl *pPlayerImpl = (_PlayerImpl *)pUserData;
1831         __pMutex->Acquire();
1832         if (__pPlayerImplList->Contains(*pPlayerImpl) == true)
1833         {
1834                 pPlayerImpl->SendUserEvent(PLAYER_IMPL_SEEKTO_CB, null);
1835         }
1836         __pMutex->Release();
1837         //pPlyarImpl->HandlePlayerSeekCompleted();
1838 }
1839
1840 //This is used exclusively for End of stream handling
1841 void
1842 _PlayerImpl::OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs)
1843 {
1844         unsigned char *pData = null;
1845         std::unique_ptr<ArrayList, _ListPtrUtil::Remover> pArrayList(null, _ListPtrUtil::remover);
1846         int width = 0;
1847         int height = 0;
1848         int size = 0;
1849                 switch (requestId)
1850                 {
1851                 case PLAYER_IMPL_EOS_CB:
1852                         HandlePlayerCompleted();
1853                         break;
1854                 case PLAYER_IMPL_OPEN_ASYNC_CB:
1855                         SysTryReturn(NID_MEDIA, pArgs, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pArgs is null.");
1856                         pArrayList.reset(dynamic_cast<ArrayList *>(pArgs));
1857                         HandlePlayerPrepared(static_cast<Integer *>(pArrayList->GetAt(0))->value);
1858                         break;
1859                 case PLAYER_IMPL_ERROR_CB:
1860                         SysTryReturn(NID_MEDIA, pArgs, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pArgs is null.");
1861                         pArrayList.reset(dynamic_cast<ArrayList *>(pArgs));
1862                         HandlePlayerError(static_cast<Integer *>(pArrayList->GetAt(0))->value);
1863                         break;
1864                 case PLAYER_IMPL_BUFFERING_CB:
1865                         SysTryReturn(NID_MEDIA, pArgs, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pArgs is null.");
1866                         pArrayList.reset(dynamic_cast<ArrayList *>(pArgs));
1867                         HandlePlayerBuffering(static_cast<Integer *>(pArrayList->GetAt(0))->value);
1868                         break;
1869                 case PLAYER_IMPL_INTERRUPTED_CB:
1870                         SysTryReturn(NID_MEDIA, pArgs, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pArgs is null.");
1871                         pArrayList.reset(dynamic_cast<ArrayList *>(pArgs));
1872                         HandleInterruptedCallback((player_interrupted_code_e)static_cast<Integer *>(pArrayList->GetAt(0))->value);
1873                         break;
1874                 case PLAYER_IMPL_SEEKTO_CB:
1875                         HandlePlayerSeekCompleted();
1876                         break;
1877                 case PLAYER_IMPL_VIDEO_DECODED_CB:
1878                         SysTryReturn(NID_MEDIA, pArgs, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pArgs is null.");
1879                         pArrayList.reset(dynamic_cast<ArrayList *>(pArgs));
1880                         pData = (unsigned char *) static_cast<Integer *>(pArrayList->GetAt(0))->value;
1881                         width = static_cast<Integer *>(pArrayList->GetAt(1))->value;
1882                         height = static_cast<Integer *>(pArrayList->GetAt(2))->value;
1883                         size = static_cast<Integer *>(pArrayList->GetAt(3))->value;
1884                         HandlePlayerVideoFrameDecoded(pData, width, height, size);
1885                         break;
1886                 case PLAYER_IMPL_CAPTURE_VIDEO_CB:
1887                         SysTryReturn(NID_MEDIA, pArgs, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. pArgs is null.");
1888                         pArrayList.reset(dynamic_cast<ArrayList *>(pArgs));
1889                         pData = (unsigned char *) static_cast<Integer *>(pArrayList->GetAt(0))->value;
1890                         width = static_cast<Integer *>(pArrayList->GetAt(1))->value;
1891                         height = static_cast<Integer *>(pArrayList->GetAt(2))->value;
1892                         size = static_cast<Integer *>(pArrayList->GetAt(3))->value;
1893                         HandlePlayerVideoCaptured(pData, width, height, size);
1894                         delete pData;
1895                         break;
1896                 default:
1897                         break;
1898                 }
1899         return;
1900 }
1901
1902 //Tizen Handle Functions
1903
1904 void
1905 _PlayerImpl::HandleInterruptedCallback(player_interrupted_code_e code)
1906 {
1907         switch (code)
1908         {
1909         case PLAYER_INTERRUPTED_COMPLETED:
1910                 // Interrupt completed
1911                 if (!(__interruptFlag))
1912                 {
1913                         HandlePlayerReleased();
1914                 }
1915                 __interruptFlag = false;
1916                 break;
1917         case PLAYER_INTERRUPTED_BY_CALL:
1918                 //Interrupted by incoming call
1919                 //Intentional fall through
1920                 __interruptFlag = true;
1921         case PLAYER_INTERRUPTED_BY_MEDIA:
1922                 //Interrupted by another application
1923                 //Intentional fall through
1924         case PLAYER_INTERRUPTED_BY_RESOURCE_CONFLICT:
1925                 //Interrupted by resource conflict
1926                 //Intentional fall through
1927         case PLAYER_INTERRUPTED_BY_EARJACK_UNPLUG:
1928                 //Interrupted by earjack unplug
1929                 HandlePlayerAudioFocusChanged();
1930                 break;
1931         case PLAYER_INTERRUPTED_BY_EMERGENCY:
1932                 //Interrupted by emergency
1933                 //Intentional fall through
1934         case PLAYER_INTERRUPTED_BY_ALARM:
1935                 //Interrupted by alarm
1936         case PLAYER_INTERRUPTED_BY_RESUMABLE_MEDIA:
1937                 //Interrupted by resumable media
1938                 HandlePlayerInterrupted();
1939                 break;
1940         default:
1941                 SysLog(NID_MEDIA, "Player interrupt is not set.");
1942                 break;
1943         }
1944 }
1945
1946 void
1947 _PlayerImpl::HandlePlayerPrepared(int errorCode)
1948 {
1949         int err = ::PLAYER_ERROR_NONE;
1950         result r = E_SUCCESS;
1951
1952         err = player_get_state(__hPlayer, &__corePlayerCurState);
1953         r = MapExceptionToResult(err);
1954         SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), err);
1955
1956         r = MapExceptionToResult(errorCode);
1957         if (r == E_SUCCESS)
1958         {
1959                 __currentState = PLAYER_STATE_OPENED;
1960         }
1961         else
1962         {
1963                 SysLog(NID_MEDIA, "[%s] Failed to perform player_prepare_async with error code (%d).", GetErrorMessage(r), errorCode);
1964                 __currentState = __preState;
1965         }
1966         SendEvent(_PLAYER_EVENT_OPENED, r);
1967 }
1968
1969 void
1970 _PlayerImpl::HandlePlayerCompleted(void)
1971 {
1972         player_stop(__hPlayer);
1973         __currentState = PLAYER_STATE_ENDOFCLIP;
1974         SendEvent(_PLAYER_EVENT_ENDOFCLIP, 0);
1975 }
1976
1977 void
1978 _PlayerImpl::HandlePlayerError(int errorCode)
1979 {
1980         __currentState = PLAYER_STATE_ERROR;
1981         SendEvent(_PLAYER_EVENT_ERROR, MapExceptionToPlayerErrorReason(errorCode));
1982 }
1983
1984 void
1985 _PlayerImpl::HandlePlayerBuffering(int percent)
1986 {
1987         SendEvent(_PLAYER_EVENT_BUFFERING, percent);
1988 }
1989
1990 void
1991 _PlayerImpl::HandlePlayerVideoCaptured(unsigned char *pData, int width, int height, unsigned int size)
1992 {
1993         SysLog(NID_MEDIA, "width - %d height - %d size - %d", width, height, size);
1994
1995         result r = E_SUCCESS;
1996         std::unique_ptr<byte[]> pOputPtr;
1997         int streamSize = 0;
1998         int err = ::PLAYER_ERROR_NONE;
1999
2000         r = SetVolume(__currentVolume);
2001         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating ", GetErrorMessage(r));
2002
2003         err = player_get_state(__hPlayer, &__corePlayerCurState);
2004         r = MapExceptionToResult(err);
2005         SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), err);
2006
2007         if (__corePlayerCurState == ::PLAYER_STATE_PLAYING && __isStateChangeForVideoCapture == true)
2008         {
2009                 err = player_pause(__hPlayer);
2010                 r = MapExceptionToResult(err);
2011                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_pause operation with - 0x%x", GetErrorMessage(r), err);
2012
2013                 err = player_get_state(__hPlayer, &__corePlayerCurState);
2014                 r = MapExceptionToResult(err);
2015                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with - 0x%x", GetErrorMessage(r), err);
2016
2017                 SysTryCatch(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_PAUSED, r = E_INVALID_STATE, E_INVALID_STATE,
2018                                                                 "[E_INVALID_STATE] Player state is in an invalid state. Current state is %d", __corePlayerCurState);
2019                 __currentState = PLAYER_STATE_PAUSED;
2020         }
2021
2022
2023         SysTryCatch(NID_MEDIA, !((width == 0) || (height == 0)), r = E_INVALID_DATA, E_INVALID_DATA,
2024                         ("[E_INVALID_DATA] A error has been occurred. width or height size is wrong !"));
2025
2026         //send frame to video event listenner
2027         if (pData != null)
2028         {
2029                 MediaPixelFormat srcFmt = MEDIA_PIXEL_FORMAT_RGB888;
2030                 unsigned int frameSize = width*height*4;
2031                 if (frameSize == size)
2032                 {
2033                         srcFmt = MEDIA_PIXEL_FORMAT_BGRA8888;
2034                 }
2035
2036                 if (__videoPixelFormat == BITMAP_PIXEL_FORMAT_RGB565 )
2037                 {
2038                         _ColorConverter cvt;
2039                         // Converter construction
2040                         r = cvt.Construct(srcFmt, width, height,
2041                                                 MEDIA_PIXEL_FORMAT_RGB565LE, width, height);
2042                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2043                         // Convert to output format
2044                         pOputPtr.reset(cvt.ConvertN((byte *)pData, size, streamSize));
2045                         r = GetLastResult();
2046                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2047                 }
2048                 else
2049                 {
2050                         _ColorConverter cvt;
2051                         r = cvt.Construct(srcFmt, width, height,
2052                                                 MEDIA_PIXEL_FORMAT_BGRA8888, width, height);
2053                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2054                         // Convert to output format
2055                         pOputPtr.reset(cvt.ConvertN((byte *)pData, size, streamSize));
2056                         r = GetLastResult();
2057                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2058                 }
2059                 SysTryCatch(NID_MEDIA, pOputPtr.get(), r = E_INVALID_DATA, E_INVALID_DATA, "[E_INVALID_DATA] A error has been occurred. pOputPtr is null.");
2060 //              r = SendCapturedVideoFrame( _PLAYER_VIDEO_EVENT_DECODED, pOputPtr.get(), streamSize, width, height, E_SUCCESS);
2061                 r = SendCapturedVideoFrame( _PLAYER_VIDEO_EVENT_DECODED, static_cast<byte *>(pOputPtr.release()), streamSize, width, height, E_SUCCESS);
2062                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s]Propagating", GetErrorMessage(r));
2063         }
2064         else
2065         {
2066                 r = SendCapturedVideoFrame( _PLAYER_VIDEO_EVENT_DECODED_WITHOUT_DATA, pData, size, width, height, E_SUCCESS);
2067                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s]Propagating", GetErrorMessage(r));
2068         }
2069         return;
2070 CATCH:
2071         __isStateChangeForVideoCapture = false;
2072         SysLog(NID_MEDIA, "__isStateChangeForVideoCapture is %d",__isStateChangeForVideoCapture);
2073         return;
2074 }
2075 void
2076 _PlayerImpl::HandlePlayerVideoFrameDecoded(unsigned char *pData, int width, int height, unsigned int size)
2077 {
2078         SysLog(NID_MEDIA, "width - %d height - %d size - %d", width, height, size);
2079
2080         result r = E_SUCCESS;
2081         if (__isStateChangeForVideoCapture)
2082         {
2083                 // caused by PlayerVideoCapturedCallBack()
2084                 SysLog(NID_MEDIA, "Skip HandlePlayerVideoFrameDecoded()");
2085                 return;
2086         }
2087         if (pData)
2088         {
2089                 r = SendCapturedVideoFrame( _PLAYER_VIDEO_EVENT_DECODED, pData, size, width, height, E_SUCCESS);
2090                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s]Propagating", GetErrorMessage(r));
2091         }
2092         else
2093         {
2094                 SendCapturedVideoFrame( _PLAYER_VIDEO_EVENT_DECODED_WITHOUT_DATA, pData, size, width, height, E_SUCCESS);
2095                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s]Propagating", GetErrorMessage(r));
2096         }
2097
2098 CATCH:
2099         return;
2100 }
2101
2102 void
2103 _PlayerImpl::HandlePlayerSeekCompleted(void)
2104 {
2105         int err = ::PLAYER_ERROR_NONE;
2106         result r = E_SUCCESS;
2107         if (__pPlayerVideoEvent)
2108         {
2109                 err = player_get_state(__hPlayer, &__corePlayerCurState);
2110                 r = MapExceptionToResult(err);
2111                 SysLog(NID_MEDIA, "[%s] Player state is %d", GetErrorMessage(r), __corePlayerCurState);
2112                 if (__corePlayerCurState == ::PLAYER_STATE_PAUSED)
2113                 {
2114                         err = player_capture_video(__hPlayer, PlayerVideoCapturedCallBack, (void*)this);
2115                         r = MapExceptionToResult(err);
2116                         SysTryLog(NID_MEDIA, r == E_SUCCESS,"[%s] Failed to perform player_capture_video operation with 0x%x", GetErrorMessage(r), err);
2117                 }
2118
2119         }
2120         if (r == E_SUCCESS)
2121         {
2122                 SendEvent(_PLAYER_EVENT_SEEKTO, r);
2123         }
2124         else
2125         {
2126                 SendEvent(_PLAYER_EVENT_SEEKTO, E_SYSTEM);
2127         }
2128 }
2129
2130 void
2131 _PlayerImpl::HandlePlayerInterrupted(void)
2132 {
2133         int ret = ::PLAYER_ERROR_NONE;
2134         result r = E_SUCCESS;
2135         ret = player_get_state(__hPlayer, &__corePlayerCurState);
2136         r = MapExceptionToResult(ret);
2137         SysLog(NID_MEDIA, "[%s] Player state is %d", GetErrorMessage(r), __corePlayerCurState);
2138         if (__corePlayerCurState == ::PLAYER_STATE_PAUSED)
2139         {
2140                 SysLog(NID_MEDIA, "Setting player state to be paused");
2141                 __currentState = PLAYER_STATE_PAUSED;
2142                 SendEvent(_PLAYER_EVENT_INTERRUPTED, 0);
2143         }
2144         else if (__corePlayerCurState == ::PLAYER_STATE_IDLE)
2145         {
2146                 SysLog(NID_MEDIA, "Setting player state to be Closed");
2147                 __currentState = PLAYER_STATE_CLOSED;
2148                 __isStreamingContent = false;
2149                 __isOpenBuffer = false;
2150                 __bufferDataSize = 0;
2151
2152                 SendEvent(_PLAYER_EVENT_INTERRUPTED, 0);
2153         }
2154         else
2155         {
2156                 SysLog(NID_MEDIA, "player state is %d so sending error", __currentState);
2157                 ret = player_stop(__hPlayer);
2158                 r = MapExceptionToResult(ret);
2159                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
2160                 ret = player_unprepare(__hPlayer);
2161                 r = MapExceptionToResult(ret);
2162                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
2163                 __isStreamingContent = false;
2164                 __isOpenBuffer = false;
2165                 __bufferDataSize = 0;
2166
2167                 __currentState = PLAYER_STATE_ERROR;
2168                 SendEvent(_PLAYER_EVENT_ERROR, PLAYER_ERROR_DEVICE_FAILED);
2169         }
2170 }
2171
2172 void
2173 _PlayerImpl::HandlePlayerAudioFocusChanged(void)
2174 {
2175         int ret = ::PLAYER_ERROR_NONE;
2176         result r = E_SUCCESS;
2177         ret = player_get_state(__hPlayer, &__corePlayerCurState);
2178         r = MapExceptionToResult(ret);
2179         SysLog(NID_MEDIA, "[%s] Player state is - %d", GetErrorMessage(r), __corePlayerCurState);
2180         if (__corePlayerCurState == ::PLAYER_STATE_PAUSED)
2181         {
2182                 SysLog(NID_MEDIA, "Setting player state to be paused");
2183                 __currentState = PLAYER_STATE_PAUSED;
2184                 SendEvent(_PLAYER_EVENT_AUDIO_FOCUS_CHANGED, 0);
2185         }
2186         else if (__corePlayerCurState == ::PLAYER_STATE_IDLE)
2187         {
2188                 SysLog(NID_MEDIA, "Setting player state to be Closed");
2189                 __currentState = PLAYER_STATE_CLOSED;
2190                 __isStreamingContent = false;
2191                 __isOpenBuffer = false;
2192                 __bufferDataSize = 0;
2193
2194                 SendEvent(_PLAYER_EVENT_AUDIO_FOCUS_CHANGED, 0);
2195         }
2196         else
2197         {
2198                 SysLog(NID_MEDIA, "player state is %d so sending error", __currentState);
2199                 ret = player_stop(__hPlayer);
2200                 r = MapExceptionToResult(ret);
2201                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
2202                 ret = player_unprepare(__hPlayer);
2203                 r = MapExceptionToResult(ret);
2204                 SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
2205                 __isStreamingContent = false;
2206                 __isOpenBuffer = false;
2207                 __bufferDataSize = 0;
2208
2209                 __currentState = PLAYER_STATE_ERROR;
2210                 SendEvent(_PLAYER_EVENT_ERROR, PLAYER_ERROR_DEVICE_FAILED);
2211         }
2212 }
2213
2214 void
2215 _PlayerImpl::HandlePlayerReleased(void)
2216 {
2217         SendEvent(_PLAYER_EVENT_RELEASED, 0);
2218 }
2219
2220 CodecType
2221 _PlayerImpl::ConvertAudioCodec(char *pAudioCodec)
2222 {
2223         if (!String::Compare(String(pAudioCodec), String(L"MPEG 1 Audio, Layer 3 (MP3)")))
2224         {
2225                 return CODEC_MP3;
2226         }
2227         if (!String::Compare(String(pAudioCodec), String(L"MPEG 3 Audio, Layer 3 (MP3)")))
2228         {
2229                 return CODEC_MP3;
2230         }
2231         if (!String::Compare(String(pAudioCodec),String(L"AAC")))
2232         {
2233                 return CODEC_AAC;
2234         }
2235         if (!String::Compare(String(pAudioCodec),String(L"MPEG-4 AAC audio")))
2236         {
2237                 return CODEC_AAC;
2238         }
2239         if (!String::Compare(String(pAudioCodec), String(L"Adaptive Multi Rate (AMR)")))
2240         {
2241                 return CODEC_AMR_NB;
2242         }
2243         if (!String::Compare(String(pAudioCodec), String(L"AMR")))
2244         {
2245                 return CODEC_AMR_NB;
2246         }
2247         if (!String::Compare(String(pAudioCodec), String(L"AMR audio")))
2248         {
2249                 return CODEC_AMR_NB;
2250         }
2251         if (!String::Compare(String(pAudioCodec), String(L"WMA")))
2252         {
2253                 return CODEC_WMA;
2254         }
2255         if (!String::Compare(String(pAudioCodec), String(L"WMA Version 8")))
2256         {
2257                 return CODEC_WMA;
2258         }
2259         if (!String::Compare(String(pAudioCodec), String(L"WMA Version 9")))
2260         {
2261                 return CODEC_WMA;
2262         }
2263         if (!String::Compare(String(pAudioCodec), String(L"Uncompressed 16-bit PCM audio")))
2264         {
2265                 return CODEC_LPCM;
2266         }
2267         if (!String::Compare(String(pAudioCodec), String(L"MIDI")))
2268         {
2269                 return CODEC_MIDI;
2270         }
2271         return CODEC_UNKNOWN;
2272 }
2273
2274 CodecType
2275 _PlayerImpl::ConvertVideoCodec(char *pVideoCodec)
2276 {
2277         if (!String::Compare(String(pVideoCodec),String(L"H263")))
2278         {
2279                 return CODEC_H263;
2280         }
2281         if (!String::Compare(String(pVideoCodec),String(L"H.263")))
2282         {
2283                 return CODEC_H263;
2284         }
2285         if (!String::Compare(String(pVideoCodec), String(L"MPEG-4 video")))
2286         {
2287                 return CODEC_MPEG4;
2288         }
2289         if (!String::Compare(String(pVideoCodec),String(L"H.264 / AVC")))
2290         {
2291                 return CODEC_H264;
2292         }
2293         if (!String::Compare(String(pVideoCodec),String(L"Microsoft Windows Media 9")))
2294         {
2295                 return CODEC_WMV;
2296         }
2297         if (!String::Compare(String(pVideoCodec),String(L"THEORA")))
2298         {
2299                 return CODEC_THEORA;
2300         }
2301         return CODEC_UNKNOWN;
2302 }
2303
2304
2305 MediaStreamInfo*
2306 _PlayerImpl::GetCurrentMediaStreamInfoN()
2307 {
2308         result r = E_SUCCESS;
2309         int err = ::PLAYER_ERROR_NONE;
2310         MediaStreamInfo* pMediaStreamInfo = null;
2311         Tizen::Base::Collection::IList* pAudioList = null;
2312         Tizen::Base::Collection::IList* pVideoList = null;
2313         AudioStreamInfo* pAudioStream = null;
2314         VideoStreamInfo* pVideoStream = null;
2315         result audioStreamException = E_SUCCESS;
2316         result videoStreamException = E_SUCCESS;
2317         String strArtist;
2318         String strTitle;
2319         String strAlbum;
2320         String strGenre;
2321         String strAuthor;
2322         int year = 0;
2323         char *pToCollect = null;
2324         int sizeArtWork = 0;
2325
2326         ByteBuffer* pImageByteBuffer = null;
2327         char* pAudioCodec = null;
2328         char* pVideoCodec = null;
2329
2330         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
2331
2332         err = player_get_state(__hPlayer, &__corePlayerCurState);
2333         r = MapExceptionToResult(err);
2334         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_state operation with 0x%x ", GetErrorMessage(r), err);
2335
2336         SysTryCatch(NID_MEDIA, (__corePlayerCurState == ::PLAYER_STATE_PLAYING) || (__corePlayerCurState == ::PLAYER_STATE_PAUSED) || (__corePlayerCurState == ::PLAYER_STATE_READY) ,
2337                          r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. Current state is %d", __corePlayerCurState);
2338
2339         err = player_get_codec_info(__hPlayer, &pAudioCodec, &pVideoCodec);
2340         SysTryCatch(NID_MEDIA, err == ::PLAYER_ERROR_NONE, r = E_SYSTEM, E_SYSTEM,
2341                                         "[E_SYSTEM] A system error has been occurred. Failed to perform player_get_codec_info operation with 0x%x", err);
2342
2343         pAudioList = new (std::nothrow) Tizen::Base::Collection::ArrayList();
2344         if (pAudioList && String::Compare(String(pAudioCodec),(String(L"unknown"))))
2345         {
2346                 SysLog(NID_MEDIA, "Audio Codec is %s",pAudioCodec);
2347                 AudioChannelType channel = AUDIO_CHANNEL_TYPE_NONE;
2348                 CodecType codec = CODEC_UNKNOWN;
2349                 int bitrate = 0;
2350                 int samplingRate = 0;
2351                 int channels = 0;
2352                 err = player_get_audio_stream_info(__hPlayer, &samplingRate, &channels, &bitrate);
2353                 if (err != ::PLAYER_ERROR_NONE)
2354                 {
2355                         SysTryLog(NID_MEDIA, false, "Failed to perform player_get_audio_stream_info operation with 0x%x", err);
2356                 }
2357                 else
2358                 {
2359                         if (channels == 1 )
2360                         {
2361                                 channel = AUDIO_CHANNEL_TYPE_MONO;
2362                         }
2363                         else if (channels == 2 )
2364                         {
2365                                 channel = AUDIO_CHANNEL_TYPE_STEREO;
2366                         }
2367                         //Reserved for Audio CodecCodec
2368                         codec = ConvertAudioCodec(pAudioCodec);
2369                         SysLog(NID_MEDIA, "Channel is %d , bitrate is %d , sampling rate is %d, Codec is %d.",channel, bitrate, samplingRate, codec);
2370                         pAudioStream = new (std::nothrow) Tizen::Media::AudioStreamInfo(codec, bitrate, samplingRate, channel);
2371                         pAudioList->Add(*pAudioStream);
2372                 }
2373         }
2374         if (pAudioCodec)
2375         {
2376                 free(pAudioCodec);
2377         }
2378
2379         pVideoList = new (std::nothrow) Tizen::Base::Collection::ArrayList();
2380         if (pVideoList && *pVideoCodec != '\0')
2381         {
2382                 CodecType codec = CODEC_UNKNOWN;
2383                 int width = 0;
2384                 int height = 0;
2385                 int bitrate = 0;
2386                 int frameRate = 0;
2387                 SysLog(NID_MEDIA, "Video Codec is %s",pVideoCodec);
2388
2389                 err = player_get_video_size(__hPlayer, &width, &height);
2390                 if (err != ::PLAYER_ERROR_NONE)
2391                 {
2392                         SysTryLog(NID_MEDIA, false, "Failed to perform player_get_video_size operation with 0x%x", err);
2393                 }
2394                 else
2395                 {
2396                         err = player_get_video_stream_info(__hPlayer, &frameRate, &bitrate);
2397                         if (err != ::PLAYER_ERROR_NONE)
2398                         {
2399                                 SysTryLog(NID_MEDIA, false, "Failed to perform player_get_video_stream_info operation with 0x%x", err);
2400                         }
2401                         else
2402                         {
2403                                 codec = ConvertVideoCodec(pVideoCodec);
2404                                 SysLog(NID_MEDIA, "bitrate is %d, frame rate is %d, width is %d, height is %d, Codec is %d ",bitrate, frameRate, width, height, codec);
2405                                 float frameRateFloat = frameRate * 1.0;
2406                                 pVideoStream = new (std::nothrow) Tizen::Media::VideoStreamInfo(codec, width, height, bitrate, frameRateFloat);
2407                                 pVideoList->Add(*pVideoStream);
2408                         }
2409                 }
2410         }
2411         if (pVideoCodec)
2412         {
2413                 free(pVideoCodec);
2414         }
2415
2416         //Obtain the Tag info
2417         err = player_get_content_info(__hPlayer, PLAYER_CONTENT_INFO_ARTIST, &pToCollect);
2418         if (err != ::PLAYER_ERROR_NONE)
2419         {
2420                 SysLog(NID_MEDIA, "Failed to perform player_get_content_info operation with 0x%x", err);
2421         }
2422         else if (pToCollect)
2423         {
2424                 SysTryLog(NID_MEDIA, false, "Artist is %s ", pToCollect);
2425                 strArtist.Append(pToCollect);
2426                 free(pToCollect);
2427                 pToCollect = null;
2428         }
2429         err = player_get_content_info(__hPlayer, PLAYER_CONTENT_INFO_TITLE, &pToCollect);
2430         if (err != ::PLAYER_ERROR_NONE)
2431         {
2432                 SysTryLog(NID_MEDIA, false, "Failed to perform player_get_content_info operation with 0x%x", err);
2433         }
2434         else if (pToCollect)
2435         {
2436                 SysLog(NID_MEDIA, "Title is %s ", pToCollect);
2437                 strTitle.Append(pToCollect);
2438                 free(pToCollect);
2439                 pToCollect = null;
2440         }
2441         err = player_get_content_info(__hPlayer, PLAYER_CONTENT_INFO_ALBUM, &pToCollect);
2442         if (err != ::PLAYER_ERROR_NONE)
2443         {
2444                 SysTryLog(NID_MEDIA, false, "Failed to perform player_get_content_info operation with 0x%x", err);
2445         }
2446         else if (pToCollect)
2447         {
2448                 SysLog(NID_MEDIA, "Album is %s ", pToCollect);
2449                 strAlbum.Append(pToCollect);
2450                 free(pToCollect);
2451                 pToCollect = null;
2452         }
2453         err = player_get_content_info(__hPlayer, PLAYER_CONTENT_INFO_GENRE, &pToCollect);
2454         if (err != ::PLAYER_ERROR_NONE)
2455         {
2456                 SysTryLog(NID_MEDIA, false, "Failed to perform player_get_content_info operation with 0x%x", err);
2457         }
2458         else if (pToCollect)
2459         {
2460                 SysLog(NID_MEDIA, "Genre is %s ", pToCollect);
2461                 strGenre.Append(pToCollect);
2462                 free(pToCollect);
2463                 pToCollect = null;
2464         }
2465         err = player_get_content_info(__hPlayer, PLAYER_CONTENT_INFO_AUTHOR, &pToCollect);
2466         if (err != ::PLAYER_ERROR_NONE)
2467         {
2468                 SysTryLog(NID_MEDIA, false, "Failed to perform player_get_content_info operation with 0x%x", err);
2469         }
2470         else if (pToCollect)
2471         {
2472                 SysLog(NID_MEDIA, "Author is %s ", pToCollect);
2473                 strAuthor.Append(pToCollect);
2474                 free(pToCollect);
2475                 pToCollect = null;
2476         }
2477         err = player_get_content_info(__hPlayer, PLAYER_CONTENT_INFO_YEAR, &pToCollect);
2478         if (err != ::PLAYER_ERROR_NONE)
2479         {
2480                 SysTryLog(NID_MEDIA, false, "Failed to perform player_get_content_info operation with 0x%x", err);
2481         }
2482         else if (pToCollect)
2483         {
2484                 year = atoi(pToCollect);
2485                 SysLog(NID_MEDIA, "Year is %d ", year);
2486                 free(pToCollect);
2487                 pToCollect = null;
2488         }
2489         //Artwork
2490         err = player_get_album_art(__hPlayer, (void **)&pToCollect, &sizeArtWork);
2491         if (err != ::PLAYER_ERROR_NONE)
2492         {
2493                 SysTryLog(NID_MEDIA, false, "Failed to perform player_get_album_art operation with 0x%x", err);
2494         }
2495         else if (pToCollect && sizeArtWork > 0)
2496         {
2497                 SysLog(NID_MEDIA, "there is art work so packing that in bytebuffer size of the ArtWork is %d", sizeArtWork);
2498                 pImageByteBuffer = new (std::nothrow) ByteBuffer;
2499                 if (pImageByteBuffer)
2500                 {
2501                         pImageByteBuffer->Construct(sizeArtWork);
2502                         r = pImageByteBuffer->SetArray((const byte *) pToCollect, 0, sizeArtWork);
2503                         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Failed to perform SetArray operation.", GetErrorMessage(r));
2504                         pImageByteBuffer->Flip();
2505                 }
2506         }
2507
2508         pMediaStreamInfo = new (std::nothrow) MediaStreamInfo(strTitle, strArtist, strAlbum,
2509                                                         strGenre, year, pImageByteBuffer,
2510                                                         pAudioList, pVideoList, audioStreamException, videoStreamException);
2511
2512         SetLastResult(r);
2513         return pMediaStreamInfo;
2514 CATCH:
2515         if (pAudioCodec)
2516         {
2517                 free(pAudioCodec);
2518         }
2519         if (pVideoCodec)
2520         {
2521                 free(pVideoCodec);
2522         }
2523         return null;
2524 }
2525
2526 result
2527 _PlayerImpl::SetAudioStreamType(AudioStreamType type)
2528 {
2529         result r = E_SUCCESS;
2530         int ret = ::PLAYER_ERROR_NONE;
2531
2532         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
2533
2534         SysTryReturn(NID_MEDIA, type != AUDIO_STREAM_TYPE_NO_SOUND      , E_INVALID_ARG, E_INVALID_ARG,
2535                         "Invalid argument is used. AudioStream type = %d", type);
2536
2537         ret = player_set_sound_type(__hPlayer, _AudioManagerConvert::ConvertAudioStreamType2SoundType(type));
2538         r = MapExceptionToResult(ret);
2539         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_sound_type operation with 0x%x", GetErrorMessage(r), ret);
2540
2541         ret = player_set_audio_latency_mode(__hPlayer, ::AUDIO_LATENCY_MODE_HIGH);
2542         r = MapExceptionToResult(ret);
2543         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_audio_latency_mode operation with 0x%x", GetErrorMessage(r), ret);
2544
2545         return E_SUCCESS;
2546 CATCH:
2547         return r;
2548 }
2549
2550 result
2551 _PlayerImpl::OpenUrlAsync(const Tizen::Base::String& url, const Tizen::Base::Collection::IMap* pHeader)
2552 {
2553         result r = E_SUCCESS;
2554
2555         int err = ::PLAYER_ERROR_NONE;
2556         Tizen::Base::String scheme;
2557         bool containsCookie = false;
2558         bool containsUserAgent = false;
2559         std::unique_ptr<const String> pCookieValue;
2560         std::unique_ptr<const String> pUserAgentValue;
2561         std::unique_ptr<char[]> pCookieChars;
2562         std::unique_ptr<char[]> pUsetAgentChars;
2563         std::unique_ptr<char[]> pInputFilePath;
2564
2565         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
2566
2567         err = player_get_state(__hPlayer, &__corePlayerCurState);
2568         r = MapExceptionToResult(err);
2569         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_getstate operation with - 0x%x", GetErrorMessage(r), err);
2570
2571         SysTryReturn(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_IDLE,
2572                  E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. returned state is %d", __corePlayerCurState);
2573
2574         SysTryReturn(NID_MEDIA, !url.IsEmpty(), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. Input url is empty");
2575
2576         if (pHeader)
2577         {
2578                 r = url.SubString(0, 4, scheme);
2579                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, E_UNSUPPORTED_PROTOCOL , E_UNSUPPORTED_PROTOCOL, "[%s] Failed to perform SubString operation", GetErrorMessage(E_UNSUPPORTED_PROTOCOL));
2580                 SysTryReturn(NID_MEDIA, scheme.Equals(L"http", false), E_UNSUPPORTED_PROTOCOL,  E_UNSUPPORTED_PROTOCOL, "[E_UNSUPPORTED_PROTOCOL] error has been occurred.");
2581
2582                 const HashMap *pMapHeader = dynamic_cast<const HashMap *>(pHeader);
2583                 SysTryCatch(NID_MEDIA, pMapHeader != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
2584                 r = pMapHeader->ContainsKey(String(L"Cookie"), containsCookie);
2585                 if (r != E_SUCCESS)
2586                 {
2587                         SysLogException(NID_MEDIA, r, "[%s] Failed to perform HashMap::ContainsKey operation", GetErrorMessage(r));
2588                 }
2589                 else if (containsCookie)
2590                 {
2591                         pCookieValue.reset(dynamic_cast<const String *>(pMapHeader->GetValue(String(L"Cookie"))));
2592                         if (pCookieValue)
2593                         {
2594                                 pCookieChars.reset(_StringConverter::CopyToCharArrayN(*(pCookieValue.get())));
2595                                 if (pCookieChars.get())
2596                                 {
2597                                         err = player_set_streaming_cookie(__hPlayer, pCookieChars.get(),pCookieValue->GetLength());
2598                                         r = MapExceptionToResult(err);
2599                                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_streaming_cookie with - 0x%x", GetErrorMessage(r), err);
2600                                 }
2601                         }
2602                         else
2603                         {
2604                                 r = GetLastResult();
2605                                 SysLogException(NID_MEDIA, r, "[%s]Failed to perform HashMap::GetValue(Cookie) operation.", GetErrorMessage(r));
2606                         }
2607                 }
2608                 r = pMapHeader->ContainsKey(String(L"User-Agent"), containsUserAgent);
2609                 if (r != E_SUCCESS)
2610                 {
2611                         SysLogException(NID_MEDIA, r, "[%s]Failed to perform HashMap::ContainsKey operation.", GetErrorMessage(r));
2612                 }
2613                 else if (containsUserAgent)
2614                 {
2615                         pUserAgentValue.reset(dynamic_cast<const String *>(pMapHeader->GetValue(String(L"User-Agent"))));
2616                         if (pUserAgentValue.get())
2617                         {
2618                                 pUsetAgentChars.reset(_StringConverter::CopyToCharArrayN(*(pUserAgentValue.get())));
2619                                 if (pUsetAgentChars.get())
2620                                 {
2621                                         err = player_set_streaming_user_agent(__hPlayer, pUsetAgentChars.get(),pUserAgentValue->GetLength());
2622                                         r = MapExceptionToResult(err);
2623                                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_streaming_user_agent with - 0x%x", GetErrorMessage(r), err);
2624                                 }
2625                         }
2626                         else
2627                         {
2628                                 r = GetLastResult();
2629                                 SysLogException(NID_MEDIA, r, "[%s] Failed to perform HashMap::GetValue(User-Agent) operation.", GetErrorMessage(r));
2630                         }
2631                 }
2632         }
2633         else
2634         {
2635                 r = url.SubString(0, 4, scheme);
2636                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, E_UNSUPPORTED_PROTOCOL , E_UNSUPPORTED_PROTOCOL, "[%s] Failed to perform SubString operation", GetErrorMessage(E_UNSUPPORTED_PROTOCOL));
2637                 SysTryReturn(NID_MEDIA, (scheme.Equals(L"rtsp", false) || scheme.Equals(L"http", false)), E_UNSUPPORTED_PROTOCOL,       E_UNSUPPORTED_PROTOCOL, "[E_UNSUPPORTED_PROTOCOL] error has been occurred.");
2638         }
2639
2640         pInputFilePath.reset(_StringConverter::CopyToCharArrayN(url));
2641         __isAsync = true;
2642         __isStreamingContent = true;
2643         __preState = __currentState;
2644         __currentState = PLAYER_STATE_OPENING;
2645
2646         r = OpenInputData(std::move(pInputFilePath));
2647         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform OpenInputData operation.", GetErrorMessage(r));
2648
2649         return r;
2650 CATCH:
2651         __isStreamingContent = false;
2652         __currentState = PLAYER_STATE_INITIALIZED;
2653         return r;
2654 }
2655
2656 void
2657 _PlayerImpl::PlayerPdMessageCallBack(player_pd_message_type_e type, void* pUserData)
2658 {
2659         SysTryReturn(NID_MEDIA, pUserData, , E_SYSTEM, "[E_SYSTEM] A system error has been occured. pUserData is NULL!!");
2660         _PlayerImpl *pPlyarImpl = (_PlayerImpl *)pUserData;
2661         pPlyarImpl->HandlePdMessageCallBack(type);
2662 }
2663
2664 result
2665 _PlayerImpl::HandlePdMessageCallBack(player_pd_message_type_e type)
2666 {
2667         result r = E_SUCCESS;
2668         SysTryReturn(NID_MEDIA, __pPlayerProgressiveDownloadEvent != null, E_SYSTEM, E_SYSTEM,
2669                 "[E_SYSTEM] A system error has been occurred. PlayerProgressiveEvent is null.");
2670         _PlayerProgressiveDownloadEventArg* pPlayerProgressiveDownloadEventArg = null;
2671         pPlayerProgressiveDownloadEventArg = new (std::nothrow) _PlayerProgressiveDownloadEventArg;
2672         SysTryCatch(NID_MEDIA, __pPlayerProgressiveDownloadEvent != null , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
2673                 "[E_OUT_OF_MEMORY] Memory allocation failed.");
2674         switch (type)
2675         {
2676         case PLAYER_PD_STARTED:
2677                 SysLog(NID_MEDIA, "Type is set to PLAYER_PD_STARTED");
2678                 pPlayerProgressiveDownloadEventArg->SetEventType(PLAYER_PROGRESSIVE_DOWNLOAD_EVENT_STARTED);
2679                 r = __pPlayerProgressiveDownloadEvent->FireAsync(*pPlayerProgressiveDownloadEventArg);
2680                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2681                 break;
2682         case PLAYER_PD_COMPLETED:
2683                 SysLog(NID_MEDIA, "Type is set to PLAYER_PD_COMPLETED");
2684
2685                 if (__pPdTimer)
2686                 {
2687                         __pPdTimer->Cancel();
2688                         __isProgressiveTimerStarted = false;
2689                 }
2690                 pPlayerProgressiveDownloadEventArg->SetEventType(PLAYER_PROGRESSIVE_DOWNLOAD_EVENT_COMPLETED);
2691                 pPlayerProgressiveDownloadEventArg->SetResult(E_SUCCESS);
2692                 r = __pPlayerProgressiveDownloadEvent->FireAsync(*pPlayerProgressiveDownloadEventArg);
2693                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2694                 break;
2695         default:
2696                 SysLogException(NID_MEDIA, E_SYSTEM, "A system error has been occurred. Never come here player_pd_message is wrong -%d", type);
2697                 break;
2698         }
2699
2700         return E_SUCCESS;
2701 CATCH:
2702         if (pPlayerProgressiveDownloadEventArg)
2703         {
2704                 delete pPlayerProgressiveDownloadEventArg;
2705                 pPlayerProgressiveDownloadEventArg = null;
2706         }
2707         return r;
2708 }
2709
2710 void
2711 _PlayerImpl::OnTimerExpired(Timer& timer)
2712 {
2713         int ret = ::PLAYER_ERROR_NONE;
2714         result r = E_SUCCESS;
2715         unsigned long currentSize = 0;
2716         unsigned long totalSize = 0;
2717         unsigned int callbackSizeQuantum = 0;
2718         _PlayerProgressiveDownloadEventArg* pPlayerProgressiveDownloadEventArg = null;
2719
2720         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
2721
2722         ret = player_get_progressive_download_status(__hPlayer, &currentSize, &totalSize);
2723         r = MapExceptionToResult(ret);
2724         SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_get_progressive_download_status operation with - 0x%x", GetErrorMessage(r), ret);
2725         SysLog(NID_MEDIA, "Current Size is %d Total Size is %d", currentSize, totalSize);
2726         callbackSizeQuantum = (totalSize * __pdCallbackRate ) / 100;
2727         if (__pdNextCallbackSize == 0)
2728         {
2729                 __pdNextCallbackSize = __pdNextCallbackSize + callbackSizeQuantum;
2730         }
2731         if (currentSize >= __pdNextCallbackSize)
2732         {
2733                 pPlayerProgressiveDownloadEventArg = new (std::nothrow) _PlayerProgressiveDownloadEventArg;
2734                 SysTryCatch(NID_MEDIA, __pPlayerProgressiveDownloadEvent != null , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
2735                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
2736                 pPlayerProgressiveDownloadEventArg->SetEventType(PLAYER_PROGRESSIVE_DOWNLOAD_EVENT_IN_PROGRESS);
2737                 pPlayerProgressiveDownloadEventArg->SetDownloadedSize(currentSize);
2738                 pPlayerProgressiveDownloadEventArg->SetTotalSize(totalSize);
2739                 r = __pPlayerProgressiveDownloadEvent->FireAsync(*pPlayerProgressiveDownloadEventArg);
2740                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2741                 __pdNextCallbackSize = __pdNextCallbackSize + callbackSizeQuantum;
2742
2743         }
2744         r = timer.Start(_PLAYER_PROGRESSIVE_DOWNLOAD_TIMER_100_MS);
2745         SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2746         return;
2747 CATCH:
2748         if (pPlayerProgressiveDownloadEventArg)
2749         {
2750                 delete pPlayerProgressiveDownloadEventArg;
2751                 pPlayerProgressiveDownloadEventArg = null;
2752         }
2753 }
2754
2755 result
2756 _PlayerImpl::OpenUrlAsync(Player* pPlayerInstance, const Tizen::Base::String& url, const Tizen::Base::String& filePath, IPlayerProgressiveDownloadListener& listener, const Tizen::Base::Collection::IMap* pHeader)
2757 {
2758         result r = E_SUCCESS;
2759
2760         int err = ::PLAYER_ERROR_NONE;
2761         Tizen::Base::String scheme;
2762         bool containsCookie = false;
2763         bool containsUserAgent = false;
2764         std::unique_ptr<char[]> pProgressiveDownloadPath;
2765         std::unique_ptr<const String> pCookieValue;
2766         std::unique_ptr<const String> pUserAgentValue;
2767         std::unique_ptr<char[]> pCookieChars;
2768         std::unique_ptr<char[]> pUsetAgentChars;
2769         std::unique_ptr<char[]> pInputFilePath;
2770
2771         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
2772
2773         SysTryReturn(NID_MEDIA, pPlayerInstance != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM]A system error has been occurred. Player instance is null.");
2774
2775         pProgressiveDownloadPath.reset(_StringConverter::CopyToCharArrayN(filePath));
2776         SysTryReturn(NID_MEDIA, pProgressiveDownloadPath.get() != null, E_INVALID_ARG, E_INVALID_ARG,
2777                 "[E_INVALID_ARG] Invalid argument is used. progressive download file path is wrong");
2778
2779         err = player_get_state(__hPlayer, &__corePlayerCurState);
2780         r = MapExceptionToResult(err);
2781         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_getstate operation with - 0x%x", GetErrorMessage(r), err);
2782
2783         SysTryReturn(NID_MEDIA, __corePlayerCurState == ::PLAYER_STATE_IDLE,
2784                  E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. returned state is %d", __corePlayerCurState);
2785
2786         SysTryReturn(NID_MEDIA, !url.IsEmpty(), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. Input url is empty");
2787
2788         r = url.SubString(0, 4, scheme);
2789         SysTryReturn(NID_MEDIA, r == E_SUCCESS, E_UNSUPPORTED_PROTOCOL , E_UNSUPPORTED_PROTOCOL, "[%s] Failed to perform SubString operation", GetErrorMessage(E_UNSUPPORTED_PROTOCOL));
2790         SysTryReturn(NID_MEDIA, (scheme.Equals(L"http", false)), E_UNSUPPORTED_PROTOCOL,        E_UNSUPPORTED_PROTOCOL, "[E_UNSUPPORTED_PROTOCOL] error has been occurred.");
2791
2792         pInputFilePath.reset(_StringConverter::CopyToCharArrayN(url));
2793         __isAsync = true;
2794         __isStreamingContent = true;
2795         __isProgressiveContent = true;
2796
2797         // Create progressive download Event
2798         __pPlayerProgressiveDownloadEvent.reset(new (std::nothrow) _PlayerProgressiveDownloadEvent);
2799         SysTryCatch(NID_MEDIA, __pPlayerProgressiveDownloadEvent != null , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
2800                 "[E_OUT_OF_MEMORY] Memory allocation failed.");
2801
2802         __pPdTimer.reset(new (std::nothrow) Timer);
2803         SysTryCatch(NID_MEDIA, __pPdTimer != null , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
2804         __pPdTimer->Construct(*this);
2805         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2806
2807         r = __pPlayerProgressiveDownloadEvent->Construct(pPlayerInstance);
2808         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to construct PlayerProgressiveDownloadEvent.", GetErrorMessage(r));
2809         r = __pPlayerProgressiveDownloadEvent->AddListener(listener);
2810         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform PlayerProgressiveDownloadEvent AddListener operation.", GetErrorMessage(r));
2811
2812         __pPlayerProgressiveDownloadListener = &listener;
2813
2814         err = player_set_progressive_download_message_cb(__hPlayer, PlayerPdMessageCallBack, this);
2815         r = MapExceptionToResult(err);
2816         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_progressive_download_message_cb operation with - 0x%x", GetErrorMessage(r), err);
2817
2818         err = player_set_progressive_download_path(__hPlayer, pProgressiveDownloadPath.get());
2819         r = MapExceptionToResult(err);
2820         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_progressive_download_path operation with - 0x%x", GetErrorMessage(r), err);
2821
2822         if (pHeader)
2823         {
2824                 const HashMap *pMapHeader = dynamic_cast<const HashMap *>(pHeader);
2825                 SysTryCatch(NID_MEDIA, pMapHeader != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
2826                 r = pMapHeader->ContainsKey(String(L"Cookie"), containsCookie);
2827                 if (r != E_SUCCESS)
2828                 {
2829                         SysLogException(NID_MEDIA, r, "[%s] Failed to perform HashMap::ContainsKey operation.", GetErrorMessage(r));
2830                 }
2831                 else if (containsCookie)
2832                 {
2833                         pCookieValue.reset(dynamic_cast<const String *>(pMapHeader->GetValue(String(L"Cookie"))));
2834                         if (pCookieValue.get())
2835                         {
2836                                 pCookieChars.reset(_StringConverter::CopyToCharArrayN(*(pCookieValue.get())));
2837                                 if (pCookieChars.get())
2838                                 {
2839                                         err = player_set_streaming_cookie(__hPlayer, pCookieChars.get(),pCookieValue->GetLength());
2840                                         r = MapExceptionToResult(err);
2841                                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_streaming_cookie with - 0x%x", GetErrorMessage(r), err);
2842                                 }
2843                         }
2844                         else
2845                         {
2846                                 r = GetLastResult();
2847                                 SysLogException(NID_MEDIA, r, "[%s] Failed to perform HashMap::GetValue(Cookie) operation.", GetErrorMessage(r));
2848                         }
2849                 }
2850                 r = pMapHeader->ContainsKey(String(L"User-Agent"), containsUserAgent);
2851                 if (r != E_SUCCESS)
2852                 {
2853                         SysLogException(NID_MEDIA, r, "[%s] Failed to perform HashMap::ContainsKey operation.", GetErrorMessage(r));
2854                 }
2855                 else if (containsUserAgent)
2856                 {
2857                         pUserAgentValue.reset(dynamic_cast<const String *>(pMapHeader->GetValue(String(L"User-Agent"))));
2858                         if (pUserAgentValue.get())
2859                         {
2860                                 pUsetAgentChars.reset(_StringConverter::CopyToCharArrayN(*(pUserAgentValue.get())));
2861                                 if (pUsetAgentChars.get())
2862                                 {
2863                                         err = player_set_streaming_user_agent(__hPlayer, pUsetAgentChars.get(),pUserAgentValue->GetLength());
2864                                         r = MapExceptionToResult(err);
2865                                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform player_set_streaming_user_agent with - 0x%x", GetErrorMessage(r), err);
2866                                 }
2867                         }
2868                         else
2869                         {
2870                                 r = GetLastResult();
2871                                 SysLogException(NID_MEDIA, r, "[%s]HashMap::GetValue(User-Agent) Failed", GetErrorMessage(r));
2872                         }
2873                 }
2874         }
2875         __preState = __currentState;
2876         __currentState = PLAYER_STATE_OPENING;
2877
2878         r = OpenInputData(std::move(pInputFilePath));
2879         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform OpenInputData operation.", GetErrorMessage(r));
2880
2881         return r;
2882 CATCH:
2883         __isStreamingContent = false;
2884         __currentState = PLAYER_STATE_INITIALIZED;
2885         return r;
2886 }
2887
2888 void
2889 _PlayerImpl::SetProgressiveDownloadIntervalByPercent(int percent)
2890 {
2891         if((0 <= percent) && (percent <= 100))
2892         {
2893                 __pdCallbackRate = percent;
2894         }
2895 }
2896
2897 int
2898 _PlayerImpl::GetHttpStreamingDownloadProgress(void) const
2899 {
2900         int returnValue = 0;
2901         int startValue = 0;
2902         int err = ::PLAYER_ERROR_NONE;
2903         player_state_e corePlayerCurState;
2904         result r = E_SUCCESS;
2905
2906         SysAssertf(__hPlayer !=  null, "Not yet constructed! Construct() should be called before use");
2907
2908         SysTryReturn(NID_MEDIA, __isStreamingContent == true, -1, E_INVALID_OPERATION, "[%s] Failed to perform this operation. This method dose not work on local content.", GetErrorMessage(E_INVALID_OPERATION));
2909
2910         err = player_get_state(__hPlayer, &corePlayerCurState);
2911         r = MapExceptionToResult(err);
2912         SysTryReturn(NID_MEDIA, r == E_SUCCESS, -1, r, "[%s] Failed to perform player_getstate operation with - 0x%x", GetErrorMessage(r), err);
2913
2914         SysTryReturn(NID_MEDIA, (corePlayerCurState == ::PLAYER_STATE_PLAYING) || (corePlayerCurState == ::PLAYER_STATE_PAUSED) ,
2915                                                                    -1, E_INVALID_STATE, "[E_INVALID_STATE] Player state is in an invalid state. Current state is %d", corePlayerCurState);
2916
2917         err =  player_get_streaming_download_progress(__hPlayer, &startValue, &returnValue);
2918         r = MapExceptionToResult(err);
2919         SysTryReturn(NID_MEDIA, r == E_SUCCESS, -1, r, "[%s] Failed to perform player_get_streaming_download_progress operation with - 0x%x", GetErrorMessage(r), err);
2920
2921         return returnValue;
2922 }
2923
2924
2925 };
2926 };  // Tizen::Media
2927