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;
}
