Merge "Add media.c2 AIDL service to media.swcodec" into main am: 3237d78cb7
Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/2758286
Change-Id: Idf4719a3c265ebafa18cb39e7187299bcfd01410
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
diff --git a/media/codec2/hal/aidl/Android.bp b/media/codec2/hal/aidl/Android.bp
index 44f85fd..68d7152 100644
--- a/media/codec2/hal/aidl/Android.bp
+++ b/media/codec2/hal/aidl/Android.bp
@@ -6,7 +6,6 @@
// use libcodec2-aidl-client-defaults instead
cc_library {
name: "libcodec2_aidl_client",
- min_sdk_version: "31",
srcs: [
"BufferTypes.cpp",
@@ -36,7 +35,6 @@
],
static_libs: [
- "libPlatformProperties",
"libaidlcommonsupport",
],
@@ -55,7 +53,7 @@
// use libcodec2-aidl-defaults instead
cc_library {
name: "libcodec2_aidl",
- min_sdk_version: "31",
+ min_sdk_version: "30",
vendor_available: true,
apex_available: [
"//apex_available:platform",
@@ -98,7 +96,6 @@
],
static_libs: [
- "libPlatformProperties",
"libaidlcommonsupport",
],
@@ -134,7 +131,7 @@
// public dependency for Codec 2.0 HAL service implementations
cc_defaults {
name: "libcodec2-aidl-defaults",
- min_sdk_version: "31",
+ min_sdk_version: "30",
defaults: ["libcodec2-impl-defaults"],
shared_libs: [
@@ -147,7 +144,6 @@
// public dependency for Codec 2.0 HAL client
cc_defaults {
name: "libcodec2-aidl-client-defaults",
- min_sdk_version: "31",
defaults: ["libcodec2-impl-defaults"],
shared_libs: [
diff --git a/media/codec2/hal/aidl/ParamTypes.cpp b/media/codec2/hal/aidl/ParamTypes.cpp
index 41e6f50..495e748 100644
--- a/media/codec2/hal/aidl/ParamTypes.cpp
+++ b/media/codec2/hal/aidl/ParamTypes.cpp
@@ -19,7 +19,9 @@
#include <android-base/logging.h>
#include <android/binder_manager.h>
-#include <android/sysprop/MediaProperties.sysprop.h>
+// NOTE: due to dependency from mainline modules cannot use libsysprop
+// #include <android/sysprop/MediaProperties.sysprop.h>
+#include <android-base/properties.h>
#include <codec2/aidl/ParamTypes.h>
#include <codec2/common/ParamTypes.h>
@@ -167,6 +169,8 @@
// Cannot select AIDL if not enabled
return false;
}
+#if 0
+ // NOTE: due to dependency from mainline modules cannot use libsysprop
using ::android::sysprop::MediaProperties::codec2_hal_selection;
using ::android::sysprop::MediaProperties::codec2_hal_selection_values;
constexpr codec2_hal_selection_values AIDL = codec2_hal_selection_values::AIDL;
@@ -180,6 +184,16 @@
default:
LOG(FATAL) << "Unexpected codec2 HAL selection value: " << (int)selection;
}
+#else
+ std::string selection = ::android::base::GetProperty("media.c2.hal.selection", "hidl");
+ if (selection == "aidl") {
+ return true;
+ } else if (selection == "hidl") {
+ return false;
+ } else {
+ LOG(FATAL) << "Unexpected codec2 HAL selection value: " << selection;
+ }
+#endif
return false;
}
diff --git a/media/codec2/hal/client/client.cpp b/media/codec2/hal/client/client.cpp
index ab6505e..5311b31 100644
--- a/media/codec2/hal/client/client.cpp
+++ b/media/codec2/hal/client/client.cpp
@@ -45,6 +45,7 @@
#include <aidl/android/hardware/media/c2/StructDescriptor.h>
#include <aidlcommonsupport/NativeHandle.h>
+#include <android/api-level.h>
#include <android/binder_auto_utils.h>
#include <android/binder_ibinder.h>
#include <android/binder_manager.h>
@@ -1439,12 +1440,16 @@
std::vector<std::string> names;
if (c2_aidl::utils::IsSelected()) {
- // Get AIDL service names
- AServiceManager_forEachDeclaredInstance(
- AidlBase::descriptor, &names, [](const char *name, void *context) {
- std::vector<std::string> *names = (std::vector<std::string> *)context;
- names->emplace_back(name);
- });
+ if (__builtin_available(android __ANDROID_API_S__, *)) {
+ // Get AIDL service names
+ AServiceManager_forEachDeclaredInstance(
+ AidlBase::descriptor, &names, [](const char *name, void *context) {
+ std::vector<std::string> *names = (std::vector<std::string> *)context;
+ names->emplace_back(name);
+ });
+ } else {
+ LOG(FATAL) << "C2 AIDL cannot be selected on Android version older than 35";
+ }
} else {
// Get HIDL service names
using ::android::hardware::media::c2::V1_0::IComponentStore;
@@ -1546,21 +1551,25 @@
LOG(VERBOSE) << "Creating a Codec2 client to service \"" << name << "\"";
if (c2_aidl::utils::IsSelected()) {
- std::string instanceName =
- ::android::base::StringPrintf("%s/%s", AidlBase::descriptor, name.c_str());
- if (AServiceManager_isDeclared(instanceName.c_str())) {
- std::shared_ptr<AidlBase> baseStore = AidlBase::fromBinder(
- ::ndk::SpAIBinder(AServiceManager_waitForService(instanceName.c_str())));
- CHECK(baseStore) << "Codec2 AIDL service \"" << name << "\""
- " inaccessible for unknown reasons.";
- LOG(VERBOSE) << "Client to Codec2 AIDL service \"" << name << "\" created";
- std::shared_ptr<c2_aidl::IConfigurable> configurable;
- ::ndk::ScopedAStatus transStatus = baseStore->getConfigurable(&configurable);
- CHECK(transStatus.isOk()) << "Codec2 AIDL service \"" << name << "\""
- "does not have IConfigurable.";
- return std::make_shared<Codec2Client>(baseStore, configurable, index);
+ if (__builtin_available(android __ANDROID_API_S__, *)) {
+ std::string instanceName =
+ ::android::base::StringPrintf("%s/%s", AidlBase::descriptor, name.c_str());
+ if (AServiceManager_isDeclared(instanceName.c_str())) {
+ std::shared_ptr<AidlBase> baseStore = AidlBase::fromBinder(
+ ::ndk::SpAIBinder(AServiceManager_waitForService(instanceName.c_str())));
+ CHECK(baseStore) << "Codec2 AIDL service \"" << name << "\""
+ " inaccessible for unknown reasons.";
+ LOG(VERBOSE) << "Client to Codec2 AIDL service \"" << name << "\" created";
+ std::shared_ptr<c2_aidl::IConfigurable> configurable;
+ ::ndk::ScopedAStatus transStatus = baseStore->getConfigurable(&configurable);
+ CHECK(transStatus.isOk()) << "Codec2 AIDL service \"" << name << "\""
+ "does not have IConfigurable.";
+ return std::make_shared<Codec2Client>(baseStore, configurable, index);
+ } else {
+ LOG(ERROR) << "Codec2 AIDL service \"" << name << "\" is not declared";
+ }
} else {
- LOG(ERROR) << "Codec2 AIDL service \"" << name << "\" is not declared";
+ LOG(FATAL) << "C2 AIDL cannot be selected on Android version older than 35";
}
} else {
std::string instanceName = "android.hardware.media.c2/" + name;
diff --git a/media/mediaserver/manifest_media_c2_software.xml b/media/mediaserver/manifest_media_c2_software.xml
index a5b4896..d7fb1a0 100644
--- a/media/mediaserver/manifest_media_c2_software.xml
+++ b/media/mediaserver/manifest_media_c2_software.xml
@@ -8,4 +8,9 @@
<instance>software</instance>
</interface>
</hal>
+ <hal format="aidl">
+ <name>android.hardware.media.c2</name>
+ <version>1</version>
+ <fqname>IComponentStore/software</fqname>
+ </hal>
</manifest>
diff --git a/media/module/codecserviceregistrant/Android.bp b/media/module/codecserviceregistrant/Android.bp
index 9ee81a4..becb98a 100644
--- a/media/module/codecserviceregistrant/Android.bp
+++ b/media/module/codecserviceregistrant/Android.bp
@@ -64,6 +64,7 @@
],
defaults: [
+ "libcodec2-aidl-defaults",
"libcodec2-hidl-defaults",
"libcodec2-runtime-libs",
],
diff --git a/media/module/codecserviceregistrant/CodecServiceRegistrant.cpp b/media/module/codecserviceregistrant/CodecServiceRegistrant.cpp
index 1de9efe..b65ad48 100644
--- a/media/module/codecserviceregistrant/CodecServiceRegistrant.cpp
+++ b/media/module/codecserviceregistrant/CodecServiceRegistrant.cpp
@@ -20,15 +20,25 @@
#include <android/api-level.h>
#include <android-base/logging.h>
#include <android-base/properties.h>
+#include <android-base/stringprintf.h>
#include <C2Component.h>
#include <C2PlatformSupport.h>
+
#include <codec2/hidl/1.0/ComponentStore.h>
#include <codec2/hidl/1.1/ComponentStore.h>
#include <codec2/hidl/1.2/ComponentStore.h>
#include <codec2/hidl/1.2/Configurable.h>
#include <codec2/hidl/1.2/types.h>
#include <hidl/HidlSupport.h>
+#include <hidl/HidlTransportSupport.h>
+
+#include <android/binder_interface_utils.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
+#include <codec2/aidl/ComponentStore.h>
+#include <codec2/aidl/ParamTypes.h>
+
#include <media/CodecServiceRegistrant.h>
namespace /* unnamed */ {
@@ -36,59 +46,139 @@
using ::android::hardware::hidl_vec;
using ::android::hardware::hidl_string;
using ::android::hardware::Return;
-using ::android::hardware::Void;
using ::android::sp;
-using namespace ::android::hardware::media::c2::V1_2;
-using namespace ::android::hardware::media::c2::V1_2::utils;
+using ::ndk::ScopedAStatus;
+namespace c2_hidl = ::android::hardware::media::c2::V1_2;
+namespace c2_aidl = ::aidl::android::hardware::media::c2;
constexpr c2_status_t C2_TRANSACTION_FAILED = C2_CORRUPTED;
// Converter from IComponentStore to C2ComponentStore.
class H2C2ComponentStore : public C2ComponentStore {
protected:
- using IComponentStore =
+ using HidlComponentStore =
::android::hardware::media::c2::V1_0::IComponentStore;
- using IConfigurable =
+ using HidlConfigurable =
::android::hardware::media::c2::V1_0::IConfigurable;
- sp<IComponentStore> mStore;
- sp<IConfigurable> mConfigurable;
+ sp<HidlComponentStore> mHidlStore;
+ sp<HidlConfigurable> mHidlConfigurable;
+
+ using AidlComponentStore =
+ ::aidl::android::hardware::media::c2::IComponentStore;
+ using AidlConfigurable =
+ ::aidl::android::hardware::media::c2::IConfigurable;
+ std::shared_ptr<AidlComponentStore> mAidlStore;
+ std::shared_ptr<AidlConfigurable> mAidlConfigurable;
public:
- explicit H2C2ComponentStore(sp<IComponentStore> const& store)
- : mStore{store},
- mConfigurable{[store]() -> sp<IConfigurable>{
+ explicit H2C2ComponentStore(sp<HidlComponentStore> const& store)
+ : mHidlStore{store},
+ mHidlConfigurable{[store]() -> sp<HidlConfigurable>{
if (!store) {
return nullptr;
}
- Return<sp<IConfigurable>> transResult =
+ Return<sp<HidlConfigurable>> transResult =
store->getConfigurable();
return transResult.isOk() ?
- static_cast<sp<IConfigurable>>(transResult) :
+ static_cast<sp<HidlConfigurable>>(transResult) :
nullptr;
}()} {
- if (!mConfigurable) {
+ if (!mHidlConfigurable) {
+ LOG(ERROR) << "Preferred store is corrupted.";
+ }
+ }
+
+ explicit H2C2ComponentStore(std::shared_ptr<AidlComponentStore> const& store)
+ : mAidlStore{store},
+ mAidlConfigurable{[store]() -> std::shared_ptr<AidlConfigurable>{
+ if (!store) {
+ return nullptr;
+ }
+ std::shared_ptr<AidlConfigurable> configurable;
+ ScopedAStatus status = store->getConfigurable(&configurable);
+ if (!status.isOk()) {
+ return nullptr;
+ }
+ return configurable;
+ }()} {
+ if (!mAidlConfigurable) {
LOG(ERROR) << "Preferred store is corrupted.";
}
}
virtual ~H2C2ComponentStore() override = default;
- virtual c2_status_t config_sm(
+ c2_status_t config_sm(
std::vector<C2Param*> const ¶ms,
std::vector<std::unique_ptr<C2SettingResult>>* const failures
) override {
- Params hidlParams;
- if (!createParamsBlob(&hidlParams, params)) {
+ if (mAidlStore) {
+ return config_sm_aidl(params, failures);
+ } else if (mHidlStore) {
+ return config_sm_hidl(params, failures);
+ } else {
+ return C2_OMITTED;
+ }
+ }
+
+ c2_status_t config_sm_aidl(
+ std::vector<C2Param*> const ¶ms,
+ std::vector<std::unique_ptr<C2SettingResult>>* const failures
+ ) {
+ c2_aidl::Params aidlParams;
+ if (!c2_aidl::utils::CreateParamsBlob(&aidlParams, params)) {
+ LOG(ERROR) << "config -- bad input.";
+ return C2_TRANSACTION_FAILED;
+ }
+ c2_status_t status = C2_OK;
+ c2_aidl::IConfigurable::ConfigResult configResult;
+ ScopedAStatus transResult = mAidlConfigurable->config(
+ aidlParams, true, &configResult);
+ if (!transResult.isOk()) {
+ if (transResult.getExceptionCode() == EX_SERVICE_SPECIFIC) {
+ status = c2_status_t(transResult.getServiceSpecificError());
+ if (status != C2_BAD_INDEX) {
+ LOG(DEBUG) << "config -- call failed: "
+ << status << ".";
+ }
+ } else {
+ LOG(ERROR) << "config -- transaction failed.";
+ return C2_TRANSACTION_FAILED;
+ }
+ }
+ size_t i = failures->size();
+ failures->resize(i + configResult.failures.size());
+ for (const c2_aidl::SettingResult& sf : configResult.failures) {
+ if (!c2_aidl::utils::FromAidl(&(*failures)[i++], sf)) {
+ LOG(ERROR) << "config -- "
+ << "invalid SettingResult returned.";
+ status = C2_CORRUPTED;
+ }
+ }
+ if (!c2_aidl::utils::UpdateParamsFromBlob(params, configResult.params)) {
+ LOG(ERROR) << "config -- "
+ << "failed to parse returned params.";
+ status = C2_CORRUPTED;
+ }
+ return status;
+ };
+
+ c2_status_t config_sm_hidl(
+ std::vector<C2Param*> const ¶ms,
+ std::vector<std::unique_ptr<C2SettingResult>>* const failures
+ ) {
+ c2_hidl::Params hidlParams;
+ if (!c2_hidl::utils::createParamsBlob(&hidlParams, params)) {
LOG(ERROR) << "config -- bad input.";
return C2_TRANSACTION_FAILED;
}
c2_status_t status{};
- Return<void> transResult = mConfigurable->config(
+ Return<void> transResult = mHidlConfigurable->config(
hidlParams,
true,
[&status, ¶ms, failures](
- Status s,
- const hidl_vec<SettingResult> f,
- const Params& o) {
+ c2_hidl::Status s,
+ const hidl_vec<c2_hidl::SettingResult> f,
+ const c2_hidl::Params& o) {
status = static_cast<c2_status_t>(s);
if (status != C2_OK && status != C2_BAD_INDEX) {
LOG(DEBUG) << "config -- call failed: "
@@ -96,14 +186,14 @@
}
size_t i = failures->size();
failures->resize(i + f.size());
- for (const SettingResult& sf : f) {
- if (!objcpy(&(*failures)[i++], sf)) {
+ for (const c2_hidl::SettingResult& sf : f) {
+ if (!c2_hidl::utils::objcpy(&(*failures)[i++], sf)) {
LOG(ERROR) << "config -- "
<< "invalid SettingResult returned.";
return;
}
}
- if (!updateParamsFromBlob(params, o)) {
+ if (!c2_hidl::utils::updateParamsFromBlob(params, o)) {
LOG(ERROR) << "config -- "
<< "failed to parse returned params.";
status = C2_CORRUPTED;
@@ -116,33 +206,142 @@
return status;
};
- virtual c2_status_t copyBuffer(
+ c2_status_t copyBuffer(
std::shared_ptr<C2GraphicBuffer>,
std::shared_ptr<C2GraphicBuffer>) override {
LOG(ERROR) << "copyBuffer -- not supported.";
return C2_OMITTED;
}
- virtual c2_status_t createComponent(
+ c2_status_t createComponent(
C2String, std::shared_ptr<C2Component> *const component) override {
component->reset();
LOG(ERROR) << "createComponent -- not supported.";
return C2_OMITTED;
}
- virtual c2_status_t createInterface(
- C2String, std::shared_ptr<C2ComponentInterface> *const interface) {
+ c2_status_t createInterface(
+ C2String, std::shared_ptr<C2ComponentInterface> *const interface) override {
interface->reset();
LOG(ERROR) << "createInterface -- not supported.";
return C2_OMITTED;
}
- virtual c2_status_t query_sm(
+ c2_status_t query_sm(
const std::vector<C2Param *> &stackParams,
const std::vector<C2Param::Index> &heapParamIndices,
- std::vector<std::unique_ptr<C2Param>> *const heapParams) const
- override {
- hidl_vec<ParamIndex> indices(
+ std::vector<std::unique_ptr<C2Param>> *const heapParams) const override {
+ if (mAidlStore) {
+ return query_sm_aidl(stackParams, heapParamIndices, heapParams);
+ } else if (mHidlStore) {
+ return query_sm_hidl(stackParams, heapParamIndices, heapParams);
+ } else {
+ return C2_OMITTED;
+ }
+ }
+
+ static c2_status_t UpdateQueryResult(
+ const std::vector<C2Param *> ¶mPointers,
+ size_t numStackIndices,
+ const std::vector<C2Param *> &stackParams,
+ std::vector<std::unique_ptr<C2Param>> *const heapParams) {
+ c2_status_t status = C2_OK;
+ size_t i = 0;
+ for (auto it = paramPointers.begin(); it != paramPointers.end(); ) {
+ C2Param* paramPointer = *it;
+ if (numStackIndices > 0) {
+ --numStackIndices;
+ if (!paramPointer) {
+ LOG(WARNING) << "query -- null stack param.";
+ ++it;
+ continue;
+ }
+ for (; i < stackParams.size() && !stackParams[i]; ) {
+ ++i;
+ }
+ if (i >= stackParams.size()) {
+ LOG(ERROR) << "query -- unexpected error.";
+ status = C2_CORRUPTED;
+ break;
+ }
+ if (stackParams[i]->index() != paramPointer->index()) {
+ LOG(WARNING) << "query -- param skipped: "
+ "index = "
+ << stackParams[i]->index() << ".";
+ stackParams[i++]->invalidate();
+ continue;
+ }
+ if (!stackParams[i++]->updateFrom(*paramPointer)) {
+ LOG(WARNING) << "query -- param update failed: "
+ "index = "
+ << paramPointer->index() << ".";
+ }
+ } else {
+ if (!paramPointer) {
+ LOG(WARNING) << "query -- null heap param.";
+ ++it;
+ continue;
+ }
+ if (!heapParams) {
+ LOG(WARNING) << "query -- "
+ "unexpected extra stack param.";
+ } else {
+ heapParams->emplace_back(
+ C2Param::Copy(*paramPointer));
+ }
+ }
+ ++it;
+ }
+ return status;
+ }
+
+ c2_status_t query_sm_aidl(
+ const std::vector<C2Param *> &stackParams,
+ const std::vector<C2Param::Index> &heapParamIndices,
+ std::vector<std::unique_ptr<C2Param>> *const heapParams) const {
+ std::vector<int32_t> indices;
+ size_t numIndices = 0;
+ for (C2Param* const& stackParam : stackParams) {
+ if (!stackParam) {
+ LOG(WARNING) << "query -- null stack param encountered.";
+ continue;
+ }
+ indices[numIndices++] = stackParam->index();
+ }
+ size_t numStackIndices = numIndices;
+ for (const C2Param::Index& index : heapParamIndices) {
+ indices[numIndices++] = static_cast<uint32_t>(index);
+ }
+ indices.resize(numIndices);
+ if (heapParams) {
+ heapParams->reserve(heapParams->size() + numIndices);
+ }
+ c2_status_t status = C2_OK;
+ c2_aidl::Params aidlParams;
+ ScopedAStatus transResult = mAidlConfigurable->query(indices, true, &aidlParams);
+ if (!transResult.isOk()) {
+ if (transResult.getExceptionCode() == EX_SERVICE_SPECIFIC) {
+ status = c2_status_t(transResult.getServiceSpecificError());
+ LOG(DEBUG) << "query -- call failed: " << status << ".";
+ return status;
+ } else {
+ LOG(ERROR) << "query -- transaction failed.";
+ return C2_TRANSACTION_FAILED;
+ }
+ }
+ std::vector<C2Param*> paramPointers;
+ if (!c2_aidl::utils::ParseParamsBlob(¶mPointers, aidlParams)) {
+ LOG(ERROR) << "query -- error while parsing params.";
+ return C2_CORRUPTED;
+ }
+ return UpdateQueryResult(paramPointers, numStackIndices, stackParams, heapParams);
+ }
+
+ c2_status_t query_sm_hidl(
+ const std::vector<C2Param *> &stackParams,
+ const std::vector<C2Param::Index> &heapParamIndices,
+ std::vector<std::unique_ptr<C2Param>> *const heapParams) const {
+ hidl_vec<c2_hidl::ParamIndex> indices(
stackParams.size() + heapParamIndices.size());
size_t numIndices = 0;
for (C2Param* const& stackParam : stackParams) {
@@ -150,23 +349,23 @@
LOG(WARNING) << "query -- null stack param encountered.";
continue;
}
- indices[numIndices++] = static_cast<ParamIndex>(stackParam->index());
+ indices[numIndices++] = static_cast<c2_hidl::ParamIndex>(stackParam->index());
}
size_t numStackIndices = numIndices;
for (const C2Param::Index& index : heapParamIndices) {
indices[numIndices++] =
- static_cast<ParamIndex>(static_cast<uint32_t>(index));
+ static_cast<c2_hidl::ParamIndex>(static_cast<uint32_t>(index));
}
indices.resize(numIndices);
if (heapParams) {
heapParams->reserve(heapParams->size() + numIndices);
}
c2_status_t status;
- Return<void> transResult = mConfigurable->query(
+ Return<void> transResult = mHidlConfigurable->query(
indices,
true,
[&status, &numStackIndices, &stackParams, heapParams](
- Status s, const Params& p) {
+ c2_hidl::Status s, const c2_hidl::Params& p) {
status = static_cast<c2_status_t>(s);
if (status != C2_OK && status != C2_BAD_INDEX) {
LOG(DEBUG) << "query -- call failed: "
@@ -174,58 +373,13 @@
return;
}
std::vector<C2Param*> paramPointers;
- if (!parseParamsBlob(¶mPointers, p)) {
+ if (!c2_hidl::utils::parseParamsBlob(¶mPointers, p)) {
LOG(ERROR) << "query -- error while parsing params.";
status = C2_CORRUPTED;
return;
}
- size_t i = 0;
- for (auto it = paramPointers.begin();
- it != paramPointers.end(); ) {
- C2Param* paramPointer = *it;
- if (numStackIndices > 0) {
- --numStackIndices;
- if (!paramPointer) {
- LOG(WARNING) << "query -- null stack param.";
- ++it;
- continue;
- }
- for (; i < stackParams.size() && !stackParams[i]; ) {
- ++i;
- }
- if (i >= stackParams.size()) {
- LOG(ERROR) << "query -- unexpected error.";
- status = C2_CORRUPTED;
- return;
- }
- if (stackParams[i]->index() != paramPointer->index()) {
- LOG(WARNING) << "query -- param skipped: "
- "index = "
- << stackParams[i]->index() << ".";
- stackParams[i++]->invalidate();
- continue;
- }
- if (!stackParams[i++]->updateFrom(*paramPointer)) {
- LOG(WARNING) << "query -- param update failed: "
- "index = "
- << paramPointer->index() << ".";
- }
- } else {
- if (!paramPointer) {
- LOG(WARNING) << "query -- null heap param.";
- ++it;
- continue;
- }
- if (!heapParams) {
- LOG(WARNING) << "query -- "
- "unexpected extra stack param.";
- } else {
- heapParams->emplace_back(
- C2Param::Copy(*paramPointer));
- }
- }
- ++it;
- }
+ status = UpdateQueryResult(
+ paramPointers, numStackIndices, stackParams, heapParams);
});
if (!transResult.isOk()) {
LOG(ERROR) << "query -- transaction failed.";
@@ -234,15 +388,58 @@
return status;
}
- virtual c2_status_t querySupportedParams_nb(
+ c2_status_t querySupportedParams_nb(
+ std::vector<std::shared_ptr<C2ParamDescriptor>> *const params) const override {
+ if (mAidlStore) {
+ return querySupportedParams_nb_aidl(params);
+ } else if (mHidlStore) {
+ return querySupportedParams_nb_hidl(params);
+ } else {
+ return C2_OMITTED;
+ }
+ }
+
+ c2_status_t querySupportedParams_nb_aidl(
+ std::vector<std::shared_ptr<C2ParamDescriptor>> *const params) const {
+ c2_status_t status = C2_OK;
+ std::vector<c2_aidl::ParamDescriptor> aidlParams;
+ ScopedAStatus transResult = mAidlConfigurable->querySupportedParams(
+ std::numeric_limits<uint32_t>::min(),
+ std::numeric_limits<uint32_t>::max(),
+ &aidlParams);
+ if (!transResult.isOk()) {
+ if (transResult.getExceptionCode() == EX_SERVICE_SPECIFIC) {
+ status = c2_status_t(transResult.getServiceSpecificError());
+ LOG(DEBUG) << "querySupportedParams -- call failed: "
+ << status << ".";
+ return status;
+ } else {
+ LOG(ERROR) << "querySupportedParams -- transaction failed.";
+ return C2_TRANSACTION_FAILED;
+ }
+ }
+
+ size_t i = params->size();
+ params->resize(i + aidlParams.size());
+ for (const c2_aidl::ParamDescriptor& sp : aidlParams) {
+ if (!c2_aidl::utils::FromAidl(&(*params)[i++], sp)) {
+ LOG(ERROR) << "querySupportedParams -- "
+ << "invalid returned ParamDescriptor.";
+ break;
+ }
+ }
+ return status;
+ }
+
+ c2_status_t querySupportedParams_nb_hidl(
std::vector<std::shared_ptr<C2ParamDescriptor>> *const params) const {
c2_status_t status;
- Return<void> transResult = mConfigurable->querySupportedParams(
+ Return<void> transResult = mHidlConfigurable->querySupportedParams(
std::numeric_limits<uint32_t>::min(),
std::numeric_limits<uint32_t>::max(),
[&status, params](
- Status s,
- const hidl_vec<ParamDescriptor>& p) {
+ c2_hidl::Status s,
+ const hidl_vec<c2_hidl::ParamDescriptor>& p) {
status = static_cast<c2_status_t>(s);
if (status != C2_OK) {
LOG(DEBUG) << "querySupportedParams -- call failed: "
@@ -251,8 +448,8 @@
}
size_t i = params->size();
params->resize(i + p.size());
- for (const ParamDescriptor& sp : p) {
- if (!objcpy(&(*params)[i++], sp)) {
+ for (const c2_hidl::ParamDescriptor& sp : p) {
+ if (!c2_hidl::utils::objcpy(&(*params)[i++], sp)) {
LOG(ERROR) << "querySupportedParams -- "
<< "invalid returned ParamDescriptor.";
return;
@@ -266,23 +463,75 @@
return status;
}
- virtual c2_status_t querySupportedValues_sm(
+ c2_status_t querySupportedValues_sm(
+ std::vector<C2FieldSupportedValuesQuery> &fields) const override {
+ if (mAidlStore) {
+ return querySupportedValues_sm_aidl(fields);
+ } else if (mHidlStore) {
+ return querySupportedValues_sm_hidl(fields);
+ } else {
+ return C2_OMITTED;
+ }
+ }
+
+ c2_status_t querySupportedValues_sm_aidl(
std::vector<C2FieldSupportedValuesQuery> &fields) const {
- hidl_vec<FieldSupportedValuesQuery> inFields(fields.size());
+ std::vector<c2_aidl::FieldSupportedValuesQuery> aidlFields(fields.size());
for (size_t i = 0; i < fields.size(); ++i) {
- if (!objcpy(&inFields[i], fields[i])) {
+ if (!c2_aidl::utils::ToAidl(&aidlFields[i], fields[i])) {
+ LOG(ERROR) << "querySupportedValues -- bad input";
+ return C2_TRANSACTION_FAILED;
+ }
+ }
+
+ c2_status_t status = C2_OK;
+ std::vector<c2_aidl::FieldSupportedValuesQueryResult> queryResults;
+ ScopedAStatus transResult = mAidlConfigurable->querySupportedValues(
+ aidlFields, true, &queryResults);
+ if (!transResult.isOk()) {
+ if (transResult.getExceptionCode() == EX_SERVICE_SPECIFIC) {
+ status = c2_status_t(transResult.getServiceSpecificError());
+ LOG(DEBUG) << "querySupportedValues -- call failed: "
+ << status << ".";
+ return status;
+ } else {
+ LOG(ERROR) << "querySupportedValues -- transaction failed.";
+ return C2_TRANSACTION_FAILED;
+ }
+ }
+ if (queryResults.size() != fields.size()) {
+ LOG(ERROR) << "querySupportedValues -- "
+ "input and output lists "
+ "have different sizes.";
+ return C2_CORRUPTED;
+ }
+ for (size_t i = 0; i < fields.size(); ++i) {
+ if (!c2_aidl::utils::FromAidl(&fields[i], aidlFields[i], queryResults[i])) {
+ LOG(ERROR) << "querySupportedValues -- "
+ "invalid returned value.";
+ return C2_CORRUPTED;
+ }
+ }
+ return status;
+ }
+
+ c2_status_t querySupportedValues_sm_hidl(
+ std::vector<C2FieldSupportedValuesQuery> &fields) const {
+ hidl_vec<c2_hidl::FieldSupportedValuesQuery> inFields(fields.size());
+ for (size_t i = 0; i < fields.size(); ++i) {
+ if (!c2_hidl::utils::objcpy(&inFields[i], fields[i])) {
LOG(ERROR) << "querySupportedValues -- bad input";
return C2_TRANSACTION_FAILED;
}
}
c2_status_t status;
- Return<void> transResult = mConfigurable->querySupportedValues(
+ Return<void> transResult = mHidlConfigurable->querySupportedValues(
inFields,
true,
[&status, &inFields, &fields](
- Status s,
- const hidl_vec<FieldSupportedValuesQueryResult>& r) {
+ c2_hidl::Status s,
+ const hidl_vec<c2_hidl::FieldSupportedValuesQueryResult>& r) {
status = static_cast<c2_status_t>(s);
if (status != C2_OK) {
LOG(DEBUG) << "querySupportedValues -- call failed: "
@@ -297,7 +546,7 @@
return;
}
for (size_t i = 0; i < fields.size(); ++i) {
- if (!objcpy(&fields[i], inFields[i], r[i])) {
+ if (!c2_hidl::utils::objcpy(&fields[i], inFields[i], r[i])) {
LOG(ERROR) << "querySupportedValues -- "
"invalid returned value.";
status = C2_CORRUPTED;
@@ -312,14 +561,21 @@
return status;
}
- virtual C2String getName() const {
- C2String outName;
- Return<void> transResult = mConfigurable->getName(
- [&outName](const hidl_string& name) {
- outName = name.c_str();
- });
- if (!transResult.isOk()) {
- LOG(ERROR) << "getName -- transaction failed.";
+ C2String getName() const override {
+ C2String outName = "(unknown)";
+ if (mAidlStore) {
+ ScopedAStatus transResult = mAidlConfigurable->getName(&outName);
+ if (!transResult.isOk()) {
+ LOG(ERROR) << "getName -- transaction failed.";
+ }
+ } else if (mHidlStore) {
+ Return<void> transResult = mHidlConfigurable->getName(
+ [&outName](const hidl_string& name) {
+ outName = name.c_str();
+ });
+ if (!transResult.isOk()) {
+ LOG(ERROR) << "getName -- transaction failed.";
+ }
}
return outName;
}
@@ -327,16 +583,62 @@
virtual std::shared_ptr<C2ParamReflector> getParamReflector() const
override {
struct SimpleParamReflector : public C2ParamReflector {
- virtual std::unique_ptr<C2StructDescriptor> describe(
+ std::unique_ptr<C2StructDescriptor> describe(
+ C2Param::CoreIndex coreIndex) const override {
+ if (mAidlBase) {
+ return describe_aidl(coreIndex);
+ } else if (mHidlBase) {
+ return describe_hidl(coreIndex);
+ } else {
+ return nullptr;
+ }
+ }
+
+ std::unique_ptr<C2StructDescriptor> describe_aidl(
C2Param::CoreIndex coreIndex) const {
- hidl_vec<ParamIndex> indices(1);
- indices[0] = static_cast<ParamIndex>(coreIndex.coreIndex());
+ std::vector<int32_t> indices(1);
+ indices[0] = coreIndex.coreIndex();
std::unique_ptr<C2StructDescriptor> descriptor;
- Return<void> transResult = mBase->getStructDescriptors(
+ std::vector<c2_aidl::StructDescriptor> aidlDescs;
+ ScopedAStatus transResult = mAidlBase->getStructDescriptors(
+ indices, &aidlDescs);
+ if (!transResult.isOk()) {
+ c2_status_t status = C2_TRANSACTION_FAILED;
+ if (transResult.getExceptionCode() == EX_SERVICE_SPECIFIC) {
+ status = c2_status_t(transResult.getServiceSpecificError());
+ LOG(DEBUG) << "SimpleParamReflector -- "
+ "getStructDescriptors() failed: "
+ << status << ".";
+ return nullptr;
+ }
+ }
+ if (aidlDescs.size() != 1) {
+ LOG(DEBUG) << "SimpleParamReflector -- "
+ "getStructDescriptors() "
+ "returned vector of size "
+ << aidlDescs.size() << ". "
+ "It should be 1.";
+ return nullptr;
+ }
+ if (!c2_aidl::utils::FromAidl(&descriptor, aidlDescs[0])) {
+ LOG(DEBUG) << "SimpleParamReflector -- "
+ "getStructDescriptors() returned "
+ "corrupted data.";
+ return nullptr;
+ }
+ return descriptor;
+ }
+
+ std::unique_ptr<C2StructDescriptor> describe_hidl(
+ C2Param::CoreIndex coreIndex) const {
+ hidl_vec<c2_hidl::ParamIndex> indices(1);
+ indices[0] = static_cast<c2_hidl::ParamIndex>(coreIndex.coreIndex());
+ std::unique_ptr<C2StructDescriptor> descriptor;
+ Return<void> transResult = mHidlBase->getStructDescriptors(
indices,
[&descriptor](
- Status s,
- const hidl_vec<StructDescriptor>& sd) {
+ c2_hidl::Status s,
+ const hidl_vec<c2_hidl::StructDescriptor>& sd) {
c2_status_t status = static_cast<c2_status_t>(s);
if (status != C2_OK) {
LOG(DEBUG) << "SimpleParamReflector -- "
@@ -354,7 +656,7 @@
descriptor.reset();
return;
}
- if (!objcpy(&descriptor, sd[0])) {
+ if (!c2_hidl::utils::objcpy(&descriptor, sd[0])) {
LOG(DEBUG) << "SimpleParamReflector -- "
"getStructDescriptors() returned "
"corrupted data.";
@@ -365,13 +667,23 @@
return descriptor;
}
- explicit SimpleParamReflector(sp<IComponentStore> base)
- : mBase(base) { }
+ explicit SimpleParamReflector(const sp<HidlComponentStore> &base)
+ : mHidlBase(base) { }
- sp<IComponentStore> mBase;
+ explicit SimpleParamReflector(const std::shared_ptr<AidlComponentStore> &base)
+ : mAidlBase(base) { }
+
+ std::shared_ptr<AidlComponentStore> mAidlBase;
+ sp<HidlComponentStore> mHidlBase;
};
- return std::make_shared<SimpleParamReflector>(mStore);
+ if (mAidlStore) {
+ return std::make_shared<SimpleParamReflector>(mAidlStore);
+ } else if (mHidlStore) {
+ return std::make_shared<SimpleParamReflector>(mHidlStore);
+ } else {
+ return nullptr;
+ }
}
virtual std::vector<std::shared_ptr<const C2Component::Traits>>
@@ -406,6 +718,15 @@
} // unnamed namespace
extern "C" void RegisterCodecServices() {
+ const bool aidlSelected = c2_aidl::utils::IsSelected();
+ constexpr int kThreadCount = 64;
+ if (aidlSelected) {
+ ABinderProcess_setThreadPoolMaxThreadCount(kThreadCount);
+ ABinderProcess_startThreadPool();
+ } else {
+ ::android::hardware::configureRpcThreadpool(kThreadCount, false);
+ }
+
LOG(INFO) << "Creating software Codec2 service...";
std::shared_ptr<C2ComponentStore> store =
android::GetCodec2PlatformComponentStore();
@@ -418,7 +739,18 @@
int platformVersion = android_get_device_api_level();
- if (platformVersion >= __ANDROID_API_S__) {
+ std::shared_ptr<c2_aidl::IComponentStore> aidlStore;
+ if (aidlSelected) {
+ aidlStore = ::ndk::SharedRefBase::make<c2_aidl::utils::ComponentStore>(store);
+ const std::string serviceName =
+ std::string(c2_aidl::IComponentStore::descriptor) + "/software";
+ binder_exception_t ex = AServiceManager_addService(
+ aidlStore->asBinder().get(), serviceName.c_str());
+ if (ex != EX_NONE) {
+ LOG(ERROR) << "Cannot register software Codec2 AIDL service.";
+ return;
+ }
+ } else if (platformVersion >= __ANDROID_API_S__) {
android::sp<V1_2::IComponentStore> storeV1_2 =
new V1_2::utils::ComponentStore(store);
if (storeV1_2->registerAsService("software") != android::OK) {
@@ -448,19 +780,47 @@
using IComponentStore =
::android::hardware::media::c2::V1_0::IComponentStore;
std::string const preferredStoreName = "default";
- sp<IComponentStore> preferredStore =
- IComponentStore::getService(preferredStoreName.c_str());
- if (preferredStore) {
- ::android::SetPreferredCodec2ComponentStore(
- std::make_shared<H2C2ComponentStore>(preferredStore));
- LOG(INFO) <<
- "Preferred Codec2 store is set to \"" <<
- preferredStoreName << "\".";
+ if (aidlSelected) {
+ std::shared_ptr<c2_aidl::IComponentStore> preferredStore;
+ if (__builtin_available(android __ANDROID_API_S__, *)) {
+ std::string instanceName = ::android::base::StringPrintf(
+ "%s/%s", c2_aidl::IComponentStore::descriptor, preferredStoreName.c_str());
+ if (AServiceManager_isDeclared(instanceName.c_str())) {
+ preferredStore = c2_aidl::IComponentStore::fromBinder(::ndk::SpAIBinder(
+ AServiceManager_waitForService(instanceName.c_str())));
+ }
+ }
+ if (preferredStore) {
+ ::android::SetPreferredCodec2ComponentStore(
+ std::make_shared<H2C2ComponentStore>(preferredStore));
+ LOG(INFO) <<
+ "Preferred Codec2 AIDL store is set to \"" <<
+ preferredStoreName << "\".";
+ } else {
+ LOG(INFO) <<
+ "Preferred Codec2 AIDL store is defaulted to \"software\".";
+ }
} else {
- LOG(INFO) <<
- "Preferred Codec2 store is defaulted to \"software\".";
+ sp<IComponentStore> preferredStore =
+ IComponentStore::getService(preferredStoreName.c_str());
+ if (preferredStore) {
+ ::android::SetPreferredCodec2ComponentStore(
+ std::make_shared<H2C2ComponentStore>(preferredStore));
+ LOG(INFO) <<
+ "Preferred Codec2 HIDL store is set to \"" <<
+ preferredStoreName << "\".";
+ } else {
+ LOG(INFO) <<
+ "Preferred Codec2 HIDL store is defaulted to \"software\".";
+ }
}
}
LOG(INFO) << "Software Codec2 service created and registered.";
+
+ if (aidlSelected) {
+ ABinderProcess_joinThreadPool();
+ } else {
+ ::android::hardware::joinRpcThreadpool();
+ }
}
diff --git a/media/module/codecserviceregistrant/fuzzer/Android.bp b/media/module/codecserviceregistrant/fuzzer/Android.bp
index 1cb8c2b..f4e8751 100644
--- a/media/module/codecserviceregistrant/fuzzer/Android.bp
+++ b/media/module/codecserviceregistrant/fuzzer/Android.bp
@@ -34,6 +34,7 @@
"libmedia_headers",
],
defaults: [
+ "libcodec2-aidl-defaults",
"libcodec2-hidl-defaults",
],
fuzz_config: {
diff --git a/media/module/codecserviceregistrant/fuzzer/codecServiceRegistrant_fuzzer.cpp b/media/module/codecserviceregistrant/fuzzer/codecServiceRegistrant_fuzzer.cpp
index fba4230..4868e0c 100644
--- a/media/module/codecserviceregistrant/fuzzer/codecServiceRegistrant_fuzzer.cpp
+++ b/media/module/codecserviceregistrant/fuzzer/codecServiceRegistrant_fuzzer.cpp
@@ -86,8 +86,8 @@
}
string const preferredStoreName = string(kServiceName);
- sp<IComponentStore> preferredStore =
- IComponentStore::getService(preferredStoreName.c_str());
+ sp<V1_0::IComponentStore> preferredStore =
+ V1_0::IComponentStore::getService(preferredStoreName.c_str());
mH2C2 = new H2C2ComponentStore(preferredStore);
}
diff --git a/services/mediacodec/main_swcodecservice.cpp b/services/mediacodec/main_swcodecservice.cpp
index d91b788..9aa5d3d 100644
--- a/services/mediacodec/main_swcodecservice.cpp
+++ b/services/mediacodec/main_swcodecservice.cpp
@@ -40,9 +40,5 @@
SetUpMinijail(kSystemSeccompPolicyPath, kVendorSeccompPolicyPath);
strcpy(argv[0], "media.swcodec");
- ::android::hardware::configureRpcThreadpool(64, false);
-
RegisterCodecServices();
-
- ::android::hardware::joinRpcThreadpool();
}