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

Commit 1e1bcaae authored by Dongwon Kang's avatar Dongwon Kang
Browse files

MediaPlayer2: Remove libdrmframework.so dependency. 

libdrmframework.so is being used in FileSource and MediaHTTP
for Forward Lock DRM use case.
This change removes this dependency from MediaPlayer2 by adding
ClearFileSource and ClearMediaHTTP.
Forward Lock DRM use case will be covered by MediaPlayer1.

Test: build & MediaPlayerTest & DrmTest
Bug: 111406958
Change-Id: I5cf51b2d6f477e8fa8950ac931c0142491baa747
parent 978dcac6

media/libmediaplayer2/nuplayer2/GenericSource2.cpp

+3 −3
Original line number Diff line number Diff line
@@ -34,7 +34,7 @@ 
#include <media/stagefright/foundation/ABuffer.h>

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

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

#include <media/stagefright/DataSourceFactory.h>

#include <media/stagefright/ClearDataSourceFactory.h>

#include <media/stagefright/InterfaceUtils.h>

#include <media/stagefright/MediaBuffer.h>

#include <media/stagefright/MediaClock.h>
@@ -368,7 +368,7 @@ void NuPlayer2::GenericSource2::onPrepareAsync() { 
            String8 contentType;



            if (!strncasecmp("http://", uri, 7) || !strncasecmp("https://", uri, 8)) {

                mHttpSource = DataSourceFactory::CreateMediaHTTP(mHTTPService);

                mHttpSource = ClearDataSourceFactory::CreateMediaHTTP(mHTTPService);

                if (mHttpSource == NULL) {

                    ALOGE("Failed to create http source!");

                    notifyPreparedAndCleanup(UNKNOWN_ERROR);
@@ -378,7 +378,7 @@ void NuPlayer2::GenericSource2::onPrepareAsync() { 


            mLock.unlock();

            // This might take long time if connection has some issue.

            sp<DataSource> dataSource = DataSourceFactory::CreateFromURI(

            sp<DataSource> dataSource = ClearDataSourceFactory::CreateFromURI(

                   mHTTPService, uri, &mUriHeaders, &contentType,

                   static_cast<HTTPBase *>(mHttpSource.get()));

            mLock.lock();

media/libstagefright/Android.bp

+5 −4
Original line number Diff line number Diff line
@@ -105,6 +105,7 @@ cc_library_shared { 
        "DataConverter.cpp",

        "DataSourceFactory.cpp",

        "DataURISource.cpp",

        "ClearFileSource.cpp",

        "FileSource.cpp",

        "FrameDecoder.cpp",

        "HTTPBase.cpp",
@@ -121,6 +122,7 @@ cc_library_shared { 
        "MediaCodecSource.cpp",

        "MediaExtractorFactory.cpp",

        "MediaSync.cpp",

        "http/ClearMediaHTTP.cpp",

        "http/MediaHTTP.cpp",

        "MediaMuxer.cpp",

        "NuCachedSource2.cpp",
@@ -232,9 +234,9 @@ cc_library { 
    srcs: [

        "CallbackDataSource.cpp",

        "CallbackMediaSource.cpp",

        "DataSourceFactory.cpp",

        "ClearDataSourceFactory.cpp",

        "ClearFileSource.cpp",

        "DataURISource.cpp",

        "FileSource.cpp",

        "HTTPBase.cpp",

        "HevcUtils.cpp",

        "InterfaceUtils.cpp",
@@ -246,13 +248,12 @@ cc_library { 
        "RemoteMediaSource.cpp",

        "Utils.cpp",

        "VideoFrameScheduler.cpp",

        "http/MediaHTTP.cpp",

        "http/ClearMediaHTTP.cpp",

    ],



    shared_libs: [

        "libbinder",

        "libcutils",

        "libdrmframework",

        "libgui",

        "liblog",

        "libmedia_player2_util",

media/libstagefright/ClearDataSourceFactory.cpp

0 → 100644
+117 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 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.

 */

//#define LOG_NDEBUG 0

#define LOG_TAG "ClearDataSourceFactory"



#include "include/HTTPBase.h"

#include "include/NuCachedSource2.h"



#include <media/MediaHTTPConnection.h>

#include <media/MediaHTTPService.h>

#include <media/stagefright/ClearFileSource.h>

#include <media/stagefright/ClearMediaHTTP.h>

#include <media/stagefright/ClearDataSourceFactory.h>

#include <media/stagefright/DataURISource.h>

#include <utils/String8.h>



namespace android {



// static

sp<DataSource> ClearDataSourceFactory::CreateFromURI(

        const sp<MediaHTTPService> &httpService,

        const char *uri,

        const KeyedVector<String8, String8> *headers,

        String8 *contentType,

        HTTPBase *httpSource) {

    if (contentType != NULL) {

        *contentType = "";

    }



    sp<DataSource> source;

    if (!strncasecmp("file://", uri, 7)) {

        source = new ClearFileSource(uri + 7);

    } else if (!strncasecmp("http://", uri, 7) || !strncasecmp("https://", uri, 8)) {

        if (httpService == NULL) {

            ALOGE("Invalid http service!");

            return NULL;

        }



        if (httpSource == NULL) {

            sp<MediaHTTPConnection> conn = httpService->makeHTTPConnection();

            if (conn == NULL) {

                ALOGE("Failed to make http connection from http service!");

                return NULL;

            }

            httpSource = new ClearMediaHTTP(conn);

        }



        String8 cacheConfig;

        bool disconnectAtHighwatermark = false;

        KeyedVector<String8, String8> nonCacheSpecificHeaders;

        if (headers != NULL) {

            nonCacheSpecificHeaders = *headers;

            NuCachedSource2::RemoveCacheSpecificHeaders(

                    &nonCacheSpecificHeaders,

                    &cacheConfig,

                    &disconnectAtHighwatermark);

        }



        if (httpSource->connect(uri, &nonCacheSpecificHeaders) != OK) {

            ALOGE("Failed to connect http source!");

            return NULL;

        }



        if (contentType != NULL) {

            *contentType = httpSource->getMIMEType();

        }



        source = NuCachedSource2::Create(

                httpSource,

                cacheConfig.isEmpty() ? NULL : cacheConfig.string(),

                disconnectAtHighwatermark);

    } else if (!strncasecmp("data:", uri, 5)) {

        source = DataURISource::Create(uri);

    } else {

        // Assume it's a filename.

        source = new ClearFileSource(uri);

    }



    if (source == NULL || source->initCheck() != OK) {

        return NULL;

    }



    return source;

}



sp<DataSource> ClearDataSourceFactory::CreateFromFd(int fd, int64_t offset, int64_t length) {

    sp<ClearFileSource> source = new ClearFileSource(fd, offset, length);

    return source->initCheck() != OK ? nullptr : source;

}



sp<DataSource> ClearDataSourceFactory::CreateMediaHTTP(const sp<MediaHTTPService> &httpService) {

    if (httpService == NULL) {

        return NULL;

    }



    sp<MediaHTTPConnection> conn = httpService->makeHTTPConnection();

    if (conn == NULL) {

        return NULL;

    } else {

        return new ClearMediaHTTP(conn);

    }

}



}  // namespace android

media/libstagefright/ClearFileSource.cpp

0 → 100644
+143 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 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.

 */



//#define LOG_NDEBUG 0

#define LOG_TAG "ClearFileSource"

#include <utils/Log.h>



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

#include <media/stagefright/ClearFileSource.h>

#include <media/stagefright/Utils.h>

#include <sys/types.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>



namespace android {



ClearFileSource::ClearFileSource(const char *filename)

    : mFd(-1),

      mOffset(0),

      mLength(-1),

      mName("<null>") {



    if (filename) {

        mName = String8::format("FileSource(%s)", filename);

    }

    ALOGV("%s", filename);

    mFd = open(filename, O_LARGEFILE | O_RDONLY);



    if (mFd >= 0) {

        mLength = lseek64(mFd, 0, SEEK_END);

    } else {

        ALOGE("Failed to open file '%s'. (%s)", filename, strerror(errno));

    }

}



ClearFileSource::ClearFileSource(int fd, int64_t offset, int64_t length)

    : mFd(fd),

      mOffset(offset),

      mLength(length),

      mName("<null>") {

    ALOGV("fd=%d (%s), offset=%lld, length=%lld",

            fd, nameForFd(fd).c_str(), (long long) offset, (long long) length);



    if (mOffset < 0) {

        mOffset = 0;

    }

    if (mLength < 0) {

        mLength = 0;

    }

    if (mLength > INT64_MAX - mOffset) {

        mLength = INT64_MAX - mOffset;

    }

    struct stat s;

    if (fstat(fd, &s) == 0) {

        if (mOffset > s.st_size) {

            mOffset = s.st_size;

            mLength = 0;

        }

        if (mOffset + mLength > s.st_size) {

            mLength = s.st_size - mOffset;

        }

    }

    if (mOffset != offset || mLength != length) {

        ALOGW("offset/length adjusted from %lld/%lld to %lld/%lld",

                (long long) offset, (long long) length,

                (long long) mOffset, (long long) mLength);

    }



    mName = String8::format(

            "FileSource(fd(%s), %lld, %lld)",

            nameForFd(fd).c_str(),

            (long long) mOffset,

            (long long) mLength);



}



ClearFileSource::~ClearFileSource() {

    if (mFd >= 0) {

        ::close(mFd);

        mFd = -1;

    }

}



status_t ClearFileSource::initCheck() const {

    return mFd >= 0 ? OK : NO_INIT;

}



ssize_t ClearFileSource::readAt(off64_t offset, void *data, size_t size) {

    if (mFd < 0) {

        return NO_INIT;

    }



    Mutex::Autolock autoLock(mLock);

    if (mLength >= 0) {

        if (offset >= mLength) {

            return 0;  // read beyond EOF.

        }

        uint64_t numAvailable = mLength - offset;

        if ((uint64_t)size > numAvailable) {

            size = numAvailable;

        }

    }

    return readAt_l(offset, data, size);

}



ssize_t ClearFileSource::readAt_l(off64_t offset, void *data, size_t size) {

    off64_t result = lseek64(mFd, offset + mOffset, SEEK_SET);

    if (result == -1) {

        ALOGE("seek to %lld failed", (long long)(offset + mOffset));

        return UNKNOWN_ERROR;

    }



    return ::read(mFd, data, size);

}



status_t ClearFileSource::getSize(off64_t *size) {

    Mutex::Autolock autoLock(mLock);



    if (mFd < 0) {

        return NO_INIT;

    }



    *size = mLength;



    return OK;

}



}  // namespace android

media/libstagefright/FileSource.cpp

+5 −89
Original line number Diff line number Diff line
@@ -22,90 +22,28 @@ 
#include <media/stagefright/FileSource.h>

#include <media/stagefright/Utils.h>

#include <private/android_filesystem_config.h>

#include <sys/types.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>



namespace android {



FileSource::FileSource(const char *filename)

    : mFd(-1),

      mOffset(0),

      mLength(-1),

      mName("<null>"),

    : ClearFileSource(filename),

      mDecryptHandle(NULL),

      mDrmManagerClient(NULL),

      mDrmBufOffset(0),

      mDrmBufSize(0),

      mDrmBuf(NULL){



    if (filename) {

        mName = String8::format("FileSource(%s)", filename);

    }

    ALOGV("%s", filename);

    mFd = open(filename, O_LARGEFILE | O_RDONLY);



    if (mFd >= 0) {

        mLength = lseek64(mFd, 0, SEEK_END);

    } else {

        ALOGE("Failed to open file '%s'. (%s)", filename, strerror(errno));

    }

}



FileSource::FileSource(int fd, int64_t offset, int64_t length)

    : mFd(fd),

      mOffset(offset),

      mLength(length),

      mName("<null>"),

    : ClearFileSource(fd, offset, length),

      mDecryptHandle(NULL),

      mDrmManagerClient(NULL),

      mDrmBufOffset(0),

      mDrmBufSize(0),

      mDrmBuf(NULL) {

    ALOGV("fd=%d (%s), offset=%lld, length=%lld",

            fd, nameForFd(fd).c_str(), (long long) offset, (long long) length);



    if (mOffset < 0) {

        mOffset = 0;

    }

    if (mLength < 0) {

        mLength = 0;

    }

    if (mLength > INT64_MAX - mOffset) {

        mLength = INT64_MAX - mOffset;

    }

    struct stat s;

    if (fstat(fd, &s) == 0) {

        if (mOffset > s.st_size) {

            mOffset = s.st_size;

            mLength = 0;

        }

        if (mOffset + mLength > s.st_size) {

            mLength = s.st_size - mOffset;

        }

    }

    if (mOffset != offset || mLength != length) {

        ALOGW("offset/length adjusted from %lld/%lld to %lld/%lld",

                (long long) offset, (long long) length,

                (long long) mOffset, (long long) mLength);

    }



    mName = String8::format(

            "FileSource(fd(%s), %lld, %lld)",

            nameForFd(fd).c_str(),

            (long long) mOffset,

            (long long) mLength);



}



FileSource::~FileSource() {

    if (mFd >= 0) {

        ::close(mFd);

        mFd = -1;

    }



    if (mDrmBuf != NULL) {

        delete[] mDrmBuf;

        mDrmBuf = NULL;
@@ -124,10 +62,6 @@ FileSource::~FileSource() { 
    }

}



status_t FileSource::initCheck() const {

    return mFd >= 0 ? OK : NO_INIT;

}



ssize_t FileSource::readAt(off64_t offset, void *data, size_t size) {

    if (mFd < 0) {

        return NO_INIT;
@@ -147,28 +81,10 @@ ssize_t FileSource::readAt(off64_t offset, void *data, size_t size) { 


    if (mDecryptHandle != NULL && DecryptApiType::CONTAINER_BASED

            == mDecryptHandle->decryptApiType) {

        return readAtDRM(offset, data, size);

        return readAtDRM_l(offset, data, size);

   } else {

        off64_t result = lseek64(mFd, offset + mOffset, SEEK_SET);

        if (result == -1) {

            ALOGE("seek to %lld failed", (long long)(offset + mOffset));

            return UNKNOWN_ERROR;

        return readAt_l(offset, data, size);

    }



        return ::read(mFd, data, size);

    }

}



status_t FileSource::getSize(off64_t *size) {

    Mutex::Autolock autoLock(mLock);



    if (mFd < 0) {

        return NO_INIT;

    }



    *size = mLength;



    return OK;

}



sp<DecryptHandle> FileSource::DrmInitialization(const char *mime) {
@@ -194,7 +110,7 @@ sp<DecryptHandle> FileSource::DrmInitialization(const char *mime) { 
    return mDecryptHandle;

}



ssize_t FileSource::readAtDRM(off64_t offset, void *data, size_t size) {

ssize_t FileSource::readAtDRM_l(off64_t offset, void *data, size_t size) {

    size_t DRM_CACHE_SIZE = 1024;

    if (mDrmBuf == NULL) {

        mDrmBuf = new unsigned char[DRM_CACHE_SIZE];