Merge "Add callback for codec format changed." into rvc-dev am: e4146905d4 (e33f4157) · Commits · e / os / android_frameworks_base

core/jni/Android.bp

+1 −0

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

core/jni/android_media_AudioTrack.cpp

+14 −19

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

	#include "android_media_AudioFormat.h"		#include "android_media_AudioAttributes.h"
	#include "android_media_AudioErrors.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_MediaMetricsJNI.h"
	#include "android_media_PlaybackParams.h"		#include "android_media_PlaybackParams.h"
	#include "android_media_DeviceCallback.h"
	#include "android_media_VolumeShaper.h"		#include "android_media_VolumeShaper.h"
	#include "android_media_AudioAttributes.h"

	#include <cinttypes>		#include <cinttypes>

	@@ -78,19 +79,9 @@ class AudioTrackJniStorage {
	public:		public:
	sp<MemoryHeapBase> mMemHeap;		sp<MemoryHeapBase> mMemHeap;
	sp<MemoryBase> mMemBase;		sp<MemoryBase> mMemBase;
	audiotrack_callback_cookie mCallbackData;		audiotrack_callback_cookie mCallbackData{};
	sp<JNIDeviceCallback> mDeviceCallback;		sp<JNIDeviceCallback> mDeviceCallback;
			sp<JNIAudioTrackCallback> mAudioTrackCallback;
	AudioTrackJniStorage() {
	mCallbackData.audioTrack_class = 0;
	mCallbackData.audioTrack_ref = 0;
	mCallbackData.isOffload = false;
	}

	~AudioTrackJniStorage() {
	mMemBase.clear();
	mMemHeap.clear();
	}

	bool allocSharedMem(int sizeInBytes) {		bool allocSharedMem(int sizeInBytes) {
	mMemHeap = new MemoryHeapBase(sizeInBytes, 0, "AudioTrack Heap Base");		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.audioTrack_ref = env->NewGlobalRef(weak_this);
	lpJniStorage->mCallbackData.busy = false;		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);		nSession = (jint *) env->GetPrimitiveArrayCritical(jSession, NULL);
	if (nSession == NULL) {		if (nSession == NULL) {

core/jni/android_media_AudioTrackCallback.cpp

0 → 100644

+99 −0

Original line number	Original line	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	Original line	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