Snap for 5450365 from a24ab5c987af6e14a8e92970630f4ae19091eebd to pi-platform-release (b855638c) · Commits · e / os / android_frameworks_av

media/libmedia/Visualizer.cpp

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

media/libmedia/include/media/Visualizer.h

+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;
		};

media/libstagefright/rtsp/APacketSource.cpp

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

media/libstagefright/xmlparser/MediaCodecsXmlParser.cpp

+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";