Add callback for codec format changed. (a02129ba) · Commits · e / os / android_frameworks_base

core/jni/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -149,6 +149,7 @@ cc_library_shared {
		"android_media_AudioEffectDescriptor.cpp",
		"android_media_AudioRecord.cpp",
		"android_media_AudioSystem.cpp",
		"android_media_AudioTrackCallback.cpp",
		"android_media_AudioTrack.cpp",
		"android_media_AudioAttributes.cpp",
		"android_media_AudioProductStrategies.cpp",

core/jni/android_media_AudioTrack.cpp

+14 −19

Original line number	Diff line number	Diff line
		@@ -31,13 +31,14 @@
		#include <binder/MemoryHeapBase.h>
		#include <binder/MemoryBase.h>

		#include "android_media_AudioFormat.h"
		#include "android_media_AudioAttributes.h"
		#include "android_media_AudioErrors.h"
		#include "android_media_AudioFormat.h"
		#include "android_media_AudioTrackCallback.h"
		#include "android_media_DeviceCallback.h"
		#include "android_media_MediaMetricsJNI.h"
		#include "android_media_PlaybackParams.h"
		#include "android_media_DeviceCallback.h"
		#include "android_media_VolumeShaper.h"
		#include "android_media_AudioAttributes.h"

		#include <cinttypes>

		@@ -78,19 +79,9 @@ class AudioTrackJniStorage {
		public:
		sp<MemoryHeapBase> mMemHeap;
		sp<MemoryBase> mMemBase;
		audiotrack_callback_cookie mCallbackData;
		audiotrack_callback_cookie mCallbackData{};
		sp<JNIDeviceCallback> mDeviceCallback;

		AudioTrackJniStorage() {
		mCallbackData.audioTrack_class = 0;
		mCallbackData.audioTrack_ref = 0;
		mCallbackData.isOffload = false;
		}

		~AudioTrackJniStorage() {
		mMemBase.clear();
		mMemHeap.clear();
		}
		sp<JNIAudioTrackCallback> mAudioTrackCallback;

		bool allocSharedMem(int sizeInBytes) {
		mMemHeap = new MemoryHeapBase(sizeInBytes, 0, "AudioTrack Heap Base");
		@@ -459,6 +450,10 @@ static jint android_media_AudioTrack_setup(JNIEnv *env, jobject thiz, jobject we
		lpJniStorage->mCallbackData.audioTrack_ref = env->NewGlobalRef(weak_this);
		lpJniStorage->mCallbackData.busy = false;
		}
		lpJniStorage->mAudioTrackCallback =
		new JNIAudioTrackCallback(env, thiz, lpJniStorage->mCallbackData.audioTrack_ref,
		javaAudioTrackFields.postNativeEventInJava);
		lpTrack->setAudioTrackCallback(lpJniStorage->mAudioTrackCallback);

		nSession = (jint *) env->GetPrimitiveArrayCritical(jSession, NULL);
		if (nSession == NULL) {

core/jni/android_media_AudioTrackCallback.cpp

0 → 100644

+99 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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 "AudioTrackCallback-JNI"

		#include <algorithm>

		#include <nativehelper/JNIHelp.h>
		#include <utils/Errors.h>
		#include <utils/Log.h>

		#include "android_media_AudioTrackCallback.h"
		#include "core_jni_helpers.h"

		using namespace android;

		#define BYTE_BUFFER_NAME "java/nio/ByteBuffer"
		#define BYTE_BUFFER_ALLOCATE_DIRECT_NAME "allocateDirect"

		JNIAudioTrackCallback::JNIAudioTrackCallback(JNIEnv* env, jobject thiz, jobject weak_thiz,
		jmethodID postEventFromNative) {
		// Hold onto the AudioTrack class for use in calling the static method
		// that posts events to the application thread.
		jclass clazz = env->GetObjectClass(thiz);
		if (clazz == nullptr) {
		return;
		}
		mClass = (jclass)env->NewGlobalRef(clazz);

		// We use a weak reference so the AudioTrack object can be garbage collected.
		// The reference is only used as a proxy for callbacks.
		mObject = env->NewGlobalRef(weak_thiz);

		mPostEventFromNative = postEventFromNative;

		jclass byteBufferClass = FindClassOrDie(env, BYTE_BUFFER_NAME);
		mByteBufferClass = (jclass)env->NewGlobalRef(byteBufferClass);
		mAllocateDirectMethod =
		GetStaticMethodIDOrDie(env, mByteBufferClass, BYTE_BUFFER_ALLOCATE_DIRECT_NAME,
		"(I)Ljava/nio/ByteBuffer;");
		}

		JNIAudioTrackCallback::~JNIAudioTrackCallback() {
		// remove global references
		JNIEnv* env = AndroidRuntime::getJNIEnv();
		if (env == nullptr) {
		return;
		}
		env->DeleteGlobalRef(mObject);
		env->DeleteGlobalRef(mClass);
		env->DeleteGlobalRef(mByteBufferClass);
		}

		binder::Status JNIAudioTrackCallback::onCodecFormatChanged(
		const std::vector<uint8_t>& audioMetadata) {
		JNIEnv* env = AndroidRuntime::getJNIEnv();
		if (env == nullptr) {
		return binder::Status::ok();
		}

		jobject byteBuffer = env->CallStaticObjectMethod(mByteBufferClass, mAllocateDirectMethod,
		(jint)audioMetadata.size());
		if (env->ExceptionCheck()) {
		ALOGW("An exception occurred while allocating direct buffer");
		env->ExceptionDescribe();
		env->ExceptionClear();
		}
		if (byteBuffer == nullptr) {
		ALOGE("Failed allocating a direct ByteBuffer");
		return binder::Status::fromStatusT(NO_MEMORY);
		}

		uint8_t* byteBufferAddr = (uint8_t*)env->GetDirectBufferAddress(byteBuffer);
		std::copy(audioMetadata.begin(), audioMetadata.end(), byteBufferAddr);
		env->CallStaticVoidMethod(mClass, mPostEventFromNative, mObject,
		AUDIO_NATIVE_EVENT_CODEC_FORMAT_CHANGE, 0, 0, byteBuffer);
		if (env->ExceptionCheck()) {
		ALOGW("An exception occurred while notifying codec format changed.");
		env->ExceptionDescribe();
		env->ExceptionClear();
		}

		return binder::Status::ok();
		}

core/jni/android_media_AudioTrackCallback.h

0 → 100644

+45 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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 ANDROID_MEDIA_AUDIO_TRACK_CALLBACK_H
		#define ANDROID_MEDIA_AUDIO_TRACK_CALLBACK_H

		#include <android/media/BnAudioTrackCallback.h>

		namespace android {

		#define AUDIO_NATIVE_EVENT_CODEC_FORMAT_CHANGE 100

		// TODO(b/149870866) : Extract common part for JNIAudioTrackCallback and JNIDeviceCallback
		class JNIAudioTrackCallback : public media::BnAudioTrackCallback {
		public:
		JNIAudioTrackCallback(JNIEnv* env, jobject thiz, jobject weak_thiz,
		jmethodID postEventFromNative);
		~JNIAudioTrackCallback() override;

		binder::Status onCodecFormatChanged(const std::vector<uint8_t>& audioMetadata) override;

		private:
		jclass mClass; // Reference to AudioTrack class
		jobject mObject; // Weak ref to AudioTrack Java object to call on
		jmethodID mPostEventFromNative; // postEventFromNative method ID
		jclass mByteBufferClass; // Reference to ByteBuffer class
		jmethodID mAllocateDirectMethod; // ByteBuffer.allocateDirect method ID
		};

		}; // namespace android

		#endif // ANDROID_MEDIA_AUDIO_TRACK_CALLBACK_H