Merge "Revert "audio policy: concurrent capture""
diff --git a/camera/Android.bp b/camera/Android.bp
index 24b3918..21588d4 100644
--- a/camera/Android.bp
+++ b/camera/Android.bp
@@ -43,6 +43,7 @@
"ICameraRecordingProxyListener.cpp",
"camera2/CaptureRequest.cpp",
"camera2/OutputConfiguration.cpp",
+ "camera2/SessionConfiguration.cpp",
"camera2/SubmitInfo.cpp",
"CameraBase.cpp",
"CameraUtils.cpp",
diff --git a/camera/aidl/android/hardware/camera2/ICameraDeviceUser.aidl b/camera/aidl/android/hardware/camera2/ICameraDeviceUser.aidl
index 4ced08c..49dfde8 100644
--- a/camera/aidl/android/hardware/camera2/ICameraDeviceUser.aidl
+++ b/camera/aidl/android/hardware/camera2/ICameraDeviceUser.aidl
@@ -19,6 +19,7 @@
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.impl.CameraMetadataNative;
import android.hardware.camera2.params.OutputConfiguration;
+import android.hardware.camera2.params.SessionConfiguration;
import android.hardware.camera2.utils.SubmitInfo;
import android.view.Surface;
@@ -83,6 +84,16 @@
*/
void endConfigure(int operatingMode, in CameraMetadataNative sessionParams);
+ /**
+ * Check whether a particular session configuration has camera device
+ * support.
+ *
+ * @param sessionConfiguration Specific session configuration to be verified.
+ * @return true - in case the stream combination is supported.
+ * false - in case there is no device support.
+ */
+ boolean isSessionConfigurationSupported(in SessionConfiguration sessionConfiguration);
+
void deleteStream(int streamId);
/**
diff --git a/camera/aidl/android/hardware/camera2/params/SessionConfiguration.aidl b/camera/aidl/android/hardware/camera2/params/SessionConfiguration.aidl
new file mode 100644
index 0000000..abf1556
--- /dev/null
+++ b/camera/aidl/android/hardware/camera2/params/SessionConfiguration.aidl
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+package android.hardware.camera2.params;
+
+/** @hide */
+parcelable SessionConfiguration cpp_header "camera/camera2/SessionConfiguration.h";
diff --git a/camera/camera2/SessionConfiguration.cpp b/camera/camera2/SessionConfiguration.cpp
new file mode 100644
index 0000000..a431a33
--- /dev/null
+++ b/camera/camera2/SessionConfiguration.cpp
@@ -0,0 +1,133 @@
+/*
+**
+** Copyright 2018, 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_TAG "SessionConfiguration"
+//#define LOG_NDEBUG 0
+
+#include <utils/Log.h>
+
+#include <camera/camera2/SessionConfiguration.h>
+#include <camera/camera2/OutputConfiguration.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+status_t SessionConfiguration::readFromParcel(const android::Parcel* parcel) {
+ status_t err = OK;
+ int operatingMode = 0;
+
+ if (parcel == nullptr) return BAD_VALUE;
+
+ if ((err = parcel->readInt32(&operatingMode)) != OK) {
+ ALOGE("%s: Failed to read operating mode from parcel", __FUNCTION__);
+ return err;
+ }
+
+ int inputWidth = 0;
+ if ((err = parcel->readInt32(&inputWidth)) != OK) {
+ ALOGE("%s: Failed to read input width from parcel", __FUNCTION__);
+ return err;
+ }
+
+ int inputHeight = 0;
+ if ((err = parcel->readInt32(&inputHeight)) != OK) {
+ ALOGE("%s: Failed to read input height from parcel", __FUNCTION__);
+ return err;
+ }
+
+ int inputFormat = -1;
+ if ((err = parcel->readInt32(&inputFormat)) != OK) {
+ ALOGE("%s: Failed to read input format from parcel", __FUNCTION__);
+ return err;
+ }
+
+ std::vector<OutputConfiguration> outputStreams;
+ if ((err = parcel->readParcelableVector(&outputStreams)) != OK) {
+ ALOGE("%s: Failed to read output configurations from parcel", __FUNCTION__);
+ return err;
+ }
+
+ mOperatingMode = operatingMode;
+ mInputWidth = inputWidth;
+ mInputHeight = inputHeight;
+ mInputFormat = inputFormat;
+ for (auto& stream : outputStreams) {
+ mOutputStreams.push_back(stream);
+ }
+
+
+ return err;
+}
+
+status_t SessionConfiguration::writeToParcel(android::Parcel* parcel) const {
+
+ if (parcel == nullptr) return BAD_VALUE;
+ status_t err = OK;
+
+ err = parcel->writeInt32(mOperatingMode);
+ if (err != OK) return err;
+
+ err = parcel->writeInt32(mInputWidth);
+ if (err != OK) return err;
+
+ err = parcel->writeInt32(mInputHeight);
+ if (err != OK) return err;
+
+ err = parcel->writeInt32(mInputFormat);
+ if (err != OK) return err;
+
+ err = parcel->writeParcelableVector(mOutputStreams);
+ if (err != OK) return err;
+
+ return OK;
+}
+
+bool SessionConfiguration::outputsEqual(const SessionConfiguration& other) const {
+ const std::vector<OutputConfiguration>& otherOutputStreams =
+ other.getOutputConfigurations();
+
+ if (mOutputStreams.size() != otherOutputStreams.size()) {
+ return false;
+ }
+
+ for (size_t i = 0; i < mOutputStreams.size(); i++) {
+ if (mOutputStreams[i] != otherOutputStreams[i]) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool SessionConfiguration::outputsLessThan(const SessionConfiguration& other) const {
+ const std::vector<OutputConfiguration>& otherOutputStreams =
+ other.getOutputConfigurations();
+
+ if (mOutputStreams.size() != otherOutputStreams.size()) {
+ return mOutputStreams.size() < otherOutputStreams.size();
+ }
+
+ for (size_t i = 0; i < mOutputStreams.size(); i++) {
+ if (mOutputStreams[i] != otherOutputStreams[i]) {
+ return mOutputStreams[i] < otherOutputStreams[i];
+ }
+ }
+
+ return false;
+}
+
+}; // namespace android
diff --git a/camera/cameraserver/Android.bp b/camera/cameraserver/Android.bp
index ef6930c..b88a2c5 100644
--- a/camera/cameraserver/Android.bp
+++ b/camera/cameraserver/Android.bp
@@ -29,6 +29,7 @@
"android.hardware.camera.provider@2.4",
"android.hardware.camera.device@1.0",
"android.hardware.camera.device@3.2",
+ "android.hardware.camera.device@3.4",
],
compile_multilib: "32",
cflags: [
diff --git a/camera/include/camera/camera2/SessionConfiguration.h b/camera/include/camera/camera2/SessionConfiguration.h
new file mode 100644
index 0000000..64288ed
--- /dev/null
+++ b/camera/include/camera/camera2/SessionConfiguration.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_HARDWARE_CAMERA2_SESSIONCONFIGURATION_H
+#define ANDROID_HARDWARE_CAMERA2_SESSIONCONFIGURATION_H
+
+#include <binder/Parcelable.h>
+
+namespace android {
+
+namespace hardware {
+namespace camera2 {
+namespace params {
+
+class OutputConfiguration;
+
+class SessionConfiguration : public android::Parcelable {
+public:
+
+ const std::vector<OutputConfiguration>& getOutputConfigurations() const {
+ return mOutputStreams;
+ }
+
+ int getInputWidth() const { return mInputWidth; }
+ int getInputHeight() const { return mInputHeight; }
+ int getInputFormat() const { return mInputFormat; }
+ int getOperatingMode() const { return mOperatingMode; }
+
+ virtual status_t writeToParcel(android::Parcel* parcel) const override;
+ virtual status_t readFromParcel(const android::Parcel* parcel) override;
+
+ SessionConfiguration() :
+ mInputWidth(0),
+ mInputHeight(0),
+ mInputFormat(-1),
+ mOperatingMode(-1) {}
+
+ SessionConfiguration(const android::Parcel& parcel) {
+ readFromParcel(&parcel);
+ }
+
+ SessionConfiguration(int inputWidth, int inputHeight, int inputFormat, int operatingMode) :
+ mInputWidth(inputWidth), mInputHeight(inputHeight), mInputFormat(inputFormat),
+ mOperatingMode(operatingMode) {}
+
+ bool operator == (const SessionConfiguration& other) const {
+ return (outputsEqual(other) &&
+ mInputWidth == other.mInputWidth &&
+ mInputHeight == other.mInputHeight &&
+ mInputFormat == other.mInputFormat &&
+ mOperatingMode == other.mOperatingMode);
+ }
+
+ bool operator != (const SessionConfiguration& other) const {
+ return !(*this == other);
+ }
+
+ bool operator < (const SessionConfiguration& other) const {
+ if (*this == other) return false;
+
+ if (mInputWidth != other.mInputWidth) {
+ return mInputWidth < other.mInputWidth;
+ }
+
+ if (mInputHeight != other.mInputHeight) {
+ return mInputHeight < other.mInputHeight;
+ }
+
+ if (mInputFormat != other.mInputFormat) {
+ return mInputFormat < other.mInputFormat;
+ }
+
+ if (mOperatingMode != other.mOperatingMode) {
+ return mOperatingMode < other.mOperatingMode;
+ }
+
+ return outputsLessThan(other);
+ }
+
+ bool operator > (const SessionConfiguration& other) const {
+ return (*this != other && !(*this < other));
+ }
+
+ bool outputsEqual(const SessionConfiguration& other) const;
+ bool outputsLessThan(const SessionConfiguration& other) const;
+ void addOutputConfiguration(const OutputConfiguration &config) {
+ mOutputStreams.push_back(config);
+ }
+
+private:
+
+ std::vector<OutputConfiguration> mOutputStreams;
+ int mInputWidth, mInputHeight, mInputFormat, mOperatingMode;
+};
+} // namespace params
+} // namespace camera2
+} // namespace hardware
+
+using hardware::camera2::params::SessionConfiguration;
+
+}; // namespace android
+
+#endif
diff --git a/camera/ndk/ndk_vendor/impl/ACameraDevice.cpp b/camera/ndk/ndk_vendor/impl/ACameraDevice.cpp
index b86f854..26e6b3c 100644
--- a/camera/ndk/ndk_vendor/impl/ACameraDevice.cpp
+++ b/camera/ndk/ndk_vendor/impl/ACameraDevice.cpp
@@ -754,8 +754,8 @@
const camera_metadata_t *params_metadata = params.getAndLock();
utils::convertToHidl(params_metadata, &hidlParams);
params.unlock(params_metadata);
- remoteRet = mRemote->endConfigure(StreamConfigurationMode::NORMAL_MODE, hidlParams);
}
+ remoteRet = mRemote->endConfigure(StreamConfigurationMode::NORMAL_MODE, hidlParams);
if (!remoteRet.isOk()) {
ALOGE("Transaction error: endConfigure failed %s", remoteRet.description().c_str());
}
diff --git a/camera/tests/CameraBinderTests.cpp b/camera/tests/CameraBinderTests.cpp
index 1de7013..fa8a7a3 100644
--- a/camera/tests/CameraBinderTests.cpp
+++ b/camera/tests/CameraBinderTests.cpp
@@ -29,6 +29,7 @@
#include <utils/Condition.h>
#include <utils/Mutex.h>
#include <system/graphics.h>
+#include <hardware/camera3.h>
#include <hardware/gralloc.h>
#include <camera/CameraMetadata.h>
@@ -40,6 +41,7 @@
#include <android/hardware/camera2/BnCameraDeviceCallbacks.h>
#include <camera/camera2/CaptureRequest.h>
#include <camera/camera2/OutputConfiguration.h>
+#include <camera/camera2/SessionConfiguration.h>
#include <camera/camera2/SubmitInfo.h>
#include <gui/BufferItemConsumer.h>
@@ -55,6 +57,8 @@
#include <algorithm>
using namespace android;
+using ::android::hardware::ICameraServiceDefault;
+using ::android::hardware::camera2::ICameraDeviceUser;
#define ASSERT_NOT_NULL(x) \
ASSERT_TRUE((x) != nullptr)
@@ -490,6 +494,19 @@
EXPECT_TRUE(res.isOk()) << res;
EXPECT_FALSE(callbacks->hadError());
+ // Session configuration must also be supported in this case
+ SessionConfiguration sessionConfiguration = { /*inputWidth*/ 0, /*inputHeight*/0,
+ /*inputFormat*/ -1, CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE};
+ sessionConfiguration.addOutputConfiguration(output);
+ bool queryStatus;
+ res = device->isSessionConfigurationSupported(sessionConfiguration, &queryStatus);
+ EXPECT_TRUE(res.isOk() ||
+ (res.serviceSpecificErrorCode() == ICameraServiceDefault::ERROR_INVALID_OPERATION))
+ << res;
+ if (res.isOk()) {
+ EXPECT_TRUE(queryStatus);
+ }
+
// Can we make requests?
CameraMetadata requestTemplate;
res = device->createDefaultRequest(/*preview template*/1,
diff --git a/include/media/MediaExtractorPluginApi.h b/include/media/MediaExtractorPluginApi.h
index 38962e5..b480bbe 100644
--- a/include/media/MediaExtractorPluginApi.h
+++ b/include/media/MediaExtractorPluginApi.h
@@ -69,6 +69,40 @@
bool (*supportsNonBlockingRead)(void *data);
};
+/**
+ * only use CMediaBufferV3 allocated from the CMediaBufferGroupV3 that is
+ * provided to CMediaTrack::start()
+ */
+struct CMediaBufferV3 {
+ void *handle;
+ void (*release)(void *handle);
+ void* (*data)(void *handle);
+ size_t (*size)(void *handle);
+ size_t (*range_offset)(void *handle);
+ size_t (*range_length)(void *handle);
+ void (*set_range)(void *handle, size_t offset, size_t length);
+ AMediaFormat* (*meta_data)(void *handle);
+};
+
+struct CMediaBufferGroupV3 {
+ void *handle;
+ bool (*init)(void *handle, size_t buffers, size_t buffer_size, size_t growthLimit);
+ void (*add_buffer)(void *handle, size_t size);
+ media_status_t (*acquire_buffer)(void *handle,
+ CMediaBufferV3 **buffer, bool nonBlocking, size_t requestedSize);
+ bool (*has_buffers)(void *handle);
+};
+
+struct CMediaTrackV3 {
+ void *data;
+ void (*free)(void *data);
+
+ media_status_t (*start)(void *data, CMediaBufferGroupV3 *bufferGroup);
+ media_status_t (*stop)(void *data);
+ media_status_t (*getFormat)(void *data, AMediaFormat *format);
+ media_status_t (*read)(void *data, CMediaBufferV3 **buffer, uint32_t options, int64_t seekPosUs);
+ bool (*supportsNonBlockingRead)(void *data);
+};
struct CMediaExtractorV1 {
void *data;
@@ -104,6 +138,23 @@
const char * (*name)(void *data);
};
+struct CMediaExtractorV3 {
+ void *data;
+
+ void (*free)(void *data);
+ size_t (*countTracks)(void *data);
+ CMediaTrackV3* (*getTrack)(void *data, size_t index);
+ media_status_t (*getTrackMetaData)(
+ void *data,
+ AMediaFormat *meta,
+ size_t index, uint32_t flags);
+
+ media_status_t (*getMetaData)(void *data, AMediaFormat *meta);
+ uint32_t (*flags)(void *data);
+ media_status_t (*setMediaCas)(void *data, const uint8_t* casToken, size_t size);
+ const char * (*name)(void *data);
+};
+
typedef CMediaExtractorV1* (*CreatorFuncV1)(CDataSource *source, void *meta);
typedef void (*FreeMetaFunc)(void *meta);
@@ -121,6 +172,12 @@
CDataSource *source, float *confidence,
void **meta, FreeMetaFunc *freeMeta);
+typedef CMediaExtractorV3* (*CreatorFuncV3)(CDataSource *source, void *meta);
+
+typedef CreatorFuncV3 (*SnifferFuncV3)(
+ CDataSource *source, float *confidence,
+ void **meta, FreeMetaFunc *freeMeta);
+
typedef CMediaExtractorV1 CMediaExtractor;
typedef CreatorFuncV1 CreatorFunc;
@@ -148,6 +205,7 @@
union {
SnifferFuncV1 v1;
SnifferFuncV2 v2;
+ SnifferFuncV3 v3;
} sniff;
};
diff --git a/include/media/MediaExtractorPluginHelper.h b/include/media/MediaExtractorPluginHelper.h
index 858c575..292ec93 100644
--- a/include/media/MediaExtractorPluginHelper.h
+++ b/include/media/MediaExtractorPluginHelper.h
@@ -20,12 +20,13 @@
#include <arpa/inet.h>
#include <stdio.h>
-#include <vector>
+#include <map>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <utils/RefBase.h>
#include <media/MediaExtractorPluginApi.h>
+#include <media/NdkMediaFormat.h>
namespace android {
@@ -171,6 +172,176 @@
return wrapper;
}
+class MediaTrackHelperV3;
+
+class MediaBufferHelperV3 {
+private:
+ friend CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *);
+ CMediaBufferV3 *mBuffer;
+public:
+ MediaBufferHelperV3(CMediaBufferV3 *buf) {
+ mBuffer = buf;
+ }
+
+ ~MediaBufferHelperV3() {}
+
+ void release() {
+ mBuffer->release(mBuffer->handle);
+ }
+
+ void* data() {
+ return mBuffer->data(mBuffer->handle);
+ }
+
+ size_t size() {
+ return mBuffer->size(mBuffer->handle);
+ }
+
+ size_t range_offset() {
+ return mBuffer->range_offset(mBuffer->handle);
+ }
+
+ size_t range_length() {
+ return mBuffer->range_length(mBuffer->handle);
+ }
+
+ void set_range(size_t offset, size_t length) {
+ mBuffer->set_range(mBuffer->handle, offset, length);
+ }
+ AMediaFormat *meta_data() {
+ return mBuffer->meta_data(mBuffer->handle);
+ }
+};
+
+class MediaBufferGroupHelperV3 {
+private:
+ CMediaBufferGroupV3 *mGroup;
+ std::map<CMediaBufferV3*, MediaBufferHelperV3*> mBufferHelpers;
+public:
+ MediaBufferGroupHelperV3(CMediaBufferGroupV3 *group) {
+ mGroup = group;
+ }
+ ~MediaBufferGroupHelperV3() {
+ // delete all entries in map
+ ALOGV("buffergroup %p map has %zu entries", this, mBufferHelpers.size());
+ for (auto it = mBufferHelpers.begin(); it != mBufferHelpers.end(); ++it) {
+ delete it->second;
+ }
+ }
+ bool init(size_t buffers, size_t buffer_size, size_t growthLimit = 0) {
+ return mGroup->init(mGroup->handle, buffers, buffer_size, growthLimit);
+ }
+ void add_buffer(size_t size) {
+ mGroup->add_buffer(mGroup->handle, size);
+ }
+ media_status_t acquire_buffer(
+ MediaBufferHelperV3 **buffer, bool nonBlocking = false, size_t requestedSize = 0) {
+ CMediaBufferV3 *buf = nullptr;
+ media_status_t ret =
+ mGroup->acquire_buffer(mGroup->handle, &buf, nonBlocking, requestedSize);
+ if (ret == AMEDIA_OK && buf != nullptr) {
+ auto helper = mBufferHelpers.find(buf);
+ if (helper == mBufferHelpers.end()) {
+ MediaBufferHelperV3* newHelper = new MediaBufferHelperV3(buf);
+ mBufferHelpers.insert(std::make_pair(buf, newHelper));
+ *buffer = newHelper;
+ } else {
+ *buffer = helper->second;
+ }
+ } else {
+ *buffer = nullptr;
+ }
+ return ret;
+ }
+ bool has_buffers() {
+ return mGroup->has_buffers(mGroup->handle);
+ }
+};
+
+class MediaTrackHelperV3 {
+public:
+ MediaTrackHelperV3() : mBufferGroup(nullptr) {
+ }
+ virtual ~MediaTrackHelperV3() {
+ delete mBufferGroup;
+ }
+ virtual media_status_t start() = 0;
+ virtual media_status_t stop() = 0;
+ virtual media_status_t getFormat(AMediaFormat *format) = 0;
+
+ class ReadOptions {
+ public:
+ enum SeekMode : int32_t {
+ SEEK_PREVIOUS_SYNC,
+ SEEK_NEXT_SYNC,
+ SEEK_CLOSEST_SYNC,
+ SEEK_CLOSEST,
+ SEEK_FRAME_INDEX,
+ };
+
+ ReadOptions(uint32_t options, int64_t seekPosUs) {
+ mOptions = options;
+ mSeekPosUs = seekPosUs;
+ }
+ bool getSeekTo(int64_t *time_us, SeekMode *mode) const {
+ if ((mOptions & CMediaTrackReadOptions::SEEK) == 0) {
+ return false;
+ }
+ *time_us = mSeekPosUs;
+ *mode = (SeekMode) (mOptions & 7);
+ return true;
+ }
+ bool getNonBlocking() const {
+ return mOptions & CMediaTrackReadOptions::NONBLOCKING;
+ }
+ private:
+ uint32_t mOptions;
+ int64_t mSeekPosUs;
+ };
+
+ virtual media_status_t read(
+ MediaBufferHelperV3 **buffer, const ReadOptions *options = NULL) = 0;
+ virtual bool supportsNonBlockingRead() { return false; }
+protected:
+ friend CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *track);
+ MediaBufferGroupHelperV3 *mBufferGroup;
+};
+
+inline CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *track) {
+ CMediaTrackV3 *wrapper = (CMediaTrackV3*) malloc(sizeof(CMediaTrackV3));
+ wrapper->data = track;
+ wrapper->free = [](void *data) -> void {
+ delete (MediaTrackHelperV3*)(data);
+ };
+ wrapper->start = [](void *data, CMediaBufferGroupV3 *bufferGroup) -> media_status_t {
+ if (((MediaTrackHelperV3*)data)->mBufferGroup) {
+ // this shouldn't happen, but handle it anyway
+ delete ((MediaTrackHelperV3*)data)->mBufferGroup;
+ }
+ ((MediaTrackHelperV3*)data)->mBufferGroup = new MediaBufferGroupHelperV3(bufferGroup);
+ return ((MediaTrackHelperV3*)data)->start();
+ };
+ wrapper->stop = [](void *data) -> media_status_t {
+ return ((MediaTrackHelperV3*)data)->stop();
+ };
+ wrapper->getFormat = [](void *data, AMediaFormat *meta) -> media_status_t {
+ return ((MediaTrackHelperV3*)data)->getFormat(meta);
+ };
+ wrapper->read = [](void *data, CMediaBufferV3 **buffer, uint32_t options, int64_t seekPosUs)
+ -> media_status_t {
+ MediaTrackHelperV3::ReadOptions opts(options, seekPosUs);
+ MediaBufferHelperV3 *buf = NULL;
+ media_status_t ret = ((MediaTrackHelperV3*)data)->read(&buf, &opts);
+ if (ret == AMEDIA_OK && buf != nullptr) {
+ *buffer = buf->mBuffer;
+ }
+ return ret;
+ };
+ wrapper->supportsNonBlockingRead = [](void *data) -> bool {
+ return ((MediaTrackHelperV3*)data)->supportsNonBlockingRead();
+ };
+ return wrapper;
+}
// extractor plugins can derive from this class which looks remarkably
@@ -341,6 +512,89 @@
return wrapper;
}
+class MediaExtractorPluginHelperV3
+{
+public:
+ virtual ~MediaExtractorPluginHelperV3() {}
+ virtual size_t countTracks() = 0;
+ virtual MediaTrackHelperV3 *getTrack(size_t index) = 0;
+
+ enum GetTrackMetaDataFlags {
+ kIncludeExtensiveMetaData = 1
+ };
+ virtual media_status_t getTrackMetaData(
+ AMediaFormat *meta,
+ size_t index, uint32_t flags = 0) = 0;
+
+ // Return container specific meta-data. The default implementation
+ // returns an empty metadata object.
+ virtual media_status_t getMetaData(AMediaFormat *meta) = 0;
+
+ enum Flags {
+ CAN_SEEK_BACKWARD = 1, // the "seek 10secs back button"
+ CAN_SEEK_FORWARD = 2, // the "seek 10secs forward button"
+ CAN_PAUSE = 4,
+ CAN_SEEK = 8, // the "seek bar"
+ };
+
+ // If subclasses do _not_ override this, the default is
+ // CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE
+ virtual uint32_t flags() const {
+ return CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE;
+ };
+
+ virtual media_status_t setMediaCas(const uint8_t* /*casToken*/, size_t /*size*/) {
+ return AMEDIA_ERROR_INVALID_OPERATION;
+ }
+
+ virtual const char * name() { return "<unspecified>"; }
+
+protected:
+ MediaExtractorPluginHelperV3() {}
+
+private:
+ MediaExtractorPluginHelperV3(const MediaExtractorPluginHelperV2 &);
+ MediaExtractorPluginHelperV3 &operator=(const MediaExtractorPluginHelperV2 &);
+};
+
+inline CMediaExtractorV3 *wrapV3(MediaExtractorPluginHelperV3 *extractor) {
+ CMediaExtractorV3 *wrapper = (CMediaExtractorV3*) malloc(sizeof(CMediaExtractorV3));
+ wrapper->data = extractor;
+ wrapper->free = [](void *data) -> void {
+ delete (MediaExtractorPluginHelperV3*)(data);
+ };
+ wrapper->countTracks = [](void *data) -> size_t {
+ return ((MediaExtractorPluginHelperV3*)data)->countTracks();
+ };
+ wrapper->getTrack = [](void *data, size_t index) -> CMediaTrackV3* {
+ return wrapV3(((MediaExtractorPluginHelperV3*)data)->getTrack(index));
+ };
+ wrapper->getTrackMetaData = [](
+ void *data,
+ AMediaFormat *meta,
+ size_t index, uint32_t flags) -> media_status_t {
+ return ((MediaExtractorPluginHelperV3*)data)->getTrackMetaData(meta, index, flags);
+ };
+ wrapper->getMetaData = [](
+ void *data,
+ AMediaFormat *meta) -> media_status_t {
+ return ((MediaExtractorPluginHelperV3*)data)->getMetaData(meta);
+ };
+ wrapper->flags = [](
+ void *data) -> uint32_t {
+ return ((MediaExtractorPluginHelperV3*)data)->flags();
+ };
+ wrapper->setMediaCas = [](
+ void *data, const uint8_t *casToken, size_t size) -> media_status_t {
+ return ((MediaExtractorPluginHelperV3*)data)->setMediaCas(casToken, size);
+ };
+ wrapper->name = [](
+ void *data) -> const char * {
+ return ((MediaExtractorPluginHelperV3*)data)->name();
+ };
+ return wrapper;
+}
+
/* adds some convience methods */
class DataSourceHelper {
public:
diff --git a/include/media/MediaTrack.h b/include/media/MediaTrack.h
index ee3591e..baa3410 100644
--- a/include/media/MediaTrack.h
+++ b/include/media/MediaTrack.h
@@ -23,6 +23,7 @@
#include <binder/IMemory.h>
#include <binder/MemoryDealer.h>
#include <media/MediaExtractorPluginApi.h>
+#include <media/stagefright/MediaBufferGroup.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
#include <media/MediaExtractorPluginApi.h>
@@ -175,6 +176,25 @@
CMediaTrackV2 *wrapper;
};
+class MediaTrackCUnwrapperV3 : public MediaTrack {
+public:
+ explicit MediaTrackCUnwrapperV3(CMediaTrackV3 *wrapper);
+
+ virtual status_t start();
+ virtual status_t stop();
+ virtual status_t getFormat(MetaDataBase& format);
+ virtual status_t read(MediaBufferBase **buffer, const ReadOptions *options = NULL);
+
+ virtual bool supportNonblockingRead();
+
+protected:
+ virtual ~MediaTrackCUnwrapperV3();
+
+private:
+ CMediaTrackV3 *wrapper;
+ MediaBufferGroup *bufferGroup;
+};
+
} // namespace android
#endif // MEDIA_SOURCE_BASE_H_
diff --git a/include/media/NdkMediaErrorPriv.h b/include/media/NdkMediaErrorPriv.h
index f5e2f02..3bbba79 100644
--- a/include/media/NdkMediaErrorPriv.h
+++ b/include/media/NdkMediaErrorPriv.h
@@ -20,10 +20,8 @@
#include <media/NdkMediaError.h>
#include <utils/Errors.h>
-using namespace android;
+media_status_t translate_error(android::status_t);
-media_status_t translate_error(status_t);
-
-status_t reverse_translate_error(media_status_t);
+android::status_t reverse_translate_error(media_status_t);
#endif // _NDK_MEDIA_ERROR_PRIV_H
diff --git a/include/media/NdkMediaFormatPriv.h b/include/media/NdkMediaFormatPriv.h
index 6c452c3..1fda4a8 100644
--- a/include/media/NdkMediaFormatPriv.h
+++ b/include/media/NdkMediaFormatPriv.h
@@ -27,6 +27,7 @@
#ifndef _NDK_MEDIA_FORMAT_PRIV_H
#define _NDK_MEDIA_FORMAT_PRIV_H
+#include <utils/KeyedVector.h>
#include <utils/String8.h>
#include <utils/StrongPointer.h>
#include <media/stagefright/foundation/AMessage.h>
@@ -35,20 +36,22 @@
extern "C" {
#endif
-using namespace android;
-
struct AMediaFormat {
- sp<AMessage> mFormat;
- String8 mDebug;
- KeyedVector<String8, String8> mStringCache;
+ android::sp<android::AMessage> mFormat;
+ android::String8 mDebug;
+ android::KeyedVector<android::String8, android::String8> mStringCache;
};
-AMediaFormat* AMediaFormat_fromMsg(const void*);
-void AMediaFormat_getFormat(const AMediaFormat* mData, void* dest);
-
#ifdef __cplusplus
} // extern "C"
#endif
+namespace android {
+
+AMediaFormat* AMediaFormat_fromMsg(sp<AMessage> *);
+void AMediaFormat_getFormat(const AMediaFormat* mData, sp<AMessage> *dest);
+
+} // namespace android
+
#endif // _NDK_MEDIA_FORMAT_PRIV_H
diff --git a/media/codec2/components/base/Android.bp b/media/codec2/components/base/Android.bp
index 06bb81a..d02f541 100644
--- a/media/codec2/components/base/Android.bp
+++ b/media/codec2/components/base/Android.bp
@@ -31,9 +31,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
ldflags: ["-Wl,-Bsymbolic"],
diff --git a/media/codec2/components/cmds/Android.bp b/media/codec2/components/cmds/Android.bp
index 994dfee..6b0977b 100644
--- a/media/codec2/components/cmds/Android.bp
+++ b/media/codec2/components/cmds/Android.bp
@@ -33,8 +33,5 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/codec2/faultinjection/Android.bp b/media/codec2/faultinjection/Android.bp
index ade638f..a0ad3ce 100644
--- a/media/codec2/faultinjection/Android.bp
+++ b/media/codec2/faultinjection/Android.bp
@@ -22,9 +22,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
ldflags: ["-Wl,-Bsymbolic"],
diff --git a/media/codec2/sfplugin/Android.bp b/media/codec2/sfplugin/Android.bp
index f5578726..2870d39 100644
--- a/media/codec2/sfplugin/Android.bp
+++ b/media/codec2/sfplugin/Android.bp
@@ -54,8 +54,5 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/codec2/sfplugin/utils/Android.bp b/media/codec2/sfplugin/utils/Android.bp
index bd4983c..eb6c3e9 100644
--- a/media/codec2/sfplugin/utils/Android.bp
+++ b/media/codec2/sfplugin/utils/Android.bp
@@ -32,8 +32,5 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/aac/Android.bp b/media/extractors/aac/Android.bp
index 42b0a64..a5e91bb 100644
--- a/media/extractors/aac/Android.bp
+++ b/media/extractors/aac/Android.bp
@@ -36,9 +36,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/amr/Android.bp b/media/extractors/amr/Android.bp
index 83ea4c7..0791fa3 100644
--- a/media/extractors/amr/Android.bp
+++ b/media/extractors/amr/Android.bp
@@ -34,9 +34,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/flac/Android.bp b/media/extractors/flac/Android.bp
index 4d0a4cc..4bf1295 100644
--- a/media/extractors/flac/Android.bp
+++ b/media/extractors/flac/Android.bp
@@ -40,9 +40,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/flac/FLACExtractor.cpp b/media/extractors/flac/FLACExtractor.cpp
index d54aaef..671fa5a 100644
--- a/media/extractors/flac/FLACExtractor.cpp
+++ b/media/extractors/flac/FLACExtractor.cpp
@@ -401,6 +401,7 @@
// Copy samples from FLAC native 32-bit non-interleaved to 16-bit signed
// or 32-bit float interleaved.
+// TODO: Consider moving to audio_utils.
// These are candidates for optimization if needed.
static void copyTo16Signed(
short *dst,
@@ -408,10 +409,19 @@
unsigned nSamples,
unsigned nChannels,
unsigned bitsPerSample) {
- const unsigned leftShift = 16 - bitsPerSample;
- for (unsigned i = 0; i < nSamples; ++i) {
- for (unsigned c = 0; c < nChannels; ++c) {
- *dst++ = src[c][i] << leftShift;
+ const int leftShift = 16 - (int)bitsPerSample; // cast to int to prevent unsigned overflow.
+ if (leftShift >= 0) {
+ for (unsigned i = 0; i < nSamples; ++i) {
+ for (unsigned c = 0; c < nChannels; ++c) {
+ *dst++ = src[c][i] << leftShift;
+ }
+ }
+ } else {
+ const int rightShift = -leftShift;
+ for (unsigned i = 0; i < nSamples; ++i) {
+ for (unsigned c = 0; c < nChannels; ++c) {
+ *dst++ = src[c][i] >> rightShift;
+ }
}
}
}
@@ -514,8 +524,10 @@
case 8:
case 16:
case 24:
+ case 32: // generally not expected for FLAC
break;
default:
+ // Note: internally the FLAC extractor supports 2-32 bits.
ALOGE("unsupported bits per sample %u", getBitsPerSample());
return NO_INIT;
}
@@ -532,8 +544,11 @@
case 48000:
case 88200:
case 96000:
+ case 176400:
+ case 192000:
break;
default:
+ // Note: internally we support arbitrary sample rates from 8kHz to 192kHz.
ALOGE("unsupported sample rate %u", getSampleRate());
return NO_INIT;
}
diff --git a/media/extractors/midi/Android.bp b/media/extractors/midi/Android.bp
index c5df5c7..937e545 100644
--- a/media/extractors/midi/Android.bp
+++ b/media/extractors/midi/Android.bp
@@ -35,9 +35,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/mkv/Android.bp b/media/extractors/mkv/Android.bp
index ae108ec..8d028e1 100644
--- a/media/extractors/mkv/Android.bp
+++ b/media/extractors/mkv/Android.bp
@@ -41,9 +41,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/mp3/Android.bp b/media/extractors/mp3/Android.bp
index 1025c46..97b687f 100644
--- a/media/extractors/mp3/Android.bp
+++ b/media/extractors/mp3/Android.bp
@@ -40,9 +40,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/mp4/Android.bp b/media/extractors/mp4/Android.bp
index 47dc718..91de353 100644
--- a/media/extractors/mp4/Android.bp
+++ b/media/extractors/mp4/Android.bp
@@ -48,9 +48,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/mpeg2/Android.bp b/media/extractors/mpeg2/Android.bp
index 40314dc..38c86eb 100644
--- a/media/extractors/mpeg2/Android.bp
+++ b/media/extractors/mpeg2/Android.bp
@@ -52,9 +52,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/ogg/Android.bp b/media/extractors/ogg/Android.bp
index c6deb18..01acb2c 100644
--- a/media/extractors/ogg/Android.bp
+++ b/media/extractors/ogg/Android.bp
@@ -38,9 +38,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/wav/Android.bp b/media/extractors/wav/Android.bp
index 185bb32..7e89271 100644
--- a/media/extractors/wav/Android.bp
+++ b/media/extractors/wav/Android.bp
@@ -9,7 +9,6 @@
shared_libs: [
"libbinder_ndk",
"liblog",
- "libmediaextractor",
"libmediandk",
],
@@ -37,9 +36,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/extractors/wav/WAVExtractor.cpp b/media/extractors/wav/WAVExtractor.cpp
index 86500ef..17b5f81 100644
--- a/media/extractors/wav/WAVExtractor.cpp
+++ b/media/extractors/wav/WAVExtractor.cpp
@@ -22,9 +22,7 @@
#include <android/binder_ibinder.h> // for AIBinder_getCallingUid
#include <audio_utils/primitives.h>
-#include <media/DataSourceBase.h>
#include <media/stagefright/foundation/ADebug.h>
-#include <media/stagefright/MediaBufferGroup.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
@@ -68,7 +66,7 @@
return ptr[1] << 8 | ptr[0];
}
-struct WAVSource : public MediaTrackHelperV2 {
+struct WAVSource : public MediaTrackHelperV3 {
WAVSource(
DataSourceHelper *dataSource,
AMediaFormat *meta,
@@ -81,7 +79,7 @@
virtual media_status_t getFormat(AMediaFormat *meta);
virtual media_status_t read(
- MediaBufferBase **buffer, const ReadOptions *options = NULL);
+ MediaBufferHelperV3 **buffer, const ReadOptions *options = NULL);
virtual bool supportNonblockingRead() { return true; }
@@ -101,7 +99,6 @@
off64_t mOffset;
size_t mSize;
bool mStarted;
- MediaBufferGroup *mGroup;
off64_t mCurrentPos;
WAVSource(const WAVSource &);
@@ -134,7 +131,7 @@
return mInitCheck == OK ? 1 : 0;
}
-MediaTrackHelperV2 *WAVExtractor::getTrack(size_t index) {
+MediaTrackHelperV3 *WAVExtractor::getTrack(size_t index) {
if (mInitCheck != OK || index > 0) {
return NULL;
}
@@ -379,14 +376,14 @@
mOutputFloat(outputFloat),
mOffset(offset),
mSize(size),
- mStarted(false),
- mGroup(NULL) {
+ mStarted(false) {
CHECK(AMediaFormat_getInt32(mMeta, AMEDIAFORMAT_KEY_SAMPLE_RATE, &mSampleRate));
CHECK(AMediaFormat_getInt32(mMeta, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &mNumChannels));
CHECK(AMediaFormat_getInt32(mMeta, AMEDIAFORMAT_KEY_BITS_PER_SAMPLE, &mBitsPerSample));
}
WAVSource::~WAVSource() {
+ ALOGI("~WAVSource");
if (mStarted) {
stop();
}
@@ -398,7 +395,9 @@
CHECK(!mStarted);
// some WAV files may have large audio buffers that use shared memory transfer.
- mGroup = new MediaBufferGroup(4 /* buffers */, kMaxFrameSize);
+ if (!mBufferGroup->init(4 /* buffers */, kMaxFrameSize)) {
+ return AMEDIA_ERROR_UNKNOWN;
+ }
mCurrentPos = mOffset;
@@ -412,9 +411,6 @@
CHECK(mStarted);
- delete mGroup;
- mGroup = NULL;
-
mStarted = false;
return AMEDIA_OK;
@@ -433,10 +429,10 @@
}
media_status_t WAVSource::read(
- MediaBufferBase **out, const ReadOptions *options) {
+ MediaBufferHelperV3 **out, const ReadOptions *options) {
*out = NULL;
- if (options != nullptr && options->getNonBlocking() && !mGroup->has_buffers()) {
+ if (options != nullptr && options->getNonBlocking() && !mBufferGroup->has_buffers()) {
return AMEDIA_ERROR_WOULD_BLOCK;
}
@@ -459,10 +455,10 @@
mCurrentPos = pos + mOffset;
}
- MediaBufferBase *buffer;
- status_t err = mGroup->acquire_buffer(&buffer);
+ MediaBufferHelperV3 *buffer;
+ media_status_t err = mBufferGroup->acquire_buffer(&buffer);
if (err != OK) {
- return AMEDIA_ERROR_UNKNOWN;
+ return err;
}
// maxBytesToRead may be reduced so that in-place data conversion will fit in buffer size.
@@ -573,9 +569,10 @@
/ (mNumChannels * bytesPerSample) / mSampleRate;
}
- buffer->meta_data().setInt64(kKeyTime, timeStampUs);
+ AMediaFormat *meta = buffer->meta_data();
+ AMediaFormat_setInt64(meta, AMEDIAFORMAT_KEY_TIME_US, timeStampUs);
+ AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, 1);
- buffer->meta_data().setInt32(kKeyIsSyncFrame, 1);
mCurrentPos += n;
*out = buffer;
@@ -585,13 +582,13 @@
////////////////////////////////////////////////////////////////////////////////
-static CMediaExtractorV2* CreateExtractor(
+static CMediaExtractorV3* CreateExtractor(
CDataSource *source,
void *) {
- return wrapV2(new WAVExtractor(new DataSourceHelper(source)));
+ return wrapV3(new WAVExtractor(new DataSourceHelper(source)));
}
-static CreatorFuncV2 Sniff(
+static CreatorFuncV3 Sniff(
CDataSource *source,
float *confidence,
void **,
@@ -625,11 +622,11 @@
__attribute__ ((visibility ("default")))
ExtractorDef GETEXTRACTORDEF() {
return {
- EXTRACTORDEF_VERSION_CURRENT,
+ EXTRACTORDEF_VERSION_CURRENT + 1,
UUID("7d613858-5837-4a38-84c5-332d1cddee27"),
1, // version
"WAV Extractor",
- { .v2 = Sniff }
+ { .v3 = Sniff }
};
}
diff --git a/media/extractors/wav/WAVExtractor.h b/media/extractors/wav/WAVExtractor.h
index ce34881..9b7dfde 100644
--- a/media/extractors/wav/WAVExtractor.h
+++ b/media/extractors/wav/WAVExtractor.h
@@ -29,12 +29,12 @@
struct CDataSource;
class String8;
-class WAVExtractor : public MediaExtractorPluginHelperV2 {
+class WAVExtractor : public MediaExtractorPluginHelperV3 {
public:
explicit WAVExtractor(DataSourceHelper *source);
virtual size_t countTracks();
- virtual MediaTrackHelperV2 *getTrack(size_t index);
+ virtual MediaTrackHelperV3 *getTrack(size_t index);
virtual media_status_t getTrackMetaData(AMediaFormat *meta, size_t index, uint32_t flags);
virtual media_status_t getMetaData(AMediaFormat *meta);
diff --git a/media/libaaudio/src/binding/IAAudioService.cpp b/media/libaaudio/src/binding/IAAudioService.cpp
index 620edc7..9b32543 100644
--- a/media/libaaudio/src/binding/IAAudioService.cpp
+++ b/media/libaaudio/src/binding/IAAudioService.cpp
@@ -72,7 +72,6 @@
ALOGE("BpAAudioService::client transact(OPEN_STREAM) readInt %d", err);
return AAudioConvert_androidToAAudioResult(err);
} else if (stream < 0) {
- ALOGE("BpAAudioService::client OPEN_STREAM passed stream %d", stream);
return stream;
}
err = configurationOutput.readFromParcel(&reply);
diff --git a/media/libaaudio/src/client/AudioStreamInternal.cpp b/media/libaaudio/src/client/AudioStreamInternal.cpp
index 0a8021a..fffcda0 100644
--- a/media/libaaudio/src/client/AudioStreamInternal.cpp
+++ b/media/libaaudio/src/client/AudioStreamInternal.cpp
@@ -131,7 +131,6 @@
mServiceStreamHandle = mServiceInterface.openStream(request, configurationOutput);
}
if (mServiceStreamHandle < 0) {
- ALOGE("%s - openStream() returned %d", __func__, mServiceStreamHandle);
return mServiceStreamHandle;
}
@@ -693,7 +692,6 @@
}
aaudio_result_t result = mAudioEndpoint.setBufferSizeInFrames(adjustedFrames, &actualFrames);
- ALOGD("setBufferSize() req = %d => %d", requestedFrames, actualFrames);
if (result < 0) {
return result;
} else {
diff --git a/media/libaaudio/src/core/AAudioAudio.cpp b/media/libaaudio/src/core/AAudioAudio.cpp
index e272f2a..2fb3986 100644
--- a/media/libaaudio/src/core/AAudioAudio.cpp
+++ b/media/libaaudio/src/core/AAudioAudio.cpp
@@ -241,7 +241,7 @@
{
AudioStream *audioStream = nullptr;
// Please leave these logs because they are very helpful when debugging.
- ALOGD("AAudioStreamBuilder_openStream() called ----------------------------------------");
+ ALOGD("%s() called ----------------------------------------", __func__);
AudioStreamBuilder *streamBuilder = COMMON_GET_FROM_BUILDER_OR_RETURN(streamPtr);
aaudio_result_t result = streamBuilder->build(&audioStream);
ALOGD("AAudioStreamBuilder_openStream() returns %d = %s for (%p) ----------------",
@@ -269,7 +269,7 @@
{
aaudio_result_t result = AAUDIO_ERROR_NULL;
AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
- ALOGD("AAudioStream_close(%p) called ---------------", stream);
+ ALOGD("%s(%p) called ---------------", __func__, stream);
if (audioStream != nullptr) {
result = audioStream->safeClose();
// Close will only fail if called illegally, for example, from a callback.
@@ -284,7 +284,7 @@
// We're potentially freeing `stream` above, so its use here makes some
// static analysis tools unhappy. Casting to uintptr_t helps assure
// said tools that we're not doing anything bad here.
- ALOGD("AAudioStream_close(%#" PRIxPTR ") returned %d ---------",
+ ALOGD("%s(%#" PRIxPTR ") returned %d ---------", __func__,
reinterpret_cast<uintptr_t>(stream), result);
return result;
}
@@ -292,30 +292,30 @@
AAUDIO_API aaudio_result_t AAudioStream_requestStart(AAudioStream* stream)
{
AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
- ALOGD("AAudioStream_requestStart(%p) called --------------", stream);
+ ALOGD("%s(%p) called --------------", __func__, stream);
aaudio_result_t result = audioStream->systemStart();
- ALOGD("AAudioStream_requestStart(%p) returned %d ---------", stream, result);
+ ALOGD("%s(%p) returned %d ---------", __func__, stream, result);
return result;
}
AAUDIO_API aaudio_result_t AAudioStream_requestPause(AAudioStream* stream)
{
AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
- ALOGD("AAudioStream_requestPause(%p)", stream);
+ ALOGD("%s(%p) called", __func__, stream);
return audioStream->systemPause();
}
AAUDIO_API aaudio_result_t AAudioStream_requestFlush(AAudioStream* stream)
{
AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
- ALOGD("AAudioStream_requestFlush(%p)", stream);
+ ALOGD("%s(%p) called", __func__, stream);
return audioStream->safeFlush();
}
AAUDIO_API aaudio_result_t AAudioStream_requestStop(AAudioStream* stream)
{
AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
- ALOGD("AAudioStream_requestStop(%p)", stream);
+ ALOGD("%s(%p) called", __func__, stream);
return audioStream->systemStop();
}
diff --git a/media/libaaudio/src/core/AudioStream.cpp b/media/libaaudio/src/core/AudioStream.cpp
index 358021b..391af29 100644
--- a/media/libaaudio/src/core/AudioStream.cpp
+++ b/media/libaaudio/src/core/AudioStream.cpp
@@ -37,7 +37,6 @@
}
AudioStream::~AudioStream() {
- ALOGD("destroying %p, state = %s", this, AAudio_convertStreamStateToText(getState()));
// If the stream is deleted when OPEN or in use then audio resources will leak.
// This would indicate an internal error. So we want to find this ASAP.
LOG_ALWAYS_FATAL_IF(!(getState() == AAUDIO_STREAM_STATE_CLOSED
diff --git a/media/libaaudio/src/fifo/FifoControllerBase.cpp b/media/libaaudio/src/fifo/FifoControllerBase.cpp
index 9885cb0..66e247f 100644
--- a/media/libaaudio/src/fifo/FifoControllerBase.cpp
+++ b/media/libaaudio/src/fifo/FifoControllerBase.cpp
@@ -38,7 +38,7 @@
fifo_frames_t FifoControllerBase::getReadIndex() {
// % works with non-power of two sizes
- return (fifo_frames_t) (getReadCounter() % mCapacity);
+ return (fifo_frames_t) ((uint64_t)getReadCounter() % mCapacity);
}
void FifoControllerBase::advanceReadIndex(fifo_frames_t numFrames) {
@@ -51,7 +51,7 @@
fifo_frames_t FifoControllerBase::getWriteIndex() {
// % works with non-power of two sizes
- return (fifo_frames_t) (getWriteCounter() % mCapacity);
+ return (fifo_frames_t) ((uint64_t)getWriteCounter() % mCapacity);
}
void FifoControllerBase::advanceWriteIndex(fifo_frames_t numFrames) {
diff --git a/media/libaaudio/tests/test_atomic_fifo.cpp b/media/libaaudio/tests/test_atomic_fifo.cpp
index a09b74c..130ef43 100644
--- a/media/libaaudio/tests/test_atomic_fifo.cpp
+++ b/media/libaaudio/tests/test_atomic_fifo.cpp
@@ -23,12 +23,12 @@
#include "fifo/FifoController.h"
using android::fifo_frames_t;
+using android::fifo_counter_t;
using android::FifoController;
using android::FifoBuffer;
using android::WrappingBuffer;
-//void foo() {
-TEST(test_fifi_controller, fifo_indices) {
+TEST(test_fifo_controller, fifo_indices) {
// Values are arbitrary primes designed to trigger edge cases.
constexpr int capacity = 83;
constexpr int threshold = 47;
@@ -73,18 +73,59 @@
ASSERT_EQ(threshold - advance2, fifoController.getEmptyFramesAvailable());
}
+TEST(test_fifo_controller, fifo_wrap_around_zero) {
+ constexpr int capacity = 7; // arbitrary prime
+ constexpr int threshold = capacity;
+ FifoController fifoController(capacity, threshold);
+ ASSERT_EQ(capacity, fifoController.getCapacity());
+ ASSERT_EQ(threshold, fifoController.getThreshold());
+
+ fifoController.setReadCounter(-10); // a bit less than negative capacity
+ for (int i = 0; i < 20; i++) {
+ EXPECT_EQ(i - 10, fifoController.getReadCounter());
+ EXPECT_GE(fifoController.getReadIndex(), 0);
+ EXPECT_LT(fifoController.getReadIndex(), capacity);
+ fifoController.advanceReadIndex(1);
+ }
+
+ fifoController.setWriteCounter(-10);
+ for (int i = 0; i < 20; i++) {
+ EXPECT_EQ(i - 10, fifoController.getWriteCounter());
+ EXPECT_GE(fifoController.getWriteIndex(), 0);
+ EXPECT_LT(fifoController.getWriteIndex(), capacity);
+ fifoController.advanceWriteIndex(1);
+ }
+}
+
+
// TODO consider using a template for other data types.
+
+// Create a big array and then use a region in the middle for the unit tests.
+// Then we can scan the rest of the array to see if it got clobbered.
+static constexpr fifo_frames_t kBigArraySize = 1024;
+static constexpr fifo_frames_t kFifoDataOffset = 128; // starting index of FIFO data
+static constexpr int16_t kSafeDataValue = 0x7654; // original value of BigArray
+
class TestFifoBuffer {
public:
explicit TestFifoBuffer(fifo_frames_t capacity, fifo_frames_t threshold = 0)
- : mFifoBuffer(sizeof(int16_t), capacity) {
+ : mFifoBuffer(sizeof(int16_t), capacity,
+ &mReadIndex,
+ &mWriteIndex,
+ &mVeryBigArray[kFifoDataOffset]) // address of start of FIFO data
+ {
+
+ // Assume a frame is one int16_t.
// For reading and writing.
- mData = new int16_t[capacity];
if (threshold <= 0) {
threshold = capacity;
}
mFifoBuffer.setThreshold(threshold);
mThreshold = threshold;
+
+ for (fifo_frames_t i = 0; i < kBigArraySize; i++) {
+ mVeryBigArray[i] = kSafeDataValue;
+ }
}
void checkMisc() {
@@ -92,26 +133,70 @@
ASSERT_EQ(mThreshold, mFifoBuffer.getThreshold());
}
+ void verifyAddressInRange(void *p, void *valid, size_t numBytes) {
+ uintptr_t p_int = (uintptr_t) p;
+ uintptr_t valid_int = (uintptr_t) valid;
+ EXPECT_GE(p_int, valid_int);
+ EXPECT_LT(p_int, (valid_int + numBytes));
+ }
+
+ void verifyStorageIntegrity() {
+ for (fifo_frames_t i = 0; i < kFifoDataOffset; i++) {
+ EXPECT_EQ(mVeryBigArray[i], kSafeDataValue);
+ }
+ fifo_frames_t firstFrameAfter = kFifoDataOffset + mFifoBuffer.getBufferCapacityInFrames();
+ for (fifo_frames_t i = firstFrameAfter; i < kBigArraySize; i++) {
+ EXPECT_EQ(mVeryBigArray[i], kSafeDataValue);
+ }
+ }
+
// Verify that the available frames in each part add up correctly.
- void checkWrappingBuffer() {
+ void verifyWrappingBuffer() {
WrappingBuffer wrappingBuffer;
+
+
+ // Does the sum of the two parts match the available value returned?
+ // For EmptyRoom
fifo_frames_t framesAvailable =
mFifoBuffer.getEmptyFramesAvailable();
fifo_frames_t wrapAvailable = mFifoBuffer.getEmptyRoomAvailable(&wrappingBuffer);
EXPECT_EQ(framesAvailable, wrapAvailable);
fifo_frames_t bothAvailable = wrappingBuffer.numFrames[0] + wrappingBuffer.numFrames[1];
EXPECT_EQ(framesAvailable, bothAvailable);
-
+ // For FullData
framesAvailable =
mFifoBuffer.getFullFramesAvailable();
wrapAvailable = mFifoBuffer.getFullDataAvailable(&wrappingBuffer);
EXPECT_EQ(framesAvailable, wrapAvailable);
bothAvailable = wrappingBuffer.numFrames[0] + wrappingBuffer.numFrames[1];
EXPECT_EQ(framesAvailable, bothAvailable);
+
+ // Are frame counts in legal range?
+ fifo_frames_t capacity = mFifoBuffer.getBufferCapacityInFrames();
+ EXPECT_GE(wrappingBuffer.numFrames[0], 0);
+ EXPECT_LE(wrappingBuffer.numFrames[0], capacity);
+ EXPECT_GE(wrappingBuffer.numFrames[1], 0);
+ EXPECT_LE(wrappingBuffer.numFrames[1], capacity);
+
+ // Are addresses within the FIFO data area?
+ size_t validBytes = capacity * sizeof(int16_t);
+ if (wrappingBuffer.numFrames[0]) {
+ verifyAddressInRange(wrappingBuffer.data[0], mFifoStorage, validBytes);
+ uint8_t *last = ((uint8_t *)wrappingBuffer.data[0])
+ + mFifoBuffer.convertFramesToBytes(wrappingBuffer.numFrames[0]) - 1;
+ verifyAddressInRange(last, mFifoStorage, validBytes);
+ }
+ if (wrappingBuffer.numFrames[1]) {
+ verifyAddressInRange(wrappingBuffer.data[1], mFifoStorage, validBytes);
+ uint8_t *last = ((uint8_t *)wrappingBuffer.data[1])
+ + mFifoBuffer.convertFramesToBytes(wrappingBuffer.numFrames[1]) - 1;
+ verifyAddressInRange(last, mFifoStorage, validBytes);
+ }
+
}
// Write data but do not overflow.
- void writeData(fifo_frames_t numFrames) {
+ void writeMultipleDataFrames(fifo_frames_t numFrames) {
fifo_frames_t framesAvailable =
mFifoBuffer.getEmptyFramesAvailable();
fifo_frames_t framesToWrite = std::min(framesAvailable, numFrames);
@@ -122,8 +207,8 @@
ASSERT_EQ(framesToWrite, actual);
}
- // Read data but do not underflow.
- void verifyData(fifo_frames_t numFrames) {
+ // Read whatever data is available, Do not underflow.
+ void verifyMultipleDataFrames(fifo_frames_t numFrames) {
fifo_frames_t framesAvailable =
mFifoBuffer.getFullFramesAvailable();
fifo_frames_t framesToRead = std::min(framesAvailable, numFrames);
@@ -134,20 +219,35 @@
}
}
+ // Read specified number of frames
+ void verifyRequestedData(fifo_frames_t numFrames) {
+ fifo_frames_t framesAvailable =
+ mFifoBuffer.getFullFramesAvailable();
+ ASSERT_LE(numFrames, framesAvailable);
+ fifo_frames_t framesToRead = std::min(framesAvailable, numFrames);
+ fifo_frames_t actual = mFifoBuffer.read(mData, framesToRead);
+ ASSERT_EQ(actual, numFrames);
+ for (int i = 0; i < actual; i++) {
+ ASSERT_EQ(mNextVerifyIndex++, mData[i]);
+ }
+ }
+
// Wrap around the end of the buffer.
void checkWrappingWriteRead() {
constexpr int frames1 = 43;
constexpr int frames2 = 15;
- writeData(frames1);
- checkWrappingBuffer();
- verifyData(frames1);
- checkWrappingBuffer();
+ writeMultipleDataFrames(frames1);
+ verifyWrappingBuffer();
+ verifyRequestedData(frames1);
+ verifyWrappingBuffer();
- writeData(frames2);
- checkWrappingBuffer();
- verifyData(frames2);
- checkWrappingBuffer();
+ writeMultipleDataFrames(frames2);
+ verifyWrappingBuffer();
+ verifyRequestedData(frames2);
+ verifyWrappingBuffer();
+
+ verifyStorageIntegrity();
}
// Write and Read a specific amount of data.
@@ -156,10 +256,12 @@
// Wrap around with the smaller region in the second half.
const int frames1 = capacity - 4;
const int frames2 = 7; // arbitrary, small
- writeData(frames1);
- verifyData(frames1);
- writeData(frames2);
- verifyData(frames2);
+ writeMultipleDataFrames(frames1);
+ verifyRequestedData(frames1);
+ writeMultipleDataFrames(frames2);
+ verifyRequestedData(frames2);
+
+ verifyStorageIntegrity();
}
// Write and Read a specific amount of data.
@@ -168,10 +270,12 @@
// Wrap around with the larger region in the second half.
const int frames1 = capacity - 4;
const int frames2 = capacity - 9; // arbitrary, large
- writeData(frames1);
- verifyData(frames1);
- writeData(frames2);
- verifyData(frames2);
+ writeMultipleDataFrames(frames1);
+ verifyRequestedData(frames1);
+ writeMultipleDataFrames(frames2);
+ verifyRequestedData(frames2);
+
+ verifyStorageIntegrity();
}
// Randomly read or write up to the maximum amount of data.
@@ -180,30 +284,67 @@
fifo_frames_t framesEmpty =
mFifoBuffer.getEmptyFramesAvailable();
fifo_frames_t numFrames = (fifo_frames_t)(drand48() * framesEmpty);
- writeData(numFrames);
+ writeMultipleDataFrames(numFrames);
fifo_frames_t framesFull =
mFifoBuffer.getFullFramesAvailable();
numFrames = (fifo_frames_t)(drand48() * framesFull);
- verifyData(numFrames);
+ verifyMultipleDataFrames(numFrames);
}
+
+ verifyStorageIntegrity();
+ }
+
+ // Write and Read a specific amount of data.
+ void checkNegativeCounters() {
+ fifo_counter_t counter = -9876;
+ mFifoBuffer.setWriteCounter(counter);
+ mFifoBuffer.setReadCounter(counter);
+ checkWrappingWriteRead();
+ }
+
+ // Wrap over the boundary at 0x7FFFFFFFFFFFFFFF
+ // Note that the behavior of a signed overflow is technically undefined.
+ void checkHalfWrap() {
+ fifo_counter_t counter = INT64_MAX - 10;
+ mFifoBuffer.setWriteCounter(counter);
+ mFifoBuffer.setReadCounter(counter);
+ ASSERT_GT(mFifoBuffer.getWriteCounter(), 0);
+ checkWrappingWriteRead();
+ ASSERT_LT(mFifoBuffer.getWriteCounter(), 0); // did we wrap past INT64_MAX?
+ }
+
+ // Wrap over the boundary at 0xFFFFFFFFFFFFFFFF
+ void checkFullWrap() {
+ fifo_counter_t counter = -10;
+ mFifoBuffer.setWriteCounter(counter);
+ mFifoBuffer.setReadCounter(counter);
+ ASSERT_LT(mFifoBuffer.getWriteCounter(), 0);
+ writeMultipleDataFrames(20);
+ ASSERT_GT(mFifoBuffer.getWriteCounter(), 0); // did we wrap past zero?
+ verifyStorageIntegrity();
}
FifoBuffer mFifoBuffer;
- int16_t *mData;
fifo_frames_t mNextWriteIndex = 0;
fifo_frames_t mNextVerifyIndex = 0;
fifo_frames_t mThreshold;
+
+ fifo_counter_t mReadIndex = 0;
+ fifo_counter_t mWriteIndex = 0;
+ int16_t mVeryBigArray[kBigArraySize]; // Use the middle of this array for the FIFO.
+ int16_t *mFifoStorage = &mVeryBigArray[kFifoDataOffset]; // Start here for storage.
+ int16_t mData[kBigArraySize]{};
};
-TEST(test_fifo_buffer, fifo_read_write) {
+TEST(test_fifo_buffer, fifo_write_read) {
constexpr int capacity = 51; // arbitrary
TestFifoBuffer tester(capacity);
tester.checkMisc();
tester.checkWriteRead();
}
-TEST(test_fifo_buffer, fifo_wrapping_read_write) {
+TEST(test_fifo_buffer, fifo_wrapping_write_read) {
constexpr int capacity = 59; // arbitrary, a little bigger this time
TestFifoBuffer tester(capacity);
tester.checkWrappingWriteRead();
@@ -227,3 +368,21 @@
TestFifoBuffer tester(capacity, threshold);
tester.checkRandomWriteRead();
}
+
+TEST(test_fifo_buffer, fifo_negative_counters) {
+ constexpr int capacity = 49; // arbitrary
+ TestFifoBuffer tester(capacity);
+ tester.checkNegativeCounters();
+}
+
+TEST(test_fifo_buffer, fifo_half_wrap) {
+ constexpr int capacity = 57; // arbitrary
+ TestFifoBuffer tester(capacity);
+ tester.checkHalfWrap();
+}
+
+TEST(test_fifo_buffer, fifo_full_wrap) {
+ constexpr int capacity = 57; // arbitrary
+ TestFifoBuffer tester(capacity);
+ tester.checkFullWrap();
+}
diff --git a/media/libaudioprocessing/BufferProviders.cpp b/media/libaudioprocessing/BufferProviders.cpp
index 2d9e1cb..e06a1aa 100644
--- a/media/libaudioprocessing/BufferProviders.cpp
+++ b/media/libaudioprocessing/BufferProviders.cpp
@@ -63,7 +63,8 @@
CopyBufferProvider::~CopyBufferProvider()
{
- ALOGV("~CopyBufferProvider(%p)", this);
+ ALOGV("%s(%p) %zu %p %p",
+ __func__, this, mBuffer.frameCount, mTrackBufferProvider, mLocalBufferData);
if (mBuffer.frameCount != 0) {
mTrackBufferProvider->releaseBuffer(&mBuffer);
}
@@ -133,6 +134,16 @@
mConsumed = 0;
}
+void CopyBufferProvider::setBufferProvider(AudioBufferProvider *p) {
+ ALOGV("%s(%p): mTrackBufferProvider:%p mBuffer.frameCount:%zu",
+ __func__, p, mTrackBufferProvider, mBuffer.frameCount);
+ if (mTrackBufferProvider == p) {
+ return;
+ }
+ mBuffer.frameCount = 0;
+ PassthruBufferProvider::setBufferProvider(p);
+}
+
DownmixerBufferProvider::DownmixerBufferProvider(
audio_channel_mask_t inputChannelMask,
audio_channel_mask_t outputChannelMask, audio_format_t format,
@@ -528,6 +539,16 @@
mRemaining = 0;
}
+void TimestretchBufferProvider::setBufferProvider(AudioBufferProvider *p) {
+ ALOGV("%s(%p): mTrackBufferProvider:%p mBuffer.frameCount:%zu",
+ __func__, p, mTrackBufferProvider, mBuffer.frameCount);
+ if (mTrackBufferProvider == p) {
+ return;
+ }
+ mBuffer.frameCount = 0;
+ PassthruBufferProvider::setBufferProvider(p);
+}
+
status_t TimestretchBufferProvider::setPlaybackRate(const AudioPlaybackRate &playbackRate)
{
mPlaybackRate = playbackRate;
diff --git a/media/libmedia/Android.bp b/media/libmedia/Android.bp
index 3d9e62e..6002e95 100644
--- a/media/libmedia/Android.bp
+++ b/media/libmedia/Android.bp
@@ -113,9 +113,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -144,9 +141,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -267,9 +261,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -331,8 +322,5 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libmedia/NdkMediaFormatPriv.cpp b/media/libmedia/NdkMediaFormatPriv.cpp
index 3c84d6a..3a9fb8b 100644
--- a/media/libmedia/NdkMediaFormatPriv.cpp
+++ b/media/libmedia/NdkMediaFormatPriv.cpp
@@ -19,27 +19,22 @@
#include <inttypes.h>
-//#include <ndk/include/media/NdkMediaFormat.h>
-
#include <utils/Log.h>
#include <utils/StrongPointer.h>
#include <media/NdkMediaFormatPriv.h>
-#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/AMessage.h>
-//#include <android_runtime/AndroidRuntime.h>
-//#include <android_util_Binder.h>
#include <jni.h>
using namespace android;
-extern "C" {
+namespace android {
// private functions for conversion to/from AMessage
-AMediaFormat* AMediaFormat_fromMsg(const void* data) {
+AMediaFormat* AMediaFormat_fromMsg(sp<AMessage> *data) {
ALOGV("private ctor");
AMediaFormat* mData = new AMediaFormat();
- mData->mFormat = *((sp<AMessage>*)data);
+ mData->mFormat = *data;
if (mData->mFormat == NULL) {
ALOGW("got NULL format");
mData->mFormat = new AMessage;
@@ -47,10 +42,10 @@
return mData;
}
-void AMediaFormat_getFormat(const AMediaFormat* mData, void* dest) {
- *((sp<AMessage>*)dest) = mData->mFormat;
+void AMediaFormat_getFormat(const AMediaFormat* mData, sp<AMessage> *dest) {
+ *dest = mData->mFormat;
}
-} // extern "C"
+} // namespace android
diff --git a/media/libmedia/include/media/BufferProviders.h b/media/libmedia/include/media/BufferProviders.h
index d6a9cfb..2f1a91c 100644
--- a/media/libmedia/include/media/BufferProviders.h
+++ b/media/libmedia/include/media/BufferProviders.h
@@ -78,6 +78,7 @@
// Overrides PassthruBufferProvider
virtual void reset();
+ void setBufferProvider(AudioBufferProvider *p) override;
// this function should be supplied by the derived class. It converts
// #frames in the *src pointer to the *dst pointer. It is public because
@@ -186,6 +187,7 @@
// Overrides PassthruBufferProvider
virtual void reset();
+ void setBufferProvider(AudioBufferProvider *p) override;
virtual status_t setPlaybackRate(const AudioPlaybackRate &playbackRate);
diff --git a/media/libmediaextractor/Android.bp b/media/libmediaextractor/Android.bp
index 0871d60..6f2b35f 100644
--- a/media/libmediaextractor/Android.bp
+++ b/media/libmediaextractor/Android.bp
@@ -48,8 +48,5 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libmediaextractor/MediaBufferGroup.cpp b/media/libmediaextractor/MediaBufferGroup.cpp
index 62b83cc..4e6beca 100644
--- a/media/libmediaextractor/MediaBufferGroup.cpp
+++ b/media/libmediaextractor/MediaBufferGroup.cpp
@@ -44,12 +44,16 @@
};
MediaBufferGroup::MediaBufferGroup(size_t growthLimit)
- : mInternal(new InternalData()) {
+ : mWrapper(nullptr), mInternal(new InternalData()) {
mInternal->mGrowthLimit = growthLimit;
}
MediaBufferGroup::MediaBufferGroup(size_t buffers, size_t buffer_size, size_t growthLimit)
- : mInternal(new InternalData()) {
+ : mWrapper(nullptr), mInternal(new InternalData()) {
+ init(buffers, buffer_size, growthLimit);
+}
+
+void MediaBufferGroup::init(size_t buffers, size_t buffer_size, size_t growthLimit) {
mInternal->mGrowthLimit = growthLimit;
if (mInternal->mGrowthLimit > 0 && buffers > mInternal->mGrowthLimit) {
diff --git a/media/libmediaextractor/include/media/DataSource.h b/media/libmediaextractor/include/media/DataSource.h
index cb96ff5..1f7a473 100644
--- a/media/libmediaextractor/include/media/DataSource.h
+++ b/media/libmediaextractor/include/media/DataSource.h
@@ -22,7 +22,7 @@
#include <media/stagefright/MediaErrors.h>
#include <media/DataSourceBase.h>
#include <media/IDataSource.h>
-#include <media/MediaExtractorPluginHelper.h>
+#include <media/MediaExtractorPluginApi.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
#include <utils/threads.h>
diff --git a/media/libmediaextractor/include/media/stagefright/MediaBufferBase.h b/media/libmediaextractor/include/media/stagefright/MediaBufferBase.h
index 6c8d94a..d67ddbd 100644
--- a/media/libmediaextractor/include/media/stagefright/MediaBufferBase.h
+++ b/media/libmediaextractor/include/media/stagefright/MediaBufferBase.h
@@ -18,6 +18,10 @@
#define MEDIA_BUFFER_BASE_H_
+#include <media/MediaExtractorPluginApi.h>
+#include <media/stagefright/foundation/AMessage.h>
+#include <media/NdkMediaFormatPriv.h>
+
namespace android {
class MediaBufferBase;
@@ -77,6 +81,48 @@
virtual int remoteRefcount() const = 0;
virtual ~MediaBufferBase() {};
+
+ CMediaBufferV3 *wrap() {
+ if (mWrapper) {
+ return mWrapper;
+ }
+ mWrapper = new CMediaBufferV3;
+ mWrapper->handle = this;
+
+ mWrapper->release = [](void *handle) -> void {
+ ((MediaBufferBase*)handle)->release();
+ };
+
+ mWrapper->data = [](void *handle) -> void * {
+ return ((MediaBufferBase*)handle)->data();
+ };
+
+ mWrapper->size = [](void *handle) -> size_t {
+ return ((MediaBufferBase*)handle)->size();
+ };
+
+ mWrapper->set_range = [](void *handle, size_t offset, size_t length) -> void {
+ return ((MediaBufferBase*)handle)->set_range(offset, length);
+ };
+
+ mWrapper->meta_data = [](void *handle) -> AMediaFormat* {
+ if (((MediaBufferBase*)handle)->mFormat == nullptr) {
+ sp<AMessage> msg = new AMessage();
+ ((MediaBufferBase*)handle)->mFormat = AMediaFormat_fromMsg(&msg);
+ }
+ return ((MediaBufferBase*)handle)->mFormat;
+ };
+
+ return mWrapper;
+ }
+protected:
+ MediaBufferBase() {
+ mWrapper = nullptr;
+ mFormat = nullptr;
+ }
+private:
+ CMediaBufferV3 *mWrapper;
+ AMediaFormat *mFormat;
};
} // namespace android
diff --git a/media/libmediaextractor/include/media/stagefright/MediaBufferGroup.h b/media/libmediaextractor/include/media/stagefright/MediaBufferGroup.h
index 75d5df7..dc04556 100644
--- a/media/libmediaextractor/include/media/stagefright/MediaBufferGroup.h
+++ b/media/libmediaextractor/include/media/stagefright/MediaBufferGroup.h
@@ -20,6 +20,8 @@
#include <list>
+#include <media/MediaExtractorPluginApi.h>
+#include <media/NdkMediaErrorPriv.h>
#include <media/stagefright/MediaBufferBase.h>
#include <utils/Errors.h>
#include <utils/threads.h>
@@ -57,12 +59,54 @@
// If buffer is nullptr, have acquire_buffer() check for remote release.
virtual void signalBufferReturned(MediaBufferBase *buffer);
+ CMediaBufferGroupV3 *wrap() {
+ if (mWrapper) {
+ return mWrapper;
+ }
+
+ mWrapper = new CMediaBufferGroupV3;
+ mWrapper->handle = this;
+
+ mWrapper->add_buffer = [](void *handle, size_t size) -> void {
+ MediaBufferBase *buf = MediaBufferBase::Create(size);
+ ((MediaBufferGroup*)handle)->add_buffer(buf);
+ };
+
+ mWrapper->init = [](void *handle,
+ size_t buffers, size_t buffer_size, size_t growthLimit) -> bool {
+ ((MediaBufferGroup*)handle)->init(buffers, buffer_size, growthLimit);
+ // ((MediaBufferGroup*)handle)->mWrapper->init = nullptr; // enforce call-once
+ return true;
+ };
+
+ mWrapper->acquire_buffer = [](void *handle,
+ CMediaBufferV3 **buf, bool nonBlocking, size_t requestedSize) -> media_status_t {
+ MediaBufferBase *acquiredBuf = nullptr;
+ status_t err = ((MediaBufferGroup*)handle)->acquire_buffer(
+ &acquiredBuf, nonBlocking, requestedSize);
+ if (err == OK && acquiredBuf != nullptr) {
+ *buf = acquiredBuf->wrap();
+ } else {
+ *buf = nullptr;
+ }
+ return translate_error(err);
+ };
+
+ mWrapper->has_buffers = [](void *handle) -> bool {
+ return ((MediaBufferGroup*)handle)->has_buffers();
+ };
+
+ return mWrapper;
+ }
+
private:
+ CMediaBufferGroupV3 *mWrapper;
struct InternalData;
InternalData *mInternal;
MediaBufferGroup(const MediaBufferGroup &);
MediaBufferGroup &operator=(const MediaBufferGroup &);
+ void init(size_t buffers, size_t buffer_size, size_t growthLimit);
};
} // namespace android
diff --git a/media/libmediametrics/Android.bp b/media/libmediametrics/Android.bp
index 07e124b..0a342b8 100644
--- a/media/libmediametrics/Android.bp
+++ b/media/libmediametrics/Android.bp
@@ -31,8 +31,5 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libmediaplayer2/Android.bp b/media/libmediaplayer2/Android.bp
index 2109ad1..6b43375 100644
--- a/media/libmediaplayer2/Android.bp
+++ b/media/libmediaplayer2/Android.bp
@@ -78,9 +78,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Interface.h b/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Interface.h
index 4b19e38..5e98589 100644
--- a/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Interface.h
+++ b/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Interface.h
@@ -260,11 +260,11 @@
virtual void onMessageReceived(const sp<AMessage> & /* msg */) override { }
// Modular DRM
- virtual status_t prepareDrm(const uint8_t /* uuid */[16],
+ virtual status_t prepareDrm(int64_t /*srcId*/, const uint8_t /* uuid */[16],
const Vector<uint8_t>& /* drmSessionId */) {
return INVALID_OPERATION;
}
- virtual status_t releaseDrm() {
+ virtual status_t releaseDrm(int64_t /*srcId*/) {
return INVALID_OPERATION;
}
diff --git a/media/libmediaplayer2/include/mediaplayer2/mediaplayer2.h b/media/libmediaplayer2/include/mediaplayer2/mediaplayer2.h
index 4bc1a4a..c7cd7d2 100644
--- a/media/libmediaplayer2/include/mediaplayer2/mediaplayer2.h
+++ b/media/libmediaplayer2/include/mediaplayer2/mediaplayer2.h
@@ -105,8 +105,10 @@
status_t getParameter(int key, Parcel* reply);
// Modular DRM
- status_t prepareDrm(const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId);
- status_t releaseDrm();
+ status_t prepareDrm(int64_t srcId,
+ const uint8_t uuid[16],
+ const Vector<uint8_t>& drmSessionId);
+ status_t releaseDrm(int64_t srcId);
// AudioRouting
status_t setPreferredDevice(jobject device);
jobject getRoutedDevice();
diff --git a/media/libmediaplayer2/mediaplayer2.cpp b/media/libmediaplayer2/mediaplayer2.cpp
index 921a5b7..2ae5a8c 100644
--- a/media/libmediaplayer2/mediaplayer2.cpp
+++ b/media/libmediaplayer2/mediaplayer2.cpp
@@ -1094,7 +1094,8 @@
}
// Modular DRM
-status_t MediaPlayer2::prepareDrm(const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId) {
+status_t MediaPlayer2::prepareDrm(
+ int64_t srcId, const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId) {
// TODO change to ALOGV
ALOGD("prepareDrm: uuid: %p drmSessionId: %p(%zu)", uuid,
drmSessionId.array(), drmSessionId.size());
@@ -1118,7 +1119,7 @@
}
// Passing down to mediaserver mainly for creating the crypto
- status_t status = mPlayer->prepareDrm(uuid, drmSessionId);
+ status_t status = mPlayer->prepareDrm(srcId, uuid, drmSessionId);
ALOGE_IF(status != OK, "prepareDrm: Failed at mediaserver with ret: %d", status);
// TODO change to ALOGV
@@ -1127,7 +1128,7 @@
return status;
}
-status_t MediaPlayer2::releaseDrm() {
+status_t MediaPlayer2::releaseDrm(int64_t srcId) {
Mutex::Autolock _l(mLock);
if (mPlayer == NULL) {
return NO_INIT;
@@ -1142,7 +1143,7 @@
return INVALID_OPERATION;
}
- status_t status = mPlayer->releaseDrm();
+ status_t status = mPlayer->releaseDrm(srcId);
// TODO change to ALOGV
ALOGD("releaseDrm: mediaserver::releaseDrm ret: %d", status);
if (status != OK) {
diff --git a/media/libmediaplayer2/nuplayer2/Android.bp b/media/libmediaplayer2/nuplayer2/Android.bp
index 93c218e..71cd50f 100644
--- a/media/libmediaplayer2/nuplayer2/Android.bp
+++ b/media/libmediaplayer2/nuplayer2/Android.bp
@@ -66,9 +66,6 @@
sanitize: {
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2.cpp b/media/libmediaplayer2/nuplayer2/NuPlayer2.cpp
index 6c4f0db..1561850 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2.cpp
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2.cpp
@@ -240,8 +240,7 @@
mVideoDecoderError(false),
mPaused(false),
mPausedByClient(true),
- mPausedForBuffering(false),
- mIsDrmProtected(false) {
+ mPausedForBuffering(false) {
CHECK(mediaClock != NULL);
clearFlushComplete();
}
@@ -1630,7 +1629,7 @@
case kWhatReleaseDrm:
{
- status_t status = onReleaseDrm();
+ status_t status = onReleaseDrm(msg);
sp<AMessage> response = new AMessage;
response->setInt32("status", status);
@@ -1672,7 +1671,7 @@
}
void NuPlayer2::onStart(bool play) {
- ALOGV("onStart: mCrypto: %p", mCrypto.get());
+ ALOGV("onStart: mCrypto: %p", mCurrentSourceInfo.mCrypto.get());
if (!mSourceStarted) {
mSourceStarted = true;
@@ -1716,7 +1715,7 @@
&& (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
// Modular DRM: Disabling audio offload if the source is protected
- if (mOffloadAudio && mIsDrmProtected) {
+ if (mOffloadAudio && mCurrentSourceInfo.mIsDrmProtected) {
mOffloadAudio = false;
ALOGV("onStart: Disabling mOffloadAudio now that the source is protected.");
}
@@ -2010,7 +2009,7 @@
&& (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
// Modular DRM: Disabling audio offload if the source is protected
- if (canOffload && mIsDrmProtected) {
+ if (canOffload && mCurrentSourceInfo.mIsDrmProtected) {
canOffload = false;
ALOGV("determineAudioModeChange: Disabling mOffloadAudio b/c the source is protected.");
}
@@ -2117,10 +2116,11 @@
(*decoder)->init();
// Modular DRM
- if (mIsDrmProtected) {
- format->setObject("crypto", mCrypto);
+ if (mCurrentSourceInfo.mIsDrmProtected) {
+ format->setObject("crypto", mCurrentSourceInfo.mCrypto);
ALOGV("instantiateDecoder: mCrypto: %p isSecure: %d",
- mCrypto.get(), (mCurrentSourceInfo.mSourceFlags & Source::FLAG_SECURE) != 0);
+ mCurrentSourceInfo.mCrypto.get(),
+ (mCurrentSourceInfo.mSourceFlags & Source::FLAG_SECURE) != 0);
}
(*decoder)->configure(format);
@@ -2506,12 +2506,8 @@
mRenderer.clear();
++mRendererGeneration;
- if (mCurrentSourceInfo.mSource != NULL) {
- mCurrentSourceInfo.mSource->stop();
-
- Mutex::Autolock autoLock(mSourceLock);
- mCurrentSourceInfo.mSource.clear();
- }
+ resetSourceInfo(mCurrentSourceInfo);
+ resetSourceInfo(mNextSourceInfo);
if (mDriver != NULL) {
sp<NuPlayer2Driver> driver = mDriver.promote();
@@ -2525,14 +2521,6 @@
mResetting = false;
mSourceStarted = false;
- // Modular DRM
- if (mCrypto != NULL) {
- // decoders will be flushed before this so their mCrypto would go away on their own
- // TODO change to ALOGV
- ALOGD("performReset mCrypto: %p", mCrypto.get());
- mCrypto.clear();
- }
- mIsDrmProtected = false;
}
void NuPlayer2::performPlayNextDataSource() {
@@ -2586,15 +2574,6 @@
addEndTimeMonitor();
- // Modular DRM
- if (mCrypto != NULL) {
- // decoders will be flushed before this so their mCrypto would go away on their own
- // TODO change to ALOGV
- ALOGD("performReset mCrypto: %p", mCrypto.get());
- mCrypto.clear();
- }
- mIsDrmProtected = false;
-
if (mRenderer != NULL) {
mRenderer->resume();
}
@@ -3045,8 +3024,34 @@
}
}
+NuPlayer2::SourceInfo* NuPlayer2::getSourceInfoByIdInMsg(const sp<AMessage> &msg) {
+ int64_t srcId;
+ CHECK(msg->findInt64("srcId", &srcId));
+ if (mCurrentSourceInfo.mSrcId == srcId) {
+ return &mCurrentSourceInfo;
+ } else if (mNextSourceInfo.mSrcId == srcId) {
+ return &mNextSourceInfo;
+ } else {
+ return NULL;
+ }
+}
+
+void NuPlayer2::resetSourceInfo(NuPlayer2::SourceInfo &srcInfo) {
+ if (srcInfo.mSource != NULL) {
+ srcInfo.mSource->stop();
+
+ Mutex::Autolock autoLock(mSourceLock);
+ srcInfo.mSource.clear();
+ }
+ // Modular DRM
+ ALOGD("performReset mCrypto: %p", srcInfo.mCrypto.get());
+ srcInfo.mCrypto.clear();
+ srcInfo.mIsDrmProtected = false;
+}
+
// Modular DRM begin
-status_t NuPlayer2::prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId)
+status_t NuPlayer2::prepareDrm(
+ int64_t srcId, const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId)
{
ALOGV("prepareDrm ");
@@ -3056,6 +3061,7 @@
uint8_t UUID[16];
memcpy(UUID, uuid, sizeof(UUID));
Vector<uint8_t> sessionId = drmSessionId;
+ msg->setInt64("srcId", srcId);
msg->setPointer("uuid", (void*)UUID);
msg->setPointer("drmSessionId", (void*)&sessionId);
@@ -3072,11 +3078,12 @@
return status;
}
-status_t NuPlayer2::releaseDrm()
+status_t NuPlayer2::releaseDrm(int64_t srcId)
{
ALOGV("releaseDrm ");
sp<AMessage> msg = new AMessage(kWhatReleaseDrm, this);
+ msg->setInt64("srcId", srcId);
sp<AMessage> response;
status_t status = msg->postAndAwaitResponse(&response);
@@ -3097,8 +3104,15 @@
ALOGD("onPrepareDrm ");
status_t status = INVALID_OPERATION;
- if (mCurrentSourceInfo.mSource == NULL) {
- ALOGE("onPrepareDrm: No source. onPrepareDrm failed with %d.", status);
+ SourceInfo *srcInfo = getSourceInfoByIdInMsg(msg);
+ if (srcInfo == NULL) {
+ return status;
+ }
+
+ int64_t srcId = srcInfo->mSrcId;
+ if (srcInfo->mSource == NULL) {
+ ALOGE("onPrepareDrm: srcInfo(%lld) No source. onPrepareDrm failed with %d.",
+ (long long)srcId, status);
return status;
}
@@ -3110,42 +3124,50 @@
status = OK;
sp<AMediaCryptoWrapper> crypto = NULL;
- status = mCurrentSourceInfo.mSource->prepareDrm(uuid, *drmSessionId, &crypto);
+ status = srcInfo->mSource->prepareDrm(uuid, *drmSessionId, &crypto);
if (crypto == NULL) {
- ALOGE("onPrepareDrm: mCurrentSourceInfo.mSource->prepareDrm failed. status: %d", status);
+ ALOGE("onPrepareDrm: srcInfo(%lld).mSource->prepareDrm failed. status: %d",
+ (long long)srcId, status);
return status;
}
- ALOGV("onPrepareDrm: mCurrentSourceInfo.mSource->prepareDrm succeeded");
+ ALOGV("onPrepareDrm: srcInfo(%lld).mSource->prepareDrm succeeded", (long long)srcId);
- if (mCrypto != NULL) {
- ALOGE("onPrepareDrm: Unexpected. Already having mCrypto: %p", mCrypto.get());
- mCrypto.clear();
+ if (srcInfo->mCrypto != NULL) {
+ ALOGE("onPrepareDrm: srcInfo(%lld) Unexpected. Already having mCrypto: %p",
+ (long long)srcId, srcInfo->mCrypto.get());
+ srcInfo->mCrypto.clear();
}
- mCrypto = crypto;
- mIsDrmProtected = true;
+ srcInfo->mCrypto = crypto;
+ srcInfo->mIsDrmProtected = true;
// TODO change to ALOGV
- ALOGD("onPrepareDrm: mCrypto: %p", mCrypto.get());
+ ALOGD("onPrepareDrm: mCrypto: %p", srcInfo->mCrypto.get());
return status;
}
-status_t NuPlayer2::onReleaseDrm()
+status_t NuPlayer2::onReleaseDrm(const sp<AMessage> &msg)
{
// TODO change to ALOGV
ALOGD("onReleaseDrm ");
-
- if (!mIsDrmProtected) {
- ALOGW("onReleaseDrm: Unexpected. mIsDrmProtected is already false.");
+ SourceInfo *srcInfo = getSourceInfoByIdInMsg(msg);;
+ if (srcInfo == NULL) {
+ return INVALID_OPERATION;
}
- mIsDrmProtected = false;
+ int64_t srcId = srcInfo->mSrcId;
+ if (!srcInfo->mIsDrmProtected) {
+ ALOGW("onReleaseDrm: srcInfo(%lld) Unexpected. mIsDrmProtected is already false.",
+ (long long)srcId);
+ }
+
+ srcInfo->mIsDrmProtected = false;
status_t status;
- if (mCrypto != NULL) {
+ if (srcInfo->mCrypto != NULL) {
// notifying the source first before removing crypto from codec
- if (mCurrentSourceInfo.mSource != NULL) {
- mCurrentSourceInfo.mSource->releaseDrm();
+ if (srcInfo->mSource != NULL) {
+ srcInfo->mSource->releaseDrm();
}
status=OK;
@@ -3166,9 +3188,9 @@
}
// TODO change to ALOGV
- ALOGD("onReleaseDrm: mCrypto: %p", mCrypto.get());
- mCrypto.clear();
- } else { // mCrypto == NULL
+ ALOGD("onReleaseDrm: mCrypto: %p", srcInfo->mCrypto.get());
+ srcInfo->mCrypto.clear();
+ } else { // srcInfo->mCrypto == NULL
ALOGE("onReleaseDrm: Unexpected. There is no crypto.");
status = INVALID_OPERATION;
}
@@ -3240,11 +3262,13 @@
NuPlayer2::SourceInfo & NuPlayer2::SourceInfo::operator=(const NuPlayer2::SourceInfo &other) {
mSource = other.mSource;
+ mCrypto = other.mCrypto;
mDataSourceType = (DATA_SOURCE_TYPE)other.mDataSourceType;
mSrcId = other.mSrcId;
mSourceFlags = other.mSourceFlags;
mStartTimeUs = other.mStartTimeUs;
mEndTimeUs = other.mEndTimeUs;
+ mIsDrmProtected = other.mIsDrmProtected;
return *this;
}
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2.h b/media/libmediaplayer2/nuplayer2/NuPlayer2.h
index 3ecdb01..e9b5f11 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2.h
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2.h
@@ -92,8 +92,8 @@
float getFrameRate();
// Modular DRM
- status_t prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId);
- status_t releaseDrm();
+ status_t prepareDrm(int64_t srcId, const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId);
+ status_t releaseDrm(int64_t srcId);
const char *getDataSourceType();
@@ -178,6 +178,9 @@
uint32_t mSourceFlags;
int64_t mStartTimeUs;
int64_t mEndTimeUs;
+ // Modular DRM
+ sp<AMediaCryptoWrapper> mCrypto;
+ bool mIsDrmProtected = false;
};
wp<NuPlayer2Driver> mDriver;
@@ -269,10 +272,6 @@
// Pause state as requested by source (internally) due to buffering
bool mPausedForBuffering;
- // Modular DRM
- sp<AMediaCryptoWrapper> mCrypto;
- bool mIsDrmProtected;
-
inline const sp<DecoderBase> &getDecoder(bool audio) {
return audio ? mAudioDecoder : mVideoDecoder;
}
@@ -351,7 +350,10 @@
void writeTrackInfo(PlayerMessage* reply, const sp<AMessage>& format) const;
status_t onPrepareDrm(const sp<AMessage> &msg);
- status_t onReleaseDrm();
+ status_t onReleaseDrm(const sp<AMessage> &msg);
+
+ SourceInfo* getSourceInfoByIdInMsg(const sp<AMessage> &msg);
+ void resetSourceInfo(SourceInfo &srcInfo);
DISALLOW_EVIL_CONSTRUCTORS(NuPlayer2);
};
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
index 821dc9f..eff8866 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
@@ -976,24 +976,25 @@
}
// Modular DRM
-status_t NuPlayer2Driver::prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId)
+status_t NuPlayer2Driver::prepareDrm(
+ int64_t srcId, const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId)
{
ALOGV("prepareDrm(%p) state: %d", this, mState);
// leaving the state verification for mediaplayer.cpp
- status_t ret = mPlayer->prepareDrm(uuid, drmSessionId);
+ status_t ret = mPlayer->prepareDrm(srcId, uuid, drmSessionId);
ALOGV("prepareDrm ret: %d", ret);
return ret;
}
-status_t NuPlayer2Driver::releaseDrm()
+status_t NuPlayer2Driver::releaseDrm(int64_t srcId)
{
ALOGV("releaseDrm(%p) state: %d", this, mState);
// leaving the state verification for mediaplayer.cpp
- status_t ret = mPlayer->releaseDrm();
+ status_t ret = mPlayer->releaseDrm(srcId);
ALOGV("releaseDrm ret: %d", ret);
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.h b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.h
index 50ee173..bb30c76 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.h
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.h
@@ -82,8 +82,9 @@
void notifyFlagsChanged(int64_t srcId, uint32_t flags);
// Modular DRM
- virtual status_t prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId);
- virtual status_t releaseDrm();
+ virtual status_t prepareDrm(
+ int64_t srcId, const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId);
+ virtual status_t releaseDrm(int64_t srcId);
protected:
virtual ~NuPlayer2Driver();
diff --git a/media/libmediaplayerservice/Android.bp b/media/libmediaplayerservice/Android.bp
index 09b19d7..51879fd 100644
--- a/media/libmediaplayerservice/Android.bp
+++ b/media/libmediaplayerservice/Android.bp
@@ -68,9 +68,6 @@
sanitize: {
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libmediaplayerservice/nuplayer/Android.bp b/media/libmediaplayerservice/nuplayer/Android.bp
index a4da564..23a19e7 100644
--- a/media/libmediaplayerservice/nuplayer/Android.bp
+++ b/media/libmediaplayerservice/nuplayer/Android.bp
@@ -56,9 +56,6 @@
sanitize: {
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/Android.bp b/media/libstagefright/Android.bp
index cc5b7da..163cd99 100644
--- a/media/libstagefright/Android.bp
+++ b/media/libstagefright/Android.bp
@@ -18,9 +18,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: ["libmedia"],
@@ -40,9 +37,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: ["libmedia", "libmediandk"],
@@ -80,9 +74,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
@@ -234,9 +225,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
@@ -291,9 +279,6 @@
"unsigned-integer-overflow",
"signed-integer-overflow",
],
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/MediaExtractor.cpp b/media/libstagefright/MediaExtractor.cpp
index ac9eb0b..ea818ff 100644
--- a/media/libstagefright/MediaExtractor.cpp
+++ b/media/libstagefright/MediaExtractor.cpp
@@ -134,4 +134,57 @@
return plugin->setMediaCas(plugin->data, casToken, size);
}
+// --------------------------------------------------------------------------------
+MediaExtractorCUnwrapperV3::MediaExtractorCUnwrapperV3(CMediaExtractorV3 *plugin) {
+ this->plugin = plugin;
+}
+
+MediaExtractorCUnwrapperV3::~MediaExtractorCUnwrapperV3() {
+ plugin->free(plugin->data);
+ free(plugin);
+}
+
+size_t MediaExtractorCUnwrapperV3::countTracks() {
+ return plugin->countTracks(plugin->data);
+}
+
+MediaTrack *MediaExtractorCUnwrapperV3::getTrack(size_t index) {
+ return new MediaTrackCUnwrapperV3(plugin->getTrack(plugin->data, index));
+}
+
+status_t MediaExtractorCUnwrapperV3::getTrackMetaData(
+ MetaDataBase& meta, size_t index, uint32_t flags) {
+ sp<AMessage> msg = new AMessage();
+ AMediaFormat *format = AMediaFormat_fromMsg(&msg);
+ media_status_t ret = plugin->getTrackMetaData(plugin->data, format, index, flags);
+ sp<MetaData> newMeta = new MetaData();
+ convertMessageToMetaData(msg, newMeta);
+ delete format;
+ meta = *newMeta;
+ return reverse_translate_error(ret);
+}
+
+status_t MediaExtractorCUnwrapperV3::getMetaData(MetaDataBase& meta) {
+ sp<AMessage> msg = new AMessage();
+ AMediaFormat *format = AMediaFormat_fromMsg(&msg);
+ media_status_t ret = plugin->getMetaData(plugin->data, format);
+ sp<MetaData> newMeta = new MetaData();
+ convertMessageToMetaData(msg, newMeta);
+ delete format;
+ meta = *newMeta;
+ return reverse_translate_error(ret);
+}
+
+const char * MediaExtractorCUnwrapperV3::name() {
+ return plugin->name(plugin->data);
+}
+
+uint32_t MediaExtractorCUnwrapperV3::flags() const {
+ return plugin->flags(plugin->data);
+}
+
+status_t MediaExtractorCUnwrapperV3::setMediaCas(const uint8_t* casToken, size_t size) {
+ return plugin->setMediaCas(plugin->data, casToken, size);
+}
+
} // namespace android
diff --git a/media/libstagefright/MediaExtractorFactory.cpp b/media/libstagefright/MediaExtractorFactory.cpp
index 318c1eb..1f8ccb3 100644
--- a/media/libstagefright/MediaExtractorFactory.cpp
+++ b/media/libstagefright/MediaExtractorFactory.cpp
@@ -100,6 +100,12 @@
freeMeta(meta);
}
ex = ret != nullptr ? new MediaExtractorCUnwrapperV2(ret) : nullptr;
+ } else if (creatorVersion == 3) {
+ CMediaExtractorV3 *ret = ((CreatorFuncV3)creator)(source->wrap(), meta);
+ if (meta != nullptr && freeMeta != nullptr) {
+ freeMeta(meta);
+ }
+ ex = ret != nullptr ? new MediaExtractorCUnwrapperV3(ret) : nullptr;
}
ALOGV("Created an extractor '%s' with confidence %.2f",
@@ -170,6 +176,9 @@
} else if ((*it)->def.def_version == 2) {
curCreator = (void*) (*it)->def.sniff.v2(
source->wrap(), &newConfidence, &newMeta, &newFreeMeta);
+ } else if ((*it)->def.def_version == 3) {
+ curCreator = (void*) (*it)->def.sniff.v3(
+ source->wrap(), &newConfidence, &newMeta, &newFreeMeta);
}
if (curCreator) {
@@ -199,7 +208,7 @@
std::list<sp<ExtractorPlugin>> &pluginList) {
// sanity check check struct version, uuid, name
if (plugin->def.def_version == 0
- || plugin->def.def_version > EXTRACTORDEF_VERSION_CURRENT) {
+ || plugin->def.def_version > EXTRACTORDEF_VERSION_CURRENT + 1) {
ALOGE("don't understand extractor format %u, ignoring.", plugin->def.def_version);
return;
}
diff --git a/media/libstagefright/MediaTrack.cpp b/media/libstagefright/MediaTrack.cpp
index 821605d..daed5a0 100644
--- a/media/libstagefright/MediaTrack.cpp
+++ b/media/libstagefright/MediaTrack.cpp
@@ -155,4 +155,76 @@
return wrapper->supportsNonBlockingRead(wrapper->data);
}
+/* -------------- unwrapper v3 --------------- */
+
+MediaTrackCUnwrapperV3::MediaTrackCUnwrapperV3(CMediaTrackV3 *cmediatrack3) {
+ wrapper = cmediatrack3;
+ bufferGroup = nullptr;
+}
+
+MediaTrackCUnwrapperV3::~MediaTrackCUnwrapperV3() {
+ wrapper->free(wrapper->data);
+ free(wrapper);
+}
+
+status_t MediaTrackCUnwrapperV3::start() {
+ if (bufferGroup == nullptr) {
+ bufferGroup = new MediaBufferGroup();
+ }
+ return reverse_translate_error(wrapper->start(wrapper->data, bufferGroup->wrap()));
+}
+
+status_t MediaTrackCUnwrapperV3::stop() {
+ return reverse_translate_error(wrapper->stop(wrapper->data));
+}
+
+status_t MediaTrackCUnwrapperV3::getFormat(MetaDataBase& format) {
+ sp<AMessage> msg = new AMessage();
+ AMediaFormat *tmpFormat = AMediaFormat_fromMsg(&msg);
+ media_status_t ret = wrapper->getFormat(wrapper->data, tmpFormat);
+ sp<MetaData> newMeta = new MetaData();
+ convertMessageToMetaData(msg, newMeta);
+ delete tmpFormat;
+ format = *newMeta;
+ return reverse_translate_error(ret);
+}
+
+status_t MediaTrackCUnwrapperV3::read(MediaBufferBase **buffer, const ReadOptions *options) {
+
+ uint32_t opts = 0;
+
+ if (options && options->getNonBlocking()) {
+ opts |= CMediaTrackReadOptions::NONBLOCKING;
+ }
+
+ int64_t seekPosition = 0;
+ MediaTrack::ReadOptions::SeekMode seekMode;
+ if (options && options->getSeekTo(&seekPosition, &seekMode)) {
+ opts |= SEEK;
+ opts |= (uint32_t) seekMode;
+ }
+ CMediaBufferV3 *buf = nullptr;
+ media_status_t ret = wrapper->read(wrapper->data, &buf, opts, seekPosition);
+ if (ret == AMEDIA_OK && buf != nullptr) {
+ *buffer = (MediaBufferBase*)buf->handle;
+ MetaDataBase &meta = (*buffer)->meta_data();
+ AMediaFormat *format = buf->meta_data(buf->handle);
+ // only convert the keys we're actually expecting, as doing
+ // the full convertMessageToMetadata() for every buffer is
+ // too expensive
+ int64_t val;
+ if (format->mFormat->findInt64("timeUs", &val)) {
+ meta.setInt64(kKeyTime, val);
+ }
+ } else {
+ *buffer = nullptr;
+ }
+
+ return reverse_translate_error(ret);
+}
+
+bool MediaTrackCUnwrapperV3::supportNonblockingRead() {
+ return wrapper->supportsNonBlockingRead(wrapper->data);
+}
+
} // namespace android
diff --git a/media/libstagefright/Utils.cpp b/media/libstagefright/Utils.cpp
index 53c32b2..df929ae 100644
--- a/media/libstagefright/Utils.cpp
+++ b/media/libstagefright/Utils.cpp
@@ -588,10 +588,17 @@
}
};
+static std::vector<std::pair<const char *, uint32_t>> floatMappings {
+ {
+ { "capture-rate", kKeyCaptureFramerate },
+ }
+};
+
static std::vector<std::pair<const char *, uint32_t>> int64Mappings {
{
{ "exif-offset", kKeyExifOffset },
{ "exif-size", kKeyExifSize },
+ { "thumbnail-time", kKeyThumbnailTime },
}
};
@@ -632,6 +639,13 @@
}
}
+ for (auto elem : floatMappings) {
+ float value;
+ if (msg->findFloat(elem.first, &value)) {
+ meta->setFloat(elem.second, value);
+ }
+ }
+
for (auto elem : int64Mappings) {
int64_t value;
if (msg->findInt64(elem.first, &value)) {
@@ -663,6 +677,13 @@
}
}
+ for (auto elem : floatMappings) {
+ float value;
+ if (meta->findFloat(elem.second, &value)) {
+ format->setFloat(elem.first, value);
+ }
+ }
+
for (auto elem : int64Mappings) {
int64_t value;
if (meta->findInt64(elem.second, &value)) {
diff --git a/media/libstagefright/bqhelper/Android.bp b/media/libstagefright/bqhelper/Android.bp
index c647f5f..81777f1 100644
--- a/media/libstagefright/bqhelper/Android.bp
+++ b/media/libstagefright/bqhelper/Android.bp
@@ -61,8 +61,5 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/codecs/aacdec/Android.bp b/media/libstagefright/codecs/aacdec/Android.bp
index 7352854..25628a2 100644
--- a/media/libstagefright/codecs/aacdec/Android.bp
+++ b/media/libstagefright/codecs/aacdec/Android.bp
@@ -25,9 +25,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
static_libs: ["libFraunhoferAAC"],
diff --git a/media/libstagefright/codecs/aacenc/Android.bp b/media/libstagefright/codecs/aacenc/Android.bp
index 9342351..ec1151b 100644
--- a/media/libstagefright/codecs/aacenc/Android.bp
+++ b/media/libstagefright/codecs/aacenc/Android.bp
@@ -22,9 +22,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
static_libs: ["libFraunhoferAAC"],
diff --git a/media/libstagefright/codecs/amrwbenc/Android.bp b/media/libstagefright/codecs/amrwbenc/Android.bp
index ebe08c6..b9d45c1 100644
--- a/media/libstagefright/codecs/amrwbenc/Android.bp
+++ b/media/libstagefright/codecs/amrwbenc/Android.bp
@@ -134,9 +134,6 @@
cflags: ["-Werror"],
sanitize: {
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -166,9 +163,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
static_libs: ["libstagefright_amrwbenc"],
diff --git a/media/libstagefright/codecs/amrwbenc/SampleCode/Android.bp b/media/libstagefright/codecs/amrwbenc/SampleCode/Android.bp
index 81b3f69..95f9494 100644
--- a/media/libstagefright/codecs/amrwbenc/SampleCode/Android.bp
+++ b/media/libstagefright/codecs/amrwbenc/SampleCode/Android.bp
@@ -23,8 +23,5 @@
sanitize: {
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/codecs/avcdec/Android.bp b/media/libstagefright/codecs/avcdec/Android.bp
index cf50a04..8a34845 100644
--- a/media/libstagefright/codecs/avcdec/Android.bp
+++ b/media/libstagefright/codecs/avcdec/Android.bp
@@ -34,9 +34,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
ldflags: ["-Wl,-Bsymbolic"],
diff --git a/media/libstagefright/codecs/avcenc/Android.bp b/media/libstagefright/codecs/avcenc/Android.bp
index cefe77c..6371828 100644
--- a/media/libstagefright/codecs/avcenc/Android.bp
+++ b/media/libstagefright/codecs/avcenc/Android.bp
@@ -28,9 +28,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
cflags: [
diff --git a/media/libstagefright/codecs/flac/dec/Android.bp b/media/libstagefright/codecs/flac/dec/Android.bp
index 9af086b..1674cb2 100644
--- a/media/libstagefright/codecs/flac/dec/Android.bp
+++ b/media/libstagefright/codecs/flac/dec/Android.bp
@@ -26,9 +26,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: [
diff --git a/media/libstagefright/codecs/flac/enc/Android.bp b/media/libstagefright/codecs/flac/enc/Android.bp
index 73f0dac..9b696da 100644
--- a/media/libstagefright/codecs/flac/enc/Android.bp
+++ b/media/libstagefright/codecs/flac/enc/Android.bp
@@ -18,9 +18,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: [
diff --git a/media/libstagefright/codecs/g711/dec/Android.bp b/media/libstagefright/codecs/g711/dec/Android.bp
index 3d97d8c..7097688 100644
--- a/media/libstagefright/codecs/g711/dec/Android.bp
+++ b/media/libstagefright/codecs/g711/dec/Android.bp
@@ -29,9 +29,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
compile_multilib: "32",
}
diff --git a/media/libstagefright/codecs/gsm/dec/Android.bp b/media/libstagefright/codecs/gsm/dec/Android.bp
index 1c3208b..a973f70 100644
--- a/media/libstagefright/codecs/gsm/dec/Android.bp
+++ b/media/libstagefright/codecs/gsm/dec/Android.bp
@@ -23,9 +23,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: [
diff --git a/media/libstagefright/codecs/hevcdec/Android.bp b/media/libstagefright/codecs/hevcdec/Android.bp
index 45920e6..60fc446 100644
--- a/media/libstagefright/codecs/hevcdec/Android.bp
+++ b/media/libstagefright/codecs/hevcdec/Android.bp
@@ -28,9 +28,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: [
diff --git a/media/libstagefright/codecs/m4v_h263/dec/Android.bp b/media/libstagefright/codecs/m4v_h263/dec/Android.bp
index ca70cc2..41141b1 100644
--- a/media/libstagefright/codecs/m4v_h263/dec/Android.bp
+++ b/media/libstagefright/codecs/m4v_h263/dec/Android.bp
@@ -60,9 +60,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -106,9 +103,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
compile_multilib: "32",
}
diff --git a/media/libstagefright/codecs/m4v_h263/enc/Android.bp b/media/libstagefright/codecs/m4v_h263/enc/Android.bp
index 6be4036..d4f7d50 100644
--- a/media/libstagefright/codecs/m4v_h263/enc/Android.bp
+++ b/media/libstagefright/codecs/m4v_h263/enc/Android.bp
@@ -44,9 +44,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -92,9 +89,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
compile_multilib: "32",
}
@@ -122,9 +116,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
static_libs: ["libstagefright_m4vh263enc"],
diff --git a/media/libstagefright/codecs/m4v_h263/enc/SoftMPEG4Encoder.h b/media/libstagefright/codecs/m4v_h263/enc/SoftMPEG4Encoder.h
index 00f2dd3..71e1170 100644
--- a/media/libstagefright/codecs/m4v_h263/enc/SoftMPEG4Encoder.h
+++ b/media/libstagefright/codecs/m4v_h263/enc/SoftMPEG4Encoder.h
@@ -17,7 +17,6 @@
#ifndef SOFT_MPEG4_ENCODER_H_
#define SOFT_MPEG4_ENCODER_H_
-#include <media/stagefright/MediaBuffer.h>
#include <media/stagefright/foundation/ABase.h>
#include <media/stagefright/omx/SoftVideoEncoderOMXComponent.h>
#include "mp4enc_api.h"
diff --git a/media/libstagefright/codecs/mp3dec/Android.bp b/media/libstagefright/codecs/mp3dec/Android.bp
index 9fa9a4c..2154f84 100644
--- a/media/libstagefright/codecs/mp3dec/Android.bp
+++ b/media/libstagefright/codecs/mp3dec/Android.bp
@@ -59,9 +59,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
include_dirs: ["frameworks/av/media/libstagefright/include"],
@@ -106,9 +103,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: [
@@ -144,9 +138,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
static_libs: [
diff --git a/media/libstagefright/codecs/mpeg2dec/Android.bp b/media/libstagefright/codecs/mpeg2dec/Android.bp
index cd83db0..c655544 100644
--- a/media/libstagefright/codecs/mpeg2dec/Android.bp
+++ b/media/libstagefright/codecs/mpeg2dec/Android.bp
@@ -34,9 +34,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
compile_multilib: "32",
}
diff --git a/media/libstagefright/codecs/on2/dec/Android.bp b/media/libstagefright/codecs/on2/dec/Android.bp
index 8a9399a..174f183 100644
--- a/media/libstagefright/codecs/on2/dec/Android.bp
+++ b/media/libstagefright/codecs/on2/dec/Android.bp
@@ -31,9 +31,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
compile_multilib: "32",
}
diff --git a/media/libstagefright/codecs/on2/enc/Android.bp b/media/libstagefright/codecs/on2/enc/Android.bp
index 3d9feeb..891a771 100644
--- a/media/libstagefright/codecs/on2/enc/Android.bp
+++ b/media/libstagefright/codecs/on2/enc/Android.bp
@@ -26,9 +26,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
static_libs: ["libvpx"],
diff --git a/media/libstagefright/codecs/opus/dec/Android.bp b/media/libstagefright/codecs/opus/dec/Android.bp
index 43318f2..afe459d 100644
--- a/media/libstagefright/codecs/opus/dec/Android.bp
+++ b/media/libstagefright/codecs/opus/dec/Android.bp
@@ -30,9 +30,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
compile_multilib: "32",
}
diff --git a/media/libstagefright/codecs/raw/Android.bp b/media/libstagefright/codecs/raw/Android.bp
index c8d7d00..f822445 100644
--- a/media/libstagefright/codecs/raw/Android.bp
+++ b/media/libstagefright/codecs/raw/Android.bp
@@ -22,9 +22,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: [
diff --git a/media/libstagefright/colorconversion/Android.bp b/media/libstagefright/colorconversion/Android.bp
index 16e9ded..ba57497 100644
--- a/media/libstagefright/colorconversion/Android.bp
+++ b/media/libstagefright/colorconversion/Android.bp
@@ -24,8 +24,5 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/filters/Android.bp b/media/libstagefright/filters/Android.bp
index e944224..7a67e55 100644
--- a/media/libstagefright/filters/Android.bp
+++ b/media/libstagefright/filters/Android.bp
@@ -31,8 +31,5 @@
sanitize: {
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/flac/dec/Android.bp b/media/libstagefright/flac/dec/Android.bp
index 8d486cf..6bfab16 100644
--- a/media/libstagefright/flac/dec/Android.bp
+++ b/media/libstagefright/flac/dec/Android.bp
@@ -24,9 +24,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
static: {
diff --git a/media/libstagefright/foundation/Android.bp b/media/libstagefright/foundation/Android.bp
index 861528e..dcf1ab8 100644
--- a/media/libstagefright/foundation/Android.bp
+++ b/media/libstagefright/foundation/Android.bp
@@ -79,8 +79,5 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/http/Android.bp b/media/libstagefright/http/Android.bp
index 2e49fc4..8655caf 100644
--- a/media/libstagefright/http/Android.bp
+++ b/media/libstagefright/http/Android.bp
@@ -29,9 +29,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
product_variables: {
diff --git a/media/libstagefright/httplive/Android.bp b/media/libstagefright/httplive/Android.bp
index 2907751..78d410a 100644
--- a/media/libstagefright/httplive/Android.bp
+++ b/media/libstagefright/httplive/Android.bp
@@ -25,9 +25,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: [
diff --git a/media/libstagefright/id3/Android.bp b/media/libstagefright/id3/Android.bp
index b42c053..7151d07 100644
--- a/media/libstagefright/id3/Android.bp
+++ b/media/libstagefright/id3/Android.bp
@@ -16,9 +16,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -47,9 +44,6 @@
sanitize: {
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/include/media/stagefright/MediaExtractor.h b/media/libstagefright/include/media/stagefright/MediaExtractor.h
index 71343d5..6f3e57e 100644
--- a/media/libstagefright/include/media/stagefright/MediaExtractor.h
+++ b/media/libstagefright/include/media/stagefright/MediaExtractor.h
@@ -135,6 +135,22 @@
CMediaExtractorV2 *plugin;
};
+class MediaExtractorCUnwrapperV3 : public MediaExtractorCUnwrapper {
+public:
+ explicit MediaExtractorCUnwrapperV3(CMediaExtractorV3 *plugin);
+ virtual size_t countTracks();
+ virtual MediaTrack *getTrack(size_t index);
+ virtual status_t getTrackMetaData(MetaDataBase& meta, size_t index, uint32_t flags = 0);
+ virtual status_t getMetaData(MetaDataBase& meta);
+ virtual const char * name();
+ virtual uint32_t flags() const;
+ virtual status_t setMediaCas(const uint8_t* casToken, size_t size);
+protected:
+ virtual ~MediaExtractorCUnwrapperV3();
+private:
+ CMediaExtractorV3 *plugin;
+};
+
} // namespace android
#endif // MEDIA_EXTRACTOR_H_
diff --git a/media/libstagefright/mpeg2ts/Android.bp b/media/libstagefright/mpeg2ts/Android.bp
index 7e00eb8..e516cf1 100644
--- a/media/libstagefright/mpeg2ts/Android.bp
+++ b/media/libstagefright/mpeg2ts/Android.bp
@@ -25,9 +25,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
shared_libs: [
diff --git a/media/libstagefright/omx/Android.bp b/media/libstagefright/omx/Android.bp
index 6250045..8a76de3 100644
--- a/media/libstagefright/omx/Android.bp
+++ b/media/libstagefright/omx/Android.bp
@@ -79,9 +79,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -115,9 +112,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
cflags: ["-Wall", "-Werror"],
}
diff --git a/media/libstagefright/rtsp/Android.bp b/media/libstagefright/rtsp/Android.bp
index d1767d3..9bc9c89 100644
--- a/media/libstagefright/rtsp/Android.bp
+++ b/media/libstagefright/rtsp/Android.bp
@@ -46,9 +46,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
@@ -104,8 +101,5 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/libstagefright/timedtext/Android.bp b/media/libstagefright/timedtext/Android.bp
index 7c51333..97e1ec6 100644
--- a/media/libstagefright/timedtext/Android.bp
+++ b/media/libstagefright/timedtext/Android.bp
@@ -14,9 +14,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
include_dirs: [
diff --git a/media/libstagefright/webm/Android.bp b/media/libstagefright/webm/Android.bp
index 97e1452..64ecc2d 100644
--- a/media/libstagefright/webm/Android.bp
+++ b/media/libstagefright/webm/Android.bp
@@ -14,9 +14,6 @@
"unsigned-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
srcs: [
diff --git a/media/libstagefright/xmlparser/Android.bp b/media/libstagefright/xmlparser/Android.bp
index 5737ac2..b55dbb0 100644
--- a/media/libstagefright/xmlparser/Android.bp
+++ b/media/libstagefright/xmlparser/Android.bp
@@ -36,9 +36,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/mtp/MtpDataPacket.cpp b/media/mtp/MtpDataPacket.cpp
index 992dc9a..5dbcd08 100644
--- a/media/mtp/MtpDataPacket.cpp
+++ b/media/mtp/MtpDataPacket.cpp
@@ -561,7 +561,7 @@
return processedBytes == mPacketSize ? processedBytes : -1;
}
-int MtpDataPacket::write(struct usb_request *request,
+int64_t MtpDataPacket::write(struct usb_request *request,
UrbPacketDivisionMode divisionMode,
int fd,
size_t payloadSize) {
diff --git a/media/mtp/MtpDataPacket.h b/media/mtp/MtpDataPacket.h
index 1ddb821..138f7b0 100644
--- a/media/mtp/MtpDataPacket.h
+++ b/media/mtp/MtpDataPacket.h
@@ -117,7 +117,8 @@
int write(struct usb_request *request, UrbPacketDivisionMode divisionMode);
// Similar to previous write method but it reads the payload from |fd|. If |size| is larger than
// MTP_BUFFER_SIZE, the data will be sent by multiple bulk transfer requests.
- int write(struct usb_request *request, UrbPacketDivisionMode divisionMode,
+ // Return type (int64_t) is used to handle the case that the size can be larger than 2GB.
+ int64_t write(struct usb_request *request, UrbPacketDivisionMode divisionMode,
int fd, size_t size);
#endif
diff --git a/media/mtp/MtpDevice.cpp b/media/mtp/MtpDevice.cpp
index 993797a..9665c58 100644
--- a/media/mtp/MtpDevice.cpp
+++ b/media/mtp/MtpDevice.cpp
@@ -516,7 +516,7 @@
return (MtpObjectHandle)-1;
}
-bool MtpDevice::sendObject(MtpObjectHandle handle, int size, int srcFD) {
+bool MtpDevice::sendObject(MtpObjectHandle handle, uint32_t size, int srcFD) {
std::lock_guard<std::mutex> lg(mMutex);
if (mLastSendObjectInfoTransactionID + 1 != mTransactionID ||
@@ -529,7 +529,7 @@
if (sendRequest(MTP_OPERATION_SEND_OBJECT)) {
mData.setOperationCode(mRequest.getOperationCode());
mData.setTransactionID(mRequest.getTransactionID());
- const int writeResult = mData.write(mRequestOut, mPacketDivisionMode, srcFD, size);
+ const int64_t writeResult = mData.write(mRequestOut, mPacketDivisionMode, srcFD, size);
const MtpResponseCode ret = readResponse();
return ret == MTP_RESPONSE_OK && writeResult > 0;
}
diff --git a/media/mtp/MtpDevice.h b/media/mtp/MtpDevice.h
index 8cf9e5e..01bc3db 100644
--- a/media/mtp/MtpDevice.h
+++ b/media/mtp/MtpDevice.h
@@ -104,7 +104,7 @@
MtpObjectInfo* getObjectInfo(MtpObjectHandle handle);
void* getThumbnail(MtpObjectHandle handle, int& outLength);
MtpObjectHandle sendObjectInfo(MtpObjectInfo* info);
- bool sendObject(MtpObjectHandle handle, int size, int srcFD);
+ bool sendObject(MtpObjectHandle handle, uint32_t size, int srcFD);
bool deleteObject(MtpObjectHandle handle);
MtpObjectHandle getParent(MtpObjectHandle handle);
MtpStorageID getStorageID(MtpObjectHandle handle);
diff --git a/media/ndk/Android.bp b/media/ndk/Android.bp
index 541ba3e..8267ba5 100644
--- a/media/ndk/Android.bp
+++ b/media/ndk/Android.bp
@@ -149,9 +149,6 @@
"signed-integer-overflow",
],
cfi: true,
- diag: {
- cfi: true,
- },
},
}
diff --git a/media/ndk/NdkMediaFormat.cpp b/media/ndk/NdkMediaFormat.cpp
index bf9725c..bc140bf 100644
--- a/media/ndk/NdkMediaFormat.cpp
+++ b/media/ndk/NdkMediaFormat.cpp
@@ -327,6 +327,7 @@
EXPORT const char* AMEDIAFORMAT_KEY_IS_AUTOSELECT = "is-autoselect";
EXPORT const char* AMEDIAFORMAT_KEY_IS_DEFAULT = "is-default";
EXPORT const char* AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE = "is-forced-subtitle";
+EXPORT const char* AMEDIAFORMAT_KEY_IS_SYNC_FRAME = "is-sync-frame";
EXPORT const char* AMEDIAFORMAT_KEY_I_FRAME_INTERVAL = "i-frame-interval";
EXPORT const char* AMEDIAFORMAT_KEY_LANGUAGE = "language";
EXPORT const char* AMEDIAFORMAT_KEY_LATENCY = "latency";
diff --git a/media/ndk/include/media/NdkMediaFormat.h b/media/ndk/include/media/NdkMediaFormat.h
index 658cbac..4be1928 100644
--- a/media/ndk/include/media/NdkMediaFormat.h
+++ b/media/ndk/include/media/NdkMediaFormat.h
@@ -209,6 +209,7 @@
extern const char* AMEDIAFORMAT_KEY_GENRE __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_HDR_STATIC_INFO __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_ICC_PROFILE __INTRODUCED_IN(29);
+extern const char* AMEDIAFORMAT_KEY_IS_SYNC_FRAME __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_LOCATION __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_LOOP __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_LYRICIST __INTRODUCED_IN(29);
diff --git a/packages/MediaComponents/apex/java/android/media/session/MediaController.java b/packages/MediaComponents/apex/java/android/media/session/MediaController.java
index a8e77c7..60f74ab 100644
--- a/packages/MediaComponents/apex/java/android/media/session/MediaController.java
+++ b/packages/MediaComponents/apex/java/android/media/session/MediaController.java
@@ -149,12 +149,9 @@
if (keyEvent == null) {
throw new IllegalArgumentException("KeyEvent may not be null");
}
- //TODO(b/119789707): Resolve hidden API usage: KeyEvent#isMediaKey
- /*
- if (!KeyEvent.isMediaKey(keyEvent.getKeyCode())) {
+ if (!KeyEvent.isMediaSessionKey(keyEvent.getKeyCode())) {
return false;
}
- */
try {
//TODO(b/119748678): Resolve mContext.getOpPackageName() through this file.
// Temporarilly it's replaced with "mContext.getOpPackageName()" for compiling.
diff --git a/packages/MediaComponents/apex/java/android/media/session/MediaSession.java b/packages/MediaComponents/apex/java/android/media/session/MediaSession.java
index b40e3b0..e3cc1ba 100644
--- a/packages/MediaComponents/apex/java/android/media/session/MediaSession.java
+++ b/packages/MediaComponents/apex/java/android/media/session/MediaSession.java
@@ -179,9 +179,7 @@
MediaSessionManager manager = (MediaSessionManager) context
.getSystemService(Context.MEDIA_SESSION_SERVICE);
try {
- //TODO(b/119749862): Resolve hidden API usage. MediaSessioManager#createSession
- //mBinder = manager.createSession(mCbStub, tag, userId);
- mBinder = null; //TODO: remove this.
+ mBinder = manager.createSession(mCbStub, tag, userId);
mSessionToken = new Token(mBinder.getController());
mController = new MediaController(context, mSessionToken);
} catch (RemoteException e) {
@@ -1072,12 +1070,8 @@
private static RemoteUserInfo createRemoteUserInfo(String packageName, int pid, int uid,
ISessionControllerCallback caller) {
- //TODO(b/119752205): Resolve hidden API usage. 4-param constructor of RemoteUserInfo
- /*
return new RemoteUserInfo(packageName, pid, uid,
caller != null ? caller.asBinder() : null);
- */
- return new RemoteUserInfo(packageName, pid, uid);
}
@Override
diff --git a/packages/MediaComponents/apex/java/android/service/media/MediaBrowserService.java b/packages/MediaComponents/apex/java/android/service/media/MediaBrowserService.java
index 2f2fbaf..fa7696e 100644
--- a/packages/MediaComponents/apex/java/android/service/media/MediaBrowserService.java
+++ b/packages/MediaComponents/apex/java/android/service/media/MediaBrowserService.java
@@ -544,12 +544,8 @@
throw new IllegalStateException("This should be called inside of onGetRoot or"
+ " onLoadChildren or onLoadItem methods");
}
- //TODO(b/119752205): Resolve hidden API usage. 4-param constructor of RemoteUserInfo
- /*
return new RemoteUserInfo(mCurConnection.pkg, mCurConnection.pid, mCurConnection.uid,
mCurConnection.callbacks.asBinder());
- */
- return new RemoteUserInfo(mCurConnection.pkg, mCurConnection.pid, mCurConnection.uid);
}
/**
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 45d3a06..27aec9e 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -9146,7 +9146,13 @@
status_t AudioFlinger::MmapCaptureThread::exitStandby()
{
- mInput->stream->setGain(1.0f);
+ {
+ // mInput might have been cleared by clearInput()
+ Mutex::Autolock _l(mLock);
+ if (mInput != nullptr && mInput->stream != nullptr) {
+ mInput->stream->setGain(1.0f);
+ }
+ }
return MmapThread::exitStandby();
}
diff --git a/services/audiopolicy/common/managerdefinitions/include/DeviceDescriptor.h b/services/audiopolicy/common/managerdefinitions/include/DeviceDescriptor.h
index 83fb10c..6f99bf3 100644
--- a/services/audiopolicy/common/managerdefinitions/include/DeviceDescriptor.h
+++ b/services/audiopolicy/common/managerdefinitions/include/DeviceDescriptor.h
@@ -31,6 +31,8 @@
public:
// Note that empty name refers by convention to a generic device.
explicit DeviceDescriptor(audio_devices_t type, const String8 &tagName = String8(""));
+ DeviceDescriptor(audio_devices_t type, const FormatVector &encodedFormats,
+ const String8 &tagName = String8(""));
virtual ~DeviceDescriptor() {}
@@ -38,6 +40,8 @@
audio_devices_t type() const { return mDeviceType; }
+ const FormatVector& encodedFormats() const { return mEncodedFormats; }
+
bool equals(const sp<DeviceDescriptor>& other) const;
// AudioPortConfig
@@ -59,6 +63,7 @@
private:
String8 mTagName; // Unique human readable identifier for a device port found in conf file.
audio_devices_t mDeviceType;
+ FormatVector mEncodedFormats;
audio_port_handle_t mId;
friend class DeviceVector;
diff --git a/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
index a9f7220..9e5f944 100644
--- a/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
@@ -26,14 +26,25 @@
namespace android {
DeviceDescriptor::DeviceDescriptor(audio_devices_t type, const String8 &tagName) :
+ DeviceDescriptor(type, FormatVector{}, tagName)
+{
+}
+
+DeviceDescriptor::DeviceDescriptor(audio_devices_t type, const FormatVector &encodedFormats,
+ const String8 &tagName) :
AudioPort(String8(""), AUDIO_PORT_TYPE_DEVICE,
audio_is_output_device(type) ? AUDIO_PORT_ROLE_SINK :
AUDIO_PORT_ROLE_SOURCE),
- mAddress(""), mTagName(tagName), mDeviceType(type), mId(0)
+ mAddress(""), mTagName(tagName), mDeviceType(type), mEncodedFormats(encodedFormats), mId(0)
{
if (type == AUDIO_DEVICE_IN_REMOTE_SUBMIX || type == AUDIO_DEVICE_OUT_REMOTE_SUBMIX ) {
mAddress = String8("0");
}
+ /* FIXME: read from APM config file */
+ if (type == AUDIO_DEVICE_OUT_HDMI) {
+ mEncodedFormats.add(AUDIO_FORMAT_AC3);
+ mEncodedFormats.add(AUDIO_FORMAT_IEC61937);
+ }
}
audio_port_handle_t DeviceDescriptor::getId() const
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 6ec6a76..0041570 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -36,6 +36,7 @@
#include <inttypes.h>
#include <math.h>
+#include <unordered_set>
#include <vector>
#include <AudioPolicyManagerInterface.h>
@@ -4228,7 +4229,7 @@
mpClientInterface->setParameters(output, String8(param));
free(param);
}
- updateAudioProfiles(device, output, profile->getAudioProfiles());
+ updateAudioProfiles(devDesc, output, profile->getAudioProfiles());
if (!profile->hasValidAudioProfile()) {
ALOGW("checkOutputsForDevice() missing param");
desc->close();
@@ -4436,7 +4437,7 @@
mpClientInterface->setParameters(input, String8(param));
free(param);
}
- updateAudioProfiles(device, input, profile->getAudioProfiles());
+ updateAudioProfiles(devDesc, input, profile->getAudioProfiles());
if (!profile->hasValidAudioProfile()) {
ALOGW("checkInputsForDevice() direct input missing param");
desc->close();
@@ -5789,117 +5790,65 @@
}
}
-// Modify the list of surround sound formats supported.
-void AudioPolicyManager::filterSurroundFormats(FormatVector *formatsPtr) {
- FormatVector &formats = *formatsPtr;
- // TODO Set this based on Config properties.
- const bool alwaysForceAC3 = true;
+void AudioPolicyManager::modifySurroundFormats(
+ const sp<DeviceDescriptor>& devDesc, FormatVector *formatsPtr) {
+ // Use a set because FormatVector is unsorted.
+ std::unordered_set<audio_format_t> enforcedSurround(
+ devDesc->encodedFormats().begin(), devDesc->encodedFormats().end());
audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
ALOGD("%s: forced use = %d", __FUNCTION__, forceUse);
+ std::unordered_set<audio_format_t> formatSet;
+ if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL
+ || forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
+ // Only copy non-surround formats to formatSet.
+ for (auto formatIter = formatsPtr->begin(); formatIter != formatsPtr->end(); ++formatIter) {
+ if (mConfig.getSurroundFormats().count(*formatIter) == 0 &&
+ enforcedSurround.count(*formatIter) == 0) {
+ formatSet.insert(*formatIter);
+ }
+ }
+ } else {
+ formatSet.insert(formatsPtr->begin(), formatsPtr->end());
+ }
+ formatsPtr->clear(); // Re-filled from the formatSet in the end.
+
// If MANUAL, keep the supported surround sound formats as current enabled ones.
if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
- formats.clear();
- for (auto it = mSurroundFormats.begin(); it != mSurroundFormats.end(); it++) {
- formats.add(*it);
+ formatSet.insert(mSurroundFormats.begin(), mSurroundFormats.end());
+ // Enable IEC61937 when in MANUAL mode if it's enforced for this device.
+ if (enforcedSurround.count(AUDIO_FORMAT_IEC61937) != 0) {
+ formatSet.insert(AUDIO_FORMAT_IEC61937);
}
- // Always enable IEC61937 when in MANUAL mode.
- formats.add(AUDIO_FORMAT_IEC61937);
} else { // NEVER, AUTO or ALWAYS
- // Analyze original support for various formats.
- bool supportsAC3 = false;
- bool supportsOtherSurround = false;
- bool supportsIEC61937 = false;
mSurroundFormats.clear();
- for (ssize_t formatIndex = 0; formatIndex < (ssize_t)formats.size(); formatIndex++) {
- audio_format_t format = formats[formatIndex];
- switch (format) {
- case AUDIO_FORMAT_AC3:
- supportsAC3 = true;
- break;
- case AUDIO_FORMAT_E_AC3:
- case AUDIO_FORMAT_DTS:
- case AUDIO_FORMAT_DTS_HD:
- // If ALWAYS, remove all other surround formats here
- // since we will add them later.
- if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
- formats.removeAt(formatIndex);
- formatIndex--;
- }
- supportsOtherSurround = true;
- break;
- case AUDIO_FORMAT_IEC61937:
- supportsIEC61937 = true;
- break;
- default:
- break;
- }
- }
-
// Modify formats based on surround preferences.
- // If NEVER, remove support for surround formats.
- if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
- if (supportsAC3 || supportsOtherSurround || supportsIEC61937) {
- // Remove surround sound related formats.
- for (size_t formatIndex = 0; formatIndex < formats.size(); ) {
- audio_format_t format = formats[formatIndex];
- switch(format) {
- case AUDIO_FORMAT_AC3:
- case AUDIO_FORMAT_E_AC3:
- case AUDIO_FORMAT_DTS:
- case AUDIO_FORMAT_DTS_HD:
- case AUDIO_FORMAT_IEC61937:
- formats.removeAt(formatIndex);
- break;
- default:
- formatIndex++; // keep it
- break;
- }
- }
- supportsAC3 = false;
- supportsOtherSurround = false;
- supportsIEC61937 = false;
- }
- } else { // AUTO or ALWAYS
- // Most TVs support AC3 even if they do not report it in the EDID.
- if ((alwaysForceAC3 || (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS))
- && !supportsAC3) {
- formats.add(AUDIO_FORMAT_AC3);
- supportsAC3 = true;
- }
-
+ if (forceUse != AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) { // AUTO or ALWAYS
// If ALWAYS, add support for raw surround formats if all are missing.
// This assumes that if any of these formats are reported by the HAL
// then the report is valid and should not be modified.
if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
- formats.add(AUDIO_FORMAT_E_AC3);
- formats.add(AUDIO_FORMAT_DTS);
- formats.add(AUDIO_FORMAT_DTS_HD);
- supportsOtherSurround = true;
+ for (const auto& format : mConfig.getSurroundFormats()) {
+ formatSet.insert(format.first);
+ }
}
+ formatSet.insert(enforcedSurround.begin(), enforcedSurround.end());
- // Add support for IEC61937 if any raw surround supported.
- // The HAL could do this but add it here, just in case.
- if ((supportsAC3 || supportsOtherSurround) && !supportsIEC61937) {
- formats.add(AUDIO_FORMAT_IEC61937);
- supportsIEC61937 = true;
- }
-
- // Add reported surround sound formats to enabled surround formats.
- for (size_t formatIndex = 0; formatIndex < formats.size(); formatIndex++) {
- audio_format_t format = formats[formatIndex];
+ for (const auto& format : formatSet) {
if (mConfig.getSurroundFormats().count(format) != 0) {
mSurroundFormats.insert(format);
}
}
}
}
+ for (const auto& format : formatSet) {
+ formatsPtr->push(format);
+ }
}
-// Modify the list of channel masks supported.
-void AudioPolicyManager::filterSurroundChannelMasks(ChannelsVector *channelMasksPtr) {
+void AudioPolicyManager::modifySurroundChannelMasks(ChannelsVector *channelMasksPtr) {
ChannelsVector &channelMasks = *channelMasksPtr;
audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
@@ -5934,11 +5883,12 @@
}
}
-void AudioPolicyManager::updateAudioProfiles(audio_devices_t device,
+void AudioPolicyManager::updateAudioProfiles(const sp<DeviceDescriptor>& devDesc,
audio_io_handle_t ioHandle,
AudioProfileVector &profiles)
{
String8 reply;
+ audio_devices_t device = devDesc->type();
// Format MUST be checked first to update the list of AudioProfile
if (profiles.hasDynamicFormat()) {
@@ -5953,7 +5903,7 @@
}
FormatVector formats = formatsFromString(reply.string());
if (device == AUDIO_DEVICE_OUT_HDMI) {
- filterSurroundFormats(&formats);
+ modifySurroundFormats(devDesc, &formats);
}
profiles.setFormats(formats);
}
@@ -5986,7 +5936,7 @@
String8(AudioParameter::keyStreamSupportedChannels), reply) == NO_ERROR) {
channelMasks = channelMasksFromString(reply.string());
if (device == AUDIO_DEVICE_OUT_HDMI) {
- filterSurroundChannelMasks(&channelMasks);
+ modifySurroundChannelMasks(&channelMasks);
}
}
}
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index 0436b1d..2b89380 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -612,8 +612,8 @@
std::unordered_set<audio_format_t> mSurroundFormats;
private:
// Add or remove AC3 DTS encodings based on user preferences.
- void filterSurroundFormats(FormatVector *formatsPtr);
- void filterSurroundChannelMasks(ChannelsVector *channelMasksPtr);
+ void modifySurroundFormats(const sp<DeviceDescriptor>& devDesc, FormatVector *formatsPtr);
+ void modifySurroundChannelMasks(ChannelsVector *channelMasksPtr);
// Support for Multi-Stream Decoder (MSD) module
sp<DeviceDescriptor> getMsdAudioInDevice() const;
@@ -627,7 +627,7 @@
status_t setMsdPatch(audio_devices_t outputDevice = AUDIO_DEVICE_NONE);
// If any, resolve any "dynamic" fields of an Audio Profiles collection
- void updateAudioProfiles(audio_devices_t device, audio_io_handle_t ioHandle,
+ void updateAudioProfiles(const sp<DeviceDescriptor>& devDesc, audio_io_handle_t ioHandle,
AudioProfileVector &profiles);
// Notify the policy client of any change of device state with AUDIO_IO_HANDLE_NONE,
diff --git a/services/audiopolicy/tests/Android.mk b/services/audiopolicy/tests/Android.mk
index 513312e..2ccb542 100644
--- a/services/audiopolicy/tests/Android.mk
+++ b/services/audiopolicy/tests/Android.mk
@@ -41,6 +41,9 @@
libmedia_helper \
libutils
+LOCAL_HEADER_LIBRARIES := \
+ libmedia_headers
+
LOCAL_SRC_FILES := \
systemaudio_tests.cpp \
diff --git a/services/camera/libcameraservice/api2/CameraDeviceClient.cpp b/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
index 6da05c3..c1a4c11 100644
--- a/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
+++ b/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
@@ -27,6 +27,8 @@
#include <camera/CameraUtils.h>
#include "common/CameraDeviceBase.h"
+#include "device3/Camera3Device.h"
+#include "device3/Camera3OutputStream.h"
#include "api2/CameraDeviceClient.h"
#include <camera_metadata_hidden.h>
@@ -471,6 +473,68 @@
return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
}
+ res = checkOperatingModeLocked(operatingMode);
+ if (!res.isOk()) {
+ return res;
+ }
+
+ status_t err = mDevice->configureStreams(sessionParams, operatingMode);
+ if (err == BAD_VALUE) {
+ String8 msg = String8::format("Camera %s: Unsupported set of inputs/outputs provided",
+ mCameraIdStr.string());
+ ALOGE("%s: %s", __FUNCTION__, msg.string());
+ res = STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
+ } else if (err != OK) {
+ String8 msg = String8::format("Camera %s: Error configuring streams: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
+ ALOGE("%s: %s", __FUNCTION__, msg.string());
+ res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
+ }
+
+ return res;
+}
+
+binder::Status CameraDeviceClient::checkSurfaceTypeLocked(size_t numBufferProducers,
+ bool deferredConsumer, int surfaceType) const {
+ if (numBufferProducers > MAX_SURFACES_PER_STREAM) {
+ ALOGE("%s: GraphicBufferProducer count %zu for stream exceeds limit of %d",
+ __FUNCTION__, numBufferProducers, MAX_SURFACES_PER_STREAM);
+ return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Surface count is too high");
+ } else if ((numBufferProducers == 0) && (!deferredConsumer)) {
+ ALOGE("%s: Number of consumers cannot be smaller than 1", __FUNCTION__);
+ return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "No valid consumers.");
+ }
+
+ bool validSurfaceType = ((surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW) ||
+ (surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_TEXTURE));
+
+ if (deferredConsumer && !validSurfaceType) {
+ ALOGE("%s: Target surface has invalid surfaceType = %d.", __FUNCTION__, surfaceType);
+ return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Target Surface is invalid");
+ }
+
+ return binder::Status::ok();
+}
+
+binder::Status CameraDeviceClient::checkPhysicalCameraIdLocked(String8 physicalCameraId) {
+ if (physicalCameraId.size() > 0) {
+ std::vector<std::string> physicalCameraIds;
+ bool logicalCamera =
+ mProviderManager->isLogicalCamera(mCameraIdStr.string(), &physicalCameraIds);
+ if (!logicalCamera ||
+ std::find(physicalCameraIds.begin(), physicalCameraIds.end(),
+ physicalCameraId.string()) == physicalCameraIds.end()) {
+ String8 msg = String8::format("Camera %s: Camera doesn't support physicalCameraId %s.",
+ mCameraIdStr.string(), physicalCameraId.string());
+ ALOGE("%s: %s", __FUNCTION__, msg.string());
+ return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
+ }
+ }
+
+ return binder::Status::ok();
+}
+
+binder::Status CameraDeviceClient::checkOperatingModeLocked(int operatingMode) const {
if (operatingMode < 0) {
String8 msg = String8::format(
"Camera %s: Invalid operating mode %d requested", mCameraIdStr.string(), operatingMode);
@@ -479,7 +543,6 @@
msg.string());
}
- // Sanitize the high speed session against necessary capability bit.
bool isConstrainedHighSpeed = (operatingMode == ICameraDeviceUser::CONSTRAINED_HIGH_SPEED_MODE);
if (isConstrainedHighSpeed) {
CameraMetadata staticInfo = mDevice->info();
@@ -502,17 +565,163 @@
}
}
- status_t err = mDevice->configureStreams(sessionParams, operatingMode);
- if (err == BAD_VALUE) {
- String8 msg = String8::format("Camera %s: Unsupported set of inputs/outputs provided",
- mCameraIdStr.string());
+ return binder::Status::ok();
+}
+
+void CameraDeviceClient::mapStreamInfo(const OutputStreamInfo &streamInfo,
+ camera3_stream_rotation_t rotation, String8 physicalId,
+ hardware::camera::device::V3_4::Stream *stream /*out*/) {
+ if (stream == nullptr) {
+ return;
+ }
+
+ stream->v3_2.streamType = hardware::camera::device::V3_2::StreamType::OUTPUT;
+ stream->v3_2.width = streamInfo.width;
+ stream->v3_2.height = streamInfo.height;
+ stream->v3_2.format = Camera3Device::mapToPixelFormat(streamInfo.format);
+ auto u = streamInfo.consumerUsage;
+ camera3::Camera3OutputStream::applyZSLUsageQuirk(streamInfo.format, &u);
+ stream->v3_2.usage = Camera3Device::mapToConsumerUsage(u);
+ stream->v3_2.dataSpace = Camera3Device::mapToHidlDataspace(streamInfo.dataSpace);
+ stream->v3_2.rotation = Camera3Device::mapToStreamRotation(rotation);
+ stream->physicalCameraId = std::string(physicalId.string());
+ stream->bufferSize = 0;
+}
+
+binder::Status CameraDeviceClient::isSessionConfigurationSupported(
+ const SessionConfiguration& sessionConfiguration, bool *status /*out*/) {
+ ATRACE_CALL();
+
+ binder::Status res;
+ if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
+
+ Mutex::Autolock icl(mBinderSerializationLock);
+
+ if (!mDevice.get()) {
+ return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
+ }
+
+ auto operatingMode = sessionConfiguration.getOperatingMode();
+ res = checkOperatingModeLocked(operatingMode);
+ if (!res.isOk()) {
+ return res;
+ }
+
+ if (status == nullptr) {
+ String8 msg = String8::format( "Camera %s: Invalid status!", mCameraIdStr.string());
ALOGE("%s: %s", __FUNCTION__, msg.string());
- res = STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
- } else if (err != OK) {
- String8 msg = String8::format("Camera %s: Error configuring streams: %s (%d)",
- mCameraIdStr.string(), strerror(-err), err);
+ return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
+ }
+
+ hardware::camera::device::V3_4::StreamConfiguration streamConfiguration;
+ auto ret = Camera3Device::mapToStreamConfigurationMode(
+ static_cast<camera3_stream_configuration_mode_t> (operatingMode),
+ /*out*/ &streamConfiguration.operationMode);
+ if (ret != OK) {
+ String8 msg = String8::format(
+ "Camera %s: Failed mapping operating mode %d requested: %s (%d)", mCameraIdStr.string(),
+ operatingMode, strerror(-ret), ret);
ALOGE("%s: %s", __FUNCTION__, msg.string());
- res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
+ return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
+ msg.string());
+ }
+
+ bool isInputValid = (sessionConfiguration.getInputWidth() > 0) &&
+ (sessionConfiguration.getInputHeight() > 0) &&
+ (sessionConfiguration.getInputFormat() > 0);
+ auto outputConfigs = sessionConfiguration.getOutputConfigurations();
+ size_t streamCount = outputConfigs.size();
+ streamCount = isInputValid ? streamCount + 1 : streamCount;
+ streamConfiguration.streams.resize(streamCount);
+ size_t streamIdx = 0;
+ if (isInputValid) {
+ streamConfiguration.streams[streamIdx++] = {{/*streamId*/0,
+ hardware::camera::device::V3_2::StreamType::INPUT,
+ static_cast<uint32_t> (sessionConfiguration.getInputWidth()),
+ static_cast<uint32_t> (sessionConfiguration.getInputHeight()),
+ Camera3Device::mapToPixelFormat(sessionConfiguration.getInputFormat()),
+ /*usage*/ 0, HAL_DATASPACE_UNKNOWN,
+ hardware::camera::device::V3_2::StreamRotation::ROTATION_0},
+ /*physicalId*/ nullptr, /*bufferSize*/0};
+ }
+
+ for (const auto &it : outputConfigs) {
+ const std::vector<sp<IGraphicBufferProducer>>& bufferProducers =
+ it.getGraphicBufferProducers();
+ bool deferredConsumer = it.isDeferred();
+ String8 physicalCameraId = String8(it.getPhysicalCameraId());
+ size_t numBufferProducers = bufferProducers.size();
+ bool isStreamInfoValid = false;
+ OutputStreamInfo streamInfo;
+
+ res = checkSurfaceTypeLocked(numBufferProducers, deferredConsumer, it.getSurfaceType());
+ if (!res.isOk()) {
+ return res;
+ }
+
+ res = checkPhysicalCameraIdLocked(physicalCameraId);
+ if (!res.isOk()) {
+ return res;
+ }
+
+ if (deferredConsumer) {
+ streamInfo.width = it.getWidth();
+ streamInfo.height = it.getHeight();
+ streamInfo.format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
+ streamInfo.dataSpace = android_dataspace_t::HAL_DATASPACE_UNKNOWN;
+ auto surfaceType = it.getSurfaceType();
+ streamInfo.consumerUsage = GraphicBuffer::USAGE_HW_TEXTURE;
+ if (surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW) {
+ streamInfo.consumerUsage |= GraphicBuffer::USAGE_HW_COMPOSER;
+ }
+ mapStreamInfo(streamInfo, CAMERA3_STREAM_ROTATION_0, physicalCameraId,
+ &streamConfiguration.streams[streamIdx++]);
+ isStreamInfoValid = true;
+
+ if (numBufferProducers == 0) {
+ continue;
+ }
+ }
+
+ for (auto& bufferProducer : bufferProducers) {
+ sp<Surface> surface;
+ res = createSurfaceFromGbp(streamInfo, isStreamInfoValid, surface, bufferProducer,
+ physicalCameraId);
+
+ if (!res.isOk())
+ return res;
+
+ if (!isStreamInfoValid) {
+ mapStreamInfo(streamInfo, static_cast<camera3_stream_rotation_t> (it.getRotation()),
+ physicalCameraId, &streamConfiguration.streams[streamIdx++]);
+ isStreamInfoValid = true;
+ }
+ }
+ }
+
+ *status = false;
+ ret = mProviderManager->isSessionConfigurationSupported(mCameraIdStr.string(),
+ streamConfiguration, status);
+ switch (ret) {
+ case OK:
+ // Expected, do nothing.
+ break;
+ case INVALID_OPERATION: {
+ String8 msg = String8::format(
+ "Camera %s: Session configuration query not supported!",
+ mCameraIdStr.string());
+ ALOGD("%s: %s", __FUNCTION__, msg.string());
+ res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
+ }
+
+ break;
+ default: {
+ String8 msg = String8::format( "Camera %s: Error: %s (%d)", mCameraIdStr.string(),
+ strerror(-ret), ret);
+ ALOGE("%s: %s", __FUNCTION__, msg.string());
+ res = STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
+ msg.string());
+ }
}
return res;
@@ -605,40 +814,23 @@
bool deferredConsumer = outputConfiguration.isDeferred();
bool isShared = outputConfiguration.isShared();
String8 physicalCameraId = String8(outputConfiguration.getPhysicalCameraId());
-
- if (numBufferProducers > MAX_SURFACES_PER_STREAM) {
- ALOGE("%s: GraphicBufferProducer count %zu for stream exceeds limit of %d",
- __FUNCTION__, bufferProducers.size(), MAX_SURFACES_PER_STREAM);
- return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Surface count is too high");
- }
bool deferredConsumerOnly = deferredConsumer && numBufferProducers == 0;
- int surfaceType = outputConfiguration.getSurfaceType();
- bool validSurfaceType = ((surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW) ||
- (surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_TEXTURE));
- if (deferredConsumer && !validSurfaceType) {
- ALOGE("%s: Target surface is invalid: bufferProducer = %p, surfaceType = %d.",
- __FUNCTION__, bufferProducers[0].get(), surfaceType);
- return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Target Surface is invalid");
+ res = checkSurfaceTypeLocked(numBufferProducers, deferredConsumer,
+ outputConfiguration.getSurfaceType());
+ if (!res.isOk()) {
+ return res;
}
if (!mDevice.get()) {
return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
}
- if (physicalCameraId.size() > 0) {
- std::vector<std::string> physicalCameraIds;
- bool logicalCamera =
- mProviderManager->isLogicalCamera(mCameraIdStr.string(), &physicalCameraIds);
- if (!logicalCamera ||
- std::find(physicalCameraIds.begin(), physicalCameraIds.end(),
- physicalCameraId.string()) == physicalCameraIds.end()) {
- String8 msg = String8::format("Camera %s: Camera doesn't support physicalCameraId %s.",
- mCameraIdStr.string(), physicalCameraId.string());
- ALOGE("%s: %s", __FUNCTION__, msg.string());
- return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
- }
+ res = checkPhysicalCameraIdLocked(physicalCameraId);
+ if (!res.isOk()) {
+ return res;
}
+
std::vector<sp<Surface>> surfaces;
std::vector<sp<IBinder>> binders;
status_t err;
diff --git a/services/camera/libcameraservice/api2/CameraDeviceClient.h b/services/camera/libcameraservice/api2/CameraDeviceClient.h
index 09ce977..17a0983 100644
--- a/services/camera/libcameraservice/api2/CameraDeviceClient.h
+++ b/services/camera/libcameraservice/api2/CameraDeviceClient.h
@@ -20,6 +20,7 @@
#include <android/hardware/camera2/BnCameraDeviceUser.h>
#include <android/hardware/camera2/ICameraDeviceCallbacks.h>
#include <camera/camera2/OutputConfiguration.h>
+#include <camera/camera2/SessionConfiguration.h>
#include <camera/camera2/SubmitInfo.h>
#include "CameraService.h"
@@ -89,6 +90,12 @@
virtual binder::Status endConfigure(int operatingMode,
const hardware::camera2::impl::CameraMetadataNative& sessionParams) override;
+ // Verify specific session configuration.
+ virtual binder::Status isSessionConfigurationSupported(
+ const SessionConfiguration& sessionConfiguration,
+ /*out*/
+ bool* streamStatus) override;
+
// Returns -EBUSY if device is not idle or in error state
virtual binder::Status deleteStream(int streamId) override;
@@ -230,6 +237,13 @@
/** Utility members */
binder::Status checkPidStatus(const char* checkLocation);
+ binder::Status checkOperatingModeLocked(int operatingMode) const;
+ binder::Status checkPhysicalCameraIdLocked(String8 physicalCameraId);
+ binder::Status checkSurfaceTypeLocked(size_t numBufferProducers, bool deferredConsumer,
+ int surfaceType) const;
+ static void mapStreamInfo(const OutputStreamInfo &streamInfo,
+ camera3_stream_rotation_t rotation, String8 physicalId,
+ hardware::camera::device::V3_4::Stream *stream /*out*/);
bool enforceRequestPermissions(CameraMetadata& metadata);
// Find the square of the euclidean distance between two points
@@ -300,7 +314,7 @@
// stream ID -> outputStreamInfo mapping
std::unordered_map<int32_t, OutputStreamInfo> mStreamInfoMap;
- static const int32_t MAX_SURFACES_PER_STREAM = 2;
+ static const int32_t MAX_SURFACES_PER_STREAM = 4;
sp<CameraProviderManager> mProviderManager;
};
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.cpp b/services/camera/libcameraservice/common/CameraProviderManager.cpp
index 2542ab2..a82f0f7 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.cpp
+++ b/services/camera/libcameraservice/common/CameraProviderManager.cpp
@@ -177,6 +177,19 @@
return deviceInfo->getCameraInfo(info);
}
+status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
+ const hardware::camera::device::V3_4::StreamConfiguration &configuration,
+ bool *status /*out*/) const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ auto deviceInfo = findDeviceInfoLocked(id);
+ if (deviceInfo == nullptr) {
+ return NAME_NOT_FOUND;
+ }
+
+ return deviceInfo->isSessionConfigurationSupported(configuration, status);
+}
+
status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
CameraMetadata* characteristics) const {
std::lock_guard<std::mutex> lock(mInterfaceMutex);
@@ -1381,6 +1394,43 @@
return OK;
}
+status_t CameraProviderManager::ProviderInfo::DeviceInfo3::isSessionConfigurationSupported(
+ const hardware::camera::device::V3_4::StreamConfiguration &configuration,
+ bool *status /*out*/) const {
+ auto castResult = device::V3_5::ICameraDevice::castFrom(mInterface);
+ sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult;
+ if (interface_3_5 == nullptr) {
+ return INVALID_OPERATION;
+ }
+
+ status_t res;
+ Status callStatus;
+ auto ret = interface_3_5->isStreamCombinationSupported(configuration,
+ [&callStatus, &status] (Status s, bool combStatus) {
+ callStatus = s;
+ *status = combStatus;
+ });
+ if (ret.isOk()) {
+ switch (callStatus) {
+ case Status::OK:
+ // Expected case, do nothing.
+ res = OK;
+ break;
+ case Status::METHOD_NOT_SUPPORTED:
+ res = INVALID_OPERATION;
+ break;
+ default:
+ ALOGE("%s: Session configuration query failed: %d", __FUNCTION__, callStatus);
+ res = UNKNOWN_ERROR;
+ }
+ } else {
+ ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
+ res = UNKNOWN_ERROR;
+ }
+
+ return res;
+}
+
status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
std::string *type, uint32_t *id) {
// Format must be "<type>/<id>"
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.h b/services/camera/libcameraservice/common/CameraProviderManager.h
index c506d35..99b87fb 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.h
+++ b/services/camera/libcameraservice/common/CameraProviderManager.h
@@ -28,6 +28,7 @@
#include <utils/Errors.h>
#include <android/hardware/camera/common/1.0/types.h>
#include <android/hardware/camera/provider/2.4/ICameraProvider.h>
+#include <android/hardware/camera/device/3.4/ICameraDeviceSession.h>
//#include <android/hardware/camera/provider/2.4/ICameraProviderCallbacks.h>
#include <android/hidl/manager/1.0/IServiceNotification.h>
#include <camera/VendorTagDescriptor.h>
@@ -166,6 +167,13 @@
CameraMetadata* characteristics) const;
/**
+ * Check for device support of specific stream combination.
+ */
+ status_t isSessionConfigurationSupported(const std::string& id,
+ const hardware::camera::device::V3_4::StreamConfiguration &configuration,
+ bool *status /*out*/) const;
+
+ /**
* Return the highest supported device interface version for this ID
*/
status_t getHighestSupportedVersion(const std::string &id,
@@ -315,6 +323,13 @@
return INVALID_OPERATION;
}
+ virtual status_t isSessionConfigurationSupported(
+ const hardware::camera::device::V3_4::StreamConfiguration &/*configuration*/,
+ bool * /*status*/)
+ const {
+ return INVALID_OPERATION;
+ }
+
DeviceInfo(const std::string& name, const metadata_vendor_id_t tagId,
const std::string &id, const hardware::hidl_version& version,
const std::vector<std::string>& publicCameraIds,
@@ -375,6 +390,10 @@
CameraMetadata *characteristics) const override;
virtual status_t getPhysicalCameraCharacteristics(const std::string& physicalCameraId,
CameraMetadata *characteristics) const override;
+ virtual status_t isSessionConfigurationSupported(
+ const hardware::camera::device::V3_4::StreamConfiguration &configuration,
+ bool *status /*out*/)
+ const override;
DeviceInfo3(const std::string& name, const metadata_vendor_id_t tagId,
const std::string &id, uint16_t minorVersion,
diff --git a/services/camera/libcameraservice/device3/Camera3Device.h b/services/camera/libcameraservice/device3/Camera3Device.h
index 419ac42..e5a38bb 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.h
+++ b/services/camera/libcameraservice/device3/Camera3Device.h
@@ -194,6 +194,28 @@
*/
status_t dropStreamBuffers(bool dropping, int streamId) override;
+ /**
+ * Helper functions to map between framework and HIDL values
+ */
+ static hardware::graphics::common::V1_0::PixelFormat mapToPixelFormat(int frameworkFormat);
+ static hardware::camera::device::V3_2::DataspaceFlags mapToHidlDataspace(
+ android_dataspace dataSpace);
+ static hardware::camera::device::V3_2::BufferUsageFlags mapToConsumerUsage(uint64_t usage);
+ static hardware::camera::device::V3_2::StreamRotation mapToStreamRotation(
+ camera3_stream_rotation_t rotation);
+ // Returns a negative error code if the passed-in operation mode is not valid.
+ static status_t mapToStreamConfigurationMode(camera3_stream_configuration_mode_t operationMode,
+ /*out*/ hardware::camera::device::V3_2::StreamConfigurationMode *mode);
+ static camera3_buffer_status_t mapHidlBufferStatus(
+ hardware::camera::device::V3_2::BufferStatus status);
+ static int mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat);
+ static android_dataspace mapToFrameworkDataspace(
+ hardware::camera::device::V3_2::DataspaceFlags);
+ static uint64_t mapConsumerToFrameworkUsage(
+ hardware::camera::device::V3_2::BufferUsageFlags usage);
+ static uint64_t mapProducerToFrameworkUsage(
+ hardware::camera::device::V3_2::BufferUsageFlags usage);
+
private:
status_t disconnectImpl();
@@ -679,27 +701,6 @@
*/
static nsecs_t getMonoToBoottimeOffset();
- /**
- * Helper functions to map between framework and HIDL values
- */
- static hardware::graphics::common::V1_0::PixelFormat mapToPixelFormat(int frameworkFormat);
- static hardware::camera::device::V3_2::DataspaceFlags mapToHidlDataspace(
- android_dataspace dataSpace);
- static hardware::camera::device::V3_2::BufferUsageFlags mapToConsumerUsage(uint64_t usage);
- static hardware::camera::device::V3_2::StreamRotation mapToStreamRotation(
- camera3_stream_rotation_t rotation);
- // Returns a negative error code if the passed-in operation mode is not valid.
- static status_t mapToStreamConfigurationMode(camera3_stream_configuration_mode_t operationMode,
- /*out*/ hardware::camera::device::V3_2::StreamConfigurationMode *mode);
- static camera3_buffer_status_t mapHidlBufferStatus(hardware::camera::device::V3_2::BufferStatus status);
- static int mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat);
- static android_dataspace mapToFrameworkDataspace(
- hardware::camera::device::V3_2::DataspaceFlags);
- static uint64_t mapConsumerToFrameworkUsage(
- hardware::camera::device::V3_2::BufferUsageFlags usage);
- static uint64_t mapProducerToFrameworkUsage(
- hardware::camera::device::V3_2::BufferUsageFlags usage);
-
struct RequestTrigger {
// Metadata tag number, e.g. android.control.aePrecaptureTrigger
uint32_t metadataTag;
diff --git a/services/camera/libcameraservice/device3/Camera3OutputStream.cpp b/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
index 219cc24..8cd575d 100644
--- a/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
@@ -663,12 +663,11 @@
return res;
}
-status_t Camera3OutputStream::getEndpointUsageForSurface(uint64_t *usage,
- const sp<Surface>& surface) const {
- status_t res;
- uint64_t u = 0;
+void Camera3OutputStream::applyZSLUsageQuirk(int format, uint64_t *consumerUsage /*inout*/) {
+ if (consumerUsage == nullptr) {
+ return;
+ }
- res = native_window_get_consumer_usage(static_cast<ANativeWindow*>(surface.get()), &u);
// If an opaque output stream's endpoint is ImageReader, add
// GRALLOC_USAGE_HW_CAMERA_ZSL to the usage so HAL knows it will be used
// for the ZSL use case.
@@ -677,12 +676,20 @@
// 2. GRALLOC_USAGE_HW_RENDER
// 3. GRALLOC_USAGE_HW_COMPOSER
// 4. GRALLOC_USAGE_HW_VIDEO_ENCODER
- if (camera3_stream::format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
- (u & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER |
+ if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
+ (*consumerUsage & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER |
GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_VIDEO_ENCODER)) == 0) {
- u |= GRALLOC_USAGE_HW_CAMERA_ZSL;
+ *consumerUsage |= GRALLOC_USAGE_HW_CAMERA_ZSL;
}
+}
+status_t Camera3OutputStream::getEndpointUsageForSurface(uint64_t *usage,
+ const sp<Surface>& surface) const {
+ status_t res;
+ uint64_t u = 0;
+
+ res = native_window_get_consumer_usage(static_cast<ANativeWindow*>(surface.get()), &u);
+ applyZSLUsageQuirk(camera3_stream::format, &u);
*usage = u;
return res;
}
diff --git a/services/camera/libcameraservice/device3/Camera3OutputStream.h b/services/camera/libcameraservice/device3/Camera3OutputStream.h
index 410905d..2128da2 100644
--- a/services/camera/libcameraservice/device3/Camera3OutputStream.h
+++ b/services/camera/libcameraservice/device3/Camera3OutputStream.h
@@ -201,6 +201,11 @@
const std::vector<size_t> &removedSurfaceIds,
KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
+ /**
+ * Apply ZSL related consumer usage quirk.
+ */
+ static void applyZSLUsageQuirk(int format, uint64_t *consumerUsage /*inout*/);
+
protected:
Camera3OutputStream(int id, camera3_stream_type_t type,
uint32_t width, uint32_t height, int format,
diff --git a/services/camera/libcameraservice/hidl/Convert.cpp b/services/camera/libcameraservice/hidl/Convert.cpp
index 76ed6f6..582ce34 100644
--- a/services/camera/libcameraservice/hidl/Convert.cpp
+++ b/services/camera/libcameraservice/hidl/Convert.cpp
@@ -101,12 +101,14 @@
bool convertFromHidl(const HCameraMetadata &src, CameraMetadata *dst) {
const camera_metadata_t *buffer = reinterpret_cast<const camera_metadata_t*>(src.data());
size_t expectedSize = src.size();
- int res = validate_camera_metadata_structure(buffer, &expectedSize);
- if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
- *dst = buffer;
- } else {
- ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
- return false;
+ if (buffer != nullptr) {
+ int res = validate_camera_metadata_structure(buffer, &expectedSize);
+ if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
+ *dst = buffer;
+ } else {
+ ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
+ return false;
+ }
}
return true;
}
diff --git a/services/camera/libcameraservice/tests/Android.mk b/services/camera/libcameraservice/tests/Android.mk
index 8d80ff1..ad9963a 100644
--- a/services/camera/libcameraservice/tests/Android.mk
+++ b/services/camera/libcameraservice/tests/Android.mk
@@ -30,7 +30,8 @@
android.hardware.camera.common@1.0 \
android.hardware.camera.provider@2.4 \
android.hardware.camera.device@1.0 \
- android.hardware.camera.device@3.2
+ android.hardware.camera.device@3.2 \
+ android.hardware.camera.device@3.4
LOCAL_C_INCLUDES += \
system/media/private/camera/include \
diff --git a/services/oboeservice/AAudioEndpointManager.cpp b/services/oboeservice/AAudioEndpointManager.cpp
index b1854bf..cca1895 100644
--- a/services/oboeservice/AAudioEndpointManager.cpp
+++ b/services/oboeservice/AAudioEndpointManager.cpp
@@ -172,7 +172,7 @@
aaudio_result_t result = endpoint->open(request);
if (result != AAUDIO_OK) {
- ALOGE("openExclusiveEndpoint(), open failed");
+ ALOGV("openExclusiveEndpoint(), open failed");
endpoint.clear();
} else {
mExclusiveStreams.push_back(endpointMMap);
diff --git a/services/oboeservice/AAudioService.cpp b/services/oboeservice/AAudioService.cpp
index 5ec997c..2fbaeb4 100644
--- a/services/oboeservice/AAudioService.cpp
+++ b/services/oboeservice/AAudioService.cpp
@@ -118,7 +118,7 @@
}
}
- // If SHARED requested or if EXCLUSIVE failed.
+ // Try SHARED if SHARED requested or if EXCLUSIVE failed.
if (sharingMode == AAUDIO_SHARING_MODE_SHARED) {
serviceStream = new AAudioServiceStreamShared(*this);
result = serviceStream->open(request);
@@ -132,8 +132,7 @@
if (result != AAUDIO_OK) {
serviceStream.clear();
- ALOGE("openStream(): failed, return %d = %s",
- result, AAudio_convertResultToText(result));
+ ALOGW("openStream(): failed, return %d = %s", result, AAudio_convertResultToText(result));
return result;
} else {
aaudio_handle_t handle = mStreamTracker.addStreamForHandle(serviceStream.get());
diff --git a/services/oboeservice/AAudioServiceEndpoint.cpp b/services/oboeservice/AAudioServiceEndpoint.cpp
index 24ab65e..539735a 100644
--- a/services/oboeservice/AAudioServiceEndpoint.cpp
+++ b/services/oboeservice/AAudioServiceEndpoint.cpp
@@ -38,10 +38,6 @@
using namespace android; // TODO just import names needed
using namespace aaudio; // TODO just import names needed
-AAudioServiceEndpoint::~AAudioServiceEndpoint() {
- ALOGD("%s(%p) destroyed", __func__, this);
-}
-
std::string AAudioServiceEndpoint::dump() const {
std::stringstream result;
diff --git a/services/oboeservice/AAudioServiceEndpoint.h b/services/oboeservice/AAudioServiceEndpoint.h
index a134a13..43b0a37 100644
--- a/services/oboeservice/AAudioServiceEndpoint.h
+++ b/services/oboeservice/AAudioServiceEndpoint.h
@@ -41,7 +41,7 @@
, public AAudioStreamParameters {
public:
- virtual ~AAudioServiceEndpoint();
+ virtual ~AAudioServiceEndpoint() = default;
virtual std::string dump() const;
diff --git a/services/oboeservice/AAudioServiceEndpointMMAP.cpp b/services/oboeservice/AAudioServiceEndpointMMAP.cpp
index 18fcd35..e4dbee1 100644
--- a/services/oboeservice/AAudioServiceEndpointMMAP.cpp
+++ b/services/oboeservice/AAudioServiceEndpointMMAP.cpp
@@ -101,8 +101,6 @@
.flags = AUDIO_FLAG_LOW_LATENCY,
.tags = ""
};
- ALOGD("%s(%p) MMAP attributes.usage = %d, content_type = %d, source = %d",
- __func__, this, attributes.usage, attributes.content_type, attributes.source);
mMmapClient.clientUid = request.getUserId();
mMmapClient.clientPid = request.getProcessId();
@@ -163,12 +161,12 @@
ALOGD("%s() mMapClient.uid = %d, pid = %d => portHandle = %d\n",
__func__, mMmapClient.clientUid, mMmapClient.clientPid, mPortHandle);
if (status != OK) {
- ALOGE("%s() openMmapStream() returned status %d", __func__, status);
+ ALOGE("%s() - openMmapStream() returned status %d", __func__, status);
return AAUDIO_ERROR_UNAVAILABLE;
}
if (deviceId == AAUDIO_UNSPECIFIED) {
- ALOGW("%s() openMmapStream() failed to set deviceId", __func__);
+ ALOGW("%s() - openMmapStream() failed to set deviceId", __func__);
}
setDeviceId(deviceId);
diff --git a/services/oboeservice/AAudioServiceEndpointPlay.cpp b/services/oboeservice/AAudioServiceEndpointPlay.cpp
index a274466..923a1a4 100644
--- a/services/oboeservice/AAudioServiceEndpointPlay.cpp
+++ b/services/oboeservice/AAudioServiceEndpointPlay.cpp
@@ -47,10 +47,6 @@
mStreamInternal = &mStreamInternalPlay;
}
-AAudioServiceEndpointPlay::~AAudioServiceEndpointPlay() {
- ALOGD("%s(%p) destroyed", __func__, this);
-}
-
aaudio_result_t AAudioServiceEndpointPlay::open(const aaudio::AAudioStreamRequest &request) {
aaudio_result_t result = AAudioServiceEndpointShared::open(request);
if (result == AAUDIO_OK) {
diff --git a/services/oboeservice/AAudioServiceEndpointPlay.h b/services/oboeservice/AAudioServiceEndpointPlay.h
index a0a383c..981e430 100644
--- a/services/oboeservice/AAudioServiceEndpointPlay.h
+++ b/services/oboeservice/AAudioServiceEndpointPlay.h
@@ -39,7 +39,6 @@
class AAudioServiceEndpointPlay : public AAudioServiceEndpointShared {
public:
explicit AAudioServiceEndpointPlay(android::AAudioService &audioService);
- virtual ~AAudioServiceEndpointPlay();
aaudio_result_t open(const aaudio::AAudioStreamRequest &request) override;
diff --git a/services/oboeservice/AAudioServiceEndpointShared.h b/services/oboeservice/AAudioServiceEndpointShared.h
index d671710..bfc1744 100644
--- a/services/oboeservice/AAudioServiceEndpointShared.h
+++ b/services/oboeservice/AAudioServiceEndpointShared.h
@@ -52,8 +52,7 @@
aaudio_result_t getTimestamp(int64_t *positionFrames, int64_t *timeNanos) override;
- virtual void *callbackLoop() = 0;
-
+ virtual void *callbackLoop() = 0;
protected:
diff --git a/services/oboeservice/AAudioServiceStreamBase.cpp b/services/oboeservice/AAudioServiceStreamBase.cpp
index 12be4a3..354b36a 100644
--- a/services/oboeservice/AAudioServiceStreamBase.cpp
+++ b/services/oboeservice/AAudioServiceStreamBase.cpp
@@ -51,7 +51,6 @@
}
AAudioServiceStreamBase::~AAudioServiceStreamBase() {
- ALOGD("~AAudioServiceStreamBase() destroying %p", this);
// If the stream is deleted when OPEN or in use then audio resources will leak.
// This would indicate an internal error. So we want to find this ASAP.
LOG_ALWAYS_FATAL_IF(!(getState() == AAUDIO_STREAM_STATE_CLOSED
@@ -110,7 +109,6 @@
mServiceEndpoint = mEndpointManager.openEndpoint(mAudioService,
request);
if (mServiceEndpoint == nullptr) {
- ALOGE("%s() openEndpoint() failed", __func__);
result = AAUDIO_ERROR_UNAVAILABLE;
goto error;
}
diff --git a/services/oboeservice/AAudioServiceStreamShared.cpp b/services/oboeservice/AAudioServiceStreamShared.cpp
index dbc2c2e..d5450fe 100644
--- a/services/oboeservice/AAudioServiceStreamShared.cpp
+++ b/services/oboeservice/AAudioServiceStreamShared.cpp
@@ -128,7 +128,6 @@
aaudio_result_t result = AAudioServiceStreamBase::open(request);
if (result != AAUDIO_OK) {
- ALOGE("%s() returned %d", __func__, result);
return result;
}