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

Commit 4453f452 authored by Marco Nelissen's avatar Marco Nelissen
Browse files

Remove DRMExtractor 

It was not used, untested and untestable.

Bug: 33354165
Test: ran forward lock and media playback CTS tests, manual playback.
Change-Id: I4dd3f07ca5b019a5fed0c860aa573fc993464712
parent 67d0d7eb

include/media/stagefright/MediaExtractor.h

+0 −1
Original line number Diff line number Diff line
@@ -72,7 +72,6 @@ protected: 
    virtual ~MediaExtractor() {}



private:

    bool mIsDrm;



    typedef bool (*SnifferFunc)(

            const sp<DataSource> &source, String8 *mimeType,

media/libstagefright/Android.mk

+0 −1
Original line number Diff line number Diff line
@@ -18,7 +18,6 @@ LOCAL_SRC_FILES:= \ 
        DataConverter.cpp                 \

        DataSource.cpp                    \

        DataURISource.cpp                 \

        DRMExtractor.cpp                  \

        ESDS.cpp                          \

        FileSource.cpp                    \

        FLACExtractor.cpp                 \

media/libstagefright/DRMExtractor.cpp

deleted100644 → 0
+0 −305
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include "include/DRMExtractor.h"



#include <arpa/inet.h>

#include <utils/String8.h>

#include <media/stagefright/foundation/ADebug.h>

#include <media/stagefright/Utils.h>

#include <media/stagefright/DataSource.h>

#include <media/stagefright/MediaSource.h>

#include <media/stagefright/MediaDefs.h>

#include <media/stagefright/MetaData.h>

#include <media/stagefright/MediaErrors.h>

#include <media/stagefright/MediaBuffer.h>



#include <drm/drm_framework_common.h>

#include <utils/Errors.h>





namespace android {



class DRMSource : public MediaSource {

public:

    DRMSource(const sp<IMediaSource> &mediaSource,

            const sp<DecryptHandle> &decryptHandle,

            DrmManagerClient *managerClient,

            int32_t trackId, DrmBuffer *ipmpBox);



    virtual status_t start(MetaData *params = NULL);

    virtual status_t stop();

    virtual sp<MetaData> getFormat();

    virtual status_t read(

            MediaBuffer **buffer, const ReadOptions *options = NULL);



protected:

    virtual ~DRMSource();



private:

    sp<IMediaSource> mOriginalMediaSource;

    sp<DecryptHandle> mDecryptHandle;

    DrmManagerClient* mDrmManagerClient;

    size_t mTrackId;

    mutable Mutex mDRMLock;

    size_t mNALLengthSize;

    bool mWantsNALFragments;



    DRMSource(const DRMSource &);

    DRMSource &operator=(const DRMSource &);

};



////////////////////////////////////////////////////////////////////////////////



DRMSource::DRMSource(const sp<IMediaSource> &mediaSource,

        const sp<DecryptHandle> &decryptHandle,

        DrmManagerClient *managerClient,

        int32_t trackId, DrmBuffer *ipmpBox)

    : mOriginalMediaSource(mediaSource),

      mDecryptHandle(decryptHandle),

      mDrmManagerClient(managerClient),

      mTrackId(trackId),

      mNALLengthSize(0),

      mWantsNALFragments(false) {

    CHECK(mDrmManagerClient);

    mDrmManagerClient->initializeDecryptUnit(

            mDecryptHandle, trackId, ipmpBox);



    const char *mime;

    bool success = getFormat()->findCString(kKeyMIMEType, &mime);

    CHECK(success);



    if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) {

        uint32_t type;

        const void *data;

        size_t size;

        CHECK(getFormat()->findData(kKeyAVCC, &type, &data, &size));



        const uint8_t *ptr = (const uint8_t *)data;



        CHECK(size >= 7);

        CHECK_EQ(ptr[0], 1);  // configurationVersion == 1



        // The number of bytes used to encode the length of a NAL unit.

        mNALLengthSize = 1 + (ptr[4] & 3);

    }

}



DRMSource::~DRMSource() {

    Mutex::Autolock autoLock(mDRMLock);

    mDrmManagerClient->finalizeDecryptUnit(mDecryptHandle, mTrackId);

}



status_t DRMSource::start(MetaData *params) {

    int32_t val;

    if (params && params->findInt32(kKeyWantsNALFragments, &val)

        && val != 0) {

        mWantsNALFragments = true;

    } else {

        mWantsNALFragments = false;

    }



   return mOriginalMediaSource->start(params);

}



status_t DRMSource::stop() {

    return mOriginalMediaSource->stop();

}



sp<MetaData> DRMSource::getFormat() {

    return mOriginalMediaSource->getFormat();

}



status_t DRMSource::read(MediaBuffer **buffer, const ReadOptions *options) {

    Mutex::Autolock autoLock(mDRMLock);

    status_t err;

    if ((err = mOriginalMediaSource->read(buffer, options)) != OK) {

        return err;

    }



    size_t len = (*buffer)->range_length();



    char *src = (char *)(*buffer)->data() + (*buffer)->range_offset();



    DrmBuffer encryptedDrmBuffer(src, len);

    DrmBuffer decryptedDrmBuffer;

    decryptedDrmBuffer.length = len;

    decryptedDrmBuffer.data = new char[len];

    DrmBuffer *pDecryptedDrmBuffer = &decryptedDrmBuffer;



    if ((err = mDrmManagerClient->decrypt(mDecryptHandle, mTrackId,

            &encryptedDrmBuffer, &pDecryptedDrmBuffer)) != NO_ERROR) {



        if (decryptedDrmBuffer.data) {

            delete [] decryptedDrmBuffer.data;

            decryptedDrmBuffer.data = NULL;

        }



        return err;

    }

    CHECK(pDecryptedDrmBuffer == &decryptedDrmBuffer);



    const char *mime;

    CHECK(getFormat()->findCString(kKeyMIMEType, &mime));



    if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC) && !mWantsNALFragments) {

        uint8_t *dstData = (uint8_t*)src;

        size_t srcOffset = 0;

        size_t dstOffset = 0;



        len = decryptedDrmBuffer.length;

        while (srcOffset < len) {

            CHECK(srcOffset + mNALLengthSize <= len);

            size_t nalLength = 0;

            const uint8_t* data = (const uint8_t*)(&decryptedDrmBuffer.data[srcOffset]);



            switch (mNALLengthSize) {

                case 1:

                    nalLength = *data;

                    break;

                case 2:

                    nalLength = U16_AT(data);

                    break;

                case 3:

                    nalLength = ((size_t)data[0] << 16) | U16_AT(&data[1]);

                    break;

                case 4:

                    nalLength = U32_AT(data);

                    break;

                default:

                    CHECK(!"Should not be here.");

                    break;

            }



            srcOffset += mNALLengthSize;



            size_t end = srcOffset + nalLength;

            if (end > len || end < srcOffset) {

                if (decryptedDrmBuffer.data) {

                    delete [] decryptedDrmBuffer.data;

                    decryptedDrmBuffer.data = NULL;

                }



                return ERROR_MALFORMED;

            }



            if (nalLength == 0) {

                continue;

            }



            if (dstOffset > SIZE_MAX - 4 ||

                dstOffset + 4 > SIZE_MAX - nalLength ||

                dstOffset + 4 + nalLength > (*buffer)->size()) {

                (*buffer)->release();

                (*buffer) = NULL;

                if (decryptedDrmBuffer.data) {

                    delete [] decryptedDrmBuffer.data;

                    decryptedDrmBuffer.data = NULL;

                }

                return ERROR_MALFORMED;

            }



            dstData[dstOffset++] = 0;

            dstData[dstOffset++] = 0;

            dstData[dstOffset++] = 0;

            dstData[dstOffset++] = 1;

            memcpy(&dstData[dstOffset], &decryptedDrmBuffer.data[srcOffset], nalLength);

            srcOffset += nalLength;

            dstOffset += nalLength;

        }



        CHECK_EQ(srcOffset, len);

        (*buffer)->set_range((*buffer)->range_offset(), dstOffset);



    } else {

        memcpy(src, decryptedDrmBuffer.data, decryptedDrmBuffer.length);

        (*buffer)->set_range((*buffer)->range_offset(), decryptedDrmBuffer.length);

    }



    if (decryptedDrmBuffer.data) {

        delete [] decryptedDrmBuffer.data;

        decryptedDrmBuffer.data = NULL;

    }



    return OK;

}



////////////////////////////////////////////////////////////////////////////////



DRMExtractor::DRMExtractor(const sp<DataSource> &source, const char* mime)

    : mDataSource(source),

      mDecryptHandle(NULL),

      mDrmManagerClient(NULL) {

    mOriginalExtractor = MediaExtractor::Create(source, mime);

    mOriginalExtractor->getMetaData()->setInt32(kKeyIsDRM, 1);



    source->getDrmInfo(mDecryptHandle, &mDrmManagerClient);

}



DRMExtractor::~DRMExtractor() {

}



size_t DRMExtractor::countTracks() {

    return mOriginalExtractor->countTracks();

}



sp<IMediaSource> DRMExtractor::getTrack(size_t index) {

    sp<IMediaSource> originalMediaSource = mOriginalExtractor->getTrack(index);

    originalMediaSource->getFormat()->setInt32(kKeyIsDRM, 1);



    int32_t trackID;

    CHECK(getTrackMetaData(index, 0)->findInt32(kKeyTrackID, &trackID));



    DrmBuffer ipmpBox;

    ipmpBox.data = mOriginalExtractor->getDrmTrackInfo(trackID, &(ipmpBox.length));

    CHECK(ipmpBox.length > 0);



    return interface_cast<IMediaSource>(

            new DRMSource(originalMediaSource, mDecryptHandle, mDrmManagerClient,

            trackID, &ipmpBox));

}



sp<MetaData> DRMExtractor::getTrackMetaData(size_t index, uint32_t flags) {

    return mOriginalExtractor->getTrackMetaData(index, flags);

}



sp<MetaData> DRMExtractor::getMetaData() {

    return mOriginalExtractor->getMetaData();

}



bool SniffDRM(

    const sp<DataSource> &source, String8 *mimeType, float *confidence,

        sp<AMessage> *) {

    sp<DecryptHandle> decryptHandle = source->DrmInitialization();



    if (decryptHandle != NULL) {

        if (decryptHandle->decryptApiType == DecryptApiType::CONTAINER_BASED) {

            *mimeType = String8("drm+container_based+") + decryptHandle->mimeType;

            *confidence = 10.0f;

        } else if (decryptHandle->decryptApiType == DecryptApiType::ELEMENTARY_STREAM_BASED) {

            *mimeType = String8("drm+es_based+") + decryptHandle->mimeType;

            *confidence = 10.0f;

        } else {

            return false;

        }



        return true;

    }



    return false;

}

} //namespace android

media/libstagefright/MediaExtractor.cpp

+4 −23
Original line number Diff line number Diff line
@@ -27,7 +27,6 @@ 
#include "include/OggExtractor.h"

#include "include/MPEG2PSExtractor.h"

#include "include/MPEG2TSExtractor.h"

#include "include/DRMExtractor.h"

#include "include/FLACExtractor.h"

#include "include/AACExtractor.h"

#include "include/MidiExtractor.h"
@@ -51,8 +50,7 @@ 


namespace android {



MediaExtractor::MediaExtractor():

    mIsDrm(false) {

MediaExtractor::MediaExtractor() {

    if (!LOG_NDEBUG) {

        uid_t uid = getuid();

        struct passwd *pw = getpwuid(uid);
@@ -148,23 +146,6 @@ sp<IMediaExtractor> MediaExtractor::Create( 
        ALOGW("creating media extractor in calling process");

        return CreateFromService(source, mime);

    } else {

        String8 mime8;

        float confidence;

        sp<AMessage> meta;



        // Check if it's es-based DRM, since DRMExtractor needs to be created in the media server

        // process, not the extractor process.

        if (SniffDRM(source, &mime8, &confidence, &meta)) {

            const char *drmMime = mime8.string();

            ALOGV("Detected media content as '%s' with confidence %.2f", drmMime, confidence);

            if (!strncmp(drmMime, "drm+es_based+", 13)) {

                // DRMExtractor sets container metadata kKeyIsDRM to 1

                return new DRMExtractor(source, drmMime + 14);

            } else {

                mime = drmMime + 20; // get real mimetype after "drm+container_based+" prefix

            }

        }



        // remote extractor

        ALOGV("get service manager");

        sp<IBinder> binder = defaultServiceManager()->getService(String16("media.extractor"));
@@ -187,6 +168,9 @@ sp<MediaExtractor> MediaExtractor::CreateFromService( 
    ALOGV("MediaExtractor::CreateFromService %s", mime);

    RegisterDefaultSniffers();



    // initialize source decryption if needed

    source->DrmInitialization();



    sp<AMessage> meta;



    String8 tmp;
@@ -299,9 +283,6 @@ void MediaExtractor::RegisterDefaultSniffers() { 
    RegisterSniffer_l(SniffMPEG2PS);

    RegisterSniffer_l(SniffMidi);



    if (property_get_bool("drm.service.enabled", false)) {

        RegisterSniffer_l(SniffDRM);

    }

    gSniffersRegistered = true;

}

media/libstagefright/include/DRMExtractor.h

deleted100644 → 0
+0 −64
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef DRM_EXTRACTOR_H_



#define DRM_EXTRACTOR_H_



#include <media/IMediaSource.h>

#include <media/stagefright/MediaExtractor.h>

#include <drm/DrmManagerClient.h>



namespace android {



struct AMessage;

class DataSource;

class SampleTable;

class String8;

class DecryptHandle;



class DRMExtractor : public MediaExtractor {

public:

    DRMExtractor(const sp<DataSource> &source, const char *mime);



    virtual size_t countTracks();

    virtual sp<IMediaSource> getTrack(size_t index);

    virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);

    virtual sp<MetaData> getMetaData();

    virtual const char * name() { return "DRMExtractor"; }



protected:

    virtual ~DRMExtractor();



private:

    sp<DataSource> mDataSource;



    sp<IMediaExtractor> mOriginalExtractor;

    sp<DecryptHandle> mDecryptHandle;

    DrmManagerClient* mDrmManagerClient;



    DRMExtractor(const DRMExtractor &);

    DRMExtractor &operator=(const DRMExtractor &);

};



bool SniffDRM(

        const sp<DataSource> &source, String8 *mimeType, float *confidence,

            sp<AMessage> *);



}  // namespace android



#endif  // DRM_EXTRACTOR_H_