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_player_node_registry.h" 19 20 #include "pvmi_datastreamsyncinterface_ref_factory.h" 21 22 #ifdef USE_LOADABLE_MODULES 23 #include "oscl_shared_library.h" 24 #include "oscl_library_list.h" 25 #include "oscl_configfile_list.h" 26 #include "osclconfig_lib.h" 27 #include "oscl_shared_lib_interface.h" 28 29 #include "pvmf_node_shared_lib_interface.h" 30 31 #endif //USE_LOADABLE_MODULES 32 33 #include "pvmf_omx_videodec_factory.h" 34 35 #if BUILD_VIDEO_DEC_NODE 36 #include "pvmf_videodec_factory.h" 37 #endif 38 39 40 void PVPlayerRegistryPopulator::Populate(PVPlayerNodeRegistry& aNode, PVPlayerRecognizerRegistry& aRec) 41 { 42 43 #ifdef USE_LOADABLE_MODULES 44 //add loadable modules 45 46 OsclConfigFileList aCfgList; 47 // collects all config files from the project specified directory 48 if (NULL != PV_DYNAMIC_LOADING_CONFIG_FILE_PATH) 49 { 50 OSCL_HeapString<OsclMemAllocator> configFilePath = PV_DYNAMIC_LOADING_CONFIG_FILE_PATH; 51 aCfgList.Populate(configFilePath); 52 } 53 // populate libraries from all config files 54 for (uint k = 0; k < aCfgList.Size(); k++) 55 { 56 aNode.AddLoadableModules(aCfgList.GetConfigfileAt(k)); 57 aRec.AddLoadableModules(aCfgList.GetConfigfileAt(k)); 58 } 59 #endif 60 61 //add static modules 62 PVPlayerRegistryPopulator pop; 63 pop.RegisterAllNodes(&aNode, aNode.iStaticPopulatorContext); 64 pop.RegisterAllRecognizers(&aRec, aRec.iStaticPopulatorContext); 65 66 } 67 68 void PVPlayerRegistryPopulator::Depopulate(PVPlayerNodeRegistry& aNode, PVPlayerRecognizerRegistry& aRec) 69 { 70 aNode.RemoveLoadableModules(); 71 aRec.RemoveLoadableModules(); 72 73 PVPlayerRegistryPopulator pop; 74 pop.UnregisterAllNodes(&aNode, aNode.iStaticPopulatorContext); 75 pop.UnregisterAllRecognizers(&aRec, aRec.iStaticPopulatorContext); 76 } 77 78 79 PVPlayerNodeRegistry::PVPlayerNodeRegistry() 80 { 81 iType.reserve(20); 82 iLogger = PVLogger::GetLoggerObject("pvplayerengine.playernoderegistry"); 83 } 84 85 86 PVPlayerNodeRegistry::~PVPlayerNodeRegistry() 87 { 88 iType.clear(); 89 iLogger = NULL; 90 } 91 92 void PVPlayerNodeRegistry::AddLoadableModules(const OSCL_String& aConfigFilePath) 93 { 94 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::AddLoadableModules() IN")); 95 #ifdef USE_LOADABLE_MODULES 96 97 OsclLibraryList libList; 98 libList.Populate(PV_NODE_REGISTRY_POPULATOR_INTERFACE, aConfigFilePath); 99 100 for (unsigned int i = 0; i < libList.Size(); i++) 101 { 102 OsclSharedLibrary* lib = OSCL_NEW(OsclSharedLibrary, ()); 103 if (lib->LoadLib(libList.GetLibraryPathAt(i)) == OsclLibSuccess) 104 { 105 OsclAny* interfacePtr = NULL; 106 OsclLibStatus result = lib->QueryInterface(PV_NODE_REGISTRY_POPULATOR_INTERFACE, (OsclAny*&)interfacePtr); 107 if (result == OsclLibSuccess && interfacePtr != NULL) 108 { 109 struct PVPlayerEngineNodeSharedLibInfo *libInfo = (struct PVPlayerEngineNodeSharedLibInfo *)oscl_malloc(sizeof(struct PVPlayerEngineNodeSharedLibInfo)); 110 if (NULL != libInfo) 111 { 112 libInfo->iLib = lib; 113 114 NodeRegistryPopulatorInterface* nodeIntPtr = OSCL_DYNAMIC_CAST(NodeRegistryPopulatorInterface*, interfacePtr); 115 libInfo->iNodeLibIfacePtr = nodeIntPtr; 116 nodeIntPtr->RegisterAllNodes(this, libInfo->iContext); 117 118 // save for depopulation later 119 iNodeLibInfoList.push_front(libInfo); 120 continue; 121 } 122 } 123 else 124 { 125 PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_ERR, 126 (0, "PVPlayerNodeRegistry::AddLoadableModules() QueryInterface() of PV_NODE_POPULATOR_INTERFACE for library %s failed.", 127 libList.GetLibraryPathAt(i).get_cstr())); 128 } 129 } 130 else 131 { 132 PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_ERR, 133 (0, "PVPlayerNodeRegistry::AddLoadableModules() LoadLib() of library %s failed.", 134 libList.GetLibraryPathAt(i).get_cstr())); 135 136 } 137 lib->Close(); 138 OSCL_DELETE(lib); 139 } 140 #else 141 OSCL_UNUSED_ARG(aConfigFilePath); 142 #endif 143 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::AddLoadableModules() OUT")); 144 } 145 146 void PVPlayerNodeRegistry::RemoveLoadableModules() 147 { 148 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::RemoveLoadableModules() IN")); 149 #ifdef USE_LOADABLE_MODULES 150 // remove all dynamic nodes now 151 // unregister node one by one 152 while (!iNodeLibInfoList.empty()) 153 { 154 struct PVPlayerEngineNodeSharedLibInfo *libInfo = iNodeLibInfoList.front(); 155 iNodeLibInfoList.erase(iNodeLibInfoList.begin()); 156 157 OsclSharedLibrary* lib = libInfo->iLib; 158 NodeRegistryPopulatorInterface* nodeIntPtr = libInfo->iNodeLibIfacePtr; 159 OsclAny* context = libInfo->iContext; 160 oscl_free(libInfo); 161 162 nodeIntPtr->UnregisterAllNodes(this, context); 163 164 lib->Close(); 165 OSCL_DELETE(lib); 166 } 167 #endif 168 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::RemoveLoadableModules() OUT")); 169 } 170 171 172 PVMFStatus PVPlayerNodeRegistry::QueryRegistry(PVMFFormatType& aInputType, PVMFFormatType& aOutputType, Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids) 173 { 174 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::QueryRegistry() IN")); 175 uint32 SearchCount = 0; 176 bool matchfound = false; 177 178 // Find all nodes that support the specified input and ouput format pair 179 while (SearchCount < iType.size()) 180 { 181 uint32 inputsearchcount = 0, outputsearchcount = 0; 182 bool iInputFoundFlag = false, iOutputFoundFlag = false; 183 184 while (inputsearchcount < iType[SearchCount].iInputTypes.size()) 185 { 186 // Check if the input format matches 187 if (iType[SearchCount].iInputTypes[inputsearchcount] == aInputType) 188 { 189 // Set the the input flag to true since we found the match in the search 190 iInputFoundFlag = true; 191 break; 192 } 193 inputsearchcount++; 194 } 195 196 //Check the flag of input format if it is true check for the output format, if not return failure 197 if (iInputFoundFlag) 198 { 199 while (outputsearchcount < iType[SearchCount].iOutputType.size()) 200 { 201 if (iType[SearchCount].iOutputType[outputsearchcount] == aOutputType) 202 { 203 //set the the output flag to true since we found the match in the search 204 iOutputFoundFlag = true; 205 break; 206 } 207 208 outputsearchcount++; 209 } 210 211 if (iOutputFoundFlag) 212 { 213 // There's a match so add this node UUID to the list. 214 aUuids.push_back(iType[SearchCount].iNodeUUID); 215 matchfound = true; 216 } 217 } 218 219 SearchCount++; 220 } 221 222 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::QueryRegistry() OUT")); 223 if (matchfound) 224 { 225 return PVMFSuccess; 226 } 227 else 228 { 229 return PVMFFailure; 230 } 231 } 232 233 234 PVMFNodeInterface* PVPlayerNodeRegistry::CreateNode(PVUuid& aUuid, bool aHwAccelerated) 235 { 236 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::CreateNode() IN")); 237 bool iFoundFlag = false; 238 uint32 NodeSearchCount = 0; 239 240 while (NodeSearchCount < iType.size()) 241 { 242 //Search if the UUID's will match 243 if (iType[NodeSearchCount].iNodeUUID == aUuid) 244 { 245 //Since the UUID's match set the flag to true 246 iFoundFlag = true; 247 break; 248 } 249 250 NodeSearchCount++; 251 252 } 253 254 if (iFoundFlag) 255 { 256 OsclActiveObject::OsclActivePriority priority = OsclActiveObject::EPriorityNominal; 257 PVPlayerNodeInfo* nodeInfo = &iType[NodeSearchCount]; 258 PVMFNodeInterface* nodeInterface = NULL; 259 260 #if VIDEO_DEC_NODE_LOW_PRIORITY 261 //Call the appropriate Node creation function & return Node pointer 262 if (KPVMFOMXVideoDecNodeUuid == aUuid) 263 { 264 priority = OsclActiveObject::EPriorityLow; 265 } 266 #endif 267 if (NULL != nodeInfo->iNodeCreateFunc) 268 { 269 if (KPVMFOMXVideoDecNodeUuid == aUuid) 270 { 271 // FIXME: 272 // for now, we care about whether it is hardware-based or not only when it is a video decoder node. 273 // do a cast on the fucntion pointer 274 PVMFNodeInterface*(*aVideoDecNodeCreateFunc)(int32, bool); 275 aVideoDecNodeCreateFunc = (PVMFNodeInterface*(*)(int32, bool)) (iType[NodeSearchCount].iNodeCreateFunc); 276 nodeInterface = (*(aVideoDecNodeCreateFunc))(priority, aHwAccelerated); 277 } 278 else 279 { 280 nodeInterface = (*(iType[NodeSearchCount].iNodeCreateFunc))(priority); 281 } 282 } 283 284 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::CreateNode() OUT")); 285 return nodeInterface; 286 } 287 else 288 { 289 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::CreateNode() OUT")); 290 return NULL; 291 } 292 293 294 } 295 296 bool PVPlayerNodeRegistry::ReleaseNode(PVUuid& aUuid, PVMFNodeInterface* aNode) 297 { 298 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::ReleaseNode() IN")); 299 bool iFoundFlag = false; 300 uint32 NodeSearchCount = 0; 301 302 while (NodeSearchCount < iType.size()) 303 { 304 //Search if the UUID's will match 305 if (iType[NodeSearchCount].iNodeUUID == aUuid) 306 { 307 //Since the UUID's match set the flag to true 308 iFoundFlag = true; 309 break; 310 } 311 312 NodeSearchCount++; 313 314 } 315 316 if (iFoundFlag) 317 { 318 //Call the appropriate Node release function 319 bool del_stat = (*(iType[NodeSearchCount].iNodeReleaseFunc))(aNode); 320 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::ReleaseNode() OUT")); 321 return del_stat; 322 } 323 324 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerNodeRegistry::ReleaseNode() OUT")); 325 return false; 326 } 327 328 329 PVPlayerRecognizerRegistry::PVPlayerRecognizerRegistry() 330 : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PVPlayerRecognizerRegistry") 331 { 332 AddToScheduler(); 333 334 iRecSessionId = 0; 335 iRecognizerResult.reserve(4); 336 iFileDataStreamFactory = NULL; 337 iDataStreamFactory = NULL; 338 iSourceFormatType = PVMF_MIME_FORMAT_UNKNOWN; 339 iObserver = NULL; 340 iCmdContext = NULL; 341 iCancelQuery = false; 342 iCancelCmdContext = NULL; 343 344 if (PVMFRecognizerRegistry::Init() != PVMFSuccess) 345 { 346 OSCL_ASSERT(false); 347 return; 348 } 349 350 iLogger = PVLogger::GetLoggerObject("pvplayerengine.playerrecognizerregistry"); 351 } 352 353 354 PVPlayerRecognizerRegistry::~PVPlayerRecognizerRegistry() 355 { 356 if (iFileDataStreamFactory) 357 { 358 OSCL_DELETE(OSCL_STATIC_CAST(PVMIDataStreamSyncInterfaceRefFactory*, iFileDataStreamFactory)); 359 iFileDataStreamFactory = NULL; 360 } 361 362 PVMFRecognizerRegistry::Cleanup(); 363 iLogger = NULL; 364 } 365 366 void PVPlayerRecognizerRegistry::AddLoadableModules(const OSCL_String& aConfigFilePath) 367 { 368 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::AddLoadableModules() IN")); 369 #ifdef USE_LOADABLE_MODULES 370 OsclLibraryList libList; 371 libList.Populate(PV_RECOGNIZER_POPULATOR_INTERFACE, aConfigFilePath); 372 373 for (unsigned int i = 0; i < libList.Size(); i++) 374 { 375 OsclSharedLibrary* lib = OSCL_NEW(OsclSharedLibrary, ()); 376 if (lib->LoadLib(libList.GetLibraryPathAt(i)) == OsclLibSuccess) 377 { 378 OsclAny* interfacePtr = NULL; 379 OsclLibStatus result = lib->QueryInterface(PV_RECOGNIZER_POPULATOR_INTERFACE, (OsclAny*&)interfacePtr); 380 if (result == OsclLibSuccess && interfacePtr != NULL) 381 { 382 struct PVPlayerEngineRecognizerSharedLibInfo *libInfo = (struct PVPlayerEngineRecognizerSharedLibInfo *)oscl_malloc(sizeof(struct PVPlayerEngineRecognizerSharedLibInfo)); 383 if (NULL != libInfo) 384 { 385 libInfo->iLib = lib; 386 387 RecognizerPopulatorInterface* recognizerIntPtr = OSCL_DYNAMIC_CAST(RecognizerPopulatorInterface*, interfacePtr); 388 389 libInfo->iRecognizerLibIfacePtr = recognizerIntPtr; 390 391 recognizerIntPtr->RegisterAllRecognizers(this, libInfo->iContext); 392 393 // save for depopulation later 394 iRecognizerLibInfoList.push_front(libInfo); 395 continue; 396 } 397 } 398 } 399 lib->Close(); 400 OSCL_DELETE(lib); 401 } 402 #else 403 OSCL_UNUSED_ARG(aConfigFilePath); 404 #endif 405 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::AddLoadableModules() OUT")); 406 } 407 408 void PVPlayerRecognizerRegistry::RemoveLoadableModules() 409 { 410 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::RemoveLoadableModules() IN")); 411 #ifdef USE_LOADABLE_MODULES 412 // remove all the dynamic plugins now 413 // unregister the plugins one by one 414 while (!iRecognizerLibInfoList.empty()) 415 { 416 struct PVPlayerEngineRecognizerSharedLibInfo *libInfo = iRecognizerLibInfoList.front(); 417 iRecognizerLibInfoList.erase(iRecognizerLibInfoList.begin()); 418 419 OsclSharedLibrary* lib = libInfo->iLib; 420 RecognizerPopulatorInterface* recognizerIntPtr = libInfo->iRecognizerLibIfacePtr; 421 OsclAny* context = libInfo->iContext; 422 oscl_free(libInfo); 423 424 recognizerIntPtr->UnregisterAllRecognizers(this, context); 425 426 lib->Close(); 427 OSCL_DELETE(lib); 428 } 429 #endif 430 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::RemoveLoadableModules() OUT")); 431 } 432 433 PVMFStatus PVPlayerRecognizerRegistry::QueryFormatType(OSCL_wString& aSourceURL, PVPlayerRecognizerRegistryObserver& aObserver, OsclAny* aCmdContext) 434 { 435 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::QueryFormatType() IN")); 436 if (iObserver != NULL) 437 { 438 // Previous query still ongoing 439 return PVMFErrBusy; 440 } 441 iObserver = &aObserver; 442 iCmdContext = aCmdContext; 443 444 // Create a datastream wrapper factory for standard file 445 if (iFileDataStreamFactory) 446 { 447 OSCL_DELETE(OSCL_STATIC_CAST(PVMIDataStreamSyncInterfaceRefFactory*, iFileDataStreamFactory)); 448 iFileDataStreamFactory = NULL; 449 } 450 int32 leavecode = 0; 451 OSCL_TRY(leavecode, iFileDataStreamFactory = OSCL_STATIC_CAST(PVMFDataStreamFactory*, OSCL_NEW(PVMIDataStreamSyncInterfaceRefFactory, (aSourceURL)))); 452 OSCL_FIRST_CATCH_ANY(leavecode, 453 return PVMFErrNoMemory; 454 ); 455 456 // Open the session with recognizer 457 PVMFRecognizerRegistry::OpenSession(iRecSessionId, *this); 458 459 // Request file recognition 460 iRecognizerResult.clear(); 461 iRecognizeCmdId = PVMFRecognizerRegistry::Recognize(iRecSessionId, *iFileDataStreamFactory, NULL, iRecognizerResult, NULL); 462 463 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::QueryFormatType() OUT")); 464 return PVMFSuccess; 465 } 466 467 PVMFStatus PVPlayerRecognizerRegistry::QueryFormatType(PVMFCPMPluginAccessInterfaceFactory* aDataStreamFactory, PVPlayerRecognizerRegistryObserver& aObserver, OsclAny* aCmdContext) 468 { 469 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::QueryFormatType() IN")); 470 if (iObserver != NULL) 471 { 472 // Previous query still ongoing 473 return PVMFErrBusy; 474 } 475 476 if (aDataStreamFactory == NULL) 477 { 478 return PVMFErrArgument; 479 } 480 481 iObserver = &aObserver; 482 iCmdContext = aCmdContext; 483 484 // delete the previous DataStreamFactory created by PVPlayerRecognizerRegistry 485 if (iFileDataStreamFactory) 486 { 487 OSCL_DELETE(OSCL_STATIC_CAST(PVMIDataStreamSyncInterfaceRefFactory*, iFileDataStreamFactory)); 488 iFileDataStreamFactory = NULL; 489 } 490 491 iDataStreamFactory = aDataStreamFactory; 492 493 // Open the session with recognizer 494 PVMFRecognizerRegistry::OpenSession(iRecSessionId, *this); 495 496 // Request file recognition 497 iRecognizerResult.clear(); 498 iRecognizeCmdId = PVMFRecognizerRegistry::Recognize(iRecSessionId, *iDataStreamFactory, NULL, iRecognizerResult, NULL); 499 500 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::QueryFormatType() OUT")); 501 return PVMFSuccess; 502 } 503 504 505 void PVPlayerRecognizerRegistry::CancelQuery(OsclAny* aContext) 506 { 507 if (iObserver == NULL) 508 { 509 // No pending recognize request 510 OSCL_LEAVE(OsclErrInvalidState); 511 return; 512 } 513 514 iCancelQuery = true; 515 iCancelCmdContext = aContext; 516 517 if (!IsBusy()) 518 { 519 // The recognition pending so cancel it 520 PVMFRecognizerRegistry::CancelCommand(iRecSessionId, iRecognizeCmdId); 521 } 522 // Else the recognition already completed so just cancel it in the Run() 523 } 524 525 526 void PVPlayerRecognizerRegistry::Run() 527 { 528 // Close the session with recognizer 529 PVMFRecognizerRegistry::CloseSession(iRecSessionId); 530 531 // Destroy the data stream wrapper factory for standard file 532 if (iFileDataStreamFactory) 533 { 534 OSCL_DELETE(OSCL_STATIC_CAST(PVMIDataStreamSyncInterfaceRefFactory*, iFileDataStreamFactory)); 535 iFileDataStreamFactory = NULL; 536 } 537 538 // Tell the engine the result 539 if (iObserver) 540 { 541 iObserver->RecognizeCompleted(iSourceFormatType, iCmdContext); 542 543 if (iCancelQuery) 544 { 545 iObserver->RecognizeCompleted(iSourceFormatType, iCancelCmdContext); 546 iCancelQuery = false; 547 iCancelCmdContext = NULL; 548 } 549 } 550 iObserver = NULL; 551 iCmdContext = NULL; 552 } 553 554 void PVPlayerRecognizerRegistry::RecognizerCommandCompleted(const PVMFCmdResp& aResponse) 555 { 556 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::RecognizerCommandCompleted() IN")); 557 iSourceFormatType = PVMF_MIME_FORMAT_UNKNOWN; 558 559 if (aResponse.GetCmdId() == iRecognizeCmdId) 560 { 561 // Recognize() command completed 562 if (aResponse.GetCmdStatus() == PVMFSuccess) 563 { 564 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::RecognizeCommandCompleted() - Recognize returned Success")); 565 Oscl_Vector<PVMFRecognizerResult, OsclMemAllocator>::iterator it; 566 for (it = iRecognizerResult.begin(); it != iRecognizerResult.end(); it++) 567 { 568 if (it->iRecognitionConfidence == PVMFRecognizerConfidenceCertain) 569 { //@TODO: validate whether there are more than one claims Certain. 570 iSourceFormatType = it->iRecognizedFormat.get_str(); 571 break; 572 } 573 if (it->iRecognitionConfidence == PVMFRecognizerConfidencePossible) 574 { 575 iSourceFormatType = it->iRecognizedFormat.get_str(); 576 } 577 } 578 } 579 else if (aResponse.GetCmdStatus() == PVMFErrCancelled) 580 { 581 // If cancelled, need to wait for the cancel command to complete before 582 // calling Run 583 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::RecognizerCommandCompleted() - Recognize returned Cancelled - OUT")); 584 return; 585 } 586 } 587 588 RunIfNotReady(); 589 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerRecognizerRegistry::RecognizerCommandCompleted() OUT")); 590 } 591 592 593 594 595 596