media/stagefright: add support for codec attributes in MediaCodecInfo
- Move away from int flags, and signal capabilities in info AMessage/Map
instead.
- Add more attributes (other than isEncoder).
- Parse aliases, attributes and performance points from XML
- Add plumbing for codec aliases and attributes
- Use proper 'mediaType' phrase for supported types.
Bug: 119631295
Bug: 112370870
Bug: 112374531
Change-Id: I41ea555ca26ab09be176fb96a3138043d960caa3
diff --git a/media/codec2/core/include/C2Component.h b/media/codec2/core/include/C2Component.h
index 8810725..ecf8d2e 100644
--- a/media/codec2/core/include/C2Component.h
+++ b/media/codec2/core/include/C2Component.h
@@ -409,12 +409,13 @@
kind_t kind; ///< component kind
rank_t rank; ///< component rank
C2String mediaType; ///< media type supported by the component
+ C2String owner; ///< name of the component store owning this component
/**
* name alias(es) for backward compatibility.
* \note Multiple components can have the same alias as long as their media-type differs.
*/
- std::vector<C2StringLiteral> aliases; ///< name aliases for backward compatibility
+ std::vector<C2String> aliases; ///< name aliases for backward compatibility
};
// METHODS AVAILABLE WHEN RUNNING
diff --git a/media/codec2/hidl/client/client.cpp b/media/codec2/hidl/client/client.cpp
index ff3e534..f5cc9ff 100644
--- a/media/codec2/hidl/client/client.cpp
+++ b/media/codec2/hidl/client/client.cpp
@@ -557,6 +557,7 @@
for (size_t i = 0; i < t.size(); ++i) {
c2_status_t status = objcpy(
&mTraitsList[i], &mAliasesBuffer[i], t[i]);
+ mTraitsList[i].owner = mInstanceName;
if (status != C2_OK) {
ALOGE("listComponents -- corrupted output.");
return;
diff --git a/media/codec2/sfplugin/Codec2InfoBuilder.cpp b/media/codec2/sfplugin/Codec2InfoBuilder.cpp
index 5d0ccd2..70ffa83 100644
--- a/media/codec2/sfplugin/Codec2InfoBuilder.cpp
+++ b/media/codec2/sfplugin/Codec2InfoBuilder.cpp
@@ -73,10 +73,10 @@
constexpr OMX_U32 kMaxIndicesToCheck = 32;
status_t queryOmxCapabilities(
- const char* name, const char* mime, bool isEncoder,
+ const char* name, const char* mediaType, bool isEncoder,
MediaCodecInfo::CapabilitiesWriter* caps) {
- const char *role = GetComponentRole(isEncoder, mime);
+ const char *role = GetComponentRole(isEncoder, mediaType);
if (role == nullptr) {
return BAD_VALUE;
}
@@ -128,8 +128,8 @@
return err;
}
- bool isVideo = hasPrefix(mime, "video/") == 0;
- bool isImage = hasPrefix(mime, "image/") == 0;
+ bool isVideo = hasPrefix(mediaType, "video/") == 0;
+ bool isImage = hasPrefix(mediaType, "image/") == 0;
if (isVideo || isImage) {
OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
@@ -149,7 +149,7 @@
// AVC components may not list the constrained profiles explicitly, but
// decoders that support a profile also support its constrained version.
// Encoders must explicitly support constrained profiles.
- if (!isEncoder && strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC) == 0) {
+ if (!isEncoder && strcasecmp(mediaType, MEDIA_MIMETYPE_VIDEO_AVC) == 0) {
if (param.eProfile == OMX_VIDEO_AVCProfileHigh) {
caps->addProfileLevel(OMX_VIDEO_AVCProfileConstrainedHigh, param.eLevel);
} else if (param.eProfile == OMX_VIDEO_AVCProfileBaseline) {
@@ -193,7 +193,7 @@
asString(portFormat.eColorFormat), portFormat.eColorFormat);
}
}
- } else if (strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC) == 0) {
+ } else if (strcasecmp(mediaType, MEDIA_MIMETYPE_AUDIO_AAC) == 0) {
// More audio codecs if they have profiles.
OMX_AUDIO_PARAM_ANDROID_PROFILETYPE param;
InitOMXParams(¶m);
@@ -228,14 +228,17 @@
if (omxNode->configureVideoTunnelMode(
kPortIndexOutput, OMX_TRUE, 0, &sidebandHandle) == OK) {
// tunneled playback includes adaptive playback
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsAdaptivePlayback
- | MediaCodecInfo::Capabilities::kFlagSupportsTunneledPlayback);
- } else if (omxNode->setPortMode(
- kPortIndexOutput, IOMX::kPortModeDynamicANWBuffer) == OK ||
- omxNode->prepareForAdaptivePlayback(
- kPortIndexOutput, OMX_TRUE,
- 1280 /* width */, 720 /* height */) == OK) {
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsAdaptivePlayback);
+ } else {
+ // tunneled playback is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_TUNNELED_PLAYBACK);
+ if (omxNode->setPortMode(
+ kPortIndexOutput, IOMX::kPortModeDynamicANWBuffer) == OK ||
+ omxNode->prepareForAdaptivePlayback(
+ kPortIndexOutput, OMX_TRUE,
+ 1280 /* width */, 720 /* height */) != OK) {
+ // adaptive playback is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_ADAPTIVE_PLAYBACK);
+ }
}
}
@@ -243,11 +246,20 @@
OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE params;
InitOMXParams(¶ms);
params.nPortIndex = kPortIndexOutput;
- // TODO: should we verify if fallback is supported?
+
+ OMX_VIDEO_PARAM_INTRAREFRESHTYPE fallbackParams;
+ InitOMXParams(&fallbackParams);
+ fallbackParams.nPortIndex = kPortIndexOutput;
+ fallbackParams.eRefreshMode = OMX_VIDEO_IntraRefreshCyclic;
+
if (omxNode->getConfig(
(OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh,
- ¶ms, sizeof(params)) == OK) {
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsIntraRefresh);
+ ¶ms, sizeof(params)) != OK &&
+ omxNode->getParameter(
+ OMX_IndexParamVideoIntraRefresh, &fallbackParams,
+ sizeof(fallbackParams)) != OK) {
+ // intra refresh is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_INTRA_REFRESH);
}
}
@@ -270,12 +282,26 @@
writer->addMediaCodecInfo();
info->setName(name.c_str());
info->setOwner("default");
- info->setEncoder(encoder);
+ typename std::underlying_type<MediaCodecInfo::Attributes>::type attrs = 0;
+ if (encoder) {
+ attrs |= MediaCodecInfo::kFlagIsEncoder;
+ }
+ // NOTE: we don't support software-only codecs in OMX
+ if (!hasPrefix(name, "OMX.google.")) {
+ attrs |= MediaCodecInfo::kFlagIsVendor;
+ if (properties.quirkSet.find("attribute::software-codec")
+ == properties.quirkSet.end()) {
+ attrs |= MediaCodecInfo::kFlagIsHardwareAccelerated;
+ }
+ }
+ info->setAttributes(attrs);
info->setRank(omxRank);
- for (const MediaCodecsXmlParser::Type& type : properties.typeMap) {
- const std::string &mime = type.first;
+ // OMX components don't have aliases
+ for (const MediaCodecsXmlParser::Type &type : properties.typeMap) {
+ const std::string &mediaType = type.first;
+
std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> caps =
- info->addMime(mime.c_str());
+ info->addMediaType(mediaType.c_str());
const MediaCodecsXmlParser::AttributeMap &attrMap = type.second;
for (const MediaCodecsXmlParser::Attribute& attr : attrMap) {
const std::string &key = attr.first;
@@ -289,13 +315,13 @@
}
status_t err = queryOmxCapabilities(
name.c_str(),
- mime.c_str(),
+ mediaType.c_str(),
encoder,
caps.get());
if (err != OK) {
- ALOGE("Failed to query capabilities for %s (mime: %s). Error: %d",
+ ALOGI("Failed to query capabilities for %s (media type: %s). Error: %d",
name.c_str(),
- mime.c_str(),
+ mediaType.c_str(),
static_cast<int>(err));
}
}
@@ -407,20 +433,40 @@
break;
}
+ ALOGV("canonName = %s", canonName.c_str());
std::unique_ptr<MediaCodecInfoWriter> codecInfo = writer->addMediaCodecInfo();
codecInfo->setName(trait.name.c_str());
- codecInfo->setOwner("codec2");
+ codecInfo->setOwner(("codec2::" + trait.owner).c_str());
+ const MediaCodecsXmlParser::CodecProperties &codec = parser.getCodecMap().at(canonName);
+
bool encoder = trait.kind == C2Component::KIND_ENCODER;
- codecInfo->setEncoder(encoder);
+ typename std::underlying_type<MediaCodecInfo::Attributes>::type attrs = 0;
+
+ if (encoder) {
+ attrs |= MediaCodecInfo::kFlagIsEncoder;
+ }
+ if (trait.owner == "software") {
+ attrs |= MediaCodecInfo::kFlagIsSoftwareOnly;
+ } else {
+ attrs |= MediaCodecInfo::kFlagIsVendor;
+ if (trait.owner == "vendor-software") {
+ attrs |= MediaCodecInfo::kFlagIsSoftwareOnly;
+ } else if (codec.quirkSet.find("attribute::software-codec") == codec.quirkSet.end()) {
+ attrs |= MediaCodecInfo::kFlagIsHardwareAccelerated;
+ }
+ }
+ codecInfo->setAttributes(attrs);
codecInfo->setRank(rank);
- const MediaCodecsXmlParser::CodecProperties &codec =
- parser.getCodecMap().at(canonName);
+
+ for (const std::string &alias : codec.aliases) {
+ codecInfo->addAlias(alias.c_str());
+ }
for (auto typeIt = codec.typeMap.begin(); typeIt != codec.typeMap.end(); ++typeIt) {
const std::string &mediaType = typeIt->first;
const MediaCodecsXmlParser::AttributeMap &attrMap = typeIt->second;
std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> caps =
- codecInfo->addMime(mediaType.c_str());
+ codecInfo->addMediaType(mediaType.c_str());
for (auto attrIt = attrMap.begin(); attrIt != attrMap.end(); ++attrIt) {
std::string key, value;
std::tie(key, value) = *attrIt;