Merge "NBLog: add retroactive dump and standard printing format"
diff --git a/media/audioserver/Android.mk b/media/audioserver/Android.mk
index ddf98f6..1ca0fdc 100644
--- a/media/audioserver/Android.mk
+++ b/media/audioserver/Android.mk
@@ -22,9 +22,6 @@
libsoundtriggerservice \
libutils
-LOCAL_STATIC_LIBRARIES := \
- libjsoncpp
-
# TODO oboeservice is the old folder name for aaudioservice. It will be changed.
LOCAL_C_INCLUDES := \
frameworks/av/services/audioflinger \
@@ -58,13 +55,9 @@
# both to build both 32 bit and 64 bit libraries,
# and use primary target architecture (32 or 64) for audioserver.
# first to build libraries and audioserver for the primary target architecture only.
-# <empty> to build both 32 and 64 bit libraries and 32 bit audioserver.
+# <empty> to build both 32 and 64 bit libraries and primary target audioserver.
-ifeq ($(strip $(AUDIOSERVER_MULTILIB)),)
-LOCAL_MULTILIB := 32
-else
LOCAL_MULTILIB := $(AUDIOSERVER_MULTILIB)
-endif
LOCAL_MODULE := audioserver
diff --git a/media/libmediaplayer2/Android.bp b/media/libmediaplayer2/Android.bp
index 0672ca9..e30da85 100644
--- a/media/libmediaplayer2/Android.bp
+++ b/media/libmediaplayer2/Android.bp
@@ -8,8 +8,6 @@
name: "libmediaplayer2",
srcs: [
- "JAudioTrack.cpp",
- "JavaVMHelper.cpp",
"MediaPlayer2AudioOutput.cpp",
"mediaplayer2.cpp",
],
@@ -84,3 +82,55 @@
},
},
}
+
+cc_library {
+ name: "libmedia2_jni_core",
+
+ srcs: [
+ "JavaVMHelper.cpp",
+ "JAudioTrack.cpp",
+ "JMedia2HTTPService.cpp",
+ "JMedia2HTTPConnection.cpp",
+ ],
+
+ shared_libs: [
+ "android.hidl.token@1.0-utils",
+ "liblog",
+ "libcutils",
+ "libutils",
+ "libbinder",
+ "libstagefright_foundation",
+ "libmediaextractor",
+ "libdl",
+ "libaudioutils",
+ "libaudioclient",
+ "libnativehelper",
+ ],
+
+ include_dirs: [
+ "frameworks/av/media/libmedia/include",
+ "frameworks/base/core/jni",
+ ],
+
+ export_include_dirs: [
+ "include",
+ ],
+
+ cflags: [
+ "-Werror",
+ "-Wno-error=deprecated-declarations",
+ "-Wall",
+ ],
+
+ sanitize: {
+ misc_undefined: [
+ "unsigned-integer-overflow",
+ "signed-integer-overflow",
+ ],
+ cfi: true,
+ diag: {
+ cfi: true,
+ },
+ },
+
+}
diff --git a/media/libmediaplayer2/JMedia2HTTPConnection.cpp b/media/libmediaplayer2/JMedia2HTTPConnection.cpp
new file mode 100644
index 0000000..d264a7f
--- /dev/null
+++ b/media/libmediaplayer2/JMedia2HTTPConnection.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2017, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "JMedia2HTTPConnection"
+#include <utils/Log.h>
+
+#include <mediaplayer2/JavaVMHelper.h>
+#include <mediaplayer2/JMedia2HTTPConnection.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <nativehelper/ScopedLocalRef.h>
+
+#include "log/log.h"
+#include "jni.h"
+#include <nativehelper/JNIHelp.h>
+
+namespace android {
+
+static const size_t kBufferSize = 32768;
+
+JMedia2HTTPConnection::JMedia2HTTPConnection(JNIEnv *env, jobject thiz) {
+ mMedia2HTTPConnectionObj = env->NewGlobalRef(thiz);
+ CHECK(mMedia2HTTPConnectionObj != NULL);
+
+ ScopedLocalRef<jclass> media2HTTPConnectionClass(
+ env, env->GetObjectClass(mMedia2HTTPConnectionObj));
+ CHECK(media2HTTPConnectionClass.get() != NULL);
+
+ mConnectMethod = env->GetMethodID(
+ media2HTTPConnectionClass.get(),
+ "connect",
+ "(Ljava/lang/String;Ljava/lang/String;)Z");
+ CHECK(mConnectMethod != NULL);
+
+ mDisconnectMethod = env->GetMethodID(
+ media2HTTPConnectionClass.get(),
+ "disconnect",
+ "()V");
+ CHECK(mDisconnectMethod != NULL);
+
+ mReadAtMethod = env->GetMethodID(
+ media2HTTPConnectionClass.get(),
+ "readAt",
+ "(J[BI)I");
+ CHECK(mReadAtMethod != NULL);
+
+ mGetSizeMethod = env->GetMethodID(
+ media2HTTPConnectionClass.get(),
+ "getSize",
+ "()J");
+ CHECK(mGetSizeMethod != NULL);
+
+ mGetMIMETypeMethod = env->GetMethodID(
+ media2HTTPConnectionClass.get(),
+ "getMIMEType",
+ "()Ljava/lang/String;");
+ CHECK(mGetMIMETypeMethod != NULL);
+
+ mGetUriMethod = env->GetMethodID(
+ media2HTTPConnectionClass.get(),
+ "getUri",
+ "()Ljava/lang/String;");
+ CHECK(mGetUriMethod != NULL);
+
+ ScopedLocalRef<jbyteArray> tmp(
+ env, env->NewByteArray(kBufferSize));
+ mByteArrayObj = (jbyteArray)env->NewGlobalRef(tmp.get());
+ CHECK(mByteArrayObj != NULL);
+}
+
+JMedia2HTTPConnection::~JMedia2HTTPConnection() {
+ JNIEnv *env = JavaVMHelper::getJNIEnv();
+ env->DeleteGlobalRef(mMedia2HTTPConnectionObj);
+ env->DeleteGlobalRef(mByteArrayObj);
+}
+
+bool JMedia2HTTPConnection::connect(
+ const char *uri, const KeyedVector<String8, String8> *headers) {
+ String8 tmp("");
+ if (headers != NULL) {
+ for (size_t i = 0; i < headers->size(); ++i) {
+ tmp.append(headers->keyAt(i));
+ tmp.append(String8(": "));
+ tmp.append(headers->valueAt(i));
+ tmp.append(String8("\r\n"));
+ }
+ }
+
+ JNIEnv* env = JavaVMHelper::getJNIEnv();
+ jstring juri = env->NewStringUTF(uri);
+ jstring jheaders = env->NewStringUTF(tmp.string());
+
+ jboolean ret =
+ env->CallBooleanMethod(mMedia2HTTPConnectionObj, mConnectMethod, juri, jheaders);
+
+ env->DeleteLocalRef(juri);
+ env->DeleteLocalRef(jheaders);
+
+ return (bool)ret;
+}
+
+void JMedia2HTTPConnection::disconnect() {
+ JNIEnv* env = JavaVMHelper::getJNIEnv();
+ env->CallVoidMethod(mMedia2HTTPConnectionObj, mDisconnectMethod);
+}
+
+ssize_t JMedia2HTTPConnection::readAt(off64_t offset, void *data, size_t size) {
+ JNIEnv* env = JavaVMHelper::getJNIEnv();
+
+ if (size > kBufferSize) {
+ size = kBufferSize;
+ }
+
+ jint n = env->CallIntMethod(
+ mMedia2HTTPConnectionObj, mReadAtMethod, (jlong)offset, mByteArrayObj, (jint)size);
+
+ if (n > 0) {
+ env->GetByteArrayRegion(
+ mByteArrayObj,
+ 0,
+ n,
+ (jbyte *)data);
+ }
+
+ return n;
+}
+
+off64_t JMedia2HTTPConnection::getSize() {
+ JNIEnv* env = JavaVMHelper::getJNIEnv();
+ return (off64_t)(env->CallLongMethod(mMedia2HTTPConnectionObj, mGetSizeMethod));
+}
+
+status_t JMedia2HTTPConnection::getMIMEType(String8 *mimeType) {
+ JNIEnv* env = JavaVMHelper::getJNIEnv();
+ jstring jmime = (jstring)env->CallObjectMethod(mMedia2HTTPConnectionObj, mGetMIMETypeMethod);
+ jboolean flag = env->ExceptionCheck();
+ if (flag) {
+ env->ExceptionClear();
+ return UNKNOWN_ERROR;
+ }
+
+ const char *str = env->GetStringUTFChars(jmime, 0);
+ if (str != NULL) {
+ *mimeType = String8(str);
+ } else {
+ *mimeType = "application/octet-stream";
+ }
+ env->ReleaseStringUTFChars(jmime, str);
+ return OK;
+}
+
+status_t JMedia2HTTPConnection::getUri(String8 *uri) {
+ JNIEnv* env = JavaVMHelper::getJNIEnv();
+ jstring juri = (jstring)env->CallObjectMethod(mMedia2HTTPConnectionObj, mGetUriMethod);
+ jboolean flag = env->ExceptionCheck();
+ if (flag) {
+ env->ExceptionClear();
+ return UNKNOWN_ERROR;
+ }
+
+ const char *str = env->GetStringUTFChars(juri, 0);
+ *uri = String8(str);
+ env->ReleaseStringUTFChars(juri, str);
+ return OK;
+}
+
+} // namespace android
diff --git a/media/libmediaplayer2/JMedia2HTTPService.cpp b/media/libmediaplayer2/JMedia2HTTPService.cpp
new file mode 100644
index 0000000..264c15d
--- /dev/null
+++ b/media/libmediaplayer2/JMedia2HTTPService.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2017, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "JMedia2HTTPService"
+#include <utils/Log.h>
+
+#include <jni.h>
+
+#include <mediaplayer2/JavaVMHelper.h>
+#include <mediaplayer2/JMedia2HTTPService.h>
+#include <mediaplayer2/JMedia2HTTPConnection.h>
+#include <media/stagefright/foundation/ADebug.h>
+
+#include <nativehelper/JNIHelp.h>
+#include <nativehelper/ScopedLocalRef.h>
+
+namespace android {
+
+JMedia2HTTPService::JMedia2HTTPService(JNIEnv *env, jobject thiz) {
+ mMedia2HTTPServiceObj = env->NewGlobalRef(thiz);
+ CHECK(mMedia2HTTPServiceObj != NULL);
+
+ ScopedLocalRef<jclass> media2HTTPServiceClass(env, env->GetObjectClass(mMedia2HTTPServiceObj));
+ CHECK(media2HTTPServiceClass.get() != NULL);
+
+ mMakeHTTPConnectionMethod = env->GetMethodID(
+ media2HTTPServiceClass.get(),
+ "makeHTTPConnection",
+ "()Landroid/media/Media2HTTPConnection;");
+ CHECK(mMakeHTTPConnectionMethod != NULL);
+}
+
+JMedia2HTTPService::~JMedia2HTTPService() {
+ JNIEnv *env = JavaVMHelper::getJNIEnv();
+ env->DeleteGlobalRef(mMedia2HTTPServiceObj);
+}
+
+sp<MediaHTTPConnection> JMedia2HTTPService::makeHTTPConnection() {
+ JNIEnv* env = JavaVMHelper::getJNIEnv();
+ jobject media2HTTPConnectionObj =
+ env->CallObjectMethod(mMedia2HTTPServiceObj, mMakeHTTPConnectionMethod);
+
+ return new JMedia2HTTPConnection(env, media2HTTPConnectionObj);
+}
+
+} // namespace android
diff --git a/media/libmediaplayer2/include/mediaplayer2/JMedia2HTTPConnection.h b/media/libmediaplayer2/include/mediaplayer2/JMedia2HTTPConnection.h
new file mode 100644
index 0000000..15f7f83
--- /dev/null
+++ b/media/libmediaplayer2/include/mediaplayer2/JMedia2HTTPConnection.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2017, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _J_MEDIA2_HTTP_CONNECTION_H_
+#define _J_MEDIA2_HTTP_CONNECTION_H_
+
+#include "jni.h"
+
+#include <media/MediaHTTPConnection.h>
+#include <media/stagefright/foundation/ABase.h>
+
+namespace android {
+
+struct JMedia2HTTPConnection : public MediaHTTPConnection {
+ JMedia2HTTPConnection(JNIEnv *env, jobject thiz);
+
+ virtual bool connect(
+ const char *uri, const KeyedVector<String8, String8> *headers) override;
+
+ virtual void disconnect() override;
+ virtual ssize_t readAt(off64_t offset, void *data, size_t size) override;
+ virtual off64_t getSize() override;
+ virtual status_t getMIMEType(String8 *mimeType) override;
+ virtual status_t getUri(String8 *uri) override;
+
+protected:
+ virtual ~JMedia2HTTPConnection();
+
+private:
+ jobject mMedia2HTTPConnectionObj;
+ jmethodID mConnectMethod;
+ jmethodID mDisconnectMethod;
+ jmethodID mReadAtMethod;
+ jmethodID mGetSizeMethod;
+ jmethodID mGetMIMETypeMethod;
+ jmethodID mGetUriMethod;
+
+ jbyteArray mByteArrayObj;
+
+ DISALLOW_EVIL_CONSTRUCTORS(JMedia2HTTPConnection);
+};
+
+} // namespace android
+
+#endif // _J_MEDIA2_HTTP_CONNECTION_H_
diff --git a/media/libmediaplayer2/include/mediaplayer2/JMedia2HTTPService.h b/media/libmediaplayer2/include/mediaplayer2/JMedia2HTTPService.h
new file mode 100644
index 0000000..bf61a7f
--- /dev/null
+++ b/media/libmediaplayer2/include/mediaplayer2/JMedia2HTTPService.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2017, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _J_MEDIA2_HTTP_SERVICE_H_
+#define _J_MEDIA2_HTTP_SERVICE_H_
+
+#include <jni.h>
+#include <utils/RefBase.h>
+
+#include <media/MediaHTTPService.h>
+#include <media/MediaHTTPConnection.h>
+#include <media/stagefright/foundation/ABase.h>
+
+namespace android {
+
+struct JMedia2HTTPService : public MediaHTTPService {
+ JMedia2HTTPService(JNIEnv *env, jobject thiz);
+
+ virtual sp<MediaHTTPConnection> makeHTTPConnection() override;
+
+protected:
+ virtual ~JMedia2HTTPService();
+
+private:
+ jobject mMedia2HTTPServiceObj;
+
+ jmethodID mMakeHTTPConnectionMethod;
+
+ DISALLOW_EVIL_CONSTRUCTORS(JMedia2HTTPService);
+};
+
+} // namespace android
+
+#endif // _J_MEDIA2_HTTP_SERVICE_H_
diff --git a/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Types.h b/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Types.h
index 4b0a960..1fe2efa 100644
--- a/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Types.h
+++ b/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Types.h
@@ -34,8 +34,7 @@
MEDIA2_SET_VIDEO_SIZE = 5,
MEDIA2_STARTED = 6,
MEDIA2_PAUSED = 7,
- MEDIA2_STOPPED = 8,
- MEDIA2_SKIPPED = 9,
+ MEDIA2_SKIPPED = 8,
MEDIA2_NOTIFY_TIME = 98,
MEDIA2_TIMED_TEXT = 99,
MEDIA2_ERROR = 100,
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2.cpp b/media/libmediaplayer2/nuplayer2/NuPlayer2.cpp
index 2f90825..e51727b 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2.cpp
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2.cpp
@@ -487,7 +487,7 @@
status_t NuPlayer2::setPlaybackSettings(const AudioPlaybackRate &rate) {
// do some cursory validation of the settings here. audio modes are
// only validated when set on the audiosink.
- if ((rate.mSpeed != 0.f && rate.mSpeed < AUDIO_TIMESTRETCH_SPEED_MIN)
+ if (rate.mSpeed < AUDIO_TIMESTRETCH_SPEED_MIN
|| rate.mSpeed > AUDIO_TIMESTRETCH_SPEED_MAX
|| rate.mPitch < AUDIO_TIMESTRETCH_SPEED_MIN
|| rate.mPitch > AUDIO_TIMESTRETCH_SPEED_MAX) {
@@ -986,8 +986,7 @@
if (mRenderer != NULL) {
// AudioSink allows only 1.f and 0.f for offload mode.
// For other speed, switch to non-offload mode.
- if (mOffloadAudio && ((rate.mSpeed != 0.f && rate.mSpeed != 1.f)
- || rate.mPitch != 1.f)) {
+ if (mOffloadAudio && (rate.mSpeed != 1.f || rate.mPitch != 1.f)) {
int64_t currentPositionUs;
if (getCurrentPosition(¤tPositionUs) != OK) {
currentPositionUs = mPreviousSeekTimeUs;
@@ -1010,36 +1009,15 @@
err = mRenderer->setPlaybackSettings(rate);
}
if (err == OK) {
- if (rate.mSpeed == 0.f) {
- onPause();
- notifyListener(mSrcId, MEDIA2_PAUSED, 0, 0);
- mPausedByClient = true;
- // save all other settings (using non-paused speed)
- // so we can restore them on start
- AudioPlaybackRate newRate = rate;
- newRate.mSpeed = mPlaybackSettings.mSpeed;
- mPlaybackSettings = newRate;
- } else { /* rate.mSpeed != 0.f */
- mPlaybackSettings = rate;
- if (mStarted) {
- // do not resume yet if the source is still buffering
- if (!mPausedForBuffering) {
- onResume();
- }
- } else if (mPrepared) {
- onStart();
- }
+ mPlaybackSettings = rate;
- mPausedByClient = false;
+ if (mVideoDecoder != NULL) {
+ sp<AMessage> params = new AMessage();
+ params->setFloat("playback-speed", mPlaybackSettings.mSpeed);
+ mVideoDecoder->setParameters(params);
}
}
- if (mVideoDecoder != NULL) {
- sp<AMessage> params = new AMessage();
- params->setFloat("playback-speed", mPlaybackSettings.mSpeed);
- mVideoDecoder->setParameters(params);
- }
-
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
@@ -1059,9 +1037,6 @@
// get playback settings used by renderer, as it may be
// slightly off due to audiosink not taking small changes.
mPlaybackSettings = rate;
- if (mPaused) {
- rate.mSpeed = 0.f;
- }
}
sp<AMessage> response = new AMessage;
if (err == OK) {
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
index d3be53a..b02e3f6 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
@@ -352,14 +352,6 @@
// try to update position
int64_t unused;
getCurrentPosition(&unused);
- Mutex::Autolock autoLock(mLock);
- if (rate.mSpeed == 0.f && mState == STATE_RUNNING) {
- mState = STATE_PAUSED;
- } else if (rate.mSpeed != 0.f
- && (mState == STATE_PAUSED
- || mState == STATE_PREPARED)) {
- err = start_l();
- }
}
return err;
}
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Renderer.cpp b/media/libmediaplayer2/nuplayer2/NuPlayer2Renderer.cpp
index a0bd900..021ddde 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Renderer.cpp
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Renderer.cpp
@@ -133,8 +133,7 @@
mUseAudioCallback(false),
mWakeLock(new JWakeLock()) {
CHECK(mediaClock != NULL);
- mPlaybackRate = mPlaybackSettings.mSpeed;
- mMediaClock->setPlaybackRate(mPlaybackRate);
+ mMediaClock->setPlaybackRate(mPlaybackSettings.mSpeed);
}
NuPlayer2::Renderer::~Renderer() {
@@ -190,26 +189,20 @@
}
status_t NuPlayer2::Renderer::onConfigPlayback(const AudioPlaybackRate &rate /* sanitized */) {
- if (rate.mSpeed == 0.f) {
- onPause();
- // don't call audiosink's setPlaybackRate if pausing, as pitch does not
- // have to correspond to the any non-0 speed (e.g old speed). Keep
- // settings nonetheless, using the old speed, in case audiosink changes.
- AudioPlaybackRate newRate = rate;
- newRate.mSpeed = mPlaybackSettings.mSpeed;
- mPlaybackSettings = newRate;
- return OK;
+ if (rate.mSpeed <= 0.f) {
+ ALOGW("playback rate cannot be %f", rate.mSpeed);
+ return BAD_VALUE;
}
if (mAudioSink != NULL && mAudioSink->ready()) {
status_t err = mAudioSink->setPlaybackRate(rate);
if (err != OK) {
+ ALOGW("failed to get playback rate from audio sink, err(%d)", err);
return err;
}
}
mPlaybackSettings = rate;
- mPlaybackRate = rate.mSpeed;
- mMediaClock->setPlaybackRate(mPlaybackRate);
+ mMediaClock->setPlaybackRate(mPlaybackSettings.mSpeed);
return OK;
}
@@ -236,9 +229,6 @@
// get playback settings used by audiosink, as it may be
// slightly off due to audiosink not taking small changes.
mPlaybackSettings = *rate;
- if (mPaused) {
- rate->mSpeed = 0.f;
- }
}
return err;
}
@@ -560,8 +550,8 @@
int64_t delayUs =
mAudioSink->msecsPerFrame()
* numFramesPendingPlayout * 1000ll;
- if (mPlaybackRate > 1.0f) {
- delayUs /= mPlaybackRate;
+ if (mPlaybackSettings.mSpeed > 1.0f) {
+ delayUs /= mPlaybackSettings.mSpeed;
}
// Let's give it more data after about half that time
@@ -1773,7 +1763,7 @@
mAudioSink->setPlaybackRate(mPlaybackSettings);
}
- mMediaClock->setPlaybackRate(mPlaybackRate);
+ mMediaClock->setPlaybackRate(mPlaybackSettings.mSpeed);
if (!mAudioQueue.empty()) {
postDrainAudioQueue_l();
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Renderer.h b/media/libmediaplayer2/nuplayer2/NuPlayer2Renderer.h
index 62cf0d8..305af68 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Renderer.h
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Renderer.h
@@ -167,7 +167,6 @@
int32_t mAudioEOSGeneration;
const sp<MediaClock> mMediaClock;
- float mPlaybackRate; // audio track rate
AudioPlaybackRate mPlaybackSettings;
AVSyncSettings mSyncSettings;
diff --git a/media/libstagefright/StagefrightMetadataRetriever.cpp b/media/libstagefright/StagefrightMetadataRetriever.cpp
index be01a7d..231d540 100644
--- a/media/libstagefright/StagefrightMetadataRetriever.cpp
+++ b/media/libstagefright/StagefrightMetadataRetriever.cpp
@@ -342,15 +342,15 @@
for (size_t i = 0; i < matchingCodecs.size(); ++i) {
const AString &componentName = matchingCodecs[i];
- VideoFrameDecoder decoder(componentName, trackMeta, source);
- if (decoder.init(timeUs, numFrames, option, colorFormat) == OK) {
+ sp<VideoFrameDecoder> decoder = new VideoFrameDecoder(componentName, trackMeta, source);
+ if (decoder->init(timeUs, numFrames, option, colorFormat) == OK) {
if (outFrame != NULL) {
- *outFrame = decoder.extractFrame();
+ *outFrame = decoder->extractFrame();
if (*outFrame != NULL) {
return OK;
}
} else if (outFrames != NULL) {
- status_t err = decoder.extractFrames(outFrames);
+ status_t err = decoder->extractFrames(outFrames);
if (err == OK) {
return OK;
}
diff --git a/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp b/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
index 8912f8a..d534f64 100644
--- a/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
+++ b/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
@@ -548,11 +548,21 @@
// Make sure that the next buffer output does not still
// depend on fragments from the last one decoded.
+ mInputBufferCount = 0;
mNumFramesOutput = 0;
+ if (mState != NULL) {
+ vorbis_dsp_clear(mState);
+ delete mState;
+ mState = NULL;
+ }
+ if (mVi != NULL) {
+ vorbis_info_clear(mVi);
+ delete mVi;
+ mVi = NULL;
+ }
mSawInputEos = false;
mSignalledOutputEos = false;
mNumFramesLeftOnPage = -1;
- vorbis_dsp_restart(mState);
}
}
diff --git a/media/ndk/Android.bp b/media/ndk/Android.bp
index 4a36681..2f298cf 100644
--- a/media/ndk/Android.bp
+++ b/media/ndk/Android.bp
@@ -82,6 +82,7 @@
"libbinder",
"libgui",
"libui",
+ "libmedia2_jni_core",
],
export_include_dirs: ["include"],
diff --git a/media/ndk/NdkMediaDataSource.cpp b/media/ndk/NdkMediaDataSource.cpp
index 9d00e5e..ec2aed6 100644
--- a/media/ndk/NdkMediaDataSource.cpp
+++ b/media/ndk/NdkMediaDataSource.cpp
@@ -23,13 +23,18 @@
#include <jni.h>
#include <unistd.h>
+#include <android_runtime/AndroidRuntime.h>
+#include <android_util_Binder.h>
#include <binder/IServiceManager.h>
#include <cutils/properties.h>
#include <utils/Log.h>
#include <utils/StrongPointer.h>
+#include <media/IMediaHTTPService.h>
#include <media/NdkMediaError.h>
#include <media/NdkMediaDataSource.h>
#include <media/stagefright/InterfaceUtils.h>
+#include <mediaplayer2/JavaVMHelper.h>
+#include <mediaplayer2/JMedia2HTTPService.h>
#include "../../libstagefright/include/HTTPBase.h"
#include "../../libstagefright/include/NuCachedSource2.h"
@@ -92,6 +97,84 @@
}
}
+static sp<MediaHTTPService> createMediaHttpServiceFromJavaObj(JNIEnv *env, jobject obj, int version) {
+ if (obj == NULL) {
+ return NULL;
+ }
+ switch (version) {
+ case 1:
+ return interface_cast<IMediaHTTPService>(ibinderForJavaObject(env, obj));
+ case 2:
+ return new JMedia2HTTPService(env, obj);
+ default:
+ return NULL;
+ }
+}
+
+static sp<MediaHTTPService> createMediaHttpServiceTemplate(
+ JNIEnv *env,
+ const char *uri,
+ const char *clazz,
+ const char *method,
+ const char *signature,
+ int version) {
+ jobject service = NULL;
+ if (env == NULL) {
+ ALOGE("http service must be created from Java thread");
+ return NULL;
+ }
+
+ jclass mediahttpclass = env->FindClass(clazz);
+ if (mediahttpclass == NULL) {
+ ALOGE("can't find Media(2)HttpService");
+ env->ExceptionClear();
+ return NULL;
+ }
+
+ jmethodID mediaHttpCreateMethod = env->GetStaticMethodID(mediahttpclass, method, signature);
+ if (mediaHttpCreateMethod == NULL) {
+ ALOGE("can't find method");
+ env->ExceptionClear();
+ return NULL;
+ }
+
+ jstring juri = env->NewStringUTF(uri);
+
+ service = env->CallStaticObjectMethod(mediahttpclass, mediaHttpCreateMethod, juri);
+ env->DeleteLocalRef(juri);
+
+ env->ExceptionClear();
+ sp<MediaHTTPService> httpService = createMediaHttpServiceFromJavaObj(env, service, version);
+ return httpService;
+
+}
+
+sp<MediaHTTPService> createMediaHttpService(const char *uri, int version) {
+
+ JNIEnv *env;
+ const char *clazz, *method, *signature;
+
+ switch (version) {
+ case 1:
+ env = AndroidRuntime::getJNIEnv();
+ clazz = "android/media/MediaHTTPService";
+ method = "createHttpServiceBinderIfNecessary";
+ signature = "(Ljava/lang/String;)Landroid/os/IBinder;";
+ break;
+ case 2:
+ env = JavaVMHelper::getJNIEnv();
+ clazz = "android/media/Media2HTTPService";
+ method = "createHTTPService";
+ signature = "(Ljava/lang/String;)Landroid/media/Media2HTTPService;";
+ break;
+ default:
+ return NULL;
+ }
+
+ return createMediaHttpServiceTemplate(env, uri, clazz, method, signature, version);
+
+}
+
extern "C" {
EXPORT
diff --git a/media/ndk/NdkMediaDataSourcePriv.h b/media/ndk/NdkMediaDataSourcePriv.h
index ea9c865..3b0aa59 100644
--- a/media/ndk/NdkMediaDataSourcePriv.h
+++ b/media/ndk/NdkMediaDataSourcePriv.h
@@ -32,6 +32,7 @@
#include <sys/types.h>
#include <media/DataSource.h>
+#include <media/MediaHTTPService.h>
#include <media/NdkMediaDataSource.h>
#include <utils/Mutex.h>
#include <utils/String8.h>
@@ -59,5 +60,7 @@
};
+sp<MediaHTTPService> createMediaHttpService(const char *uri, int version);
+
#endif // _NDK_MEDIA_DATASOURCE_PRIV_H
diff --git a/media/ndk/NdkMediaExtractor.cpp b/media/ndk/NdkMediaExtractor.cpp
index c66cd50..f00a19c 100644
--- a/media/ndk/NdkMediaExtractor.cpp
+++ b/media/ndk/NdkMediaExtractor.cpp
@@ -96,39 +96,12 @@
ALOGV("setDataSource(%s)", uri);
- JNIEnv *env = AndroidRuntime::getJNIEnv();
- jobject service = NULL;
- if (env == NULL) {
- ALOGE("setDataSource(path) must be called from Java thread");
+ sp<MediaHTTPService> httpService = createMediaHttpService(uri, /* version = */ 1);
+ if (httpService == NULL) {
+ ALOGE("can't create http service");
return AMEDIA_ERROR_UNSUPPORTED;
}
- jclass mediahttpclass = env->FindClass("android/media/MediaHTTPService");
- if (mediahttpclass == NULL) {
- ALOGE("can't find MediaHttpService");
- env->ExceptionClear();
- return AMEDIA_ERROR_UNSUPPORTED;
- }
-
- jmethodID mediaHttpCreateMethod = env->GetStaticMethodID(mediahttpclass,
- "createHttpServiceBinderIfNecessary", "(Ljava/lang/String;)Landroid/os/IBinder;");
- if (mediaHttpCreateMethod == NULL) {
- ALOGE("can't find method");
- env->ExceptionClear();
- return AMEDIA_ERROR_UNSUPPORTED;
- }
-
- jstring jloc = env->NewStringUTF(uri);
-
- service = env->CallStaticObjectMethod(mediahttpclass, mediaHttpCreateMethod, jloc);
- env->DeleteLocalRef(jloc);
-
- sp<IMediaHTTPService> httpService;
- if (service != NULL) {
- sp<IBinder> binder = ibinderForJavaObject(env, service);
- httpService = interface_cast<IMediaHTTPService>(binder);
- }
-
KeyedVector<String8, String8> headers;
for (int i = 0; i < numheaders; ++i) {
String8 key8(keys[i]);
@@ -138,7 +111,6 @@
status_t err;
err = mData->mImpl->setDataSource(httpService, uri, numheaders > 0 ? &headers : NULL);
- env->ExceptionClear();
return translate_error(err);
}
diff --git a/services/audioflinger/Android.mk b/services/audioflinger/Android.mk
index 2c26ba4..c0aa477 100644
--- a/services/audioflinger/Android.mk
+++ b/services/audioflinger/Android.mk
@@ -42,7 +42,6 @@
LOCAL_STATIC_LIBRARIES := \
libcpustats \
- libjsoncpp \
libsndfile \
LOCAL_MULTILIB := $(AUDIOSERVER_MULTILIB)
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 47dbabf..06975ac 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -20,7 +20,6 @@
//#define LOG_NDEBUG 0
#include "Configuration.h"
-#include <algorithm> // std::any_of
#include <dirent.h>
#include <math.h>
#include <signal.h>
@@ -58,8 +57,6 @@
#include <audio_utils/primitives.h>
-#include <json/json.h>
-
#include <powermanager/PowerManager.h>
#include <media/IMediaLogService.h>
@@ -437,18 +434,6 @@
if (!dumpAllowed()) {
dumpPermissionDenial(fd, args);
} else {
- // XXX This is sort of hacky for now.
- const bool formatJson = std::any_of(args.begin(), args.end(),
- [](const String16 &arg) { return arg == String16("--json"); });
- if (formatJson) {
- Json::Value root = getJsonDump();
- Json::FastWriter writer;
- std::string rootStr = writer.write(root);
- // XXX consider buffering if the string happens to be too long.
- dprintf(fd, "%s", rootStr.c_str());
- return NO_ERROR;
- }
-
// get state of hardware lock
bool hardwareLocked = dumpTryLock(mHardwareLock);
if (!hardwareLocked) {
@@ -575,32 +560,6 @@
return NO_ERROR;
}
-Json::Value AudioFlinger::getJsonDump()
-{
- Json::Value root(Json::objectValue);
- const bool locked = dumpTryLock(mLock);
-
- // failed to lock - AudioFlinger is probably deadlocked
- if (!locked) {
- root["deadlock_message"] = kDeadlockedString;
- }
- // FIXME risky to access data structures without a lock held?
-
- Json::Value playbackThreads = Json::arrayValue;
- // dump playback threads
- for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- playbackThreads.append(mPlaybackThreads.valueAt(i)->getJsonDump());
- }
-
- if (locked) {
- mLock.unlock();
- }
-
- root["playback_threads"] = playbackThreads;
-
- return root;
-}
-
sp<AudioFlinger::Client> AudioFlinger::registerPid(pid_t pid)
{
Mutex::Autolock _cl(mClientLock);
@@ -787,7 +746,7 @@
output.afFrameCount = thread->frameCount();
output.afSampleRate = thread->sampleRate();
output.afLatencyMs = thread->latency();
- output.trackId = track->id();
+ output.trackId = track == nullptr ? -1 : track->id();
// move effect chain to this output thread if an effect on same session was waiting
// for a track to be created
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index 37d26b2..b6b3815 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -23,7 +23,6 @@
#include <mutex>
#include <deque>
#include <map>
-#include <memory>
#include <set>
#include <string>
#include <vector>
@@ -81,7 +80,6 @@
#include <powermanager/IPowerManager.h>
-#include <json/json.h>
#include <media/nblog/NBLog.h>
#include <private/media/AudioEffectShared.h>
#include <private/media/AudioTrackShared.h>
@@ -117,7 +115,6 @@
static const char* getServiceName() ANDROID_API { return "media.audio_flinger"; }
virtual status_t dump(int fd, const Vector<String16>& args);
- Json::Value getJsonDump();
// IAudioFlinger interface, in binder opcode order
virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input,
diff --git a/services/audioflinger/Configuration.h b/services/audioflinger/Configuration.h
index 34cd821..ede8e3f 100644
--- a/services/audioflinger/Configuration.h
+++ b/services/audioflinger/Configuration.h
@@ -27,7 +27,7 @@
//#define AUDIO_WATCHDOG
// uncomment to display CPU load adjusted for CPU frequency
-//define CPU_FREQUENCY_STATISTICS
+//#define CPU_FREQUENCY_STATISTICS
// uncomment to enable fast threads to take performance samples for later statistical analysis
#define FAST_THREAD_STATISTICS
diff --git a/services/audioflinger/FastMixerDumpState.cpp b/services/audioflinger/FastMixerDumpState.cpp
index 2abfbfb..a42e09c 100644
--- a/services/audioflinger/FastMixerDumpState.cpp
+++ b/services/audioflinger/FastMixerDumpState.cpp
@@ -24,8 +24,6 @@
#include <cpustats/ThreadCpuUsage.h>
#endif
#endif
-#include <json/json.h>
-#include <string>
#include <utils/Debug.h>
#include <utils/Log.h>
#include "FastMixerDumpState.h"
@@ -206,49 +204,4 @@
}
}
-Json::Value FastMixerDumpState::getJsonDump() const
-{
- Json::Value root(Json::objectValue);
- if (mCommand == FastMixerState::INITIAL) {
- root["status"] = "uninitialized";
- return root;
- }
-#ifdef FAST_THREAD_STATISTICS
- // find the interval of valid samples
- const uint32_t bounds = mBounds;
- const uint32_t newestOpen = bounds & 0xFFFF;
- uint32_t oldestClosed = bounds >> 16;
-
- //uint32_t n = (newestOpen - oldestClosed) & 0xFFFF;
- uint32_t n;
- __builtin_sub_overflow(newestOpen, oldestClosed, &n);
- n &= 0xFFFF;
-
- if (n > mSamplingN) {
- ALOGE("too many samples %u", n);
- n = mSamplingN;
- }
- // statistics for monotonic (wall clock) time, thread raw CPU load in time, CPU clock frequency,
- // and adjusted CPU load in MHz normalized for CPU clock frequency
- Json::Value jsonWall(Json::arrayValue);
- Json::Value jsonLoadNs(Json::arrayValue);
- // loop over all the samples
- for (uint32_t j = 0; j < n; ++j) {
- size_t i = oldestClosed++ & (mSamplingN - 1);
- uint32_t wallNs = mMonotonicNs[i];
- jsonWall.append(wallNs);
- uint32_t sampleLoadNs = mLoadNs[i];
- jsonLoadNs.append(sampleLoadNs);
- }
- if (n) {
- root["wall_clock_time_ns"] = jsonWall;
- root["raw_cpu_load_ns"] = jsonLoadNs;
- root["status"] = "ok";
- } else {
- root["status"] = "unavailable";
- }
-#endif
- return root;
-}
-
} // android
diff --git a/services/audioflinger/FastMixerDumpState.h b/services/audioflinger/FastMixerDumpState.h
index 69c2e4e..9b91cbc 100644
--- a/services/audioflinger/FastMixerDumpState.h
+++ b/services/audioflinger/FastMixerDumpState.h
@@ -18,9 +18,7 @@
#define ANDROID_AUDIO_FAST_MIXER_DUMP_STATE_H
#include <stdint.h>
-#include <string>
#include <audio_utils/TimestampVerifier.h>
-#include <json/json.h>
#include "Configuration.h"
#include "FastThreadDumpState.h"
#include "FastMixerState.h"
@@ -67,8 +65,7 @@
FastMixerDumpState();
/*virtual*/ ~FastMixerDumpState();
- void dump(int fd) const; // should only be called on a stable copy, not the original
- Json::Value getJsonDump() const; // should only be called on a stable copy, not the original
+ void dump(int fd) const; // should only be called on a stable copy, not the original
double mLatencyMs = 0.; // measured latency, default of 0 if no valid timestamp read.
uint32_t mWriteSequence; // incremented before and after each write()
diff --git a/services/audioflinger/FastThread.cpp b/services/audioflinger/FastThread.cpp
index 01b0432..04b32c2 100644
--- a/services/audioflinger/FastThread.cpp
+++ b/services/audioflinger/FastThread.cpp
@@ -66,8 +66,6 @@
/* mMeasuredWarmupTs({0, 0}), */
mWarmupCycles(0),
mWarmupConsecutiveInRangeCycles(0),
- mDummyNBLogWriter(new NBLog::Writer()),
- mNBLogWriter(mDummyNBLogWriter.get()),
mTimestampStatus(INVALID_OPERATION),
mCommand(FastThreadState::INITIAL),
@@ -124,10 +122,9 @@
// As soon as possible of learning of a new dump area, start using it
mDumpState = next->mDumpState != NULL ? next->mDumpState : mDummyDumpState;
- mNBLogWriter = next->mNBLogWriter != NULL ?
+ tlNBLogWriter = next->mNBLogWriter != NULL ?
next->mNBLogWriter : mDummyNBLogWriter.get();
- setNBLogWriter(mNBLogWriter); // FastMixer informs its AudioMixer, FastCapture ignores
- tlNBLogWriter = mNBLogWriter;
+ setNBLogWriter(tlNBLogWriter); // FastMixer informs its AudioMixer, FastCapture ignores
// We want to always have a valid reference to the previous (non-idle) state.
// However, the state queue only guarantees access to current and previous states.
diff --git a/services/audioflinger/FastThread.h b/services/audioflinger/FastThread.h
index bbb1d22..3f6b206 100644
--- a/services/audioflinger/FastThread.h
+++ b/services/audioflinger/FastThread.h
@@ -81,9 +81,7 @@
struct timespec mMeasuredWarmupTs; // how long did it take for warmup to complete
uint32_t mWarmupCycles; // counter of number of loop cycles during warmup phase
uint32_t mWarmupConsecutiveInRangeCycles; // number of consecutive cycles in range
- sp<NBLog::Writer> mDummyNBLogWriter;
- NBLog::Writer* mNBLogWriter; // always non-nullptr: real NBLog::Writer* or
- // mDummyNBLogWriter.get()
+ const sp<NBLog::Writer> mDummyNBLogWriter{new NBLog::Writer()};
status_t mTimestampStatus;
FastThreadState::Command mCommand;
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index b5e7856..d7a4451 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -42,7 +42,6 @@
#include <audio_utils/primitives.h>
#include <audio_utils/format.h>
#include <audio_utils/minifloat.h>
-#include <json/json.h>
#include <system/audio_effects/effect_ns.h>
#include <system/audio_effects/effect_aec.h>
#include <system/audio.h>
@@ -1776,11 +1775,6 @@
mLocalLog.dump(fd, " " /* prefix */, 40 /* lines */);
}
-Json::Value AudioFlinger::PlaybackThread::getJsonDump() const
-{
- return Json::Value(Json::objectValue);
-}
-
void AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args __unused)
{
String8 result;
@@ -5182,7 +5176,8 @@
// while we are dumping it. It may be inconsistent, but it won't mutate!
// This is a large object so we place it on the heap.
// FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
- const std::unique_ptr<FastMixerDumpState> copy(new FastMixerDumpState(mFastMixerDumpState));
+ const std::unique_ptr<FastMixerDumpState> copy =
+ std::make_unique<FastMixerDumpState>(mFastMixerDumpState);
copy->dump(fd);
#ifdef STATE_QUEUE_DUMP
@@ -5206,22 +5201,6 @@
}
}
-Json::Value AudioFlinger::MixerThread::getJsonDump() const
-{
- Json::Value root;
- if (hasFastMixer()) {
- // Make a non-atomic copy of fast mixer dump state so it won't change underneath us
- // while we are dumping it. It may be inconsistent, but it won't mutate!
- // This is a large object so we place it on the heap.
- // FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
- const std::unique_ptr<FastMixerDumpState> copy(new FastMixerDumpState(mFastMixerDumpState));
- root["fastmixer_stats"] = copy->getJsonDump();
- } else {
- root["fastmixer_stats"] = "no_fastmixer";
- }
- return root;
-}
-
uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
{
return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
@@ -7570,7 +7549,8 @@
// while we are dumping it. It may be inconsistent, but it won't mutate!
// This is a large object so we place it on the heap.
// FIXME 25972958: Need an intelligent copy constructor that does not touch unused pages.
- std::unique_ptr<FastCaptureDumpState> copy(new FastCaptureDumpState(mFastCaptureDumpState));
+ const std::unique_ptr<FastCaptureDumpState> copy =
+ std::make_unique<FastCaptureDumpState>(mFastCaptureDumpState);
copy->dump(fd);
}
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index bb37a0a..88c6ff3 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -668,8 +668,6 @@
virtual ~PlaybackThread();
void dump(int fd, const Vector<String16>& args) override;
- // returns a string of audio performance related data in JSON format.
- virtual Json::Value getJsonDump() const;
// Thread virtuals
virtual bool threadLoop();
@@ -1116,7 +1114,6 @@
virtual bool checkForNewParameter_l(const String8& keyValuePair,
status_t& status);
virtual void dumpInternals(int fd, const Vector<String16>& args);
- Json::Value getJsonDump() const override;
virtual bool isTrackAllowed_l(
audio_channel_mask_t channelMask, audio_format_t format,
diff --git a/services/audiopolicy/common/managerdefinitions/include/Serializer.h b/services/audiopolicy/common/managerdefinitions/include/Serializer.h
index 29de848..48c4147 100644
--- a/services/audiopolicy/common/managerdefinitions/include/Serializer.h
+++ b/services/audiopolicy/common/managerdefinitions/include/Serializer.h
@@ -17,223 +17,9 @@
#pragma once
#include "AudioPolicyConfig.h"
-#include <utils/StrongPointer.h>
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-#include <string>
-#include <sstream>
-#include <fstream>
-
-struct _xmlNode;
-struct _xmlDoc;
namespace android {
-struct AudioGainTraits
-{
- static const char *const tag;
- static const char *const collectionTag;
-
- struct Attributes
- {
- static const char mode[]; /**< gain modes supported, e.g. AUDIO_GAIN_MODE_CHANNELS. */
- /** controlled channels, needed if mode AUDIO_GAIN_MODE_CHANNELS. */
- static const char channelMask[];
- static const char minValueMB[]; /**< min value in millibel. */
- static const char maxValueMB[]; /**< max value in millibel. */
- static const char defaultValueMB[]; /**< default value in millibel. */
- static const char stepValueMB[]; /**< step value in millibel. */
- static const char minRampMs[]; /**< needed if mode AUDIO_GAIN_MODE_RAMP. */
- static const char maxRampMs[]; /**< .needed if mode AUDIO_GAIN_MODE_RAMP */
- };
-
- typedef AudioGain Element;
- typedef sp<Element> PtrElement;
- typedef AudioGainCollection Collection;
- typedef void *PtrSerializingCtx;
-
- static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
- PtrSerializingCtx serializingContext);
-
- // Gain has no child
-};
-
-// A profile section contains a name, one audio format and the list of supported sampling rates
-// and channel masks for this format
-struct AudioProfileTraits
-{
- static const char *const tag;
- static const char *const collectionTag;
-
- struct Attributes
- {
- static const char name[];
- static const char samplingRates[];
- static const char format[];
- static const char channelMasks[];
- };
-
- typedef AudioProfile Element;
- typedef sp<AudioProfile> PtrElement;
- typedef AudioProfileVector Collection;
- typedef void *PtrSerializingCtx;
-
- static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
- PtrSerializingCtx serializingContext);
-};
-
-struct MixPortTraits
-{
- static const char *const tag;
- static const char *const collectionTag;
-
- struct Attributes
- {
- static const char name[];
- static const char role[];
- static const char flags[];
- static const char maxOpenCount[];
- static const char maxActiveCount[];
- };
-
- typedef IOProfile Element;
- typedef sp<Element> PtrElement;
- typedef IOProfileCollection Collection;
- typedef void *PtrSerializingCtx;
-
- static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
- PtrSerializingCtx serializingContext);
-
- // Children are: GainTraits
-};
-
-struct DevicePortTraits
-{
- static const char *const tag;
- static const char *const collectionTag;
-
- struct Attributes
- {
- static const char tagName[]; /**< <device tag name>: any string without space. */
- static const char type[]; /**< <device type>. */
- static const char role[]; /**< <device role: sink or source>. */
- static const char roleSource[]; /**< <attribute role source value>. */
- static const char address[]; /**< optional: device address, char string less than 64. */
- };
- typedef DeviceDescriptor Element;
- typedef sp<DeviceDescriptor> PtrElement;
- typedef DeviceVector Collection;
- typedef void *PtrSerializingCtx;
-
- static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
- PtrSerializingCtx serializingContext);
- // Children are: GainTraits (optionnal)
-};
-
-struct RouteTraits
-{
- static const char *const tag;
- static const char *const collectionTag;
-
- struct Attributes
- {
- static const char type[]; /**< <route type>: mix or mux. */
- static const char typeMix[]; /**< type attribute mix value. */
- static const char sink[]; /**< <sink: involved in this route>. */
- static const char sources[]; /**< sources: all source that can be involved in this route. */
- };
- typedef AudioRoute Element;
- typedef sp<AudioRoute> PtrElement;
- typedef AudioRouteVector Collection;
- typedef HwModule *PtrSerializingCtx;
-
- static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
- PtrSerializingCtx ctx);
-};
-
-struct ModuleTraits
-{
- static const char *const tag;
- static const char *const collectionTag;
-
- static const char *const childAttachedDevicesTag;
- static const char *const childAttachedDeviceTag;
- static const char *const childDefaultOutputDeviceTag;
-
- struct Attributes
- {
- static const char name[];
- static const char version[];
- };
-
- typedef HwModule Element;
- typedef sp<Element> PtrElement;
- typedef HwModuleCollection Collection;
- typedef AudioPolicyConfig *PtrSerializingCtx;
-
- static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
- PtrSerializingCtx serializingContext);
-
- // Children are: mixPortTraits, devicePortTraits and routeTraits
- // Need to call deserialize on each child
-};
-
-struct GlobalConfigTraits
-{
- static const char *const tag;
-
- struct Attributes
- {
- static const char speakerDrcEnabled[];
- };
-
- static status_t deserialize(const _xmlNode *root, AudioPolicyConfig &config);
-};
-
-struct VolumeTraits
-{
- static const char *const tag;
- static const char *const collectionTag;
- static const char *const volumePointTag;
-
- struct Attributes
- {
- static const char stream[];
- static const char deviceCategory[];
- static const char reference[];
- };
-
- typedef VolumeCurve Element;
- typedef sp<VolumeCurve> PtrElement;
- typedef VolumeCurvesCollection Collection;
- typedef void *PtrSerializingCtx;
-
- static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
- PtrSerializingCtx serializingContext);
-
- // No Child
-};
-
-class PolicySerializer
-{
-private:
- static const char *const rootName;
-
- static const char *const versionAttribute;
- static const uint32_t gMajor; /**< the major number of the policy xml format version. */
- static const uint32_t gMinor; /**< the minor number of the policy xml format version. */
-
-public:
- PolicySerializer();
- status_t deserialize(const char *str, AudioPolicyConfig &config);
-
-private:
- typedef AudioPolicyConfig Element;
-
- std::string mRootElementName;
- std::string mVersion;
-
- // Children are: ModulesTraits, VolumeTraits
-};
+status_t deserializeAudioPolicyFile(const char *fileName, AudioPolicyConfig *config);
} // namespace android
diff --git a/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp b/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
index 8008a7c..f903845 100644
--- a/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
@@ -17,164 +17,355 @@
#define LOG_TAG "APM::Serializer"
//#define LOG_NDEBUG 0
-#include "Serializer.h"
-#include <media/convert.h>
-#include "TypeConverter.h"
+#include <memory>
+#include <string>
+
#include <libxml/parser.h>
#include <libxml/xinclude.h>
-#include <string>
-#include <sstream>
-#include <istream>
-
-using std::string;
+#include <media/convert.h>
+#include <utils/Log.h>
+#include <utils/StrongPointer.h>
+#include <utils/Errors.h>
+#include <utils/RefBase.h>
+#include "Serializer.h"
+#include "TypeConverter.h"
namespace android {
-string getXmlAttribute(const xmlNode *cur, const char *attribute)
-{
- xmlChar *xmlValue = xmlGetProp(cur, (const xmlChar*)attribute);
- if (xmlValue == NULL) {
- return "";
- }
- string value((const char*)xmlValue);
- xmlFree(xmlValue);
- return value;
-}
+namespace {
using utilities::convertTo;
-const char *const PolicySerializer::rootName = "audioPolicyConfiguration";
-const char *const PolicySerializer::versionAttribute = "version";
-const uint32_t PolicySerializer::gMajor = 1;
-const uint32_t PolicySerializer::gMinor = 0;
-static const char *const gReferenceElementName = "reference";
-static const char *const gReferenceAttributeName = "name";
+template<typename E, typename C>
+struct BaseSerializerTraits {
+ typedef E Element;
+ typedef sp<E> PtrElement;
+ typedef C Collection;
+ typedef void* PtrSerializingCtx;
+};
-template <class Trait>
-static void getReference(const _xmlNode *root, const _xmlNode *&refNode, const string &refName)
+struct AudioGainTraits : public BaseSerializerTraits<AudioGain, AudioGainCollection>
{
- const _xmlNode *col = root;
- while (col != NULL) {
- if (!xmlStrcmp(col->name, (const xmlChar *)Trait::collectionTag)) {
- const xmlNode *cur = col->children;
- while (cur != NULL) {
- if ((!xmlStrcmp(cur->name, (const xmlChar *)gReferenceElementName))) {
- string name = getXmlAttribute(cur, gReferenceAttributeName);
- if (refName == name) {
- refNode = cur;
- return;
- }
- }
- cur = cur->next;
- }
- }
- col = col->next;
+ static constexpr const char *tag = "gain";
+ static constexpr const char *collectionTag = "gains";
+
+ struct Attributes
+ {
+ /** gain modes supported, e.g. AUDIO_GAIN_MODE_CHANNELS. */
+ static constexpr const char *mode = "mode";
+ /** controlled channels, needed if mode AUDIO_GAIN_MODE_CHANNELS. */
+ static constexpr const char *channelMask = "channel_mask";
+ static constexpr const char *minValueMB = "minValueMB"; /**< min value in millibel. */
+ static constexpr const char *maxValueMB = "maxValueMB"; /**< max value in millibel. */
+ /** default value in millibel. */
+ static constexpr const char *defaultValueMB = "defaultValueMB";
+ static constexpr const char *stepValueMB = "stepValueMB"; /**< step value in millibel. */
+ /** needed if mode AUDIO_GAIN_MODE_RAMP. */
+ static constexpr const char *minRampMs = "minRampMs";
+ /** needed if mode AUDIO_GAIN_MODE_RAMP. */
+ static constexpr const char *maxRampMs = "maxRampMs";
+ };
+
+ static status_t deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
+ PtrSerializingCtx serializingContext);
+ // No children
+};
+
+// A profile section contains a name, one audio format and the list of supported sampling rates
+// and channel masks for this format
+struct AudioProfileTraits : public BaseSerializerTraits<AudioProfile, AudioProfileVector>
+{
+ static constexpr const char *tag = "profile";
+ static constexpr const char *collectionTag = "profiles";
+
+ struct Attributes
+ {
+ static constexpr const char *samplingRates = "samplingRates";
+ static constexpr const char *format = "format";
+ static constexpr const char *channelMasks = "channelMasks";
+ };
+
+ static status_t deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
+ PtrSerializingCtx serializingContext);
+};
+
+struct MixPortTraits : public BaseSerializerTraits<IOProfile, IOProfileCollection>
+{
+ static constexpr const char *tag = "mixPort";
+ static constexpr const char *collectionTag = "mixPorts";
+
+ struct Attributes
+ {
+ static constexpr const char *name = "name";
+ static constexpr const char *role = "role";
+ static constexpr const char *roleSource = "source"; /**< <attribute role source value>. */
+ static constexpr const char *flags = "flags";
+ static constexpr const char *maxOpenCount = "maxOpenCount";
+ static constexpr const char *maxActiveCount = "maxActiveCount";
+ };
+
+ static status_t deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
+ PtrSerializingCtx serializingContext);
+ // Children: GainTraits
+};
+
+struct DevicePortTraits : public BaseSerializerTraits<DeviceDescriptor, DeviceVector>
+{
+ static constexpr const char *tag = "devicePort";
+ static constexpr const char *collectionTag = "devicePorts";
+
+ struct Attributes
+ {
+ /** <device tag name>: any string without space. */
+ static constexpr const char *tagName = "tagName";
+ static constexpr const char *type = "type"; /**< <device type>. */
+ static constexpr const char *role = "role"; /**< <device role: sink or source>. */
+ static constexpr const char *roleSource = "source"; /**< <attribute role source value>. */
+ /** optional: device address, char string less than 64. */
+ static constexpr const char *address = "address";
+ };
+
+ static status_t deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
+ PtrSerializingCtx serializingContext);
+ // Children: GainTraits (optional)
+};
+
+struct RouteTraits : public BaseSerializerTraits<AudioRoute, AudioRouteVector>
+{
+ static constexpr const char *tag = "route";
+ static constexpr const char *collectionTag = "routes";
+
+ struct Attributes
+ {
+ static constexpr const char *type = "type"; /**< <route type>: mix or mux. */
+ static constexpr const char *typeMix = "mix"; /**< type attribute mix value. */
+ static constexpr const char *sink = "sink"; /**< <sink: involved in this route>. */
+ /** sources: all source that can be involved in this route. */
+ static constexpr const char *sources = "sources";
+ };
+
+ typedef HwModule *PtrSerializingCtx;
+
+ static status_t deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
+ PtrSerializingCtx ctx);
+};
+
+struct ModuleTraits : public BaseSerializerTraits<HwModule, HwModuleCollection>
+{
+ static constexpr const char *tag = "module";
+ static constexpr const char *collectionTag = "modules";
+
+ static constexpr const char *childAttachedDevicesTag = "attachedDevices";
+ static constexpr const char *childAttachedDeviceTag = "item";
+ static constexpr const char *childDefaultOutputDeviceTag = "defaultOutputDevice";
+
+ struct Attributes
+ {
+ static constexpr const char *name = "name";
+ static constexpr const char *version = "halVersion";
+ };
+
+ typedef AudioPolicyConfig *PtrSerializingCtx;
+
+ static status_t deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
+ PtrSerializingCtx serializingContext);
+
+ // Children: mixPortTraits, devicePortTraits, and routeTraits
+ // Need to call deserialize on each child
+};
+
+struct GlobalConfigTraits
+{
+ static constexpr const char *tag = "globalConfiguration";
+
+ struct Attributes
+ {
+ static constexpr const char *speakerDrcEnabled = "speaker_drc_enabled";
+ };
+
+ static status_t deserialize(const xmlNode *root, AudioPolicyConfig *config);
+};
+
+struct VolumeTraits : public BaseSerializerTraits<VolumeCurve, VolumeCurvesCollection>
+{
+ static constexpr const char *tag = "volume";
+ static constexpr const char *collectionTag = "volumes";
+ static constexpr const char *volumePointTag = "point";
+ static constexpr const char *referenceTag = "reference";
+
+ struct Attributes
+ {
+ static constexpr const char *stream = "stream";
+ static constexpr const char *deviceCategory = "deviceCategory";
+ static constexpr const char *reference = "ref";
+ static constexpr const char *referenceName = "name";
+ };
+
+ static status_t deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
+ PtrSerializingCtx serializingContext);
+ // No Children
+};
+
+class PolicySerializer
+{
+public:
+ PolicySerializer() : mVersion{std::to_string(gMajor) + "." + std::to_string(gMinor)}
+ {
+ ALOGV("%s: Version=%s Root=%s", __func__, mVersion.c_str(), rootName);
}
- return;
+ status_t deserialize(const char *str, AudioPolicyConfig *config);
+
+private:
+ static constexpr const char *rootName = "audioPolicyConfiguration";
+ static constexpr const char *versionAttribute = "version";
+ static constexpr uint32_t gMajor = 1; /**< the major number of the policy xml format version. */
+ static constexpr uint32_t gMinor = 0; /**< the minor number of the policy xml format version. */
+
+ typedef AudioPolicyConfig Element;
+
+ const std::string mVersion;
+
+ // Children: ModulesTraits, VolumeTraits
+};
+
+template <class T>
+constexpr void (*xmlDeleter)(T* t);
+template <>
+constexpr auto xmlDeleter<xmlDoc> = xmlFreeDoc;
+template <>
+constexpr auto xmlDeleter<xmlChar> = [](xmlChar *s) { xmlFree(s); };
+
+/** @return a unique_ptr with the correct deleter for the libxml2 object. */
+template <class T>
+constexpr auto make_xmlUnique(T *t) {
+ // Wrap deleter in lambda to enable empty base optimization
+ auto deleter = [](T *t) { xmlDeleter<T>(t); };
+ return std::unique_ptr<T, decltype(deleter)>{t, deleter};
+}
+
+std::string getXmlAttribute(const xmlNode *cur, const char *attribute)
+{
+ auto xmlValue = make_xmlUnique(xmlGetProp(cur, reinterpret_cast<const xmlChar*>(attribute)));
+ if (xmlValue == nullptr) {
+ return "";
+ }
+ std::string value(reinterpret_cast<const char*>(xmlValue.get()));
+ return value;
}
template <class Trait>
-static status_t deserializeCollection(_xmlDoc *doc, const _xmlNode *cur,
- typename Trait::Collection &collection,
- typename Trait::PtrSerializingCtx serializingContext)
+const xmlNode* getReference(const xmlNode *cur, const std::string &refName)
{
- const xmlNode *root = cur->xmlChildrenNode;
- while (root != NULL) {
- if (xmlStrcmp(root->name, (const xmlChar *)Trait::collectionTag) &&
- xmlStrcmp(root->name, (const xmlChar *)Trait::tag)) {
- root = root->next;
+ while (cur != NULL) {
+ if (!xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(Trait::collectionTag))) {
+ const xmlNode *child = cur->children;
+ while (child != NULL) {
+ if ((!xmlStrcmp(child->name,
+ reinterpret_cast<const xmlChar*>(Trait::referenceTag)))) {
+ std::string name = getXmlAttribute(child, Trait::Attributes::referenceName);
+ if (refName == name) {
+ return child;
+ }
+ }
+ child = child->next;
+ }
+ }
+ cur = cur->next;
+ }
+ return NULL;
+}
+
+template <class Trait>
+status_t deserializeCollection(xmlDoc *doc, const xmlNode *cur,
+ typename Trait::Collection *collection,
+ typename Trait::PtrSerializingCtx serializingContext)
+{
+ cur = cur->xmlChildrenNode;
+ while (cur != NULL) {
+ if (xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(Trait::collectionTag)) &&
+ xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(Trait::tag))) {
+ cur = cur->next;
continue;
}
- const xmlNode *child = root;
- if (!xmlStrcmp(child->name, (const xmlChar *)Trait::collectionTag)) {
+ const xmlNode *child = cur;
+ if (!xmlStrcmp(child->name, reinterpret_cast<const xmlChar*>(Trait::collectionTag))) {
child = child->xmlChildrenNode;
}
while (child != NULL) {
- if (!xmlStrcmp(child->name, (const xmlChar *)Trait::tag)) {
+ if (!xmlStrcmp(child->name, reinterpret_cast<const xmlChar*>(Trait::tag))) {
typename Trait::PtrElement element;
- status_t status = Trait::deserialize(doc, child, element, serializingContext);
+ status_t status = Trait::deserialize(doc, child, &element, serializingContext);
if (status != NO_ERROR) {
return status;
}
- if (collection.add(element) < 0) {
- ALOGE("%s: could not add element to %s collection", __FUNCTION__,
+ if (collection->add(element) < 0) {
+ ALOGE("%s: could not add element to %s collection", __func__,
Trait::collectionTag);
+ return BAD_VALUE;
}
}
child = child->next;
}
- if (!xmlStrcmp(root->name, (const xmlChar *)Trait::tag)) {
+ if (!xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(Trait::tag))) {
return NO_ERROR;
}
- root = root->next;
+ cur = cur->next;
}
return NO_ERROR;
}
-const char *const AudioGainTraits::tag = "gain";
-const char *const AudioGainTraits::collectionTag = "gains";
-
-const char AudioGainTraits::Attributes::mode[] = "mode";
-const char AudioGainTraits::Attributes::channelMask[] = "channel_mask";
-const char AudioGainTraits::Attributes::minValueMB[] = "minValueMB";
-const char AudioGainTraits::Attributes::maxValueMB[] = "maxValueMB";
-const char AudioGainTraits::Attributes::defaultValueMB[] = "defaultValueMB";
-const char AudioGainTraits::Attributes::stepValueMB[] = "stepValueMB";
-const char AudioGainTraits::Attributes::minRampMs[] = "minRampMs";
-const char AudioGainTraits::Attributes::maxRampMs[] = "maxRampMs";
-
-status_t AudioGainTraits::deserialize(_xmlDoc */*doc*/, const _xmlNode *root, PtrElement &gain,
+status_t AudioGainTraits::deserialize(xmlDoc */*doc*/, const xmlNode *root, PtrElement *element,
PtrSerializingCtx /*serializingContext*/)
{
static uint32_t index = 0;
- gain = new Element(index++, true);
+ PtrElement &gain = *element = new Element(index++, true);
- string mode = getXmlAttribute(root, Attributes::mode);
+ std::string mode = getXmlAttribute(root, Attributes::mode);
if (!mode.empty()) {
gain->setMode(GainModeConverter::maskFromString(mode));
}
- string channelsLiteral = getXmlAttribute(root, Attributes::channelMask);
+ std::string channelsLiteral = getXmlAttribute(root, Attributes::channelMask);
if (!channelsLiteral.empty()) {
gain->setChannelMask(channelMaskFromString(channelsLiteral));
}
- string minValueMBLiteral = getXmlAttribute(root, Attributes::minValueMB);
+ std::string minValueMBLiteral = getXmlAttribute(root, Attributes::minValueMB);
int32_t minValueMB;
if (!minValueMBLiteral.empty() && convertTo(minValueMBLiteral, minValueMB)) {
gain->setMinValueInMb(minValueMB);
}
- string maxValueMBLiteral = getXmlAttribute(root, Attributes::maxValueMB);
+ std::string maxValueMBLiteral = getXmlAttribute(root, Attributes::maxValueMB);
int32_t maxValueMB;
if (!maxValueMBLiteral.empty() && convertTo(maxValueMBLiteral, maxValueMB)) {
gain->setMaxValueInMb(maxValueMB);
}
- string defaultValueMBLiteral = getXmlAttribute(root, Attributes::defaultValueMB);
+ std::string defaultValueMBLiteral = getXmlAttribute(root, Attributes::defaultValueMB);
int32_t defaultValueMB;
if (!defaultValueMBLiteral.empty() && convertTo(defaultValueMBLiteral, defaultValueMB)) {
gain->setDefaultValueInMb(defaultValueMB);
}
- string stepValueMBLiteral = getXmlAttribute(root, Attributes::stepValueMB);
+ std::string stepValueMBLiteral = getXmlAttribute(root, Attributes::stepValueMB);
uint32_t stepValueMB;
if (!stepValueMBLiteral.empty() && convertTo(stepValueMBLiteral, stepValueMB)) {
gain->setStepValueInMb(stepValueMB);
}
- string minRampMsLiteral = getXmlAttribute(root, Attributes::minRampMs);
+ std::string minRampMsLiteral = getXmlAttribute(root, Attributes::minRampMs);
uint32_t minRampMs;
if (!minRampMsLiteral.empty() && convertTo(minRampMsLiteral, minRampMs)) {
gain->setMinRampInMs(minRampMs);
}
- string maxRampMsLiteral = getXmlAttribute(root, Attributes::maxRampMs);
+ std::string maxRampMsLiteral = getXmlAttribute(root, Attributes::maxRampMs);
uint32_t maxRampMs;
if (!maxRampMsLiteral.empty() && convertTo(maxRampMsLiteral, maxRampMs)) {
gain->setMaxRampInMs(maxRampMs);
}
- ALOGV("%s: adding new gain mode %08x channel mask %08x min mB %d max mB %d", __FUNCTION__,
+ ALOGV("%s: adding new gain mode %08x channel mask %08x min mB %d max mB %d", __func__,
gain->getMode(), gain->getChannelMask(), gain->getMinValueInMb(),
gain->getMaxValueInMb());
@@ -184,24 +375,16 @@
return NO_ERROR;
}
-const char *const AudioProfileTraits::collectionTag = "profiles";
-const char *const AudioProfileTraits::tag = "profile";
-
-const char AudioProfileTraits::Attributes::name[] = "name";
-const char AudioProfileTraits::Attributes::samplingRates[] = "samplingRates";
-const char AudioProfileTraits::Attributes::format[] = "format";
-const char AudioProfileTraits::Attributes::channelMasks[] = "channelMasks";
-
-status_t AudioProfileTraits::deserialize(_xmlDoc */*doc*/, const _xmlNode *root, PtrElement &profile,
+status_t AudioProfileTraits::deserialize(xmlDoc */*doc*/, const xmlNode *root, PtrElement *element,
PtrSerializingCtx /*serializingContext*/)
{
- string samplingRates = getXmlAttribute(root, Attributes::samplingRates);
- string format = getXmlAttribute(root, Attributes::format);
- string channels = getXmlAttribute(root, Attributes::channelMasks);
+ std::string samplingRates = getXmlAttribute(root, Attributes::samplingRates);
+ std::string format = getXmlAttribute(root, Attributes::format);
+ std::string channels = getXmlAttribute(root, Attributes::channelMasks);
- profile = new Element(formatFromString(format, gDynamicFormat),
- channelMasksFromString(channels, ","),
- samplingRatesFromString(samplingRates, ","));
+ PtrElement &profile = *element = new Element(formatFromString(format, gDynamicFormat),
+ channelMasksFromString(channels, ","),
+ samplingRatesFromString(samplingRates, ","));
profile->setDynamicFormat(profile->getFormat() == gDynamicFormat);
profile->setDynamicChannels(profile->getChannels().isEmpty());
@@ -210,43 +393,37 @@
return NO_ERROR;
}
-
-const char *const MixPortTraits::collectionTag = "mixPorts";
-const char *const MixPortTraits::tag = "mixPort";
-
-const char MixPortTraits::Attributes::name[] = "name";
-const char MixPortTraits::Attributes::role[] = "role";
-const char MixPortTraits::Attributes::flags[] = "flags";
-const char MixPortTraits::Attributes::maxOpenCount[] = "maxOpenCount";
-const char MixPortTraits::Attributes::maxActiveCount[] = "maxActiveCount";
-
-status_t MixPortTraits::deserialize(_xmlDoc *doc, const _xmlNode *child, PtrElement &mixPort,
+status_t MixPortTraits::deserialize(xmlDoc *doc, const xmlNode *child, PtrElement *element,
PtrSerializingCtx /*serializingContext*/)
{
- string name = getXmlAttribute(child, Attributes::name);
+ std::string name = getXmlAttribute(child, Attributes::name);
if (name.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::name);
+ ALOGE("%s: No %s found", __func__, Attributes::name);
return BAD_VALUE;
}
- ALOGV("%s: %s %s=%s", __FUNCTION__, tag, Attributes::name, name.c_str());
- string role = getXmlAttribute(child, Attributes::role);
+ ALOGV("%s: %s %s=%s", __func__, tag, Attributes::name, name.c_str());
+ std::string role = getXmlAttribute(child, Attributes::role);
if (role.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::role);
+ ALOGE("%s: No %s found", __func__, Attributes::role);
return BAD_VALUE;
}
- ALOGV("%s: Role=%s", __FUNCTION__, role.c_str());
- audio_port_role_t portRole = role == "source" ? AUDIO_PORT_ROLE_SOURCE : AUDIO_PORT_ROLE_SINK;
+ ALOGV("%s: Role=%s", __func__, role.c_str());
+ audio_port_role_t portRole = (role == Attributes::roleSource) ?
+ AUDIO_PORT_ROLE_SOURCE : AUDIO_PORT_ROLE_SINK;
- mixPort = new Element(String8(name.c_str()), portRole);
+ PtrElement &mixPort = *element = new Element(String8(name.c_str()), portRole);
AudioProfileTraits::Collection profiles;
- deserializeCollection<AudioProfileTraits>(doc, child, profiles, NULL);
+ status_t status = deserializeCollection<AudioProfileTraits>(doc, child, &profiles, NULL);
+ if (status != NO_ERROR) {
+ return status;
+ }
if (profiles.isEmpty()) {
profiles.add(AudioProfile::createFullDynamic());
}
mixPort->setAudioProfiles(profiles);
- string flags = getXmlAttribute(child, Attributes::flags);
+ std::string flags = getXmlAttribute(child, Attributes::flags);
if (!flags.empty()) {
// Source role
if (portRole == AUDIO_PORT_ROLE_SOURCE) {
@@ -256,52 +433,46 @@
mixPort->setFlags(InputFlagConverter::maskFromString(flags));
}
}
- string maxOpenCount = getXmlAttribute(child, Attributes::maxOpenCount);
+ std::string maxOpenCount = getXmlAttribute(child, Attributes::maxOpenCount);
if (!maxOpenCount.empty()) {
convertTo(maxOpenCount, mixPort->maxOpenCount);
}
- string maxActiveCount = getXmlAttribute(child, Attributes::maxActiveCount);
+ std::string maxActiveCount = getXmlAttribute(child, Attributes::maxActiveCount);
if (!maxActiveCount.empty()) {
convertTo(maxActiveCount, mixPort->maxActiveCount);
}
// Deserialize children
AudioGainTraits::Collection gains;
- deserializeCollection<AudioGainTraits>(doc, child, gains, NULL);
+ status = deserializeCollection<AudioGainTraits>(doc, child, &gains, NULL);
+ if (status != NO_ERROR) {
+ return status;
+ }
mixPort->setGains(gains);
return NO_ERROR;
}
-const char *const DevicePortTraits::tag = "devicePort";
-const char *const DevicePortTraits::collectionTag = "devicePorts";
-
-const char DevicePortTraits::Attributes::tagName[] = "tagName";
-const char DevicePortTraits::Attributes::type[] = "type";
-const char DevicePortTraits::Attributes::role[] = "role";
-const char DevicePortTraits::Attributes::address[] = "address";
-const char DevicePortTraits::Attributes::roleSource[] = "source";
-
-status_t DevicePortTraits::deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &deviceDesc,
+status_t DevicePortTraits::deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
PtrSerializingCtx /*serializingContext*/)
{
- string name = getXmlAttribute(root, Attributes::tagName);
+ std::string name = getXmlAttribute(root, Attributes::tagName);
if (name.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::tagName);
+ ALOGE("%s: No %s found", __func__, Attributes::tagName);
return BAD_VALUE;
}
- ALOGV("%s: %s %s=%s", __FUNCTION__, tag, Attributes::tagName, name.c_str());
- string typeName = getXmlAttribute(root, Attributes::type);
+ ALOGV("%s: %s %s=%s", __func__, tag, Attributes::tagName, name.c_str());
+ std::string typeName = getXmlAttribute(root, Attributes::type);
if (typeName.empty()) {
- ALOGE("%s: no type for %s", __FUNCTION__, name.c_str());
+ ALOGE("%s: no type for %s", __func__, name.c_str());
return BAD_VALUE;
}
- ALOGV("%s: %s %s=%s", __FUNCTION__, tag, Attributes::type, typeName.c_str());
- string role = getXmlAttribute(root, Attributes::role);
+ ALOGV("%s: %s %s=%s", __func__, tag, Attributes::type, typeName.c_str());
+ std::string role = getXmlAttribute(root, Attributes::role);
if (role.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::role);
+ ALOGE("%s: No %s found", __func__, Attributes::role);
return BAD_VALUE;
}
- ALOGV("%s: %s %s=%s", __FUNCTION__, tag, Attributes::role, role.c_str());
+ ALOGV("%s: %s %s=%s", __func__, tag, Attributes::role, role.c_str());
audio_port_role_t portRole = (role == Attributes::roleSource) ?
AUDIO_PORT_ROLE_SOURCE : AUDIO_PORT_ROLE_SINK;
@@ -309,174 +480,173 @@
if (!deviceFromString(typeName, type) ||
(!audio_is_input_device(type) && portRole == AUDIO_PORT_ROLE_SOURCE) ||
(!audio_is_output_devices(type) && portRole == AUDIO_PORT_ROLE_SINK)) {
- ALOGW("%s: bad type %08x", __FUNCTION__, type);
+ ALOGW("%s: bad type %08x", __func__, type);
return BAD_VALUE;
}
- deviceDesc = new Element(type, String8(name.c_str()));
+ PtrElement &deviceDesc = *element = new Element(type, String8(name.c_str()));
- string address = getXmlAttribute(root, Attributes::address);
+ std::string address = getXmlAttribute(root, Attributes::address);
if (!address.empty()) {
- ALOGV("%s: address=%s for %s", __FUNCTION__, address.c_str(), name.c_str());
+ ALOGV("%s: address=%s for %s", __func__, address.c_str(), name.c_str());
deviceDesc->mAddress = String8(address.c_str());
}
AudioProfileTraits::Collection profiles;
- deserializeCollection<AudioProfileTraits>(doc, root, profiles, NULL);
+ status_t status = deserializeCollection<AudioProfileTraits>(doc, root, &profiles, NULL);
+ if (status != NO_ERROR) {
+ return status;
+ }
if (profiles.isEmpty()) {
profiles.add(AudioProfile::createFullDynamic());
}
deviceDesc->setAudioProfiles(profiles);
// Deserialize AudioGain children
- deserializeCollection<AudioGainTraits>(doc, root, deviceDesc->mGains, NULL);
- ALOGV("%s: adding device tag %s type %08x address %s", __FUNCTION__,
+ status = deserializeCollection<AudioGainTraits>(doc, root, &deviceDesc->mGains, NULL);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ ALOGV("%s: adding device tag %s type %08x address %s", __func__,
deviceDesc->getName().string(), type, deviceDesc->mAddress.string());
return NO_ERROR;
}
-const char *const RouteTraits::tag = "route";
-const char *const RouteTraits::collectionTag = "routes";
-
-const char RouteTraits::Attributes::type[] = "type";
-const char RouteTraits::Attributes::typeMix[] = "mix";
-const char RouteTraits::Attributes::sink[] = "sink";
-const char RouteTraits::Attributes::sources[] = "sources";
-
-
-status_t RouteTraits::deserialize(_xmlDoc */*doc*/, const _xmlNode *root, PtrElement &element,
+status_t RouteTraits::deserialize(xmlDoc */*doc*/, const xmlNode *root, PtrElement *element,
PtrSerializingCtx ctx)
{
- string type = getXmlAttribute(root, Attributes::type);
+ std::string type = getXmlAttribute(root, Attributes::type);
if (type.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::type);
+ ALOGE("%s: No %s found", __func__, Attributes::type);
return BAD_VALUE;
}
audio_route_type_t routeType = (type == Attributes::typeMix) ?
AUDIO_ROUTE_MIX : AUDIO_ROUTE_MUX;
- ALOGV("%s: %s %s=%s", __FUNCTION__, tag, Attributes::type, type.c_str());
- element = new Element(routeType);
+ ALOGV("%s: %s %s=%s", __func__, tag, Attributes::type, type.c_str());
+ PtrElement &route = *element = new Element(routeType);
- string sinkAttr = getXmlAttribute(root, Attributes::sink);
+ std::string sinkAttr = getXmlAttribute(root, Attributes::sink);
if (sinkAttr.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::sink);
+ ALOGE("%s: No %s found", __func__, Attributes::sink);
return BAD_VALUE;
}
// Convert Sink name to port pointer
sp<AudioPort> sink = ctx->findPortByTagName(String8(sinkAttr.c_str()));
if (sink == NULL) {
- ALOGE("%s: no sink found with name=%s", __FUNCTION__, sinkAttr.c_str());
+ ALOGE("%s: no sink found with name=%s", __func__, sinkAttr.c_str());
return BAD_VALUE;
}
- element->setSink(sink);
+ route->setSink(sink);
- string sourcesAttr = getXmlAttribute(root, Attributes::sources);
+ std::string sourcesAttr = getXmlAttribute(root, Attributes::sources);
if (sourcesAttr.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::sources);
+ ALOGE("%s: No %s found", __func__, Attributes::sources);
return BAD_VALUE;
}
// Tokenize and Convert Sources name to port pointer
AudioPortVector sources;
- char *sourcesLiteral = strndup(sourcesAttr.c_str(), strlen(sourcesAttr.c_str()));
- char *devTag = strtok(sourcesLiteral, ",");
+ std::unique_ptr<char[]> sourcesLiteral{strndup(
+ sourcesAttr.c_str(), strlen(sourcesAttr.c_str()))};
+ char *devTag = strtok(sourcesLiteral.get(), ",");
while (devTag != NULL) {
if (strlen(devTag) != 0) {
sp<AudioPort> source = ctx->findPortByTagName(String8(devTag));
if (source == NULL) {
- ALOGE("%s: no source found with name=%s", __FUNCTION__, devTag);
- free(sourcesLiteral);
+ ALOGE("%s: no source found with name=%s", __func__, devTag);
return BAD_VALUE;
}
sources.add(source);
}
devTag = strtok(NULL, ",");
}
- free(sourcesLiteral);
- sink->addRoute(element);
+ sink->addRoute(route);
for (size_t i = 0; i < sources.size(); i++) {
sp<AudioPort> source = sources.itemAt(i);
- source->addRoute(element);
+ source->addRoute(route);
}
- element->setSources(sources);
+ route->setSources(sources);
return NO_ERROR;
}
-const char *const ModuleTraits::childAttachedDevicesTag = "attachedDevices";
-const char *const ModuleTraits::childAttachedDeviceTag = "item";
-const char *const ModuleTraits::childDefaultOutputDeviceTag = "defaultOutputDevice";
-
-const char *const ModuleTraits::tag = "module";
-const char *const ModuleTraits::collectionTag = "modules";
-
-const char ModuleTraits::Attributes::name[] = "name";
-const char ModuleTraits::Attributes::version[] = "halVersion";
-
-status_t ModuleTraits::deserialize(xmlDocPtr doc, const xmlNode *root, PtrElement &module,
+status_t ModuleTraits::deserialize(xmlDocPtr doc, const xmlNode *root, PtrElement *element,
PtrSerializingCtx ctx)
{
- string name = getXmlAttribute(root, Attributes::name);
+ std::string name = getXmlAttribute(root, Attributes::name);
if (name.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::name);
+ ALOGE("%s: No %s found", __func__, Attributes::name);
return BAD_VALUE;
}
uint32_t versionMajor = 0, versionMinor = 0;
- string versionLiteral = getXmlAttribute(root, Attributes::version);
+ std::string versionLiteral = getXmlAttribute(root, Attributes::version);
if (!versionLiteral.empty()) {
sscanf(versionLiteral.c_str(), "%u.%u", &versionMajor, &versionMinor);
- ALOGV("%s: mHalVersion = major %u minor %u", __FUNCTION__,
+ ALOGV("%s: mHalVersion = major %u minor %u", __func__,
versionMajor, versionMajor);
}
- ALOGV("%s: %s %s=%s", __FUNCTION__, tag, Attributes::name, name.c_str());
+ ALOGV("%s: %s %s=%s", __func__, tag, Attributes::name, name.c_str());
- module = new Element(name.c_str(), versionMajor, versionMinor);
+ PtrElement &module = *element = new Element(name.c_str(), versionMajor, versionMinor);
// Deserialize childrens: Audio Mix Port, Audio Device Ports (Source/Sink), Audio Routes
MixPortTraits::Collection mixPorts;
- deserializeCollection<MixPortTraits>(doc, root, mixPorts, NULL);
+ status_t status = deserializeCollection<MixPortTraits>(doc, root, &mixPorts, NULL);
+ if (status != NO_ERROR) {
+ return status;
+ }
module->setProfiles(mixPorts);
DevicePortTraits::Collection devicePorts;
- deserializeCollection<DevicePortTraits>(doc, root, devicePorts, NULL);
+ status = deserializeCollection<DevicePortTraits>(doc, root, &devicePorts, NULL);
+ if (status != NO_ERROR) {
+ return status;
+ }
module->setDeclaredDevices(devicePorts);
RouteTraits::Collection routes;
- deserializeCollection<RouteTraits>(doc, root, routes, module.get());
+ status = deserializeCollection<RouteTraits>(doc, root, &routes, module.get());
+ if (status != NO_ERROR) {
+ return status;
+ }
module->setRoutes(routes);
const xmlNode *children = root->xmlChildrenNode;
while (children != NULL) {
- if (!xmlStrcmp(children->name, (const xmlChar *)childAttachedDevicesTag)) {
- ALOGV("%s: %s %s found", __FUNCTION__, tag, childAttachedDevicesTag);
+ if (!xmlStrcmp(children->name, reinterpret_cast<const xmlChar*>(childAttachedDevicesTag))) {
+ ALOGV("%s: %s %s found", __func__, tag, childAttachedDevicesTag);
const xmlNode *child = children->xmlChildrenNode;
while (child != NULL) {
- if (!xmlStrcmp(child->name, (const xmlChar *)childAttachedDeviceTag)) {
- xmlChar *attachedDevice = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
- if (attachedDevice != NULL) {
- ALOGV("%s: %s %s=%s", __FUNCTION__, tag, childAttachedDeviceTag,
- (const char*)attachedDevice);
- sp<DeviceDescriptor> device =
- module->getDeclaredDevices().getDeviceFromTagName(String8((const char*)attachedDevice));
+ if (!xmlStrcmp(child->name,
+ reinterpret_cast<const xmlChar*>(childAttachedDeviceTag))) {
+ auto attachedDevice = make_xmlUnique(xmlNodeListGetString(
+ doc, child->xmlChildrenNode, 1));
+ if (attachedDevice != nullptr) {
+ ALOGV("%s: %s %s=%s", __func__, tag, childAttachedDeviceTag,
+ reinterpret_cast<const char*>(attachedDevice.get()));
+ sp<DeviceDescriptor> device = module->getDeclaredDevices().
+ getDeviceFromTagName(String8(reinterpret_cast<const char*>(
+ attachedDevice.get())));
ctx->addAvailableDevice(device);
- xmlFree(attachedDevice);
}
}
child = child->next;
}
}
- if (!xmlStrcmp(children->name, (const xmlChar *)childDefaultOutputDeviceTag)) {
- xmlChar *defaultOutputDevice = xmlNodeListGetString(doc, children->xmlChildrenNode, 1);;
- if (defaultOutputDevice != NULL) {
- ALOGV("%s: %s %s=%s", __FUNCTION__, tag, childDefaultOutputDeviceTag,
- (const char*)defaultOutputDevice);
- sp<DeviceDescriptor> device =
- module->getDeclaredDevices().getDeviceFromTagName(String8((const char*)defaultOutputDevice));
+ if (!xmlStrcmp(children->name,
+ reinterpret_cast<const xmlChar*>(childDefaultOutputDeviceTag))) {
+ auto defaultOutputDevice = make_xmlUnique(xmlNodeListGetString(
+ doc, children->xmlChildrenNode, 1));
+ if (defaultOutputDevice != nullptr) {
+ ALOGV("%s: %s %s=%s", __func__, tag, childDefaultOutputDeviceTag,
+ reinterpret_cast<const char*>(defaultOutputDevice.get()));
+ sp<DeviceDescriptor> device = module->getDeclaredDevices().getDeviceFromTagName(
+ String8(reinterpret_cast<const char*>(defaultOutputDevice.get())));
if (device != 0 && ctx->getDefaultOutputDevice() == 0) {
ctx->setDefaultOutputDevice(device);
- ALOGV("%s: default is %08x", __FUNCTION__, ctx->getDefaultOutputDevice()->type());
+ ALOGV("%s: default is %08x",
+ __func__, ctx->getDefaultOutputDevice()->type());
}
- xmlFree(defaultOutputDevice);
}
}
children = children->next;
@@ -484,22 +654,17 @@
return NO_ERROR;
}
-const char *const GlobalConfigTraits::tag = "globalConfiguration";
-
-const char GlobalConfigTraits::Attributes::speakerDrcEnabled[] = "speaker_drc_enabled";
-
-
-status_t GlobalConfigTraits::deserialize(const xmlNode *cur, AudioPolicyConfig &config)
+status_t GlobalConfigTraits::deserialize(const xmlNode *cur, AudioPolicyConfig *config)
{
const xmlNode *root = cur->xmlChildrenNode;
while (root != NULL) {
- if (!xmlStrcmp(root->name, (const xmlChar *)tag)) {
- string speakerDrcEnabled =
+ if (!xmlStrcmp(root->name, reinterpret_cast<const xmlChar*>(tag))) {
+ std::string speakerDrcEnabled =
getXmlAttribute(root, Attributes::speakerDrcEnabled);
bool isSpeakerDrcEnabled;
if (!speakerDrcEnabled.empty() &&
- convertTo<string, bool>(speakerDrcEnabled, isSpeakerDrcEnabled)) {
- config.setSpeakerDrcEnabled(isSpeakerDrcEnabled);
+ convertTo<std::string, bool>(speakerDrcEnabled, isSpeakerDrcEnabled)) {
+ config->setSpeakerDrcEnabled(isSpeakerDrcEnabled);
}
return NO_ERROR;
}
@@ -508,134 +673,129 @@
return NO_ERROR;
}
-
-const char *const VolumeTraits::tag = "volume";
-const char *const VolumeTraits::collectionTag = "volumes";
-const char *const VolumeTraits::volumePointTag = "point";
-
-const char VolumeTraits::Attributes::stream[] = "stream";
-const char VolumeTraits::Attributes::deviceCategory[] = "deviceCategory";
-const char VolumeTraits::Attributes::reference[] = "ref";
-
-status_t VolumeTraits::deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
+status_t VolumeTraits::deserialize(xmlDoc *doc, const xmlNode *root, PtrElement *element,
PtrSerializingCtx /*serializingContext*/)
{
- string streamTypeLiteral = getXmlAttribute(root, Attributes::stream);
+ std::string streamTypeLiteral = getXmlAttribute(root, Attributes::stream);
if (streamTypeLiteral.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::stream);
+ ALOGE("%s: No %s found", __func__, Attributes::stream);
return BAD_VALUE;
}
audio_stream_type_t streamType;
if (!StreamTypeConverter::fromString(streamTypeLiteral, streamType)) {
- ALOGE("%s: Invalid %s", __FUNCTION__, Attributes::stream);
+ ALOGE("%s: Invalid %s", __func__, Attributes::stream);
return BAD_VALUE;
}
- string deviceCategoryLiteral = getXmlAttribute(root, Attributes::deviceCategory);
+ std::string deviceCategoryLiteral = getXmlAttribute(root, Attributes::deviceCategory);
if (deviceCategoryLiteral.empty()) {
- ALOGE("%s: No %s found", __FUNCTION__, Attributes::deviceCategory);
+ ALOGE("%s: No %s found", __func__, Attributes::deviceCategory);
return BAD_VALUE;
}
device_category deviceCategory;
if (!DeviceCategoryConverter::fromString(deviceCategoryLiteral, deviceCategory)) {
- ALOGE("%s: Invalid %s=%s", __FUNCTION__, Attributes::deviceCategory,
+ ALOGE("%s: Invalid %s=%s", __func__, Attributes::deviceCategory,
deviceCategoryLiteral.c_str());
return BAD_VALUE;
}
- string referenceName = getXmlAttribute(root, Attributes::reference);
- const _xmlNode *ref = NULL;
+ std::string referenceName = getXmlAttribute(root, Attributes::reference);
+ const xmlNode *ref = NULL;
if (!referenceName.empty()) {
- getReference<VolumeTraits>(root->parent, ref, referenceName);
+ ref = getReference<VolumeTraits>(root->parent, referenceName);
if (ref == NULL) {
- ALOGE("%s: No reference Ptr found for %s", __FUNCTION__, referenceName.c_str());
+ ALOGE("%s: No reference Ptr found for %s", __func__, referenceName.c_str());
return BAD_VALUE;
}
}
- element = new Element(deviceCategory, streamType);
+ PtrElement &volCurve = *element = new Element(deviceCategory, streamType);
const xmlNode *child = referenceName.empty() ? root->xmlChildrenNode : ref->xmlChildrenNode;
while (child != NULL) {
- if (!xmlStrcmp(child->name, (const xmlChar *)volumePointTag)) {
- xmlChar *pointDefinition = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);;
- if (pointDefinition == NULL) {
+ if (!xmlStrcmp(child->name, reinterpret_cast<const xmlChar*>(volumePointTag))) {
+ auto pointDefinition = make_xmlUnique(xmlNodeListGetString(
+ doc, child->xmlChildrenNode, 1));
+ if (pointDefinition == nullptr) {
return BAD_VALUE;
}
- ALOGV("%s: %s=%s", __FUNCTION__, tag, (const char*)pointDefinition);
+ ALOGV("%s: %s=%s",
+ __func__, tag, reinterpret_cast<const char*>(pointDefinition.get()));
Vector<int32_t> point;
- collectionFromString<DefaultTraits<int32_t> >((const char*)pointDefinition, point, ",");
+ collectionFromString<DefaultTraits<int32_t>>(
+ reinterpret_cast<const char*>(pointDefinition.get()), point, ",");
if (point.size() != 2) {
- ALOGE("%s: Invalid %s: %s", __FUNCTION__, volumePointTag,
- (const char*)pointDefinition);
+ ALOGE("%s: Invalid %s: %s", __func__, volumePointTag,
+ reinterpret_cast<const char*>(pointDefinition.get()));
return BAD_VALUE;
}
- element->add(CurvePoint(point[0], point[1]));
- xmlFree(pointDefinition);
+ volCurve->add(CurvePoint(point[0], point[1]));
}
child = child->next;
}
return NO_ERROR;
}
-PolicySerializer::PolicySerializer() : mRootElementName(rootName)
+status_t PolicySerializer::deserialize(const char *configFile, AudioPolicyConfig *config)
{
- std::ostringstream oss;
- oss << gMajor << "." << gMinor;
- mVersion = oss.str();
- ALOGV("%s: Version=%s Root=%s", __FUNCTION__, mVersion.c_str(), mRootElementName.c_str());
-}
-
-status_t PolicySerializer::deserialize(const char *configFile, AudioPolicyConfig &config)
-{
- xmlDocPtr doc;
- doc = xmlParseFile(configFile);
- if (doc == NULL) {
- ALOGE("%s: Could not parse %s document.", __FUNCTION__, configFile);
+ auto doc = make_xmlUnique(xmlParseFile(configFile));
+ if (doc == nullptr) {
+ ALOGE("%s: Could not parse %s document.", __func__, configFile);
return BAD_VALUE;
}
- xmlNodePtr cur = xmlDocGetRootElement(doc);
+ xmlNodePtr cur = xmlDocGetRootElement(doc.get());
if (cur == NULL) {
- ALOGE("%s: Could not parse %s document: empty.", __FUNCTION__, configFile);
- xmlFreeDoc(doc);
+ ALOGE("%s: Could not parse %s document: empty.", __func__, configFile);
return BAD_VALUE;
}
- if (xmlXIncludeProcess(doc) < 0) {
- ALOGE("%s: libxml failed to resolve XIncludes on %s document.", __FUNCTION__, configFile);
+ if (xmlXIncludeProcess(doc.get()) < 0) {
+ ALOGE("%s: libxml failed to resolve XIncludes on %s document.", __func__, configFile);
}
- if (xmlStrcmp(cur->name, (const xmlChar *) mRootElementName.c_str())) {
- ALOGE("%s: No %s root element found in xml data %s.", __FUNCTION__, mRootElementName.c_str(),
- (const char *)cur->name);
- xmlFreeDoc(doc);
+ if (xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(rootName))) {
+ ALOGE("%s: No %s root element found in xml data %s.", __func__, rootName,
+ reinterpret_cast<const char*>(cur->name));
return BAD_VALUE;
}
- string version = getXmlAttribute(cur, versionAttribute);
+ std::string version = getXmlAttribute(cur, versionAttribute);
if (version.empty()) {
- ALOGE("%s: No version found in root node %s", __FUNCTION__, mRootElementName.c_str());
+ ALOGE("%s: No version found in root node %s", __func__, rootName);
return BAD_VALUE;
}
if (version != mVersion) {
- ALOGE("%s: Version does not match; expect %s got %s", __FUNCTION__, mVersion.c_str(),
+ ALOGE("%s: Version does not match; expect %s got %s", __func__, mVersion.c_str(),
version.c_str());
return BAD_VALUE;
}
// Lets deserialize children
// Modules
ModuleTraits::Collection modules;
- deserializeCollection<ModuleTraits>(doc, cur, modules, &config);
- config.setHwModules(modules);
+ status_t status = deserializeCollection<ModuleTraits>(doc.get(), cur, &modules, config);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ config->setHwModules(modules);
// deserialize volume section
VolumeTraits::Collection volumes;
- deserializeCollection<VolumeTraits>(doc, cur, volumes, &config);
- config.setVolumes(volumes);
+ status = deserializeCollection<VolumeTraits>(doc.get(), cur, &volumes, config);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ config->setVolumes(volumes);
// Global Configuration
GlobalConfigTraits::deserialize(cur, config);
- xmlFreeDoc(doc);
return android::OK;
}
+} // namespace
+
+status_t deserializeAudioPolicyFile(const char *fileName, AudioPolicyConfig *config)
+{
+ PolicySerializer serializer;
+ return serializer.deserialize(fileName, config);
+}
+
} // namespace android
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index dd2158b..600f968 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -3921,10 +3921,9 @@
for (const char* fileName : fileNames) {
for (int i = 0; i < kConfigLocationListSize; i++) {
- PolicySerializer serializer;
snprintf(audioPolicyXmlConfigFile, sizeof(audioPolicyXmlConfigFile),
"%s/%s", kConfigLocationList[i], fileName);
- ret = serializer.deserialize(audioPolicyXmlConfigFile, config);
+ ret = deserializeAudioPolicyFile(audioPolicyXmlConfigFile, &config);
if (ret == NO_ERROR) {
config.setSource(audioPolicyXmlConfigFile);
return ret;