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