int process_media_file(const char *media_file) { void * libstagefright = dlopen("libstagefright.so",0); if(!libstagefright){ die("[-] dlopen failed"); } stageFrightConstructor = resolveSymbol(libstagefright, "_ZN7android28StagefrightMetadataRetrieverC1Ev"); setDataSource = resolveSymbol(libstagefright, "_ZN7android28StagefrightMetadataRetriever13setDataSourceEixx"); extractMetaData = resolveSymbol(libstagefright, "_ZN7android28StagefrightMetadataRetriever15extractMetadataEi"); void * metaDataReceiverObject = malloc(0x100); if(!metaDataReceiverObject){ die("[-] no memory for object"); } stageFrightConstructor(metaDataReceiverObject); int testPOC = open(media_file, 0xa << 12); if(testPOC < 0){ die("[-] failed opening file"); } errno = 0; status_t ret = setDataSource(metaDataReceiverObject, testPOC, 0ull,0x7FFFFFFFFFFFFFFull); if(ret){ printf("[-] setDataSource = 0x%x\n", ret); die("[-] setDataSource"); } ret = extractMetaData(metaDataReceiverObject, 12); printf("ret value %d\n", ret); return 0; }
IBasePropertyPtr DefinitionDetails::directLookupProperty(const char* name) const /* override */ { // Some properties from dir are not accessible as attributes // e.g. __abstractmethods__ is a descriptor if (!pythonObject_.hasAttribute(name)) { return nullptr; } auto meta = extractMetaData(name, metaDataDict_); return std::make_shared<ReflectedPython::Property>(context_, name, pythonObject_, meta); }
status_t AudioResourceManager::setParameter(const String8& keyValuePairs) { String8 key; String8 value; status_t status = NO_ERROR; AudioParameter param = AudioParameter(keyValuePairs); Mutex::Autolock autolock(mLock); ALOGD(" setParameter %s:", keyValuePairs.string()); for(uint8_t i=0; i < ARRAY_SIZE(sUseCaseNameToEnumValue); i++) { key = sUseCaseNameToEnumValue[i].name; if (param.get(key, value) == NO_ERROR) { audio_use_case_value_t useCase = (audio_use_case_value_t) extractMetaData( sUseCaseNameToEnumValue, ARRAY_SIZE(sUseCaseNameToEnumValue), key); ALOGD("key = %s, value = %s, useCase = %d", key.string(), value.string(), (int32_t)useCase); if(value == "true") { // check if there is a conflicting usecase // if yes, return error without updating the refCount // if no increment the refCount ALOGV("handleConcurrency"); status = handleConcurrency(useCase, true); } else if(value == "false") { // Decrement the refCount ALOGV("updateUsecaseRefCount"); status = updateUsecaseRefCount(useCase, false); } else { ALOGE(" Wrong value set for use case = %s", key.string()); status = BAD_VALUE; } break; } else { status = NAME_NOT_FOUND; ALOGV("Not a concurrency setParameter - Not an error"); } } param.remove(key); return status; }
IDBDatabaseBackendImpl::IDBDatabaseBackendImpl(const String& name, IDBSQLiteDatabase* sqliteDatabase, IDBTransactionCoordinator* coordinator, IDBFactoryBackendImpl* factory, const String& uniqueIdentifier) : m_sqliteDatabase(sqliteDatabase) , m_id(InvalidId) , m_name(name) , m_version("") , m_identifier(uniqueIdentifier) , m_factory(factory) , m_transactionCoordinator(coordinator) { ASSERT(!m_name.isNull()); bool success = extractMetaData(m_sqliteDatabase->db(), m_name, m_version, m_id); ASSERT_UNUSED(success, success == (m_id != InvalidId)); if (!setMetaData(m_sqliteDatabase->db(), m_name, m_version, m_id)) ASSERT_NOT_REACHED(); // FIXME: Need better error handling. loadObjectStores(); }
status_t AudioResourceManager::updateDependencyListForUsecases( audio_use_case_value_t useCase) { //Read the list from predefined as they are dependent uint32_t size = 0; struct UseCaseMetadata *table = NULL; status_t err = NO_ERROR; audio_use_case_value_t dependentUseCase = (audio_use_case_value_t)0; ConcurrencyDataDescriptor *desc = NULL; switch(useCase) { case USECASE_PCM_PLAYBACK: table = (UseCaseMetadata * )sPcmPlaybackConflicts; size = ARRAY_SIZE(sPcmPlaybackConflicts); break; case USECASE_PCM_RECORDING: table = (UseCaseMetadata * )sPcmRecordingConflicts; size = ARRAY_SIZE(sPcmRecordingConflicts); break; case USECASE_NON_TUNNEL_DSP_PLAYBACK: table = (UseCaseMetadata * )sNonTunnelDSPPlaybackConflicts; size = ARRAY_SIZE(sNonTunnelDSPPlaybackConflicts); break; case USECASE_TUNNEL_DSP_PLAYBACK: table = (UseCaseMetadata * )sTunnelPlaybackConflicts; size = ARRAY_SIZE(sTunnelPlaybackConflicts); break; case USECASE_LPA_PLAYBACK: table = (UseCaseMetadata * )sLPAPlaybackConflicts; size = ARRAY_SIZE(sLPAPlaybackConflicts); break; case USECASE_NON_TUNNEL_VIDEO_DSP_PLAYBACK: table = (UseCaseMetadata * )sNonTunnelVideoDSPPlaybackConflicts; size = ARRAY_SIZE(sNonTunnelVideoDSPPlaybackConflicts); break; case USECASE_VIDEO_PLAYBACK: table = (UseCaseMetadata * )sVideoPlaybackConflicts; size = ARRAY_SIZE(sVideoPlaybackConflicts); break; case USECASE_VIDEO_RECORD: table = (UseCaseMetadata * )sVideoRecordConflicts; size = ARRAY_SIZE(sVideoRecordConflicts); break; case USECASE_VOICE_CALL: table = (UseCaseMetadata * )sVoiceCallConflicts; size = ARRAY_SIZE(sVoiceCallConflicts); break; case USECASE_VOIP_CALL: table = (UseCaseMetadata * )sVoipCallConflicts; size = ARRAY_SIZE(sVoipCallConflicts); break; case USECASE_VIDEO_TELEPHONY: //table = (UseCaseMetadata * )sVideoTelephonyConflicts; //size = ARRAY_SIZE(sVideoTelephonyConflicts); break; case USECASE_FM_PLAYBACK: table = (UseCaseMetadata * )sFMPlaybackConflicts; size = ARRAY_SIZE(sFMPlaybackConflicts); break; case USECASE_ULL: ALOGD("USECASE_ULL"); break; default: ALOGE("BAD_VALUE"); err = BAD_VALUE; break; } ALOGD("updateDependencyListForUsecases = %d, table = %p,size = %d", useCase, table, size); if(!err) { for(uint8_t i = 0; i < size; i++) { dependentUseCase = (audio_use_case_value_t) extractMetaData( sUseCaseNameToEnumValue, ARRAY_SIZE(sUseCaseNameToEnumValue),table[i].name); desc = mConcurrencyDataVector.valueFor(dependentUseCase); ConcurrencyRefCountVector *vector = new ConcurrencyRefCountVector(); vector->desc = desc; vector->maxRefCount = table[i].value; ALOGD("desc = %p, dependentUseCase = %d, vector = %p", desc, dependentUseCase, vector); mConcurrencyDataList[useCase].push_back(vector); } mConcurrencyDataGraph.add(useCase, mConcurrencyDataList[useCase]); } return err; }