|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel.changes
|
|
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel.spec
^
|
|
|
|
[-]
[+]
|
Changed |
_service
^
|
| @@ -2,7 +2,7 @@
<service name="tar_git">
<param name="url">https://github.com/sailfishos/droidmedia.git</param>
<param name="branch">master</param>
- <param name="revision">0.20211101.0</param>
+ <param name="revision">0.20220929.0</param>
<param name="token"/>
<param name="debian"/>
<param name="dumb"/>
|
|
[-]
[+]
|
Deleted |
_service:tar_git:droidmedia-devel-0.20211101.0.tgz/AsyncDecodingSource.cpp
^
|
| @@ -1,406 +0,0 @@
-/*
- * Copyright (c) 2020 Open Mobile Platform LLC.
- * Copyright 2016, 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.
- */
-
-#include "AsyncDecodingSource.h"
-#include <utils/Log.h>
-#include <gui/Surface.h>
-#if ANDROID_MAJOR >= 11
-#include <mediadrm/ICrypto.h>
-#else
-#include <media/ICrypto.h>
-#endif
-#include <media/stagefright/MediaDefs.h>
-#include <media/stagefright/foundation/ALooper.h>
-#include <media/stagefright/foundation/AMessage.h>
-#include <media/stagefright/foundation/AUtils.h>
-#include <media/stagefright/MediaBuffer.h>
-#include <media/stagefright/MediaCodecList.h>
-#include <media/stagefright/MediaCodec.h>
-#include <media/stagefright/MetaData.h>
-#include <media/stagefright/Utils.h>
-#include <media/stagefright/SurfaceUtils.h>
-
-using namespace android;
-
-#if ANDROID_MAJOR > 7
-#include <media/MediaCodecBuffer.h>
-#else
-#include <media/stagefright/foundation/ABuffer.h>
-typedef ABuffer MediaCodecBuffer;
-#endif
-
-//#define LOG_NDEBUG 0
-#define LOG_TAG "AsyncDecodingSource"
-
-
-
-//static
-sp<AsyncDecodingSource> AsyncDecodingSource::Create(
- const sp<MediaSource> &source, uint32_t flags, const sp<ANativeWindow> &nativeWindow,
- const sp<ALooper> &looper, const char *desiredCodec) {
- sp<Surface> surface = static_cast<Surface*>(nativeWindow.get());
- const char *mime = nullptr;
- sp<MetaData> meta = source->getFormat();
- CHECK(meta->findCString(kKeyMIMEType, &mime));
-
- sp<AMessage> format = new AMessage;
- if (convertMetaDataToMessage(meta, &format) != OK) {
- return nullptr;
- }
-
- format->setInt32("android._num-input-buffers", 12);
-
- Vector<AString> matchingCodecs;
- MediaCodecList::findMatchingCodecs(
- mime, false /* encoder */, flags, &matchingCodecs);
-
- for (const AString &componentName : matchingCodecs) {
- if (desiredCodec != nullptr && componentName.compare(desiredCodec)) {
- continue;
- }
-
- ALOGV("Attempting to allocate codec '%s'", componentName.c_str());
- sp<AsyncDecodingSource> res = new AsyncDecodingSource(componentName, source, looper,
- strcmp(mime, MEDIA_MIMETYPE_AUDIO_VORBIS) == 0);
-
- if (res->mCodec != NULL) {
- ALOGI("Successfully allocated codec '%s'", componentName.c_str());
- if (res->configure(format, surface, 0)) {
- if (surface != nullptr) {
-#if ANDROID_MAJOR > 7
- nativeWindowConnect(nativeWindow.get(), "AsyncDecodingSource");
-#else
- native_window_api_connect(nativeWindow.get(),
- NATIVE_WINDOW_API_MEDIA);
-#endif
- }
- return res;
- } else {
- ALOGE("Failed to configure codec '%s'", componentName.c_str());
- }
- }
- else {
- ALOGE("Failed to allocate codec '%s'", componentName.c_str());
- }
- }
-
- ALOGE("No matching decoder! (mime: %s)", mime);
- return nullptr;
-}
-
-AsyncDecodingSource::AsyncDecodingSource(
- const AString &codecName, const sp<MediaSource> &source, const sp<ALooper> &looper,
- bool isVorbis)
- : mComponentName(codecName),
- mSource(source),
- mLooper(looper),
- mCodecLooper(new ALooper),
- mMeta(new MetaData),
- mUsingSurface(false),
- mIsVorbis(isVorbis) {
- mCodecLooper->setName("codec_looper");
- mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
-
- mCodec = MediaCodec::CreateByComponentName(mCodecLooper, mComponentName);
-
- mReflector = new AHandlerReflector<AsyncDecodingSource>(this);
- mLooper->registerHandler(mReflector);
- mNotify = new AMessage(0, mReflector);
-}
-
-AsyncDecodingSource::~AsyncDecodingSource() {
- mCodec->release();
- mCodecLooper->stop();
- mLooper->unregisterHandler(mReflector->id());
-}
-
-bool AsyncDecodingSource::configure(const sp<AMessage> format, const sp<Surface> surface, uint32_t flags) {
- mCodec->setCallback(mNotify);
- status_t err = mCodec->configure(format, surface, nullptr /* crypto */, flags);
- if (err != OK) {
- ALOGE("Failed to configure codec '%s'", mComponentName.c_str());
- return false;
- }
- mUsingSurface = surface != nullptr;
-
- // Set output format metadata
- sp<AMessage> outputFormat;
- mCodec->getOutputFormat(&outputFormat);
- sp<MetaData> meta = new MetaData;
- convertMessageToMetaData(outputFormat, meta);
- mMeta.lock().set(meta);
-
- mOutput.lock()->mReachedEOS = false;
- ALOGI("Configured codec '%s'!", mComponentName.c_str());
- return true;
-}
-
-status_t AsyncDecodingSource::start(MetaData *params) {
- (void)params;
- Mutexed<Output>::Locked me(mOutput);
-
- if (mState != INIT) {
- return -EINVAL;
- }
-
- status_t res = mCodec->start();
- if (res == OK) {
- res = mSource->start();
- }
-
- if (res == OK) {
- mState = STARTED;
- me->mReachedEOS = false;
- } else {
- mState = ERROR;
- }
- return res;
-}
-
-status_t AsyncDecodingSource::stop() {
- Mutexed<Output>::Locked me(mOutput);
- if (mState != STARTED) {
- return -EINVAL;
- }
-
- // wait for any pending reads to complete
- mState = STOPPING;
- while (me->mReading) {
- me.waitForCondition(me->mReadCondition);
- }
-
- status_t res1 = mCodec->stop();
- if (res1 != OK) {
- mCodec->release();
- }
- status_t res2 = mSource->stop();
- if (res1 == OK && res2 == OK) {
- mState = STOPPED;
- } else {
- mState = ERROR;
- }
- return res1 != OK ? res1 : res2;
-}
-
-sp<MetaData> AsyncDecodingSource::getFormat() {
|
|
[-]
[+]
|
Deleted |
_service:tar_git:droidmedia-devel-0.20211101.0.tgz/AsyncDecodingSource.h
^
|
| @@ -1,125 +0,0 @@
-/*
- * Copyright (c) 2020 Open Mobile Platform LLC.
- * Copyright 2016, 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 ASYNC_DECODING_SOURCE_H_
-#define ASYNC_DECODING_SOURCE_H_
-
-#include <media/stagefright/foundation/AString.h>
-#include <media/stagefright/foundation/Mutexed.h>
-#include <media/stagefright/foundation/AHandlerReflector.h>
-#if ANDROID_MAJOR >= 9 && ANDROID_MAJOR <= 10
-#include <media/MediaSource.h>
-#else
-#include <media/stagefright/MediaSource.h>
-#endif
-#include <media/stagefright/MediaBuffer.h>
-#include <utils/Condition.h>
-#include <utils/StrongPointer.h>
-
-struct ANativeWindow;
-
-namespace android {
-
-#if ANDROID_MAJOR < 9
-typedef MediaBuffer DroidMediaBuffer;
-#else
-typedef MediaBufferBase DroidMediaBuffer;
-#endif
-
-struct ALooper;
-struct AMessage;
-struct MediaCodec;
-class MetaData;
-class Surface;
-
-class AsyncDecodingSource : public MediaSource {
-public:
- static sp<AsyncDecodingSource> Create(const sp<MediaSource> &source,
- uint32_t flags, const sp<ANativeWindow> &nativeWindow,
- const sp<ALooper> &looper, const char *desiredCodec = NULL);
-
- bool configure(const sp<AMessage> format,
- const sp<Surface> surface,
- uint32_t flags = 0);
-
- virtual ~AsyncDecodingSource();
-
- // starts this source (and its underlying source). |params| is ignored.
- virtual status_t start(MetaData *params = NULL);
-
- // stops this source (and its underlying source).
- virtual status_t stop();
-
- // returns the output format of this source.
- virtual sp<MetaData> getFormat();
-
- // reads from the source. This call always blocks.
- virtual status_t read(
- android::DroidMediaBuffer **buffer,
- const ReadOptions *options);
-
- // for AHandlerReflector
- void onMessageReceived(const sp<AMessage> &msg);
-
- // unsupported methods
- virtual status_t pause() { return INVALID_OPERATION; }
-
-
-private:
- // Construct this using a codec, source and looper.
- AsyncDecodingSource(
- const AString &codecName, const sp<MediaSource> &source, const sp<ALooper> &looper,
- bool isVorbis);
-
- AString mComponentName;
- sp<MediaCodec> mCodec;
- sp<MediaSource> mSource;
- sp<ALooper> mLooper;
- sp<ALooper> mCodecLooper;
- sp<AMessage> mNotify = 0;
- sp<AHandlerReflector<AsyncDecodingSource> > mReflector;
- List<size_t> mAvailInputIndices;
- Mutexed<sp<MetaData>> mMeta;
- bool mUsingSurface;
- bool mIsVorbis;
- bool mFeeding = false;
- bool mOutputChanged = false;
- enum State {
- INIT,
- STARTED,
- STOPPING,
- STOPPED,
- ERROR,
- };
- State mState = INIT;
-
- struct Output {
- Output();
-
- List<DroidMediaBuffer*> mBufferQueue;
- bool mReachedEOS;
- bool mReading = false;
- Condition mAvailable;
- Condition mReadCondition;
- };
- Mutexed<Output> mOutput;
-
-};
-
-} // namespace android
-
-#endif //ASYNC_DECODING_SOURCE_H_
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/Android.mk
^
|
| @@ -61,7 +61,7 @@
private.cpp
ifeq ($(shell test $(ANDROID_MAJOR) -ge 7 && echo true),true)
-LOCAL_SRC_FILES += AsyncDecodingSource.cpp
+LOCAL_SRC_FILES += AsyncCodecSource.cpp
endif
LOCAL_SHARED_LIBRARIES := libc \
@@ -124,7 +124,14 @@
LOCAL_SRC_FILES := minimedia.cpp
LOCAL_C_INCLUDES := frameworks/av/services/camera/libcameraservice \
frameworks/av/media/libmediaplayerservice \
- system/media/camera/include
+ system/media/camera/include \
+ $(call include-path-for, audio-utils) \
+ frameworks/av/media/libaaudio/include \
+ frameworks/av/media/libaaudio/src \
+ frameworks/av/media/libaaudio/src/binding \
+ frameworks/av/media/libmedia \
+ frameworks/av/services/audioflinger
+
LOCAL_SHARED_LIBRARIES := libcameraservice \
libmediaplayerservice \
libcamera_client \
@@ -135,7 +142,6 @@
libcutils \
libui
-ifeq ($(MINIMEDIA_AUDIOPOLICYSERVICE_ENABLE),1)
ifeq ($(ANDROID_MAJOR),$(filter $(ANDROID_MAJOR),5))
LOCAL_C_INCLUDES += frameworks/av/services/audiopolicy
else
@@ -146,7 +152,12 @@
frameworks/av/services/audiopolicy/managerdefault \
frameworks/av/services/audiopolicy/service
endif
-LOCAL_SHARED_LIBRARIES += libaudiopolicyservice
+
+# libmedia was split into libmedia and libaudioclient starting with A8
+ifeq ($(shell test $(ANDROID_MAJOR) -ge 8 && echo true),true)
+LOCAL_SHARED_LIBRARIES += libaudioclient
+else
+LOCAL_SHARED_LIBRARIES += libmedia
endif
ifeq ($(ANDROID_MAJOR),$(filter $(ANDROID_MAJOR),8 9))
@@ -194,8 +205,11 @@
ifeq ($(MINIMEDIA_SENSORSERVER_DISABLE),1)
LOCAL_CPPFLAGS += -DSENSORSERVER_DISABLE
endif
-ifeq ($(MINIMEDIA_AUDIOPOLICYSERVICE_ENABLE),1)
- LOCAL_CPPFLAGS += -DAUDIOPOLICYSERVICE_ENABLE
+ifeq ($(AUDIOPOLICY_MTK_AUDIO_ADD),1)
+LOCAL_CPPFLAGS += -DAUDIOPOLICY_MTK_AUDIO_ADD
+endif
+ifeq ($(shell grep -q listAudioSessions frameworks/av/services/audiopolicy/service/AudioPolicyService.h && echo true),true)
+LOCAL_CPPFLAGS += -DAUDIOPOLICY_LINEAGE_AUDIOSESSIONINFO
endif
LOCAL_MODULE := minimediaservice
ifeq ($(strip $(DROIDMEDIA_32)), true)
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/AsyncCodecSource.cpp
^
|
| @@ -0,0 +1,435 @@
+/*
+ * Copyright (c) 2020 Open Mobile Platform LLC.
+ * Copyright 2016, 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
+#include "AsyncCodecSource.h"
+#include <utils/Log.h>
+#include <gui/Surface.h>
+#if ANDROID_MAJOR >= 11
+#include <mediadrm/ICrypto.h>
+#else
+#include <media/ICrypto.h>
+#endif
+#include <media/stagefright/MediaDefs.h>
+#include <media/stagefright/foundation/ALooper.h>
+#include <media/stagefright/foundation/AMessage.h>
+#include <media/stagefright/foundation/AUtils.h>
+#include <media/stagefright/MediaBuffer.h>
+#include <media/stagefright/MediaCodecList.h>
+#include <media/stagefright/MediaCodec.h>
+#include <media/stagefright/MetaData.h>
+#include <media/stagefright/Utils.h>
+#include <media/stagefright/SurfaceUtils.h>
+
+using namespace android;
+
+#if ANDROID_MAJOR > 7
+#include <media/MediaCodecBuffer.h>
+#else
+#include <media/stagefright/foundation/ABuffer.h>
+typedef ABuffer MediaCodecBuffer;
+#endif
+
+#define LOG_TAG "AsyncCodecSource"
+
+
+
+//static
+sp<MediaSource> AsyncCodecSource::Create(
+ const sp<MediaSource> &source, const sp<AMessage> &srcFormat,
+ bool isEncoder, uint32_t flags, const sp<ANativeWindow> &nativeWindow,
+ const sp<ALooper> &looper, const char *desiredCodec, OMX_COLOR_FORMATTYPE colorFormat) {
+ sp<Surface> surface = static_cast<Surface*>(nativeWindow.get());
+ const char *mime = nullptr;
+ sp<MetaData> meta = source->getFormat();
+ CHECK(meta->findCString(kKeyMIMEType, &mime));
+
+ sp<AMessage> format = new AMessage;
+ if (srcFormat.get()) {
+ // The unconfigured MediaSource comes from android::CameraSource.
+ if (isEncoder && !strcmp(mime, "video/raw")) {
+ // Use MediaCodecSource for the camera recorder.
+ return MediaCodecSource::Create(looper, srcFormat, source, nullptr, flags);
+ }
+ format = srcFormat;
+ } else if (convertMetaDataToMessage(meta, &format) != OK) {
+ ALOGE("Cannot convertMetaDataToMessage()");
+ return nullptr;
+ }
+
+ if (!isEncoder) {
+#if ANDROID_MAJOR > 6
+ format->setInt32("android._num-input-buffers", 12);
+#else
+ format->setInt32("inputbuffercnt", 12);
+#endif
+ }
+
+ if (colorFormat != OMX_COLOR_FormatUnused) {
+ format->setInt32("color-format", colorFormat);
+ }
+
+ Vector<AString> matchingCodecs;
+ MediaCodecList::findMatchingCodecs(
+ mime, isEncoder, flags, &matchingCodecs);
+
+ for (const AString &componentName : matchingCodecs) {
+ if (desiredCodec != nullptr && componentName.compare(desiredCodec)) {
+ continue;
+ }
+
+ ALOGV("Attempting to allocate codec '%s'", componentName.c_str());
+ sp<AsyncCodecSource> res = new AsyncCodecSource(componentName, source, looper,
+ strcmp(mime, MEDIA_MIMETYPE_AUDIO_VORBIS) == 0);
+
+ if (res->mCodec != NULL) {
+ ALOGI("Successfully allocated codec '%s'", componentName.c_str());
+ if (res->configure(format, surface, isEncoder ? MediaCodec::CONFIGURE_FLAG_ENCODE : 0)) {
+ if (surface != nullptr) {
+#if ANDROID_MAJOR > 7
+ nativeWindowConnect(nativeWindow.get(), "AsyncCodecSource");
+#else
+ native_window_api_connect(nativeWindow.get(),
+ NATIVE_WINDOW_API_MEDIA);
+#endif
+ }
+ return res;
+ } else {
+ ALOGE("Failed to configure codec '%s'", componentName.c_str());
+ }
+ }
+ else {
+ ALOGE("Failed to allocate codec '%s'", componentName.c_str());
+ }
+ }
+
+ ALOGE("No matching codec! (mime: %s)", mime);
+ return nullptr;
+}
+
+AsyncCodecSource::AsyncCodecSource(
+ const AString &codecName, const sp<MediaSource> &source, const sp<ALooper> &looper,
+ bool isVorbis)
+ : mComponentName(codecName),
+ mSource(source),
+ mLooper(looper),
+ mCodecLooper(new ALooper),
+ mMeta(new MetaData),
+ mUsingSurface(false),
+ mIsVorbis(isVorbis) {
+ mCodecLooper->setName("codec_looper");
+ mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
+
+ mCodec = MediaCodec::CreateByComponentName(mCodecLooper, mComponentName);
+
+ mReflector = new AHandlerReflector<AsyncCodecSource>(this);
+ mLooper->registerHandler(mReflector);
+ mNotify = new AMessage(0, mReflector);
+}
+
+AsyncCodecSource::~AsyncCodecSource() {
+ mCodec->release();
+ mCodecLooper->stop();
+ mLooper->unregisterHandler(mReflector->id());
+}
+
+bool AsyncCodecSource::configure(const sp<AMessage> format, const sp<Surface> surface, uint32_t flags) {
+ mCodec->setCallback(mNotify);
+ status_t err = mCodec->configure(format, surface, nullptr /* crypto */, flags);
+ if (err != OK) {
+ ALOGE("Failed to configure codec '%s'", mComponentName.c_str());
+ return false;
+ }
+ mUsingSurface = surface != nullptr;
+
+ // Set output format metadata
+ sp<AMessage> outputFormat;
+ mCodec->getOutputFormat(&outputFormat);
+ sp<MetaData> meta = new MetaData;
+ convertMessageToMetaData(outputFormat, meta);
+ mMeta.lock().set(meta);
+
+ mOutput.lock()->mReachedEOS = false;
+ ALOGI("Configured codec '%s'!", mComponentName.c_str());
+ return true;
+}
+
+status_t AsyncCodecSource::start(MetaData *params) {
+ (void)params;
+ Mutexed<Output>::Locked me(mOutput);
+
+ if (mState != INIT) {
+ return -EINVAL;
+ }
+
+ status_t res = mCodec->start();
+ if (res == OK) {
+ res = mSource->start();
+ }
+
+ if (res == OK) {
+ mState = STARTED;
+ me->mReachedEOS = false;
+ } else {
+ mState = ERROR;
+ }
+ return res;
+}
+
+status_t AsyncCodecSource::stop() {
+ Mutexed<Output>::Locked me(mOutput);
+ if (mState != STARTED && mState != ERROR) {
+ return -EINVAL;
+ }
+
+ // wait for any pending reads to complete
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/AsyncCodecSource.h
^
|
| @@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2020 Open Mobile Platform LLC.
+ * Copyright 2016, 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 ASYNC_CODEC_SOURCE_H_
+#define ASYNC_CODEC_SOURCE_H_
+
+#include <media/openmax/OMX_IVCommon.h>
+#include <media/stagefright/foundation/AString.h>
+#include <media/stagefright/foundation/Mutexed.h>
+#include <media/stagefright/foundation/AHandlerReflector.h>
+#if ANDROID_MAJOR >= 9 && ANDROID_MAJOR <= 10
+#include <media/MediaSource.h>
+#else
+#include <media/stagefright/MediaSource.h>
+#endif
+#include <media/stagefright/MediaBuffer.h>
+#include <media/stagefright/MediaCodecSource.h>
+#include <utils/Condition.h>
+#include <utils/StrongPointer.h>
+
+struct ANativeWindow;
+
+namespace android {
+
+#if ANDROID_MAJOR < 9
+typedef MediaBuffer DroidMediaBuffer;
+#else
+typedef MediaBufferBase DroidMediaBuffer;
+#endif
+
+struct ALooper;
+struct AMessage;
+struct MediaCodec;
+class MetaData;
+class Surface;
+
+class AsyncCodecSource : public MediaSource {
+public:
+ static sp<MediaSource> Create(const sp<MediaSource> &source,
+ const sp<AMessage> &format, bool isEncoder, uint32_t flags,
+ const sp<ANativeWindow> &nativeWindow, const sp<ALooper> &looper,
+ const char *desiredCodec = NULL,
+ OMX_COLOR_FORMATTYPE colorFormat = OMX_COLOR_FormatUnused);
+
+ bool configure(const sp<AMessage> format,
+ const sp<Surface> surface,
+ uint32_t flags = 0);
+
+ virtual ~AsyncCodecSource();
+
+ // starts this source (and its underlying source). |params| is ignored.
+ virtual status_t start(MetaData *params = NULL);
+
+ // stops this source (and its underlying source).
+ virtual status_t stop();
+
+ // returns the output format of this source.
+ virtual sp<MetaData> getFormat();
+
+ // reads from the source. This call always blocks.
+ virtual status_t read(
+ android::DroidMediaBuffer **buffer,
+ const ReadOptions *options);
+
+ // for AHandlerReflector
+ void onMessageReceived(const sp<AMessage> &msg);
+
+ // unsupported methods
+ virtual status_t pause() { return INVALID_OPERATION; }
+
+ status_t setParameters(const sp<AMessage> ¶ms);
+private:
+ // Construct this using a codec, source and looper.
+ AsyncCodecSource(
+ const AString &codecName, const sp<MediaSource> &source, const sp<ALooper> &looper,
+ bool isVorbis);
+
+ AString mComponentName;
+ sp<MediaCodec> mCodec;
+ sp<MediaSource> mSource;
+ sp<ALooper> mLooper;
+ sp<ALooper> mCodecLooper;
+ sp<AMessage> mNotify = 0;
+ sp<AHandlerReflector<AsyncCodecSource> > mReflector;
+ List<size_t> mAvailInputIndices;
+ Mutexed<sp<MetaData>> mMeta;
+ bool mUsingSurface;
+ bool mIsVorbis;
+ bool mFeeding = false;
+ bool mOutputChanged = false;
+ enum State {
+ INIT,
+ STARTED,
+ STOPPING,
+ STOPPED,
+ ERROR,
+ };
+ State mState = INIT;
+
+ struct Output {
+ Output();
+
+ List<DroidMediaBuffer*> mBufferQueue;
+ bool mReachedEOS;
+ bool mReading = false;
+ Condition mAvailable;
+ Condition mReadCondition;
+ };
+ Mutexed<Output> mOutput;
+
+};
+
+} // namespace android
+
+#endif //ASYNC_DECODING_SOURCE_H_
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/droidmediacodec.cpp
^
|
| @@ -42,7 +42,7 @@
#include <media/stagefright/OMXCodec.h>
#else
#include <media/hardware/MetadataBufferType.h>
-#include "AsyncDecodingSource.h"
+#include "AsyncCodecSource.h"
#endif
#if ANDROID_MAJOR >= 9 && ANDROID_MAJOR <= 10
@@ -75,6 +75,9 @@
int key;
int type;
} metaDataKeys[] = {
+#if ANDROID_MAJOR >= 10
+ {android::MEDIA_MIMETYPE_VIDEO_AV1, android::kKeyAV1C, android::kKeyAV1C},
+#endif
#if ANDROID_MAJOR >= 5
{android::MEDIA_MIMETYPE_VIDEO_HEVC, android::kKeyHVCC, android::kKeyHVCC},
#endif
@@ -480,7 +483,10 @@
}
//TODO: time-scale
-#if ANDROID_MAJOR >= 6
+#if ANDROID_MAJOR > 6
+ return android::AsyncCodecSource::Create(src, format, true /* isEncoder */,
+ flags(), window, looper);
+#elif ANDROID_MAJOR == 6
return android::MediaCodecSource::Create(looper, format, src, NULL, flags());
#else
return android::MediaCodecSource::Create(looper, format, src, flags());
@@ -525,7 +531,9 @@
src,
NULL, flags(), window);
#else
- return android::AsyncDecodingSource::Create(src, flags(), window, looper);
+ return android::AsyncCodecSource::Create(src, nullptr, false /* isEncoder */,
+ flags(), window, looper, nullptr,
+ (OMX_COLOR_FORMATTYPE)m_dec->color_format);
#endif
}
@@ -876,7 +884,11 @@
codec->m_thread->requestExit();
// in case the thread is waiting in ->read()
droid_media_codec_drain (codec);
+ }
+#if ANDROID_MAJOR < 7
+ // On older devices the reader thread must be stopped first.
+ if (codec->m_thread != NULL) {
int err = codec->m_thread->requestExitAndWait();
if (err != android::NO_ERROR) {
@@ -886,10 +898,28 @@
codec->m_thread.clear();
}
+ // All buffers are returned to HAL, it is safe to stop now.
int err = codec->m_codec->stop();
if (err != android::OK) {
ALOGE("error 0x%x stopping codec", -err);
}
+#else
+ // Wake up AsyncCodecSource and send EOS to it.
+ int err = codec->m_codec->stop();
+ if (err != android::OK) {
+ ALOGE("error 0x%x stopping codec", -err);
+ }
+
+ if (codec->m_thread != NULL) {
+ int err = codec->m_thread->requestExitAndWait();
+
+ if (err != android::NO_ERROR) {
+ ALOGE("Error 0x%x stopping thread", -err);
+ }
+
+ codec->m_thread.clear();
+ }
+#endif
if (codec->m_queue.get()) {
codec->m_queue->buffersReleased();
@@ -975,7 +1005,10 @@
codec->m_cb.signal_eos (codec->m_cb_data);
}
- return DROID_MEDIA_CODEC_LOOP_EOS;
+ // Prevent new frames from being queued.
+ codec->m_src->drain();
+
+ return DROID_MEDIA_CODEC_LOOP_EOS;
} else {
ALOGE("Error 0x%x reading from codec", -err);
@@ -1141,4 +1174,19 @@
}
}
+bool droid_media_codec_set_video_encoder_bitrate(DroidMediaCodec *codec, int32_t bitrate)
+{
+#if ANDROID_MAJOR >= 7
+ ALOGI("Setting video encoder bitrate to %d bps", bitrate);
+ android::sp<android::AMessage> params = new android::AMessage();
+ params->setInt32("video-bitrate", bitrate);
+ android::sp<android::AsyncCodecSource> src =
+ static_cast<android::AsyncCodecSource*>(codec->m_codec.get());
+ android::status_t err = src->setParameters(params);
+ return err == android::NO_ERROR;
+#else
+ return false;
+#endif
+}
+
};
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/droidmediacodec.h
^
|
| @@ -58,6 +58,7 @@
DroidMediaCodecMetaData parent;
DroidMediaData codec_data;
+ int32_t color_format;
} DroidMediaCodecDecoderMetaData;
typedef struct DroidMediaCodecEncoderH264Settings {
@@ -118,6 +119,8 @@
DroidMediaCodecLoopReturn droid_media_codec_loop(DroidMediaCodec *codec);
void droid_media_codec_get_output_info(DroidMediaCodec *codec, DroidMediaCodecMetaData *info, DroidMediaRect *crop);
+bool droid_media_codec_set_video_encoder_bitrate(DroidMediaCodec *codec, int32_t bitrate);
+
#ifdef __cplusplus
};
#endif
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/droidmediaconstants.cpp
^
|
| @@ -74,9 +74,18 @@
#else
c->HAL_PIXEL_FORMAT_RAW_SENSOR = HAL_PIXEL_FORMAT_RAW16;
#endif
+#if ANDROID_MAJOR < 8
c->HAL_PIXEL_FORMAT_YCrCb_420_SP = HAL_PIXEL_FORMAT_YCrCb_420_SP;
c->HAL_PIXEL_FORMAT_YCbCr_422_SP = HAL_PIXEL_FORMAT_YCbCr_422_SP;
c->HAL_PIXEL_FORMAT_YCbCr_422_I = HAL_PIXEL_FORMAT_YCbCr_422_I;
+#else
+#undef HAL_PIXEL_FORMAT_YCrCb_420_SP
+#undef HAL_PIXEL_FORMAT_YCbCr_422_SP
+#undef HAL_PIXEL_FORMAT_YCbCr_422_I
+ c->HAL_PIXEL_FORMAT_YCrCb_420_SP = HAL_PIXEL_FORMAT_YCRCB_420_SP;
+ c->HAL_PIXEL_FORMAT_YCbCr_422_SP = HAL_PIXEL_FORMAT_YCBCR_422_SP;
+ c->HAL_PIXEL_FORMAT_YCbCr_422_I = HAL_PIXEL_FORMAT_YCBCR_422_I;
+#endif
c->QOMX_COLOR_FormatYUV420PackedSemiPlanar32m = 0x7FA30C04;
c->QOMX_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka = 0x7FA30C03;
}
@@ -97,6 +106,12 @@
c->OMX_COLOR_Format32bitBGRA8888 = OMX_COLOR_Format32bitBGRA8888;
c->OMX_COLOR_Format16bitRGB565 = OMX_COLOR_Format16bitRGB565;
c->OMX_COLOR_Format16bitBGR565 = OMX_COLOR_Format16bitBGR565;
+#if ANDROID_MAJOR >= 5
+ c->OMX_COLOR_FormatYUV420Flexible = OMX_COLOR_FormatYUV420Flexible;
+#else
+ // OMX_COLOR_FormatUnused = 0
+ c->OMX_COLOR_FormatYUV420Flexible = OMX_COLOR_FormatUnused;
+#endif
}
};
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/droidmediaconstants.h
^
|
| @@ -68,15 +68,9 @@
int HAL_PIXEL_FORMAT_BGRA_8888;
int HAL_PIXEL_FORMAT_YV12;
int HAL_PIXEL_FORMAT_RAW_SENSOR;
-#if ANDROID_MAJOR < 8
int HAL_PIXEL_FORMAT_YCrCb_420_SP;
int HAL_PIXEL_FORMAT_YCbCr_422_SP;
int HAL_PIXEL_FORMAT_YCbCr_422_I;
-#else
- int HAL_PIXEL_FORMAT_YCRCB_420_SP;
- int HAL_PIXEL_FORMAT_YCBCR_422_SP;
- int HAL_PIXEL_FORMAT_YCBCR_422_I;
-#endif
int QOMX_COLOR_FormatYUV420PackedSemiPlanar32m;
int QOMX_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka;
} DroidMediaPixelFormatConstants;
@@ -91,11 +85,12 @@
int OMX_COLOR_FormatL8;
int OMX_COLOR_FormatYCbYCr;
int OMX_COLOR_FormatYCrYCb;
- int OMX_COLOR_FormatCbYCrY;
+ int OMX_COLOR_FormatCbYCrY;
int OMX_COLOR_Format32bitARGB8888;
int OMX_COLOR_Format32bitBGRA8888;
int OMX_COLOR_Format16bitRGB565;
int OMX_COLOR_Format16bitBGR565;
+ int OMX_COLOR_FormatYUV420Flexible;
} DroidMediaColourFormatConstants;
void droid_media_camera_constants_init(DroidMediaCameraConstants *c);
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/hybris.c
^
|
| @@ -240,6 +240,7 @@
HYBRIS_WRAPPER_0_1(DroidMediaCodec *, droid_media_codec_drain);
HYBRIS_WRAPPER_1_1(DroidMediaCodecLoopReturn,DroidMediaCodec*,droid_media_codec_loop);
HYBRIS_WRAPPER_0_3(DroidMediaCodec*,DroidMediaCodecMetaData*,DroidMediaRect*,droid_media_codec_get_output_info);
+HYBRIS_WRAPPER_1_2(bool,DroidMediaCodec*,int32_t,droid_media_codec_set_video_encoder_bitrate);
HYBRIS_WRAPPER_0_0(_droid_media_init)
HYBRIS_WRAPPER_0_0(droid_media_deinit)
HYBRIS_WRAPPER_1_2(DroidMediaBuffer*,DroidMediaBufferQueue*,DroidMediaBufferCallbacks*,droid_media_buffer_queue_acquire_buffer)
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/init/minimediaservice.rc
^
|
| @@ -0,0 +1,5 @@
+service minimedia /usr/libexec/droid-hybris/system/bin/minimediaservice
+ class main
+ user media
+ group audio camera
+ ioprio rt 4
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/init/minisfservice.rc
^
|
| @@ -0,0 +1,4 @@
+service minisf /usr/libexec/droid-hybris/system/bin/minisfservice
+ class main
+ user system
+ group graphics
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/meson.build
^
|
| @@ -20,7 +20,6 @@
dependencies: cc.find_library('dl', required : true))
droidmedia_headers = [
- 'droidmediabuffer.h',
'droidmediacamera.h',
'droidmediacodec.h',
'droidmediaconstants.h',
|
|
[-]
[+]
|
Changed |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/minimedia.cpp
^
|
| @@ -20,9 +20,6 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <CameraService.h>
-#ifdef AUDIOPOLICYSERVICE_ENABLE
-#include <AudioPolicyService.h>
-#endif
#include <binder/MemoryHeapBase.h>
#include <MediaPlayerService.h>
#if ANDROID_MAJOR >= 6
@@ -39,6 +36,9 @@
#include "allocator.h"
#endif
#include "services/services.h"
+#if ANDROID_MAJOR >= 5
+#include "services/audiopolicy/audiopolicy.h"
+#endif
#include <cutils/properties.h>
@@ -64,8 +64,8 @@
FakeActivityManager::instantiate();
#endif
MediaPlayerService::instantiate();
-#ifdef AUDIOPOLICYSERVICE_ENABLE
- AudioPolicyService::instantiate();
+#if ANDROID_MAJOR >= 5
+ FakeAudioPolicyService::instantiate();
#endif
// PermissionController and AppOps are needed on Android 4, but aren't allowed to be run here.
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/services/audiopolicy/audiopolicy.h
^
|
| @@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 Jolla Ltd.
+ *
+ * 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.
+ *
+ */
+
+#if ANDROID_MAJOR == 5 && ANDROID_MINOR == 1
+#include "audiopolicy_5_1_0.h"
+#endif
+
+#if ANDROID_MAJOR == 6 && ANDROID_MINOR == 0
+#include "audiopolicy_6_0_0.h"
+#endif
+
+#if ANDROID_MAJOR == 7
+#include "audiopolicy_7_x_x.h"
+#endif
+
+#if ANDROID_MAJOR == 8 && ANDROID_MINOR == 1
+#include "audiopolicy_8_1_0.h"
+#endif
+
+#if ANDROID_MAJOR == 9
+#include "audiopolicy_9_0_0.h"
+#endif
+
+#if ANDROID_MAJOR == 10
+#include "audiopolicy_10_0_0.h"
+#endif
+
+#if ANDROID_MAJOR == 11
+#include "audiopolicy_11_0_0.h"
+#endif
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/services/audiopolicy/audiopolicy_10_0_0.h
^
|
| @@ -0,0 +1,480 @@
+/* -*- c++ -*-
+ * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2022 Jolla Ltd.
+ *
+ * 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 FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+#define FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+
+#include <cutils/misc.h>
+#include <cutils/config_utils.h>
+#include <cutils/compiler.h>
+#include <utils/String8.h>
+#include <utils/Vector.h>
+#include <utils/SortedVector.h>
+#include <binder/BinderService.h>
+#include <binder/IUidObserver.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <media/IAudioPolicyService.h>
+#include <AudioPolicyInterface.h>
+
+#include <unordered_map>
+
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+class FakeAudioPolicyService :
+ public BinderService<FakeAudioPolicyService>,
+ public BnAudioPolicyService,
+ public IBinder::DeathRecipient
+{
+ friend class BinderService<FakeAudioPolicyService>;
+
+public:
+ // for BinderService
+ static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
+
+ virtual status_t dump(int fd, const Vector<String16>& args) { return NO_ERROR; }
+
+ //
+ // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
+ //
+
+ virtual status_t setDeviceConnectionState(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name,
+ audio_format_t encodedFormat) {
+ return NO_ERROR;
+
+ }
+ virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
+ const char *device_address) {
+ return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ }
+ virtual status_t handleDeviceConfigChange(audio_devices_t device,
+ const char *device_address,
+ const char *device_name,
+ audio_format_t encodedFormat) {
+ return NO_ERROR;
+ }
+ virtual status_t setPhoneState(audio_mode_t state) {
+ return NO_ERROR;
+ }
+ virtual status_t setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t config) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) {
+ return AUDIO_POLICY_FORCE_NONE;
+ }
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream) {
+ return AUDIO_IO_HANDLE_NONE;
+ }
+ status_t getOutputForAttr(audio_attributes_t *attr,
+ audio_io_handle_t *output,
+ audio_session_t session,
+ audio_stream_type_t *stream,
+ pid_t pid,
+ uid_t uid,
+ const audio_config_t *config,
+ audio_output_flags_t flags,
+ audio_port_handle_t *selectedDeviceId,
+ audio_port_handle_t *portId,
+ std::vector<audio_io_handle_t> *secondaryOutputs) override {
+ return NO_ERROR;
+ }
+ virtual status_t startOutput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual status_t stopOutput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual void releaseOutput(audio_port_handle_t portId) {
+ return;
+ }
+ virtual status_t getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_unique_id_t riid,
+ audio_session_t session,
+ pid_t pid,
+ uid_t uid,
+ const String16& opPackageName,
+ const audio_config_base_t *config,
+ audio_input_flags_t flags,
+ audio_port_handle_t *selectedDeviceId = NULL,
+ audio_port_handle_t *portId = NULL) {
+ return NO_ERROR;
+ }
+ virtual status_t startInput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual status_t stopInput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual void releaseInput(audio_port_handle_t portId) {
+ return;
+ }
+ virtual status_t initStreamVolume(audio_stream_type_t stream,
+ int indexMin,
+ int indexMax) {
+ return NO_ERROR;
+ }
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
+ int *index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index) {
+ return NO_ERROR;
+ }
+ virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index) {
+ return NO_ERROR;
+ }
+
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream) {
+ return PRODUCT_STRATEGY_NONE;
+ }
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) {
+ return AUDIO_DEVICE_NONE;
+ }
+
+ virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) {
+ return 0;
+ }
+ virtual status_t registerEffect(const effect_descriptor_t *desc,
+ audio_io_handle_t io,
+ uint32_t strategy,
+ audio_session_t session,
+ int id) {
+ return NO_ERROR;
+ }
+ virtual status_t unregisterEffect(int id) { return NO_ERROR; }
+ virtual status_t setEffectEnabled(int id, bool enabled) { return NO_ERROR; }
+ status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override {
+ return NO_ERROR;
+ }
+ virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isStreamActiveRemotely(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isSourceActive(audio_source_t source) const { return false; }
+
+ virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/services/audiopolicy/audiopolicy_11_0_0.h
^
|
| @@ -0,0 +1,531 @@
+/* -*- c++ -*-
+ * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2022 Jolla Ltd.
+ *
+ * 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 FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+#define FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+
+#include <cutils/misc.h>
+#include <cutils/config_utils.h>
+#include <cutils/compiler.h>
+#include <utils/String8.h>
+#include <utils/Vector.h>
+#include <utils/SortedVector.h>
+#include <binder/BinderService.h>
+#include <binder/IUidObserver.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <media/IAudioPolicyService.h>
+#include <AudioPolicyInterface.h>
+
+#include <unordered_map>
+
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+class FakeAudioPolicyService :
+ public BinderService<FakeAudioPolicyService>,
+ public BnAudioPolicyService,
+ public IBinder::DeathRecipient
+{
+ friend class BinderService<FakeAudioPolicyService>;
+
+public:
+ // for BinderService
+ static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
+
+ virtual status_t dump(int fd, const Vector<String16>& args) { return NO_ERROR; }
+
+ //
+ // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
+ //
+
+ void onNewAudioModulesAvailable() override {
+ return;
+ }
+ virtual status_t setDeviceConnectionState(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name,
+ audio_format_t encodedFormat) {
+ return NO_ERROR;
+
+ }
+ virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
+ const char *device_address) {
+ return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ }
+ virtual status_t handleDeviceConfigChange(audio_devices_t device,
+ const char *device_address,
+ const char *device_name,
+ audio_format_t encodedFormat) {
+ return NO_ERROR;
+ }
+ virtual status_t setPhoneState(audio_mode_t state, uid_t uid) {
+ return NO_ERROR;
+ }
+ virtual status_t setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t config) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) {
+ return AUDIO_POLICY_FORCE_NONE;
+ }
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream) {
+ return AUDIO_IO_HANDLE_NONE;
+ }
+ status_t getOutputForAttr(audio_attributes_t *attr,
+ audio_io_handle_t *output,
+ audio_session_t session,
+ audio_stream_type_t *stream,
+ pid_t pid,
+ uid_t uid,
+ const audio_config_t *config,
+ audio_output_flags_t flags,
+ audio_port_handle_t *selectedDeviceId,
+ audio_port_handle_t *portId,
+ std::vector<audio_io_handle_t> *secondaryOutputs) override {
+ return NO_ERROR;
+ }
+ virtual status_t startOutput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual status_t stopOutput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual void releaseOutput(audio_port_handle_t portId) {
+ return;
+ }
+ virtual status_t getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_unique_id_t riid,
+ audio_session_t session,
+ pid_t pid,
+ uid_t uid,
+ const String16& opPackageName,
+ const audio_config_base_t *config,
+ audio_input_flags_t flags,
+ audio_port_handle_t *selectedDeviceId = NULL,
+ audio_port_handle_t *portId = NULL) {
+ return NO_ERROR;
+ }
+ virtual status_t startInput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual status_t stopInput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual void releaseInput(audio_port_handle_t portId) {
+ return;
+ }
+ virtual status_t initStreamVolume(audio_stream_type_t stream,
+ int indexMin,
+ int indexMax) {
+ return NO_ERROR;
+ }
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
+ int *index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index) {
+ return NO_ERROR;
+ }
+ virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index) {
+ return NO_ERROR;
+ }
+
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream) {
+ return PRODUCT_STRATEGY_NONE;
+ }
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) {
+ return AUDIO_DEVICE_NONE;
+ }
+ virtual status_t getDevicesForAttributes(const AudioAttributes &aa,
+ AudioDeviceTypeAddrVector *devices) const {
+ return NO_ERROR;
+ }
+
+ virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) {
+ return 0;
+ }
+ virtual status_t registerEffect(const effect_descriptor_t *desc,
+ audio_io_handle_t io,
+ uint32_t strategy,
+ audio_session_t session,
+ int id) {
+ return NO_ERROR;
+ }
+ virtual status_t unregisterEffect(int id) { return NO_ERROR; }
+ virtual status_t setEffectEnabled(int id, bool enabled) { return NO_ERROR; }
+ status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override {
+ return NO_ERROR;
+ }
+ virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const {
+ return false;
+ }
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/services/audiopolicy/audiopolicy_5_1_0.h
^
|
| @@ -0,0 +1,298 @@
+/* -*- c++ -*-
+ * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2022 Jolla Ltd.
+ *
+ * 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 FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+#define FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+
+#include <cutils/misc.h>
+#include <cutils/config_utils.h>
+#include <cutils/compiler.h>
+#include <utils/String8.h>
+#include <utils/Vector.h>
+#include <utils/SortedVector.h>
+#include <binder/BinderService.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <hardware/audio_policy.h>
+#include <media/IAudioPolicyService.h>
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+class FakeAudioPolicyService :
+ public BinderService<FakeAudioPolicyService>,
+ public BnAudioPolicyService,
+ public IBinder::DeathRecipient
+{
+ friend class BinderService<FakeAudioPolicyService>;
+
+public:
+ // for BinderService
+ static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
+
+ virtual status_t dump(int fd, const Vector<String16>& args) { return NO_ERROR; }
+
+ //
+ // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
+ //
+
+ virtual status_t setDeviceConnectionState(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
+ const char *device_address) {
+ return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ }
+ virtual status_t setPhoneState(audio_mode_t state) { return NO_ERROR; }
+ virtual status_t setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t config) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) {
+ return AUDIO_POLICY_FORCE_NONE;
+ }
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
+ uint32_t samplingRate = 0,
+ audio_format_t format = AUDIO_FORMAT_DEFAULT,
+ audio_channel_mask_t channelMask = 0,
+ audio_output_flags_t flags =
+ AUDIO_OUTPUT_FLAG_NONE,
+ const audio_offload_info_t *offloadInfo = NULL) {
+ return AUDIO_IO_HANDLE_NONE;
+ }
+ virtual status_t getOutputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *output,
+ audio_session_t session,
+ audio_stream_type_t *stream,
+ uint32_t samplingRate = 0,
+ audio_format_t format = AUDIO_FORMAT_DEFAULT,
+ audio_channel_mask_t channelMask = 0,
+ audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,
+ const audio_offload_info_t *offloadInfo = NULL) {
+ return NO_ERROR;
+ }
+ virtual status_t startOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_session_t session,
+ uint32_t samplingRate,
+ audio_format_t format,
+ audio_channel_mask_t channelMask,
+ audio_input_flags_t flags) {
+ return NO_ERROR;
+ }
+ virtual status_t startInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t initStreamVolume(audio_stream_type_t stream,
+ int indexMin,
+ int indexMax){
+ return NO_ERROR;
+ }
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
+ int *index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream) {
+ return 0;
+ }
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) {
+ return AUDIO_DEVICE_NONE;
+ }
+ virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) {
+ return 0;
+ }
+ virtual status_t registerEffect(const effect_descriptor_t *desc,
+ audio_io_handle_t io,
+ uint32_t strategy,
+ int session,
+ int id) {
+ return NO_ERROR;
+ }
+ virtual status_t unregisterEffect(int id) { return NO_ERROR; }
+ virtual status_t setEffectEnabled(int id, bool enabled) { return NO_ERROR; }
+ virtual bool isStreamActive(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isStreamActiveRemotely(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isSourceActive(audio_source_t source) const { return false; }
+ virtual status_t queryDefaultPreProcessing(int audioSession,
+ effect_descriptor_t *descriptors,
+ uint32_t *count) {
+ return NO_ERROR;
+ }
+ virtual status_t onTransact(
+ uint32_t code,
+ const Parcel& data,
+ Parcel* reply,
+ uint32_t flags) {
+ return NO_ERROR;
+ }
+ // IBinder::DeathRecipient
+ virtual void binderDied(const wp<IBinder>& who) { return; }
+
+ // RefBase
+ virtual void onFirstRef() { return; }
+
+ //
+ // Helpers for the struct audio_policy_service_ops implementation.
+ // This is used by the audio policy manager for certain operations that
+ // are implemented by the policy service.
+ //
+ virtual void setParameters(audio_io_handle_t ioHandle,
+ const char *keyValuePairs,
+ int delayMs) {
+ return;
+ }
+ virtual status_t setStreamVolume(audio_stream_type_t stream,
+ float volume,
+ audio_io_handle_t output,
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/services/audiopolicy/audiopolicy_6_0_0.h
^
|
| @@ -0,0 +1,311 @@
+/* -*- c++ -*-
+ * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2022 Jolla Ltd.
+ *
+ * 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 FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+#define FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+
+#include <cutils/misc.h>
+#include <cutils/config_utils.h>
+#include <cutils/compiler.h>
+#include <utils/String8.h>
+#include <utils/Vector.h>
+#include <utils/SortedVector.h>
+#include <binder/BinderService.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <hardware/audio_policy.h>
+#include <media/IAudioPolicyService.h>
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+class FakeAudioPolicyService :
+ public BinderService<FakeAudioPolicyService>,
+ public BnAudioPolicyService,
+ public IBinder::DeathRecipient
+{
+ friend class BinderService<FakeAudioPolicyService>;
+
+public:
+ // for BinderService
+ static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
+
+ virtual status_t dump(int fd, const Vector<String16>& args) { return NO_ERROR; }
+
+ //
+ // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
+ //
+
+ virtual status_t setDeviceConnectionState(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
+ const char *device_address) {
+ return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ }
+ virtual status_t setPhoneState(audio_mode_t state) { return NO_ERROR; }
+ virtual status_t setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t config) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) {
+ return AUDIO_POLICY_FORCE_NONE;
+ }
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
+ uint32_t samplingRate = 0,
+ audio_format_t format = AUDIO_FORMAT_DEFAULT,
+ audio_channel_mask_t channelMask = 0,
+ audio_output_flags_t flags =
+ AUDIO_OUTPUT_FLAG_NONE,
+ const audio_offload_info_t *offloadInfo = NULL) {
+ return AUDIO_IO_HANDLE_NONE;
+ }
+ virtual status_t getOutputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *output,
+ audio_session_t session,
+ audio_stream_type_t *stream,
+ uid_t uid,
+ uint32_t samplingRate = 0,
+ audio_format_t format = AUDIO_FORMAT_DEFAULT,
+ audio_channel_mask_t channelMask = 0,
+ audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,
+ audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE,
+ const audio_offload_info_t *offloadInfo = NULL) {
+ return NO_ERROR;
+ }
+ virtual status_t startOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_session_t session,
+ uid_t uid,
+ uint32_t samplingRate,
+ audio_format_t format,
+ audio_channel_mask_t channelMask,
+ audio_input_flags_t flags,
+ audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE) {
+ return NO_ERROR;
+ }
+ virtual status_t startInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t initStreamVolume(audio_stream_type_t stream,
+ int indexMin,
+ int indexMax){
+ return NO_ERROR;
+ }
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
+ int *index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream) {
+ return 0;
+ }
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) {
+ return AUDIO_DEVICE_NONE;
+ }
+ virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) {
+ return 0;
+ }
+ virtual status_t registerEffect(const effect_descriptor_t *desc,
+ audio_io_handle_t io,
+ uint32_t strategy,
+ int session,
+ int id) {
+ return NO_ERROR;
+ }
+ virtual status_t unregisterEffect(int id) { return NO_ERROR; }
+ virtual status_t setEffectEnabled(int id, bool enabled) { return NO_ERROR; }
+ virtual bool isStreamActive(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isStreamActiveRemotely(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isSourceActive(audio_source_t source) const { return false; }
+ virtual status_t queryDefaultPreProcessing(int audioSession,
+ effect_descriptor_t *descriptors,
+ uint32_t *count) {
+ return NO_ERROR;
+ }
+ virtual status_t onTransact(
+ uint32_t code,
+ const Parcel& data,
+ Parcel* reply,
+ uint32_t flags) {
+ return NO_ERROR;
+ }
+ // IBinder::DeathRecipient
+ virtual void binderDied(const wp<IBinder>& who) { return; }
+
+ // RefBase
+ virtual void onFirstRef() { return; }
+
+ //
+ // Helpers for the struct audio_policy_service_ops implementation.
+ // This is used by the audio policy manager for certain operations that
+ // are implemented by the policy service.
+ //
+ virtual void setParameters(audio_io_handle_t ioHandle,
+ const char *keyValuePairs,
+ int delayMs) {
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/services/audiopolicy/audiopolicy_7_x_x.h
^
|
| @@ -0,0 +1,367 @@
+/* -*- c++ -*-
+ * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2022 Jolla Ltd.
+ *
+ * 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 FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+#define FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+
+#include <cutils/misc.h>
+#include <cutils/config_utils.h>
+#include <cutils/compiler.h>
+#include <utils/String8.h>
+#include <utils/Vector.h>
+#include <utils/SortedVector.h>
+#include <binder/BinderService.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <hardware/audio_policy.h>
+#include <media/IAudioPolicyService.h>
+
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+class FakeAudioPolicyService :
+ public BinderService<FakeAudioPolicyService>,
+ public BnAudioPolicyService,
+ public IBinder::DeathRecipient
+{
+ friend class BinderService<FakeAudioPolicyService>;
+
+public:
+ // for BinderService
+ static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
+
+ virtual status_t dump(int fd, const Vector<String16>& args) { return NO_ERROR; }
+
+ //
+ // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
+ //
+
+ virtual status_t setDeviceConnectionState(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
+ const char *device_address) {
+ return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ }
+ virtual status_t setPhoneState(audio_mode_t state) { return NO_ERROR; }
+ virtual status_t setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t config) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) {
+ return AUDIO_POLICY_FORCE_NONE;
+ }
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
+ uint32_t samplingRate = 0,
+ audio_format_t format = AUDIO_FORMAT_DEFAULT,
+ audio_channel_mask_t channelMask = 0,
+ audio_output_flags_t flags =
+ AUDIO_OUTPUT_FLAG_NONE,
+ const audio_offload_info_t *offloadInfo = NULL) {
+ return AUDIO_IO_HANDLE_NONE;
+ }
+ virtual status_t getOutputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *output,
+ audio_session_t session,
+ audio_stream_type_t *stream,
+ uid_t uid,
+ uint32_t samplingRate = 0,
+ audio_format_t format = AUDIO_FORMAT_DEFAULT,
+ audio_channel_mask_t channelMask = 0,
+ audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,
+ audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE,
+ const audio_offload_info_t *offloadInfo = NULL) {
+ return NO_ERROR;
+ }
+ virtual status_t startOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_session_t session,
+ pid_t pid,
+ uid_t uid,
+ uint32_t samplingRate,
+ audio_format_t format,
+ audio_channel_mask_t channelMask,
+ audio_input_flags_t flags,
+ audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE) {
+ return NO_ERROR;
+ }
+ virtual status_t startInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t initStreamVolume(audio_stream_type_t stream,
+ int indexMin,
+ int indexMax) {
+ return NO_ERROR;
+ }
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
+ int *index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream) {
+ return 0;
+ }
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) {
+ return AUDIO_DEVICE_NONE;
+ }
+ virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) {
+ return 0;
+ }
+ virtual status_t registerEffect(const effect_descriptor_t *desc,
+ audio_io_handle_t io,
+ uint32_t strategy,
+ audio_session_t session,
+ int id) {
+ return NO_ERROR;
+ }
+ virtual status_t unregisterEffect(int id) { return NO_ERROR; }
+ virtual status_t setEffectEnabled(int id, bool enabled) { return NO_ERROR; }
+ virtual bool isStreamActive(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isStreamActiveRemotely(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isSourceActive(audio_source_t source) const { return false; }
+ virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
+ effect_descriptor_t *descriptors,
+ uint32_t *count) {
+ return NO_ERROR;
+ }
+ virtual status_t onTransact(
+ uint32_t code,
+ const Parcel& data,
+ Parcel* reply,
+ uint32_t flags) {
+ return NO_ERROR;
+ }
+ // IBinder::DeathRecipient
+ virtual void binderDied(const wp<IBinder>& who) { return; }
+
+ // RefBase
+ virtual void onFirstRef() { return; }
+
+ //
+ // Helpers for the struct audio_policy_service_ops implementation.
+ // This is used by the audio policy manager for certain operations that
+ // are implemented by the policy service.
+ //
+ virtual void setParameters(audio_io_handle_t ioHandle,
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/services/audiopolicy/audiopolicy_8_1_0.h
^
|
| @@ -0,0 +1,335 @@
+/* -*- c++ -*-
+ * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2022 Jolla Ltd.
+ *
+ * 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 FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+#define FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+
+#include <cutils/misc.h>
+#include <cutils/config_utils.h>
+#include <cutils/compiler.h>
+#include <utils/String8.h>
+#include <utils/Vector.h>
+#include <utils/SortedVector.h>
+#include <binder/BinderService.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <media/IAudioPolicyService.h>
+
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+class FakeAudioPolicyService :
+ public BinderService<FakeAudioPolicyService>,
+ public BnAudioPolicyService,
+ public IBinder::DeathRecipient
+{
+ friend class BinderService<FakeAudioPolicyService>;
+
+public:
+ // for BinderService
+ static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
+
+ virtual status_t dump(int fd, const Vector<String16>& args) { return NO_ERROR; }
+
+ //
+ // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
+ //
+
+ virtual status_t setDeviceConnectionState(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_dev_state_t getDeviceConnectionState(
+ audio_devices_t device,
+ const char *device_address) {
+ return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ }
+ virtual status_t handleDeviceConfigChange(audio_devices_t device,
+ const char *device_address,
+ const char *device_name) {
+ return NO_ERROR;
+ }
+ virtual status_t setPhoneState(audio_mode_t state) {
+ return NO_ERROR;
+ }
+ virtual status_t setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t config) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) {
+ return AUDIO_POLICY_FORCE_NONE;
+ }
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
+ uint32_t samplingRate = 0,
+ audio_format_t format = AUDIO_FORMAT_DEFAULT,
+ audio_channel_mask_t channelMask = 0,
+ audio_output_flags_t flags =
+ AUDIO_OUTPUT_FLAG_NONE,
+ const audio_offload_info_t *offloadInfo = NULL) {
+ return AUDIO_IO_HANDLE_NONE;
+ }
+ virtual status_t getOutputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *output,
+ audio_session_t session,
+ audio_stream_type_t *stream,
+ uid_t uid,
+ const audio_config_t *config,
+ audio_output_flags_t flags,
+ audio_port_handle_t *selectedDeviceId,
+ audio_port_handle_t *portId) {
+ return NO_ERROR;
+ }
+ virtual status_t startOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_session_t session,
+ pid_t pid,
+ uid_t uid,
+ const audio_config_base_t *config,
+ audio_input_flags_t flags,
+ audio_port_handle_t *selectedDeviceId = NULL,
+ audio_port_handle_t *portId = NULL) {
+ return NO_ERROR;
+ }
+ virtual status_t startInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseInput(audio_io_handle_t input,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t initStreamVolume(audio_stream_type_t stream,
+ int indexMin,
+ int indexMax) {
+ return NO_ERROR;
+ }
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
+ int *index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream) {
+ return 0;
+ }
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) {
+ return AUDIO_DEVICE_NONE;
+ }
+ virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) {
+ return 0;
+ }
+ virtual status_t registerEffect(const effect_descriptor_t *desc,
+ audio_io_handle_t io,
+ uint32_t strategy,
+ audio_session_t session,
+ int id) {
+ return NO_ERROR;
+ }
+ virtual status_t unregisterEffect(int id) { return NO_ERROR; }
+ virtual status_t setEffectEnabled(int id, bool enabled) { return NO_ERROR; }
+ virtual bool isStreamActive(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isStreamActiveRemotely(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isSourceActive(audio_source_t source) const { return false; }
+ virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
+ effect_descriptor_t *descriptors,
+ uint32_t *count) {
+ return NO_ERROR;
+ }
+ virtual status_t onTransact(
+ uint32_t code,
+ const Parcel& data,
+ Parcel* reply,
+ uint32_t flags) {
+ return NO_ERROR;
+ }
+ // IBinder::DeathRecipient
+ virtual void binderDied(const wp<IBinder>& who) { return; }
+ // RefBase
+ virtual void onFirstRef() { return; }
+ //
+ // Helpers for the struct audio_policy_service_ops implementation.
+ // This is used by the audio policy manager for certain operations that
+ // are implemented by the policy service.
|
|
[-]
[+]
|
Added |
_service:tar_git:droidmedia-devel-0.20220929.0.tgz/services/audiopolicy/audiopolicy_9_0_0.h
^
|
| @@ -0,0 +1,350 @@
+/* -*- c++ -*-
+ * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2022 Jolla Ltd.
+ *
+ * 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 FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+#define FAKE_ANDROID_AUDIOPOLICYSERVICE_H
+
+#include <cutils/misc.h>
+#include <cutils/config_utils.h>
+#include <cutils/compiler.h>
+#include <utils/String8.h>
+#include <utils/Vector.h>
+#include <utils/SortedVector.h>
+#include <binder/BinderService.h>
+#include <binder/IUidObserver.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <media/IAudioPolicyService.h>
+
+#include <unordered_map>
+
+namespace android {
+
+using namespace std;
+
+// ----------------------------------------------------------------------------
+
+class FakeAudioPolicyService :
+ public BinderService<FakeAudioPolicyService>,
+ public BnAudioPolicyService,
+ public IBinder::DeathRecipient
+{
+ friend class BinderService<FakeAudioPolicyService>;
+
+public:
+ // for BinderService
+ static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
+
+ virtual status_t dump(int fd, const Vector<String16>& args) { return NO_ERROR; }
+
+ //
+ // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
+ //
+
+ virtual status_t setDeviceConnectionState(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_dev_state_t getDeviceConnectionState(
+ audio_devices_t device,
+ const char *device_address) {
+ return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ }
+ virtual status_t handleDeviceConfigChange(audio_devices_t device,
+ const char *device_address,
+ const char *device_name) {
+ return NO_ERROR;
+ }
+ virtual status_t setPhoneState(audio_mode_t state) {
+ return NO_ERROR;
+ }
+ virtual status_t setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t config) {
+ return NO_ERROR;
+ }
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) {
+ return AUDIO_POLICY_FORCE_NONE;
+ }
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream) {
+ return AUDIO_IO_HANDLE_NONE;
+ }
+ virtual status_t getOutputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *output,
+ audio_session_t session,
+ audio_stream_type_t *stream,
+ pid_t pid,
+ uid_t uid,
+ const audio_config_t *config,
+ audio_output_flags_t flags,
+ audio_port_handle_t *selectedDeviceId,
+ audio_port_handle_t *portId) {
+ return NO_ERROR;
+ }
+ virtual status_t startOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual status_t stopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual void releaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ virtual status_t getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_session_t session,
+ pid_t pid,
+ uid_t uid,
+ const String16& opPackageName,
+ const audio_config_base_t *config,
+ audio_input_flags_t flags,
+ audio_port_handle_t *selectedDeviceId = NULL,
+ audio_port_handle_t *portId = NULL) {
+ return NO_ERROR;
+ }
+ virtual status_t startInput(audio_port_handle_t portId,
+ bool *silenced) {
+ return NO_ERROR;
+ }
+ virtual status_t stopInput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ virtual void releaseInput(audio_port_handle_t portId) {
+ return;
+ }
+ virtual status_t initStreamVolume(audio_stream_type_t stream,
+ int indexMin,
+ int indexMax) {
+ return NO_ERROR;
+ }
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
+ int index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
+ int *index,
+ audio_devices_t device) {
+ return NO_ERROR;
+ }
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream) {
+ return 0;
+ }
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) {
+ return AUDIO_DEVICE_NONE;
+ }
+ virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) {
+ return 0;
+ }
+ virtual status_t registerEffect(const effect_descriptor_t *desc,
+ audio_io_handle_t io,
+ uint32_t strategy,
+ audio_session_t session,
+ int id) {
+ return NO_ERROR;
+ }
+ virtual status_t unregisterEffect(int id) { return NO_ERROR; }
+ virtual status_t setEffectEnabled(int id, bool enabled) { return NO_ERROR; }
+ virtual bool isStreamActive(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isStreamActiveRemotely(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const {
+ return false;
+ }
+ virtual bool isSourceActive(audio_source_t source) const { return false; }
+ virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
+ effect_descriptor_t *descriptors,
+ uint32_t *count) {
+ return NO_ERROR;
+ }
+ virtual status_t onTransact(uint32_t code,
+ const Parcel& data,
+ Parcel* reply,
+ uint32_t flags) {
+ return NO_ERROR;
+ }
+ // IBinder::DeathRecipient
+ virtual void binderDied(const wp<IBinder>& who) {
+ return;
+ }
+ // RefBase
+ virtual void onFirstRef() {
+ return;
+ }
+ //
+ // Helpers for the struct audio_policy_service_ops implementation.
+ // This is used by the audio policy manager for certain operations that
|
