[-]
[+]
|
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() {
- Mutexed<sp<MetaData>>::Locked meta(mMeta);
- return *meta;
-}
-
-AsyncDecodingSource::Output::Output()
- : mReachedEOS(false),
- mReading(false) {
-}
-
-status_t AsyncDecodingSource::read(
- DroidMediaBuffer **buffer,
- const ReadOptions *options) {
- *buffer = nullptr;
- Mutexed<Output>::Locked me(mOutput);
- me->mReading = true;
- status_t res = OK;
-
- if (mState != STARTED) {
- return ERROR_END_OF_STREAM;
- }
-
- // flush codec on seek
- MediaSource::ReadOptions::SeekMode mode;
- int64_t timeUs = 0ll;
- if (options != nullptr && options->getSeekTo(&timeUs, &mode)) {
- me->mReachedEOS = false;
- mCodec->flush();
- }
-
- *buffer = nullptr;
- while (me->mBufferQueue.size() == 0 && !me->mReachedEOS) {
- ALOGV("[%s] Waiting for output.", mComponentName.c_str());
- me.waitForCondition(me->mAvailable);
- }
-
- if (mState == ERROR) {
- res = ERROR;
- }
- else if (!me->mBufferQueue.empty()) {
- *buffer = *me->mBufferQueue.begin();
- me->mBufferQueue.erase(me->mBufferQueue.begin());
- if (mOutputChanged && (*buffer)->size() == 0) {
- mOutputChanged = false;
- res = INFO_FORMAT_CHANGED;
- }
- }
- else if (me->mReachedEOS) {
- res = ERROR_END_OF_STREAM;
- }
-
- me->mReading = false;
- if (mState != STARTED) {
- me->mReadCondition.signal();
- }
-
- return res;
-}
-
-void AsyncDecodingSource::onMessageReceived(const sp<AMessage> &msg) {
-
- if (mCodec == nullptr) {
- return;
- }
-
- int32_t cbID;
- CHECK(msg->findInt32("callbackID", &cbID));
- if (cbID == MediaCodec::CB_INPUT_AVAILABLE) {
- int32_t index;
- CHECK(msg->findInt32("index", &index));
- ALOGV("[%s] Got input buffer #%d", mComponentName.c_str(), index);
- mAvailInputIndices.push_back(index);
- if (!mFeeding) {
- while (!mAvailInputIndices.empty()) {
- DroidMediaBuffer *srcbuf = nullptr;
- mFeeding = true;
- size_t bufferIndex = *mAvailInputIndices.begin();
- mAvailInputIndices.erase(mAvailInputIndices.begin());
- mSource->read(&srcbuf);
- uint32_t flags = 0;
- int64_t timeUs = 0ll;
-
- if (srcbuf != nullptr) {
-#if ANDROID_MAJOR >= 9
- CHECK(srcbuf->meta_data().findInt64(kKeyTime, &timeUs));
-#else
- CHECK(srcbuf->meta_data()->findInt64(kKeyTime, &timeUs));
-#endif
-
- sp<MediaCodecBuffer> inbuf;
- status_t err = mCodec->getInputBuffer(bufferIndex, &inbuf);
-
- if (err != OK || inbuf == nullptr || inbuf->data() == nullptr) {
- ALOGE("[%s] Error: Input buffer #%d invalid.", mComponentName.c_str(), index);
- srcbuf->release();
- mState = ERROR;
- return;
- }
-
- size_t cpLen = min(srcbuf->range_length(), inbuf->capacity());
- memcpy(inbuf->base(), (uint8_t *)srcbuf->data() + srcbuf->range_offset(),
- cpLen );
-
- if (mIsVorbis) {
- int32_t numPageSamples;
- if (!
-#if ANDROID_MAJOR >= 9
- srcbuf->meta_data().findInt32(kKeyValidSamples, &numPageSamples)
-#else
- srcbuf->meta_data()->findInt32(kKeyValidSamples, &numPageSamples)
-#endif
- ) {
- numPageSamples = -1;
- }
- memcpy(inbuf->base() + cpLen, &numPageSamples, sizeof(numPageSamples));
- }
-
- status_t res = mCodec->queueInputBuffer(
- bufferIndex, 0 /* offset */, srcbuf->range_length() + (mIsVorbis ? 4 : 0),
- timeUs, 0 /* flags */);
- if (res != OK) {
- ALOGE("[%s] failed to queue input buffer #%d", mComponentName.c_str(), index);
- mState = ERROR;
- }
- ALOGV("[%s] Queued input buffer #%d.", mComponentName.c_str(), index);
- srcbuf->release();
- } else {
- flags = MediaCodec::BUFFER_FLAG_EOS;
- mCodec->queueInputBuffer(bufferIndex, 0, 0, timeUs, flags);
- }
- }
- mFeeding = false;
- }
- } else if (cbID == MediaCodec::CB_OUTPUT_FORMAT_CHANGED) {
- ALOGD("[%s] Output format changed! Buffers remaining: %zu", mComponentName.c_str(), mOutput.lock()->mBufferQueue.size());
- sp<AMessage> outputFormat;
- status_t err = mCodec->getOutputFormat(&outputFormat);
- if (err != OK) {
- ALOGE("[%s] Error fetching output format!", mComponentName.c_str());
- mState = ERROR;
- return;
- }
- sp<MetaData> meta = new MetaData;
- convertMessageToMetaData(outputFormat, meta);
- mMeta.lock().set(meta);
- MediaBuffer *buffer = new MediaBuffer(0);
- Mutexed<Output>::Locked me(mOutput);
- me->mBufferQueue.push_back(buffer);
- mOutputChanged = true;
- me->mAvailable.signal();
- } else if (cbID == MediaCodec::CB_OUTPUT_AVAILABLE) {
- int32_t index;
- size_t size;
- int64_t timeUs = 0ll;
- int32_t flags;
-
- CHECK(msg->findInt32("index", &index));
- CHECK(msg->findSize("size", &size));
- CHECK(msg->findInt64("timeUs", &timeUs));
- CHECK(msg->findInt32("flags", &flags));
- ALOGV("[%s] Got output buffer #%d", mComponentName.c_str(), index);
- if (flags & MediaCodec::BUFFER_FLAG_EOS) {
- mCodec->releaseOutputBuffer(index);
- mOutput.lock()->mReachedEOS = true;
- mOutput.lock()->mAvailable.signal();
- return;
- }
-
- sp<MediaCodecBuffer> out_buffer;
- status_t res = mCodec->getOutputBuffer(index, &out_buffer);
- if (res != OK) {
- ALOGE("[%s] could not get output buffer #%d",
- mComponentName.c_str(), index);
- mState = ERROR;
- mCodec->releaseOutputBuffer(index);
- return;
- }
-
- if (mUsingSurface && size > 0) {
- MediaBuffer *buffer = new MediaBuffer(0);
- Mutexed<Output>::Locked me(mOutput);
- me->mBufferQueue.push_back(buffer);
- mCodec->renderOutputBufferAndRelease(index);
- me->mAvailable.signal();
- } else {
- MediaBuffer *buffer = new MediaBuffer(size);
- CHECK_LE(out_buffer->size(), buffer->size());
- memcpy(buffer->data(), out_buffer->data(), out_buffer->size());
-#if ANDROID_MAJOR >= 9
- buffer->meta_data().setInt64(kKeyTime, timeUs);
-#else
- buffer->meta_data()->setInt64(kKeyTime, timeUs);
-#endif
- Mutexed<Output>::Locked me(mOutput);
- me->mBufferQueue.push_back(buffer);
- mCodec->releaseOutputBuffer(index);
- me->mAvailable.signal();
- }
- } else if (cbID == MediaCodec::CB_ERROR) {
- status_t err;
- CHECK(msg->findInt32("err", &err));
- ALOGE("Decoder (%s) reported error : 0x%d",
- mComponentName.c_str(), err);
- mState = ERROR;
- } else {
- ALOGE("Decoder (%s) unhandled callback id : 0x%d", mComponentName.c_str(), cbID);
- }
-}
|
[-]
[+]
|
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
+ mState = STOPPING;
+ me->mAvailable.signal();
+ 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> AsyncCodecSource::getFormat() {
+ Mutexed<sp<MetaData>>::Locked meta(mMeta);
+ return *meta;
+}
+
+AsyncCodecSource::Output::Output()
+ : mReachedEOS(false),
+ mReading(false) {
+}
+
+status_t AsyncCodecSource::read(
+ DroidMediaBuffer **buffer,
+ const ReadOptions *options) {
+ *buffer = nullptr;
+ Mutexed<Output>::Locked me(mOutput);
+ me->mReading = true;
+ status_t res = OK;
+
+ if (mState != STARTED) {
+ return ERROR_END_OF_STREAM;
+ }
+
+ // flush codec on seek
+ MediaSource::ReadOptions::SeekMode mode;
+ int64_t timeUs = 0ll;
+ if (options != nullptr && options->getSeekTo(&timeUs, &mode)) {
+ me->mReachedEOS = false;
+ mCodec->flush();
+ }
+
+ *buffer = nullptr;
+ while (me->mBufferQueue.size() == 0 && !me->mReachedEOS
+ && mState == STARTED) {
+ ALOGV("[%s] Waiting for output.", mComponentName.c_str());
+ me.waitForCondition(me->mAvailable);
+ }
+
+ if (mState == ERROR) {
+ res = ERROR;
+ }
+ else if (!me->mBufferQueue.empty()) {
+ *buffer = *me->mBufferQueue.begin();
+ me->mBufferQueue.erase(me->mBufferQueue.begin());
+ if (mOutputChanged && (*buffer)->size() == 0) {
+ mOutputChanged = false;
+ res = INFO_FORMAT_CHANGED;
+ }
+ }
+ else if (me->mReachedEOS || mState != STARTED) {
+ res = ERROR_END_OF_STREAM;
+ }
+
+ me->mReading = false;
+ if (mState != STARTED) {
+ me->mReadCondition.signal();
+ }
+
+ return res;
+}
+
+void AsyncCodecSource::onMessageReceived(const sp<AMessage> &msg) {
+
+ if (mCodec == nullptr) {
+ return;
+ }
+
+ int32_t cbID;
+ CHECK(msg->findInt32("callbackID", &cbID));
+ if (cbID == MediaCodec::CB_INPUT_AVAILABLE) {
+ int32_t index;
+ CHECK(msg->findInt32("index", &index));
+ ALOGV("[%s] Got input buffer #%d", mComponentName.c_str(), index);
+ mAvailInputIndices.push_back(index);
+ if (!mFeeding) {
+ while (!mAvailInputIndices.empty()) {
+ DroidMediaBuffer *srcbuf = nullptr;
+ mFeeding = true;
+ size_t bufferIndex = *mAvailInputIndices.begin();
+ mAvailInputIndices.erase(mAvailInputIndices.begin());
+ mSource->read(&srcbuf);
+ uint32_t flags = 0;
+ int64_t timeUs = 0ll;
+
+ if (srcbuf != nullptr) {
+#if ANDROID_MAJOR >= 9
+ CHECK(srcbuf->meta_data().findInt64(kKeyTime, &timeUs));
+#else
+ CHECK(srcbuf->meta_data()->findInt64(kKeyTime, &timeUs));
+#endif
+
+ sp<MediaCodecBuffer> inbuf;
+ status_t err = mCodec->getInputBuffer(bufferIndex, &inbuf);
+
+ if (err != OK || inbuf == nullptr || inbuf->data() == nullptr) {
+ ALOGE("[%s] Error: Input buffer #%d invalid.", mComponentName.c_str(), index);
+ srcbuf->release();
+ mState = ERROR;
+ return;
+ }
+
+ size_t cpLen = min(srcbuf->range_length(), inbuf->capacity());
+ memcpy(inbuf->base(), (uint8_t *)srcbuf->data() + srcbuf->range_offset(),
+ cpLen );
+
+ if (mIsVorbis) {
+ int32_t numPageSamples;
+ if (!
+#if ANDROID_MAJOR >= 9
+ srcbuf->meta_data().findInt32(kKeyValidSamples, &numPageSamples)
+#else
+ srcbuf->meta_data()->findInt32(kKeyValidSamples, &numPageSamples)
+#endif
+ ) {
+ numPageSamples = -1;
+ }
+ memcpy(inbuf->base() + cpLen, &numPageSamples, sizeof(numPageSamples));
+ }
+
+ status_t res = mCodec->queueInputBuffer(
+ bufferIndex, 0 /* offset */, srcbuf->range_length() + (mIsVorbis ? 4 : 0),
+ timeUs, 0 /* flags */);
+ if (res != OK) {
+ ALOGE("[%s] failed to queue input buffer #%d", mComponentName.c_str(), index);
+ mState = ERROR;
+ }
+ ALOGV("[%s] Queued input buffer #%d.", mComponentName.c_str(), index);
+ srcbuf->release();
+ } else {
+ flags = MediaCodec::BUFFER_FLAG_EOS;
+ mCodec->queueInputBuffer(bufferIndex, 0, 0, timeUs, flags);
+ }
+ }
+ mFeeding = false;
+ }
+ } else if (cbID == MediaCodec::CB_OUTPUT_FORMAT_CHANGED) {
+ ALOGD("[%s] Output format changed! Buffers remaining: %zu", mComponentName.c_str(), mOutput.lock()->mBufferQueue.size());
+ sp<AMessage> outputFormat;
+ status_t err = mCodec->getOutputFormat(&outputFormat);
+ if (err != OK) {
+ ALOGE("[%s] Error fetching output format!", mComponentName.c_str());
+ mState = ERROR;
+ return;
+ }
+ sp<MetaData> meta = new MetaData;
+ convertMessageToMetaData(outputFormat, meta);
+ mMeta.lock().set(meta);
+ MediaBuffer *buffer = new MediaBuffer(0);
+ Mutexed<Output>::Locked me(mOutput);
+ me->mBufferQueue.push_back(buffer);
+ mOutputChanged = true;
+ me->mAvailable.signal();
+ } else if (cbID == MediaCodec::CB_OUTPUT_AVAILABLE) {
+ int32_t index;
+ size_t size;
+ int64_t timeUs = 0ll;
+ int32_t flags;
+
+ CHECK(msg->findInt32("index", &index));
+ CHECK(msg->findSize("size", &size));
+ CHECK(msg->findInt64("timeUs", &timeUs));
+ CHECK(msg->findInt32("flags", &flags));
+ ALOGV("[%s] Got output buffer #%d", mComponentName.c_str(), index);
+ if (flags & MediaCodec::BUFFER_FLAG_EOS) {
+ mCodec->releaseOutputBuffer(index);
+ mOutput.lock()->mReachedEOS = true;
+ mOutput.lock()->mAvailable.signal();
+ return;
+ }
+
+ sp<MediaCodecBuffer> out_buffer;
+ status_t res = mCodec->getOutputBuffer(index, &out_buffer);
+ if (res != OK) {
+ ALOGE("[%s] could not get output buffer #%d",
+ mComponentName.c_str(), index);
+ mState = ERROR;
+ mCodec->releaseOutputBuffer(index);
+ return;
+ }
+
+ if (mUsingSurface && size > 0) {
+ MediaBuffer *buffer = new MediaBuffer(0);
+ Mutexed<Output>::Locked me(mOutput);
+ me->mBufferQueue.push_back(buffer);
+ mCodec->renderOutputBufferAndRelease(index);
+ me->mAvailable.signal();
+ } else {
+ MediaBuffer *buffer = new MediaBuffer(size);
+ CHECK_LE(out_buffer->size(), buffer->size());
+ memcpy(buffer->data(), out_buffer->data(), out_buffer->size());
+#if ANDROID_MAJOR >= 9
+ buffer->meta_data().setInt64(kKeyTime, timeUs);
+#else
+ buffer->meta_data()->setInt64(kKeyTime, timeUs);
+#endif
+ Mutexed<Output>::Locked me(mOutput);
+ me->mBufferQueue.push_back(buffer);
+ mCodec->releaseOutputBuffer(index);
+ me->mAvailable.signal();
+ }
+ } else if (cbID == MediaCodec::CB_ERROR) {
+ status_t err;
+ CHECK(msg->findInt32("err", &err));
+ ALOGE("Codec (%s) reported error : 0x%d",
+ mComponentName.c_str(), err);
+ mState = ERROR;
+ } else {
+ ALOGE("Codec (%s) unhandled callback id : 0x%d", mComponentName.c_str(), cbID);
+ }
+}
+
+status_t AsyncCodecSource::setParameters(const sp<AMessage> ¶ms)
+{
+ if (mState == STARTED && mCodec.get()) {
+ return mCodec->setParameters(params);
+ }
+ return android::DEAD_OBJECT;
+}
|
[-]
[+]
|
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,
+ effect_descriptor_t *descriptors,
+ uint32_t *count) {
+ return NO_ERROR;
+ }
+ virtual status_t addSourceDefaultEffect(const effect_uuid_t *type,
+ const String16& opPackageName,
+ const effect_uuid_t *uuid,
+ int32_t priority,
+ audio_source_t source,
+ audio_unique_id_t* id) {
+ return NO_ERROR;
+ }
+ virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
+ const String16& opPackageName,
+ const effect_uuid_t *uuid,
+ int32_t priority,
+ audio_usage_t usage,
+ audio_unique_id_t* id) {
+ return NO_ERROR;
+ }
+ virtual status_t removeSourceDefaultEffect(audio_unique_id_t id) {
+ return NO_ERROR;
+ }
+ virtual status_t removeStreamDefaultEffect(audio_unique_id_t id) {
+ 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,
+ int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual status_t setVoiceVolume(float volume, int delayMs = 0) {
+ return NO_ERROR;
+ }
+ status_t setAllowedCapturePolicy(uint_t uid,
+ audio_flags_mask_t capturePolicy) override {
+ return NO_ERROR;
+ }
+ virtual bool isOffloadSupported(const audio_offload_info_t &config) {
+ return false;
+ }
+ virtual bool isDirectOutputSupported(const audio_config_base_t& config,
+ const audio_attributes_t& attributes) {
+ return false;
+ }
+
+ virtual status_t listAudioPorts(audio_port_role_t role,
+ audio_port_type_t type,
+ unsigned int *num_ports,
+ struct audio_port *ports,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t getAudioPort(struct audio_port *port) {
+ return NO_ERROR;
+ }
+ virtual status_t createAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseAudioPatch(audio_patch_handle_t handle) {
+ return NO_ERROR;
+ }
+ virtual status_t listAudioPatches(unsigned int *num_patches,
+ struct audio_patch *patches,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t setAudioPortConfig(const struct audio_port_config *config) {
+ return NO_ERROR;
+ }
+
+ virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) {
+ return;
+ }
+
+ virtual void setAudioPortCallbacksEnabled(bool enabled) { return; }
+
+ virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled) { return; }
+
+ virtual status_t acquireSoundTriggerSession(audio_session_t *session,
+ audio_io_handle_t *ioHandle,
+ audio_devices_t *device) {
+ return NO_ERROR;
+ }
+
+ virtual status_t releaseSoundTriggerSession(audio_session_t session) {
+ return NO_ERROR;
+ }
+
+ virtual audio_mode_t getPhoneState() {
+ return AUDIO_MODE_CURRENT;
+ }
+
+ virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes,
+ bool registration) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setUidDeviceAffinities(uid_t uid, const
+ Vector<AudioDeviceTypeAddr>& devices) {
+ return NO_ERROR;
+ }
+
+ virtual status_t removeUidDeviceAffinities(uid_t uid) {
+ return NO_ERROR;
+ }
+
+ virtual status_t startAudioSource(const struct audio_port_config *source,
+ const audio_attributes_t *attributes,
+ audio_port_handle_t *portId) {
+ return NO_ERROR;
+ }
+ virtual status_t stopAudioSource(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setMasterMono(bool mono) { return NO_ERROR; }
+ virtual status_t getMasterMono(bool *mono) { return NO_ERROR; }
+
+ virtual float getStreamVolumeDB(audio_stream_type_t stream,
+ int index, audio_devices_t device) {
+ return 0;
+ }
+
+ virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
+ audio_format_t *surroundFormats,
+ bool *surroundFormatsEnabled,
+ bool reported) {
+ return NO_ERROR;
+ }
+ virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
+ std::vector<audio_format_t> *formats) {
+ return NO_ERROR;
+ }
+ virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat,
+ bool enabled) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setAssistantUid(uid_t uid) {
+ return NO_ERROR;
+ }
+ virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids) {
+ return NO_ERROR;
+ }
+
+ virtual bool isHapticPlaybackSupported() {
+ return false;
+ }
+
+ virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) {
+ return NO_ERROR;
+ }
+ virtual status_t getProductStrategyFromAudioAttributes(
+ const AudioAttributes &aa,
+ product_strategy_t &productStrategy) {
+ return NO_ERROR;
+ }
+
+
+ virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) {
+ return NO_ERROR;
+ }
+
+ virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setRttEnabled(bool enabled) {
+ return NO_ERROR;
+ }
+
+ status_t doStopOutput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ void doReleaseOutput(audio_port_handle_t portId) {
+ return;
+ }
+
+ status_t clientCreateAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+ int delayMs) {
+ return NO_ERROR;
+ }
+
+ void removeNotificationClient(uid_t uid, pid_t pid) { return; }
+ void onAudioPortListUpdate() { return; }
+ void doOnAudioPortListUpdate() { return; }
+ void onAudioPatchListUpdate() { return; }
+ void doOnAudioPatchListUpdate() { return; }
+
+ void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state) {
+ return;
+ }
+ void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state) {
+ return;
+ }
+ void onRecordingConfigurationUpdate(int event,
+ const record_client_info_t *clientInfo,
+ const audio_config_base_t *clientConfig,
+ std::vector<effect_descriptor_t> clientEffects,
+ const audio_config_base_t *deviceConfig,
+ std::vector<effect_descriptor_t> effects,
+ audio_patch_handle_t patchHandle,
+ audio_source_t source) {
+ return;
+ }
+ void doOnRecordingConfigurationUpdate(int event,
+ const record_client_info_t *clientInfo,
+ const audio_config_base_t *clientConfig,
+ std::vector<effect_descriptor_t> clientEffects,
+ const audio_config_base_t *deviceConfig,
+ std::vector<effect_descriptor_t> effects,
+ audio_patch_handle_t patchHandle,
+ audio_source_t source) {
+ return;
+ }
+
+ void onAudioVolumeGroupChanged(volume_group_t group, int flags) {
+ return;
+ }
+ void doOnAudioVolumeGroupChanged(volume_group_t group, int flags) {
+ return;
+ }
+ void setEffectSuspended(int effectId,
+ audio_session_t sessionId,
+ bool suspended) {
+ return;
+ }
+
+#ifdef AUDIOPOLICY_LINEAGE_AUDIOSESSIONINFO
+ status_t listAudioSessions(audio_stream_type_t streams,
+ Vector< sp<AudioSessionInfo>> &sessions) {
+ return NO_ERROR;
+ }
+#endif
+};
+
+}
+
+#endif // FAKE_ANDROID_AUDIOPOLICYSERVICE_H
|
[-]
[+]
|
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;
+ }
+ 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 addSourceDefaultEffect(const effect_uuid_t *type,
+ const String16& opPackageName,
+ const effect_uuid_t *uuid,
+ int32_t priority,
+ audio_source_t source,
+ audio_unique_id_t* id) {
+ return NO_ERROR;
+ }
+ virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
+ const String16& opPackageName,
+ const effect_uuid_t *uuid,
+ int32_t priority,
+ audio_usage_t usage,
+ audio_unique_id_t* id) {
+ return NO_ERROR;
+ }
+ virtual status_t removeSourceDefaultEffect(audio_unique_id_t id) {
+ return NO_ERROR;
+ }
+ virtual status_t removeStreamDefaultEffect(audio_unique_id_t id) {
+ 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,
+ int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual status_t setVoiceVolume(float volume, int delayMs = 0) {
+ return NO_ERROR;
+ }
+ status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
+ return NO_ERROR;
+ }
+ status_t setAllowedCapturePolicy(uint_t uid,
+ audio_flags_mask_t capturePolicy) override {
+ return NO_ERROR;
+ }
+ virtual bool isOffloadSupported(const audio_offload_info_t &config) {
+ return false;
+ }
+ virtual bool isDirectOutputSupported(const audio_config_base_t& config,
+ const audio_attributes_t& attributes) {
+ return false;
+ }
+
+ virtual status_t listAudioPorts(audio_port_role_t role,
+ audio_port_type_t type,
+ unsigned int *num_ports,
+ struct audio_port *ports,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t getAudioPort(struct audio_port *port) {
+ return NO_ERROR;
+ }
+ virtual status_t createAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseAudioPatch(audio_patch_handle_t handle) {
+ return NO_ERROR;
+ }
+ virtual status_t listAudioPatches(unsigned int *num_patches,
+ struct audio_patch *patches,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t setAudioPortConfig(const struct audio_port_config *config) {
+ return NO_ERROR;
+ }
+
+ virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) {
+ return;
+ }
+
+ virtual void setAudioPortCallbacksEnabled(bool enabled) { return; }
+
+ virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled) { return; }
+
+ virtual status_t acquireSoundTriggerSession(audio_session_t *session,
+ audio_io_handle_t *ioHandle,
+ audio_devices_t *device) {
+ return NO_ERROR;
+ }
+
+ virtual status_t releaseSoundTriggerSession(audio_session_t session) {
+ return NO_ERROR;
+ }
+
+ virtual audio_mode_t getPhoneState() {
+ return AUDIO_MODE_CURRENT;
+ }
+
+ virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes,
+ bool registration) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setUidDeviceAffinities(uid_t uid, const
+ Vector<AudioDeviceTypeAddr>& devices) {
+ return NO_ERROR;
+ }
+
+ virtual status_t removeUidDeviceAffinities(uid_t uid) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setPreferredDeviceForStrategy(product_strategy_t strategy,
+ const AudioDeviceTypeAddr &device) {
+ return NO_ERROR;
+ }
+
+ virtual status_t removePreferredDeviceForStrategy(product_strategy_t strategy) {
+ return NO_ERROR;
+ }
+
+
+ virtual status_t getPreferredDeviceForStrategy(product_strategy_t strategy,
+ AudioDeviceTypeAddr &device) {
+ return NO_ERROR;
+ }
+ virtual status_t setUserIdDeviceAffinities(int userId,
+ const Vector<AudioDeviceTypeAddr>& devices) {
+ return NO_ERROR;
+ }
+
+ virtual status_t removeUserIdDeviceAffinities(int userId) {
+ return NO_ERROR;
+ }
+
+ virtual status_t startAudioSource(const struct audio_port_config *source,
+ const audio_attributes_t *attributes,
+ audio_port_handle_t *portId) {
+ return NO_ERROR;
+ }
+ virtual status_t stopAudioSource(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setMasterMono(bool mono) { return NO_ERROR; }
+ virtual status_t getMasterMono(bool *mono) { return NO_ERROR; }
+
+ virtual float getStreamVolumeDB( audio_stream_type_t stream,
+ int index, audio_devices_t device) {
+ return 0;
+ }
+
+ virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
+ audio_format_t *surroundFormats,
+ bool *surroundFormatsEnabled,
+ bool reported) {
+ return NO_ERROR;
+ }
+ virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
+ std::vector<audio_format_t> *formats) {
+ return NO_ERROR;
+ }
+ virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat,
+ bool enabled) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setAssistantUid(uid_t uid) {
+ return NO_ERROR;
+ }
+ virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids) {
+ return NO_ERROR;
+ }
+
+ virtual status_t setCurrentImeUid(uid_t uid) {
+ return NO_ERROR;
+ }
+
+ virtual bool isHapticPlaybackSupported() {
+ return false;
+ }
+
+ virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) {
+ return NO_ERROR;
+ }
+ virtual status_t getProductStrategyFromAudioAttributes(
+ const AudioAttributes &aa,
+ product_strategy_t &productStrategy) {
+ return NO_ERROR;
+ }
+
+
+ virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) {
+ return NO_ERROR;
+ }
+
+ virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup) {
+ return NO_ERROR;
+ }
+
+ status_t registerSoundTriggerCaptureStateListener(
+ const sp<media::ICaptureStateListener>& listener,
+ bool* result) override {
+ return NO_ERROR;
+ }
+
+ virtual status_t setRttEnabled(bool enabled) {
+ return NO_ERROR;
+ }
+
+ bool isCallScreenModeSupported() override {
+ return false;
+ }
+
+ void doOnNewAudioModulesAvailable() {
+ return;
+ }
+
+ status_t doStopOutput(audio_port_handle_t portId) {
+ return NO_ERROR;
+ }
+ void doReleaseOutput(audio_port_handle_t portId) {
+ return;
+ }
+
+ status_t clientCreateAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+ int delayMs) {
+ return NO_ERROR;
+ }
+
+ void removeNotificationClient(uid_t uid, pid_t pid) { return; }
+ void onAudioPortListUpdate() { return; }
+ void doOnAudioPortListUpdate() { return; }
+ void onAudioPatchListUpdate() { return; }
+ void doOnAudioPatchListUpdate() { return; }
+
+ void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state) {
+ return;
+ }
+ void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state) {
+ return;
+ }
+ void onRecordingConfigurationUpdate(int event,
+ const record_client_info_t *clientInfo,
+ const audio_config_base_t *clientConfig,
+ std::vector<effect_descriptor_t> clientEffects,
+ const audio_config_base_t *deviceConfig,
+ std::vector<effect_descriptor_t> effects,
+ audio_patch_handle_t patchHandle,
+ audio_source_t source) {
+ return;
+ }
+ void doOnRecordingConfigurationUpdate(int event,
+ const record_client_info_t *clientInfo,
+ const audio_config_base_t *clientConfig,
+ std::vector<effect_descriptor_t> clientEffects,
+ const audio_config_base_t *deviceConfig,
+ std::vector<effect_descriptor_t> effects,
+ audio_patch_handle_t patchHandle,
+ audio_source_t source) {
+ return;
+ }
+
+ void onAudioVolumeGroupChanged(volume_group_t group, int flags) {
+ return;
+ }
+ void doOnAudioVolumeGroupChanged(volume_group_t group, int flags) {
+ return;
+ }
+ void setEffectSuspended(int effectId,
+ audio_session_t sessionId,
+ bool suspended) {
+ return;
+ }
+
+#ifdef AUDIOPOLICY_LINEAGE_AUDIOSESSIONINFO
+ status_t listAudioSessions(audio_stream_type_t streams,
+ Vector< sp<AudioSessionInfo>> &sessions) {
+ return NO_ERROR;
+ }
+#endif
+};
+
+}
+
+#endif // FAKE_ANDROID_AUDIOPOLICYSERVICE_H
|
[-]
[+]
|
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,
+ int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream) {
+ return NO_ERROR;
+ }
+ virtual status_t stopTone() { return NO_ERROR; }
+ virtual status_t setVoiceVolume(float volume, int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual bool isOffloadSupported(const audio_offload_info_t &config) {
+ return false;
+ }
+ virtual status_t listAudioPorts(audio_port_role_t role,
+ audio_port_type_t type,
+ unsigned int *num_ports,
+ struct audio_port *ports,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t getAudioPort(struct audio_port *port) {
+ return NO_ERROR;
+ }
+ virtual status_t createAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseAudioPatch(audio_patch_handle_t handle) {
+ return NO_ERROR;
+ }
+ virtual status_t listAudioPatches(unsigned int *num_patches,
+ struct audio_patch *patches,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t setAudioPortConfig(const struct audio_port_config *config) {
+ return NO_ERROR;
+ }
+ virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) {
+ return;
+ }
+ virtual void setAudioPortCallbacksEnabled(bool enabled){ return; }
+ virtual status_t acquireSoundTriggerSession(audio_session_t *session,
+ audio_io_handle_t *ioHandle,
+ audio_devices_t *device) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseSoundTriggerSession(audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual audio_mode_t getPhoneState() {
+ return AUDIO_MODE_CURRENT;
+ }
+ virtual status_t registerPolicyMixes(Vector<AudioMix> mixes, bool registration) {
+ return NO_ERROR;;
+ }
+ virtual status_t startAudioSource(const struct audio_port_config *source,
+ const audio_attributes_t *attributes,
+ audio_io_handle_t *handle){
+ return NO_ERROR;
+ }
+ virtual status_t stopAudioSource(audio_io_handle_t handle) { return NO_ERROR; }
+ status_t doStopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ void doReleaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ status_t clientCreateAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ void removeNotificationClient(uid_t uid) { return; }
+ void onAudioPortListUpdate() { return; }
+ void doOnAudioPortListUpdate() { return; }
+ void onAudioPatchListUpdate() { return; }
+ void doOnAudioPatchListUpdate() { return; }
+ void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state) {
+ return;
+ }
+ void doOnDynamicPolicyMixStateUpdate(String8 regId, int32_t state) {
+ return;
+ }
+};
+}; // namespace android
+#endif // ANDROID_AUDIOPOLICYSERVICE_H
|
[-]
[+]
|
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) {
+ return;
+ }
+ virtual status_t setStreamVolume(audio_stream_type_t stream,
+ float volume,
+ audio_io_handle_t output,
+ int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream) {
+ return NO_ERROR;
+ }
+ virtual status_t stopTone() { return NO_ERROR; }
+ virtual status_t setVoiceVolume(float volume, int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual bool isOffloadSupported(const audio_offload_info_t &config) {
+ return false;
+ }
+ virtual status_t listAudioPorts(audio_port_role_t role,
+ audio_port_type_t type,
+ unsigned int *num_ports,
+ struct audio_port *ports,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t getAudioPort(struct audio_port *port) {
+ return NO_ERROR;
+ }
+ virtual status_t createAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseAudioPatch(audio_patch_handle_t handle) {
+ return NO_ERROR;
+ }
+ virtual status_t listAudioPatches(unsigned int *num_patches,
+ struct audio_patch *patches,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t setAudioPortConfig(const struct audio_port_config *config) {
+ return NO_ERROR;
+ }
+ virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) {
+ return;
+ }
+ virtual void setAudioPortCallbacksEnabled(bool enabled){ return; }
+ virtual status_t acquireSoundTriggerSession(audio_session_t *session,
+ audio_io_handle_t *ioHandle,
+ audio_devices_t *device) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseSoundTriggerSession(audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual audio_mode_t getPhoneState() {
+ return AUDIO_MODE_CURRENT;
+ }
+ virtual status_t registerPolicyMixes(Vector<AudioMix> mixes, bool registration) {
+ return NO_ERROR;;
+ }
+ virtual status_t startAudioSource(const struct audio_port_config *source,
+ const audio_attributes_t *attributes,
+ audio_io_handle_t *handle){
+ return NO_ERROR;
+ }
+ virtual status_t stopAudioSource(audio_io_handle_t handle) { return NO_ERROR; }
+ status_t doStopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ void doReleaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ status_t clientCreateAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ void removeNotificationClient(uid_t uid) { return; }
+ void onAudioPortListUpdate() { return; }
+ void doOnAudioPortListUpdate() { return; }
+ void onAudioPatchListUpdate() { return; }
+ void doOnAudioPatchListUpdate() { return; }
+ void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state) {
+ return;
+ }
+ void doOnDynamicPolicyMixStateUpdate(String8 regId, int32_t state) {
+ return;
+ }
+
+#ifdef AUDIOPOLICY_LINEAGE_AUDIOSESSIONINFO
+ status_t listAudioSessions(audio_stream_type_t streams,
+ Vector< sp<AudioSessionInfo>> &sessions) {
+ return NO_ERROR;
+ }
+#endif
+
+};
+}; // namespace android
+#endif // ANDROID_AUDIOPOLICYSERVICE_H
|
[-]
[+]
|
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,
+ const char *keyValuePairs,
+ int delayMs) {
+ return;
+ }
+ virtual status_t setStreamVolume(audio_stream_type_t stream,
+ float volume,
+ audio_io_handle_t output,
+ int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream) {
+ return NO_ERROR;
+ }
+ virtual status_t stopTone() { return NO_ERROR; }
+ virtual status_t setVoiceVolume(float volume, int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual bool isOffloadSupported(const audio_offload_info_t &config) {
+ return false;
+ }
+ virtual status_t listAudioPorts(audio_port_role_t role,
+ audio_port_type_t type,
+ unsigned int *num_ports,
+ struct audio_port *ports,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t getAudioPort(struct audio_port *port) {
+ return NO_ERROR;
+ }
+ virtual status_t createAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseAudioPatch(audio_patch_handle_t handle) {
+ return NO_ERROR;
+ }
+ virtual status_t listAudioPatches(unsigned int *num_patches,
+ struct audio_patch *patches,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t setAudioPortConfig(const struct audio_port_config *config) {
+ return NO_ERROR;
+ }
+ virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) {
+ return;
+ }
+ virtual void setAudioPortCallbacksEnabled(bool enabled) { return; }
+ virtual status_t acquireSoundTriggerSession(audio_session_t *session,
+ audio_io_handle_t *ioHandle,
+ audio_devices_t *device) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseSoundTriggerSession(audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual audio_mode_t getPhoneState() {
+ return AUDIO_MODE_CURRENT;
+ }
+ virtual status_t registerPolicyMixes(Vector<AudioMix> mixes, bool registration) {
+ return NO_ERROR;
+ }
+ virtual status_t startAudioSource(const struct audio_port_config *source,
+ const audio_attributes_t *attributes,
+ audio_io_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t stopAudioSource(audio_io_handle_t handle) { return NO_ERROR; }
+ virtual status_t setMasterMono(bool mono) { return NO_ERROR; }
+ virtual status_t getMasterMono(bool *mono) { return NO_ERROR; }
+ status_t doStopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ void doReleaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ status_t clientCreateAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ void removeNotificationClient(uid_t uid) { return; }
+ void onAudioPortListUpdate() { return; }
+ void doOnAudioPortListUpdate() { return; }
+ void onAudioPatchListUpdate() { return; }
+ void doOnAudioPatchListUpdate() { return; }
+ void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state) {
+ return;
+ }
+ void doOnDynamicPolicyMixStateUpdate(String8 regId, int32_t state) {
+ return;
+ }
+ void onRecordingConfigurationUpdate(int event, audio_session_t session,
+ audio_source_t source,
+ const audio_config_base_t *clientConfig,
+ const audio_config_base_t *deviceConfig,
+ audio_patch_handle_t patchHandle) {
+ return;
+ }
+ void doOnRecordingConfigurationUpdate(int event, audio_session_t session,
+ audio_source_t source,
+ const audio_config_base_t *clientConfig,
+ const audio_config_base_t *deviceConfig,
+ audio_patch_handle_t patchHandle) {
+ return;
+ }
+
+#ifdef AUDIOPOLICY_LINEAGE_AUDIOSESSIONINFO
+ status_t listAudioSessions(audio_stream_type_t streams,
+ Vector< sp<AudioSessionInfo>> &sessions) {
+ return NO_ERROR;
+ }
+#endif
+
+#ifdef AUDIOPOLICY_MTK_AUDIO_ADD
+ virtual status_t SetPolicyManagerParameters(int par1, int par2, int par3,
+ int par4) {
+ return NO_ERROR;
+ }
+ virtual status_t StartOutputSamplerate(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session, int samplerate) {
+ return NO_ERROR;
+ }
+ virtual status_t StopOutputSamplerate(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session,
+ int samplerate) {
+ return NO_ERROR;
+ }
+ virtual status_t SampleRateRequestFocus(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ int *samplerate) {
+ return NO_ERROR;
+ }
+ virtual status_t SampleRateUnrequestFocus(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ int samplerate) {
+ return NO_ERROR;
+ }
+
+ virtual status_t doStopOutputSamplerate(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session,
+ int samplerate) {
+ return NO_ERROR;
+ }
+ virtual status_t getCustomAudioVolume(void* pCustomVol) {
+ return NO_ERROR;
+ }
+#endif
+};
+
+}; // namespace android
+#endif // FAKE_ANDROID_AUDIOPOLICYSERVICE_H
|
[-]
[+]
|
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.
+ //
+ 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,
+ int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream) {
+ return NO_ERROR;
+ }
+ virtual status_t stopTone() { return NO_ERROR; }
+ virtual status_t setVoiceVolume(float volume, int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual bool isOffloadSupported(const audio_offload_info_t &config) {
+ return false;
+ }
+ virtual status_t listAudioPorts(audio_port_role_t role,
+ audio_port_type_t type,
+ unsigned int *num_ports,
+ struct audio_port *ports,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t getAudioPort(struct audio_port *port) {
+ return NO_ERROR;
+ }
+ virtual status_t createAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseAudioPatch(audio_patch_handle_t handle) {
+ return NO_ERROR;
+ }
+ virtual status_t listAudioPatches(unsigned int *num_patches,
+ struct audio_patch *patches,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t setAudioPortConfig(const struct audio_port_config *config) {
+ return NO_ERROR;
+ }
+ virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) {
+ return;
+ }
+ virtual void setAudioPortCallbacksEnabled(bool enabled) { return; }
+ virtual status_t acquireSoundTriggerSession(audio_session_t *session,
+ audio_io_handle_t *ioHandle,
+ audio_devices_t *device) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseSoundTriggerSession(audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual audio_mode_t getPhoneState() {
+ return AUDIO_MODE_CURRENT;
+ }
+ virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes,
+ bool registration) {
+ return NO_ERROR;
+ }
+ virtual status_t startAudioSource(const struct audio_port_config *source,
+ const audio_attributes_t *attributes,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t stopAudioSource(audio_patch_handle_t handle) { return NO_ERROR; }
+ virtual status_t setMasterMono(bool mono) { return NO_ERROR; }
+ virtual status_t getMasterMono(bool *mono) { return NO_ERROR; }
+ virtual float getStreamVolumeDB(audio_stream_type_t stream,
+ int index, audio_devices_t device) {
+ return NO_ERROR;
+ }
+ status_t doStopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ void doReleaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ status_t clientCreateAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ void removeNotificationClient(uid_t uid) { return; }
+ void onAudioPortListUpdate() { return; }
+ void doOnAudioPortListUpdate() { return; }
+ void onAudioPatchListUpdate() { return; }
+ void doOnAudioPatchListUpdate() { return; }
+ void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state) {
+ return;
+ }
+ void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state) {
+ return;
+ }
+ void onRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo,
+ const audio_config_base_t *clientConfig,
+ const audio_config_base_t *deviceConfig,
+ audio_patch_handle_t patchHandle) {
+ return;
+ }
+ void doOnRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo,
+ const audio_config_base_t *clientConfig,
+ const audio_config_base_t *deviceConfig,
+ audio_patch_handle_t patchHandle) {
+ return;
+ }
+
+#ifdef AUDIOPOLICY_LINEAGE_AUDIOSESSIONINFO
+ status_t listAudioSessions(audio_stream_type_t streams,
+ Vector< sp<AudioSessionInfo>> &sessions) {
+ return NO_ERROR;
+ }
+#endif
+};
+
+} // namespace android
+
+#endif // ANDROID_AUDIOPOLICYSERVICE_H
|
[-]
[+]
|
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
+ // 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,
+ int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream) {
+ return NO_ERROR;
+ }
+ virtual status_t stopTone() { return NO_ERROR; }
+ virtual status_t setVoiceVolume(float volume, int delayMs = 0) {
+ return NO_ERROR;
+ }
+ virtual bool isOffloadSupported(const audio_offload_info_t &config) {
+ return false;
+ }
+ virtual status_t listAudioPorts(audio_port_role_t role,
+ audio_port_type_t type,
+ unsigned int *num_ports,
+ struct audio_port *ports,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t getAudioPort(struct audio_port *port) {
+ return NO_ERROR;
+ }
+ virtual status_t createAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseAudioPatch(audio_patch_handle_t handle) {
+ return NO_ERROR;
+ }
+ virtual status_t listAudioPatches(unsigned int *num_patches,
+ struct audio_patch *patches,
+ unsigned int *generation) {
+ return NO_ERROR;
+ }
+ virtual status_t setAudioPortConfig(const struct audio_port_config *config) {
+ return NO_ERROR;
+ }
+ virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) {
+ return;
+ }
+ virtual void setAudioPortCallbacksEnabled(bool enabled) { return; }
+ virtual status_t acquireSoundTriggerSession(audio_session_t *session,
+ audio_io_handle_t *ioHandle,
+ audio_devices_t *device) {
+ return NO_ERROR;
+ }
+ virtual status_t releaseSoundTriggerSession(audio_session_t session) {
+ return NO_ERROR;
+ }
+ virtual audio_mode_t getPhoneState() {
+ return AUDIO_MODE_CURRENT;
+ }
+ virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes,
+ bool registration) {
+ return NO_ERROR;
+ }
+ virtual status_t startAudioSource(const struct audio_port_config *source,
+ const audio_attributes_t *attributes,
+ audio_patch_handle_t *handle) {
+ return NO_ERROR;
+ }
+ virtual status_t stopAudioSource(audio_patch_handle_t handle) {
+ return NO_ERROR;
+ }
+ virtual status_t setMasterMono(bool mono) { return NO_ERROR; }
+ virtual status_t getMasterMono(bool *mono) { return NO_ERROR; }
+ virtual float getStreamVolumeDB(audio_stream_type_t stream,
+ int index, audio_devices_t device) {
+ return 0;
+ }
+ virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
+ audio_format_t *surroundFormats,
+ bool *surroundFormatsEnabled,
+ bool reported) {
+ return NO_ERROR;
+ }
+ virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat,
+ bool enabled) {
+ return NO_ERROR;
+ }
+ status_t doStopOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return NO_ERROR;
+ }
+ void doReleaseOutput(audio_io_handle_t output,
+ audio_stream_type_t stream,
+ audio_session_t session) {
+ return;
+ }
+ status_t clientCreateAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+ int delayMs) {
+ return NO_ERROR;
+ }
+ void removeNotificationClient(uid_t uid) { return; }
+ void onAudioPortListUpdate() { return; }
+ void doOnAudioPortListUpdate() { return; }
+ void onAudioPatchListUpdate() { return; }
+ void doOnAudioPatchListUpdate() { return; }
+ void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state) {
+ return;
+ }
+ void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state) {
+ return;
+ }
+ void onRecordingConfigurationUpdate(int event,
+ const record_client_info_t *clientInfo,
+ const audio_config_base_t *clientConfig,
+ const audio_config_base_t *deviceConfig,
+ audio_patch_handle_t patchHandle) {
+ return;
+ }
+ void doOnRecordingConfigurationUpdate(int event,
+ const record_client_info_t *clientInfo,
+ const audio_config_base_t *clientConfig,
+ const audio_config_base_t *deviceConfig,
+ audio_patch_handle_t patchHandle) {
+ return;
+ }
+
+#ifdef AUDIOPOLICY_LINEAGE_AUDIOSESSIONINFO
+ status_t listAudioSessions(audio_stream_type_t streams,
+ Vector< sp<AudioSessionInfo>> &sessions) {
+ return NO_ERROR;
+ }
+#endif
+};
+
+} // namespace android
+
+#endif // FAKE_ANDROID_AUDIOPOLICYSERVICE_H
|