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

Commit 6480d09e authored by Chong Zhang's avatar Chong Zhang Committed by Android (Google) Code Review
Browse files

Merge changes from topic 'heapbase' into oc-dev 

* changes:
  DRM: more fixes for heap base mapping -- DO NOT MERGE
  Revert "Revert "Fix decoder instantiation during playback"" -- DO NOT MERGE
parents be3d40ca 6dcab2ba

drm/libmediadrm/CryptoHal.cpp

+29 −17
Original line number Original line Diff line number Diff line
@@ -105,7 +105,8 @@ static String8 toString8(hidl_string hString) { 
CryptoHal::CryptoHal()

CryptoHal::CryptoHal()

    : mFactories(makeCryptoFactories()),

    : mFactories(makeCryptoFactories()),

      mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT),

      mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT),

      mNextBufferId(0) {

      mNextBufferId(0),

      mHeapSeqNum(0) {

}

}





CryptoHal::~CryptoHal() {

CryptoHal::~CryptoHal() {
@@ -225,26 +226,37 @@ bool CryptoHal::requiresSecureDecoderComponent(const char *mime) const { 
 * size.  Once the heap base is established, shared memory buffers

 * size.  Once the heap base is established, shared memory buffers

 * are sent by providing an offset into the heap and a buffer size.

 * are sent by providing an offset into the heap and a buffer size.

 */

 */

void CryptoHal::setHeapBase(const sp<IMemoryHeap>& heap) {

int32_t CryptoHal::setHeapBase(const sp<IMemoryHeap>& heap) {

    if (heap == NULL) {

        ALOGE("setHeapBase(): heap is NULL");

        return -1;

    }

    native_handle_t* nativeHandle = native_handle_create(1, 0);

    native_handle_t* nativeHandle = native_handle_create(1, 0);

    if (!nativeHandle) {

    if (!nativeHandle) {

        ALOGE("setSharedBufferBase(), failed to create native handle");

        ALOGE("setHeapBase(), failed to create native handle");

        return;

        return -1;

    }

    if (heap == NULL) {

        ALOGE("setSharedBufferBase(): heap is NULL");

        return;

    }

    }



    Mutex::Autolock autoLock(mLock);



    int32_t seqNum = mHeapSeqNum++;

    int fd = heap->getHeapID();

    int fd = heap->getHeapID();

    nativeHandle->data[0] = fd;

    nativeHandle->data[0] = fd;

    auto hidlHandle = hidl_handle(nativeHandle);

    auto hidlHandle = hidl_handle(nativeHandle);

    auto hidlMemory = hidl_memory("ashmem", hidlHandle, heap->getSize());

    auto hidlMemory = hidl_memory("ashmem", hidlHandle, heap->getSize());

    mHeapBases.add(heap->getBase(), mNextBufferId);

    mHeapBases.add(seqNum, mNextBufferId);

    Return<void> hResult = mPlugin->setSharedBufferBase(hidlMemory, mNextBufferId++);

    Return<void> hResult = mPlugin->setSharedBufferBase(hidlMemory, mNextBufferId++);

    ALOGE_IF(!hResult.isOk(), "setSharedBufferBase(): remote call failed");

    ALOGE_IF(!hResult.isOk(), "setSharedBufferBase(): remote call failed");

    return seqNum;

}

}





status_t CryptoHal::toSharedBuffer(const sp<IMemory>& memory, ::SharedBuffer* buffer) {

void CryptoHal::clearHeapBase(int32_t seqNum) {

    Mutex::Autolock autoLock(mLock);



    mHeapBases.removeItem(seqNum);

}



status_t CryptoHal::toSharedBuffer(const sp<IMemory>& memory, int32_t seqNum, ::SharedBuffer* buffer) {

    ssize_t offset;

    ssize_t offset;

    size_t size;

    size_t size;
@@ -257,11 +269,10 @@ status_t CryptoHal::toSharedBuffer(const sp<IMemory>& memory, ::SharedBuffer* bu 
        return UNEXPECTED_NULL;

        return UNEXPECTED_NULL;

    }

    }





    if (mHeapBases.indexOfKey(heap->getBase()) < 0) {

    // memory must be in the declared heap

        setHeapBase(heap);

    CHECK(mHeapBases.indexOfKey(seqNum) >= 0);

    }





    buffer->bufferId = mHeapBases.valueFor(heap->getBase());

    buffer->bufferId = mHeapBases.valueFor(seqNum);

    buffer->offset = offset >= 0 ? offset : 0;

    buffer->offset = offset >= 0 ? offset : 0;

    buffer->size = size;

    buffer->size = size;

    return OK;

    return OK;
@@ -269,7 +280,7 @@ status_t CryptoHal::toSharedBuffer(const sp<IMemory>& memory, ::SharedBuffer* bu 




ssize_t CryptoHal::decrypt(const uint8_t keyId[16], const uint8_t iv[16],

ssize_t CryptoHal::decrypt(const uint8_t keyId[16], const uint8_t iv[16],

        CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

        CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

        const sp<IMemory> &source, size_t offset,

        const ICrypto::SourceBuffer &source, size_t offset,

        const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

        const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

        const ICrypto::DestinationBuffer &destination, AString *errorDetailMsg) {

        const ICrypto::DestinationBuffer &destination, AString *errorDetailMsg) {

    Mutex::Autolock autoLock(mLock);

    Mutex::Autolock autoLock(mLock);
@@ -309,11 +320,12 @@ ssize_t CryptoHal::decrypt(const uint8_t keyId[16], const uint8_t iv[16], 
    }

    }

    auto hSubSamples = hidl_vec<SubSample>(stdSubSamples);

    auto hSubSamples = hidl_vec<SubSample>(stdSubSamples);





    int32_t heapSeqNum = source.mHeapSeqNum;

    bool secure;

    bool secure;

    ::DestinationBuffer hDestination;

    ::DestinationBuffer hDestination;

    if (destination.mType == kDestinationTypeSharedMemory) {

    if (destination.mType == kDestinationTypeSharedMemory) {

        hDestination.type = BufferType::SHARED_MEMORY;

        hDestination.type = BufferType::SHARED_MEMORY;

        status_t status = toSharedBuffer(destination.mSharedMemory,

        status_t status = toSharedBuffer(destination.mSharedMemory, heapSeqNum,

                &hDestination.nonsecureMemory);

                &hDestination.nonsecureMemory);

        if (status != OK) {

        if (status != OK) {

            return status;

            return status;
@@ -326,7 +338,7 @@ ssize_t CryptoHal::decrypt(const uint8_t keyId[16], const uint8_t iv[16], 
    }

    }





    ::SharedBuffer hSource;

    ::SharedBuffer hSource;

    status_t status = toSharedBuffer(source, &hSource);

    status_t status = toSharedBuffer(source.mSharedMemory, heapSeqNum, &hSource);

    if (status != OK) {

    if (status != OK) {

        return status;

        return status;

    }

    }

drm/libmediadrm/ICrypto.cpp

+55 −6
Original line number Original line Diff line number Diff line
@@ -36,6 +36,8 @@ enum { 
    DECRYPT,

    DECRYPT,

    NOTIFY_RESOLUTION,

    NOTIFY_RESOLUTION,

    SET_MEDIADRM_SESSION,

    SET_MEDIADRM_SESSION,

    SET_HEAP,

    UNSET_HEAP,

};

};





struct BpCrypto : public BpInterface<ICrypto> {

struct BpCrypto : public BpInterface<ICrypto> {
@@ -96,7 +98,7 @@ struct BpCrypto : public BpInterface<ICrypto> { 




    virtual ssize_t decrypt(const uint8_t key[16], const uint8_t iv[16],

    virtual ssize_t decrypt(const uint8_t key[16], const uint8_t iv[16],

            CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

            CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

            const sp<IMemory> &source, size_t offset,

            const SourceBuffer &source, size_t offset,

            const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

            const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

            const DestinationBuffer &destination, AString *errorDetailMsg) {

            const DestinationBuffer &destination, AString *errorDetailMsg) {

        Parcel data, reply;

        Parcel data, reply;
@@ -125,7 +127,8 @@ struct BpCrypto : public BpInterface<ICrypto> { 
        }

        }





        data.writeInt32(totalSize);

        data.writeInt32(totalSize);

        data.writeStrongBinder(IInterface::asBinder(source));

        data.writeStrongBinder(IInterface::asBinder(source.mSharedMemory));

        data.writeInt32(source.mHeapSeqNum);

        data.writeInt32(offset);

        data.writeInt32(offset);





        data.writeInt32(numSubSamples);

        data.writeInt32(numSubSamples);
@@ -177,6 +180,30 @@ struct BpCrypto : public BpInterface<ICrypto> { 
        return reply.readInt32();

        return reply.readInt32();

    }

    }





    virtual int32_t setHeap(const sp<IMemoryHeap> &heap) {

        Parcel data, reply;

        data.writeInterfaceToken(ICrypto::getInterfaceDescriptor());

        data.writeStrongBinder(IInterface::asBinder(heap));

        status_t err = remote()->transact(SET_HEAP, data, &reply);

        if (err != NO_ERROR) {

            return -1;

        }

        int32_t seqNum;

        if (reply.readInt32(&seqNum) != NO_ERROR) {

            return -1;

        }

        return seqNum;

    }



    virtual void unsetHeap(int32_t seqNum) {

        Parcel data, reply;

        data.writeInterfaceToken(ICrypto::getInterfaceDescriptor());

        data.writeInt32(seqNum);

        remote()->transact(UNSET_HEAP, data, &reply);

        return;

    }





private:

private:

    void readVector(Parcel &reply, Vector<uint8_t> &vector) const {

    void readVector(Parcel &reply, Vector<uint8_t> &vector) const {

        uint32_t size = reply.readInt32();

        uint32_t size = reply.readInt32();
@@ -295,12 +322,17 @@ status_t BnCrypto::onTransact( 
            data.read(iv, sizeof(iv));

            data.read(iv, sizeof(iv));





            size_t totalSize = data.readInt32();

            size_t totalSize = data.readInt32();

            sp<IMemory> source =



            SourceBuffer source;



            source.mSharedMemory =

                interface_cast<IMemory>(data.readStrongBinder());

                interface_cast<IMemory>(data.readStrongBinder());

            if (source == NULL) {

            if (source.mSharedMemory == NULL) {

                reply->writeInt32(BAD_VALUE);

                reply->writeInt32(BAD_VALUE);

                return OK;

                return OK;

            }

            }

            source.mHeapSeqNum = data.readInt32();



            int32_t offset = data.readInt32();

            int32_t offset = data.readInt32();





            int32_t numSubSamples = data.readInt32();

            int32_t numSubSamples = data.readInt32();
@@ -353,9 +385,9 @@ status_t BnCrypto::onTransact( 




            if (overflow || sumSubsampleSizes != totalSize) {

            if (overflow || sumSubsampleSizes != totalSize) {

                result = -EINVAL;

                result = -EINVAL;

            } else if (totalSize > source->size()) {

            } else if (totalSize > source.mSharedMemory->size()) {

                result = -EINVAL;

                result = -EINVAL;

            } else if ((size_t)offset > source->size() - totalSize) {

            } else if ((size_t)offset > source.mSharedMemory->size() - totalSize) {

                result = -EINVAL;

                result = -EINVAL;

            } else {

            } else {

                result = decrypt(key, iv, mode, pattern, source, offset,

                result = decrypt(key, iv, mode, pattern, source, offset,
@@ -404,6 +436,23 @@ status_t BnCrypto::onTransact( 
            return OK;

            return OK;

        }

        }





        case SET_HEAP:

        {

            CHECK_INTERFACE(ICrypto, data, reply);

            sp<IMemoryHeap> heap =

                interface_cast<IMemoryHeap>(data.readStrongBinder());

            reply->writeInt32(setHeap(heap));

            return OK;

        }



        case UNSET_HEAP:

        {

            CHECK_INTERFACE(ICrypto, data, reply);

            int32_t seqNum = data.readInt32();

            unsetHeap(seqNum);

            return OK;

        }



        default:

        default:

            return BBinder::onTransact(code, data, reply, flags);

            return BBinder::onTransact(code, data, reply, flags);

    }

    }

media/libmedia/include/Crypto.h

+3 −0
Original line number Original line Diff line number Diff line
@@ -55,6 +55,9 @@ struct Crypto : public BnCrypto { 
            const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

            const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

            const DestinationBuffer &destination, AString *errorDetailMsg);

            const DestinationBuffer &destination, AString *errorDetailMsg);





    virtual void setHeap(const sp<IMemoryHeap>&) {}

    virtual void unsetHeap(const sp<IMemoryHeap>&) {}



private:

private:

    mutable Mutex mLock;

    mutable Mutex mLock;

media/libmedia/include/CryptoHal.h

+11 −4
Original line number Original line Diff line number Diff line
@@ -55,11 +55,16 @@ struct CryptoHal : public BnCrypto { 




    virtual ssize_t decrypt(const uint8_t key[16], const uint8_t iv[16],

    virtual ssize_t decrypt(const uint8_t key[16], const uint8_t iv[16],

            CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

            CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

            const sp<IMemory> &source, size_t offset,

            const ICrypto::SourceBuffer &source, size_t offset,

            const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

            const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

            const ICrypto::DestinationBuffer &destination,

            const ICrypto::DestinationBuffer &destination,

            AString *errorDetailMsg);

            AString *errorDetailMsg);





    virtual int32_t setHeap(const sp<IMemoryHeap>& heap) {

        return setHeapBase(heap);

    }

    virtual void unsetHeap(int32_t seqNum) { clearHeapBase(seqNum); }



private:

private:

    mutable Mutex mLock;

    mutable Mutex mLock;
@@ -74,16 +79,18 @@ private: 
     */

     */

    status_t mInitCheck;

    status_t mInitCheck;





    KeyedVector<void *, uint32_t> mHeapBases;

    KeyedVector<int32_t, uint32_t> mHeapBases;

    uint32_t mNextBufferId;

    uint32_t mNextBufferId;

    int32_t mHeapSeqNum;





    Vector<sp<ICryptoFactory>> makeCryptoFactories();

    Vector<sp<ICryptoFactory>> makeCryptoFactories();

    sp<ICryptoPlugin> makeCryptoPlugin(const sp<ICryptoFactory>& factory,

    sp<ICryptoPlugin> makeCryptoPlugin(const sp<ICryptoFactory>& factory,

            const uint8_t uuid[16], const void *initData, size_t size);

            const uint8_t uuid[16], const void *initData, size_t size);





    void setHeapBase(const sp<IMemoryHeap>& heap);

    int32_t setHeapBase(const sp<IMemoryHeap>& heap);

    void clearHeapBase(int32_t seqNum);





    status_t toSharedBuffer(const sp<IMemory>& memory, ::SharedBuffer* buffer);

    status_t toSharedBuffer(const sp<IMemory>& memory, int32_t seqNum, ::SharedBuffer* buffer);





    DISALLOW_EVIL_CONSTRUCTORS(CryptoHal);

    DISALLOW_EVIL_CONSTRUCTORS(CryptoHal);

};

};

media/libmedia/include/ICrypto.h

+16 −1
Original line number Original line Diff line number Diff line
@@ -27,6 +27,7 @@ namespace android { 




struct AString;

struct AString;

class IMemory;

class IMemory;

class IMemoryHeap;





struct ICrypto : public IInterface {

struct ICrypto : public IInterface {

    DECLARE_META_INTERFACE(Crypto);

    DECLARE_META_INTERFACE(Crypto);
@@ -47,6 +48,11 @@ struct ICrypto : public IInterface { 




    virtual status_t setMediaDrmSession(const Vector<uint8_t> &sessionId) = 0;

    virtual status_t setMediaDrmSession(const Vector<uint8_t> &sessionId) = 0;





    struct SourceBuffer {

        sp<IMemory> mSharedMemory;

        int32_t mHeapSeqNum;

    };



    enum DestinationType {

    enum DestinationType {

        kDestinationTypeSharedMemory, // non-secure

        kDestinationTypeSharedMemory, // non-secure

        kDestinationTypeNativeHandle  // secure

        kDestinationTypeNativeHandle  // secure
@@ -60,10 +66,19 @@ struct ICrypto : public IInterface { 




    virtual ssize_t decrypt(const uint8_t key[16], const uint8_t iv[16],

    virtual ssize_t decrypt(const uint8_t key[16], const uint8_t iv[16],

            CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

            CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

            const sp<IMemory> &source, size_t offset,

            const SourceBuffer &source, size_t offset,

            const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

            const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

            const DestinationBuffer &destination, AString *errorDetailMsg) = 0;

            const DestinationBuffer &destination, AString *errorDetailMsg) = 0;





    /**

     * Declare the heap that the shared memory source buffers passed

     * to decrypt will be allocated from. Returns a sequence number

     * that subsequent decrypt calls can use to refer to the heap,

     * with -1 indicating failure.

     */

    virtual int32_t setHeap(const sp<IMemoryHeap>& heap) = 0;

    virtual void unsetHeap(int32_t seqNum) = 0;



private:

private:

    DISALLOW_EVIL_CONSTRUCTORS(ICrypto);

    DISALLOW_EVIL_CONSTRUCTORS(ICrypto);

};

};