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

Commit 7edb3f7d authored by Dongwon Kang's avatar Dongwon Kang Committed by Marco Nelissen
Browse files

Move implementations to DataSourceBase.h 

Some lib*extractors include DataSourceBase.h but are not
linking libstagefright which has the implementation.
This doesn't cause any build issue in normal build, but
it actually matters when NATIVE_COVERAGE=true which uses -O0.

Fixing by moving the implementation to the header.

Bug: 139459652
Test: m
Test: NATIVE_COVERAGE=true COVERAGE_PATHS="*" m
Change-Id: Ic955189ff9f0fbc48b5b35eccdb2916dc79fdb0f
Merged-In: Ic955189ff9f0fbc48b5b35eccdb2916dc79fdb0f
parent c26431a9

media/libstagefright/Android.bp

+0 −1
Original line number Original line Diff line number Diff line
@@ -133,7 +133,6 @@ cc_library { 
        "CameraSource.cpp",

        "CameraSource.cpp",

        "CameraSourceTimeLapse.cpp",

        "CameraSourceTimeLapse.cpp",

        "DataConverter.cpp",

        "DataConverter.cpp",

        "DataSourceBase.cpp",

        "DataSourceFactory.cpp",

        "DataSourceFactory.cpp",

        "DataURISource.cpp",

        "DataURISource.cpp",

        "ClearFileSource.cpp",

        "ClearFileSource.cpp",

media/libstagefright/DataSourceBase.cpp

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

 * Copyright (C) 2009 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 "DataSourceBase"



#include <media/DataSourceBase.h>

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

#include <media/stagefright/MediaErrors.h>

#include <utils/String8.h>



namespace android {



bool DataSourceBase::getUInt16(off64_t offset, uint16_t *x) {

    *x = 0;



    uint8_t byte[2];

    if (readAt(offset, byte, 2) != 2) {

        return false;

    }



    *x = (byte[0] << 8) | byte[1];



    return true;

}



bool DataSourceBase::getUInt24(off64_t offset, uint32_t *x) {

    *x = 0;



    uint8_t byte[3];

    if (readAt(offset, byte, 3) != 3) {

        return false;

    }



    *x = (byte[0] << 16) | (byte[1] << 8) | byte[2];



    return true;

}



bool DataSourceBase::getUInt32(off64_t offset, uint32_t *x) {

    *x = 0;



    uint32_t tmp;

    if (readAt(offset, &tmp, 4) != 4) {

        return false;

    }



    *x = ntohl(tmp);



    return true;

}



bool DataSourceBase::getUInt64(off64_t offset, uint64_t *x) {

    *x = 0;



    uint64_t tmp;

    if (readAt(offset, &tmp, 8) != 8) {

        return false;

    }



    *x = ntoh64(tmp);



    return true;

}



bool DataSourceBase::getUInt16Var(off64_t offset, uint16_t *x, size_t size) {

    if (size == 2) {

        return getUInt16(offset, x);

    }

    if (size == 1) {

        uint8_t tmp;

        if (readAt(offset, &tmp, 1) == 1) {

            *x = tmp;

            return true;

        }

    }

    return false;

}



bool DataSourceBase::getUInt32Var(off64_t offset, uint32_t *x, size_t size) {

    if (size == 4) {

        return getUInt32(offset, x);

    }

    if (size == 2) {

        uint16_t tmp;

        if (getUInt16(offset, &tmp)) {

            *x = tmp;

            return true;

        }

    }

    return false;

}



bool DataSourceBase::getUInt64Var(off64_t offset, uint64_t *x, size_t size) {

    if (size == 8) {

        return getUInt64(offset, x);

    }

    if (size == 4) {

        uint32_t tmp;

        if (getUInt32(offset, &tmp)) {

            *x = tmp;

            return true;

        }

    }

    return false;

}



status_t DataSourceBase::getSize(off64_t *size) {

    *size = 0;



    return ERROR_UNSUPPORTED;

}



bool DataSourceBase::getUri(char *uriString __unused, size_t bufferSize __unused) {

    return false;

}



}  // namespace android

media/libstagefright/include/media/stagefright/DataSourceBase.h

+97 −9
Original line number Original line Diff line number Diff line
@@ -18,6 +18,8 @@ 




#define DATA_SOURCE_BASE_H_

#define DATA_SOURCE_BASE_H_





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

#include <media/stagefright/MediaErrors.h>

#include <sys/types.h>

#include <sys/types.h>

#include <utils/Errors.h>

#include <utils/Errors.h>
@@ -45,20 +47,106 @@ public: 
    virtual ssize_t readAt(off64_t offset, void *data, size_t size) = 0;

    virtual ssize_t readAt(off64_t offset, void *data, size_t size) = 0;





    // Convenience methods:

    // Convenience methods:

    bool getUInt16(off64_t offset, uint16_t *x);

    bool getUInt16(off64_t offset, uint16_t *x) {

    bool getUInt24(off64_t offset, uint32_t *x); // 3 byte int, returned as a 32-bit int

        *x = 0;

    bool getUInt32(off64_t offset, uint32_t *x);



    bool getUInt64(off64_t offset, uint64_t *x);

        uint8_t byte[2];

        if (readAt(offset, byte, 2) != 2) {

            return false;

        }



        *x = (byte[0] << 8) | byte[1];



        return true;

    }

    // 3 byte int, returned as a 32-bit int

    bool getUInt24(off64_t offset, uint32_t *x) {

        *x = 0;



        uint8_t byte[3];

        if (readAt(offset, byte, 3) != 3) {

            return false;

        }



        *x = (byte[0] << 16) | (byte[1] << 8) | byte[2];



        return true;

    }

    bool getUInt32(off64_t offset, uint32_t *x) {

        *x = 0;



        uint32_t tmp;

        if (readAt(offset, &tmp, 4) != 4) {

            return false;

        }



        *x = ntohl(tmp);



        return true;

    }

    bool getUInt64(off64_t offset, uint64_t *x) {

        *x = 0;



        uint64_t tmp;

        if (readAt(offset, &tmp, 8) != 8) {

            return false;

        }



        *x = ntoh64(tmp);



        return true;

    }





    // read either int<N> or int<2N> into a uint<2N>_t, size is the int size in bytes.

    // read either int<N> or int<2N> into a uint<2N>_t, size is the int size in bytes.

    bool getUInt16Var(off64_t offset, uint16_t *x, size_t size);

    bool getUInt16Var(off64_t offset, uint16_t *x, size_t size) {

    bool getUInt32Var(off64_t offset, uint32_t *x, size_t size);

        if (size == 2) {

    bool getUInt64Var(off64_t offset, uint64_t *x, size_t size);

            return getUInt16(offset, x);

        }

        if (size == 1) {

            uint8_t tmp;

            if (readAt(offset, &tmp, 1) == 1) {

                *x = tmp;

                return true;

            }

        }

        return false;

    }

    bool getUInt32Var(off64_t offset, uint32_t *x, size_t size) {

        if (size == 4) {

            return getUInt32(offset, x);

        }

        if (size == 2) {

            uint16_t tmp;

            if (getUInt16(offset, &tmp)) {

                *x = tmp;

                return true;

            }

        }

        return false;

    }

    bool getUInt64Var(off64_t offset, uint64_t *x, size_t size) {

        if (size == 8) {

            return getUInt64(offset, x);

        }

        if (size == 4) {

            uint32_t tmp;

            if (getUInt32(offset, &tmp)) {

                *x = tmp;

                return true;

            }

        }

        return false;

    }





    // May return ERROR_UNSUPPORTED.

    // May return ERROR_UNSUPPORTED.

    virtual status_t getSize(off64_t *size);

    virtual status_t getSize(off64_t *size) {

        *size = 0;

        return ERROR_UNSUPPORTED;

    }





    virtual bool getUri(char *uriString, size_t bufferSize);

    virtual bool getUri(char * /*uriString*/, size_t /*bufferSize*/) {

        return false;

    }





    virtual uint32_t flags() {

    virtual uint32_t flags() {

        return 0;

        return 0;