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

Commit ad964434 authored by Brian Lindahl's avatar Brian Lindahl
Browse files

Revert "Add image codec support to MediaCodec" 

This reverts commit a88d90cc.

Reason for revert: This revert fixes a test failure on barbet
identified in b/217948676.

Fixes: 217948676
Change-Id: I4992ca569fa86ffa98cf871dc7e72f7a9503a3a4
parent a88d90cc

media/libmedia/MediaResource.cpp

+2 −2
Original line number Diff line number Diff line
@@ -43,10 +43,10 @@ MediaResource::MediaResource(Type type, const std::vector<uint8_t> &id, int64_t 
}



//static

MediaResource MediaResource::CodecResource(bool secure, SubType subType, int64_t instanceCount) {

MediaResource MediaResource::CodecResource(bool secure, bool video, int64_t instanceCount) {

    return MediaResource(

            secure ? Type::kSecureCodec : Type::kNonSecureCodec,

            subType,

            video ? SubType::kVideoCodec : SubType::kAudioCodec,

            instanceCount);

}

media/libmedia/include/media/MediaResource.h

+1 −2
Original line number Diff line number Diff line
@@ -37,8 +37,7 @@ public: 
    MediaResource(Type type, SubType subType, int64_t value);

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



    static MediaResource CodecResource(bool secure, MediaResourceSubType subType,

            int64_t instanceCount = 1);

    static MediaResource CodecResource(bool secure, bool video, int64_t instanceCount = 1);

    static MediaResource GraphicMemoryResource(int64_t value);

    static MediaResource CpuBoostResource();

    static MediaResource VideoBatteryResource();

media/libstagefright/MediaCodec.cpp

+42 −71
Original line number Diff line number Diff line
@@ -102,8 +102,6 @@ static const char *kCodecMime = "android.media.mediacodec.mime"; /* e.g. audi 
static const char *kCodecMode = "android.media.mediacodec.mode";    /* audio, video */

static const char *kCodecModeVideo = "video";            /* values returned for kCodecMode */

static const char *kCodecModeAudio = "audio";

static const char *kCodecModeImage = "image";

static const char *kCodecModeUnknown = "unknown";

static const char *kCodecEncoder = "android.media.mediacodec.encoder"; /* 0,1 */

static const char *kCodecSecure = "android.media.mediacodec.secure";   /* 0, 1 */

static const char *kCodecWidth = "android.media.mediacodec.width";     /* 0..n */
@@ -651,24 +649,6 @@ void CodecCallback::onFirstTunnelFrameReady() { 
    notify->post();

}



static MediaResourceSubType toMediaResourceSubType(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;

    }

}



static const char * toCodecMode(MediaCodec::Domain domain) {

    switch (domain) {

        case MediaCodec::DOMAIN_VIDEO: return kCodecModeVideo;

        case MediaCodec::DOMAIN_AUDIO: return kCodecModeAudio;

        case MediaCodec::DOMAIN_IMAGE: return kCodecModeImage;

        default:                       return kCodecModeUnknown;

    }

}



}  // namespace



////////////////////////////////////////////////////////////////////////////////
@@ -764,9 +744,9 @@ MediaCodec::MediaCodec( 
      mFlags(0),

      mStickyError(OK),

      mSoftRenderer(NULL),

      mDomain(DOMAIN_UNKNOWN),

      mWidth(0),

      mHeight(0),

      mIsVideo(false),

      mVideoWidth(0),

      mVideoHeight(0),

      mRotationDegrees(0),

      mDequeueInputTimeoutGeneration(0),

      mDequeueInputReplyID(0),
@@ -1175,7 +1155,7 @@ void MediaCodec::statsBufferSent(int64_t presentationUs, const sp<MediaCodecBuff 
        });

    }



    if (mDomain == DOMAIN_VIDEO && (mFlags & kFlagIsEncoder)) {

    if (mIsVideo && (mFlags & kFlagIsEncoder)) {

        mBytesInput += buffer->size();

        mFramesInput++;

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


    CHECK_NE(mState, UNINITIALIZED);



    if (mDomain == DOMAIN_VIDEO && (mFlags & kFlagIsEncoder)) {

    if (mIsVideo && (mFlags & kFlagIsEncoder)) {

        int32_t flags = 0;

        (void) buffer->meta()->findInt32("flags", &flags);
@@ -1412,13 +1392,7 @@ status_t MediaCodec::init(const AString &name) { 
        mCodecInfo->getSupportedMediaTypes(&mediaTypes);

        for (size_t i = 0; i < mediaTypes.size(); ++i) {

            if (mediaTypes[i].startsWith("video/")) {

                mDomain = DOMAIN_VIDEO;

                break;

            } else if (mediaTypes[i].startsWith("audio/")) {

                mDomain = DOMAIN_AUDIO;

                break;

            } else if (mediaTypes[i].startsWith("image/")) {

                mDomain = DOMAIN_IMAGE;

                mIsVideo = true;

                break;

            }

        }
@@ -1431,7 +1405,7 @@ status_t MediaCodec::init(const AString &name) { 
        return NAME_NOT_FOUND;

    }



    if (mDomain == DOMAIN_VIDEO) {

    if (mIsVideo) {

        // video codec needs dedicated looper

        if (mCodecLooper == NULL) {

            mCodecLooper = new ALooper;
@@ -1464,16 +1438,17 @@ status_t MediaCodec::init(const AString &name) { 


    if (mMetricsHandle != 0) {

        mediametrics_setCString(mMetricsHandle, kCodecCodec, name.c_str());

        mediametrics_setCString(mMetricsHandle, kCodecMode, toCodecMode(mDomain));

        mediametrics_setCString(mMetricsHandle, kCodecMode,

                                mIsVideo ? kCodecModeVideo : kCodecModeAudio);

    }



    if (mDomain == DOMAIN_VIDEO) {

    if (mIsVideo) {

        mBatteryChecker = new BatteryChecker(new AMessage(kWhatCheckBatteryStats, this));

    }



    status_t err;

    std::vector<MediaResourceParcel> resources;

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

    resources.push_back(MediaResource::CodecResource(secureCodec, mIsVideo));

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

        if (i > 0) {

            // Don't try to reclaim resource for the first time.
@@ -1554,16 +1529,16 @@ status_t MediaCodec::configure( 
        mediametrics_setCString(mMetricsHandle, kCodecLogSessionId, mLogSessionId.c_str());

    }



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

        format->findInt32("width", &mWidth);

        format->findInt32("height", &mHeight);

    if (mIsVideo) {

        format->findInt32("width", &mVideoWidth);

        format->findInt32("height", &mVideoHeight);

        if (!format->findInt32("rotation-degrees", &mRotationDegrees)) {

            mRotationDegrees = 0;

        }



        if (mMetricsHandle != 0) {

            mediametrics_setInt32(mMetricsHandle, kCodecWidth, mWidth);

            mediametrics_setInt32(mMetricsHandle, kCodecHeight, mHeight);

            mediametrics_setInt32(mMetricsHandle, kCodecWidth, mVideoWidth);

            mediametrics_setInt32(mMetricsHandle, kCodecHeight, mVideoHeight);

            mediametrics_setInt32(mMetricsHandle, kCodecRotation, mRotationDegrees);

            int32_t maxWidth = 0;

            if (format->findInt32("max-width", &maxWidth)) {
@@ -1577,7 +1552,6 @@ status_t MediaCodec::configure( 
            if (format->findInt32("color-format", &colorFormat)) {

                mediametrics_setInt32(mMetricsHandle, kCodecColorFormat, colorFormat);

            }

            if (mDomain == DOMAIN_VIDEO) {

            float frameRate = -1.0;

            if (format->findFloat("frame-rate", &frameRate)) {

                mediametrics_setDouble(mMetricsHandle, kCodecFrameRate, frameRate);
@@ -1595,12 +1569,11 @@ status_t MediaCodec::configure( 
                mediametrics_setInt32(mMetricsHandle, kCodecPriority, priority);

            }

        }

        }



        // Prevent possible integer overflow in downstream code.

        if (mWidth < 0 || mHeight < 0 ||

               (uint64_t)mWidth * mHeight > (uint64_t)INT32_MAX / 4) {

            ALOGE("Invalid size(s), width=%d, height=%d", mWidth, mHeight);

        if (mVideoWidth < 0 || mVideoHeight < 0 ||

               (uint64_t)mVideoWidth * mVideoHeight > (uint64_t)INT32_MAX / 4) {

            ALOGE("Invalid size(s), width=%d, height=%d", mVideoWidth, mVideoHeight);

            return BAD_VALUE;

        }
@@ -1633,7 +1606,7 @@ status_t MediaCodec::configure( 
    }



    // push min/max QP to MediaMetrics after shaping

    if (mDomain == DOMAIN_VIDEO && mMetricsHandle != 0) {

    if (mIsVideo && mMetricsHandle != 0) {

        int32_t qpIMin = -1;

        if (format->findInt32("video-qp-i-min", &qpIMin)) {

            mediametrics_setInt32(mMetricsHandle, kCodecRequestedVideoQPIMin, qpIMin);
@@ -1686,8 +1659,7 @@ status_t MediaCodec::configure( 


    status_t err;

    std::vector<MediaResourceParcel> resources;

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

            toMediaResourceSubType(mDomain)));

    resources.push_back(MediaResource::CodecResource(mFlags & kFlagIsSecure, mIsVideo));

    // 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.

    resources.push_back(MediaResource::GraphicMemoryResource(1));
@@ -2268,7 +2240,7 @@ status_t MediaCodec::createInputSurface( 
}



uint64_t MediaCodec::getGraphicBufferSize() {

    if (mDomain != DOMAIN_VIDEO && mDomain != DOMAIN_IMAGE) {

    if (!mIsVideo) {

        return 0;

    }
@@ -2276,7 +2248,7 @@ uint64_t MediaCodec::getGraphicBufferSize() { 
    size_t portNum = sizeof(mPortBuffers) / sizeof((mPortBuffers)[0]);

    for (size_t i = 0; i < portNum; ++i) {

        // TODO: this is just an estimation, we should get the real buffer size from ACodec.

        size += mPortBuffers[i].size() * mWidth * mHeight * 3 / 2;

        size += mPortBuffers[i].size() * mVideoWidth * mVideoHeight * 3 / 2;

    }

    return size;

}
@@ -2288,8 +2260,7 @@ status_t MediaCodec::start() { 


    status_t err;

    std::vector<MediaResourceParcel> resources;

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

            toMediaResourceSubType(mDomain)));

    resources.push_back(MediaResource::CodecResource(mFlags & kFlagIsSecure, mIsVideo));

    // 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.

    resources.push_back(MediaResource::GraphicMemoryResource(1));
@@ -3221,8 +3192,8 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
                            : MediaCodecInfo::Attributes(0);

                    if (!(attr & MediaCodecInfo::kFlagIsSoftwareOnly)) {

                        // software codec is currently ignored.

                        mResourceManagerProxy->addResource(MediaResource::CodecResource(

                            mFlags & kFlagIsSecure, toMediaResourceSubType(mDomain)));

                        mResourceManagerProxy->addResource(

                                MediaResource::CodecResource(mFlags & kFlagIsSecure, mIsVideo));

                    }



                    postPendingRepliesAndDeferredMessages("kWhatComponentAllocated");
@@ -3388,7 +3359,7 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
                    }



                    CHECK_EQ(mState, STARTING);

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

                    if (mIsVideo) {

                        mResourceManagerProxy->addResource(

                                MediaResource::GraphicMemoryResource(getGraphicBufferSize()));

                    }

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

+3 −10
Original line number Diff line number Diff line
@@ -70,13 +70,6 @@ using hardware::cas::native::V1_0::IDescrambler; 
using aidl::android::media::MediaResourceParcel;



struct MediaCodec : public AHandler {

    enum Domain {

        DOMAIN_UNKNOWN = 0,

        DOMAIN_VIDEO = 1,

        DOMAIN_AUDIO = 2,

        DOMAIN_IMAGE = 3

    };



    enum ConfigureFlags {

        CONFIGURE_FLAG_ENCODE           = 1,

        CONFIGURE_FLAG_USE_BLOCK_MODEL  = 2,
@@ -445,10 +438,10 @@ private: 


    sp<ResourceManagerServiceProxy> mResourceManagerProxy;



    Domain mDomain;

    bool mIsVideo;

    AString mLogSessionId;

    int32_t mWidth;

    int32_t mHeight;

    int32_t mVideoWidth;

    int32_t mVideoHeight;

    int32_t mRotationDegrees;

    int32_t mAllowFrameDroppingBySurface;

services/mediaresourcemanager/test/ResourceObserverService_test.cpp

+28 −48
Original line number Diff line number Diff line
@@ -116,26 +116,6 @@ private: 


const EventTracker::Event EventTracker::NoEvent;



static MediaResource createSecureVideoCodecResource(int amount = 1) {

    return MediaResource(MediaResource::Type::kSecureCodec,

        MediaResource::SubType::kVideoCodec, amount);

}



static MediaResource createNonSecureVideoCodecResource(int amount = 1) {

    return MediaResource(MediaResource::Type::kNonSecureCodec,

        MediaResource::SubType::kVideoCodec, amount);

}



static MediaResource createSecureAudioCodecResource(int amount = 1) {

    return MediaResource(MediaResource::Type::kSecureCodec,

        MediaResource::SubType::kAudioCodec, amount);

}



static MediaResource createNonSecureAudioCodecResource(int amount = 1) {

    return MediaResource(MediaResource::Type::kNonSecureCodec,

        MediaResource::SubType::kAudioCodec, amount);

}



// Operators for GTest macros.

bool operator==(const EventTracker::Event& lhs, const EventTracker::Event& rhs) {

    return lhs.type == rhs.type && lhs.uid == rhs.uid && lhs.pid == rhs.pid &&
@@ -253,30 +233,30 @@ TEST_F(ResourceObserverServiceTest, testAddResourceBasic) { 


    std::vector<MediaResourceParcel> resources;

    // Add secure video codec.

    resources = {createSecureVideoCodecResource()};

    resources = {MediaResource::CodecResource(1 /*secure*/, 1 /*video*/)};

    mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);

    EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));



    // Add non-secure video codec.

    resources = {createNonSecureVideoCodecResource()};

    resources = {MediaResource::CodecResource(0 /*secure*/, 1 /*video*/)};

    mService->addResource(kTestPid2, kTestUid2, getId(mTestClient2), mTestClient2, resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));

    EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));



    // Add secure & non-secure video codecs.

    resources = {createSecureVideoCodecResource(),

                 createNonSecureVideoCodecResource()};

    resources = {MediaResource::CodecResource(1 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(0 /*secure*/, 1 /*video*/)};

    mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables1));

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));

    EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables3));



    // Add additional audio codecs, should be ignored.

    resources.push_back(createSecureAudioCodecResource());

    resources.push_back(createNonSecureAudioCodecResource());

    resources.push_back(MediaResource::CodecResource(1 /*secure*/, 0 /*video*/));

    resources.push_back(MediaResource::CodecResource(0 /*secure*/, 0 /*video*/));

    mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables2));
@@ -296,9 +276,9 @@ TEST_F(ResourceObserverServiceTest, testAddResourceMultiple) { 


    // Add multiple secure & non-secure video codecs.

    // Multiple entries of the same type should be merged, count should be propagated correctly.

    resources = {createSecureVideoCodecResource(),

                 createSecureVideoCodecResource(),

                 createNonSecureVideoCodecResource(3)};

    resources = {MediaResource::CodecResource(1 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(1 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(0 /*secure*/, 1 /*video*/, 3 /*count*/)};

    observables1 = {{MediaObservableType::kVideoSecureCodec, 2}};

    observables2 = {{MediaObservableType::kVideoNonSecureCodec, 3}};

    observables3 = {{MediaObservableType::kVideoSecureCodec, 2},
@@ -320,7 +300,7 @@ TEST_F(ResourceObserverServiceTest, testRemoveResourceBasic) { 


    std::vector<MediaResourceParcel> resources;

    // Add secure video codec to client1.

    resources = {createSecureVideoCodecResource()};

    resources = {MediaResource::CodecResource(1 /*secure*/, 1 /*video*/)};

    mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid1, kTestPid1, observables1));

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
@@ -342,7 +322,7 @@ TEST_F(ResourceObserverServiceTest, testRemoveResourceBasic) { 
    EXPECT_EQ(mTestObserver3->pop(), EventTracker::NoEvent);



    // Add non-secure video codec to client2.

    resources = {createNonSecureVideoCodecResource()};

    resources = {MediaResource::CodecResource(0 /*secure*/, 1 /*video*/)};

    mService->addResource(kTestPid2, kTestUid2, getId(mTestClient2), mTestClient2, resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));
@@ -364,24 +344,24 @@ TEST_F(ResourceObserverServiceTest, testRemoveResourceBasic) { 
    EXPECT_EQ(mTestObserver3->pop(), EventTracker::NoEvent);



    // Add secure & non-secure video codecs, plus audio codecs (that's ignored).

    resources = {createSecureVideoCodecResource(),

                 createNonSecureVideoCodecResource(),

                 createSecureAudioCodecResource(),

                 createNonSecureAudioCodecResource()};

    resources = {MediaResource::CodecResource(1 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(0 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(1 /*secure*/, 0 /*video*/),

                 MediaResource::CodecResource(0 /*secure*/, 0 /*video*/)};

    mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables1));

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables2));

    EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables3));

    // Remove one audio codec, should have no event.

    resources = {createSecureAudioCodecResource()};

    resources = {MediaResource::CodecResource(1 /*secure*/, 0 /*video*/)};

    mService->removeResource(kTestPid2, getId(mTestClient3), resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::NoEvent);

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);

    EXPECT_EQ(mTestObserver3->pop(), EventTracker::NoEvent);

    // Remove the other audio codec and the secure video codec, only secure video codec

    // removal should be reported.

    resources = {createNonSecureAudioCodecResource(),

                 createSecureVideoCodecResource()};

    resources = {MediaResource::CodecResource(0 /*secure*/, 0 /*video*/),

                 MediaResource::CodecResource(1 /*secure*/, 1 /*video*/)};

    mService->removeResource(kTestPid2, getId(mTestClient3), resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::Idle(kTestUid2, kTestPid2, observables1));

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);
@@ -406,10 +386,10 @@ TEST_F(ResourceObserverServiceTest, testRemoveResourceMultiple) { 


    // Add multiple secure & non-secure video codecs, plus audio codecs (that's ignored).

    // (ResourceManager will merge these internally.)

    resources = {createSecureVideoCodecResource(),

                 createNonSecureVideoCodecResource(4),

                 createSecureAudioCodecResource(),

                 createNonSecureAudioCodecResource()};

    resources = {MediaResource::CodecResource(1 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(0 /*secure*/, 1 /*video*/, 4 /*count*/),

                 MediaResource::CodecResource(1 /*secure*/, 0 /*video*/),

                 MediaResource::CodecResource(0 /*secure*/, 0 /*video*/)};

    mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);

    observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};

    observables2 = {{MediaObservableType::kVideoNonSecureCodec, 4}};
@@ -420,10 +400,10 @@ TEST_F(ResourceObserverServiceTest, testRemoveResourceMultiple) { 
    EXPECT_EQ(mTestObserver3->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables3));

    // Remove one audio codec, 2 secure video codecs and 2 non-secure video codecs.

    // 1 secure video codec removal and 2 non-secure video codec removals should be reported.

    resources = {createNonSecureAudioCodecResource(),

                 createSecureVideoCodecResource(),

                 createSecureVideoCodecResource(),

                 createNonSecureVideoCodecResource(2)};

    resources = {MediaResource::CodecResource(0 /*secure*/, 0 /*video*/),

                 MediaResource::CodecResource(1 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(1 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(0 /*secure*/, 1 /*video*/, 2 /*count*/)};

    mService->removeResource(kTestPid2, getId(mTestClient3), resources);

    observables1 = {{MediaObservableType::kVideoSecureCodec, 1}};

    observables2 = {{MediaObservableType::kVideoNonSecureCodec, 2}};
@@ -463,8 +443,8 @@ TEST_F(ResourceObserverServiceTest, testEventFilters) { 
    std::vector<MediaResourceParcel> resources;



    // Add secure & non-secure video codecs.

    resources = {createSecureVideoCodecResource(),

                 createNonSecureVideoCodecResource()};

    resources = {MediaResource::CodecResource(1 /*secure*/, 1 /*video*/),

                 MediaResource::CodecResource(0 /*secure*/, 1 /*video*/)};

    mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources);

    EXPECT_EQ(mTestObserver1->pop(), EventTracker::Busy(kTestUid2, kTestPid2, observables1));

    EXPECT_EQ(mTestObserver2->pop(), EventTracker::NoEvent);