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