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

Commit b855638c authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 5450365 from a24ab5c9 to pi-platform-release

Change-Id: I290d1d4f9a6563149839e8fd2201cc3078ecdfb7
parents a31eb276 a24ab5c9
Loading
Loading
Loading
Loading
+20 −3
Original line number Diff line number Diff line
@@ -56,6 +56,19 @@ Visualizer::~Visualizer()
    setCaptureCallBack(NULL, NULL, 0, 0);
}

void Visualizer::release()
{
    ALOGV("Visualizer::release()");
    setEnabled(false);
    Mutex::Autolock _l(mCaptureLock);

    mCaptureThread.clear();
    mCaptureCallBack = NULL;
    mCaptureCbkUser = NULL;
    mCaptureFlags = 0;
    mCaptureRate = 0;
}

status_t Visualizer::setEnabled(bool enabled)
{
    Mutex::Autolock _l(mCaptureLock);
@@ -115,7 +128,7 @@ status_t Visualizer::setCaptureCallBack(capture_cbk_t cbk, void* user, uint32_t
    mCaptureRate = rate;

    if (cbk != NULL) {
        mCaptureThread = new CaptureThread(*this, rate, ((flags & CAPTURE_CALL_JAVA) != 0));
        mCaptureThread = new CaptureThread(this, rate, ((flags & CAPTURE_CALL_JAVA) != 0));
    }
    ALOGV("setCaptureCallBack() rate: %d thread %p flags 0x%08x",
            rate, mCaptureThread.get(), mCaptureFlags);
@@ -402,7 +415,7 @@ void Visualizer::controlStatusChanged(bool controlGranted) {

//-------------------------------------------------------------------------

Visualizer::CaptureThread::CaptureThread(Visualizer& receiver, uint32_t captureRate,
Visualizer::CaptureThread::CaptureThread(Visualizer* receiver, uint32_t captureRate,
        bool bCanCallJava)
    : Thread(bCanCallJava), mReceiver(receiver)
{
@@ -413,10 +426,14 @@ Visualizer::CaptureThread::CaptureThread(Visualizer& receiver, uint32_t captureR
bool Visualizer::CaptureThread::threadLoop()
{
    ALOGV("CaptureThread %p enter", this);
    sp<Visualizer> receiver = mReceiver.promote();
    if (receiver == NULL) {
        return false;
    }
    while (!exitPending())
    {
        usleep(mSleepTimeUs);
        mReceiver.periodicCapture();
        receiver->periodicCapture();
    }
    ALOGV("CaptureThread %p exiting", this);
    return false;
+3 −2
Original line number Diff line number Diff line
@@ -131,6 +131,7 @@ public:
    // getCaptureSize() but the length of the FFT is half of the size (both parts of the spectrum
    // are returned
    status_t getFft(uint8_t *fft);
    void release();

protected:
    // from IEffectClient
@@ -146,12 +147,12 @@ private:
    class CaptureThread : public Thread
    {
    public:
        CaptureThread(Visualizer& receiver, uint32_t captureRate, bool bCanCallJava = false);
        CaptureThread(Visualizer* visualizer, uint32_t captureRate, bool bCanCallJava = false);

    private:
        friend class Visualizer;
        virtual bool        threadLoop();
        Visualizer& mReceiver;
        wp<Visualizer> mReceiver;
        Mutex       mLock;
        uint32_t mSleepTimeUs;
    };
+2 −2
Original line number Diff line number Diff line
@@ -376,8 +376,8 @@ static sp<ABuffer> MakeMPEG4VideoCodecSpecificData(
    ALOGI("VOL dimensions = %dx%d", *width, *height);

    size_t len1 = config->size() + GetSizeWidth(config->size()) + 1;
    size_t len2 = len1 + GetSizeWidth(len1) + 1 + 13;
    size_t len3 = len2 + GetSizeWidth(len2) + 1 + 3;
    size_t len2 = len1 + GetSizeWidth(len1 + 13) + 1 + 13;
    size_t len3 = len2 + GetSizeWidth(len2 + 3) + 1 + 3;

    sp<ABuffer> csd = new ABuffer(len3);
    uint8_t *dst = csd->data();
+99 −84
Original line number Diff line number Diff line
@@ -91,18 +91,18 @@ bool parseBoolean(const char* s) {
status_t limitFoundMissingAttr(const char* name, const char *attr, bool found = true) {
    ALOGE("limit '%s' with %s'%s' attribute", name,
            (found ? "" : "no "), attr);
    return -EINVAL;
    return BAD_VALUE;
}

status_t limitError(const char* name, const char *msg) {
    ALOGE("limit '%s' %s", name, msg);
    return -EINVAL;
    return BAD_VALUE;
}

status_t limitInvalidAttr(const char* name, const char* attr, const char* value) {
    ALOGE("limit '%s' with invalid '%s' attribute (%s)", name,
            attr, value);
    return -EINVAL;
    return BAD_VALUE;
}

}; // unnamed namespace
@@ -231,12 +231,12 @@ status_t MediaCodecsXmlParser::includeXMLFile(const char **attrs) {
    while (attrs[i] != nullptr) {
        if (strEq(attrs[i], "href")) {
            if (attrs[++i] == nullptr) {
                return -EINVAL;
                return BAD_VALUE;
            }
            href = attrs[i];
        } else {
            ALOGE("includeXMLFile: unrecognized attribute: %s", attrs[i]);
            return -EINVAL;
            return BAD_VALUE;
        }
        ++i;
    }
@@ -251,32 +251,32 @@ status_t MediaCodecsXmlParser::includeXMLFile(const char **attrs) {
            continue;
        }
        ALOGE("invalid include file name: %s", href);
        return -EINVAL;
        return BAD_VALUE;
    }

    std::string filename = href;
    if (filename.compare(0, 13, "media_codecs_") != 0 ||
            filename.compare(filename.size() - 4, 4, ".xml") != 0) {
        ALOGE("invalid include file name: %s", href);
        return -EINVAL;
        return BAD_VALUE;
    }
    filename.insert(0, mHrefBase);

    status_t oldParsingStatus = mParsingStatus;

    parseXMLFile(filename.c_str());
    return mParsingStatus;

    status_t newParsingStatus = mParsingStatus;
    mParsingStatus = oldParsingStatus;
    return newParsingStatus;
}

void MediaCodecsXmlParser::startElementHandler(
        const char *name, const char **attrs) {
    if (mParsingStatus != OK) {
        return;
    }

    bool inType = true;

    if (strEq(name, "Include")) {
        mParsingStatus = includeXMLFile(attrs);
        if (mParsingStatus == OK) {
        if (includeXMLFile(attrs) == OK) {
            mSectionStack.push_back(mCurrentSection);
            mCurrentSection = SECTION_INCLUDE;
        }
@@ -299,7 +299,7 @@ void MediaCodecsXmlParser::startElementHandler(
        case SECTION_SETTINGS:
        {
            if (strEq(name, "Setting")) {
                mParsingStatus = addSettingFromAttributes(attrs);
                (void)addSettingFromAttributes(attrs);
            }
            break;
        }
@@ -307,9 +307,7 @@ void MediaCodecsXmlParser::startElementHandler(
        case SECTION_DECODERS:
        {
            if (strEq(name, "MediaCodec")) {
                mParsingStatus =
                    addMediaCodecFromAttributes(false /* encoder */, attrs);

                (void)addMediaCodecFromAttributes(false /* encoder */, attrs);
                mCurrentSection = SECTION_DECODER;
            }
            break;
@@ -318,9 +316,7 @@ void MediaCodecsXmlParser::startElementHandler(
        case SECTION_ENCODERS:
        {
            if (strEq(name, "MediaCodec")) {
                mParsingStatus =
                    addMediaCodecFromAttributes(true /* encoder */, attrs);

                (void)addMediaCodecFromAttributes(true /* encoder */, attrs);
                mCurrentSection = SECTION_ENCODER;
            }
            break;
@@ -330,9 +326,9 @@ void MediaCodecsXmlParser::startElementHandler(
        case SECTION_ENCODER:
        {
            if (strEq(name, "Quirk")) {
                mParsingStatus = addQuirk(attrs);
                (void)addQuirk(attrs);
            } else if (strEq(name, "Type")) {
                mParsingStatus = addTypeFromAttributes(attrs,
                (void)addTypeFromAttributes(attrs,
                        (mCurrentSection == SECTION_ENCODER));
                mCurrentSection =
                        (mCurrentSection == SECTION_DECODER ?
@@ -352,9 +348,9 @@ void MediaCodecsXmlParser::startElementHandler(
                    (strEq(name, "Limit") || strEq(name, "Feature"))) {
                ALOGW("ignoring %s specified outside of a Type", name);
            } else if (strEq(name, "Limit")) {
                mParsingStatus = addLimit(attrs);
                (void)addLimit(attrs);
            } else if (strEq(name, "Feature")) {
                mParsingStatus = addFeature(attrs);
                (void)addFeature(attrs);
            }
            break;
        }
@@ -366,10 +362,6 @@ void MediaCodecsXmlParser::startElementHandler(
}

void MediaCodecsXmlParser::endElementHandler(const char *name) {
    if (mParsingStatus != OK) {
        return;
    }

    switch (mCurrentSection) {
        case SECTION_SETTINGS:
        {
@@ -451,31 +443,31 @@ status_t MediaCodecsXmlParser::addSettingFromAttributes(const char **attrs) {
        if (strEq(attrs[i], "name")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addSettingFromAttributes: name is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            name = attrs[i];
        } else if (strEq(attrs[i], "value")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addSettingFromAttributes: value is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            value = attrs[i];
        } else if (strEq(attrs[i], "update")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addSettingFromAttributes: update is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            update = attrs[i];
        } else {
            ALOGE("addSettingFromAttributes: unrecognized attribute: %s", attrs[i]);
            return -EINVAL;
            return BAD_VALUE;
        }
        ++i;
    }

    if (name == nullptr || value == nullptr) {
        ALOGE("addSettingFromAttributes: name or value unspecified");
        return -EINVAL;
        return BAD_VALUE;
    }

    // Boolean values are converted to "0" or "1".
@@ -488,7 +480,7 @@ status_t MediaCodecsXmlParser::addSettingFromAttributes(const char **attrs) {
    if (attribute == mServiceAttributeMap.end()) { // New attribute name
        if (mUpdate) {
            ALOGE("addSettingFromAttributes: updating non-existing setting");
            return -EINVAL;
            return BAD_VALUE;
        }
        mServiceAttributeMap.insert(Attribute(name, value));
    } else { // Existing attribute name
@@ -512,39 +504,40 @@ status_t MediaCodecsXmlParser::addMediaCodecFromAttributes(
        if (strEq(attrs[i], "name")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addMediaCodecFromAttributes: name is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            name = attrs[i];
        } else if (strEq(attrs[i], "type")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addMediaCodecFromAttributes: type is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            type = attrs[i];
        } else if (strEq(attrs[i], "update")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addMediaCodecFromAttributes: update is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            update = attrs[i];
        } else {
            ALOGE("addMediaCodecFromAttributes: unrecognized attribute: %s", attrs[i]);
            return -EINVAL;
            return BAD_VALUE;
        }
        ++i;
    }

    if (name == nullptr) {
        ALOGE("addMediaCodecFromAttributes: name not found");
        return -EINVAL;
        return BAD_VALUE;
    }

    mUpdate = (update != nullptr) && parseBoolean(update);
    mCurrentCodec = mCodecMap.find(name);
    if (mCurrentCodec == mCodecMap.end()) { // New codec name
        if (mUpdate) {
            ALOGE("addMediaCodecFromAttributes: updating non-existing codec");
            return -EINVAL;
            ALOGW("addMediaCodecFromAttributes: cannot update "
                  "non-existing codec \"%s\".", name);
            return BAD_VALUE;
        }
        // Create a new codec in mCodecMap
        mCurrentCodec = mCodecMap.insert(
@@ -559,18 +552,26 @@ status_t MediaCodecsXmlParser::addMediaCodecFromAttributes(
        mCurrentCodec->second.order = mCodecCounter++;
    } else { // Existing codec name
        if (!mUpdate) {
            ALOGE("addMediaCodecFromAttributes: adding existing codec");
            return -EINVAL;
            ALOGW("addMediaCodecFromAttributes: trying to add "
                  "existing codec \"%s\"", name);
            return ALREADY_EXISTS;
        }
        if (type != nullptr) {
            mCurrentType = mCurrentCodec->second.typeMap.find(type);
            if (mCurrentType == mCurrentCodec->second.typeMap.end()) {
                ALOGE("addMediaCodecFromAttributes: updating non-existing type");
                return -EINVAL;
                ALOGE("addMediaCodecFromAttributes: cannot update "
                      "non-existing type \"%s\" for codec \"%s\"",
                        type, name);
                return BAD_VALUE;
            }
        } else {
            // This should happen only when the codec has at most one type.
            mCurrentType = mCurrentCodec->second.typeMap.begin();
            if (mCurrentType == mCurrentCodec->second.typeMap.end()) {
                ALOGE("addMediaCodecFromAttributes: cannot update "
                      "codec \"%s\" without type specified", name);
                return BAD_VALUE;
            }
        }
    }

@@ -578,6 +579,10 @@ status_t MediaCodecsXmlParser::addMediaCodecFromAttributes(
}

status_t MediaCodecsXmlParser::addQuirk(const char **attrs) {
    if (mCurrentCodec == mCodecMap.end()) {
        return BAD_VALUE;
    }

    const char *name = nullptr;

    size_t i = 0;
@@ -585,19 +590,19 @@ status_t MediaCodecsXmlParser::addQuirk(const char **attrs) {
        if (strEq(attrs[i], "name")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addQuirk: name is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            name = attrs[i];
        } else {
            ALOGE("addQuirk: unrecognized attribute: %s", attrs[i]);
            return -EINVAL;
            return BAD_VALUE;
        }
        ++i;
    }

    if (name == nullptr) {
        ALOGE("addQuirk: name not found");
        return -EINVAL;
        return BAD_VALUE;
    }

    mCurrentCodec->second.quirkSet.emplace(name);
@@ -605,6 +610,10 @@ status_t MediaCodecsXmlParser::addQuirk(const char **attrs) {
}

status_t MediaCodecsXmlParser::addTypeFromAttributes(const char **attrs, bool encoder) {
    if (mCurrentCodec == mCodecMap.end()) {
        return BAD_VALUE;
    }

    const char *name = nullptr;
    const char *update = nullptr;

@@ -613,42 +622,51 @@ status_t MediaCodecsXmlParser::addTypeFromAttributes(const char **attrs, bool en
        if (strEq(attrs[i], "name")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addTypeFromAttributes: name is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            name = attrs[i];
        } else if (strEq(attrs[i], "update")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addTypeFromAttributes: update is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            update = attrs[i];
        } else {
            ALOGE("addTypeFromAttributes: unrecognized attribute: %s", attrs[i]);
            return -EINVAL;
            return BAD_VALUE;
        }
        ++i;
    }

    if (name == nullptr) {
        return -EINVAL;
        return BAD_VALUE;
    }

    mCurrentCodec->second.isEncoder = encoder;
    mCurrentType = mCurrentCodec->second.typeMap.find(name);
    if (!mUpdate) {
        if (mCurrentType != mCurrentCodec->second.typeMap.end()) {
            ALOGE("addTypeFromAttributes: re-defining existing type without update");
            return -EINVAL;
            ALOGW("addTypeFromAttributes: trying to update "
                  "existing type \"%s\"", name);
            return ALREADY_EXISTS;
        }
        mCurrentType = mCurrentCodec->second.typeMap.insert(
                Type(name, AttributeMap())).first;
    } else if (mCurrentType == mCurrentCodec->second.typeMap.end()) {
        ALOGE("addTypeFromAttributes: updating non-existing type");
        return BAD_VALUE;
    }
    return OK;
}

status_t MediaCodecsXmlParser::addLimit(const char **attrs) {
    if (mCurrentCodec == mCodecMap.end()) {
        return BAD_VALUE;
    }
    if (mCurrentType == mCurrentCodec->second.typeMap.end()) {
        return BAD_VALUE;
    }

    const char* a_name = nullptr;
    const char* a_default = nullptr;
    const char* a_in = nullptr;
@@ -664,78 +682,73 @@ status_t MediaCodecsXmlParser::addLimit(const char **attrs) {
        if (strEq(attrs[i], "name")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: name is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_name = attrs[i];
        } else if (strEq(attrs[i], "default")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: default is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_default = attrs[i];
        } else if (strEq(attrs[i], "in")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: in is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_in = attrs[i];
        } else if (strEq(attrs[i], "max")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: max is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_max = attrs[i];
        } else if (strEq(attrs[i], "min")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: min is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_min = attrs[i];
        } else if (strEq(attrs[i], "range")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: range is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_range = attrs[i];
        } else if (strEq(attrs[i], "ranges")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: ranges is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_ranges = attrs[i];
        } else if (strEq(attrs[i], "scale")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: scale is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_scale = attrs[i];
        } else if (strEq(attrs[i], "value")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addLimit: value is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            a_value = attrs[i];
        } else {
            ALOGE("addLimit: unrecognized limit: %s", attrs[i]);
            return -EINVAL;
            return BAD_VALUE;
        }
        ++i;
    }

    if (a_name == nullptr) {
        ALOGE("limit with no 'name' attribute");
        return -EINVAL;
        return BAD_VALUE;
    }

    // size, blocks, bitrate, frame-rate, blocks-per-second, aspect-ratio,
    // measured-frame-rate, measured-blocks-per-second: range
    // quality: range + default + [scale]
    // complexity: range + default
    if (mCurrentType == mCurrentCodec->second.typeMap.end()) {
        ALOGW("ignoring null type");
        return OK;
    }

    std::string range;
    if (strEq(a_name, "aspect-ratio") ||
            strEq(a_name, "bitrate") ||
@@ -879,6 +892,13 @@ status_t MediaCodecsXmlParser::addLimit(const char **attrs) {
}

status_t MediaCodecsXmlParser::addFeature(const char **attrs) {
    if (mCurrentCodec == mCodecMap.end()) {
        return BAD_VALUE;
    }
    if (mCurrentType == mCurrentCodec->second.typeMap.end()) {
        return BAD_VALUE;
    }

    size_t i = 0;
    const char *name = nullptr;
    int32_t optional = -1;
@@ -889,30 +909,30 @@ status_t MediaCodecsXmlParser::addFeature(const char **attrs) {
        if (strEq(attrs[i], "name")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addFeature: name is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            name = attrs[i];
        } else if (strEq(attrs[i], "optional")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addFeature: optional is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            optional = parseBoolean(attrs[i]) ? 1 : 0;
        } else if (strEq(attrs[i], "required")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addFeature: required is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            required = parseBoolean(attrs[i]) ? 1 : 0;
        } else if (strEq(attrs[i], "value")) {
            if (attrs[++i] == nullptr) {
                ALOGE("addFeature: value is null");
                return -EINVAL;
                return BAD_VALUE;
            }
            value = attrs[i];
        } else {
            ALOGE("addFeature: unrecognized attribute: %s", attrs[i]);
            return -EINVAL;
            return BAD_VALUE;
        }
        ++i;
    }
@@ -920,23 +940,18 @@ status_t MediaCodecsXmlParser::addFeature(const char **attrs) {
    // Every feature must have a name.
    if (name == nullptr) {
        ALOGE("feature with no 'name' attribute");
        return -EINVAL;
    }

    if (mCurrentType == mCurrentCodec->second.typeMap.end()) {
        ALOGW("ignoring null type");
        return OK;
        return BAD_VALUE;
    }

    if ((optional != -1) || (required != -1)) {
        if (optional == required) {
            ALOGE("feature '%s' is both/neither optional and required", name);
            return -EINVAL;
            return BAD_VALUE;
        }
        if ((optional == 1) || (required == 1)) {
            if (value != nullptr) {
                ALOGE("feature '%s' cannot have extra 'value'", name);
                return -EINVAL;
                return BAD_VALUE;
            }
            mCurrentType->second[std::string("feature-") + name] =
                    optional == 1 ? "0" : "1";