Merge "Fix memory leaks in mediaanalytics" (f7902c01) · Commits · e / os / android_frameworks_av

services/mediaanalytics/statsd_audiopolicy.cpp

+18 −26

Original line number	Diff line number	Diff line
		@@ -60,14 +60,14 @@ bool statsd_audiopolicy(MediaAnalyticsItem *item)
		metrics_proto.set_status(status);
		}
		//string char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
		char *rqst_src = NULL;
		if (item->getCString("android.media.audiopolicy.rqst.src", &rqst_src)) {
		metrics_proto.set_request_source(rqst_src);
		std::string rqst_src;
		if (item->getString("android.media.audiopolicy.rqst.src", &rqst_src)) {
		metrics_proto.set_request_source(std::move(rqst_src));
		}
		//string char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
		char *rqst_pkg = NULL;
		if (item->getCString("android.media.audiopolicy.rqst.pkg", &rqst_pkg)) {
		metrics_proto.set_request_package(rqst_pkg);
		std::string rqst_pkg;
		if (item->getString("android.media.audiopolicy.rqst.pkg", &rqst_pkg)) {
		metrics_proto.set_request_package(std::move(rqst_pkg));
		}
		//int32 char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
		int32_t rqst_session = -1;
		@@ -75,20 +75,20 @@ bool statsd_audiopolicy(MediaAnalyticsItem *item)
		metrics_proto.set_request_session(rqst_session);
		}
		//string char kAudioPolicyRqstDevice[] = "android.media.audiopolicy.rqst.device";
		char *rqst_device = NULL;
		if (item->getCString("android.media.audiopolicy.rqst.device", &rqst_device)) {
		metrics_proto.set_request_device(rqst_device);
		std::string rqst_device;
		if (item->getString("android.media.audiopolicy.rqst.device", &rqst_device)) {
		metrics_proto.set_request_device(std::move(rqst_device));
		}

		//string char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
		char *active_src = NULL;
		if (item->getCString("android.media.audiopolicy.active.src", &active_src)) {
		metrics_proto.set_active_source(active_src);
		std::string active_src;
		if (item->getString("android.media.audiopolicy.active.src", &active_src)) {
		metrics_proto.set_active_source(std::move(active_src));
		}
		//string char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
		char *active_pkg = NULL;
		if (item->getCString("android.media.audiopolicy.active.pkg", &active_pkg)) {
		metrics_proto.set_active_package(active_pkg);
		std::string active_pkg;
		if (item->getString("android.media.audiopolicy.active.pkg", &active_pkg)) {
		metrics_proto.set_active_package(std::move(active_pkg));
		}
		//int32 char kAudioPolicyActiveSession[] = "android.media.audiopolicy.active.session";
		int32_t active_session = -1;
		@@ -96,9 +96,9 @@ bool statsd_audiopolicy(MediaAnalyticsItem *item)
		metrics_proto.set_active_session(active_session);
		}
		//string char kAudioPolicyActiveDevice[] = "android.media.audiopolicy.active.device";
		char *active_device = NULL;
		if (item->getCString("android.media.audiopolicy.active.device", &active_device)) {
		metrics_proto.set_active_device(active_device);
		std::string active_device;
		if (item->getString("android.media.audiopolicy.active.device", &active_device)) {
		metrics_proto.set_active_device(std::move(active_device));
		}


		@@ -119,14 +119,6 @@ bool statsd_audiopolicy(MediaAnalyticsItem *item)
		ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
		}

		// must free the strings that we were given
		free(rqst_src);
		free(rqst_pkg);
		free(rqst_device);
		free(active_src);
		free(active_pkg);
		free(active_device);

		return true;
		}

services/mediaanalytics/statsd_audiorecord.cpp

+14 −20

Original line number	Diff line number	Diff line
		@@ -54,14 +54,14 @@ bool statsd_audiorecord(MediaAnalyticsItem *item)

		// flesh out the protobuf we'll hand off with our data
		//
		char *encoding = NULL;
		if (item->getCString("android.media.audiorecord.encoding", &encoding)) {
		metrics_proto.set_encoding(encoding);
		std::string encoding;
		if (item->getString("android.media.audiorecord.encoding", &encoding)) {
		metrics_proto.set_encoding(std::move(encoding));
		}

		char *source = NULL;
		if (item->getCString("android.media.audiorecord.source", &source)) {
		metrics_proto.set_source(source);
		std::string source;
		if (item->getString("android.media.audiorecord.source", &source)) {
		metrics_proto.set_source(std::move(source));
		}

		int32_t latency = -1;
		@@ -101,11 +101,11 @@ bool statsd_audiorecord(MediaAnalyticsItem *item)
		metrics_proto.set_error_code(errcode);
		}

		char *errfunc = NULL;
		if (item->getCString("android.media.audiorecord.errfunc", &errfunc)) {
		metrics_proto.set_error_function(errfunc);
		} else if (item->getCString("android.media.audiorecord.lastError.at", &errfunc)) {
		metrics_proto.set_error_function(errfunc);
		std::string errfunc;
		if (item->getString("android.media.audiorecord.errfunc", &errfunc)) {
		metrics_proto.set_error_function(std::move(errfunc));
		} else if (item->getString("android.media.audiorecord.lastError.at", &errfunc)) {
		metrics_proto.set_error_function(std::move(errfunc));
		}

		// portId (int32)
		@@ -119,9 +119,9 @@ bool statsd_audiorecord(MediaAnalyticsItem *item)
		metrics_proto.set_frame_count(frameCount);
		}
		// attributes (string)
		char *attributes = NULL;
		if (item->getCString("android.media.audiorecord.attributes", &attributes)) {
		metrics_proto.set_attributes(attributes);
		std::string attributes;
		if (item->getString("android.media.audiorecord.attributes", &attributes)) {
		metrics_proto.set_attributes(std::move(attributes));
		}
		// channelMask (int64)
		int64_t channelMask = -1;
		@@ -152,12 +152,6 @@ bool statsd_audiorecord(MediaAnalyticsItem *item)
		ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
		}

		// must free the strings that we were given
		free(encoding);
		free(source);
		free(errfunc);
		free(attributes);

		return true;
		}

services/mediaanalytics/statsd_audiothread.cpp

+24 −34

Original line number	Diff line number	Diff line
		@@ -56,9 +56,9 @@ bool statsd_audiothread(MediaAnalyticsItem *item)

		// flesh out the protobuf we'll hand off with our data
		//
		char *mytype = NULL;
		if (item->getCString(MM_PREFIX "type", &mytype)) {
		metrics_proto.set_type(mytype);
		std::string mytype;
		if (item->getString(MM_PREFIX "type", &mytype)) {
		metrics_proto.set_type(std::move(mytype));
		}
		int32_t framecount = -1;
		if (item->getInt32(MM_PREFIX "framecount", &framecount)) {
		@@ -68,17 +68,17 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
		if (item->getInt32(MM_PREFIX "samplerate", &samplerate)) {
		metrics_proto.set_samplerate(samplerate);
		}
		char *workhist = NULL;
		if (item->getCString(MM_PREFIX "workMs.hist", &workhist)) {
		metrics_proto.set_work_millis_hist(workhist);
		std::string workhist;
		if (item->getString(MM_PREFIX "workMs.hist", &workhist)) {
		metrics_proto.set_work_millis_hist(std::move(workhist));
		}
		char *latencyhist = NULL;
		if (item->getCString(MM_PREFIX "latencyMs.hist", &latencyhist)) {
		metrics_proto.set_latency_millis_hist(latencyhist);
		std::string latencyhist;
		if (item->getString(MM_PREFIX "latencyMs.hist", &latencyhist)) {
		metrics_proto.set_latency_millis_hist(std::move(latencyhist));
		}
		char *warmuphist = NULL;
		if (item->getCString(MM_PREFIX "warmupMs.hist", &warmuphist)) {
		metrics_proto.set_warmup_millis_hist(warmuphist);
		std::string warmuphist;
		if (item->getString(MM_PREFIX "warmupMs.hist", &warmuphist)) {
		metrics_proto.set_warmup_millis_hist(std::move(warmuphist));
		}
		int64_t underruns = -1;
		if (item->getInt64(MM_PREFIX "underruns", &underruns)) {
		@@ -108,9 +108,9 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
		metrics_proto.set_port_id(port_id);
		}
		// item->setCString(MM_PREFIX "type", threadTypeToString(mType));
		char *type = NULL;
		if (item->getCString(MM_PREFIX "type", &type)) {
		metrics_proto.set_type(type);
		std::string type;
		if (item->getString(MM_PREFIX "type", &type)) {
		metrics_proto.set_type(std::move(type));
		}
		// item->setInt32(MM_PREFIX "sampleRate", (int32_t)mSampleRate);
		int32_t sample_rate = -1;
		@@ -123,9 +123,9 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
		metrics_proto.set_channel_mask(channel_mask);
		}
		// item->setCString(MM_PREFIX "encoding", toString(mFormat).c_str());
		char *encoding = NULL;
		if (item->getCString(MM_PREFIX "encoding", &encoding)) {
		metrics_proto.set_encoding(encoding);
		std::string encoding;
		if (item->getString(MM_PREFIX "encoding", &encoding)) {
		metrics_proto.set_encoding(std::move(encoding));
		}
		// item->setInt32(MM_PREFIX "frameCount", (int32_t)mFrameCount);
		int32_t frame_count = -1;
		@@ -133,14 +133,14 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
		metrics_proto.set_frame_count(frame_count);
		}
		// item->setCString(MM_PREFIX "outDevice", toString(mOutDevice).c_str());
		char *outDevice = NULL;
		if (item->getCString(MM_PREFIX "outDevice", &outDevice)) {
		metrics_proto.set_output_device(outDevice);
		std::string outDevice;
		if (item->getString(MM_PREFIX "outDevice", &outDevice)) {
		metrics_proto.set_output_device(std::move(outDevice));
		}
		// item->setCString(MM_PREFIX "inDevice", toString(mInDevice).c_str());
		char *inDevice = NULL;
		if (item->getCString(MM_PREFIX "inDevice", &inDevice)) {
		metrics_proto.set_input_device(inDevice);
		std::string inDevice;
		if (item->getString(MM_PREFIX "inDevice", &inDevice)) {
		metrics_proto.set_input_device(std::move(inDevice));
		}
		// item->setDouble(MM_PREFIX "ioJitterMs.mean", mIoJitterMs.getMean());
		double iojitters_ms_mean = -1;
		@@ -201,16 +201,6 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
		ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
		}

		// must free the strings that we were given
		free(mytype);
		free(workhist);
		free(latencyhist);
		free(warmuphist);
		free(type);
		free(encoding);
		free(inDevice);
		free(outDevice);

		return true;
		}

services/mediaanalytics/statsd_audiotrack.cpp

+15 −22

Original line number	Diff line number	Diff line
		@@ -57,23 +57,23 @@ bool statsd_audiotrack(MediaAnalyticsItem *item)

		// static constexpr char kAudioTrackStreamType[] = "android.media.audiotrack.streamtype";
		// optional string streamType;
		char *streamtype = NULL;
		if (item->getCString("android.media.audiotrack.streamtype", &streamtype)) {
		metrics_proto.set_stream_type(streamtype);
		std::string streamtype;
		if (item->getString("android.media.audiotrack.streamtype", &streamtype)) {
		metrics_proto.set_stream_type(std::move(streamtype));
		}

		// static constexpr char kAudioTrackContentType[] = "android.media.audiotrack.type";
		// optional string contentType;
		char *contenttype = NULL;
		if (item->getCString("android.media.audiotrack.type", &contenttype)) {
		metrics_proto.set_content_type(contenttype);
		std::string contenttype;
		if (item->getString("android.media.audiotrack.type", &contenttype)) {
		metrics_proto.set_content_type(std::move(contenttype));
		}

		// static constexpr char kAudioTrackUsage[] = "android.media.audiotrack.usage";
		// optional string trackUsage;
		char *trackusage = NULL;
		if (item->getCString("android.media.audiotrack.usage", &trackusage)) {
		metrics_proto.set_track_usage(trackusage);
		std::string trackusage;
		if (item->getString("android.media.audiotrack.usage", &trackusage)) {
		metrics_proto.set_track_usage(std::move(trackusage));
		}

		// static constexpr char kAudioTrackSampleRate[] = "android.media.audiotrack.samplerate";
		@@ -111,9 +111,9 @@ bool statsd_audiotrack(MediaAnalyticsItem *item)
		metrics_proto.set_port_id(port_id);
		}
		// encoding (string)
		char *encoding = NULL;
		if (item->getCString("android.media.audiotrack.encoding", &encoding)) {
		metrics_proto.set_encoding(encoding);
		std::string encoding;
		if (item->getString("android.media.audiotrack.encoding", &encoding)) {
		metrics_proto.set_encoding(std::move(encoding));
		}
		// frameCount (int32)
		int32_t frame_count = -1;
		@@ -121,9 +121,9 @@ bool statsd_audiotrack(MediaAnalyticsItem *item)
		metrics_proto.set_frame_count(frame_count);
		}
		// attributes (string)
		char *attributes = NULL;
		if (item->getCString("android.media.audiotrack.attributes", &attributes)) {
		metrics_proto.set_attributes(attributes);
		std::string attributes;
		if (item->getString("android.media.audiotrack.attributes", &attributes)) {
		metrics_proto.set_attributes(std::move(attributes));
		}

		std::string serialized;
		@@ -143,13 +143,6 @@ bool statsd_audiotrack(MediaAnalyticsItem *item)
		ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
		}

		// must free the strings that we were given
		free(streamtype);
		free(contenttype);
		free(trackusage);
		free(encoding);
		free(attributes);

		return true;
		}

services/mediaanalytics/statsd_codec.cpp

+12 −18

Original line number	Diff line number	Diff line
		@@ -55,19 +55,19 @@ bool statsd_codec(MediaAnalyticsItem *item)
		// flesh out the protobuf we'll hand off with our data
		//
		// android.media.mediacodec.codec string
		char *codec = NULL;
		if (item->getCString("android.media.mediacodec.codec", &codec)) {
		metrics_proto.set_codec(codec);
		std::string codec;
		if (item->getString("android.media.mediacodec.codec", &codec)) {
		metrics_proto.set_codec(std::move(codec));
		}
		// android.media.mediacodec.mime string
		char *mime = NULL;
		if (item->getCString("android.media.mediacodec.mime", &mime)) {
		metrics_proto.set_mime(mime);
		std::string mime;
		if (item->getString("android.media.mediacodec.mime", &mime)) {
		metrics_proto.set_mime(std::move(mime));
		}
		// android.media.mediacodec.mode string
		char *mode = NULL;
		if ( item->getCString("android.media.mediacodec.mode", &mode)) {
		metrics_proto.set_mode(mode);
		std::string mode;
		if ( item->getString("android.media.mediacodec.mode", &mode)) {
		metrics_proto.set_mode(std::move(mode));
		}
		// android.media.mediacodec.encoder int32
		int32_t encoder = -1;
		@@ -125,9 +125,9 @@ bool statsd_codec(MediaAnalyticsItem *item)
		metrics_proto.set_error_code(errcode);
		}
		// android.media.mediacodec.errstate string
		char *errstate = NULL;
		if ( item->getCString("android.media.mediacodec.errstate", &errstate)) {
		metrics_proto.set_error_state(errstate);
		std::string errstate;
		if ( item->getString("android.media.mediacodec.errstate", &errstate)) {
		metrics_proto.set_error_state(std::move(errstate));
		}
		// android.media.mediacodec.latency.max int64
		int64_t latency_max = -1;
		@@ -173,12 +173,6 @@ bool statsd_codec(MediaAnalyticsItem *item)
		ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
		}

		// must free the strings that we were given
		free(codec);
		free(mime);
		free(mode);
		free(errstate);

		return true;
		}