Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d9c1fa26 authored by Girish Shetty's avatar Girish Shetty Committed by Automerger Merge Worker
Browse files

Merge changes from topic "rm_refactor_stage2" into main am: 20d97e07 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/2788355



Change-Id: Ie93ee59b46a2cc377ac67034fa0350a55c0d2888
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents cd8bfe44 20d97e07

media/libmedia/MediaResource.cpp

+3 −2
Original line number Diff line number Diff line
@@ -61,8 +61,9 @@ MediaResource MediaResource::CpuBoostResource() { 
}



//static

MediaResource MediaResource::VideoBatteryResource() {

    return MediaResource(Type::kBattery, SubType::kVideoCodec, 1);

MediaResource MediaResource::VideoBatteryResource(bool isHardware) {

    SubType subType = isHardware ? SubType::kHwVideoCodec : SubType::kSwVideoCodec;

    return MediaResource(Type::kBattery, subType, 1);

}



//static

media/libmedia/include/media/MediaResource.h

+8 −5
Original line number Diff line number Diff line
@@ -41,7 +41,7 @@ public: 
            int64_t instanceCount = 1);

    static MediaResource GraphicMemoryResource(int64_t value);

    static MediaResource CpuBoostResource();

    static MediaResource VideoBatteryResource();

    static MediaResource VideoBatteryResource(bool isHardware = true);

    static MediaResource DrmSessionResource(const std::vector<uint8_t> &id, int64_t value);

};
@@ -61,9 +61,12 @@ inline static const char *asString(MediaResource::Type i, const char *def = "??" 
inline static const char *asString(MediaResource::SubType i, const char *def = "??") {

    switch (i) {

        case MediaResource::SubType::kUnspecifiedSubType: return "unspecified";

        case MediaResource::SubType::kAudioCodec:         return "audio-codec";

        case MediaResource::SubType::kVideoCodec:         return "video-codec";

        case MediaResource::SubType::kImageCodec:         return "image-codec";

        case MediaResource::SubType::kHwAudioCodec:       return "hw-audio-codec";

        case MediaResource::SubType::kSwAudioCodec:       return "sw-audio-codec";

        case MediaResource::SubType::kHwVideoCodec:       return "hw-video-codec";

        case MediaResource::SubType::kSwVideoCodec:       return "sw-video-codec";

        case MediaResource::SubType::kHwImageCodec:       return "hw-image-codec";

        case MediaResource::SubType::kSwImageCodec:       return "sw-image-codec";

        default:                                          return def;

    }

}

media/libstagefright/MediaCodec.cpp

+26 −16
Original line number Diff line number Diff line
@@ -1019,12 +1019,19 @@ void CodecCallback::onMetricsUpdated(const sp<AMessage> &updatedMetrics) { 
    notify->post();

}



static MediaResourceSubType toMediaResourceSubType(MediaCodec::Domain domain) {

static MediaResourceSubType toMediaResourceSubType(bool isHardware, MediaCodec::Domain domain) {

    switch (domain) {

        case MediaCodec::DOMAIN_VIDEO: return MediaResourceSubType::kVideoCodec;

        case MediaCodec::DOMAIN_AUDIO: return MediaResourceSubType::kAudioCodec;

        case MediaCodec::DOMAIN_IMAGE: return MediaResourceSubType::kImageCodec;

        default:                       return MediaResourceSubType::kUnspecifiedSubType;

    case MediaCodec::DOMAIN_VIDEO:

        return isHardware? MediaResourceSubType::kHwVideoCodec :

                           MediaResourceSubType::kSwVideoCodec;

    case MediaCodec::DOMAIN_AUDIO:

        return isHardware? MediaResourceSubType::kHwAudioCodec :

                           MediaResourceSubType::kSwAudioCodec;

    case MediaCodec::DOMAIN_IMAGE:

        return isHardware? MediaResourceSubType::kHwImageCodec :

                           MediaResourceSubType::kSwImageCodec;

    default:

        return MediaResourceSubType::kUnspecifiedSubType;

    }

}
@@ -1794,7 +1801,7 @@ void MediaCodec::statsBufferSent(int64_t presentationUs, const sp<MediaCodecBuff 


    if (mBatteryChecker != nullptr) {

        mBatteryChecker->onCodecActivity([this] () {

            mResourceManagerProxy->addResource(MediaResource::VideoBatteryResource());

            mResourceManagerProxy->addResource(MediaResource::VideoBatteryResource(mIsHardware));

        });

    }
@@ -1866,7 +1873,7 @@ void MediaCodec::statsBufferReceived(int64_t presentationUs, const sp<MediaCodec 


    if (mBatteryChecker != nullptr) {

        mBatteryChecker->onCodecActivity([this] () {

            mResourceManagerProxy->addResource(MediaResource::VideoBatteryResource());

            mResourceManagerProxy->addResource(MediaResource::VideoBatteryResource(mIsHardware));

        });

    }
@@ -2121,13 +2128,16 @@ status_t MediaCodec::init(const AString &name) { 
        mBatteryChecker = new BatteryChecker(new AMessage(kWhatCheckBatteryStats, this));

    }



    std::vector<MediaResourceParcel> resources;

    resources.push_back(MediaResource::CodecResource(secureCodec, toMediaResourceSubType(mDomain)));



    // If the ComponentName is not set yet, use the name passed by the user.

    if (mComponentName.empty()) {

        mIsHardware = !MediaCodecList::isSoftwareCodec(name);

        mResourceManagerProxy->setCodecName(name.c_str());

    }



    std::vector<MediaResourceParcel> resources;

    resources.push_back(MediaResource::CodecResource(secureCodec,

                                                     toMediaResourceSubType(mIsHardware, mDomain)));



    for (int i = 0; i <= kMaxRetry; ++i) {

        if (i > 0) {

            // Don't try to reclaim resource for the first time.
@@ -2371,7 +2381,7 @@ status_t MediaCodec::configure( 
    status_t err;

    std::vector<MediaResourceParcel> resources;

    resources.push_back(MediaResource::CodecResource(mFlags & kFlagIsSecure,

            toMediaResourceSubType(mDomain)));

            toMediaResourceSubType(mIsHardware, mDomain)));

    if (mDomain == DOMAIN_VIDEO || mDomain == DOMAIN_IMAGE) {

        // Don't know the buffer size at this point, but it's fine to use 1 because

        // the reclaimResource call doesn't consider the requester's buffer size for now.
@@ -2976,7 +2986,7 @@ status_t MediaCodec::start() { 
    status_t err;

    std::vector<MediaResourceParcel> resources;

    resources.push_back(MediaResource::CodecResource(mFlags & kFlagIsSecure,

            toMediaResourceSubType(mDomain)));

            toMediaResourceSubType(mIsHardware, mDomain)));

    if (mDomain == DOMAIN_VIDEO || mDomain == DOMAIN_IMAGE) {

        // Don't know the buffer size at this point, but it's fine to use 1 because

        // the reclaimResource call doesn't consider the requester's buffer size for now.
@@ -3732,9 +3742,8 @@ MediaCodec::DequeueOutputResult MediaCodec::handleDequeueOutputBuffer( 




inline void MediaCodec::initClientConfigParcel(ClientConfigParcel& clientConfig) {

    clientConfig.codecType = toMediaResourceSubType(mDomain);

    clientConfig.codecType = toMediaResourceSubType(mIsHardware, mDomain);

    clientConfig.isEncoder = mFlags & kFlagIsEncoder;

    clientConfig.isHardware = !MediaCodecList::isSoftwareCodec(mComponentName);

    clientConfig.width = mWidth;

    clientConfig.height = mHeight;

    clientConfig.timeStamp = systemTime(SYSTEM_TIME_MONOTONIC) / 1000LL;
@@ -3963,6 +3972,7 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
                    CHECK(msg->findString("componentName", &mComponentName));



                    if (mComponentName.c_str()) {

                        mIsHardware = !MediaCodecList::isSoftwareCodec(mComponentName);

                        mediametrics_setCString(mMetricsHandle, kCodecCodec,

                                                mComponentName.c_str());

                        // Update the codec name.
@@ -3990,7 +4000,7 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
                                          MediaCodecList::isSoftwareCodec(mComponentName) ? 0 : 1);



                    mResourceManagerProxy->addResource(MediaResource::CodecResource(

                            mFlags & kFlagIsSecure, toMediaResourceSubType(mDomain)));

                            mFlags & kFlagIsSecure, toMediaResourceSubType(mIsHardware, mDomain)));



                    postPendingRepliesAndDeferredMessages("kWhatComponentAllocated");

                    break;
@@ -5509,7 +5519,7 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
            if (mBatteryChecker != nullptr) {

                mBatteryChecker->onCheckBatteryTimer(msg, [this] () {

                    mResourceManagerProxy->removeResource(

                            MediaResource::VideoBatteryResource());

                            MediaResource::VideoBatteryResource(mIsHardware));

                });

            }

            break;

media/libstagefright/include/media/stagefright/MediaCodec.h

+1 −0
Original line number Diff line number Diff line
@@ -723,6 +723,7 @@ private: 


    // An unique ID for the codec - Used by the metrics.

    uint64_t mCodecId = 0;

    bool     mIsHardware = false;



    std::function<sp<CodecBase>(const AString &, const char *)> mGetCodecBase;

    std::function<status_t(const AString &, sp<MediaCodecInfo> *)> mGetCodecInfo;

services/mediaresourcemanager/ResourceManagerMetrics.cpp

+55 −63
Original line number Diff line number Diff line
@@ -46,9 +46,12 @@ using stats::media_metrics::\ 


inline const char* getCodecType(MediaResourceSubType codecType) {

    switch (codecType) {

        case MediaResourceSubType::kAudioCodec:         return "Audio";

        case MediaResourceSubType::kVideoCodec:         return "Video";

        case MediaResourceSubType::kImageCodec:         return "Image";

        case MediaResourceSubType::kHwAudioCodec:       return "Hw Audio";

        case MediaResourceSubType::kSwAudioCodec:       return "Sw Audio";

        case MediaResourceSubType::kHwVideoCodec:       return "Hw Video";

        case MediaResourceSubType::kSwVideoCodec:       return "Sw Video";

        case MediaResourceSubType::kHwImageCodec:       return "Hw Image";

        case MediaResourceSubType::kSwImageCodec:       return "Sw Image";

        case MediaResourceSubType::kUnspecifiedSubType:

        default:

                                                        return "Unspecified";
@@ -56,40 +59,30 @@ inline const char* getCodecType(MediaResourceSubType codecType) { 
    return "Unspecified";

}



static CodecBucket getCodecBucket(bool isHardware,

                                  bool isEncoder,

                                  MediaResourceSubType codecType) {

    if (isHardware) {

        switch (codecType) {

            case MediaResourceSubType::kAudioCodec:

                if (isEncoder) return HwAudioEncoder;

                return HwAudioDecoder;

            case MediaResourceSubType::kVideoCodec:

                if (isEncoder) return HwVideoEncoder;

                return HwVideoDecoder;

            case MediaResourceSubType::kImageCodec:

                if (isEncoder) return HwImageEncoder;

                return HwImageDecoder;

            case MediaResourceSubType::kUnspecifiedSubType:

            default:

                return CodecBucketUnspecified;

inline bool isHardwareCodec(MediaResourceSubType codecType) {

    return (codecType == MediaResourceSubType::kHwAudioCodec ||

            codecType == MediaResourceSubType::kHwVideoCodec ||

            codecType == MediaResourceSubType::kHwImageCodec);

}

    } else {



static CodecBucket getCodecBucket(bool isEncoder, MediaResourceSubType codecType) {

    switch (codecType) {

            case MediaResourceSubType::kAudioCodec:

                if (isEncoder) return SwAudioEncoder;

                return SwAudioDecoder;

            case MediaResourceSubType::kVideoCodec:

                if (isEncoder) return SwVideoEncoder;

                return SwVideoDecoder;

            case MediaResourceSubType::kImageCodec:

                if (isEncoder) return SwImageEncoder;

                return SwImageDecoder;

    case MediaResourceSubType::kHwAudioCodec:

        return isEncoder? HwAudioEncoder : HwAudioDecoder;

    case MediaResourceSubType::kSwAudioCodec:

        return isEncoder? SwAudioEncoder : SwAudioDecoder;

    case MediaResourceSubType::kHwVideoCodec:

        return isEncoder? HwVideoEncoder : HwVideoDecoder;

    case MediaResourceSubType::kSwVideoCodec:

        return isEncoder? SwVideoEncoder : SwVideoDecoder;

    case MediaResourceSubType::kHwImageCodec:

        return isEncoder? HwImageEncoder : HwImageDecoder;

    case MediaResourceSubType::kSwImageCodec:

        return isEncoder? SwImageEncoder : SwImageDecoder;

    case MediaResourceSubType::kUnspecifiedSubType:

    default:

        return CodecBucketUnspecified;

    }

    }



    return CodecBucketUnspecified;

}
@@ -179,8 +172,10 @@ void ResourceManagerMetrics::notifyClientConfigChanged(const ClientConfigParcel& 
    std::scoped_lock lock(mLock);

    ClientConfigMap::iterator entry = mClientConfigMap.find(clientConfig.clientInfo.id);

    if (entry != mClientConfigMap.end() &&

        (clientConfig.codecType == MediaResourceSubType::kVideoCodec ||

        clientConfig.codecType == MediaResourceSubType::kImageCodec)) {

        (clientConfig.codecType == MediaResourceSubType::kHwVideoCodec ||

         clientConfig.codecType == MediaResourceSubType::kSwVideoCodec ||

         clientConfig.codecType == MediaResourceSubType::kHwImageCodec ||

         clientConfig.codecType == MediaResourceSubType::kSwImageCodec)) {

        int pid = clientConfig.clientInfo.pid;

        // Update the pixel count for this process

        updatePixelCount(pid, clientConfig.width * (long)clientConfig.height,
@@ -201,13 +196,13 @@ void ResourceManagerMetrics::notifyClientStarted(const ClientConfigParcel& clien 
    mClientConfigMap[clientConfig.clientInfo.id] = clientConfig;



    // Update the concurrent codec count for this process.

    CodecBucket codecBucket = getCodecBucket(clientConfig.isHardware,

                                             clientConfig.isEncoder,

                                             clientConfig.codecType);

    CodecBucket codecBucket = getCodecBucket(clientConfig.isEncoder, clientConfig.codecType);

    increaseConcurrentCodecs(pid, codecBucket);



    if (clientConfig.codecType == MediaResourceSubType::kVideoCodec ||

        clientConfig.codecType == MediaResourceSubType::kImageCodec) {

    if (clientConfig.codecType == MediaResourceSubType::kHwVideoCodec ||

        clientConfig.codecType == MediaResourceSubType::kSwVideoCodec ||

        clientConfig.codecType == MediaResourceSubType::kHwImageCodec ||

        clientConfig.codecType == MediaResourceSubType::kSwImageCodec) {

        // Update the pixel count for this process

        increasePixelCount(pid, clientConfig.width * (long)clientConfig.height);

    }
@@ -236,7 +231,7 @@ void ResourceManagerMetrics::notifyClientStarted(const ClientConfigParcel& clien 
         clientConfig.clientInfo.name.c_str(),

         static_cast<int32_t>(clientConfig.codecType),

         clientConfig.isEncoder,

         clientConfig.isHardware,

         isHardwareCodec(clientConfig.codecType),

         clientConfig.width, clientConfig.height,

         systemConcurrentCodecs,

         appConcurrentCodecs,
@@ -249,7 +244,7 @@ void ResourceManagerMetrics::notifyClientStarted(const ClientConfigParcel& clien 


    ALOGV("%s: Pushed MEDIA_CODEC_STARTED atom: "

          "Process[pid(%d): uid(%d)] "

          "Codec: [%s: %ju] is %s %s %s "

          "Codec: [%s: %ju] is %s %s "

          "Timestamp: %jd "

          "Resolution: %d x %d "

          "ConcurrentCodec[%d]={System: %d App: %d} "
@@ -259,7 +254,6 @@ void ResourceManagerMetrics::notifyClientStarted(const ClientConfigParcel& clien 
          pid, clientConfig.clientInfo.uid,

          clientConfig.clientInfo.name.c_str(),

          clientConfig.id,

          clientConfig.isHardware? "hardware" : "software",

          getCodecType(clientConfig.codecType),

          clientConfig.isEncoder? "encoder" : "decoder",

          clientConfig.timeStamp,
@@ -273,13 +267,13 @@ void ResourceManagerMetrics::notifyClientStopped(const ClientConfigParcel& clien 
    std::scoped_lock lock(mLock);

    int pid = clientConfig.clientInfo.pid;

    // Update the concurrent codec count for this process.

    CodecBucket codecBucket = getCodecBucket(clientConfig.isHardware,

                                             clientConfig.isEncoder,

                                             clientConfig.codecType);

    CodecBucket codecBucket = getCodecBucket(clientConfig.isEncoder, clientConfig.codecType);

    decreaseConcurrentCodecs(pid, codecBucket);



    if (clientConfig.codecType == MediaResourceSubType::kVideoCodec ||

        clientConfig.codecType == MediaResourceSubType::kImageCodec) {

    if (clientConfig.codecType == MediaResourceSubType::kHwVideoCodec ||

        clientConfig.codecType == MediaResourceSubType::kSwVideoCodec ||

        clientConfig.codecType == MediaResourceSubType::kHwImageCodec ||

        clientConfig.codecType == MediaResourceSubType::kSwImageCodec) {

        // Update the pixel count for this process

        decreasePixelCount(pid, clientConfig.width * (long)clientConfig.height);

    }
@@ -319,7 +313,7 @@ void ResourceManagerMetrics::notifyClientStopped(const ClientConfigParcel& clien 
         clientConfig.clientInfo.name.c_str(),

         static_cast<int32_t>(clientConfig.codecType),

         clientConfig.isEncoder,

         clientConfig.isHardware,

         isHardwareCodec(clientConfig.codecType),

         clientConfig.width, clientConfig.height,

         systemConcurrentCodecs,

         appConcurrentCodecs,
@@ -327,7 +321,7 @@ void ResourceManagerMetrics::notifyClientStopped(const ClientConfigParcel& clien 
         usageTime);

    ALOGV("%s: Pushed MEDIA_CODEC_STOPPED atom: "

          "Process[pid(%d): uid(%d)] "

          "Codec: [%s: %ju] is %s %s %s "

          "Codec: [%s: %ju] is %s %s "

          "Timestamp: %jd Usage time: %jd "

          "Resolution: %d x %d "

          "ConcurrentCodec[%d]={System: %d App: %d} "
@@ -336,7 +330,6 @@ void ResourceManagerMetrics::notifyClientStopped(const ClientConfigParcel& clien 
          pid, clientConfig.clientInfo.uid,

          clientConfig.clientInfo.name.c_str(),

          clientConfig.id,

          clientConfig.isHardware? "hardware" : "software",

          getCodecType(clientConfig.codecType),

          clientConfig.isEncoder? "encoder" : "decoder",

          clientConfig.timeStamp, usageTime,
@@ -434,8 +427,8 @@ void ResourceManagerMetrics::pushConcurrentUsageReport(int32_t pid, uid_t uid) { 


void ResourceManagerMetrics::pushReclaimAtom(const ClientInfoParcel& clientInfo,

                                             const std::vector<int>& priorities,

                        const std::vector<std::shared_ptr<IResourceManagerClient>>& clients,

                        const PidUidVector& idList, bool reclaimed) {

                                             const std::vector<ClientInfo>& targetClients,

                                             bool reclaimed) {

    // Construct the metrics for codec reclaim as a pushed atom.

    // 1. Information about the requester.

    //  - UID and the priority (oom score)
@@ -460,7 +453,7 @@ void ResourceManagerMetrics::pushReclaimAtom(const ClientInfoParcel& clientInfo, 
    //    - UID and the Priority (oom score)

    int32_t reclaimStatus = MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED__RECLAIM_STATUS__RECLAIM_SUCCESS;

    if (!reclaimed) {

      if (clients.size() == 0) {

      if (targetClients.size() == 0) {

        // No clients to reclaim from

        reclaimStatus =

            MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED__RECLAIM_STATUS__RECLAIM_FAILED_NO_CLIENTS;
@@ -470,10 +463,9 @@ void ResourceManagerMetrics::pushReclaimAtom(const ClientInfoParcel& clientInfo, 
            MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED__RECLAIM_STATUS__RECLAIM_FAILED_RECLAIM_RESOURCES;

      }

    }

    int32_t noOfCodecsReclaimed = clients.size();

    int32_t noOfCodecsReclaimed = targetClients.size();

    int32_t targetIndex = 1;

    for (PidUidVector::const_reference id : idList) {

        int32_t targetUid = id.second;

    for (const ClientInfo& targetClient : targetClients) {

        int targetPriority = priorities[targetIndex];

        // Post the pushed atom

        int result = stats_write(
@@ -485,7 +477,7 @@ void ResourceManagerMetrics::pushReclaimAtom(const ClientInfoParcel& clientInfo, 
            reclaimStatus,

            noOfCodecsReclaimed,

            targetIndex,

            targetUid,

            targetClient.mUid,

            targetPriority);

        ALOGI("%s: Pushed MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED atom: "

              "Requester[pid(%d): uid(%d): priority(%d)] "
@@ -497,7 +489,7 @@ void ResourceManagerMetrics::pushReclaimAtom(const ClientInfoParcel& clientInfo, 
              __func__, callingPid, requesterUid, requesterPriority,

              clientName.c_str(), noOfConcurrentCodecs,

              reclaimStatus, noOfCodecsReclaimed,

              targetIndex, id.first, targetUid, targetPriority, result);

              targetIndex, targetClient.mPid, targetClient.mUid, targetPriority, result);

        targetIndex++;

    }

}