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