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

Commit 33977145 authored by Surajit Podder's avatar Surajit Podder Committed by Steve Kondik
Browse files

DataSource: Remove global variables in DataSource related to sniff 

Removed 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 90044a90

include/media/stagefright/DataSource.h

+35 −6
Original line number Diff line number Diff line
@@ -32,6 +32,39 @@ namespace android { 


struct AMessage;

class String8;

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;



    void registerSnifferPlugin();



    Sniffer(const Sniffer &);

    Sniffer &operator=(const Sniffer &);

};



class DataSource : public RefBase {

public:
@@ -47,7 +80,7 @@ public: 
            const char *uri,

            const KeyedVector<String8, String8> *headers = NULL);



    DataSource() {}

    DataSource() { mSniffer = new Sniffer(); }



    virtual status_t initCheck() const = 0;
@@ -98,13 +131,9 @@ public: 
protected:

    virtual ~DataSource() {}



private:

    static Mutex gSnifferMutex;

    static List<SnifferFunc> gSniffers;

    static bool gSniffersRegistered;

    sp<Sniffer> mSniffer;



    static void RegisterSniffer_l(SnifferFunc func);

    static void RegisterSnifferPlugin();



    DataSource(const DataSource &);

    DataSource &operator=(const DataSource &);

media/libstagefright/DataSource.cpp

+52 −45
Original line number Diff line number Diff line
@@ -125,29 +125,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;
@@ -159,51 +172,45 @@ 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);

#ifdef QCOM_HARDWARE

    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);

#ifdef ENABLE_AV_ENHANCEMENTS

    registerSniffer_l(ExtendedExtractor::Sniff);

#endif

    RegisterSnifferPlugin();

    registerSnifferPlugin();



    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

void DataSource::RegisterSnifferPlugin() {

void Sniffer::registerSnifferPlugin() {

    static void (*getExtractorPlugin)(MediaExtractor::Plugin *) =

            (void (*)(MediaExtractor::Plugin *))loadExtractorPlugin();
@@ -212,7 +219,7 @@ void DataSource::RegisterSnifferPlugin() { 
        getExtractorPlugin(plugin);

    }

    if (plugin->sniff) {

        RegisterSniffer_l(plugin->sniff);

        registerSniffer_l(plugin->sniff);

    }

}