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

Commit 42c25a4f authored by Surajit Podder's avatar Surajit Podder Committed by Gerrit - the friendly Code Review server
Browse files

DataSource: Remove global variables in DataSource related to sniff 

Remove global variables related to sniff, and added Sniffer class
to implement the sniff functionality with non-static members.

Change-Id: I6fbd0ba5b686e09fda11d78cdd687a69c81a6bdf
CRs-Fixed: 567753
parent d9b04af0

include/media/stagefright/DataSource.h

+33 −5
Original line number Diff line number Diff line
@@ -35,6 +35,37 @@ struct AString; 
struct IMediaHTTPService;

class String8;

struct HTTPBase;

class DataSource;



class Sniffer : public RefBase {

public:

    Sniffer();



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



    bool sniff(DataSource *source, String8 *mimeType, float *confidence, sp<AMessage> *meta);



    // The sniffer can optionally fill in "meta" with an AMessage containing

    // a dictionary of values that helps the corresponding extractor initialize

    // its state without duplicating effort already exerted by the sniffer.

    typedef bool (*SnifferFunc)(

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

            float *confidence, sp<AMessage> *meta);



    //if isExtendedExtractor = true, store the location of the sniffer to register

    void registerSniffer_l(SnifferFunc func);

    void registerDefaultSniffers();



    virtual ~Sniffer() {}



private:

    Mutex mSnifferMutex;

    List<SnifferFunc> mSniffers;

    List<SnifferFunc>::iterator extendedSnifferPosition;



    Sniffer(const Sniffer &);

    Sniffer &operator=(const Sniffer &);

};



class DataSource : public RefBase {

public:
@@ -54,7 +85,7 @@ public: 


    static sp<DataSource> CreateMediaHTTP(const sp<IMediaHTTPService> &httpService);



    DataSource() {}

    DataSource() : mSniffer(new Sniffer()) {}



    virtual status_t initCheck() const = 0;
@@ -105,10 +136,7 @@ public: 
protected:

    virtual ~DataSource() {}



private:

    static Mutex gSnifferMutex;

    static List<SnifferFunc> gSniffers;

    static bool gSniffersRegistered;

    sp<Sniffer> mSniffer;



    static void RegisterSniffer_l(SnifferFunc func);

media/libstagefright/DataSource.cpp

+48 −40
Original line number Diff line number Diff line
@@ -109,29 +109,42 @@ status_t DataSource::getSize(off64_t *size) { 


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



Mutex DataSource::gSnifferMutex;

List<DataSource::SnifferFunc> DataSource::gSniffers;

bool DataSource::gSniffersRegistered = false;



bool DataSource::sniff(

        String8 *mimeType, float *confidence, sp<AMessage> *meta) {

    *mimeType = "";

    *confidence = 0.0f;

    meta->clear();



    {

        Mutex::Autolock autoLock(gSnifferMutex);

        if (!gSniffersRegistered) {

            return false;

    return  mSniffer->sniff(this, mimeType, confidence, meta);

}



// static

void DataSource::RegisterSniffer_l(SnifferFunc func) {

    return;

}



// static

void DataSource::RegisterDefaultSniffers() {

    return;

}



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



Sniffer::Sniffer() {

    registerDefaultSniffers();

}



    for (List<SnifferFunc>::iterator it = gSniffers.begin();

         it != gSniffers.end(); ++it) {

bool Sniffer::sniff(

        DataSource *source, String8 *mimeType, float *confidence, sp<AMessage> *meta) {



    *mimeType = "";

    *confidence = 0.0f;

    meta->clear();



    Mutex::Autolock autoLock(mSnifferMutex);

    for (List<SnifferFunc>::iterator it = mSniffers.begin();

         it != mSniffers.end(); ++it) {

        String8 newMimeType;

        float newConfidence;

        sp<AMessage> newMeta;

        if ((*it)(this, &newMimeType, &newConfidence, &newMeta)) {

        if ((*it)(source, &newMimeType, &newConfidence, &newMeta)) {

            if (newConfidence > *confidence) {

                *mimeType = newMimeType;

                *confidence = newConfidence;
@@ -143,44 +156,39 @@ bool DataSource::sniff( 
    return *confidence > 0.0;

}



// static

void DataSource::RegisterSniffer_l(SnifferFunc func) {

    for (List<SnifferFunc>::iterator it = gSniffers.begin();

         it != gSniffers.end(); ++it) {

void Sniffer::registerSniffer_l(SnifferFunc func) {



    for (List<SnifferFunc>::iterator it = mSniffers.begin();

         it != mSniffers.end(); ++it) {

        if (*it == func) {

            return;

        }

    }



    gSniffers.push_back(func);

    mSniffers.push_back(func);

}



// static

void DataSource::RegisterDefaultSniffers() {

    Mutex::Autolock autoLock(gSnifferMutex);

    if (gSniffersRegistered) {

        return;

    }

void Sniffer::registerDefaultSniffers() {

    Mutex::Autolock autoLock(mSnifferMutex);



    RegisterSniffer_l(SniffMPEG4);

    RegisterSniffer_l(SniffMatroska);

    RegisterSniffer_l(SniffOgg);

    RegisterSniffer_l(SniffWAV);

    RegisterSniffer_l(SniffFLAC);

    RegisterSniffer_l(SniffAMR);

    RegisterSniffer_l(SniffMPEG2TS);

    RegisterSniffer_l(SniffMP3);

    RegisterSniffer_l(SniffAAC);

    RegisterSniffer_l(SniffMPEG2PS);

    RegisterSniffer_l(SniffWVM);

    RegisterSniffer_l(ExtendedExtractor::Sniff);

    registerSniffer_l(SniffMPEG4);

    registerSniffer_l(SniffMatroska);

    registerSniffer_l(SniffOgg);

    registerSniffer_l(SniffWAV);

    registerSniffer_l(SniffFLAC);

    registerSniffer_l(SniffAMR);

    registerSniffer_l(SniffMPEG2TS);

    registerSniffer_l(SniffMP3);

    registerSniffer_l(SniffAAC);

    registerSniffer_l(SniffMPEG2PS);

    registerSniffer_l(SniffWVM);

    registerSniffer_l(ExtendedExtractor::Sniff);



    char value[PROPERTY_VALUE_MAX];

    if (property_get("drm.service.enabled", value, NULL)

            && (!strcmp(value, "1") || !strcasecmp(value, "true"))) {

        RegisterSniffer_l(SniffDRM);

        registerSniffer_l(SniffDRM);

    }

    gSniffersRegistered = true;

}



// static