1 /* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18 #include "pv_frame_metadata_utility.h" 19 #include "pv_player_interface.h" 20 #include "pv_player_factory.h" 21 #include "pv_frame_metadata_mio_video.h" 22 #include "pv_media_output_node_factory.h" 23 #include "pv_mime_string_utils.h" 24 #include "oscl_mem_mempool.h" 25 26 #define PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT 1 27 #define PVFMUTIL_ERRORHANDLINGTIMEOUT_VALUE 30 28 29 #define PVFMUTIL_TIMERID_FRAMEREADYTIMEOUT 2 30 #define PVFMUTIL_FRAMEREADYTIMEOUT_VALUE_DEFAULT 30 31 32 static const char PVFMUTIL_FRAMERETRIEVAL_TIMEOUT_KEY[] = "x-pvmf/fmu/timeout-frameretrieval-in-seconds;valtype=uint32"; 33 34 #define PVFMUTIL_VIDEOFRAMEBUFFER_WIDTH 320 35 #define PVFMUTIL_VIDEOFRAMEBUFFER_HEIGHT 240 36 #define PVFMUTIL_VIDEOFRAMEBUFFER_MAXSIZE PVFMUTIL_VIDEOFRAMEBUFFER_WIDTH * PVFMUTIL_VIDEOFRAMEBUFFER_HEIGHT * 3 37 #define PVFMUTIL_VIDEOFRAMEBUFFER_MEMPOOL_BUFFERSIZE PVFMUTIL_VIDEOFRAMEBUFFER_MAXSIZE*2 38 39 PVFrameAndMetadataUtility* PVFrameAndMetadataUtility::New(char *aOutputFormatMIMEType, PVCommandStatusObserver *aCmdObserver, 40 PVErrorEventObserver *aErrorObserver, PVInformationalEventObserver *aInfoObserver, bool aHwAccelerated) 41 { 42 if (aOutputFormatMIMEType == NULL || aCmdObserver == NULL || 43 aErrorObserver == NULL || aInfoObserver == NULL) 44 { 45 OSCL_LEAVE(OsclErrArgument); 46 return NULL; 47 } 48 49 PVFrameAndMetadataUtility* util = NULL; 50 util = OSCL_NEW(PVFrameAndMetadataUtility, (aHwAccelerated)); 51 if (util) 52 { 53 util->Construct(aOutputFormatMIMEType, 54 aCmdObserver, 55 aErrorObserver, 56 aInfoObserver); 57 } 58 59 return util; 60 } 61 62 63 PVFrameAndMetadataUtility::~PVFrameAndMetadataUtility() 64 { 65 Cancel(); 66 67 if (!iPendingCmds.empty()) 68 { 69 iPendingCmds.pop(); 70 } 71 72 if (iPlayer != NULL) 73 { 74 PVPlayerFactory::DeletePlayer(iPlayer); 75 iPlayer = NULL; 76 } 77 78 if (iVideoFrameBufferMemPool) 79 { 80 iVideoFrameBufferMemPool->removeRef(); 81 iVideoFrameBufferMemPool = NULL; 82 } 83 84 // Shutdown and destroy the timer 85 if (iTimeoutTimer) 86 { 87 iTimeoutTimer->Clear(); 88 } 89 // Memoryleak 90 iVideoDataSink.SetDataSinkNode(NULL); 91 if (iVideoNode) 92 { 93 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoNode); 94 iVideoNode = NULL; 95 } 96 if (iVideoMIO) 97 { 98 OSCL_DELETE(iVideoMIO); 99 iVideoMIO = NULL; 100 } 101 // Cleanup the audio data sink 102 iAudioDataSink.SetDataSinkNode(NULL); 103 if (iAudioNode) 104 { 105 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioNode); 106 iAudioNode = NULL; 107 } 108 if (iAudioMIO) 109 { 110 OSCL_DELETE(iAudioMIO); 111 iAudioMIO = NULL; 112 } 113 // Remove the data source handle 114 iDataSource = NULL; 115 116 OSCL_DELETE(iTimeoutTimer); 117 } 118 119 PVMFStatus PVFrameAndMetadataUtility::SetMode(uint32 aMode) 120 { 121 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::SetMode() = %d", aMode)); 122 // Mode can have values of only 1, 2 or 3. 123 if ((aMode != PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_ONLY) && 124 (aMode != PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_AND_THUMBNAIL) && 125 (aMode != PV_FRAME_METADATA_INTERFACE_MODE_ALL)) 126 { 127 return PVMFErrArgument; 128 } 129 130 131 #ifdef SUPPORT_PARSER_LEVEL_METADATA_EXTRACTION_ONLY 132 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::SetMode in NOT supported in current utility(), Value(= %d) is ignored and default(1) is used", aMode)); 133 iMode = PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_ONLY; 134 return PVMFSuccess; 135 #else 136 if (iState == PVFM_UTILITY_STATE_IDLE) 137 { 138 iMode = aMode; 139 return PVMFSuccess; 140 } 141 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::SetMode() - Invalid State")); 142 return PVMFErrInvalidState; 143 #endif 144 } 145 146 PVCommandId PVFrameAndMetadataUtility::QueryUUID(const PvmfMimeString& aMimeType, Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids, 147 bool aExactUuidsOnly, const OsclAny* aContextData) 148 { 149 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::QueryUUID()")); 150 151 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 152 paramvec.reserve(3); 153 paramvec.clear(); 154 PVFMUtilityCommandParamUnion param; 155 param.pOsclAny_value = (OsclAny*) & aMimeType; 156 paramvec.push_back(param); 157 param.pOsclAny_value = (OsclAny*) & aUuids; 158 paramvec.push_back(param); 159 param.bool_value = aExactUuidsOnly; 160 paramvec.push_back(param); 161 return AddCommandToQueue(PVFM_UTILITY_COMMAND_QUERY_UUID, (OsclAny*)aContextData, ¶mvec); 162 } 163 164 165 PVCommandId PVFrameAndMetadataUtility::QueryInterface(const PVUuid& aUuid, PVInterface*& aInterfacePtr, const OsclAny* aContextData) 166 { 167 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::QueryInterface()")); 168 169 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 170 paramvec.reserve(1); 171 paramvec.clear(); 172 PVFMUtilityCommandParamUnion param; 173 param.pOsclAny_value = (OsclAny*) & aInterfacePtr; 174 paramvec.push_back(param); 175 return AddCommandToQueue(PVFM_UTILITY_COMMAND_QUERY_INTERFACE, (OsclAny*)aContextData, ¶mvec, &aUuid); 176 } 177 178 179 PVCommandId PVFrameAndMetadataUtility::CancelAllCommands(const OsclAny* aContextData) 180 { 181 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::CancelAllCommands()")); 182 183 return AddCommandToQueue(PVFM_UTILITY_COMMAND_CANCEL_ALL_COMMANDS, (OsclAny*)aContextData); 184 } 185 186 187 PVCommandId PVFrameAndMetadataUtility::GetState(PVFrameAndMetadataState& aState, const OsclAny* aContextData) 188 { 189 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::GetState()")); 190 191 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 192 paramvec.reserve(1); 193 paramvec.clear(); 194 PVFMUtilityCommandParamUnion param; 195 param.pOsclAny_value = (OsclAny*) & aState; 196 paramvec.push_back(param); 197 return AddCommandToQueue(PVFM_UTILITY_COMMAND_GET_STATE, (OsclAny*)aContextData, ¶mvec); 198 } 199 200 201 PVMFStatus PVFrameAndMetadataUtility::GetStateSync(PVFrameAndMetadataState& aState) 202 { 203 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::GetStateSync()")); 204 205 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 206 paramvec.reserve(1); 207 paramvec.clear(); 208 PVFMUtilityCommandParamUnion param; 209 param.pOsclAny_value = (OsclAny*) & aState; 210 paramvec.push_back(param); 211 PVFMUtilityCommand cmd(PVFM_UTILITY_COMMAND_GET_STATE, -1, NULL, ¶mvec); 212 return DoGetState(cmd, true); 213 } 214 215 216 PVCommandId PVFrameAndMetadataUtility::AddDataSource(PVPlayerDataSource& aDataSource, const OsclAny* aContextData) 217 { 218 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::AddDataSource()")); 219 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 220 (0, "PVFrameAndMetadataUtility::AddDataSource called Tick=%d", OsclTickCount::TickCount())); 221 222 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 223 paramvec.reserve(1); 224 paramvec.clear(); 225 PVFMUtilityCommandParamUnion param; 226 param.pOsclAny_value = (OsclAny*) & aDataSource; 227 paramvec.push_back(param); 228 return AddCommandToQueue(PVFM_UTILITY_COMMAND_ADD_DATA_SOURCE, (OsclAny*)aContextData, ¶mvec); 229 } 230 231 232 PVCommandId PVFrameAndMetadataUtility::GetMetadataKeys(PVPMetadataList& aKeyList, int32 aStartingIndex, int32 aMaxEntries, 233 char* aQueryKey, const OsclAny* aContextData) 234 { 235 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::GetMetadataKeys()")); 236 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 237 (0, "PVFrameAndMetadataUtility::GetMetadataKeys called Tick=%d", OsclTickCount::TickCount())); 238 239 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 240 paramvec.reserve(4); 241 paramvec.clear(); 242 PVFMUtilityCommandParamUnion param; 243 param.pOsclAny_value = (OsclAny*) & aKeyList; 244 paramvec.push_back(param); 245 param.int32_value = aStartingIndex; 246 paramvec.push_back(param); 247 param.int32_value = aMaxEntries; 248 paramvec.push_back(param); 249 param.pChar_value = aQueryKey; 250 paramvec.push_back(param); 251 return AddCommandToQueue(PVFM_UTILITY_COMMAND_GET_METADATA_KEYS, (OsclAny*)aContextData, ¶mvec); 252 } 253 254 255 PVCommandId PVFrameAndMetadataUtility::GetMetadataValues(PVPMetadataList& aKeyList, int32 aStartingValueIndex, int32 aMaxValueEntries, 256 int32& aNumAvailableValueEntries, Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, 257 const OsclAny* aContextData) 258 { 259 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::GetMetadataValues()")); 260 261 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 262 (0, "PVFrameAndMetadataUtility::GetMetadataValues called Tick=%d", OsclTickCount::TickCount())); 263 264 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 265 paramvec.reserve(5); 266 paramvec.clear(); 267 PVFMUtilityCommandParamUnion param; 268 param.pOsclAny_value = (OsclAny*) & aKeyList; 269 paramvec.push_back(param); 270 param.int32_value = aStartingValueIndex; 271 paramvec.push_back(param); 272 param.int32_value = aMaxValueEntries; 273 paramvec.push_back(param); 274 param.pOsclAny_value = (OsclAny*) & aNumAvailableValueEntries; 275 paramvec.push_back(param); 276 param.pOsclAny_value = (OsclAny*) & aValueList; 277 paramvec.push_back(param); 278 return AddCommandToQueue(PVFM_UTILITY_COMMAND_GET_METADATA_VALUES, (OsclAny*)aContextData, ¶mvec); 279 } 280 281 void PVFrameAndMetadataUtility::setParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int32 aNumElements, PvmiKvp* &aRetKVP) 282 { 283 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::SetParametersSync()")); 284 OSCL_UNUSED_ARG(aSession); 285 286 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 287 paramvec.reserve(3); 288 paramvec.clear(); 289 PVFMUtilityCommandParamUnion param; 290 param.pOsclAny_value = (OsclAny*)aParameters; 291 paramvec.push_back(param); 292 param.int32_value = (int32)aNumElements; 293 paramvec.push_back(param); 294 param.pOsclAny_value = (OsclAny*) & aRetKVP; 295 paramvec.push_back(param); 296 297 PVFMUtilityCommand cmd(PVFM_UTILITY_COMMAND_SET_PARAMETERS, -1, NULL, ¶mvec); 298 299 DoCapConfigSetParameters(cmd, true); 300 } 301 302 303 PVCommandId PVFrameAndMetadataUtility::GetFrame(PVFrameSelector& aFrameInfo, uint8* aProvidedFrameBuffer, 304 uint32& aBufferSize, PVFrameBufferProperty& aBufferProp, const OsclAny* aContextData) 305 { 306 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::GetFrame() User provided buffer version")); 307 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 308 (0, "PVFrameAndMetadataUtility::GetFrame called Tick=%d", OsclTickCount::TickCount())); 309 310 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 311 paramvec.reserve(3); 312 paramvec.clear(); 313 PVFMUtilityCommandParamUnion param; 314 param.pOsclAny_value = (OsclAny*) & aFrameInfo; 315 paramvec.push_back(param); 316 param.pUint8_value = aProvidedFrameBuffer; 317 paramvec.push_back(param); 318 param.pUint32_value = &aBufferSize; 319 paramvec.push_back(param); 320 param.pOsclAny_value = (OsclAny*) & aBufferProp; 321 paramvec.push_back(param); 322 return AddCommandToQueue(PVFM_UTILITY_COMMAND_GET_FRAME_USER_BUFFER, (OsclAny*)aContextData, ¶mvec); 323 } 324 325 326 PVCommandId PVFrameAndMetadataUtility::GetFrame(PVFrameSelector& aFrameInfo, uint8** aFrameBufferPtr, 327 uint32& aBufferSize, PVFrameBufferProperty& aBufferProp, const OsclAny* aContextData) 328 { 329 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::GetFrame() Utility provided buffer version")); 330 331 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 332 paramvec.reserve(4); 333 paramvec.clear(); 334 PVFMUtilityCommandParamUnion param; 335 param.pOsclAny_value = (OsclAny*) & aFrameInfo; 336 paramvec.push_back(param); 337 param.pOsclAny_value = (OsclAny*)aFrameBufferPtr; 338 paramvec.push_back(param); 339 param.pUint32_value = &aBufferSize; 340 paramvec.push_back(param); 341 param.pOsclAny_value = (OsclAny*) & aBufferProp; 342 paramvec.push_back(param); 343 return AddCommandToQueue(PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER, (OsclAny*)aContextData, ¶mvec); 344 } 345 346 347 PVCommandId PVFrameAndMetadataUtility::ReturnBuffer(uint8* aFrameBufferPtr, const OsclAny* aContextData) 348 { 349 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::ReturnBuffer()")); 350 351 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 352 paramvec.reserve(1); 353 paramvec.clear(); 354 PVFMUtilityCommandParamUnion param; 355 param.pUint8_value = aFrameBufferPtr; 356 paramvec.push_back(param); 357 return AddCommandToQueue(PVFM_UTILITY_COMMAND_RETURN_BUFFER, (OsclAny*)aContextData, ¶mvec); 358 } 359 360 361 PVCommandId PVFrameAndMetadataUtility::RemoveDataSource(PVPlayerDataSource& aDataSource, const OsclAny* aContextData) 362 { 363 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::RemoveDataSource()")); 364 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 365 (0, "PVFrameAndMetadataUtility::RemoveDataSource called Tick=%d", OsclTickCount::TickCount())); 366 367 Oscl_Vector<PVFMUtilityCommandParamUnion, OsclMemAllocator> paramvec; 368 paramvec.reserve(1); 369 paramvec.clear(); 370 PVFMUtilityCommandParamUnion param; 371 param.pOsclAny_value = (OsclAny*) & aDataSource; 372 paramvec.push_back(param); 373 return AddCommandToQueue(PVFM_UTILITY_COMMAND_REMOVE_DATA_SOURCE, (OsclAny*)aContextData, ¶mvec); 374 } 375 376 377 PVFrameAndMetadataUtility::PVFrameAndMetadataUtility(bool aHwAccelerated) : 378 iHwAccelerated(aHwAccelerated), 379 OsclTimerObject(OsclActiveObject::EPriorityNominal, "PVFrameMetadataUtility"), 380 iCommandId(0), 381 iState(PVFM_UTILITY_STATE_IDLE), 382 iCmdStatusObserver(NULL), 383 iErrorEventObserver(NULL), 384 iInfoEventObserver(NULL), 385 iPlayer(NULL), 386 iOutputFormatType(PVMF_MIME_FORMAT_UNKNOWN), 387 iDataSource(NULL), 388 iVideoNode(NULL), 389 iVideoMIO(NULL), 390 iAudioNode(NULL), 391 iAudioMIO(NULL), 392 iLogger(NULL), 393 iErrorHandlingInUtilityAO(false), 394 iVideoFrameBufferMemPool(NULL), 395 iCurrentVideoFrameBuffer(NULL), 396 iVideoFrameBufferSize(NULL), 397 iVideoFrameSelector(NULL), 398 iVideoFrameBufferProp(NULL), 399 iFrameReceived(false), 400 iPlayerStartCompleted(false), 401 iAPICmdStatus(PVMFSuccess), 402 iAPICmdErrMsg(NULL), 403 iTimeoutTimer(NULL), 404 iErrorHandlingWaitTime(PVFMUTIL_ERRORHANDLINGTIMEOUT_VALUE), 405 iFrameReadyWaitTime(PVFMUTIL_FRAMEREADYTIMEOUT_VALUE_DEFAULT), 406 iThumbnailWidth(PVFMUTIL_VIDEOFRAMEBUFFER_WIDTH), 407 iThumbnailHeight(PVFMUTIL_VIDEOFRAMEBUFFER_HEIGHT) 408 { 409 //define this Macro in mmp build file only if mode 1 of FrMU is required. 410 #ifdef SUPPORT_PARSER_LEVEL_METADATA_EXTRACTION_ONLY 411 iMode = PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_ONLY; 412 #else 413 iMode = PV_FRAME_METADATA_INTERFACE_MODE_ALL; 414 #endif 415 iPlayerCapConfigIF = NULL; 416 iPlayerCapConfigIFPVI = NULL; 417 } 418 419 420 void PVFrameAndMetadataUtility::Construct(char *aOutputFormatMIMEType, PVCommandStatusObserver *aCmdObserver, 421 PVErrorEventObserver *aErrorObserver, PVInformationalEventObserver *aInfoObserver) 422 { 423 OSCL_ASSERT(aOutputFormatMIMEType != NULL); 424 425 iOutputFormatType = aOutputFormatMIMEType; 426 427 if (iOutputFormatType == PVMF_MIME_FORMAT_UNKNOWN) 428 { 429 OSCL_LEAVE(OsclErrArgument); 430 return; 431 } 432 iCmdStatusObserver = aCmdObserver; 433 iErrorEventObserver = aErrorObserver; 434 iInfoEventObserver = aInfoObserver; 435 436 // Create the player instance 437 iPlayer = PVPlayerFactory::CreatePlayer(this, this, this, iHwAccelerated); 438 OSCL_ASSERT(iPlayer != NULL); 439 440 // Allocate memory for vectors 441 // If a leave occurs, let it bubble up 442 iCurrentCmd.reserve(1); 443 iCurrentCmd.clear(); 444 iCmdToCancel.reserve(1); 445 iCmdToCancel.clear(); 446 iPendingCmds.reserve(4); 447 448 // Add this AO to the scheduler 449 AddToScheduler(); 450 451 // Retrieve the logger object 452 iLogger = PVLogger::GetLoggerObject("PVFrameAndMetadataUtility"); 453 iPerfLogger = PVLogger::GetLoggerObject("fmudiagnostics"); 454 455 456 // Initialize the OSCL timer for timeouts 457 iTimeoutTimer = OSCL_NEW(OsclTimer<OsclMemAllocator>, ("pvfmutility_timeout")); 458 iTimeoutTimer->SetObserver(this); 459 iTimeoutTimer->SetFrequency(1); // 1 sec resolution 460 } 461 462 463 void PVFrameAndMetadataUtility::Run() 464 { 465 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::Run() In")); 466 int32 leavecode = 0; 467 468 if (iErrorHandlingInUtilityAO) 469 { 470 iErrorHandlingInUtilityAO = false; 471 472 // Forcibly restart the player engine 473 PVMFStatus retval = DoPlayerShutdownRestart(); 474 if (retval != PVMFSuccess) 475 { 476 iAPICmdStatus = retval; 477 } 478 // Cleanup the video data sink 479 iVideoDataSink.SetDataSinkNode(NULL); 480 if (iVideoNode) 481 { 482 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoNode); 483 iVideoNode = NULL; 484 } 485 if (iVideoMIO) 486 { 487 OSCL_DELETE(iVideoMIO); 488 iVideoMIO = NULL; 489 } 490 // Cleanup the audio data sink 491 iAudioDataSink.SetDataSinkNode(NULL); 492 if (iAudioNode) 493 { 494 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioNode); 495 iAudioNode = NULL; 496 } 497 if (iAudioMIO) 498 { 499 OSCL_DELETE(iAudioMIO); 500 iAudioMIO = NULL; 501 } 502 // Remove the data source handle 503 iDataSource = NULL; 504 505 // Cancel any pending timers 506 if (iTimeoutTimer) 507 { 508 iTimeoutTimer->Clear(); 509 } 510 511 SetUtilityState(PVFM_UTILITY_STATE_IDLE); 512 513 // Complete any command if waiting to be completed 514 if (iCurrentCmd.empty() == false) 515 { 516 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 517 } 518 iAPICmdStatus = PVMFSuccess; 519 if (iAPICmdErrMsg) 520 { 521 iAPICmdErrMsg->removeRef(); 522 iAPICmdErrMsg = NULL; 523 } 524 return; 525 } 526 527 // Check if CancelAll() request was made 528 if (!iPendingCmds.empty()) 529 { 530 if (iPendingCmds.top().GetCmdType() == PVFM_UTILITY_COMMAND_CANCEL_ALL_COMMANDS) 531 { 532 // Process it right away 533 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::Run() Processing CancelAllCommands() request")); 534 PVFMUtilityCommand cmd(iPendingCmds.top()); 535 iPendingCmds.pop(); 536 DoCancelAllCommands(cmd); 537 return; 538 } 539 } 540 541 // Handle other requests normally 542 if (!iPendingCmds.empty() && iCurrentCmd.empty()) 543 { 544 // Retrieve the first pending command from queue 545 PVFMUtilityCommand cmd(iPendingCmds.top()); 546 iPendingCmds.pop(); 547 548 // Put in on the current command queue 549 leavecode = 0; 550 OSCL_TRY(leavecode, iCurrentCmd.push_front(cmd)); 551 OSCL_FIRST_CATCH_ANY(leavecode, 552 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::Run() Command could not be pushed onto iCurrentCmd vector")); 553 UtilityCommandCompleted(cmd.GetCmdId(), cmd.GetContext(), PVMFErrNoMemory); 554 OSCL_ASSERT(false); 555 return;); 556 557 // Process the command according to the cmd type 558 PVMFStatus cmdstatus = PVMFSuccess; 559 switch (cmd.GetCmdType()) 560 { 561 case PVFM_UTILITY_COMMAND_QUERY_UUID: 562 cmdstatus = DoQueryUUID(cmd);; 563 break; 564 565 case PVFM_UTILITY_COMMAND_QUERY_INTERFACE: 566 cmdstatus = DoQueryInterface(cmd); 567 break; 568 569 case PVFM_UTILITY_COMMAND_GET_STATE: 570 cmdstatus = DoGetState(cmd, false); 571 break; 572 573 case PVFM_UTILITY_COMMAND_ADD_DATA_SOURCE: 574 cmdstatus = DoAddDataSource(cmd); 575 break; 576 577 case PVFM_UTILITY_COMMAND_GET_METADATA_KEYS: 578 cmdstatus = DoGetMetadataKeys(cmd); 579 break; 580 581 case PVFM_UTILITY_COMMAND_GET_METADATA_VALUES: 582 cmdstatus = DoGetMetadataValues(cmd); 583 break; 584 585 case PVFM_UTILITY_COMMAND_SET_PARAMETERS: 586 cmdstatus = DoCapConfigSetParameters(cmd, false); 587 break; 588 589 case PVFM_UTILITY_COMMAND_GET_FRAME_USER_BUFFER: 590 case PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER: 591 cmdstatus = DoGetFrame(cmd); 592 break; 593 594 case PVFM_UTILITY_COMMAND_RETURN_BUFFER: 595 cmdstatus = DoReturnBuffer(cmd); 596 break; 597 598 case PVFM_UTILITY_COMMAND_REMOVE_DATA_SOURCE: 599 cmdstatus = DoRemoveDataSource(cmd); 600 break; 601 602 case PVFM_UTILITY_COMMAND_CANCEL_ALL_COMMANDS: 603 // CancelAll() should not be handled here 604 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::Run() CancelAllCommands should be not handled in here. Asserting.")); 605 OSCL_ASSERT(false); 606 // Just handle as "not supported" 607 cmdstatus = PVMFErrNotSupported; 608 break; 609 610 case PVFM_UTILITY_COMMAND_HANDLE_PLAYER_ERROR: 611 // Internal command so should not be handled here 612 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::Run() Internal error handling command should be not handled in here. Asserting.")); 613 OSCL_ASSERT(false); 614 // Just handle as "not supported" 615 cmdstatus = PVMFErrNotSupported; 616 break; 617 618 default: 619 cmdstatus = PVMFErrNotSupported; 620 break; 621 } 622 623 if (cmdstatus != PVMFSuccess) 624 { 625 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::Run() Command failed CmdId %d Status %d", cmd.GetCmdId(), cmdstatus)); 626 UtilityCommandCompleted(cmd.GetCmdId(), cmd.GetContext(), cmdstatus); 627 } 628 } 629 630 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::Run() Out")); 631 } 632 633 634 void PVFrameAndMetadataUtility::CommandCompleted(const PVCmdResponse& aResponse) 635 { 636 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::CommandCompleted() In")); 637 638 // Check if a cancel command on player engine completed 639 int32* context_int32 = (int32*)(aResponse.GetContext()); 640 if (context_int32 == &iCancelContext) 641 { 642 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::CommandCompleted() Player engine cancel command completed")); 643 644 // Check if the player engine state matches the utility's expected state 645 PVPlayerState playerstate = PVP_STATE_IDLE; 646 iPlayer->GetPVPlayerStateSync(playerstate); 647 if (playerstate == PVP_STATE_IDLE && iState != PVFM_UTILITY_STATE_IDLE) 648 { 649 iDataSource = NULL; 650 iState = PVFM_UTILITY_STATE_IDLE; 651 } 652 653 // Complete the utility's CancelAllCommands() request 654 iCmdToCancel.clear(); 655 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), PVMFSuccess); 656 return; 657 } 658 659 // Ignore other player command completion if cancelling 660 if (!iCmdToCancel.empty()) 661 { 662 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::CommandCompleted() Player command completion ignored due to cancel process")); 663 iUtilityContext.iCmdType = -1; 664 return; 665 } 666 667 // Process normal player engine command completions 668 if (aResponse.GetContext() == (OsclAny*)&iUtilityContext) 669 { 670 PVFMUtilityContext* context = (PVFMUtilityContext*)(aResponse.GetContext()); 671 switch (context->iCmdType) 672 { 673 case PVFM_CMD_PlayerQueryUUID: 674 HandlePlayerQueryUUID(*context, aResponse); 675 break; 676 677 case PVFM_CMD_PlayerQueryInterface: 678 case PVFM_CMD_PlayerQueryCapConfigInterface: 679 HandlePlayerQueryInterface(*context, aResponse); 680 break; 681 682 case PVFM_CMD_ADSPlayerAddDataSource: 683 HandleADSPlayerAddDataSource(*context, aResponse); 684 break; 685 686 case PVFM_CMD_ADSPlayerInit: 687 HandleADSPlayerInit(*context, aResponse); 688 break; 689 690 case PVFM_CMD_ADSPlayerAddVideoDataSink: 691 HandleADSPlayerAddVideoDataSink(*context, aResponse); 692 break; 693 694 case PVFM_CMD_ADSPlayerAddAudioDataSink: 695 HandleADSPlayerAddAudioDataSink(*context, aResponse); 696 break; 697 698 case PVFM_CMD_ADSPlayerPrepare: 699 HandleADSPlayerPrepare(*context, aResponse); 700 break; 701 702 case PVFM_CMD_ADSPlayerStart: 703 HandleADSPlayerStart(*context, aResponse); 704 break; 705 706 case PVFM_CMD_ADSPlayerPause: 707 HandleADSPlayerPause(*context, aResponse); 708 break; 709 710 case PVFM_CMD_PlayerGetMetadataKeys: 711 HandlePlayerGetMetadataKeys(*context, aResponse); 712 break; 713 714 case PVFM_CMD_PlayerGetMetadataValues: 715 HandlePlayerGetMetadataValues(*context, aResponse); 716 break; 717 718 case PVFM_CMD_PlayerSetParametersSync: 719 HandlePlayerSetParametersSync(*context, aResponse); 720 break; 721 722 case PVFM_CMD_GFPlayerStopFromPaused: 723 HandleGFPlayerStopFromPaused(*context, aResponse); 724 break; 725 726 case PVFM_CMD_GFPlayerPrepare: 727 HandleGFPlayerPrepare(*context, aResponse); 728 break; 729 730 case PVFM_CMD_GFPlayerStart: 731 HandleGFPlayerStart(*context, aResponse); 732 break; 733 734 case PVFM_CMD_GFPlayerPause: 735 HandleGFPlayerPause(*context, aResponse); 736 break; 737 738 case PVFM_CMD_RDSPlayerStopFromPaused: 739 HandleRDSPlayerStopFromPaused(*context, aResponse); 740 break; 741 742 case PVFM_CMD_RDSPlayerRemoveVideoDataSink: 743 HandleRDSPlayerRemoveVideoDataSink(*context, aResponse); 744 break; 745 746 case PVFM_CMD_RDSPlayerRemoveAudioDataSink: 747 HandleRDSPlayerRemoveAudioDataSink(*context, aResponse); 748 break; 749 750 case PVFM_CMD_RDSPlayerReset: 751 HandleRDSPlayerReset(*context, aResponse); 752 break; 753 754 case PVFM_CMD_RDSPlayerRemoveDataSource: 755 HandleRDSPlayerRemoveDataSource(*context, aResponse); 756 break; 757 758 default: 759 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::CommandCompleted() Unknown player command type. Asserting")); 760 OSCL_ASSERT(false); 761 break; 762 } 763 } 764 765 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::CommandCompleted() Out")); 766 } 767 768 769 void PVFrameAndMetadataUtility::HandleErrorEvent(const PVAsyncErrorEvent& aEvent) 770 { 771 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleErrorEvent() In")); 772 773 // Check the player state 774 PVPlayerState pstate; 775 iPlayer->GetPVPlayerStateSync(pstate); 776 777 switch (pstate) 778 { 779 case PVP_STATE_ERROR: 780 { 781 if (iCurrentCmd.empty() == true) 782 { 783 // Since error occurred while not processing a command so put in an internal 784 // utility command so a pending command would not be processing while handling error 785 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleErrorEvent() Queuing an internal command for error handlin")); 786 PVFMUtilityCommand errorcmd(PVFM_UTILITY_COMMAND_HANDLE_PLAYER_ERROR, -1, NULL, NULL, false); 787 iCurrentCmd.push_front(errorcmd); 788 } 789 790 // Wait for error handling to complete 791 PVMFErrorInfoMessageInterface* nextmsg = NULL; 792 if (aEvent.GetEventExtensionInterface()) 793 { 794 nextmsg = GetErrorInfoMessageInterface(*(aEvent.GetEventExtensionInterface())); 795 } 796 PVMFBasicErrorInfoMessage* errmsg = NULL; 797 errmsg = CreateBasicErrInfoMessage(nextmsg); 798 799 iAPICmdStatus = (PVMFStatus)(aEvent.GetEventType()); 800 if (iAPICmdErrMsg) 801 { 802 iAPICmdErrMsg->removeRef(); 803 iAPICmdErrMsg = NULL; 804 } 805 iAPICmdErrMsg = errmsg; 806 807 // Start a timer just in case the player does not report error handling complete 808 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 809 } 810 break; 811 812 case PVP_STATE_IDLE: 813 if (iState == PVFM_UTILITY_STATE_IDLE) 814 { 815 // Just report the error event up to the app 816 iErrorEventObserver->HandleErrorEvent(aEvent); 817 break; 818 } 819 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 820 iErrorHandlingInUtilityAO = true; 821 RunIfNotReady(); 822 break; 823 824 default: 825 // Need to shutdown/restart player and cleanup in utility's AO 826 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 827 iErrorHandlingInUtilityAO = true; 828 RunIfNotReady(); 829 break; 830 } 831 832 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleErrorEvent() Out")); 833 } 834 835 836 void PVFrameAndMetadataUtility::HandleInformationalEvent(const PVAsyncInformationalEvent& aEvent) 837 { 838 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleInformationalEvent() In")); 839 840 // If error handling complete event, complete the utility command 841 // that was waiting for player to complete error handling 842 if (aEvent.GetEventType() == PVMFInfoErrorHandlingComplete) 843 { 844 if (iAPICmdStatus == PVMFSuccess) 845 { 846 // Error handling wait timed out so ignore this event 847 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleInformationalEvent() Error handling already timed out so ignoring this event from player.")); 848 return; 849 } 850 851 // Cancel the timeout timer 852 iTimeoutTimer->Cancel(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT); 853 854 // Check the player state and make it sure matches with expected one 855 PVPlayerState pstate; 856 iPlayer->GetPVPlayerStateSync(pstate); 857 858 switch (pstate) 859 { 860 case PVP_STATE_INITIALIZED: 861 if (iState == PVFM_UTILITY_STATE_IDLE || iState == PVFM_UTILITY_STATE_RESETTING) 862 { 863 // This should not happen 864 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleInformationalEvent() Player is initialized even though util is in idle. Asserting.")); 865 OSCL_ASSERT(false); 866 867 // Need to shutdown/restart player and cleanup in utility's AO 868 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 869 iErrorHandlingInUtilityAO = true; 870 RunIfNotReady(); 871 return; 872 } 873 else 874 { 875 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZED); 876 877 // If the current command is AddDataSource(), player engine 878 // is in initialized state so complete the command with success 879 if (iCurrentCmd.empty() == false) 880 { 881 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_ADD_DATA_SOURCE) 882 { 883 //if the mode is in which prepare of engine is called and prepare is failing 884 //we cannot send successs of adddata source 885 if (iMode == PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_ONLY) 886 { 887 iAPICmdStatus = PVMFSuccess; 888 } 889 890 if (iAPICmdErrMsg) 891 { 892 iAPICmdErrMsg->removeRef(); 893 iAPICmdErrMsg = NULL; 894 } 895 896 // Cleanup the video data sink 897 iVideoDataSink.SetDataSinkNode(NULL); 898 if (iVideoNode) 899 { 900 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoNode); 901 iVideoNode = NULL; 902 } 903 if (iVideoMIO) 904 { 905 OSCL_DELETE(iVideoMIO); 906 iVideoMIO = NULL; 907 } 908 // Cleanup the audio data sink 909 iAudioDataSink.SetDataSinkNode(NULL); 910 if (iAudioNode) 911 { 912 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioNode); 913 iAudioNode = NULL; 914 } 915 if (iAudioMIO) 916 { 917 OSCL_DELETE(iAudioMIO); 918 iAudioMIO = NULL; 919 } 920 } 921 } 922 } 923 break; 924 925 case PVP_STATE_IDLE: 926 if (iState != PVFM_UTILITY_STATE_IDLE) 927 { 928 // Player went back to idle state so change utility's state to idle as well 929 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleInformationalEvent() Player went back to idle so set utility to idle.")); 930 931 // Cleanup the video data sink 932 iVideoDataSink.SetDataSinkNode(NULL); 933 if (iVideoNode) 934 { 935 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoNode); 936 iVideoNode = NULL; 937 } 938 if (iVideoMIO) 939 { 940 OSCL_DELETE(iVideoMIO); 941 iVideoMIO = NULL; 942 } 943 // Cleanup the audio data sink 944 iAudioDataSink.SetDataSinkNode(NULL); 945 if (iAudioNode) 946 { 947 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioNode); 948 iAudioNode = NULL; 949 } 950 if (iAudioMIO) 951 { 952 OSCL_DELETE(iAudioMIO); 953 iAudioMIO = NULL; 954 } 955 // Remove the data source handle 956 iDataSource = NULL; 957 958 SetUtilityState(PVFM_UTILITY_STATE_IDLE); 959 } 960 break; 961 962 default: 963 // Player should not be in any other state when 964 // error handling completes 965 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleInformationalEvent() Unexpected player state after error handling. Asserting.")); 966 OSCL_ASSERT(false); 967 // Need to shutdown/restart player and cleanup in utility's AO 968 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 969 iErrorHandlingInUtilityAO = true; 970 RunIfNotReady(); 971 break; 972 } 973 974 // Report the command as failed if command completion was pending 975 if (iCurrentCmd.empty() == false) 976 { 977 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 978 } 979 iAPICmdStatus = PVMFSuccess; 980 if (iAPICmdErrMsg) 981 { 982 iAPICmdErrMsg->removeRef(); 983 iAPICmdErrMsg = NULL; 984 } 985 } 986 else if (aEvent.GetEventType() == PVMFInfoEndOfData) 987 { 988 if (!iCurrentCmd.empty() && 989 (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_USER_BUFFER || 990 iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER)) 991 { 992 // End of Data is received, before frame could be fetched 993 // Need to send command completion for GetFrame 994 if (!iFrameReceived) 995 { 996 HandleFrameReadyEvent(PVMFErrMaxReached); 997 } 998 } 999 iInfoEventObserver->HandleInformationalEvent(aEvent); 1000 } 1001 else 1002 { 1003 // Just pass up other info events up to app 1004 iInfoEventObserver->HandleInformationalEvent(aEvent); 1005 } 1006 1007 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleInformationalEvent() Out")); 1008 } 1009 1010 1011 void PVFrameAndMetadataUtility::HandleFrameReadyEvent(PVMFStatus aEventStatus) 1012 { 1013 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_USER_BUFFER || 1014 iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER) 1015 { 1016 iFrameReceived = true; 1017 1018 // Cancel the timeout timer 1019 iTimeoutTimer->Cancel(PVFMUTIL_TIMERID_FRAMEREADYTIMEOUT); 1020 1021 iAPICmdStatus = aEventStatus; 1022 1023 if (aEventStatus != PVMFSuccess) 1024 { 1025 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleFrameReadyEvent() Frame retrieval from video MIO failed.")); 1026 1027 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 1028 { 1029 // Return the buffer if allocated from utility's mempool 1030 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 1031 iCurrentVideoFrameBuffer = NULL; 1032 } 1033 1034 PVUuid puuid = PVFrameAndMetadataErrorInfoEventTypesUUID; 1035 PVMFBasicErrorInfoMessage* errmsg = NULL; 1036 int32 leavecode = 0; 1037 OSCL_TRY(leavecode, errmsg = OSCL_NEW(PVMFBasicErrorInfoMessage, (PVFMErrMIOComponent, puuid, NULL))); 1038 OSCL_FIRST_CATCH_ANY(leavecode, 1039 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleFrameReadyEvent() Instantiation of error msg did a leave!")); 1040 errmsg = NULL; 1041 ); 1042 1043 if (iAPICmdErrMsg) 1044 { 1045 iAPICmdErrMsg->removeRef(); 1046 iAPICmdErrMsg = NULL; 1047 } 1048 iAPICmdErrMsg = errmsg; 1049 } 1050 else 1051 { 1052 OSCL_ASSERT(iVideoFrameBufferProp != NULL); 1053 // Retrieve the video frame properties from MIO component 1054 uint32 fw = 0; 1055 uint32 fh = 0; 1056 uint32 dw = 0; 1057 uint32 dh = 0; 1058 if (iVideoMIO->GetFrameProperties(fw, fh, dw, dh) == PVMFSuccess) 1059 { 1060 iVideoFrameBufferProp->iFrameWidth = fw; 1061 iVideoFrameBufferProp->iFrameHeight = fh; 1062 iVideoFrameBufferProp->iDisplayWidth = dw; 1063 iVideoFrameBufferProp->iDisplayHeight = dh; 1064 } 1065 else 1066 { 1067 iVideoFrameBufferProp->iFrameWidth = 0; 1068 iVideoFrameBufferProp->iFrameHeight = 0; 1069 iVideoFrameBufferProp->iDisplayWidth = 0; 1070 iVideoFrameBufferProp->iDisplayHeight = 0; 1071 } 1072 } 1073 1074 // Initiate pause on player if start already completed 1075 if (iPlayerStartCompleted) 1076 { 1077 PVMFStatus retval = DoGFPlayerPause(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext()); 1078 if (retval == PVMFErrInvalidState) 1079 { 1080 // Playback already paused so GetFrame() command completed 1081 if (iAPICmdStatus != PVMFSuccess) 1082 { 1083 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 1084 { 1085 // Return the buffer if allocated from utility's mempool 1086 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 1087 iCurrentVideoFrameBuffer = NULL; 1088 } 1089 } 1090 1091 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 1092 1093 iAPICmdStatus = PVMFSuccess; 1094 if (iAPICmdErrMsg) 1095 { 1096 iAPICmdErrMsg->removeRef(); 1097 iAPICmdErrMsg = NULL; 1098 } 1099 } 1100 else if (retval != PVMFSuccess) 1101 { 1102 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleFrameReadyEvent() Stop on player failed. Report command as failed")); 1103 1104 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 1105 { 1106 // Return the buffer if allocated from utility's mempool 1107 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 1108 iCurrentVideoFrameBuffer = NULL; 1109 } 1110 1111 if (iAPICmdStatus == PVMFSuccess) 1112 { 1113 iAPICmdStatus = retval; 1114 } 1115 1116 // Need to shutdown/restart player and cleanup in utility's AO 1117 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 1118 iErrorHandlingInUtilityAO = true; 1119 RunIfNotReady(); 1120 } 1121 } 1122 // Else just wait for player to report start completed 1123 } 1124 else 1125 { 1126 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleFrameReadyEvent() Frame ready received outside of GetFrame() command. Asserting.")); 1127 //OSCL_ASSERT(false); 1128 } 1129 } 1130 1131 1132 void PVFrameAndMetadataUtility::TimeoutOccurred(int32 timerID, int32 /*timeoutInfo*/) 1133 { 1134 if (timerID == PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT) 1135 { 1136 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::TimeoutOccurred() Timer for error handling timeout triggered")); 1137 1138 if (iAPICmdStatus == PVMFSuccess) 1139 { 1140 // Error handling wait timed out so ignore this event 1141 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::TimeoutOccurred() Error handling already reported complete by player.")); 1142 return; 1143 } 1144 1145 // Check the player state and make it sure matches with expected one 1146 PVPlayerState pstate; 1147 iPlayer->GetPVPlayerStateSync(pstate); 1148 PVFrameAndMetadataState ustate; 1149 ustate = GetUtilityState(); 1150 1151 switch (pstate) 1152 { 1153 case PVP_STATE_INITIALIZED: 1154 if (ustate == PVFM_STATE_IDLE) 1155 { 1156 // This should not happen 1157 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::TimeoutOccurred() Player is initialized even though util is in idle. Asserting.")); 1158 OSCL_ASSERT(false); 1159 } 1160 break; 1161 1162 case PVP_STATE_IDLE: 1163 if (ustate != PVFM_STATE_IDLE) 1164 { 1165 // Player went back to idle state so change utility's state to idle as well 1166 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::TimeoutOccurred() Player went back to idle so set utility to idle.")); 1167 SetUtilityState(PVFM_UTILITY_STATE_IDLE); 1168 } 1169 break; 1170 1171 default: 1172 // Player should not be in any other state when 1173 // error handling completes 1174 OSCL_ASSERT(false); 1175 break; 1176 } 1177 1178 // Report the command as failed 1179 OSCL_ASSERT(iCurrentCmd.empty() == false); 1180 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 1181 iAPICmdStatus = PVMFSuccess; 1182 if (iAPICmdErrMsg) 1183 { 1184 iAPICmdErrMsg->removeRef(); 1185 iAPICmdErrMsg = NULL; 1186 } 1187 } 1188 else if (timerID == PVFMUTIL_TIMERID_FRAMEREADYTIMEOUT) 1189 { 1190 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::TimeoutOccurred() Frame retrieval from video MIO timed out.")); 1191 1192 // Cancel the pending frame retrieval 1193 iVideoMIO->CancelGetFrame(); 1194 1195 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 1196 { 1197 // Return the buffer if allocated from utility's mempool 1198 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 1199 iCurrentVideoFrameBuffer = NULL; 1200 } 1201 1202 // Create an error message 1203 PVUuid puuid = PVFrameAndMetadataErrorInfoEventTypesUUID; 1204 PVMFBasicErrorInfoMessage* errmsg = NULL; 1205 int32 leavecode = 0; 1206 OSCL_TRY(leavecode, errmsg = OSCL_NEW(PVMFBasicErrorInfoMessage, (PVFMErrMIOComponent, puuid, NULL))); 1207 OSCL_FIRST_CATCH_ANY(leavecode, 1208 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::TimeoutOccurred() Instantiation of error msg did a leave!")); 1209 errmsg = NULL; 1210 ); 1211 1212 iAPICmdStatus = PVMFErrTimeout; 1213 if (iAPICmdErrMsg) 1214 { 1215 iAPICmdErrMsg->removeRef(); 1216 iAPICmdErrMsg = NULL; 1217 } 1218 iAPICmdErrMsg = errmsg; 1219 1220 // Timer is started after player start completes so initiate pause on player 1221 PVMFStatus retval = DoGFPlayerPause(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext()); 1222 if (retval == PVMFErrInvalidState) 1223 { 1224 // Playback already paused so GetFrame() command completed 1225 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 1226 1227 iAPICmdStatus = PVMFSuccess; 1228 if (iAPICmdErrMsg) 1229 { 1230 iAPICmdErrMsg->removeRef(); 1231 iAPICmdErrMsg = NULL; 1232 } 1233 } 1234 else if (retval != PVMFSuccess) 1235 { 1236 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::TimeoutOccurred() Pause on player failed. Report command as failed")); 1237 // Need to shutdown/restart player and cleanup in utility's AO 1238 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 1239 iErrorHandlingInUtilityAO = true; 1240 RunIfNotReady(); 1241 } 1242 } 1243 else 1244 { 1245 OSCL_ASSERT(false); 1246 } 1247 } 1248 1249 1250 PVCommandId PVFrameAndMetadataUtility::AddCommandToQueue(int32 aCmdType, OsclAny* aContextData, Oscl_Vector < PVFMUtilityCommandParamUnion, 1251 OsclMemAllocator > * aParamVector, const PVUuid* aUuid, bool aAPICommand) 1252 { 1253 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::AddCommandToQueue() In CmdType %d, CmdId %d", aCmdType, iCommandId)); 1254 1255 PVFMUtilityCommand cmd(aCmdType, iCommandId, aContextData, aParamVector, aAPICommand); 1256 if (aUuid) 1257 { 1258 cmd.SetUuid(*aUuid); 1259 } 1260 1261 int32 leavecode = 0; 1262 OSCL_TRY(leavecode, iPendingCmds.push(cmd)); 1263 OSCL_FIRST_CATCH_ANY(leavecode, 1264 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::AddCommandToQueue() Adding command to pending command list did a leave!")); 1265 OSCL_ASSERT(false); 1266 return -1;); 1267 1268 RunIfNotReady(); 1269 1270 ++iCommandId; 1271 if (iCommandId == 0x7FFFFFFF) 1272 { 1273 iCommandId = 0; 1274 } 1275 1276 1277 return cmd.GetCmdId(); 1278 } 1279 1280 1281 void PVFrameAndMetadataUtility::UtilityCommandCompleted(PVCommandId aId, OsclAny* aContext, PVMFStatus aStatus, 1282 PVInterface* aExtInterface, OsclAny* aEventData, int32 aEventDataSize) 1283 { 1284 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::UtilityCommandCompleted() In CmdId %d, Status %d", aId, aStatus)); 1285 1286 // Update the current command vector 1287 1288 // Assert if the current cmd is not saved or the cmd ID does not match 1289 OSCL_ASSERT(iCurrentCmd.size() == 1); 1290 OSCL_ASSERT(iCurrentCmd[0].GetCmdId() == aId); 1291 1292 // Empty out the current cmd vector and set active if there are other pending commands 1293 PVFMUtilityCommand completedcmd(iCurrentCmd[0]); 1294 iCurrentCmd.erase(iCurrentCmd.begin()); 1295 if (!iPendingCmds.empty()) 1296 { 1297 RunIfNotReady(); 1298 } 1299 1300 // Send the command completed event 1301 if (iCmdStatusObserver) 1302 { 1303 if (aId != -1 && completedcmd.IsAPICommand()) 1304 { 1305 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::UtilityCommandCompleted() Notifying utility command as completed. CmdId %d Status %d", aId, aStatus)); 1306 PVCmdResponse cmdcompleted(aId, aContext, aStatus, aExtInterface, aEventData, aEventDataSize); 1307 iCmdStatusObserver->CommandCompleted(cmdcompleted); 1308 } 1309 else 1310 { 1311 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::UtilityCommandCompleted() aId is -1 or not an API command. CmdType %d", completedcmd.GetCmdType())); 1312 } 1313 } 1314 else 1315 { 1316 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::UtilityCommandCompleted() iCmdStatusObserver is NULL")); 1317 } 1318 } 1319 1320 void PVFrameAndMetadataUtility::setObserver(PvmiConfigAndCapabilityCmdObserver* aObserver) 1321 { 1322 OSCL_UNUSED_ARG(aObserver); 1323 OsclError::Leave(OsclErrNotSupported); 1324 } 1325 1326 PVMFStatus PVFrameAndMetadataUtility::getParametersSync(PvmiMIOSession aSession, PvmiKeyType aIdentifier, PvmiKvp*& aParameters, int& aNumParamElements, PvmiCapabilityContext aContext) 1327 { 1328 OSCL_UNUSED_ARG(aSession); 1329 OSCL_UNUSED_ARG(aIdentifier); 1330 OSCL_UNUSED_ARG(aParameters); 1331 OSCL_UNUSED_ARG(aNumParamElements); 1332 OSCL_UNUSED_ARG(aContext); 1333 1334 return PVMFErrNotSupported; 1335 } 1336 1337 PVMFStatus PVFrameAndMetadataUtility::releaseParameters(PvmiMIOSession aSession, PvmiKvp* aParameters, int aNumElements) 1338 { 1339 OSCL_UNUSED_ARG(aSession); 1340 OSCL_UNUSED_ARG(aParameters); 1341 OSCL_UNUSED_ARG(aNumElements); 1342 1343 return PVMFErrNotSupported; 1344 } 1345 1346 void PVFrameAndMetadataUtility::createContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext) 1347 { 1348 OSCL_UNUSED_ARG(aSession); 1349 OSCL_UNUSED_ARG(aContext); 1350 OsclError::Leave(OsclErrNotSupported); 1351 } 1352 1353 void PVFrameAndMetadataUtility::DeleteContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext) 1354 { 1355 OSCL_UNUSED_ARG(aSession); 1356 OSCL_UNUSED_ARG(aContext); 1357 } 1358 1359 void PVFrameAndMetadataUtility::setContextParameters(PvmiMIOSession aSession, PvmiCapabilityContext& aContext, PvmiKvp* aParameters, int aNumParamElements) 1360 { 1361 OSCL_UNUSED_ARG(aSession); 1362 OSCL_UNUSED_ARG(aParameters); 1363 OSCL_UNUSED_ARG(aNumParamElements); 1364 OSCL_UNUSED_ARG(aContext); 1365 } 1366 1367 PVMFCommandId PVFrameAndMetadataUtility::setParametersAsync(PvmiMIOSession aSession, PvmiKvp* aParameters, int aNumElements, PvmiKvp*& aRetKVP, OsclAny* aContext) 1368 { 1369 OSCL_UNUSED_ARG(aSession); 1370 OSCL_UNUSED_ARG(aParameters); 1371 OSCL_UNUSED_ARG(aNumElements); 1372 OSCL_UNUSED_ARG(aRetKVP); 1373 OSCL_UNUSED_ARG(aContext); 1374 1375 return PVMFErrNotSupported; 1376 } 1377 1378 uint32 PVFrameAndMetadataUtility::getCapabilityMetric(PvmiMIOSession aSession) 1379 { 1380 OSCL_UNUSED_ARG(aSession); 1381 OsclError::Leave(OsclErrNotSupported); 1382 return 0; 1383 } 1384 1385 PVMFStatus PVFrameAndMetadataUtility::verifyParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int aNumElements) 1386 { 1387 OSCL_UNUSED_ARG(aSession); 1388 OSCL_UNUSED_ARG(aParameters); 1389 OSCL_UNUSED_ARG(aNumElements); 1390 1391 return PVMFErrNotSupported; 1392 } 1393 1394 1395 void PVFrameAndMetadataUtility::SetUtilityState(PVFMUtilityState aState) 1396 { 1397 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::SetUtilityState() In Current state %d, New state %d", iState, aState)); 1398 iState = aState; 1399 } 1400 1401 1402 PVFrameAndMetadataState PVFrameAndMetadataUtility::GetUtilityState(void) 1403 { 1404 switch (iState) 1405 { 1406 case PVFM_UTILITY_STATE_IDLE: 1407 case PVFM_UTILITY_STATE_INITIALIZING: 1408 return PVFM_STATE_IDLE; 1409 1410 case PVFM_UTILITY_STATE_INITIALIZED: 1411 case PVFM_UTILITY_STATE_RESETTING: 1412 return PVFM_STATE_INITIALIZED; 1413 1414 case PVFM_UTILITY_STATE_HANDLINGERROR: 1415 case PVFM_UTILITY_STATE_ERROR: 1416 return PVFM_STATE_ERROR; 1417 1418 default: 1419 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::GetUtilityState() Unknown utility state. Asserting")); 1420 OSCL_ASSERT(false); 1421 break; 1422 } 1423 1424 return PVFM_STATE_ERROR; 1425 } 1426 1427 1428 void PVFrameAndMetadataUtility::DoCancelAllCommands(PVFMUtilityCommand& aCmd) 1429 { 1430 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoCancelAllCommands() In")); 1431 1432 // Utility cannot be processing another cancel command 1433 OSCL_ASSERT(iCmdToCancel.empty() == true); 1434 1435 // Cancel the current command first 1436 if (iCurrentCmd.size() == 1) 1437 { 1438 // First save the current command being processed 1439 iCmdToCancel.push_front(iCurrentCmd[0]); 1440 // Cancel it 1441 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), PVMFErrCancelled); 1442 } 1443 1444 // Cancel all the pending commands 1445 while (!iPendingCmds.empty()) 1446 { 1447 // Retrieve the pending command from queue so it can be cancelled 1448 PVFMUtilityCommand cmd(iPendingCmds.top()); 1449 iPendingCmds.pop(); 1450 // Save it temporary as "current command" and then cancel it 1451 iCurrentCmd.push_front(cmd); 1452 UtilityCommandCompleted(cmd.GetCmdId(), cmd.GetContext(), PVMFErrCancelled); 1453 } 1454 1455 // Make the CancelAllCommands() command the current command 1456 iCurrentCmd.push_front(aCmd); 1457 1458 // Check if there was an ongoing command that needs to be properly cancelled 1459 if (!iCmdToCancel.empty()) 1460 { 1461 // Properly cancel a command being currently processed 1462 DoCancelCommandBeingProcessed(); 1463 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoCancelAllCommands() Out")); 1464 } 1465 else 1466 { 1467 // CancelAllCommands() command is completed so send the completion event 1468 UtilityCommandCompleted(aCmd.GetCmdId(), aCmd.GetContext(), PVMFSuccess); 1469 } 1470 } 1471 1472 1473 void PVFrameAndMetadataUtility::DoCancelCommandBeingProcessed() 1474 { 1475 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoCancelCommandBeingProcessed() In")); 1476 1477 switch (iCmdToCancel[0].GetCmdType()) 1478 { 1479 case PVFM_UTILITY_COMMAND_QUERY_UUID: 1480 case PVFM_UTILITY_COMMAND_QUERY_INTERFACE: 1481 case PVFM_UTILITY_COMMAND_ADD_DATA_SOURCE: 1482 case PVFM_UTILITY_COMMAND_GET_METADATA_KEYS: 1483 case PVFM_UTILITY_COMMAND_GET_METADATA_VALUES: 1484 case PVFM_UTILITY_COMMAND_GET_FRAME_USER_BUFFER: 1485 case PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER: 1486 case PVFM_UTILITY_COMMAND_RETURN_BUFFER: 1487 case PVFM_UTILITY_COMMAND_REMOVE_DATA_SOURCE: 1488 if (iUtilityContext.iCmdType != -1) 1489 { 1490 // Player command needs to be cancelled 1491 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1492 (0, "PVFrameAndMetadataUtility::CancelAllCommands Called Tick=%d", OsclTickCount::TickCount())); 1493 int32 leavecode = 0; 1494 OSCL_TRY(leavecode, iPlayer->CancelAllCommands((const OsclAny*) &iCancelContext)); 1495 OSCL_FIRST_CATCH_ANY(leavecode, 1496 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoCancelCommandBeingProcessed() Cancel on player engine did a leave. Asserting")); 1497 OSCL_ASSERT(false); 1498 iCmdToCancel.clear(); 1499 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), PVMFSuccess)); 1500 } 1501 else 1502 { 1503 // No pending player command to cancel so complete the CancelAllCommands() 1504 iCmdToCancel.clear(); 1505 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), PVMFSuccess); 1506 } 1507 break; 1508 1509 case PVFM_UTILITY_COMMAND_GET_STATE: 1510 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoCancelCommandBeingProcessed() Should not need to cancel GetState() since it completes in one Run.")); 1511 // Complete the CancelAllCommands() 1512 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), PVMFSuccess); 1513 break; 1514 1515 case PVFM_UTILITY_COMMAND_CANCEL_ALL_COMMANDS: 1516 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoCancelCommandBeingProcessed() Cannot cancel a CancelAllCommands(). Asserting")); 1517 OSCL_ASSERT(false); 1518 // Complete the current CancelAllCommands() 1519 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), PVMFSuccess); 1520 break; 1521 1522 default: 1523 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoCancelCommandBeingProcessed() Unknown command to cancel. Asserting")); 1524 OSCL_ASSERT(false); 1525 // Complete the CancelAllCommands() 1526 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), PVMFSuccess); 1527 break; 1528 } 1529 1530 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoCancelCommandBeingProcessed() Out")); 1531 } 1532 1533 1534 PVMFStatus PVFrameAndMetadataUtility::DoQueryUUID(PVFMUtilityCommand& aCmd) 1535 { 1536 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoQueryUUID() In")); 1537 1538 PvmfMimeString* mimetype; 1539 Oscl_Vector<PVUuid, OsclMemAllocator> *uuidvec; 1540 bool exactmatch; 1541 1542 mimetype = (PvmfMimeString*)(aCmd.GetParam(0).pOsclAny_value); 1543 uuidvec = (Oscl_Vector<PVUuid, OsclMemAllocator>*)(aCmd.GetParam(1).pOsclAny_value); 1544 exactmatch = aCmd.GetParam(2).bool_value; 1545 1546 if (mimetype == NULL || uuidvec == NULL) 1547 { 1548 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoQueryUUID() Passed in parameter invalid.")); 1549 return PVMFErrArgument; 1550 } 1551 1552 // For now, no extension interface available from utility 1553 1554 // Call QueryUUID() on the player 1555 PVMFStatus cmdstatus = DoPlayerQueryUUID(aCmd.GetCmdId(), aCmd.GetContext(), *mimetype, *uuidvec, exactmatch); 1556 1557 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoQueryUUID() Out")); 1558 return cmdstatus; 1559 } 1560 1561 1562 PVMFStatus PVFrameAndMetadataUtility::DoPlayerQueryUUID(PVCommandId aCmdId, OsclAny* aCmdContext, 1563 PvmfMimeString& aMIMEType, Oscl_Vector<PVUuid, OsclMemAllocator>& aUUIDVec, bool aExactMatch) 1564 { 1565 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerQueryUUID() In")); 1566 1567 iUtilityContext.iCmdId = aCmdId; 1568 iUtilityContext.iCmdContext = aCmdContext; 1569 iUtilityContext.iCmdType = PVFM_CMD_PlayerQueryUUID; 1570 int32 leavecode = 0; 1571 OSCL_ASSERT(iPlayer != NULL); 1572 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1573 (0, "PVFrameAndMetadataUtility::QueryUUID Called Tick=%d", OsclTickCount::TickCount())); 1574 OSCL_TRY(leavecode, iPlayer->QueryUUID(aMIMEType, aUUIDVec, aExactMatch, (const OsclAny*)&iUtilityContext)); 1575 OSCL_FIRST_CATCH_ANY(leavecode, 1576 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoPlayerQueryUUID() QueryUUID() on player did a leave!")); 1577 return PVMFFailure;); 1578 1579 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerQueryUUID() Out")); 1580 return PVMFSuccess; 1581 } 1582 1583 1584 PVMFStatus PVFrameAndMetadataUtility::DoQueryInterface(PVFMUtilityCommand& aCmd) 1585 { 1586 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoQueryInterface() In")); 1587 1588 PVInterface** ifptr = (PVInterface**)(aCmd.GetParam(0).pOsclAny_value); 1589 PVMFStatus cmdstatus = PVMFSuccess; 1590 1591 iPlayerQueryIFUUID = aCmd.GetUuid(); 1592 PVCommandId cmdid = aCmd.GetCmdId(); 1593 OsclAny* context = aCmd.GetContext(); 1594 1595 if (ifptr == NULL) 1596 { 1597 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoQueryInterface() Passed in parameter invalid.")); 1598 return PVMFErrArgument; 1599 } 1600 1601 if (queryInterface(iPlayerQueryIFUUID, *ifptr, cmdid, context) == false) 1602 { 1603 cmdstatus = PVMFErrNotSupported; 1604 } 1605 1606 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoQueryInterface() Out")); 1607 return cmdstatus; 1608 } 1609 1610 bool PVFrameAndMetadataUtility::queryInterface(const PVUuid& uuid, PVInterface*& iface, PVCommandId cmdid, OsclAny* context) 1611 { 1612 bool status = true; 1613 1614 if (uuid == PVMI_CAPABILITY_AND_CONFIG_PVUUID) 1615 { 1616 PvmiCapabilityAndConfig* capconfigiface = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*, this); 1617 iface = OSCL_STATIC_CAST(PVInterface*, capconfigiface); 1618 1619 // Call QueryInterface() on the player too in case of usage using setParametersSync() 1620 PVMFStatus cmdstatus = DoPlayerQueryInterface(cmdid, context, iPlayerQueryIFUUID, iPlayerCapConfigIFPVI); 1621 1622 if (PVMFSuccess != cmdstatus) 1623 status = false; 1624 } 1625 else 1626 { 1627 // Call QueryInterface() on the player 1628 PVMFStatus cmdstatus = DoPlayerQueryInterface(cmdid, context, iPlayerQueryIFUUID, (PVInterface*&)iface); 1629 if (PVMFSuccess != cmdstatus) 1630 status = false; 1631 } 1632 return status; 1633 } 1634 1635 1636 PVMFStatus PVFrameAndMetadataUtility::DoPlayerQueryInterface(PVCommandId aCmdId, OsclAny* aCmdContext, PVUuid& aUuid, PVInterface*& aInterfacePtr) 1637 { 1638 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerQueryInterface() In")); 1639 1640 iUtilityContext.iCmdId = aCmdId; 1641 iUtilityContext.iCmdContext = aCmdContext; 1642 iUtilityContext.iCmdType = PVFM_CMD_PlayerQueryInterface; 1643 1644 if (aUuid == PVMI_CAPABILITY_AND_CONFIG_PVUUID) 1645 { 1646 iUtilityContext.iCmdType = PVFM_CMD_PlayerQueryCapConfigInterface; 1647 } 1648 int32 leavecode = 0; 1649 OSCL_ASSERT(iPlayer != NULL); 1650 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1651 (0, "PVFrameAndMetadataUtility::QueryInterface Called Tick=%d", OsclTickCount::TickCount())); 1652 OSCL_TRY(leavecode, iPlayer->QueryInterface(aUuid, aInterfacePtr, (const OsclAny*)&iUtilityContext)); 1653 OSCL_FIRST_CATCH_ANY(leavecode, 1654 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoPlayerQueryInterface() QueryInterface() on player did a leave!")); 1655 return PVMFFailure;); 1656 1657 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerQueryInterface() Out")); 1658 return PVMFSuccess; 1659 } 1660 1661 1662 PVMFStatus PVFrameAndMetadataUtility::DoGetState(PVFMUtilityCommand& aCmd, bool aSyncCmd) 1663 { 1664 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGetState() In")); 1665 1666 PVFrameAndMetadataState* state = (PVFrameAndMetadataState*)(aCmd.GetParam(0).pOsclAny_value); 1667 if (state == NULL) 1668 { 1669 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetState() Passed in parameter invalid.")); 1670 return PVMFErrArgument; 1671 } 1672 1673 // Get current utility state using internal function 1674 *state = GetUtilityState(); 1675 1676 if (!aSyncCmd) 1677 { 1678 UtilityCommandCompleted(aCmd.GetCmdId(), aCmd.GetContext(), PVMFSuccess); 1679 } 1680 1681 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGetState() Out")); 1682 return PVMFSuccess; 1683 } 1684 1685 1686 PVMFStatus PVFrameAndMetadataUtility::DoAddDataSource(PVFMUtilityCommand& aCmd) 1687 { 1688 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoAddDataSource() In")); 1689 1690 if (GetUtilityState() != PVFM_STATE_IDLE) 1691 { 1692 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoAddDataSource() Wrong state")); 1693 return PVMFErrInvalidState; 1694 } 1695 1696 if (aCmd.GetParam(0).pOsclAny_value == NULL) 1697 { 1698 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoAddDataSource() Passed in parameter invalid.")); 1699 return PVMFErrArgument; 1700 } 1701 1702 // Save the data source 1703 iDataSource = (PVPlayerDataSource*)(aCmd.GetParam(0).pOsclAny_value); 1704 1705 // Initiate the player setup sequence 1706 PVMFStatus cmdstatus = DoADSPlayerAddDataSource(aCmd.GetCmdId(), aCmd.GetContext()); 1707 1708 1709 if (cmdstatus == PVMFSuccess) 1710 { 1711 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZING); 1712 } 1713 1714 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoAddDataSource() Out")); 1715 return cmdstatus; 1716 } 1717 1718 1719 PVMFStatus PVFrameAndMetadataUtility::DoADSPlayerAddDataSource(PVCommandId aCmdId, OsclAny* aCmdContext) 1720 { 1721 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddDataSource() In")); 1722 1723 iUtilityContext.iCmdId = aCmdId; 1724 iUtilityContext.iCmdContext = aCmdContext; 1725 iUtilityContext.iCmdType = PVFM_CMD_ADSPlayerAddDataSource; 1726 int32 leavecode = 0; 1727 1728 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1729 (0, "PVFrameAndMetadataUtility::PlayerADS called Tick=%d", OsclTickCount::TickCount())); 1730 1731 OSCL_TRY(leavecode, iPlayer->AddDataSource(*iDataSource, (const OsclAny*)&iUtilityContext)); 1732 OSCL_FIRST_CATCH_ANY(leavecode, 1733 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddDataSource() AddDataSource() on player did a leave!")); 1734 return PVMFFailure;); 1735 1736 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddDataSource() Out")); 1737 return PVMFSuccess; 1738 } 1739 1740 1741 PVMFStatus PVFrameAndMetadataUtility::DoADSPlayerInit(PVCommandId aCmdId, OsclAny* aCmdContext) 1742 { 1743 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerInit() In")); 1744 1745 iUtilityContext.iCmdId = aCmdId; 1746 iUtilityContext.iCmdContext = aCmdContext; 1747 iUtilityContext.iCmdType = PVFM_CMD_ADSPlayerInit; 1748 int32 leavecode = 0; 1749 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1750 (0, "PVFrameAndMetadataUtility::PlayerInit() called Tick=%d", OsclTickCount::TickCount())); 1751 OSCL_TRY(leavecode, iPlayer->Init((const OsclAny*)&iUtilityContext)); 1752 OSCL_FIRST_CATCH_ANY(leavecode, 1753 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerInit() Init() on player did a leave!")); 1754 return PVMFFailure;); 1755 1756 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerInit() Out")); 1757 return PVMFSuccess; 1758 } 1759 1760 1761 PVMFStatus PVFrameAndMetadataUtility::DoADSPlayerAddVideoDataSink(PVCommandId aCmdId, OsclAny* aCmdContext) 1762 { 1763 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddVideoDataSink() In")); 1764 1765 int32 leavecode = 0; 1766 OSCL_TRY(leavecode, iVideoMIO = OSCL_NEW(PVFMVideoMIO, ()); 1767 iVideoNode = PVMediaOutputNodeFactory::CreateMediaOutputNode(iVideoMIO)); 1768 OSCL_FIRST_CATCH_ANY(leavecode, 1769 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddVideoDataSink() Instantiation of MIO component and node for frame retrieval did a leave!")); 1770 return PVMFErrNoMemory; 1771 ); 1772 iVideoDataSink.SetDataSinkNode(iVideoNode); 1773 iVideoDataSink.SetDataSinkFormatType(PVMF_MIME_YUV420); 1774 iVideoMIO->setThumbnailDimensions(iThumbnailWidth, iThumbnailHeight); 1775 1776 iUtilityContext.iCmdId = aCmdId; 1777 iUtilityContext.iCmdContext = aCmdContext; 1778 iUtilityContext.iCmdType = PVFM_CMD_ADSPlayerAddVideoDataSink; 1779 1780 leavecode = 0; 1781 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1782 (0, "PVFrameAndMetadataUtility::PlayerAddVideoSink Called Tick=%d", OsclTickCount::TickCount())); 1783 1784 OSCL_TRY(leavecode, iPlayer->AddDataSink(iVideoDataSink, (const OsclAny*)&iUtilityContext)); 1785 OSCL_FIRST_CATCH_ANY(leavecode, 1786 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddVideoDataSink() AddDataSink() on player did a leave!")); 1787 return PVMFFailure;); 1788 1789 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddVideoDataSink() Out")); 1790 return PVMFSuccess; 1791 } 1792 1793 PVMFStatus PVFrameAndMetadataUtility::DoADSPlayerAddAudioDataSink(PVCommandId aCmdId, OsclAny* aCmdContext) 1794 { 1795 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddAudioDataSink() In")); 1796 1797 int32 leavecode = 0; 1798 OSCL_TRY(leavecode, iAudioMIO = OSCL_NEW(PVFMAudioMIO, ()); 1799 iAudioNode = PVMediaOutputNodeFactory::CreateMediaOutputNode(iAudioMIO)); 1800 OSCL_FIRST_CATCH_ANY(leavecode, 1801 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddAudioDataSink() Instantiation of Audio MIO component and node for frame retrieval did a leave!")); 1802 return PVMFErrNoMemory; 1803 ); 1804 iAudioDataSink.SetDataSinkNode(iAudioNode); 1805 iAudioDataSink.SetDataSinkFormatType(PVMF_MIME_PCM16); 1806 1807 iUtilityContext.iCmdId = aCmdId; 1808 iUtilityContext.iCmdContext = aCmdContext; 1809 iUtilityContext.iCmdType = PVFM_CMD_ADSPlayerAddAudioDataSink; 1810 1811 leavecode = 0; 1812 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1813 (0, "PVFrameAndMetadataUtility::PlayerAddAudioSink Called Tick=%d", OsclTickCount::TickCount())); 1814 OSCL_TRY(leavecode, iPlayer->AddDataSink(iAudioDataSink, (const OsclAny*)&iUtilityContext)); 1815 OSCL_FIRST_CATCH_ANY(leavecode, 1816 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddAudioDataSink() AddDataSink() on player did a leave!")); 1817 return PVMFFailure;); 1818 1819 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerAddAudioDataSink() Out")); 1820 return PVMFSuccess; 1821 } 1822 1823 PVMFStatus PVFrameAndMetadataUtility::DoADSPlayerPrepare(PVCommandId aCmdId, OsclAny* aCmdContext) 1824 { 1825 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerPrepare() In")); 1826 1827 iUtilityContext.iCmdId = aCmdId; 1828 iUtilityContext.iCmdContext = aCmdContext; 1829 iUtilityContext.iCmdType = PVFM_CMD_ADSPlayerPrepare; 1830 int32 leavecode = 0; 1831 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1832 (0, "PVFrameAndMetadataUtility::PlayerPrepare Called Tick=%d", OsclTickCount::TickCount())); 1833 OSCL_TRY(leavecode, iPlayer->Prepare((const OsclAny*)&iUtilityContext)); 1834 OSCL_FIRST_CATCH_ANY(leavecode, 1835 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerPrepare() Prepare() on player did a leave!")); 1836 return PVMFFailure;); 1837 1838 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerPrepare() Out")); 1839 return PVMFSuccess; 1840 } 1841 1842 1843 PVMFStatus PVFrameAndMetadataUtility::DoADSPlayerStart(PVCommandId aCmdId, OsclAny* aCmdContext) 1844 { 1845 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerStart() In")); 1846 1847 iUtilityContext.iCmdId = aCmdId; 1848 iUtilityContext.iCmdContext = aCmdContext; 1849 iUtilityContext.iCmdType = PVFM_CMD_ADSPlayerStart; 1850 int32 leavecode = 0; 1851 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1852 (0, "PVFrameAndMetadataUtility::PlayerStart Called Tick=%d", OsclTickCount::TickCount())); 1853 OSCL_TRY(leavecode, iPlayer->Start((const OsclAny*)&iUtilityContext)); 1854 OSCL_FIRST_CATCH_ANY(leavecode, 1855 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerStart() Start() on player did a leave!")); 1856 return PVMFFailure;); 1857 1858 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerStart() Out")); 1859 return PVMFSuccess; 1860 } 1861 1862 1863 PVMFStatus PVFrameAndMetadataUtility::DoADSPlayerPause(PVCommandId aCmdId, OsclAny* aCmdContext) 1864 { 1865 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerPause() In")); 1866 1867 iUtilityContext.iCmdId = aCmdId; 1868 iUtilityContext.iCmdContext = aCmdContext; 1869 iUtilityContext.iCmdType = PVFM_CMD_ADSPlayerPause; 1870 int32 leavecode = 0; 1871 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1872 (0, "PVFrameAndMetadataUtility::PlayerPause Called Tick=%d", OsclTickCount::TickCount())); 1873 OSCL_TRY(leavecode, iPlayer->Pause((const OsclAny*)&iUtilityContext)); 1874 OSCL_FIRST_CATCH_ANY(leavecode, 1875 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoADSPlayerPause() Pause() on player did a leave!")); 1876 return PVMFFailure;); 1877 1878 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoADSPlayerPause() Out")); 1879 return PVMFSuccess; 1880 } 1881 1882 1883 PVMFStatus PVFrameAndMetadataUtility::DoGetMetadataKeys(PVFMUtilityCommand& aCmd) 1884 { 1885 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGetMetadataKeys() In")); 1886 1887 if (GetUtilityState() == PVFM_STATE_IDLE || GetUtilityState() == PVFM_STATE_ERROR) 1888 { 1889 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetMetadataKeys() Wrong state.")); 1890 return PVMFErrInvalidState; 1891 } 1892 1893 PVPMetadataList* keylist = (PVPMetadataList*)(aCmd.GetParam(0).pOsclAny_value); 1894 int32 startingkeyindex = aCmd.GetParam(1).int32_value; 1895 int32 maxkeyentries = aCmd.GetParam(2).int32_value; 1896 char* querykey = aCmd.GetParam(3).pChar_value; 1897 1898 if (keylist == NULL) 1899 { 1900 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetMetadataKeys() Passed in parameter invalid.")); 1901 return PVMFErrArgument; 1902 } 1903 1904 if (maxkeyentries < -1 || maxkeyentries == 0 || startingkeyindex < 0) 1905 { 1906 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetMetadataKeys() Passed in parameter invalid.")); 1907 return PVMFErrArgument; 1908 } 1909 1910 // Call player engine API to retrieve metadata keys 1911 PVMFStatus cmdstatus = DoPlayerGetMetadataKeys(aCmd.GetCmdId(), aCmd.GetContext(), *keylist, startingkeyindex, maxkeyentries, querykey); 1912 1913 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGetMetadataKeys() Out")); 1914 return cmdstatus; 1915 } 1916 1917 1918 PVMFStatus PVFrameAndMetadataUtility::DoPlayerGetMetadataKeys(PVCommandId aCmdId, OsclAny* aCmdContext, 1919 PVPMetadataList& aKeyList, int32 aStartingIndex, int32 aMaxEntries, char* aQueryKey) 1920 { 1921 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerGetMetadataKeys() In")); 1922 1923 iUtilityContext.iCmdId = aCmdId; 1924 iUtilityContext.iCmdContext = aCmdContext; 1925 iUtilityContext.iCmdType = PVFM_CMD_PlayerGetMetadataKeys; 1926 int32 leavecode = 0; 1927 OSCL_ASSERT(iPlayer != NULL); 1928 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1929 (0, "PVFrameAndMetadataUtility::PlayerGetMetaDataKeys Called Tick=%d", OsclTickCount::TickCount())); 1930 OSCL_TRY(leavecode, iPlayer->GetMetadataKeys(aKeyList, aStartingIndex, aMaxEntries, aQueryKey, (const OsclAny*)&iUtilityContext)); 1931 OSCL_FIRST_CATCH_ANY(leavecode, 1932 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoPlayerGetMetadataKeys() GetMetadataKeys() on player did a leave!")); 1933 return PVMFFailure;); 1934 1935 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerGetMetadataKeys() Out")); 1936 return PVMFSuccess; 1937 } 1938 1939 1940 PVMFStatus PVFrameAndMetadataUtility::DoGetMetadataValues(PVFMUtilityCommand& aCmd) 1941 { 1942 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGetMetadataValues() In")); 1943 1944 if (GetUtilityState() == PVFM_STATE_IDLE || GetUtilityState() == PVFM_STATE_ERROR) 1945 { 1946 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetMetadataValues() Wrong state")); 1947 return PVMFErrInvalidState; 1948 } 1949 1950 PVPMetadataList* keylist = (PVPMetadataList*)(aCmd.GetParam(0).pOsclAny_value); 1951 int32 startingvalueindex = aCmd.GetParam(1).int32_value; 1952 int32 maxvalueentries = aCmd.GetParam(2).int32_value; 1953 int32* numavailablevalues = (int32*)(aCmd.GetParam(3).pOsclAny_value); 1954 Oscl_Vector<PvmiKvp, OsclMemAllocator>* valuelist = (Oscl_Vector<PvmiKvp, OsclMemAllocator>*)(aCmd.GetParam(4).pOsclAny_value); 1955 1956 if (keylist == NULL || valuelist == NULL || numavailablevalues == NULL) 1957 { 1958 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetMetadataValues() Passed in parameter invalid.")); 1959 return PVMFErrArgument; 1960 } 1961 1962 if (maxvalueentries < -1 || maxvalueentries == 0 || startingvalueindex < 0) 1963 { 1964 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetMetadataValues() Passed in parameter invalid.")); 1965 return PVMFErrArgument; 1966 } 1967 1968 // Call the player engine API to retrieve metadata values 1969 PVMFStatus cmdstatus = DoPlayerGetMetadataValues(aCmd.GetCmdId(), aCmd.GetContext(), *keylist, startingvalueindex, maxvalueentries, *numavailablevalues, *valuelist); 1970 1971 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGetMetadataValues() Out")); 1972 return cmdstatus; 1973 } 1974 1975 1976 PVMFStatus PVFrameAndMetadataUtility::DoPlayerGetMetadataValues(PVCommandId aCmdId, OsclAny* aCmdContext, 1977 PVPMetadataList& aKeyList, int32 aStartingValueIndex, int32 aMaxValueEntries, 1978 int32& aNumAvailableValueEntries, Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList) 1979 { 1980 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerGetMetadataValues() In")); 1981 1982 iUtilityContext.iCmdId = aCmdId; 1983 iUtilityContext.iCmdContext = aCmdContext; 1984 iUtilityContext.iCmdType = PVFM_CMD_PlayerGetMetadataValues; 1985 int32 leavecode = 0; 1986 OSCL_ASSERT(iPlayer != NULL); 1987 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 1988 (0, "PVFrameAndMetadataUtility::PlayerGetMetaDataValues Called Tick=%d", OsclTickCount::TickCount())); 1989 OSCL_TRY(leavecode, iPlayer->GetMetadataValues(aKeyList, aStartingValueIndex, aMaxValueEntries, aNumAvailableValueEntries, aValueList, (const OsclAny*)&iUtilityContext)); 1990 OSCL_FIRST_CATCH_ANY(leavecode, 1991 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoPlayerGetMetadataValues() GetMetadataValues() on player did a leave!")); 1992 return PVMFFailure;); 1993 1994 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerGetMetadataValues() Out")); 1995 return PVMFSuccess; 1996 } 1997 1998 PVMFStatus PVFrameAndMetadataUtility::DoCapConfigSetParameters(PVFMUtilityCommand& aCmd, bool aSyncCmd) 1999 { 2000 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoCapConfigSetParameters() In")); 2001 2002 PvmiKvp* paramkvp; 2003 int32 numparam; 2004 PvmiKvp** retkvp; 2005 paramkvp = (PvmiKvp*)(aCmd.GetParam(0).pOsclAny_value); 2006 numparam = aCmd.GetParam(1).int32_value; 2007 retkvp = (PvmiKvp**)(aCmd.GetParam(2).pOsclAny_value); 2008 2009 if (paramkvp == NULL || retkvp == NULL || numparam < 1) 2010 { 2011 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoCapConfigSetParameters() Passed in parameter invalid")); 2012 return PVMFErrArgument; 2013 } 2014 2015 // Go through each parameter 2016 for (int32 paramind = 0; paramind < numparam; ++paramind) 2017 { 2018 // Count the number of components and parameters in the key 2019 int compcount = pv_mime_string_compcnt(paramkvp[paramind].key); 2020 // Retrieve the first component from the key string 2021 char* compstr = NULL; 2022 pv_mime_string_extract_type(0, paramkvp[paramind].key, compstr); 2023 2024 if ((pv_mime_strcmp(compstr, _STRLIT_CHAR("x-pvmf")) < 0) || compcount < 2) 2025 { 2026 // First component should be "x-pvmf" and there must 2027 // be at least two components to go past x-pvmf 2028 *retkvp = ¶mkvp[paramind]; 2029 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoCapConfigSetParameters() Unsupported key")); 2030 return PVMFErrArgument; 2031 } 2032 2033 // Retrieve the second component from the key string 2034 pv_mime_string_extract_type(1, paramkvp[paramind].key, compstr); 2035 2036 // First check if it is key string for fmu ("fmu") 2037 if (pv_mime_strcmp(compstr, _STRLIT_CHAR("fmu")) >= 0) 2038 { 2039 if (compcount == 3) 2040 { 2041 // Verify and set the passed-in fmu setting 2042 PVMFStatus retval = DoVerifyAndSetFMUParameter(paramkvp[paramind], true); 2043 if (retval != PVMFSuccess) 2044 { 2045 *retkvp = ¶mkvp[paramind]; 2046 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoCapConfigSetParameters() Setting parameter %d failed", paramind)); 2047 return retval; 2048 } 2049 } 2050 else 2051 { 2052 // Do not support other keys right now 2053 *retkvp = ¶mkvp[paramind]; 2054 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoCapConfigSetParameters() Unsupported key")); 2055 return PVMFErrArgument; 2056 } 2057 } 2058 else 2059 { 2060 PVMFStatus cmdstatus = DoPlayerSetParametersSync(aCmd.GetCmdId(), aCmd.GetContext(), paramkvp, numparam, *retkvp); 2061 if (PVMFSuccess != cmdstatus) 2062 { 2063 return cmdstatus; 2064 } 2065 } 2066 } 2067 2068 if (!aSyncCmd) 2069 { 2070 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoCapConfigSetParameters() - Queuing up CommandComplete for a ASync command")); 2071 UtilityCommandCompleted(aCmd.GetCmdId(), aCmd.GetContext(), PVMFSuccess); 2072 } 2073 2074 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoCapConfigSetParameters() Out")); 2075 return PVMFSuccess; 2076 } 2077 2078 PVMFStatus PVFrameAndMetadataUtility::DoPlayerSetParametersSync(PVCommandId aCmdId, OsclAny* aCmdContext, PvmiKvp* aParameters, int aNumElements, PvmiKvp* &aRetKVP) 2079 { 2080 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerSetParameterSync() In")); 2081 2082 iUtilityContext.iCmdId = aCmdId; 2083 iUtilityContext.iCmdContext = aCmdContext; 2084 iUtilityContext.iCmdType = PVFM_CMD_PlayerSetParametersSync; 2085 int32 leavecode = 0; 2086 OSCL_ASSERT(iPlayerCapConfigIF != NULL); 2087 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2088 (0, "PVFrameAndMetadataUtility::Player setParametersSync Called Tick=%d", OsclTickCount::TickCount())); 2089 OSCL_TRY(leavecode, iPlayerCapConfigIF->setParametersSync(NULL, aParameters, aNumElements, aRetKVP)); 2090 OSCL_FIRST_CATCH_ANY(leavecode, 2091 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoPlayerQueryInterface() QueryInterface() on player did a leave!")); 2092 return PVMFFailure;); 2093 2094 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerSetParameterSync() Out")); 2095 return PVMFSuccess; 2096 } 2097 2098 2099 PVMFStatus PVFrameAndMetadataUtility::DoVerifyAndSetFMUParameter(PvmiKvp& aParameter, bool aSetParam) 2100 { 2101 OSCL_UNUSED_ARG(aSetParam); 2102 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoVerifyAndSetFMUParameter() In")); 2103 2104 PVMFStatus status = PVMFErrNotSupported; 2105 // Retrieve the third component from the key string 2106 char* compstr = NULL; 2107 pv_mime_string_extract_type(2, aParameter.key, compstr); 2108 2109 // Check if it is key string "timeout" 2110 if (pv_mime_strcmp(compstr, _STRLIT_CHAR("timeout")) >= 0) 2111 { 2112 if (oscl_strncmp(aParameter.key, PVFMUTIL_FRAMERETRIEVAL_TIMEOUT_KEY, oscl_strlen(PVFMUTIL_FRAMERETRIEVAL_TIMEOUT_KEY)) == 0) 2113 { 2114 iFrameReadyWaitTime = aParameter.value.uint32_value; 2115 status = PVMFSuccess; 2116 } 2117 // Possible addition: Error handling timeout 2118 } 2119 2120 return status; 2121 } 2122 bool PVFrameAndMetadataUtility::HasVideo() 2123 { 2124 //Query the MIO component for it's video format. If the format 2125 //is "unknown" then it's very likely the clip has no video. 2126 bool hasVideo = false; 2127 if (iVideoMIO) 2128 { 2129 PvmiKvp* kvp = NULL; 2130 int32 count = 0; 2131 OSCL_HeapString<OsclMemAllocator> str; 2132 str = MOUT_VIDEO_FORMAT_KEY; 2133 if (iVideoMIO->getParametersSync(0, (char*)str.get_cstr(), kvp, count, NULL) == PVMFSuccess) 2134 { 2135 if (kvp 2136 && kvp->value.pChar_value) 2137 { 2138 str = kvp->value.pChar_value; 2139 if (!(str == PVMF_MIME_FORMAT_UNKNOWN)) 2140 hasVideo = true; 2141 } 2142 iVideoMIO->releaseParameters(0, kvp, count); 2143 } 2144 } 2145 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HasVideo() %d", hasVideo)); 2146 return hasVideo; 2147 } 2148 2149 2150 PVMFStatus PVFrameAndMetadataUtility::DoGetFrame(PVFMUtilityCommand& aCmd) 2151 { 2152 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGetFrame() In")); 2153 2154 /* 2155 GetFrame can be called only when UI sets the correct mode either 2156 PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_AND_THUMBNAIL or PV_FRAME_METADATA_INTERFACE_MODE_ALL 2157 */ 2158 if (iMode == PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_ONLY) 2159 { 2160 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetFrame() called in wrong mode (%d)", iMode)); 2161 return PVMFErrArgument; 2162 } 2163 int32 leavecode = 0; 2164 2165 // Retrieve the requested video frame 2166 uint8* userframebuffer = NULL; 2167 uint8** utilityframebuffer = NULL; 2168 2169 iVideoFrameSelector = (PVFrameSelector*)(aCmd.GetParam(0).pOsclAny_value); 2170 iVideoFrameBufferSize = aCmd.GetParam(2).pUint32_value; 2171 iVideoFrameBufferProp = (PVFrameBufferProperty*)(aCmd.GetParam(3).pOsclAny_value); 2172 2173 if (iVideoFrameSelector == NULL || iVideoFrameBufferProp == NULL || iVideoFrameBufferSize == NULL) 2174 { 2175 return PVMFErrArgument; 2176 } 2177 2178 // Validate the frame selection mode 2179 if (iVideoFrameSelector->iSelectionMethod != PVFrameSelector::SPECIFIC_FRAME && 2180 iVideoFrameSelector->iSelectionMethod != PVFrameSelector::TIMESTAMP) 2181 { 2182 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetFrame() Unsupported frame selection method.")); 2183 return PVMFErrNotSupported; 2184 } 2185 2186 if (aCmd.GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER) 2187 { 2188 utilityframebuffer = (uint8**)(aCmd.GetParam(1).pOsclAny_value); 2189 if (utilityframebuffer == NULL) 2190 { 2191 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetFrame() Passed in parameter invalid.")); 2192 return PVMFErrArgument; 2193 } 2194 2195 // Create the memory pool for the video frame buffer if not created yet 2196 if (iVideoFrameBufferMemPool == NULL) 2197 { 2198 leavecode = 0; 2199 OSCL_TRY(leavecode, iVideoFrameBufferMemPool = OSCL_NEW(OsclMemPoolResizableAllocator, (PVFMUTIL_VIDEOFRAMEBUFFER_MEMPOOL_BUFFERSIZE))); 2200 OSCL_FIRST_CATCH_ANY(leavecode, 2201 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetFrame() Memory pool for video frame buffer could not be instantiated.")); 2202 return PVMFErrNoMemory; 2203 ); 2204 } 2205 2206 // Allocate video buffer from memory pool 2207 leavecode = 0; 2208 OSCL_TRY(leavecode, *utilityframebuffer = (uint8*)(iVideoFrameBufferMemPool->allocate(PVFMUTIL_VIDEOFRAMEBUFFER_MAXSIZE))); 2209 OSCL_FIRST_CATCH_ANY(leavecode, 2210 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetFrame() Memory pool for video frame buffer could not be instantiated.")); 2211 return PVMFErrNoMemory; 2212 ); 2213 2214 *iVideoFrameBufferSize = PVFMUTIL_VIDEOFRAMEBUFFER_MAXSIZE; 2215 iCurrentVideoFrameBuffer = *utilityframebuffer; 2216 } 2217 else 2218 { 2219 userframebuffer = aCmd.GetParam(1).pUint8_value; 2220 if (userframebuffer == NULL || *iVideoFrameBufferSize == 0) 2221 { 2222 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetFrame() Passed in parameter invalid.")); 2223 return PVMFErrArgument; 2224 } 2225 2226 iCurrentVideoFrameBuffer = userframebuffer; 2227 } 2228 2229 PVPlayerState playerstate; 2230 PVMFStatus retval = iPlayer->GetPVPlayerStateSync(playerstate); 2231 if (retval == PVMFSuccess) 2232 { 2233 if (playerstate == PVP_STATE_INITIALIZED) 2234 { 2235 // Start playback 2236 retval = DoGFPlayerPrepare(aCmd.GetCmdId(), aCmd.GetContext()); 2237 } 2238 else if (playerstate == PVP_STATE_PAUSED) 2239 { 2240 if (!HasVideo()) 2241 { 2242 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGetFrame() No video present")); 2243 return PVMFFailure; 2244 } 2245 // Stop first to return to initialized state 2246 retval = DoGFPlayerStopFromPaused(aCmd.GetCmdId(), aCmd.GetContext()); 2247 } 2248 else 2249 { 2250 // Player engine should not be in any other state 2251 // Report as underlying resource error 2252 OSCL_ASSERT(false); 2253 retval = PVMFErrResource; 2254 } 2255 } 2256 2257 if (retval != PVMFSuccess && aCmd.GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 2258 { 2259 // Return the buffer if allocated from utility's mempool 2260 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 2261 } 2262 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGetFrame() Out")); 2263 return retval; 2264 } 2265 2266 2267 PVMFStatus PVFrameAndMetadataUtility::DoGFPlayerStopFromPaused(PVCommandId aCmdId, OsclAny* aCmdContext) 2268 { 2269 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerStopFromPaused() In")); 2270 2271 iUtilityContext.iCmdId = aCmdId; 2272 iUtilityContext.iCmdContext = aCmdContext; 2273 iUtilityContext.iCmdType = PVFM_CMD_GFPlayerStopFromPaused; 2274 int32 leavecode = 0; 2275 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2276 (0, "PVFrameAndMetadataUtility::PlayerStop Called Tick=%d", OsclTickCount::TickCount())); 2277 OSCL_TRY(leavecode, iPlayer->Stop((const OsclAny*)&iUtilityContext)); 2278 OSCL_FIRST_CATCH_ANY(leavecode, 2279 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGFPlayerStopFromPaused() Stop() on player did a leave!")); 2280 return PVMFFailure;); 2281 2282 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerStopFromPaused() Out")); 2283 return PVMFSuccess; 2284 } 2285 2286 2287 PVMFStatus PVFrameAndMetadataUtility::DoGFPlayerPrepare(PVCommandId aCmdId, OsclAny* aCmdContext) 2288 { 2289 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerPrepare() In")); 2290 2291 // Assert if the frame retrieval variables are not set yet 2292 OSCL_ASSERT(iVideoFrameSelector != NULL); 2293 OSCL_ASSERT(iCurrentVideoFrameBuffer != NULL); 2294 OSCL_ASSERT(iVideoFrameBufferSize != NULL); 2295 OSCL_ASSERT(*iVideoFrameBufferSize > 0); 2296 2297 // Reset the flag for frame received 2298 iFrameReceived = false; 2299 2300 PVMFStatus retval; 2301 if (iVideoFrameSelector->iSelectionMethod == PVFrameSelector::SPECIFIC_FRAME) 2302 { 2303 // Request the frame retrieval video MIO to retrieve the specified frame 2304 retval = iVideoMIO->GetFrameByFrameNumber(iVideoFrameSelector->iFrameInfo.iFrameIndex, iCurrentVideoFrameBuffer, *iVideoFrameBufferSize, iOutputFormatType, *this); 2305 } 2306 else if (iVideoFrameSelector->iSelectionMethod == PVFrameSelector::TIMESTAMP) 2307 { 2308 // Request the frame retrieval video MIO to retrieve the specified timestamp 2309 retval = iVideoMIO->GetFrameByTimeoffset(iVideoFrameSelector->iFrameInfo.iTimeOffsetMilliSec, iCurrentVideoFrameBuffer, *iVideoFrameBufferSize, iOutputFormatType, *this); 2310 } 2311 else 2312 { 2313 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGFPlayerPrepare() Unsupported frame selection method.")); 2314 retval = PVMFErrNotSupported; 2315 } 2316 2317 if (retval != PVMFPending) 2318 { 2319 OSCL_ASSERT(retval != PVMFSuccess); 2320 return retval; 2321 } 2322 2323 iUtilityContext.iCmdId = aCmdId; 2324 iUtilityContext.iCmdContext = aCmdContext; 2325 iUtilityContext.iCmdType = PVFM_CMD_GFPlayerPrepare; 2326 int32 leavecode = 0; 2327 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2328 (0, "PVFrameAndMetadataUtility::PlayerPrepare Called Tick=%d", OsclTickCount::TickCount())); 2329 OSCL_TRY(leavecode, iPlayer->Prepare((const OsclAny*)&iUtilityContext)); 2330 OSCL_FIRST_CATCH_ANY(leavecode, 2331 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGFPlayerPrepare() Prepare() on player did a leave!")); 2332 return PVMFFailure;); 2333 2334 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerPrepare() Out")); 2335 return PVMFSuccess; 2336 } 2337 2338 2339 PVMFStatus PVFrameAndMetadataUtility::DoGFPlayerStart(PVCommandId aCmdId, OsclAny* aCmdContext) 2340 { 2341 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerStart() In")); 2342 2343 iUtilityContext.iCmdId = aCmdId; 2344 iUtilityContext.iCmdContext = aCmdContext; 2345 iUtilityContext.iCmdType = PVFM_CMD_GFPlayerStart; 2346 int32 leavecode = 0; 2347 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2348 (0, "PVFrameAndMetadataUtility::PlayerStart Called Tick=%d", OsclTickCount::TickCount())); 2349 OSCL_TRY(leavecode, iPlayer->Start((const OsclAny*)&iUtilityContext)); 2350 OSCL_FIRST_CATCH_ANY(leavecode, 2351 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGFPlayerStart() Start() on player did a leave!")); 2352 return PVMFFailure;); 2353 2354 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerStart() Out")); 2355 return PVMFSuccess; 2356 } 2357 2358 2359 PVMFStatus PVFrameAndMetadataUtility::DoGFPlayerPause(PVCommandId aCmdId, OsclAny* aCmdContext) 2360 { 2361 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerPause() In")); 2362 2363 PVPlayerState playerstate; 2364 PVMFStatus retval = iPlayer->GetPVPlayerStateSync(playerstate); 2365 if (retval == PVMFSuccess && playerstate == PVP_STATE_PAUSED) 2366 { 2367 // Player is already in paused state (due to EOS?) 2368 // so need to pause playback 2369 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerPause() Playback already paused")); 2370 return PVMFErrInvalidState; 2371 } 2372 2373 iUtilityContext.iCmdId = aCmdId; 2374 iUtilityContext.iCmdContext = aCmdContext; 2375 iUtilityContext.iCmdType = PVFM_CMD_GFPlayerPause; 2376 int32 leavecode = 0; 2377 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2378 (0, "PVFrameAndMetadataUtility::PlayerPause Called Tick=%d", OsclTickCount::TickCount())); 2379 OSCL_TRY(leavecode, iPlayer->Pause((const OsclAny*)&iUtilityContext)); 2380 OSCL_FIRST_CATCH_ANY(leavecode, 2381 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoGFPlayerPause() Pause() on player did a leave!")); 2382 return PVMFFailure;); 2383 2384 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoGFPlayerPause() Out")); 2385 return PVMFSuccess; 2386 } 2387 2388 2389 PVMFStatus PVFrameAndMetadataUtility::DoReturnBuffer(PVFMUtilityCommand& aCmd) 2390 { 2391 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoReturnBuffer() In")); 2392 2393 uint8* retbuffer = NULL; 2394 retbuffer = aCmd.GetParam(0).pUint8_value; 2395 if (retbuffer == NULL) 2396 { 2397 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoReturnBuffer() Specified buffer is NULL")); 2398 return PVMFErrArgument; 2399 } 2400 2401 // Return the video frame buffer 2402 int32 leavecode = 0; 2403 OSCL_TRY(leavecode, iVideoFrameBufferMemPool->deallocate((OsclAny*)retbuffer)); 2404 OSCL_FIRST_CATCH_ANY(leavecode, 2405 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoReturnBuffer() Specified buffer causes a leave in mempool when deallocating")); 2406 return PVMFErrArgument; 2407 ); 2408 2409 UtilityCommandCompleted(aCmd.GetCmdId(), aCmd.GetContext(), PVMFSuccess); 2410 2411 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoReturnBuffer() Out")); 2412 return PVMFSuccess; 2413 } 2414 2415 2416 PVMFStatus PVFrameAndMetadataUtility::DoRemoveDataSource(PVFMUtilityCommand& aCmd) 2417 { 2418 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRemoveDataSource() In")); 2419 2420 if (GetUtilityState() != PVFM_STATE_INITIALIZED) 2421 { 2422 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoRemoveDataSource() Wrong state")); 2423 return PVMFErrInvalidState; 2424 } 2425 2426 if (iDataSource != (PVPlayerDataSource*)(aCmd.GetParam(0).pOsclAny_value)) 2427 { 2428 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoRemoveDataSource() Passed in parameter invalid")); 2429 return PVMFErrArgument; 2430 } 2431 2432 // Tell player engine to remove data sink, reset, and remove data source 2433 PVMFStatus cmdstatus = PVMFFailure; 2434 PVPlayerState playerstate; 2435 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 2436 if (pretval == PVMFSuccess) 2437 { 2438 if (playerstate == PVP_STATE_INITIALIZED) 2439 { 2440 // Start with remove data sink 2441 if (iVideoNode && iVideoMIO) 2442 { 2443 cmdstatus = DoRDSPlayerRemoveVideoDataSink(aCmd.GetCmdId(), aCmd.GetContext()); 2444 } 2445 else if (iAudioNode && iAudioMIO) 2446 { 2447 cmdstatus = DoRDSPlayerRemoveAudioDataSink(aCmd.GetCmdId(), aCmd.GetContext()); 2448 } 2449 else 2450 { 2451 cmdstatus = DoRDSPlayerReset(aCmd.GetCmdId(), aCmd.GetContext()); 2452 } 2453 } 2454 else if (playerstate == PVP_STATE_PAUSED || playerstate == PVP_STATE_STARTED || playerstate == PVP_STATE_PREPARED) 2455 { 2456 // Stop first to return to initialized state 2457 cmdstatus = DoRDSPlayerStop(aCmd.GetCmdId(), aCmd.GetContext()); 2458 } 2459 else if (playerstate == PVP_STATE_IDLE) 2460 { 2461 // Call RemoveDataSource() on player 2462 cmdstatus = DoRDSPlayerRemoveDataSource(aCmd.GetCmdId(), aCmd.GetContext()); 2463 if (cmdstatus != PVMFSuccess) 2464 { 2465 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoRemoveDataSource: RemoveDataSource on player failed. Report command as failed")); 2466 2467 iAPICmdStatus = cmdstatus; 2468 if (iAPICmdErrMsg) 2469 { 2470 iAPICmdErrMsg->removeRef(); 2471 iAPICmdErrMsg = NULL; 2472 } 2473 // Need to shutdown/restart player and cleanup in utility's AO 2474 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 2475 iErrorHandlingInUtilityAO = true; 2476 RunIfNotReady(); 2477 } 2478 } 2479 else 2480 { 2481 // Player engine should not be in any other state 2482 // Report as underlying resource error 2483 OSCL_ASSERT(false); 2484 cmdstatus = PVMFErrResource; 2485 } 2486 } 2487 else 2488 { 2489 // Player engine state could not be checked so error out 2490 cmdstatus = pretval; 2491 } 2492 2493 if (cmdstatus == PVMFSuccess) 2494 { 2495 SetUtilityState(PVFM_UTILITY_STATE_RESETTING); 2496 } 2497 2498 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRemoveDataSource() Out")); 2499 return cmdstatus; 2500 } 2501 2502 2503 PVMFStatus PVFrameAndMetadataUtility::DoRDSPlayerStop(PVCommandId aCmdId, OsclAny* aCmdContext) 2504 { 2505 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerStop In")); 2506 2507 iUtilityContext.iCmdId = aCmdId; 2508 iUtilityContext.iCmdContext = aCmdContext; 2509 iUtilityContext.iCmdType = PVFM_CMD_RDSPlayerStopFromPaused; 2510 int32 leavecode = 0; 2511 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2512 (0, "PVFrameAndMetadataUtility::RDSPlayerStop Called Tick=%d", OsclTickCount::TickCount())); 2513 OSCL_TRY(leavecode, iPlayer->Stop((const OsclAny*)&iUtilityContext)); 2514 OSCL_FIRST_CATCH_ANY(leavecode, 2515 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoRDSPlayerStop Stop() on player did a leave!")); 2516 return PVMFFailure;); 2517 2518 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerStop Out")); 2519 return PVMFSuccess; 2520 } 2521 2522 2523 PVMFStatus PVFrameAndMetadataUtility::DoRDSPlayerRemoveVideoDataSink(PVCommandId aCmdId, OsclAny* aCmdContext) 2524 { 2525 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveVideoDataSink() In")); 2526 2527 iUtilityContext.iCmdId = aCmdId; 2528 iUtilityContext.iCmdContext = aCmdContext; 2529 iUtilityContext.iCmdType = PVFM_CMD_RDSPlayerRemoveVideoDataSink; 2530 int32 leavecode = 0; 2531 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2532 (0, "PVFrameAndMetadataUtility::RDSPlayerRemoveVideoSink Called Tick=%d", OsclTickCount::TickCount())); 2533 OSCL_TRY(leavecode, iPlayer->RemoveDataSink(iVideoDataSink, (const OsclAny*)&iUtilityContext)); 2534 OSCL_FIRST_CATCH_ANY(leavecode, 2535 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveVideoDataSink() RemoveDataSink() on player did a leave!")); 2536 return PVMFFailure;); 2537 2538 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveVideoDataSink() Out")); 2539 return PVMFSuccess; 2540 } 2541 2542 PVMFStatus PVFrameAndMetadataUtility::DoRDSPlayerRemoveAudioDataSink(PVCommandId aCmdId, OsclAny* aCmdContext) 2543 { 2544 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveAudioDataSink() In")); 2545 2546 iUtilityContext.iCmdId = aCmdId; 2547 iUtilityContext.iCmdContext = aCmdContext; 2548 iUtilityContext.iCmdType = PVFM_CMD_RDSPlayerRemoveAudioDataSink; 2549 int32 leavecode = 0; 2550 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2551 (0, "PVFrameAndMetadataUtility::RDSPlayerRemoveAudioSink Called Tick=%d", OsclTickCount::TickCount())); 2552 OSCL_TRY(leavecode, iPlayer->RemoveDataSink(iAudioDataSink, (const OsclAny*)&iUtilityContext)); 2553 OSCL_FIRST_CATCH_ANY(leavecode, 2554 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveAudioDataSink() RemoveDataSink() on player did a leave!")); 2555 return PVMFFailure;); 2556 2557 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveAudioDataSink() Out")); 2558 return PVMFSuccess; 2559 } 2560 2561 PVMFStatus PVFrameAndMetadataUtility::DoRDSPlayerReset(PVCommandId aCmdId, OsclAny* aCmdContext) 2562 { 2563 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerReset() In")); 2564 2565 iUtilityContext.iCmdId = aCmdId; 2566 iUtilityContext.iCmdContext = aCmdContext; 2567 iUtilityContext.iCmdType = PVFM_CMD_RDSPlayerReset; 2568 int32 leavecode = 0; 2569 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2570 (0, "PVFrameAndMetadataUtility::RDSPlayerReset Called Tick=%d", OsclTickCount::TickCount())); 2571 OSCL_TRY(leavecode, iPlayer->Reset((const OsclAny*)&iUtilityContext)); 2572 OSCL_FIRST_CATCH_ANY(leavecode, 2573 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoRDSPlayerReset() Reset() on player did a leave!")); 2574 return PVMFFailure;); 2575 2576 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerReset() Out")); 2577 return PVMFSuccess; 2578 } 2579 2580 2581 PVMFStatus PVFrameAndMetadataUtility::DoRDSPlayerRemoveDataSource(PVCommandId aCmdId, OsclAny* aCmdContext) 2582 { 2583 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveDataSource() In")); 2584 2585 iUtilityContext.iCmdId = aCmdId; 2586 iUtilityContext.iCmdContext = aCmdContext; 2587 iUtilityContext.iCmdType = PVFM_CMD_RDSPlayerRemoveDataSource; 2588 int32 leavecode = 0; 2589 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2590 (0, "PVFrameAndMetadataUtility::RDSPlayerRemoveDataSource Called Tick=%d", OsclTickCount::TickCount())); 2591 OSCL_TRY(leavecode, iPlayer->RemoveDataSource(*iDataSource, (const OsclAny*)&iUtilityContext)); 2592 OSCL_FIRST_CATCH_ANY(leavecode, 2593 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveDataSource() RemoveDataSource() on player did a leave!")); 2594 return PVMFFailure;); 2595 2596 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoRDSPlayerRemoveDataSource() Out")); 2597 return PVMFSuccess; 2598 } 2599 2600 2601 PVMFStatus PVFrameAndMetadataUtility::DoPlayerShutdownRestart(void) 2602 { 2603 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerShutdownRestart() In")); 2604 2605 int32 leavecode = 0; 2606 2607 // First destroy the player engine instance 2608 OSCL_ASSERT(iPlayer != NULL); 2609 if (iPlayer != NULL) 2610 { 2611 PVPlayerFactory::DeletePlayer(iPlayer); 2612 iPlayer = NULL; 2613 } 2614 2615 // Recreate the player instance 2616 leavecode = 0; 2617 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2618 (0, "PVFrameAndMetadataUtility::CreatePlayer Called Tick=%d", OsclTickCount::TickCount())); 2619 OSCL_TRY(leavecode, iPlayer = PVPlayerFactory::CreatePlayer(this, this, this, iHwAccelerated)); 2620 OSCL_FIRST_CATCH_ANY(leavecode, 2621 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::DoPlayerShutdownRestart() Player engine could not be instantiated! Asserting")); 2622 OSCL_ASSERT(false); 2623 return PVMFErrNoMemory;); 2624 OSCL_ASSERT(iPlayer != NULL); 2625 2626 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::DoPlayerShutdownRestart() Out")); 2627 return PVMFSuccess; 2628 } 2629 2630 2631 void PVFrameAndMetadataUtility::HandlePlayerQueryUUID(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 2632 { 2633 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerQueryUUID() In")); 2634 2635 aUtilContext.iCmdType = -1; 2636 2637 switch (aCmdResp.GetCmdStatus()) 2638 { 2639 case PVMFSuccess: 2640 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2641 (0, "PVFrameAndMetadataUtility::PlayerQueryUUID completed successfully Tick=%d", OsclTickCount::TickCount())); 2642 // Report QueryUUID() command as succesfully complete 2643 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 2644 break; 2645 2646 default: 2647 { 2648 PVMFErrorInfoMessageInterface* nextmsg = NULL; 2649 if (aCmdResp.GetEventExtensionInterface()) 2650 { 2651 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 2652 } 2653 PVMFBasicErrorInfoMessage* errmsg = NULL; 2654 errmsg = CreateBasicErrInfoMessage(nextmsg); 2655 2656 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, aCmdResp.GetCmdStatus(), OSCL_STATIC_CAST(PVInterface*, errmsg)); 2657 if (errmsg) 2658 { 2659 errmsg->removeRef(); 2660 } 2661 } 2662 break; 2663 } 2664 2665 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerQueryUUID() Out")); 2666 } 2667 2668 2669 void PVFrameAndMetadataUtility::HandlePlayerQueryInterface(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 2670 { 2671 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerQueryInterface() In")); 2672 2673 switch (aCmdResp.GetCmdStatus()) 2674 { 2675 case PVMFSuccess: 2676 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2677 (0, "PVFrameAndMetadataUtility::PlayerQueryInterface completed successfully Tick=%d", OsclTickCount::TickCount())); 2678 if (aUtilContext.iCmdType == PVFM_CMD_PlayerQueryCapConfigInterface) 2679 iPlayerCapConfigIF = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*, iPlayerCapConfigIFPVI); 2680 // Report QueryInterface() command as succesfully complete 2681 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 2682 break; 2683 2684 default: 2685 { 2686 PVMFErrorInfoMessageInterface* nextmsg = NULL; 2687 if (aCmdResp.GetEventExtensionInterface()) 2688 { 2689 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 2690 } 2691 PVMFBasicErrorInfoMessage* errmsg = NULL; 2692 errmsg = CreateBasicErrInfoMessage(nextmsg); 2693 2694 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, aCmdResp.GetCmdStatus(), OSCL_STATIC_CAST(PVInterface*, errmsg)); 2695 if (errmsg) 2696 { 2697 errmsg->removeRef(); 2698 } 2699 } 2700 break; 2701 } 2702 2703 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerQueryInterface() Out")); 2704 } 2705 2706 2707 void PVFrameAndMetadataUtility::HandleADSPlayerAddDataSource(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 2708 { 2709 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddDataSource() In")); 2710 2711 aUtilContext.iCmdType = -1; 2712 2713 PVMFStatus cmdstatus = PVMFFailure; 2714 2715 switch (aCmdResp.GetCmdStatus()) 2716 { 2717 case PVMFSuccess: 2718 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2719 (0, "PVFrameAndMetadataUtility::PlayerADS completed successfully Tick=%d", OsclTickCount::TickCount())); 2720 // Call Init() on player 2721 cmdstatus = DoADSPlayerInit(aUtilContext.iCmdId, aUtilContext.iCmdContext); 2722 if (cmdstatus != PVMFSuccess) 2723 { 2724 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddDataSource() Init on player failed. Report command as failed")); 2725 iAPICmdStatus = cmdstatus; 2726 if (iAPICmdErrMsg) 2727 { 2728 iAPICmdErrMsg->removeRef(); 2729 iAPICmdErrMsg = NULL; 2730 } 2731 // Need to shutdown/restart player and cleanup in utility's AO 2732 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 2733 iErrorHandlingInUtilityAO = true; 2734 RunIfNotReady(); 2735 } 2736 break; 2737 2738 default: 2739 { 2740 PVMFErrorInfoMessageInterface* nextmsg = NULL; 2741 if (aCmdResp.GetEventExtensionInterface()) 2742 { 2743 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 2744 } 2745 PVMFBasicErrorInfoMessage* errmsg = NULL; 2746 errmsg = CreateBasicErrInfoMessage(nextmsg); 2747 2748 iAPICmdStatus = aCmdResp.GetCmdStatus(); 2749 if (iAPICmdErrMsg) 2750 { 2751 iAPICmdErrMsg->removeRef(); 2752 iAPICmdErrMsg = NULL; 2753 } 2754 iAPICmdErrMsg = errmsg; 2755 2756 // Check if player is handling the error 2757 PVPlayerState playerstate; 2758 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 2759 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 2760 { 2761 // Yes so wait for error handling to complete 2762 // Start a timer just in case the player does not report error handling complete 2763 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 2764 } 2765 else 2766 { 2767 // Need to shutdown/restart player and cleanup in utility's AO 2768 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 2769 iErrorHandlingInUtilityAO = true; 2770 RunIfNotReady(); 2771 } 2772 } 2773 break; 2774 } 2775 2776 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddDataSource() Out")); 2777 } 2778 2779 2780 void PVFrameAndMetadataUtility::HandleADSPlayerInit(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 2781 { 2782 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerInit() In")); 2783 2784 aUtilContext.iCmdType = -1; 2785 2786 PVMFStatus cmdstatus = PVMFFailure; 2787 2788 switch (aCmdResp.GetCmdStatus()) 2789 { 2790 case PVMFSuccess: 2791 { 2792 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2793 (0, "PVFrameAndMetadataUtility::PlayerInit completed successfully Tick=%d", OsclTickCount::TickCount())); 2794 if (iMode == PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_ONLY) 2795 { 2796 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_INFO, (0, "PVFrameAndMetadataUtility::HandleADSPlayerInit - ADS Complete")); 2797 // Utility's AddDataSource() successfully completed 2798 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZED); 2799 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2800 (0, "PVFrameAndMetadataUtility::AddDataSource completed sucessfully Tick=%d", OsclTickCount::TickCount())); 2801 2802 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 2803 } 2804 else 2805 { 2806 // Call AddDataSink() on player 2807 cmdstatus = DoADSPlayerAddVideoDataSink(aUtilContext.iCmdId, aUtilContext.iCmdContext); 2808 if (cmdstatus != PVMFSuccess) 2809 { 2810 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleADSPlayerInit() AddDataSink on player failed. Report command as failed")); 2811 iAPICmdStatus = aCmdResp.GetCmdStatus(); 2812 if (iAPICmdErrMsg) 2813 { 2814 iAPICmdErrMsg->removeRef(); 2815 iAPICmdErrMsg = NULL; 2816 } 2817 // Need to shutdown/restart player and cleanup in utility's AO 2818 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 2819 iErrorHandlingInUtilityAO = true; 2820 RunIfNotReady(); 2821 } 2822 } 2823 } 2824 break; 2825 2826 default: 2827 { 2828 PVMFErrorInfoMessageInterface* nextmsg = NULL; 2829 if (aCmdResp.GetEventExtensionInterface()) 2830 { 2831 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 2832 } 2833 PVMFBasicErrorInfoMessage* errmsg = NULL; 2834 errmsg = CreateBasicErrInfoMessage(nextmsg); 2835 2836 iAPICmdStatus = aCmdResp.GetCmdStatus(); 2837 if (iAPICmdErrMsg) 2838 { 2839 iAPICmdErrMsg->removeRef(); 2840 iAPICmdErrMsg = NULL; 2841 } 2842 iAPICmdErrMsg = errmsg; 2843 2844 // Check if player is handling the error 2845 PVPlayerState playerstate; 2846 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 2847 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 2848 { 2849 // Wait for error handling to complete 2850 // Start a timer just in case the player does not report error handling complete 2851 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 2852 } 2853 else 2854 { 2855 // Need to shutdown/restart player and cleanup in utility's AO 2856 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 2857 iErrorHandlingInUtilityAO = true; 2858 RunIfNotReady(); 2859 } 2860 } 2861 break; 2862 } 2863 2864 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerInit() Out")); 2865 } 2866 2867 void PVFrameAndMetadataUtility::HandleADSPlayerAddVideoDataSink(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 2868 { 2869 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddVideoDataSink() In")); 2870 2871 aUtilContext.iCmdType = -1; 2872 2873 switch (aCmdResp.GetCmdStatus()) 2874 { 2875 case PVMFSuccess: 2876 { 2877 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2878 (0, "PVFrameAndMetadataUtility::PlayerAddVideoDataSink completed successfully Tick=%d", OsclTickCount::TickCount())); 2879 if (iMode == PV_FRAME_METADATA_INTERFACE_MODE_SOURCE_METADATA_AND_THUMBNAIL) 2880 { 2881 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_INFO, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddVideoDataSink - ADS Complete")); 2882 // Utility's AddDataSource() successfully completed 2883 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZED); 2884 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2885 (0, "PVFrameAndMetadataUtility::AddDataSource completed sucessfully Tick=%d", OsclTickCount::TickCount())); 2886 2887 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 2888 } 2889 else 2890 { 2891 // Add Audio data sink 2892 PVMFStatus cmdstatus = DoADSPlayerAddAudioDataSink(aUtilContext.iCmdId, aUtilContext.iCmdContext); 2893 if (cmdstatus != PVMFSuccess) 2894 { 2895 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddVideoDataSink() AddAudioDataSink on player failed. Report command as failed")); 2896 iAPICmdStatus = aCmdResp.GetCmdStatus(); 2897 if (iAPICmdErrMsg) 2898 { 2899 iAPICmdErrMsg->removeRef(); 2900 iAPICmdErrMsg = NULL; 2901 } 2902 // Need to shutdown/restart player and cleanup in utility's AO 2903 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 2904 iErrorHandlingInUtilityAO = true; 2905 RunIfNotReady(); 2906 } 2907 } 2908 } 2909 break; 2910 2911 default: 2912 { 2913 PVMFErrorInfoMessageInterface* nextmsg = NULL; 2914 if (aCmdResp.GetEventExtensionInterface()) 2915 { 2916 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 2917 } 2918 2919 PVMFBasicErrorInfoMessage* errmsg = NULL; 2920 errmsg = CreateBasicErrInfoMessage(nextmsg); 2921 2922 iAPICmdStatus = aCmdResp.GetCmdStatus(); 2923 if (iAPICmdErrMsg) 2924 { 2925 iAPICmdErrMsg->removeRef(); 2926 iAPICmdErrMsg = NULL; 2927 } 2928 iAPICmdErrMsg = errmsg; 2929 2930 // Check if player is handling the error 2931 PVPlayerState playerstate; 2932 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 2933 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 2934 { 2935 // Wait for error handling to complete 2936 // Start a timer just in case the player does not report error handling complete 2937 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 2938 } 2939 else 2940 { 2941 // Need to shutdown/restart player and cleanup in utility's AO 2942 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 2943 iErrorHandlingInUtilityAO = true; 2944 RunIfNotReady(); 2945 } 2946 } 2947 break; 2948 } 2949 2950 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddVideoDataSink() Out")); 2951 } 2952 2953 void PVFrameAndMetadataUtility::HandleADSPlayerAddAudioDataSink(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 2954 { 2955 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddAudioDataSink() In")); 2956 2957 aUtilContext.iCmdType = -1; 2958 2959 switch (aCmdResp.GetCmdStatus()) 2960 { 2961 case PVMFSuccess: 2962 { 2963 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 2964 (0, "PVFrameAndMetadataUtility::PlayerAddAudioDataSink completed successfully Tick=%d", OsclTickCount::TickCount())); 2965 // Call Prepare() on player 2966 PVMFStatus cmdstatus = DoADSPlayerPrepare(aUtilContext.iCmdId, aUtilContext.iCmdContext); 2967 if (cmdstatus != PVMFSuccess) 2968 { 2969 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddAudioDataSink() Prepare on player failed. Report command as failed")); 2970 iAPICmdStatus = aCmdResp.GetCmdStatus(); 2971 if (iAPICmdErrMsg) 2972 { 2973 iAPICmdErrMsg->removeRef(); 2974 iAPICmdErrMsg = NULL; 2975 } 2976 // Need to shutdown/restart player and cleanup in utility's AO 2977 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 2978 iErrorHandlingInUtilityAO = true; 2979 RunIfNotReady(); 2980 } 2981 } 2982 break; 2983 2984 default: 2985 { 2986 PVMFErrorInfoMessageInterface* nextmsg = NULL; 2987 if (aCmdResp.GetEventExtensionInterface()) 2988 { 2989 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 2990 } 2991 2992 PVMFBasicErrorInfoMessage* errmsg = NULL; 2993 errmsg = CreateBasicErrInfoMessage(nextmsg); 2994 2995 iAPICmdStatus = aCmdResp.GetCmdStatus(); 2996 if (iAPICmdErrMsg) 2997 { 2998 iAPICmdErrMsg->removeRef(); 2999 iAPICmdErrMsg = NULL; 3000 } 3001 iAPICmdErrMsg = errmsg; 3002 3003 // Check if player is handling the error 3004 PVPlayerState playerstate; 3005 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3006 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3007 { 3008 // Wait for error handling to complete 3009 // Start a timer just in case the player does not report error handling complete 3010 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3011 } 3012 else 3013 { 3014 // Need to shutdown/restart player and cleanup in utility's AO 3015 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3016 iErrorHandlingInUtilityAO = true; 3017 RunIfNotReady(); 3018 } 3019 } 3020 break; 3021 } 3022 3023 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerAddVideoDataSink() Out")); 3024 } 3025 3026 3027 void PVFrameAndMetadataUtility::HandleADSPlayerPrepare(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3028 { 3029 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerPrepare() In")); 3030 3031 aUtilContext.iCmdType = -1; 3032 3033 PVMFStatus cmdstatus = PVMFFailure; 3034 3035 switch (aCmdResp.GetCmdStatus()) 3036 { 3037 case PVMFSuccess: 3038 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3039 (0, "PVFrameAndMetadataUtility::PlayerPrepare completed successfully Tick=%d", OsclTickCount::TickCount())); 3040 // Call Start() on player 3041 cmdstatus = DoADSPlayerStart(aUtilContext.iCmdId, aUtilContext.iCmdContext); 3042 if (cmdstatus != PVMFSuccess) 3043 { 3044 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleADSPlayerPrepare() Start on player failed. Report command as failed")); 3045 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3046 if (iAPICmdErrMsg) 3047 { 3048 iAPICmdErrMsg->removeRef(); 3049 iAPICmdErrMsg = NULL; 3050 } 3051 // Need to shutdown/restart player and cleanup in utility's AO 3052 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3053 iErrorHandlingInUtilityAO = true; 3054 RunIfNotReady(); 3055 } 3056 break; 3057 3058 default: 3059 { 3060 // If the player engine is in initialized state, complete AddDataSource() 3061 // command with success here. User can still retrieve metadata 3062 PVPlayerState pstate; 3063 PVMFStatus playerretval = iPlayer->GetPVPlayerStateSync(pstate); 3064 if (playerretval == PVMFSuccess && pstate == PVP_STATE_INITIALIZED) 3065 { 3066 // Utility's AddDataSource() successfully completed 3067 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZED); 3068 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 3069 break; 3070 } 3071 3072 // Else fall through to the error handling in the default case since fatal error 3073 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3074 if (aCmdResp.GetEventExtensionInterface()) 3075 { 3076 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3077 } 3078 PVMFBasicErrorInfoMessage* errmsg = NULL; 3079 errmsg = CreateBasicErrInfoMessage(nextmsg); 3080 3081 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3082 if (iAPICmdErrMsg) 3083 { 3084 iAPICmdErrMsg->removeRef(); 3085 iAPICmdErrMsg = NULL; 3086 } 3087 iAPICmdErrMsg = errmsg; 3088 3089 // Check if player is handling the error 3090 PVPlayerState playerstate; 3091 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3092 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3093 { 3094 // Wait for error handling to complete 3095 // Start a timer just in case the player does not report error handling complete 3096 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3097 } 3098 else 3099 { 3100 // Need to shutdown/restart player and cleanup in utility's AO 3101 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3102 iErrorHandlingInUtilityAO = true; 3103 RunIfNotReady(); 3104 } 3105 } 3106 break; 3107 } 3108 3109 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerPrepare() Out")); 3110 } 3111 3112 3113 void PVFrameAndMetadataUtility::HandleADSPlayerStart(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3114 { 3115 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerStart() In")); 3116 3117 aUtilContext.iCmdType = -1; 3118 3119 PVMFStatus cmdstatus = PVMFFailure; 3120 3121 switch (aCmdResp.GetCmdStatus()) 3122 { 3123 case PVMFSuccess: 3124 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3125 (0, "PVFrameAndMetadataUtility::PlayerStart completed successfully Tick=%d", OsclTickCount::TickCount())); 3126 // Call Pause() on player 3127 cmdstatus = DoADSPlayerPause(aUtilContext.iCmdId, aUtilContext.iCmdContext); 3128 if (cmdstatus != PVMFSuccess) 3129 { 3130 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleADSPlayerStart() Start on player failed. Report command as failed")); 3131 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3132 if (iAPICmdErrMsg) 3133 { 3134 iAPICmdErrMsg->removeRef(); 3135 iAPICmdErrMsg = NULL; 3136 } 3137 // Need to shutdown/restart player and cleanup in utility's AO 3138 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3139 iErrorHandlingInUtilityAO = true; 3140 RunIfNotReady(); 3141 } 3142 break; 3143 3144 default: 3145 { 3146 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3147 if (aCmdResp.GetEventExtensionInterface()) 3148 { 3149 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3150 } 3151 PVMFBasicErrorInfoMessage* errmsg = NULL; 3152 errmsg = CreateBasicErrInfoMessage(nextmsg); 3153 3154 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3155 if (iAPICmdErrMsg) 3156 { 3157 iAPICmdErrMsg->removeRef(); 3158 iAPICmdErrMsg = NULL; 3159 } 3160 iAPICmdErrMsg = errmsg; 3161 3162 // Check if player is handling the error 3163 PVPlayerState playerstate; 3164 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3165 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3166 { 3167 // Wait for error handling to complete 3168 // Start a timer just in case the player does not report error handling complete 3169 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3170 } 3171 else 3172 { 3173 // Need to shutdown/restart player and cleanup in utility's AO 3174 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3175 iErrorHandlingInUtilityAO = true; 3176 RunIfNotReady(); 3177 } 3178 } 3179 break; 3180 } 3181 3182 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerStart() Out")); 3183 } 3184 3185 3186 void PVFrameAndMetadataUtility::HandleADSPlayerPause(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3187 { 3188 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerPause() In")); 3189 3190 aUtilContext.iCmdType = -1; 3191 3192 switch (aCmdResp.GetCmdStatus()) 3193 { 3194 case PVMFSuccess: 3195 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3196 (0, "PVFrameAndMetadataUtility::PlayerPause completed successfully Tick=%d", OsclTickCount::TickCount())); 3197 // Utility's AddDataSource() successfully completed 3198 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZED); 3199 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3200 (0, "PVFrameAndMetadataUtility::AddDataSource completed sucessfully Tick=%d", OsclTickCount::TickCount())); 3201 3202 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 3203 break; 3204 3205 default: 3206 { 3207 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3208 if (aCmdResp.GetEventExtensionInterface()) 3209 { 3210 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3211 } 3212 PVMFBasicErrorInfoMessage* errmsg = NULL; 3213 errmsg = CreateBasicErrInfoMessage(nextmsg); 3214 3215 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3216 if (iAPICmdErrMsg) 3217 { 3218 iAPICmdErrMsg->removeRef(); 3219 iAPICmdErrMsg = NULL; 3220 } 3221 iAPICmdErrMsg = errmsg; 3222 3223 // Check if player is handling the error 3224 PVPlayerState playerstate; 3225 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3226 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3227 { 3228 // Wait for error handling to complete 3229 // Start a timer just in case the player does not report error handling complete 3230 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3231 } 3232 else 3233 { 3234 // Need to shutdown/restart player and cleanup in utility's AO 3235 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3236 iErrorHandlingInUtilityAO = true; 3237 RunIfNotReady(); 3238 } 3239 } 3240 break; 3241 } 3242 3243 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleADSPlayerPause() Out")); 3244 } 3245 3246 3247 void PVFrameAndMetadataUtility::HandlePlayerGetMetadataKeys(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3248 { 3249 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerGetMetadataKeys() In")); 3250 3251 aUtilContext.iCmdType = -1; 3252 3253 switch (aCmdResp.GetCmdStatus()) 3254 { 3255 case PVMFSuccess: 3256 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3257 (0, "PVFrameAndMetadataUtility::PlayerGetMetadataKeys completed successfully Tick=%d", OsclTickCount::TickCount())); 3258 3259 // Report GetMetadataKeys() command as succesfully complete 3260 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 3261 break; 3262 3263 default: 3264 { 3265 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3266 if (aCmdResp.GetEventExtensionInterface()) 3267 { 3268 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3269 } 3270 PVMFBasicErrorInfoMessage* errmsg = NULL; 3271 errmsg = CreateBasicErrInfoMessage(nextmsg); 3272 3273 // Check if player is handling the error 3274 PVPlayerState playerstate; 3275 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3276 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3277 { 3278 // Yes so wait for error handling to complete 3279 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3280 if (iAPICmdErrMsg) 3281 { 3282 iAPICmdErrMsg->removeRef(); 3283 iAPICmdErrMsg = NULL; 3284 } 3285 iAPICmdErrMsg = errmsg; 3286 // Start a timer just in case the player does not report error handling complete 3287 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3288 } 3289 else 3290 { 3291 // Report the command as failed 3292 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, aCmdResp.GetCmdStatus(), OSCL_STATIC_CAST(PVInterface*, errmsg)); 3293 if (errmsg) 3294 { 3295 errmsg->removeRef(); 3296 } 3297 } 3298 } 3299 break; 3300 } 3301 3302 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerGetMetadataKeys() Out")); 3303 } 3304 3305 3306 void PVFrameAndMetadataUtility::HandlePlayerGetMetadataValues(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3307 { 3308 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerGetMetadataValues() In")); 3309 3310 aUtilContext.iCmdType = -1; 3311 3312 switch (aCmdResp.GetCmdStatus()) 3313 { 3314 case PVMFSuccess: 3315 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3316 (0, "PVFrameAndMetadataUtility::PlayerGetMetadataValues completed successfully Tick=%d", OsclTickCount::TickCount())); 3317 // Report GetMetadataValues() command as succesfully complete 3318 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 3319 break; 3320 3321 default: 3322 { 3323 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3324 if (aCmdResp.GetEventExtensionInterface()) 3325 { 3326 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3327 } 3328 PVMFBasicErrorInfoMessage* errmsg = NULL; 3329 errmsg = CreateBasicErrInfoMessage(nextmsg); 3330 3331 // Check if player is handling the error 3332 PVPlayerState playerstate; 3333 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3334 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3335 { 3336 // Yes so wait for error handling to complete 3337 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3338 if (iAPICmdErrMsg) 3339 { 3340 iAPICmdErrMsg->removeRef(); 3341 iAPICmdErrMsg = NULL; 3342 } 3343 iAPICmdErrMsg = errmsg; 3344 // Start a timer just in case the player does not report error handling complete 3345 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3346 } 3347 else 3348 { 3349 // Report the command as failed 3350 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, aCmdResp.GetCmdStatus(), OSCL_STATIC_CAST(PVInterface*, errmsg)); 3351 if (errmsg) 3352 { 3353 errmsg->removeRef(); 3354 } 3355 } 3356 } 3357 break; 3358 } 3359 3360 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerGetMetadataValues() Out")); 3361 } 3362 3363 void PVFrameAndMetadataUtility::HandlePlayerSetParametersSync(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3364 { 3365 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerSetParametersSync() In")); 3366 3367 aUtilContext.iCmdType = -1; 3368 3369 switch (aCmdResp.GetCmdStatus()) 3370 { 3371 case PVMFSuccess: 3372 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3373 (0, "PVFrameAndMetadataUtility::PlayerSetParametersSync completed successfully Tick=%d", OsclTickCount::TickCount())); 3374 // Report SetParametersSync() command as succesfully complete 3375 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 3376 break; 3377 3378 default: 3379 { 3380 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3381 if (aCmdResp.GetEventExtensionInterface()) 3382 { 3383 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3384 } 3385 PVMFBasicErrorInfoMessage* errmsg = NULL; 3386 errmsg = CreateBasicErrInfoMessage(nextmsg); 3387 3388 // Check if player is handling the error 3389 PVPlayerState playerstate; 3390 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3391 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3392 { 3393 // Yes so wait for error handling to complete 3394 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3395 if (iAPICmdErrMsg) 3396 { 3397 iAPICmdErrMsg->removeRef(); 3398 iAPICmdErrMsg = NULL; 3399 } 3400 iAPICmdErrMsg = errmsg; 3401 // Start a timer just in case the player does not report error handling complete 3402 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3403 } 3404 else 3405 { 3406 // Report the command as failed 3407 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, aCmdResp.GetCmdStatus(), OSCL_STATIC_CAST(PVInterface*, errmsg)); 3408 if (errmsg) 3409 { 3410 errmsg->removeRef(); 3411 } 3412 } 3413 } 3414 break; 3415 } 3416 3417 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandlePlayerSetParametersSync() Out")); 3418 } 3419 3420 void PVFrameAndMetadataUtility::HandleGFPlayerStopFromPaused(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3421 { 3422 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerStopFromPaused() In")); 3423 3424 aUtilContext.iCmdType = -1; 3425 3426 switch (aCmdResp.GetCmdStatus()) 3427 { 3428 case PVMFSuccess: 3429 { 3430 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3431 (0, "PVFrameAndMetadataUtility::GFPlayerStopFromPaused completed successfully Tick=%d", OsclTickCount::TickCount())); 3432 // Call DoPrepare() on player 3433 PVMFStatus cmdstatus = DoGFPlayerPrepare(aUtilContext.iCmdId, aUtilContext.iCmdContext); 3434 if (cmdstatus != PVMFSuccess) 3435 { 3436 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleGFPlayerStopFromPaused() Prepare on player failed. Report command as failed")); 3437 3438 // Check if video frame buffer was allocated from utility's memory pool 3439 OSCL_ASSERT(iCurrentCmd.empty() == false); 3440 OSCL_ASSERT(iCurrentVideoFrameBuffer != NULL); 3441 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3442 { 3443 // Return the buffer if allocated from utility's mempool 3444 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3445 iCurrentVideoFrameBuffer = NULL; 3446 } 3447 3448 iAPICmdStatus = cmdstatus; 3449 if (iAPICmdErrMsg) 3450 { 3451 iAPICmdErrMsg->removeRef(); 3452 iAPICmdErrMsg = NULL; 3453 } 3454 // Need to shutdown/restart player and cleanup in utility's AO 3455 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3456 iErrorHandlingInUtilityAO = true; 3457 RunIfNotReady(); 3458 } 3459 } 3460 break; 3461 3462 default: 3463 { 3464 // Check if video frame buffer was allocated from utility's memory pool 3465 OSCL_ASSERT(iCurrentCmd.empty() == false); 3466 OSCL_ASSERT(iCurrentVideoFrameBuffer != NULL); 3467 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3468 { 3469 // Return the buffer if allocated from utility's mempool 3470 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3471 iCurrentVideoFrameBuffer = NULL; 3472 } 3473 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3474 if (aCmdResp.GetEventExtensionInterface()) 3475 { 3476 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3477 } 3478 PVMFBasicErrorInfoMessage* errmsg = NULL; 3479 errmsg = CreateBasicErrInfoMessage(nextmsg); 3480 3481 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3482 if (iAPICmdErrMsg) 3483 { 3484 iAPICmdErrMsg->removeRef(); 3485 iAPICmdErrMsg = NULL; 3486 } 3487 iAPICmdErrMsg = errmsg; 3488 3489 // Check if player is handling the error 3490 PVPlayerState playerstate; 3491 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3492 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3493 { 3494 // Yes so wait for error handling to complete 3495 // Start a timer just in case the player does not report error handling complete 3496 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3497 } 3498 else if (pretval == PVMFSuccess && playerstate == PVP_STATE_INITIALIZED) 3499 { 3500 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZED); 3501 3502 // Report the command as failed 3503 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 3504 iAPICmdStatus = PVMFSuccess; 3505 if (iAPICmdErrMsg) 3506 { 3507 iAPICmdErrMsg->removeRef(); 3508 iAPICmdErrMsg = NULL; 3509 } 3510 } 3511 else 3512 { 3513 // Need to shutdown/restart player and cleanup in utility's AO 3514 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3515 iErrorHandlingInUtilityAO = true; 3516 RunIfNotReady(); 3517 } 3518 } 3519 break; 3520 } 3521 3522 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerStopFromPaused() Out")); 3523 } 3524 3525 3526 void PVFrameAndMetadataUtility::HandleGFPlayerPrepare(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3527 { 3528 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerPrepare() In")); 3529 3530 aUtilContext.iCmdType = -1; 3531 3532 PVMFStatus cmdstatus = PVMFFailure; 3533 3534 switch (aCmdResp.GetCmdStatus()) 3535 { 3536 case PVMFSuccess: 3537 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3538 (0, "PVFrameAndMetadataUtility::GFPlayerPrepare completed successfully Tick=%d", OsclTickCount::TickCount())); 3539 // Call Start() on player 3540 iPlayerStartCompleted = false; 3541 cmdstatus = DoGFPlayerStart(aUtilContext.iCmdId, aUtilContext.iCmdContext); 3542 if ((cmdstatus != PVMFSuccess) || (!HasVideo())) 3543 { 3544 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleGFPlayerPrepare() Prepare on player failed. Report command as failed")); 3545 // Cancel the frame retrieval 3546 iVideoMIO->CancelGetFrame(); 3547 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3548 { 3549 // Return the buffer if allocated from utility's mempool 3550 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3551 iCurrentVideoFrameBuffer = NULL; 3552 } 3553 3554 iAPICmdStatus = cmdstatus; 3555 if (iAPICmdErrMsg) 3556 { 3557 iAPICmdErrMsg->removeRef(); 3558 iAPICmdErrMsg = NULL; 3559 } 3560 // Need to shutdown/restart player and cleanup in utility's AO 3561 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3562 iErrorHandlingInUtilityAO = true; 3563 RunIfNotReady(); 3564 } 3565 break; 3566 3567 default: 3568 { 3569 // Cancel the frame retrieval 3570 iVideoMIO->CancelGetFrame(); 3571 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3572 { 3573 // Return the buffer if allocated from utility's mempool 3574 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3575 iCurrentVideoFrameBuffer = NULL; 3576 } 3577 PVFMErrorEventType errCode = PVFMErrPlayerEngine; 3578 if (aCmdResp.GetCmdStatus() == PVMFErrResourceConfiguration) 3579 { 3580 errCode = PVFMErrNoVideoTrack; 3581 } 3582 3583 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3584 if (aCmdResp.GetEventExtensionInterface()) 3585 { 3586 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3587 } 3588 PVMFBasicErrorInfoMessage* errmsg = NULL; 3589 errmsg = CreateBasicErrInfoMessage(nextmsg, errCode); 3590 3591 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3592 if (iAPICmdErrMsg) 3593 { 3594 iAPICmdErrMsg->removeRef(); 3595 iAPICmdErrMsg = NULL; 3596 } 3597 iAPICmdErrMsg = errmsg; 3598 3599 // Check if player is handling the error 3600 PVPlayerState playerstate; 3601 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3602 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3603 { 3604 // Wait for error handling to complete 3605 // Start a timer just in case the player does not report error handling complete 3606 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3607 } 3608 else if (aCmdResp.GetCmdStatus() == PVMFErrResourceConfiguration) 3609 { 3610 // Track selection in player engine failed since there is no video track. 3611 // Complete GetFrame() with not supported for this source 3612 UtilityCommandCompleted(iCurrentCmd[0].GetCmdId(), iCurrentCmd[0].GetContext(), PVMFErrNotSupported, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 3613 iAPICmdStatus = PVMFSuccess; 3614 if (iAPICmdErrMsg) 3615 { 3616 iAPICmdErrMsg->removeRef(); 3617 iAPICmdErrMsg = NULL; 3618 } 3619 } 3620 else 3621 { 3622 // Need to shutdown/restart player and cleanup in utility's AO 3623 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3624 iErrorHandlingInUtilityAO = true; 3625 RunIfNotReady(); 3626 } 3627 } 3628 break; 3629 } 3630 3631 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerPrepare() Out")); 3632 } 3633 3634 3635 void PVFrameAndMetadataUtility::HandleGFPlayerStart(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3636 { 3637 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerStart() In")); 3638 3639 aUtilContext.iCmdType = -1; 3640 PVMFStatus cmdstatus = aCmdResp.GetCmdStatus(); 3641 3642 switch (cmdstatus) 3643 { 3644 case PVMFSuccess: 3645 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3646 (0, "PVFrameAndMetadataUtility::GFPlayerStart completed successfully Tick=%d", OsclTickCount::TickCount())); 3647 iPlayerStartCompleted = true; 3648 3649 if (iFrameReceived) 3650 { 3651 PVMFStatus retval = DoGFPlayerPause(aUtilContext.iCmdId, aUtilContext.iCmdContext); 3652 if (retval == PVMFErrInvalidState) 3653 { 3654 // Playback already paused so GetFrame() command completed 3655 if (iAPICmdStatus != PVMFSuccess) 3656 { 3657 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3658 { 3659 // Return the buffer if allocated from utility's mempool 3660 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3661 iCurrentVideoFrameBuffer = NULL; 3662 } 3663 } 3664 3665 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 3666 3667 iAPICmdStatus = PVMFSuccess; 3668 if (iAPICmdErrMsg) 3669 { 3670 iAPICmdErrMsg->removeRef(); 3671 iAPICmdErrMsg = NULL; 3672 } 3673 } 3674 else if (retval != PVMFSuccess) 3675 { 3676 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleGFPlayerStart() Pause on player failed. Report command as failed")); 3677 3678 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3679 { 3680 // Return the buffer if allocated from utility's mempool 3681 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3682 iCurrentVideoFrameBuffer = NULL; 3683 } 3684 3685 iAPICmdStatus = retval; 3686 if (iAPICmdErrMsg) 3687 { 3688 iAPICmdErrMsg->removeRef(); 3689 iAPICmdErrMsg = NULL; 3690 } 3691 3692 // Need to shutdown/restart player and cleanup in utility's AO 3693 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3694 iErrorHandlingInUtilityAO = true; 3695 RunIfNotReady(); 3696 } 3697 } 3698 else 3699 { 3700 // Wait for the video MIO to report frame is ready 3701 // Start a timer just in case frame retrieval hangs 3702 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerStart() Set a timeout of %d secs for frame retrieval", iFrameReadyWaitTime)); 3703 iTimeoutTimer->Request(PVFMUTIL_TIMERID_FRAMEREADYTIMEOUT, 0, iFrameReadyWaitTime, this, false); 3704 } 3705 break; 3706 3707 default: 3708 { 3709 // Cancel the frame retrieval 3710 iVideoMIO->CancelGetFrame(); 3711 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3712 { 3713 // Return the buffer if allocated from utility's mempool 3714 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3715 iCurrentVideoFrameBuffer = NULL; 3716 } 3717 3718 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3719 if (aCmdResp.GetEventExtensionInterface()) 3720 { 3721 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3722 } 3723 PVMFBasicErrorInfoMessage* errmsg = NULL; 3724 errmsg = CreateBasicErrInfoMessage(nextmsg); 3725 3726 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3727 if (iAPICmdErrMsg) 3728 { 3729 iAPICmdErrMsg->removeRef(); 3730 iAPICmdErrMsg = NULL; 3731 } 3732 iAPICmdErrMsg = errmsg; 3733 3734 // Check if player is handling the error 3735 PVPlayerState playerstate; 3736 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3737 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3738 { 3739 // Wait for error handling to complete 3740 // Start a timer just in case the player does not report error handling complete 3741 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3742 } 3743 else 3744 { 3745 // Need to shutdown/restart player and cleanup in utility's AO 3746 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3747 iErrorHandlingInUtilityAO = true; 3748 RunIfNotReady(); 3749 } 3750 } 3751 break; 3752 } 3753 3754 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerStart() Out")); 3755 } 3756 3757 3758 void PVFrameAndMetadataUtility::HandleGFPlayerPause(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3759 { 3760 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerPause() In")); 3761 3762 aUtilContext.iCmdType = -1; 3763 3764 switch (aCmdResp.GetCmdStatus()) 3765 { 3766 case PVMFSuccess: 3767 3768 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3769 (0, "PVFrameAndMetadataUtility::GFPlayerPause completed successfully Tick=%d", OsclTickCount::TickCount())); 3770 // GetFrame() command completed 3771 if (iAPICmdStatus != PVMFSuccess) 3772 { 3773 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3774 { 3775 // Return the buffer if allocated from utility's mempool 3776 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3777 iCurrentVideoFrameBuffer = NULL; 3778 } 3779 } 3780 3781 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3782 (0, "PVFrameAndMetadataUtility::GetFrame() completed successfully Tick=%d", OsclTickCount::TickCount())); 3783 3784 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 3785 3786 iAPICmdStatus = PVMFSuccess; 3787 if (iAPICmdErrMsg) 3788 { 3789 iAPICmdErrMsg->removeRef(); 3790 iAPICmdErrMsg = NULL; 3791 } 3792 break; 3793 3794 default: 3795 { 3796 if (iCurrentCmd[0].GetCmdType() == PVFM_UTILITY_COMMAND_GET_FRAME_UTILITY_BUFFER && iCurrentVideoFrameBuffer) 3797 { 3798 // Return the buffer if allocated from utility's mempool 3799 iVideoFrameBufferMemPool->deallocate(iCurrentVideoFrameBuffer); 3800 iCurrentVideoFrameBuffer = NULL; 3801 } 3802 3803 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3804 if (aCmdResp.GetEventExtensionInterface()) 3805 { 3806 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3807 } 3808 3809 PVMFBasicErrorInfoMessage* errmsg = NULL; 3810 errmsg = CreateBasicErrInfoMessage(nextmsg); 3811 3812 // Check if player is handling the error 3813 PVPlayerState playerstate; 3814 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3815 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3816 { 3817 // Yes so wait for error handling to complete 3818 if (iAPICmdStatus == PVMFSuccess) 3819 { 3820 // Use the player error only if there is no existing error (from frame retrieval) 3821 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3822 if (iAPICmdErrMsg) 3823 { 3824 iAPICmdErrMsg->removeRef(); 3825 iAPICmdErrMsg = NULL; 3826 } 3827 iAPICmdErrMsg = errmsg; 3828 } 3829 // Start a timer just in case the player does not report error handling complete 3830 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3831 } 3832 else if (pretval == PVMFSuccess && playerstate == PVP_STATE_INITIALIZED) 3833 { 3834 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZED); 3835 3836 // Report the command as failed 3837 if (iAPICmdStatus == PVMFSuccess) 3838 { 3839 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, aCmdResp.GetCmdStatus(), OSCL_STATIC_CAST(PVInterface*, errmsg)); 3840 if (errmsg) 3841 { 3842 errmsg->removeRef(); 3843 } 3844 } 3845 else 3846 { 3847 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 3848 iAPICmdStatus = PVMFSuccess; 3849 if (iAPICmdErrMsg) 3850 { 3851 iAPICmdErrMsg->removeRef(); 3852 iAPICmdErrMsg = NULL; 3853 } 3854 } 3855 } 3856 else 3857 { 3858 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3859 if (iAPICmdErrMsg) 3860 { 3861 iAPICmdErrMsg->removeRef(); 3862 iAPICmdErrMsg = NULL; 3863 } 3864 iAPICmdErrMsg = errmsg; 3865 // Need to shutdown/restart player and cleanup in utility's AO 3866 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3867 iErrorHandlingInUtilityAO = true; 3868 RunIfNotReady(); 3869 } 3870 } 3871 break; 3872 } 3873 3874 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleGFPlayerPause() Out")); 3875 } 3876 3877 3878 void PVFrameAndMetadataUtility::HandleRDSPlayerStopFromPaused(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3879 { 3880 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerStopFromPaused() In")); 3881 3882 aUtilContext.iCmdType = -1; 3883 3884 switch (aCmdResp.GetCmdStatus()) 3885 { 3886 case PVMFSuccess: 3887 { 3888 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3889 (0, "PVFrameAndMetadataUtility::RDSPlayerStopFromPaused completed successfully Tick=%d", OsclTickCount::TickCount())); 3890 // Call RemoveDataSink() on player 3891 PVMFStatus cmdstatus = DoRDSPlayerRemoveVideoDataSink(aUtilContext.iCmdId, aUtilContext.iCmdContext); 3892 if (cmdstatus != PVMFSuccess) 3893 { 3894 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerStopFromPaused() RemoveDataSink on player failed. Report command as failed")); 3895 iAPICmdStatus = cmdstatus; 3896 if (iAPICmdErrMsg) 3897 { 3898 iAPICmdErrMsg->removeRef(); 3899 iAPICmdErrMsg = NULL; 3900 } 3901 // Need to shutdown/restart player and cleanup in utility's AO 3902 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3903 iErrorHandlingInUtilityAO = true; 3904 RunIfNotReady(); 3905 } 3906 } 3907 break; 3908 3909 default: 3910 { 3911 PVMFErrorInfoMessageInterface* nextmsg = NULL; 3912 if (aCmdResp.GetEventExtensionInterface()) 3913 { 3914 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 3915 } 3916 PVMFBasicErrorInfoMessage* errmsg = NULL; 3917 errmsg = CreateBasicErrInfoMessage(nextmsg); 3918 3919 iAPICmdStatus = aCmdResp.GetCmdStatus(); 3920 if (iAPICmdErrMsg) 3921 { 3922 iAPICmdErrMsg->removeRef(); 3923 iAPICmdErrMsg = NULL; 3924 } 3925 iAPICmdErrMsg = errmsg; 3926 3927 // Check if player is handling the error 3928 PVPlayerState playerstate; 3929 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 3930 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 3931 { 3932 // Yes so wait for error handling to complete 3933 // Start a timer just in case the player does not report error handling complete 3934 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 3935 } 3936 else if (pretval == PVMFSuccess && playerstate == PVP_STATE_INITIALIZED) 3937 { 3938 SetUtilityState(PVFM_UTILITY_STATE_INITIALIZED); 3939 3940 // Report the command as failed 3941 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, iAPICmdStatus, OSCL_STATIC_CAST(PVInterface*, iAPICmdErrMsg)); 3942 iAPICmdStatus = PVMFSuccess; 3943 if (iAPICmdErrMsg) 3944 { 3945 iAPICmdErrMsg->removeRef(); 3946 iAPICmdErrMsg = NULL; 3947 } 3948 } 3949 else 3950 { 3951 // Need to shutdown/restart player and cleanup in utility's AO 3952 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 3953 iErrorHandlingInUtilityAO = true; 3954 RunIfNotReady(); 3955 } 3956 } 3957 break; 3958 } 3959 3960 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerStopFromPaused() Out")); 3961 } 3962 3963 void PVFrameAndMetadataUtility::HandleRDSPlayerRemoveVideoDataSink(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 3964 { 3965 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility:HandleRDSPlayerRemoveVideoDataSink() In")); 3966 3967 aUtilContext.iCmdType = -1; 3968 3969 PVMFStatus cmdstatus = PVMFFailure; 3970 3971 switch (aCmdResp.GetCmdStatus()) 3972 { 3973 case PVMFSuccess: 3974 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 3975 (0, "PVFrameAndMetadataUtility::RDSPlayerRemoveVideoDataSink completed successfully Tick=%d", OsclTickCount::TickCount())); 3976 // Cleanup the data sink 3977 iVideoDataSink.SetDataSinkNode(NULL); 3978 if (iVideoNode) 3979 { 3980 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoNode); 3981 iVideoNode = NULL; 3982 } 3983 if (iVideoMIO) 3984 { 3985 OSCL_DELETE(iVideoMIO); 3986 iVideoMIO = NULL; 3987 } 3988 3989 // Call Remove audio data sink on player. 3990 if (iAudioNode && iAudioMIO) 3991 { 3992 cmdstatus = DoRDSPlayerRemoveAudioDataSink(aUtilContext.iCmdId, aUtilContext.iCmdContext); 3993 } 3994 else 3995 { 3996 // Audio sink not available so go to player reset 3997 cmdstatus = DoRDSPlayerReset(aUtilContext.iCmdId, aUtilContext.iCmdContext); 3998 } 3999 if (cmdstatus != PVMFSuccess) 4000 { 4001 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveVideoDataSink() RemoveAudioDataSink on player failed. Report command as failed")); 4002 iAPICmdStatus = cmdstatus; 4003 if (iAPICmdErrMsg) 4004 { 4005 iAPICmdErrMsg->removeRef(); 4006 iAPICmdErrMsg = NULL; 4007 } 4008 // Need to shutdown/restart player and cleanup in utility's AO 4009 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4010 iErrorHandlingInUtilityAO = true; 4011 RunIfNotReady(); 4012 } 4013 break; 4014 4015 default: 4016 { 4017 // Cleanup the data sink 4018 iVideoDataSink.SetDataSinkNode(NULL); 4019 if (iVideoNode) 4020 { 4021 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iVideoNode); 4022 iVideoNode = NULL; 4023 } 4024 if (iVideoMIO) 4025 { 4026 OSCL_DELETE(iVideoMIO); 4027 iVideoMIO = NULL; 4028 } 4029 PVMFErrorInfoMessageInterface* nextmsg = NULL; 4030 if (aCmdResp.GetEventExtensionInterface()) 4031 { 4032 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 4033 } 4034 PVMFBasicErrorInfoMessage* errmsg = NULL; 4035 errmsg = CreateBasicErrInfoMessage(nextmsg); 4036 4037 iAPICmdStatus = aCmdResp.GetCmdStatus(); 4038 if (iAPICmdErrMsg) 4039 { 4040 iAPICmdErrMsg->removeRef(); 4041 iAPICmdErrMsg = NULL; 4042 } 4043 iAPICmdErrMsg = errmsg; 4044 4045 // Check if player is handling the error 4046 PVPlayerState playerstate; 4047 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 4048 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 4049 { 4050 // Wait for error handling to complete 4051 // Start a timer just in case the player does not report error handling complete 4052 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 4053 } 4054 else if (pretval == PVMFSuccess && playerstate == PVP_STATE_INITIALIZED) 4055 { 4056 // Call Reset() on player 4057 cmdstatus = DoRDSPlayerReset(aUtilContext.iCmdId, aUtilContext.iCmdContext); 4058 if (cmdstatus != PVMFSuccess) 4059 { 4060 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveVideoDataSink() Reset on player failed. Report command as failed")); 4061 iAPICmdStatus = cmdstatus; 4062 if (iAPICmdErrMsg) 4063 { 4064 iAPICmdErrMsg->removeRef(); 4065 iAPICmdErrMsg = NULL; 4066 } 4067 // Need to shutdown/restart player and cleanup in utility's AO 4068 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4069 iErrorHandlingInUtilityAO = true; 4070 RunIfNotReady(); 4071 } 4072 } 4073 else 4074 { 4075 // Need to shutdown/restart player and cleanup in utility's AO 4076 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4077 iErrorHandlingInUtilityAO = true; 4078 RunIfNotReady(); 4079 } 4080 } 4081 break; 4082 } 4083 4084 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveVideoDataSink() Out")); 4085 } 4086 4087 void PVFrameAndMetadataUtility::HandleRDSPlayerRemoveAudioDataSink(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 4088 { 4089 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveAudioDataSink() In")); 4090 4091 aUtilContext.iCmdType = -1; 4092 4093 PVMFStatus cmdstatus = PVMFFailure; 4094 4095 switch (aCmdResp.GetCmdStatus()) 4096 { 4097 case PVMFSuccess: 4098 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 4099 (0, "PVFrameAndMetadataUtility::RDSPlayerRemoveAudioDataSink completed successfully Tick=%d", OsclTickCount::TickCount())); 4100 // Cleanup the data sink 4101 iAudioDataSink.SetDataSinkNode(NULL); 4102 if (iAudioNode) 4103 { 4104 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioNode); 4105 iAudioNode = NULL; 4106 } 4107 if (iAudioMIO) 4108 { 4109 OSCL_DELETE(iAudioMIO); 4110 iAudioMIO = NULL; 4111 } 4112 4113 // Call Reset() on player 4114 cmdstatus = DoRDSPlayerReset(aUtilContext.iCmdId, aUtilContext.iCmdContext); 4115 if (cmdstatus != PVMFSuccess) 4116 { 4117 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveAudioDataSink() Reset on player failed. Report command as failed")); 4118 iAPICmdStatus = cmdstatus; 4119 if (iAPICmdErrMsg) 4120 { 4121 iAPICmdErrMsg->removeRef(); 4122 iAPICmdErrMsg = NULL; 4123 } 4124 // Need to shutdown/restart player and cleanup in utility's AO 4125 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4126 iErrorHandlingInUtilityAO = true; 4127 RunIfNotReady(); 4128 } 4129 break; 4130 4131 default: 4132 { 4133 // Cleanup the data sink 4134 iAudioDataSink.SetDataSinkNode(NULL); 4135 if (iAudioNode) 4136 { 4137 PVMediaOutputNodeFactory::DeleteMediaOutputNode(iAudioNode); 4138 iAudioNode = NULL; 4139 } 4140 if (iAudioMIO) 4141 { 4142 OSCL_DELETE(iAudioMIO); 4143 iAudioMIO = NULL; 4144 } 4145 PVMFErrorInfoMessageInterface* nextmsg = NULL; 4146 if (aCmdResp.GetEventExtensionInterface()) 4147 { 4148 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 4149 } 4150 PVMFBasicErrorInfoMessage* errmsg = NULL; 4151 errmsg = CreateBasicErrInfoMessage(nextmsg); 4152 4153 iAPICmdStatus = aCmdResp.GetCmdStatus(); 4154 if (iAPICmdErrMsg) 4155 { 4156 iAPICmdErrMsg->removeRef(); 4157 iAPICmdErrMsg = NULL; 4158 } 4159 iAPICmdErrMsg = errmsg; 4160 4161 // Check if player is handling the error 4162 PVPlayerState playerstate; 4163 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 4164 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 4165 { 4166 // Wait for error handling to complete 4167 // Start a timer just in case the player does not report error handling complete 4168 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 4169 } 4170 else if (pretval == PVMFSuccess && playerstate == PVP_STATE_INITIALIZED) 4171 { 4172 // Call Reset() on player 4173 cmdstatus = DoRDSPlayerReset(aUtilContext.iCmdId, aUtilContext.iCmdContext); 4174 if (cmdstatus != PVMFSuccess) 4175 { 4176 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveAudioDataSink() Reset on player failed. Report command as failed")); 4177 iAPICmdStatus = cmdstatus; 4178 if (iAPICmdErrMsg) 4179 { 4180 iAPICmdErrMsg->removeRef(); 4181 iAPICmdErrMsg = NULL; 4182 } 4183 // Need to shutdown/restart player and cleanup in utility's AO 4184 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4185 iErrorHandlingInUtilityAO = true; 4186 RunIfNotReady(); 4187 } 4188 } 4189 else 4190 { 4191 // Need to shutdown/restart player and cleanup in utility's AO 4192 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4193 iErrorHandlingInUtilityAO = true; 4194 RunIfNotReady(); 4195 } 4196 } 4197 break; 4198 } 4199 4200 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveAudioDataSink() Out")); 4201 } 4202 4203 4204 void PVFrameAndMetadataUtility::HandleRDSPlayerReset(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 4205 { 4206 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerReset() In")); 4207 4208 aUtilContext.iCmdType = -1; 4209 4210 PVMFStatus cmdstatus = PVMFFailure; 4211 4212 switch (aCmdResp.GetCmdStatus()) 4213 { 4214 case PVMFSuccess: 4215 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 4216 (0, "PVFrameAndMetadataUtility::RDSPlayerReset completed successfully Tick=%d", OsclTickCount::TickCount())); 4217 // Call RemoveDataSource() on player 4218 cmdstatus = DoRDSPlayerRemoveDataSource(aUtilContext.iCmdId, aUtilContext.iCmdContext); 4219 if (cmdstatus != PVMFSuccess) 4220 { 4221 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerReset() RemoveDataSource on player failed. Report command as failed")); 4222 4223 iAPICmdStatus = cmdstatus; 4224 if (iAPICmdErrMsg) 4225 { 4226 iAPICmdErrMsg->removeRef(); 4227 iAPICmdErrMsg = NULL; 4228 } 4229 // Need to shutdown/restart player and cleanup in utility's AO 4230 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4231 iErrorHandlingInUtilityAO = true; 4232 RunIfNotReady(); 4233 } 4234 break; 4235 4236 default: 4237 { 4238 PVMFErrorInfoMessageInterface* nextmsg = NULL; 4239 if (aCmdResp.GetEventExtensionInterface()) 4240 { 4241 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 4242 } 4243 PVMFBasicErrorInfoMessage* errmsg = NULL; 4244 errmsg = CreateBasicErrInfoMessage(nextmsg); 4245 4246 iAPICmdStatus = aCmdResp.GetCmdStatus(); 4247 if (iAPICmdErrMsg) 4248 { 4249 iAPICmdErrMsg->removeRef(); 4250 iAPICmdErrMsg = NULL; 4251 } 4252 iAPICmdErrMsg = errmsg; 4253 4254 // Check if player is handling the error 4255 PVPlayerState playerstate; 4256 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 4257 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 4258 { 4259 // Wait for error handling to complete 4260 // Start a timer just in case the player does not report error handling complete 4261 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 4262 } 4263 else if (pretval == PVMFSuccess && playerstate == PVP_STATE_IDLE) 4264 { 4265 // Call RemoveDataSource() on player 4266 cmdstatus = DoRDSPlayerRemoveDataSource(aUtilContext.iCmdId, aUtilContext.iCmdContext); 4267 if (cmdstatus != PVMFSuccess) 4268 { 4269 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerReset() RemoveDataSource on player failed. Report command as failed")); 4270 iAPICmdStatus = cmdstatus; 4271 if (iAPICmdErrMsg) 4272 { 4273 iAPICmdErrMsg->removeRef(); 4274 iAPICmdErrMsg = NULL; 4275 } 4276 // Need to shutdown/restart player and cleanup in utility's AO 4277 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4278 iErrorHandlingInUtilityAO = true; 4279 RunIfNotReady(); 4280 } 4281 } 4282 else 4283 { 4284 // Need to shutdown/restart player and cleanup in utility's AO 4285 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4286 iErrorHandlingInUtilityAO = true; 4287 RunIfNotReady(); 4288 } 4289 } 4290 break; 4291 } 4292 4293 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerReset() Out")); 4294 } 4295 4296 4297 void PVFrameAndMetadataUtility::HandleRDSPlayerRemoveDataSource(PVFMUtilityContext& aUtilContext, const PVCmdResponse& aCmdResp) 4298 { 4299 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveDataSource() In")); 4300 4301 aUtilContext.iCmdType = -1; 4302 4303 switch (aCmdResp.GetCmdStatus()) 4304 { 4305 case PVMFSuccess: 4306 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 4307 (0, "PVFrameAndMetadataUtility::RDSPlayerRemoveDataSource completed successfully Tick=%d", OsclTickCount::TickCount())); 4308 // Utility's RemoveDataSource() successfully completed 4309 SetUtilityState(PVFM_UTILITY_STATE_IDLE); 4310 iDataSource = NULL; 4311 4312 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iPerfLogger, PVLOGMSG_NOTICE, 4313 (0, "PVFrameAndMetadataUtility::RemoveDataSource() completed successfully Tick=%d", OsclTickCount::TickCount())); 4314 4315 UtilityCommandCompleted(aUtilContext.iCmdId, aUtilContext.iCmdContext, PVMFSuccess); 4316 break; 4317 4318 default: 4319 { 4320 // Even if the player RemoveDataSource fails, 4321 // set the data source handle to NULL and change to idle state 4322 SetUtilityState(PVFM_UTILITY_STATE_IDLE); 4323 iDataSource = NULL; 4324 4325 PVMFErrorInfoMessageInterface* nextmsg = NULL; 4326 if (aCmdResp.GetEventExtensionInterface()) 4327 { 4328 nextmsg = GetErrorInfoMessageInterface(*(aCmdResp.GetEventExtensionInterface())); 4329 } 4330 4331 PVMFBasicErrorInfoMessage* errmsg = NULL; 4332 errmsg = CreateBasicErrInfoMessage(nextmsg); 4333 4334 iAPICmdStatus = aCmdResp.GetCmdStatus(); 4335 if (iAPICmdErrMsg) 4336 { 4337 iAPICmdErrMsg->removeRef(); 4338 iAPICmdErrMsg = NULL; 4339 } 4340 iAPICmdErrMsg = errmsg; 4341 4342 // Check if player is handling the error 4343 PVPlayerState playerstate; 4344 PVMFStatus pretval = iPlayer->GetPVPlayerStateSync(playerstate); 4345 if (pretval == PVMFSuccess && playerstate == PVP_STATE_ERROR) 4346 { 4347 // Wait for error handling to complete 4348 // Start a timer just in case the player does not report error handling complete 4349 iTimeoutTimer->Request(PVFMUTIL_TIMERID_PLAYERERRORTIMEOUT, 0, iErrorHandlingWaitTime, this, false); 4350 } 4351 else 4352 { 4353 // Need to shutdown/restart player and cleanup in utility's AO 4354 OSCL_ASSERT(iErrorHandlingInUtilityAO == false); 4355 iErrorHandlingInUtilityAO = true; 4356 RunIfNotReady(); 4357 } 4358 } 4359 break; 4360 } 4361 4362 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFrameAndMetadataUtility::HandleRDSPlayerRemoveDataSource() Out")); 4363 } 4364 4365 void PVFrameAndMetadataUtility::SetThumbnailDimensions(uint32 aWidth, uint32 aHeight) 4366 { 4367 iThumbnailWidth = aWidth; 4368 iThumbnailHeight = aHeight; 4369 } 4370 4371 void PVFrameAndMetadataUtility::GetThumbnailDimensions(uint32 &aWidth, uint32 &aHeight) 4372 { 4373 aWidth = iThumbnailWidth; 4374 aHeight = iThumbnailHeight; 4375 } 4376 4377 PVMFErrorInfoMessageInterface* PVFrameAndMetadataUtility::GetErrorInfoMessageInterface(PVInterface& aInterface) 4378 { 4379 PVInterface* temp = NULL; 4380 if (aInterface.queryInterface(PVMFErrorInfoMessageInterfaceUUID, temp)) 4381 { 4382 PVMFErrorInfoMessageInterface* extiface = OSCL_STATIC_CAST(PVMFErrorInfoMessageInterface*, temp); 4383 return extiface; 4384 } 4385 else 4386 { 4387 return NULL; 4388 } 4389 } 4390 4391 PVMFBasicErrorInfoMessage* PVFrameAndMetadataUtility::CreateBasicErrInfoMessage(PVMFErrorInfoMessageInterface* nextmsg, PVFMErrorEventType aErrEvent) 4392 { 4393 PVUuid puuid = PVFrameAndMetadataErrorInfoEventTypesUUID; 4394 PVMFBasicErrorInfoMessage* errmsg = NULL; 4395 int32 leavecode = OsclErrNone; 4396 OSCL_TRY(leavecode, errmsg = OSCL_NEW(PVMFBasicErrorInfoMessage, (aErrEvent, puuid, nextmsg))); 4397 OSCL_FIRST_CATCH_ANY(leavecode, 4398 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVFrameAndMetadataUtility::CreateBasicErrInfoMessage() Instantiation of error msg did a leave!")); 4399 errmsg = NULL;); 4400 return errmsg; 4401 } 4402
