Merge "Fix NDK CameraManager crash when no cameras exist"
diff --git a/camera/cameraserver/Android.mk b/camera/cameraserver/Android.mk
index 8c06833..bdafff1 100644
--- a/camera/cameraserver/Android.mk
+++ b/camera/cameraserver/Android.mk
@@ -24,7 +24,11 @@
liblog \
libutils \
libbinder \
- android.hardware.camera.common@1.0
+ 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.hidl.manager@1.0
LOCAL_MODULE:= cameraserver
LOCAL_32_BIT_ONLY := true
diff --git a/camera/ndk/Android.bp b/camera/ndk/Android.bp
index 6f2351f..c5fc646 100644
--- a/camera/ndk/Android.bp
+++ b/camera/ndk/Android.bp
@@ -20,4 +20,5 @@
name: "libcamera2ndk.ndk",
symbol_file: "libcamera2ndk.map.txt",
first_version: "24",
+ unversioned_until: "current",
}
diff --git a/include/media/audiohal/StreamHalInterface.h b/include/media/audiohal/StreamHalInterface.h
index 5296829..7419c34 100644
--- a/include/media/audiohal/StreamHalInterface.h
+++ b/include/media/audiohal/StreamHalInterface.h
@@ -75,6 +75,10 @@
// Get current read/write position in the mmap buffer
virtual status_t getMmapPosition(struct audio_mmap_position *position) = 0;
+ // Set the priority of the thread that interacts with the HAL
+ // (must match the priority of the audioflinger's thread that calls 'read' / 'write')
+ virtual status_t setHalThreadPriority(int priority) = 0;
+
protected:
// Subclasses can not be constructed directly by clients.
StreamHalInterface() {}
diff --git a/include/media/nbaio/NBLog.h b/include/media/nbaio/NBLog.h
index 1297b51..acf2d31 100644
--- a/include/media/nbaio/NBLog.h
+++ b/include/media/nbaio/NBLog.h
@@ -21,7 +21,7 @@
#include <binder/IMemory.h>
#include <utils/Mutex.h>
-#include <audio_utils/roundup.h>
+#include <audio_utils/fifo.h>
namespace android {
@@ -55,8 +55,11 @@
private:
friend class Writer;
Event mEvent; // event type
- size_t mLength; // length of additional data, 0 <= mLength <= 255
+ uint8_t mLength; // length of additional data, 0 <= mLength <= kMaxLength
const void *mData; // event type-specific data
+ static const size_t kMaxLength = 255;
+public:
+ static const size_t kOverhead = 3; // mEvent, mLength, mData[...], duplicate mLength
};
// representation of a single log entry in shared memory
@@ -70,13 +73,17 @@
// byte[2+mLength] duplicate copy of mLength to permit reverse scan
// byte[3+mLength] start of next log entry
-// located in shared memory
+public:
+
+// Located in shared memory, must be POD.
+// Exactly one process must explicitly call the constructor or use placement new.
+// Since this is a POD, the destructor is empty and unnecessary to call it explicitly.
struct Shared {
- Shared() : mRear(0) { }
+ Shared() /* mRear initialized via default constructor */ { }
/*virtual*/ ~Shared() { }
- volatile int32_t mRear; // index one byte past the end of most recent Entry
- char mBuffer[0]; // circular buffer for entries
+ audio_utils_fifo_index mRear; // index one byte past the end of most recent Entry
+ char mBuffer[0]; // circular buffer for entries
};
public:
@@ -117,10 +124,10 @@
// Input parameter 'size' is the desired size of the timeline in byte units.
// The size of the shared memory must be at least Timeline::sharedSize(size).
- Writer(size_t size, void *shared);
- Writer(size_t size, const sp<IMemory>& iMemory);
+ Writer(void *shared, size_t size);
+ Writer(const sp<IMemory>& iMemory, size_t size);
- virtual ~Writer() { }
+ virtual ~Writer();
virtual void log(const char *string);
virtual void logf(const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
@@ -138,13 +145,16 @@
sp<IMemory> getIMemory() const { return mIMemory; }
private:
+ // 0 <= length <= kMaxLength
void log(Event event, const void *data, size_t length);
void log(const Entry *entry, bool trusted = false);
- const size_t mSize; // circular buffer size in bytes, must be a power of 2
Shared* const mShared; // raw pointer to shared memory
- const sp<IMemory> mIMemory; // ref-counted version
- int32_t mRear; // my private copy of mShared->mRear
+ sp<IMemory> mIMemory; // ref-counted version, initialized in constructor and then const
+ audio_utils_fifo * const mFifo; // FIFO itself,
+ // non-NULL unless constructor fails
+ audio_utils_fifo_writer * const mFifoWriter; // used to write to FIFO,
+ // non-NULL unless dummy constructor used
bool mEnabled; // whether to actually log
};
@@ -154,7 +164,7 @@
class LockedWriter : public Writer {
public:
LockedWriter();
- LockedWriter(size_t size, void *shared);
+ LockedWriter(void *shared, size_t size);
virtual void log(const char *string);
virtual void logf(const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
@@ -176,21 +186,24 @@
// Input parameter 'size' is the desired size of the timeline in byte units.
// The size of the shared memory must be at least Timeline::sharedSize(size).
- Reader(size_t size, const void *shared);
- Reader(size_t size, const sp<IMemory>& iMemory);
+ Reader(const void *shared, size_t size);
+ Reader(const sp<IMemory>& iMemory, size_t size);
- virtual ~Reader() { }
+ virtual ~Reader();
void dump(int fd, size_t indent = 0);
bool isIMemory(const sp<IMemory>& iMemory) const;
private:
- const size_t mSize; // circular buffer size in bytes, must be a power of 2
- const Shared* const mShared; // raw pointer to shared memory
- const sp<IMemory> mIMemory; // ref-counted version
- int32_t mFront; // index of oldest acknowledged Entry
+ /*const*/ Shared* const mShared; // raw pointer to shared memory, actually const but not
+ // declared as const because audio_utils_fifo() constructor
+ sp<IMemory> mIMemory; // ref-counted version, assigned only in constructor
int mFd; // file descriptor
int mIndent; // indentation level
+ audio_utils_fifo * const mFifo; // FIFO itself,
+ // non-NULL unless constructor fails
+ audio_utils_fifo_reader * const mFifoReader; // used to read from FIFO,
+ // non-NULL unless constructor fails
void dumpLine(const String8& timestamp, String8& body);
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
new file mode 100644
index 0000000..03dce0c
--- /dev/null
+++ b/media/libaudioclient/Android.bp
@@ -0,0 +1,45 @@
+cc_library_shared {
+ name: "libaudioclient",
+ srcs: [
+ "AudioEffect.cpp",
+ "AudioPolicy.cpp",
+ "AudioRecord.cpp",
+ "AudioSystem.cpp",
+ "AudioTrack.cpp",
+ "AudioTrackShared.cpp",
+ "IAudioFlinger.cpp",
+ "IAudioFlingerClient.cpp",
+ "IAudioPolicyService.cpp",
+ "IAudioPolicyServiceClient.cpp",
+ "IAudioRecord.cpp",
+ "IAudioTrack.cpp",
+ "IEffect.cpp",
+ "IEffectClient.cpp",
+ "ToneGenerator.cpp",
+ ],
+ shared_libs: [
+ "liblog",
+ "libcutils",
+ "libutils",
+ "libbinder",
+ "libdl",
+ "libaudioutils",
+ ],
+ export_shared_lib_headers: ["libbinder"],
+ // for memory heap analysis
+ static_libs: [
+ "libc_malloc_debug_backtrace",
+ "libc_logging",
+ ],
+ cflags: [
+ "-Werror",
+ "-Wno-error=deprecated-declarations",
+ "-Wall",
+ ],
+ sanitize: {
+ misc_undefined : [
+ "unsigned-integer-overflow",
+ "signed-integer-overflow",
+ ],
+ },
+}
diff --git a/media/libaudioclient/Android.mk b/media/libaudioclient/Android.mk
deleted file mode 100644
index 348ab50..0000000
--- a/media/libaudioclient/Android.mk
+++ /dev/null
@@ -1,50 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES += \
- AudioEffect.cpp \
- AudioPolicy.cpp \
- AudioRecord.cpp \
- AudioSystem.cpp \
- AudioTrack.cpp \
- AudioTrackShared.cpp \
- IAudioFlinger.cpp \
- IAudioFlingerClient.cpp \
- IAudioPolicyService.cpp \
- IAudioPolicyServiceClient.cpp \
- IAudioRecord.cpp \
- IAudioTrack.cpp \
- IEffect.cpp \
- IEffectClient.cpp \
- ToneGenerator.cpp \
-
-LOCAL_SHARED_LIBRARIES := \
- liblog libcutils libutils libbinder \
- libdl libaudioutils \
-
-LOCAL_EXPORT_SHARED_LIBRARY_HEADERS := libbinder
-
-# for memory heap analysis
-LOCAL_STATIC_LIBRARIES := libc_malloc_debug_backtrace libc_logging
-
-LOCAL_MODULE:= libaudioclient
-
-LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
-
-LOCAL_C_INCLUDES := \
- $(TOP)/frameworks/native/include/media/openmax \
- $(TOP)/frameworks/av/include/media/ \
- $(TOP)/frameworks/av/media/libstagefright \
- $(TOP)/frameworks/av/media/libmedia/aidl \
- $(call include-path-for, audio-utils)
-
-LOCAL_EXPORT_C_INCLUDE_DIRS := \
- frameworks/av/include/media \
- frameworks/av/media/libmedia/aidl
-
-LOCAL_CFLAGS += -Werror -Wno-error=deprecated-declarations -Wall
-LOCAL_SANITIZE := unsigned-integer-overflow signed-integer-overflow
-
-include $(BUILD_SHARED_LIBRARY)
-
diff --git a/media/libaudiohal/Android.mk b/media/libaudiohal/Android.mk
index e82766f..893c626 100644
--- a/media/libaudiohal/Android.mk
+++ b/media/libaudiohal/Android.mk
@@ -3,11 +3,13 @@
include $(CLEAR_VARS)
LOCAL_SHARED_LIBRARIES := \
+ libbase \
libcutils \
+ libeffects \
+ libfmq \
libhardware \
liblog \
- libutils \
- libeffects
+ libutils
ifeq ($(ENABLE_TREBLE), true)
diff --git a/media/libaudiohal/ConversionHelperHidl.cpp b/media/libaudiohal/ConversionHelperHidl.cpp
index 1fabfbe..9f9eb75 100644
--- a/media/libaudiohal/ConversionHelperHidl.cpp
+++ b/media/libaudiohal/ConversionHelperHidl.cpp
@@ -82,26 +82,8 @@
}
}
-// static
-void ConversionHelperHidl::crashIfHalIsDead(const Status& status) {
- LOG_ALWAYS_FATAL_IF(
- status.transactionError() == DEAD_OBJECT, "HAL server crashed, need to restart");
-}
-
-status_t ConversionHelperHidl::processReturn(const char* funcName, const Status& status) {
- const status_t st = status.transactionError();
- ALOGE_IF(st, "%s %p %s: %s (from rpc)", mClassName, this, funcName, strerror(-st));
- crashIfHalIsDead(status);
- return st;
-}
-
-status_t ConversionHelperHidl::processReturn(
- const char* funcName, const Status& status, hardware::audio::V2_0::Result retval) {
- const status_t st = status.isOk() ? analyzeResult(retval) : status.transactionError();
- ALOGE_IF(!status.isOk() && st, "%s %p %s: %s (from rpc)",
- mClassName, this, funcName, strerror(-st));
- crashIfHalIsDead(status);
- return st;
+void ConversionHelperHidl::emitError(const char* funcName, const char* description) {
+ ALOGE("%s %p %s: %s (from rpc)", mClassName, this, funcName, description);
}
} // namespace android
diff --git a/media/libaudiohal/ConversionHelperHidl.h b/media/libaudiohal/ConversionHelperHidl.h
index 428daf2..89e6e88 100644
--- a/media/libaudiohal/ConversionHelperHidl.h
+++ b/media/libaudiohal/ConversionHelperHidl.h
@@ -30,9 +30,6 @@
namespace android {
class ConversionHelperHidl {
- public:
- static void crashIfHalIsDead(const Status& status);
-
protected:
static status_t keysFromHal(const String8& keys, hidl_vec<hidl_string> *hidlKeys);
static status_t parametersFromHal(const String8& kvPairs, hidl_vec<ParameterValue> *hidlParams);
@@ -40,18 +37,22 @@
ConversionHelperHidl(const char* className);
- status_t processReturn(const char* funcName, const Return<void>& ret) {
- return processReturn(funcName, ret.getStatus());
- }
-
template<typename R, typename T>
status_t processReturn(const char* funcName, const Return<R>& ret, T *retval) {
- if (ret.getStatus().isOk()) {
+ if (ret.isOk()) {
// This way it also works for enum class to unscoped enum conversion.
*retval = static_cast<T>(static_cast<R>(ret));
return OK;
}
- return processReturn(funcName, ret.getStatus());
+ return processReturn(funcName, ret);
+ }
+
+ template<typename T>
+ status_t processReturn(const char* funcName, const Return<T>& ret) {
+ if (!ret.isOk()) {
+ emitError(funcName, ret.description().c_str());
+ }
+ return ret.isOk() ? OK : UNKNOWN_ERROR;
}
status_t processReturn(const char* funcName, const Return<hardware::audio::V2_0::Result>& ret) {
@@ -61,16 +62,21 @@
template<typename T>
status_t processReturn(
const char* funcName, const Return<T>& ret, hardware::audio::V2_0::Result retval) {
- return processReturn(funcName, ret.getStatus(), retval);
+ const status_t st = ret.isOk() ? analyzeResult(retval) : UNKNOWN_ERROR;
+ if (!ret.isOk()) {
+ emitError(funcName, ret.description().c_str());
+ } else if (st) {
+ emitError(funcName, strerror(st));
+ }
+ return st;
}
private:
const char* mClassName;
static status_t analyzeResult(const hardware::audio::V2_0::Result& result);
- status_t processReturn(const char* funcName, const Status& status);
- status_t processReturn(
- const char* funcName, const Status& status, hardware::audio::V2_0::Result retval);
+
+ void emitError(const char* funcName, const char* description);
};
} // namespace android
diff --git a/media/libaudiohal/DevicesFactoryHalHidl.cpp b/media/libaudiohal/DevicesFactoryHalHidl.cpp
index efcc089..6444079 100644
--- a/media/libaudiohal/DevicesFactoryHalHidl.cpp
+++ b/media/libaudiohal/DevicesFactoryHalHidl.cpp
@@ -78,13 +78,12 @@
*device = new DeviceHalHidl(result);
}
});
- if (ret.getStatus().isOk()) {
+ if (ret.isOk()) {
if (retval == Result::OK) return OK;
else if (retval == Result::INVALID_ARGUMENTS) return BAD_VALUE;
else return NO_INIT;
}
- ConversionHelperHidl::crashIfHalIsDead(ret.getStatus());
- return ret.getStatus().transactionError();
+ return UNKNOWN_ERROR;
}
} // namespace android
diff --git a/media/libaudiohal/EffectHalHidl.cpp b/media/libaudiohal/EffectHalHidl.cpp
index 1cd1997..0a58fa0 100644
--- a/media/libaudiohal/EffectHalHidl.cpp
+++ b/media/libaudiohal/EffectHalHidl.cpp
@@ -103,8 +103,7 @@
effectDescriptorToHal(result, pDescriptor);
}
});
- ConversionHelperHidl::crashIfHalIsDead(ret.getStatus());
- return ret.getStatus().isOk() ? analyzeResult(retval) : ret.getStatus().transactionError();
+ return ret.isOk() ? analyzeResult(retval) : UNKNOWN_ERROR;
}
} // namespace android
diff --git a/media/libaudiohal/EffectsFactoryHalHidl.cpp b/media/libaudiohal/EffectsFactoryHalHidl.cpp
index bacbe4e..1ab5dad 100644
--- a/media/libaudiohal/EffectsFactoryHalHidl.cpp
+++ b/media/libaudiohal/EffectsFactoryHalHidl.cpp
@@ -43,7 +43,7 @@
return EffectIsNullUuid(pEffectUuid);
}
-EffectsFactoryHalHidl::EffectsFactoryHalHidl() {
+EffectsFactoryHalHidl::EffectsFactoryHalHidl() : ConversionHelperHidl("EffectsFactory"){
mEffectsFactory = IEffectsFactory::getService("audio_effects_factory");
}
@@ -60,12 +60,11 @@
mLastDescriptors = result;
}
});
- if (ret.getStatus().isOk()) {
+ if (ret.isOk()) {
return retval == Result::OK ? OK : NO_INIT;
}
mLastDescriptors.resize(0);
- ConversionHelperHidl::crashIfHalIsDead(ret.getStatus());
- return ret.getStatus().transactionError();
+ return processReturn(__FUNCTION__, ret);
}
status_t EffectsFactoryHalHidl::queryNumberEffects(uint32_t *pNumEffects) {
@@ -104,13 +103,12 @@
EffectHalHidl::effectDescriptorToHal(result, pDescriptor);
}
});
- if (ret.getStatus().isOk()) {
+ if (ret.isOk()) {
if (retval == Result::OK) return OK;
else if (retval == Result::INVALID_ARGUMENTS) return NAME_NOT_FOUND;
else return NO_INIT;
}
- ConversionHelperHidl::crashIfHalIsDead(ret.getStatus());
- return ret.getStatus().transactionError();
+ return processReturn(__FUNCTION__, ret);
}
status_t EffectsFactoryHalHidl::createEffect(
@@ -128,13 +126,12 @@
*effect = new EffectHalHidl(result, effectId);
}
});
- if (ret.getStatus().isOk()) {
+ if (ret.isOk()) {
if (retval == Result::OK) return OK;
else if (retval == Result::INVALID_ARGUMENTS) return NAME_NOT_FOUND;
else return NO_INIT;
}
- ConversionHelperHidl::crashIfHalIsDead(ret.getStatus());
- return ret.getStatus().transactionError();
+ return processReturn(__FUNCTION__, ret);
}
status_t EffectsFactoryHalHidl::dumpEffects(int fd) {
@@ -143,8 +140,7 @@
hidlHandle->data[0] = fd;
Return<void> ret = mEffectsFactory->debugDump(hidlHandle);
native_handle_delete(hidlHandle);
- ConversionHelperHidl::crashIfHalIsDead(ret.getStatus());
- return ret.getStatus().transactionError();
+ return processReturn(__FUNCTION__, ret);
}
} // namespace android
diff --git a/media/libaudiohal/EffectsFactoryHalHidl.h b/media/libaudiohal/EffectsFactoryHalHidl.h
index f16db17..e89f042 100644
--- a/media/libaudiohal/EffectsFactoryHalHidl.h
+++ b/media/libaudiohal/EffectsFactoryHalHidl.h
@@ -27,7 +27,7 @@
using ::android::hardware::audio::effect::V2_0::IEffectsFactory;
using ::android::hardware::hidl_vec;
-class EffectsFactoryHalHidl : public EffectsFactoryHalInterface
+class EffectsFactoryHalHidl : public EffectsFactoryHalInterface, public ConversionHelperHidl
{
public:
// Returns the number of different effects in all loaded libraries.
diff --git a/media/libaudiohal/StreamHalHidl.cpp b/media/libaudiohal/StreamHalHidl.cpp
index 2c6e564..5943e22 100644
--- a/media/libaudiohal/StreamHalHidl.cpp
+++ b/media/libaudiohal/StreamHalHidl.cpp
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include <time.h>
+
#define LOG_TAG "StreamHalHidl"
//#define LOG_NDEBUG 0
@@ -28,18 +30,23 @@
using ::android::hardware::audio::common::V2_0::AudioFormat;
using ::android::hardware::audio::V2_0::AudioDrain;
using ::android::hardware::audio::V2_0::IStreamOutCallback;
-using ::android::hardware::audio::V2_0::ParameterValue;
-using ::android::hardware::audio::V2_0::Result;
-using ::android::hardware::audio::V2_0::TimeSpec;
+using ::android::hardware::audio::V2_0::MessageQueueFlagBits;
using ::android::hardware::audio::V2_0::MmapBufferInfo;
using ::android::hardware::audio::V2_0::MmapPosition;
+using ::android::hardware::audio::V2_0::ParameterValue;
+using ::android::hardware::audio::V2_0::Result;
+using ::android::hardware::audio::V2_0::ThreadPriority;
+using ::android::hardware::audio::V2_0::TimeSpec;
+using ::android::hardware::MQDescriptorSync;
using ::android::hardware::Return;
using ::android::hardware::Void;
namespace android {
StreamHalHidl::StreamHalHidl(IStream *stream)
- : ConversionHelperHidl("Stream"), mStream(stream) {
+ : ConversionHelperHidl("Stream"),
+ mHalThreadPriority(static_cast<int>(ThreadPriority::NORMAL)),
+ mStream(stream) {
}
StreamHalHidl::~StreamHalHidl() {
@@ -176,6 +183,11 @@
return processReturn("getMmapPosition", ret, retval);
}
+status_t StreamHalHidl::setHalThreadPriority(int priority) {
+ mHalThreadPriority = priority;
+ return OK;
+}
+
namespace {
/* Notes on callback ownership.
@@ -229,14 +241,21 @@
} // namespace
StreamOutHalHidl::StreamOutHalHidl(const sp<IStreamOut>& stream)
- : StreamHalHidl(stream.get()), mStream(stream) {
+ : StreamHalHidl(stream.get()), mStream(stream), mEfGroup(nullptr),
+ mGetPresentationPositionNotSupported(false), mPPosFromWriteObtained(0) {
}
StreamOutHalHidl::~StreamOutHalHidl() {
- if (mCallback.unsafe_get() && mStream != 0) {
- processReturn("clearCallback", mStream->clearCallback());
+ if (mStream != 0) {
+ if (mCallback.unsafe_get()) {
+ processReturn("clearCallback", mStream->clearCallback());
+ }
+ processReturn("close", mStream->close());
}
mCallback.clear();
+ if (mEfGroup) {
+ EventFlag::deleteEventFlag(&mEfGroup);
+ }
}
status_t StreamOutHalHidl::getFrameSize(size_t *size) {
@@ -256,16 +275,89 @@
status_t StreamOutHalHidl::write(const void *buffer, size_t bytes, size_t *written) {
if (mStream == 0) return NO_INIT;
- hidl_vec<uint8_t> hidlData;
- hidlData.setToExternal(static_cast<uint8_t*>(const_cast<void*>(buffer)), bytes);
+ *written = 0;
+
+ if (bytes == 0 && !mDataMQ) {
+ // Can't determine the size for the MQ buffer. Wait for a non-empty write request.
+ ALOGW_IF(mCallback.unsafe_get(), "First call to async write with 0 bytes");
+ return OK;
+ }
+
+ status_t status;
+ if (!mDataMQ && (status = prepareForWriting(bytes)) != OK) {
+ return status;
+ }
+
+ const size_t availBytes = mDataMQ->availableToWrite();
+ if (bytes > availBytes) { bytes = availBytes; }
+ if (!mDataMQ->write(static_cast<const uint8_t*>(buffer), bytes)) {
+ ALOGW("data message queue write failed");
+ }
+ mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY));
+
+ // TODO: Remove manual event flag handling once blocking MQ is implemented. b/33815422
+ uint32_t efState = 0;
+retry:
+ status_t ret = mEfGroup->wait(
+ static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL), &efState, NS_PER_SEC);
+ if (efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL)) {
+ WriteStatus writeStatus = { Result::NOT_INITIALIZED, 0, 0, { 0, 0 } };
+ mStatusMQ->read(&writeStatus);
+ if (writeStatus.retval == Result::OK) {
+ status = OK;
+ *written = writeStatus.written;
+ mPPosFromWriteFrames = writeStatus.frames;
+ mPPosFromWriteTS.tv_sec = writeStatus.timeStamp.tvSec;
+ mPPosFromWriteTS.tv_nsec = writeStatus.timeStamp.tvNSec;
+ struct timespec timeNow;
+ clock_gettime(CLOCK_MONOTONIC, &timeNow);
+ mPPosFromWriteObtained = timeNow.tv_sec * 1000000 + timeNow.tv_nsec / 1000;
+ } else {
+ status = processReturn("write", writeStatus.retval);
+ }
+ return status;
+ }
+ if (ret == -EAGAIN) {
+ // This normally retries no more than once.
+ goto retry;
+ }
+ return ret;
+}
+
+status_t StreamOutHalHidl::prepareForWriting(size_t bufferSize) {
+ std::unique_ptr<DataMQ> tempDataMQ;
+ std::unique_ptr<StatusMQ> tempStatusMQ;
Result retval;
- Return<void> ret = mStream->write(
- hidlData,
- [&](Result r, uint64_t w) {
+ Return<void> ret = mStream->prepareForWriting(
+ 1, bufferSize, ThreadPriority(mHalThreadPriority),
+ [&](Result r,
+ const MQDescriptorSync<uint8_t>& dataMQ,
+ const MQDescriptorSync<WriteStatus>& statusMQ) {
retval = r;
- *written = w;
+ if (retval == Result::OK) {
+ tempDataMQ.reset(new DataMQ(dataMQ));
+ tempStatusMQ.reset(new StatusMQ(statusMQ));
+ if (tempDataMQ->isValid() && tempDataMQ->getEventFlagWord()) {
+ EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(), &mEfGroup);
+ }
+ }
});
- return processReturn("write", ret, retval);
+ if (!ret.isOk() || retval != Result::OK) {
+ return processReturn("prepareForWriting", ret, retval);
+ }
+ if (!tempDataMQ || !tempDataMQ->isValid() || !tempStatusMQ || !tempStatusMQ->isValid()
+ || !mEfGroup) {
+ ALOGE_IF(!tempDataMQ, "Failed to obtain data message queue for writing");
+ ALOGE_IF(tempDataMQ && !tempDataMQ->isValid(), "Data message queue for writing is invalid");
+ ALOGE_IF(!tempStatusMQ, "Failed to obtain status message queue for writing");
+ ALOGE_IF(tempStatusMQ && !tempStatusMQ->isValid(),
+ "Status message queue for writing is invalid");
+ ALOGE_IF(!mEfGroup, "Event flag creation for writing failed");
+ return NO_INIT;
+ }
+ mDataMQ = std::move(tempDataMQ);
+ mStatusMQ = std::move(tempStatusMQ);
+ return OK;
}
status_t StreamOutHalHidl::getRenderPosition(uint32_t *dspFrames) {
@@ -342,6 +434,18 @@
status_t StreamOutHalHidl::getPresentationPosition(uint64_t *frames, struct timespec *timestamp) {
if (mStream == 0) return NO_INIT;
+ if (mGetPresentationPositionNotSupported) return INVALID_OPERATION;
+ struct timespec timeNow;
+ clock_gettime(CLOCK_MONOTONIC, &timeNow);
+ uint64_t timeStampNow = timeNow.tv_sec * 1000000 + timeNow.tv_nsec / 1000;
+ if (timeStampNow - mPPosFromWriteObtained <= 1000) {
+ // No more than 1 ms passed since the last write, use cached result to avoid binder calls.
+ *frames = mPPosFromWriteFrames;
+ timestamp->tv_sec = mPPosFromWriteTS.tv_sec;
+ timestamp->tv_nsec = mPPosFromWriteTS.tv_nsec;
+ return OK;
+ }
+
Result retval;
Return<void> ret = mStream->getPresentationPosition(
[&](Result r, uint64_t hidlFrames, const TimeSpec& hidlTimeStamp) {
@@ -352,6 +456,9 @@
timestamp->tv_nsec = hidlTimeStamp.tvNSec;
}
});
+ if (ret.isOk() && retval == Result::NOT_SUPPORTED) {
+ mGetPresentationPositionNotSupported = true;
+ }
return processReturn("getPresentationPosition", ret, retval);
}
@@ -378,10 +485,16 @@
StreamInHalHidl::StreamInHalHidl(const sp<IStreamIn>& stream)
- : StreamHalHidl(stream.get()), mStream(stream) {
+ : StreamHalHidl(stream.get()), mStream(stream), mEfGroup(nullptr) {
}
StreamInHalHidl::~StreamInHalHidl() {
+ if (mStream != 0) {
+ processReturn("close", mStream->close());
+ }
+ if (mEfGroup) {
+ EventFlag::deleteEventFlag(&mEfGroup);
+ }
}
status_t StreamInHalHidl::getFrameSize(size_t *size) {
@@ -396,17 +509,83 @@
status_t StreamInHalHidl::read(void *buffer, size_t bytes, size_t *read) {
if (mStream == 0) return NO_INIT;
+ *read = 0;
+
+ if (bytes == 0 && !mDataMQ) {
+ // Can't determine the size for the MQ buffer. Wait for a non-empty read request.
+ return OK;
+ }
+
+ status_t status;
+ if (!mDataMQ) {
+ if ((status = prepareForReading(bytes)) != OK) return status;
+ // Trigger the first read.
+ mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL));
+ }
+
+ // TODO: Remove manual event flag handling once blocking MQ is implemented. b/33815422
+ uint32_t efState = 0;
+retry:
+ status_t ret = mEfGroup->wait(
+ static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY), &efState, NS_PER_SEC);
+ if (efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY)) {
+ ReadStatus readStatus = { Result::NOT_INITIALIZED, 0 };
+ const size_t availToRead = mDataMQ->availableToRead();
+ if (bytes > availToRead) { bytes = availToRead; }
+ mDataMQ->read(static_cast<uint8_t*>(buffer), bytes);
+ mStatusMQ->read(&readStatus);
+ mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL));
+ if (readStatus.retval == Result::OK) {
+ ALOGW_IF(availToRead != readStatus.read,
+ "HAL read report inconsistent: mq = %d, status = %d",
+ (int32_t)availToRead, (int32_t)readStatus.read);
+ *read = readStatus.read;
+ } else {
+ status = processReturn("read", readStatus.retval);
+ }
+ return status;
+ }
+ if (ret == -EAGAIN) {
+ // This normally retries no more than once.
+ goto retry;
+ }
+ return ret;
+}
+
+status_t StreamInHalHidl::prepareForReading(size_t bufferSize) {
+ std::unique_ptr<DataMQ> tempDataMQ;
+ std::unique_ptr<StatusMQ> tempStatusMQ;
Result retval;
- Return<void> ret = mStream->read(
- bytes,
- [&](Result r, const hidl_vec<uint8_t>& hidlData) {
+ Return<void> ret = mStream->prepareForReading(
+ 1, bufferSize, ThreadPriority(mHalThreadPriority),
+ [&](Result r,
+ const MQDescriptorSync<uint8_t>& dataMQ,
+ const MQDescriptorSync<ReadStatus>& statusMQ) {
retval = r;
- *read = std::min(hidlData.size(), bytes);
if (retval == Result::OK) {
- memcpy(buffer, &hidlData[0], *read);
+ tempDataMQ.reset(new DataMQ(dataMQ));
+ tempStatusMQ.reset(new StatusMQ(statusMQ));
+ if (tempDataMQ->isValid() && tempDataMQ->getEventFlagWord()) {
+ EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(), &mEfGroup);
+ }
}
});
- return processReturn("read", ret, retval);
+ if (!ret.isOk() || retval != Result::OK) {
+ return processReturn("prepareForReading", ret, retval);
+ }
+ if (!tempDataMQ || !tempDataMQ->isValid() || !tempStatusMQ || !tempStatusMQ->isValid()
+ || !mEfGroup) {
+ ALOGE_IF(!tempDataMQ, "Failed to obtain data message queue for reading");
+ ALOGE_IF(tempDataMQ && !tempDataMQ->isValid(), "Data message queue for reading is invalid");
+ ALOGE_IF(!tempStatusMQ, "Failed to obtain status message queue for reading");
+ ALOGE_IF(tempStatusMQ && !tempStatusMQ->isValid(),
+ "Status message queue for reading is invalid");
+ ALOGE_IF(!mEfGroup, "Event flag creation for reading failed");
+ return NO_INIT;
+ }
+ mDataMQ = std::move(tempDataMQ);
+ mStatusMQ = std::move(tempStatusMQ);
+ return OK;
}
status_t StreamInHalHidl::getInputFramesLost(uint32_t *framesLost) {
diff --git a/media/libaudiohal/StreamHalHidl.h b/media/libaudiohal/StreamHalHidl.h
index 377acb4..0093957 100644
--- a/media/libaudiohal/StreamHalHidl.h
+++ b/media/libaudiohal/StreamHalHidl.h
@@ -20,6 +20,8 @@
#include <android/hardware/audio/2.0/IStream.h>
#include <android/hardware/audio/2.0/IStreamIn.h>
#include <android/hardware/audio/2.0/IStreamOut.h>
+#include <fmq/EventFlag.h>
+#include <fmq/MessageQueue.h>
#include <media/audiohal/StreamHalInterface.h>
#include "ConversionHelperHidl.h"
@@ -27,7 +29,11 @@
using ::android::hardware::audio::V2_0::IStream;
using ::android::hardware::audio::V2_0::IStreamIn;
using ::android::hardware::audio::V2_0::IStreamOut;
+using ::android::hardware::EventFlag;
+using ::android::hardware::MessageQueue;
using ::android::hardware::Return;
+using ReadStatus = ::android::hardware::audio::V2_0::IStreamIn::ReadStatus;
+using WriteStatus = ::android::hardware::audio::V2_0::IStreamOut::WriteStatus;
namespace android {
@@ -80,6 +86,10 @@
// Get current read/write position in the mmap buffer
virtual status_t getMmapPosition(struct audio_mmap_position *position);
+ // Set the priority of the thread that interacts with the HAL
+ // (must match the priority of the audioflinger's thread that calls 'read' / 'write')
+ virtual status_t setHalThreadPriority(int priority);
+
protected:
// Subclasses can not be constructed directly by clients.
explicit StreamHalHidl(IStream *stream);
@@ -87,6 +97,8 @@
// The destructor automatically closes the stream.
virtual ~StreamHalHidl();
+ int mHalThreadPriority;
+
private:
IStream *mStream;
};
@@ -143,14 +155,25 @@
private:
friend class DeviceHalHidl;
+ typedef MessageQueue<uint8_t, hardware::kSynchronizedReadWrite> DataMQ;
+ typedef MessageQueue<WriteStatus, hardware::kSynchronizedReadWrite> StatusMQ;
wp<StreamOutHalInterfaceCallback> mCallback;
sp<IStreamOut> mStream;
+ std::unique_ptr<DataMQ> mDataMQ;
+ std::unique_ptr<StatusMQ> mStatusMQ;
+ EventFlag* mEfGroup;
+ bool mGetPresentationPositionNotSupported;
+ uint64_t mPPosFromWriteObtained;
+ uint64_t mPPosFromWriteFrames;
+ struct timespec mPPosFromWriteTS;
// Can not be constructed directly by clients.
StreamOutHalHidl(const sp<IStreamOut>& stream);
virtual ~StreamOutHalHidl();
+
+ status_t prepareForWriting(size_t bufferSize);
};
class StreamInHalHidl : public StreamInHalInterface, public StreamHalHidl {
@@ -173,13 +196,20 @@
private:
friend class DeviceHalHidl;
+ typedef MessageQueue<uint8_t, hardware::kSynchronizedReadWrite> DataMQ;
+ typedef MessageQueue<ReadStatus, hardware::kSynchronizedReadWrite> StatusMQ;
sp<IStreamIn> mStream;
+ std::unique_ptr<DataMQ> mDataMQ;
+ std::unique_ptr<StatusMQ> mStatusMQ;
+ EventFlag* mEfGroup;
// Can not be constructed directly by clients.
StreamInHalHidl(const sp<IStreamIn>& stream);
virtual ~StreamInHalHidl();
+
+ status_t prepareForReading(size_t bufferSize);
};
} // namespace android
diff --git a/media/libaudiohal/StreamHalLocal.cpp b/media/libaudiohal/StreamHalLocal.cpp
index 61c8898..b25e518 100644
--- a/media/libaudiohal/StreamHalLocal.cpp
+++ b/media/libaudiohal/StreamHalLocal.cpp
@@ -96,6 +96,12 @@
return mStream->dump(mStream, fd);
}
+status_t StreamHalLocal::setHalThreadPriority(int) {
+ // Don't need to do anything as local hal is executed by audioflinger directly
+ // on the same thread.
+ return OK;
+}
+
StreamOutHalLocal::StreamOutHalLocal(audio_stream_out_t *stream, sp<DeviceHalLocal> device)
: StreamHalLocal(&stream->common, device), mStream(stream) {
}
diff --git a/media/libaudiohal/StreamHalLocal.h b/media/libaudiohal/StreamHalLocal.h
index fbb000a..8c96c1f 100644
--- a/media/libaudiohal/StreamHalLocal.h
+++ b/media/libaudiohal/StreamHalLocal.h
@@ -70,6 +70,10 @@
// Get current read/write position in the mmap buffer
virtual status_t getMmapPosition(struct audio_mmap_position *position) = 0;
+ // Set the priority of the thread that interacts with the HAL
+ // (must match the priority of the audioflinger's thread that calls 'read' / 'write')
+ virtual status_t setHalThreadPriority(int priority);
+
protected:
// Subclasses can not be constructed directly by clients.
StreamHalLocal(audio_stream_t *stream, sp<DeviceHalLocal> device);
diff --git a/media/libeffects/downmix/EffectDownmix.c b/media/libeffects/downmix/EffectDownmix.c
index 323930a..f27d5ca 100644
--- a/media/libeffects/downmix/EffectDownmix.c
+++ b/media/libeffects/downmix/EffectDownmix.c
@@ -22,7 +22,7 @@
#include <stdlib.h>
#include <string.h>
-#include <android/log.h>
+#include <log/log.h>
#include "EffectDownmix.h"
diff --git a/media/libeffects/factory/EffectsFactory.c b/media/libeffects/factory/EffectsFactory.c
index 74d489b..554c14d 100644
--- a/media/libeffects/factory/EffectsFactory.c
+++ b/media/libeffects/factory/EffectsFactory.c
@@ -24,10 +24,10 @@
#include <string.h>
#include <unistd.h>
-#include <android/log.h>
#include <cutils/config_utils.h>
#include <cutils/misc.h>
#include <cutils/properties.h>
+#include <log/log.h>
#include <system/audio_effects/audio_effects_conf.h>
diff --git a/media/libeffects/loudness/dsp/core/dynamic_range_compression-inl.h b/media/libeffects/loudness/dsp/core/dynamic_range_compression-inl.h
index 4f9f438..7ea0593 100644
--- a/media/libeffects/loudness/dsp/core/dynamic_range_compression-inl.h
+++ b/media/libeffects/loudness/dsp/core/dynamic_range_compression-inl.h
@@ -21,7 +21,7 @@
#endif
//#define LOG_NDEBUG 0
-#include <android/log.h>
+#include <log/log.h>
namespace le_fx {
diff --git a/media/libeffects/loudness/dsp/core/interpolator_base-inl.h b/media/libeffects/loudness/dsp/core/interpolator_base-inl.h
index bdb6818..fb87c79 100644
--- a/media/libeffects/loudness/dsp/core/interpolator_base-inl.h
+++ b/media/libeffects/loudness/dsp/core/interpolator_base-inl.h
@@ -21,7 +21,7 @@
#endif
//#define LOG_NDEBUG 0
-#include <android/log.h>
+#include <log/log.h>
#include "dsp/core/basic.h"
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
index f8a6a4e..d1ade1d 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
@@ -16,6 +16,9 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "NuPlayer"
+
+#include <inttypes.h>
+
#include <utils/Log.h>
#include "NuPlayer.h"
@@ -1287,6 +1290,8 @@
} else {
ALOGW("resume called when renderer is gone or not set");
}
+
+ mLastStartedPlayingTimeNs = systemTime();
}
status_t NuPlayer::onInstantiateSecureDecoders() {
@@ -1342,26 +1347,26 @@
flags |= Renderer::FLAG_REAL_TIME;
}
- sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
- sp<MetaData> videoMeta = mSource->getFormatMeta(false /* audio */);
- if (audioMeta == NULL && videoMeta == NULL) {
+ bool hasAudio = (mSource->getFormat(true /* audio */) != NULL);
+ bool hasVideo = (mSource->getFormat(false /* audio */) != NULL);
+ if (!hasAudio && !hasVideo) {
ALOGE("no metadata for either audio or video source");
mSource->stop();
mSourceStarted = false;
notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, ERROR_MALFORMED);
return;
}
- ALOGV_IF(audioMeta == NULL, "no metadata for audio source"); // video only stream
+ ALOGV_IF(!hasAudio, "no metadata for audio source"); // video only stream
+
+ sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
audio_stream_type_t streamType = AUDIO_STREAM_MUSIC;
if (mAudioSink != NULL) {
streamType = mAudioSink->getAudioStreamType();
}
- sp<AMessage> videoFormat = mSource->getFormat(false /* audio */);
-
mOffloadAudio =
- canOffloadStream(audioMeta, (videoFormat != NULL), mSource->isStreaming(), streamType)
+ canOffloadStream(audioMeta, hasVideo, mSource->isStreaming(), streamType)
&& (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
if (mOffloadAudio) {
flags |= Renderer::FLAG_OFFLOAD_AUDIO;
@@ -1396,6 +1401,8 @@
mAudioDecoder->setRenderer(mRenderer);
}
+ mLastStartedPlayingTimeNs = systemTime();
+
postScanSources();
}
@@ -1414,6 +1421,16 @@
} else {
ALOGW("pause called when renderer is gone or not set");
}
+
+ sp<NuPlayerDriver> driver = mDriver.promote();
+ if (driver != NULL) {
+ int64_t now = systemTime();
+ int64_t played = now - mLastStartedPlayingTimeNs;
+ ALOGD("played from %" PRId64 " to %" PRId64 " = %" PRId64 ,
+ mLastStartedPlayingTimeNs, now, played);
+
+ driver->notifyMorePlayingTimeUs((played+500)/1000);
+ }
}
bool NuPlayer::audioDecoderStillNeeded() {
@@ -1697,6 +1714,16 @@
notifyListener(MEDIA_SET_VIDEO_SIZE, 0, 0);
return;
}
+ int32_t err = OK;
+ inputFormat->findInt32("err", &err);
+ if (err == -EWOULDBLOCK) {
+ ALOGW("Video meta is not available yet!");
+ return;
+ }
+ if (err != OK) {
+ ALOGW("Something is wrong with video meta!");
+ return;
+ }
int32_t displayWidth, displayHeight;
if (outputFormat != NULL) {
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.h b/media/libmediaplayerservice/nuplayer/NuPlayer.h
index c8b0102..6f737bb 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayer.h
+++ b/media/libmediaplayerservice/nuplayer/NuPlayer.h
@@ -158,6 +158,8 @@
int32_t mVideoDecoderGeneration;
int32_t mRendererGeneration;
+ int64_t mLastStartedPlayingTimeNs;
+
int64_t mPreviousSeekTimeUs;
List<sp<Action> > mDeferredActions;
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
index 6ec79e6..f7e56e4 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
@@ -31,8 +31,14 @@
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
+#include <media/IMediaAnalyticsService.h>
+
+static const int kDumpLockRetries = 50;
+static const int kDumpLockSleepUs = 20000;
+
namespace android {
+
NuPlayerDriver::NuPlayerDriver(pid_t pid)
: mState(STATE_IDLE),
mIsAsyncPrepare(false),
@@ -41,14 +47,20 @@
mDurationUs(-1),
mPositionUs(-1),
mSeekInProgress(false),
+ mPlayingTimeUs(0),
mLooper(new ALooper),
mPlayerFlags(0),
+ mAnalyticsItem(NULL),
mAtEOS(false),
mLooping(false),
mAutoLoop(false) {
- ALOGV("NuPlayerDriver(%p)", this);
+ ALOGD("NuPlayerDriver(%p) created, clientPid(%d)", this, pid);
mLooper->setName("NuPlayerDriver Looper");
+ // set up an analytics record
+ mAnalyticsItem = new MediaAnalyticsItem("nuplayer");
+ mAnalyticsItem->generateSessionID();
+
mLooper->start(
false, /* runOnCallingThread */
true, /* canCallJava */
@@ -63,6 +75,15 @@
NuPlayerDriver::~NuPlayerDriver() {
ALOGV("~NuPlayerDriver(%p)", this);
mLooper->stop();
+
+ // finalize any pending metrics, usually a no-op.
+ finalizeMetrics("destructor");
+ logMetrics("destructor");
+
+ if (mAnalyticsItem != NULL) {
+ delete mAnalyticsItem;
+ mAnalyticsItem = NULL;
+ }
}
status_t NuPlayerDriver::initCheck() {
@@ -450,8 +471,103 @@
return OK;
}
+void NuPlayerDriver::finalizeMetrics(const char *where) {
+ if (where == NULL) {
+ where = "unknown";
+ }
+ ALOGD("finalizeMetrics(%p) from %s at state %d", this, where, mState);
+
+ // gather the final stats for this record
+ Vector<sp<AMessage>> trackStats;
+ mPlayer->getStats(&trackStats);
+
+ if (trackStats.size() > 0) {
+ for (size_t i = 0; i < trackStats.size(); ++i) {
+ const sp<AMessage> &stats = trackStats.itemAt(i);
+
+ AString mime;
+ stats->findString("mime", &mime);
+
+ AString name;
+ stats->findString("component-name", &name);
+
+ if (mime.startsWith("video/")) {
+ int32_t width, height;
+ mAnalyticsItem->setCString("video/mime", mime.c_str());
+ if (!name.empty()) {
+ mAnalyticsItem->setCString("video/codec", name.c_str());
+ }
+
+ if (stats->findInt32("width", &width)
+ && stats->findInt32("height", &height)) {
+ mAnalyticsItem->setInt32("wid", width);
+ mAnalyticsItem->setInt32("ht", height);
+ }
+
+ int64_t numFramesTotal = 0;
+ int64_t numFramesDropped = 0;
+ stats->findInt64("frames-total", &numFramesTotal);
+ stats->findInt64("frames-dropped-output", &numFramesDropped);
+
+ mAnalyticsItem->setInt64("frames", numFramesTotal);
+ mAnalyticsItem->setInt64("dropped", numFramesDropped);
+
+
+ } else if (mime.startsWith("audio/")) {
+ mAnalyticsItem->setCString("audio/mime", mime.c_str());
+ if (!name.empty()) {
+ mAnalyticsItem->setCString("audio/codec", name.c_str());
+ }
+ }
+ }
+
+ // getDuration() uses mLock for mutex -- careful where we use it.
+ int duration_ms = -1;
+ getDuration(&duration_ms);
+ if (duration_ms != -1) {
+ mAnalyticsItem->setInt64("duration", duration_ms);
+ }
+
+ if (mPlayingTimeUs > 0) {
+ mAnalyticsItem->setInt64("playing", (mPlayingTimeUs+500)/1000 );
+ }
+ }
+}
+
+
+void NuPlayerDriver::logMetrics(const char *where) {
+ if (where == NULL) {
+ where = "unknown";
+ }
+ ALOGD("logMetrics(%p) from %s at state %d", this, where, mState);
+
+ if (mAnalyticsItem == NULL || mAnalyticsItem->isEnabled() == false) {
+ return;
+ }
+
+ // only bother to log non-empty records
+ if (mAnalyticsItem->count() > 0) {
+
+ mAnalyticsItem->setFinalized(true);
+ mAnalyticsItem->selfrecord();
+
+ // re-init in case we prepare() and start() again.
+ delete mAnalyticsItem ;
+ mAnalyticsItem = new MediaAnalyticsItem("nuplayer");
+ if (mAnalyticsItem) {
+ mAnalyticsItem->generateSessionID();
+ }
+ } else {
+ ALOGV("did not have anything to record");
+ }
+}
+
status_t NuPlayerDriver::reset() {
ALOGD("reset(%p) at state %d", this, mState);
+
+ finalizeMetrics("reset");
+ logMetrics("reset");
+
Mutex::Autolock autoLock(mLock);
switch (mState) {
@@ -493,6 +609,7 @@
mDurationUs = -1;
mPositionUs = -1;
mLooping = false;
+ mPlayingTimeUs = 0;
return OK;
}
@@ -624,6 +741,11 @@
mDurationUs = durationUs;
}
+void NuPlayerDriver::notifyMorePlayingTimeUs(int64_t playingUs) {
+ Mutex::Autolock autoLock(mLock);
+ mPlayingTimeUs += playingUs;
+}
+
void NuPlayerDriver::notifySeekComplete() {
ALOGV("notifySeekComplete(%p)", this);
Mutex::Autolock autoLock(mLock);
@@ -657,6 +779,24 @@
AString logString(" NuPlayer\n");
char buf[256] = {0};
+ bool locked = false;
+ for (int i = 0; i < kDumpLockRetries; ++i) {
+ if (mLock.tryLock() == NO_ERROR) {
+ locked = true;
+ break;
+ }
+ usleep(kDumpLockSleepUs);
+ }
+
+ if (locked) {
+ snprintf(buf, sizeof(buf), " state(%d), atEOS(%d), looping(%d), autoLoop(%d)\n",
+ mState, mAtEOS, mLooping, mAutoLoop);
+ mLock.unlock();
+ } else {
+ snprintf(buf, sizeof(buf), " NPD(%p) lock is taken\n", this);
+ }
+ logString.append(buf);
+
for (size_t i = 0; i < trackStats.size(); ++i) {
const sp<AMessage> &stats = trackStats.itemAt(i);
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.h b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.h
index 317b34c..9b784ae 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.h
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.h
@@ -16,6 +16,7 @@
#include <media/MediaPlayerInterface.h>
+#include <media/MediaAnalyticsItem.h>
#include <media/stagefright/foundation/ABase.h>
namespace android {
@@ -75,6 +76,7 @@
void notifyResetComplete();
void notifySetSurfaceComplete();
void notifyDuration(int64_t durationUs);
+ void notifyMorePlayingTimeUs(int64_t timeUs);
void notifySeekComplete();
void notifySeekComplete_l();
void notifyListener(int msg, int ext1 = 0, int ext2 = 0, const Parcel *in = NULL);
@@ -112,6 +114,7 @@
int64_t mDurationUs;
int64_t mPositionUs;
bool mSeekInProgress;
+ int64_t mPlayingTimeUs;
// <<<
sp<ALooper> mLooper;
@@ -119,10 +122,15 @@
sp<AudioSink> mAudioSink;
uint32_t mPlayerFlags;
+ MediaAnalyticsItem *mAnalyticsItem;
+
bool mAtEOS;
bool mLooping;
bool mAutoLoop;
+ void finalizeMetrics(const char *where);
+ void logMetrics(const char *where);
+
status_t prepare_l();
status_t start_l();
void notifyListener_l(int msg, int ext1 = 0, int ext2 = 0, const Parcel *in = NULL);
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerSource.h b/media/libmediaplayerservice/nuplayer/NuPlayerSource.h
index 5197167..6006730 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerSource.h
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerSource.h
@@ -77,7 +77,11 @@
// an error or ERROR_END_OF_STREAM if not.
virtual status_t feedMoreTSData() = 0;
+ // Returns non-NULL format when the specified track exists.
+ // When the format has "err" set to -EWOULDBLOCK, source needs more time to get valid meta data.
+ // Returns NULL if the specified track doesn't exist or is invalid;
virtual sp<AMessage> getFormat(bool audio);
+
virtual sp<MetaData> getFormatMeta(bool /* audio */) { return NULL; }
virtual sp<MetaData> getFileFormatMeta() const { return NULL; }
diff --git a/media/libmediaplayerservice/nuplayer/StreamingSource.cpp b/media/libmediaplayerservice/nuplayer/StreamingSource.cpp
index 7f9f913..d6b1e8c 100644
--- a/media/libmediaplayerservice/nuplayer/StreamingSource.cpp
+++ b/media/libmediaplayerservice/nuplayer/StreamingSource.cpp
@@ -234,8 +234,7 @@
}
status_t err = convertMetaDataToMessage(meta, &format);
if (err != OK) { // format may have been cleared on error
- format = new AMessage;
- format->setInt32("err", err);
+ return NULL;
}
return format;
}
diff --git a/media/libnbaio/NBLog.cpp b/media/libnbaio/NBLog.cpp
index c728e3e..f019df5 100644
--- a/media/libnbaio/NBLog.cpp
+++ b/media/libnbaio/NBLog.cpp
@@ -23,7 +23,7 @@
#include <string.h>
#include <time.h>
#include <new>
-#include <cutils/atomic.h>
+#include <audio_utils/roundup.h>
#include <media/nbaio/NBLog.h>
#include <utils/Log.h>
#include <utils/String8.h>
@@ -74,19 +74,30 @@
// ---------------------------------------------------------------------------
NBLog::Writer::Writer()
- : mSize(0), mShared(NULL), mRear(0), mEnabled(false)
+ : mShared(NULL), mFifo(NULL), mFifoWriter(NULL), mEnabled(false)
{
}
-NBLog::Writer::Writer(size_t size, void *shared)
- : mSize(roundup(size)), mShared((Shared *) shared), mRear(0), mEnabled(mShared != NULL)
+NBLog::Writer::Writer(void *shared, size_t size)
+ : mShared((Shared *) shared),
+ mFifo(mShared != NULL ?
+ new audio_utils_fifo(size, sizeof(uint8_t),
+ mShared->mBuffer, mShared->mRear, NULL /*throttlesFront*/) : NULL),
+ mFifoWriter(mFifo != NULL ? new audio_utils_fifo_writer(*mFifo) : NULL),
+ mEnabled(mFifoWriter != NULL)
{
}
-NBLog::Writer::Writer(size_t size, const sp<IMemory>& iMemory)
- : mSize(roundup(size)), mShared(iMemory != 0 ? (Shared *) iMemory->pointer() : NULL),
- mIMemory(iMemory), mRear(0), mEnabled(mShared != NULL)
+NBLog::Writer::Writer(const sp<IMemory>& iMemory, size_t size)
+ : Writer(iMemory != 0 ? (Shared *) iMemory->pointer() : NULL, size)
{
+ mIMemory = iMemory;
+}
+
+NBLog::Writer::~Writer()
+{
+ delete mFifoWriter;
+ delete mFifo;
}
void NBLog::Writer::log(const char *string)
@@ -95,8 +106,8 @@
return;
}
size_t length = strlen(string);
- if (length > 255) {
- length = 255;
+ if (length > Entry::kMaxLength) {
+ length = Entry::kMaxLength;
}
log(EVENT_STRING, string, length);
}
@@ -117,7 +128,7 @@
if (!mEnabled) {
return;
}
- char buffer[256];
+ char buffer[Entry::kMaxLength + 1 /*NUL*/];
int length = vsnprintf(buffer, sizeof(buffer), fmt, ap);
if (length >= (int) sizeof(buffer)) {
length = sizeof(buffer) - 1;
@@ -153,7 +164,10 @@
if (!mEnabled) {
return;
}
- if (data == NULL || length > 255) {
+ if (data == NULL || length > Entry::kMaxLength) {
+ // TODO Perhaps it makes sense to display truncated data or at least a
+ // message that the data is too long? The current behavior can create
+ // a confusion for a programmer debugging their code.
return;
}
switch (event) {
@@ -177,26 +191,16 @@
log(entry->mEvent, entry->mData, entry->mLength);
return;
}
- size_t rear = mRear & (mSize - 1);
- size_t written = mSize - rear; // written = number of bytes that have been written so far
- size_t need = entry->mLength + 3; // mEvent, mLength, data[length], mLength
- // need = number of bytes remaining to write
- if (written > need) {
- written = need;
- }
- size_t i;
+ size_t need = entry->mLength + Entry::kOverhead; // mEvent, mLength, data[length], mLength
+ // need = number of bytes remaining to write
+
// FIXME optimize this using memcpy for the data part of the Entry.
// The Entry could have a method copyTo(ptr, offset, size) to optimize the copy.
- for (i = 0; i < written; ++i) {
- mShared->mBuffer[rear + i] = entry->readAt(i);
+ uint8_t temp[Entry::kMaxLength + Entry::kOverhead];
+ for (size_t i = 0; i < need; i++) {
+ temp[i] = entry->readAt(i);
}
- if (rear + written == mSize && (need -= written) > 0) {
- for (i = 0; i < need; ++i) {
- mShared->mBuffer[i] = entry->readAt(written + i);
- }
- written += need;
- }
- android_atomic_release_store(mRear += written, &mShared->mRear);
+ mFifoWriter->write(temp, need);
}
bool NBLog::Writer::isEnabled() const
@@ -218,8 +222,8 @@
{
}
-NBLog::LockedWriter::LockedWriter(size_t size, void *shared)
- : Writer(size, shared)
+NBLog::LockedWriter::LockedWriter(void *shared, size_t size)
+ : Writer(shared, size)
{
}
@@ -273,60 +277,59 @@
// ---------------------------------------------------------------------------
-NBLog::Reader::Reader(size_t size, const void *shared)
- : mSize(roundup(size)), mShared((const Shared *) shared), mFront(0)
+NBLog::Reader::Reader(const void *shared, size_t size)
+ : mShared((/*const*/ Shared *) shared), /*mIMemory*/
+ mFd(-1), mIndent(0),
+ mFifo(mShared != NULL ?
+ new audio_utils_fifo(size, sizeof(uint8_t),
+ mShared->mBuffer, mShared->mRear, NULL /*throttlesFront*/) : NULL),
+ mFifoReader(mFifo != NULL ? new audio_utils_fifo_reader(*mFifo) : NULL)
{
}
-NBLog::Reader::Reader(size_t size, const sp<IMemory>& iMemory)
- : mSize(roundup(size)), mShared(iMemory != 0 ? (const Shared *) iMemory->pointer() : NULL),
- mIMemory(iMemory), mFront(0)
+NBLog::Reader::Reader(const sp<IMemory>& iMemory, size_t size)
+ : Reader(iMemory != 0 ? (Shared *) iMemory->pointer() : NULL, size)
{
+ mIMemory = iMemory;
+}
+
+NBLog::Reader::~Reader()
+{
+ delete mFifoReader;
+ delete mFifo;
}
void NBLog::Reader::dump(int fd, size_t indent)
{
- int32_t rear = android_atomic_acquire_load(&mShared->mRear);
- size_t avail = rear - mFront;
- if (avail == 0) {
+ if (mFifoReader == NULL) {
return;
}
- size_t lost = 0;
- if (avail > mSize) {
- lost = avail - mSize;
- mFront += lost;
- avail = mSize;
- }
- size_t remaining = avail; // remaining = number of bytes left to read
- size_t front = mFront & (mSize - 1);
- size_t read = mSize - front; // read = number of bytes that have been read so far
- if (read > remaining) {
- read = remaining;
- }
// make a copy to avoid race condition with writer
- uint8_t *copy = new uint8_t[avail];
- // copy first part of circular buffer up until the wraparound point
- memcpy(copy, &mShared->mBuffer[front], read);
- if (front + read == mSize) {
- if ((remaining -= read) > 0) {
- // copy second part of circular buffer starting at beginning
- memcpy(©[read], mShared->mBuffer, remaining);
- read += remaining;
- // remaining = 0 but not necessary
- }
- }
- mFront += read;
+ size_t capacity = mFifo->capacity();
+
+ // TODO Stack-based allocation of large objects may fail.
+ // Currently the log buffers are a page or two, which should be safe.
+ // But if the log buffers ever get a lot larger,
+ // then change this to allocate from heap when necessary.
+ static size_t kReasonableStackObjectSize = 32768;
+ ALOGW_IF(capacity > kReasonableStackObjectSize, "Stack-based allocation of object may fail");
+ uint8_t copy[capacity];
+
+ size_t lost;
+ ssize_t actual = mFifoReader->read(copy, capacity, NULL /*timeout*/, &lost);
+ ALOG_ASSERT(actual <= capacity);
+ size_t avail = actual > 0 ? (size_t) actual : 0;
size_t i = avail;
Event event;
size_t length;
struct timespec ts;
time_t maxSec = -1;
- while (i >= 3) {
+ while (i >= Entry::kOverhead) {
length = copy[i - 1];
- if (length + 3 > i || copy[i - length - 2] != length) {
+ if (length + Entry::kOverhead > i || copy[i - length - 2] != length) {
break;
}
- event = (Event) copy[i - length - 3];
+ event = (Event) copy[i - length - Entry::kOverhead];
if (event == EVENT_TIMESTAMP) {
if (length != sizeof(struct timespec)) {
// corrupt
@@ -337,7 +340,7 @@
maxSec = ts.tv_sec;
}
}
- i -= length + 3;
+ i -= length + Entry::kOverhead;
}
mFd = fd;
mIndent = indent;
@@ -362,7 +365,7 @@
event = (Event) copy[i];
length = copy[i + 1];
const void *data = ©[i + 2];
- size_t advance = length + 3;
+ size_t advance = length + Entry::kOverhead;
switch (event) {
case EVENT_STRING:
body.appendFormat("%.*s", (int) length, (const char *) data);
@@ -376,7 +379,7 @@
long deltaTotal = 0;
size_t j = i;
for (;;) {
- j += sizeof(struct timespec) + 3;
+ j += sizeof(struct timespec) + 3 /*Entry::kOverhead?*/;
if (j >= avail || (Event) copy[j] != EVENT_TIMESTAMP) {
break;
}
@@ -398,7 +401,7 @@
deltaTotal += delta;
prevNsec = tsNext.tv_nsec;
}
- size_t n = (j - i) / (sizeof(struct timespec) + 3);
+ size_t n = (j - i) / (sizeof(struct timespec) + 3 /*Entry::kOverhead?*/);
if (deferredTimestamp) {
dumpLine(timestamp, body);
deferredTimestamp = false;
@@ -432,8 +435,6 @@
if (deferredTimestamp) {
dumpLine(timestamp, body);
}
- // FIXME it would be more efficient to put a char mCopy[256] as a member variable of the dumper
- delete[] copy;
}
void NBLog::Reader::dumpLine(const String8& timestamp, String8& body)
diff --git a/media/liboboe/Android.bp b/media/liboboe/Android.bp
index 0d22e65..bfcc049 100644
--- a/media/liboboe/Android.bp
+++ b/media/liboboe/Android.bp
@@ -24,4 +24,5 @@
name: "liboboe.ndk",
symbol_file: "liboboe.map.txt",
first_version: "26",
+ unversioned_until: "current",
}
diff --git a/media/libstagefright/MPEG4Writer.cpp b/media/libstagefright/MPEG4Writer.cpp
old mode 100644
new mode 100755
index 0d61bf5..ac15687
--- a/media/libstagefright/MPEG4Writer.cpp
+++ b/media/libstagefright/MPEG4Writer.cpp
@@ -3260,8 +3260,8 @@
mOwner->writeInt32(0);
} else {
int32_t width, height;
- bool success = mMeta->findInt32(kKeyWidth, &width);
- success = success && mMeta->findInt32(kKeyHeight, &height);
+ bool success = mMeta->findInt32(kKeyDisplayWidth, &width);
+ success = success && mMeta->findInt32(kKeyDisplayHeight, &height);
CHECK(success);
mOwner->writeInt32(width << 16); // 32-bit fixed-point value
@@ -3309,13 +3309,22 @@
void MPEG4Writer::Track::writeMdhdBox(uint32_t now) {
int64_t trakDurationUs = getDurationUs();
+ int64_t mdhdDuration = (trakDurationUs * mTimeScale + 5E5) / 1E6;
mOwner->beginBox("mdhd");
- mOwner->writeInt32(0); // version=0, flags=0
- mOwner->writeInt32(now); // creation time
- mOwner->writeInt32(now); // modification time
- mOwner->writeInt32(mTimeScale); // media timescale
- int32_t mdhdDuration = (trakDurationUs * mTimeScale + 5E5) / 1E6;
- mOwner->writeInt32(mdhdDuration); // use media timescale
+
+ if (mdhdDuration > UINT32_MAX) {
+ mOwner->writeInt32((1 << 24)); // version=1, flags=0
+ mOwner->writeInt64((int64_t)now); // creation time
+ mOwner->writeInt64((int64_t)now); // modification time
+ mOwner->writeInt32(mTimeScale); // media timescale
+ mOwner->writeInt64(mdhdDuration); // media timescale
+ } else {
+ mOwner->writeInt32(0); // version=0, flags=0
+ mOwner->writeInt32(now); // creation time
+ mOwner->writeInt32(now); // modification time
+ mOwner->writeInt32(mTimeScale); // media timescale
+ mOwner->writeInt32((int32_t)mdhdDuration); // use media timescale
+ }
// Language follows the three letter standard ISO-639-2/T
// 'e', 'n', 'g' for "English", for instance.
// Each character is packed as the difference between its ASCII value and 0x60.
diff --git a/media/libstagefright/MediaCodec.cpp b/media/libstagefright/MediaCodec.cpp
index 24f0d20..9eca982 100644
--- a/media/libstagefright/MediaCodec.cpp
+++ b/media/libstagefright/MediaCodec.cpp
@@ -2623,14 +2623,7 @@
info->mData->meta()->setInt32("csd", true);
}
- // synchronization boundary for getBufferAndFormat
- sp<MediaCodecBuffer> buffer;
- {
- Mutex::Autolock al(mBufferLock);
- info->mOwnedByClient = false;
- buffer = info->mData;
- info->mData.clear();
- }
+ sp<MediaCodecBuffer> buffer = info->mData;
status_t err = OK;
if (mCrypto != NULL) {
AString *errorDetailMsg;
@@ -2650,6 +2643,13 @@
err = mBufferChannel->queueInputBuffer(buffer);
}
+ if (err == OK) {
+ // synchronization boundary for getBufferAndFormat
+ Mutex::Autolock al(mBufferLock);
+ info->mOwnedByClient = false;
+ info->mData.clear();
+ }
+
return err;
}
diff --git a/media/libstagefright/MediaCodecSource.cpp b/media/libstagefright/MediaCodecSource.cpp
index de4d06f..5981b35 100644
--- a/media/libstagefright/MediaCodecSource.cpp
+++ b/media/libstagefright/MediaCodecSource.cpp
@@ -689,7 +689,9 @@
sp<MediaCodecBuffer> inbuf;
status_t err = mEncoder->getInputBuffer(bufferIndex, &inbuf);
- if (err != OK || inbuf == NULL) {
+
+ if (err != OK || inbuf == NULL || inbuf->data() == NULL
+ || mbuf->data() == NULL || mbuf->size() == 0) {
mbuf->release();
signalEOS();
break;
@@ -851,7 +853,8 @@
sp<MediaCodecBuffer> outbuf;
status_t err = mEncoder->getOutputBuffer(index, &outbuf);
- if (err != OK || outbuf == NULL) {
+ if (err != OK || outbuf == NULL || outbuf->data() == NULL
+ || outbuf->size() == 0) {
signalEOS();
break;
}
diff --git a/media/libstagefright/codecs/amrnb/dec/src/a_refl.cpp b/media/libstagefright/codecs/amrnb/dec/src/a_refl.cpp
index 9d9cd3b..5a47510 100644
--- a/media/libstagefright/codecs/amrnb/dec/src/a_refl.cpp
+++ b/media/libstagefright/codecs/amrnb/dec/src/a_refl.cpp
@@ -60,7 +60,7 @@
; INCLUDES
----------------------------------------------------------------------------*/
#define LOG_TAG "a_refl"
-#include <android/log.h>
+#include <log/log.h>
#include "a_refl.h"
#include "typedef.h"
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/conceal.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/conceal.cpp
index 5baa2a2..8393d79 100644
--- a/media/libstagefright/codecs/m4v_h263/dec/src/conceal.cpp
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/conceal.cpp
@@ -18,7 +18,7 @@
#define LOG_TAG "conceal"
-#include "android/log.h"
+#include "log/log.h"
#include "mp4dec_lib.h" /* video decoder function prototypes */
#include "vlc_decode.h"
diff --git a/media/libstagefright/omx/hal/1.0/Conversion.h b/media/libstagefright/omx/hal/1.0/Conversion.h
index 44d2c84..d42e5bf 100644
--- a/media/libstagefright/omx/hal/1.0/Conversion.h
+++ b/media/libstagefright/omx/hal/1.0/Conversion.h
@@ -2,7 +2,6 @@
#define ANDROID_HARDWARE_MEDIA_OMX_V1_0__CONVERSION_H
#include <hidl/MQDescriptor.h>
-#include <hidl/Status.h>
#include <unistd.h>
#include <vector>
@@ -147,13 +146,13 @@
*/
/**
- * \brief Convert `binder::Status` to `hardware::Status`.
+ * \brief Convert `binder::Status` to `Return<void>`.
*
* \param[in] l The source `binder::Status`.
- * \return The corresponding `hardware::Status`.
+ * \return The corresponding `Return<void>`.
*/
-// convert: ::android::binder::Status -> ::android::hardware::Status
-inline ::android::hardware::Status toHardwareStatus(
+// convert: ::android::binder::Status -> Return<void>
+inline Return<void> toHardwareStatus(
::android::binder::Status const& l) {
if (l.exceptionCode() == ::android::binder::Status::EX_SERVICE_SPECIFIC) {
return ::android::hardware::Status::fromServiceSpecificError(
@@ -166,36 +165,17 @@
}
/**
- * \brief Convert `hardware::Status` to `binder::Status`.
+ * \brief Convert `Return<void>` to `binder::Status`.
*
- * \param[in] t The source `hardware::Status`.
+ * \param[in] t The source `Return<void>`.
* \return The corresponding `binder::Status`.
*/
-// convert: ::android::hardware::Status -> ::android::binder::Status
+// convert: Return<void> -> ::android::binder::Status
inline ::android::binder::Status toBinderStatus(
- ::android::hardware::Status const& t) {
- if (t.exceptionCode() == ::android::hardware::Status::EX_SERVICE_SPECIFIC) {
- return ::android::binder::Status::fromServiceSpecificError(
- t.serviceSpecificErrorCode(),
- t.exceptionMessage());
- }
+ Return<void> const& t) {
return ::android::binder::Status::fromExceptionCode(
- t.exceptionCode(),
- t.exceptionMessage());
-}
-
-/**
- * \brief Convert `hardware::Return<void>` to `binder::Status`.
- *
- * \param[in] t The source `hardware::Return<void>`.
- * \return The corresponding `binder::Status`.
- *
- * This function simply calls `toBinderStatus(::android::hardware::Status
- * const&)`.
- */
-// convert: ::android::hardware::Return<void> -> ::android::binder::Status
-inline ::android::binder::Status toBinderStatus(Return<void> const& t) {
- return toBinderStatus(t.getStatus());
+ t.isOk() ? OK : UNKNOWN_ERROR,
+ t.description().c_str());
}
/**
@@ -215,8 +195,7 @@
*/
// convert: Status -> status_t
inline status_t toStatusT(Return<Status> const& t) {
- return t.isOk() ? static_cast<status_t>(static_cast<Status>(t)) :
- t.getStatus().transactionError();
+ return t.isOk() ? static_cast<status_t>(static_cast<Status>(t)) : UNKNOWN_ERROR;
}
/**
@@ -227,7 +206,7 @@
*/
// convert: Return<void> -> status_t
inline status_t toStatusT(Return<void> const& t) {
- return t.getStatus().transactionError();
+ return t.isOk() ? OK : UNKNOWN_ERROR;
}
/**
diff --git a/media/ndk/Android.bp b/media/ndk/Android.bp
index 1ac1eeb..e4e3d8f 100644
--- a/media/ndk/Android.bp
+++ b/media/ndk/Android.bp
@@ -20,4 +20,5 @@
name: "libmediandk.ndk",
symbol_file: "libmediandk.map.txt",
first_version: "21",
+ unversioned_until: "current",
}
diff --git a/radio/IRadio.cpp b/radio/IRadio.cpp
index ebf3859..5bbe7cb 100644
--- a/radio/IRadio.cpp
+++ b/radio/IRadio.cpp
@@ -172,16 +172,11 @@
virtual status_t getProgramInformation(struct radio_program_info *info)
{
Parcel data, reply;
- if (info == NULL) {
+ if (info == nullptr || info->metadata == nullptr) {
return BAD_VALUE;
}
radio_metadata_t *metadata = info->metadata;
data.writeInterfaceToken(IRadio::getInterfaceDescriptor());
- if (metadata != NULL) {
- data.writeUint32(1);
- } else {
- data.writeUint32(0);
- }
status_t status = remote()->transact(GET_PROGRAM_INFORMATION, data, &reply);
if (status == NO_ERROR) {
status = (status_t)reply.readInt32();
@@ -190,13 +185,13 @@
// restore local metadata pointer
info->metadata = metadata;
- uint32_t metatataSize = reply.readUint32();
- if ((metadata != NULL) && (metatataSize != 0)) {
- radio_metadata_t *newMetadata = (radio_metadata_t *)malloc(metatataSize);
+ uint32_t metadataSize = reply.readUint32();
+ if (metadataSize != 0) {
+ radio_metadata_t *newMetadata = (radio_metadata_t *)malloc(metadataSize);
if (newMetadata == NULL) {
return NO_MEMORY;
}
- reply.read(newMetadata, metatataSize);
+ reply.read(newMetadata, metadataSize);
status = radio_metadata_add_metadata(&info->metadata, newMetadata);
free(newMetadata);
}
@@ -306,21 +301,17 @@
CHECK_INTERFACE(IRadio, data, reply);
struct radio_program_info info;
status_t status;
- // query metadata only if requested by remote side
- if (data.readUint32() == 1) {
- status = radio_metadata_allocate(&info.metadata, 0, 0);
- if (status != NO_ERROR) {
- return status;
- }
- } else {
- info.metadata = NULL;
+
+ status = radio_metadata_allocate(&info.metadata, 0, 0);
+ if (status != NO_ERROR) {
+ return status;
}
status = getProgramInformation(&info);
reply->writeInt32(status);
if (status == NO_ERROR) {
reply->write(&info, sizeof(struct radio_program_info));
- if ((info.metadata != NULL) && (radio_metadata_get_count(info.metadata) > 0)) {
+ if (radio_metadata_get_count(info.metadata) > 0) {
size_t size = radio_metadata_get_size(info.metadata);
reply->writeUint32((uint32_t)size);
reply->write(info.metadata, size);
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index d08309b..e4b73c6 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -512,8 +512,11 @@
return new NBLog::Writer();
}
success:
+ NBLog::Shared *sharedRawPtr = (NBLog::Shared *) shared->pointer();
+ new((void *) sharedRawPtr) NBLog::Shared(); // placement new here, but the corresponding
+ // explicit destructor not needed since it is POD
mediaLogService->registerWriter(shared, size, name);
- return new NBLog::Writer(size, shared);
+ return new NBLog::Writer(shared, size);
}
void AudioFlinger::unregisterWriter(const sp<NBLog::Writer>& writer)
diff --git a/services/audioflinger/AudioResampler.cpp b/services/audioflinger/AudioResampler.cpp
index 43624a0..8b7259d 100644
--- a/services/audioflinger/AudioResampler.cpp
+++ b/services/audioflinger/AudioResampler.cpp
@@ -22,8 +22,8 @@
#include <stdlib.h>
#include <sys/types.h>
-#include <android/log.h>
#include <cutils/properties.h>
+#include <log/log.h>
#include <audio_utils/primitives.h>
#include "AudioResampler.h"
diff --git a/services/audioflinger/AudioResamplerCubic.cpp b/services/audioflinger/AudioResamplerCubic.cpp
index d27dce7..9fb6699 100644
--- a/services/audioflinger/AudioResamplerCubic.cpp
+++ b/services/audioflinger/AudioResamplerCubic.cpp
@@ -19,7 +19,8 @@
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
-#include <android/log.h>
+
+#include <log/log.h>
#include "AudioResampler.h"
#include "AudioResamplerCubic.h"
diff --git a/services/audioflinger/AudioResamplerDyn.cpp b/services/audioflinger/AudioResamplerDyn.cpp
index 21914b9..8f7b982 100644
--- a/services/audioflinger/AudioResamplerDyn.cpp
+++ b/services/audioflinger/AudioResamplerDyn.cpp
@@ -29,9 +29,10 @@
#include <utils/Log.h>
#include <audio_utils/primitives.h>
-#include "AudioResamplerFirOps.h" // USE_NEON and USE_INLINE_ASSEMBLY defined here
+#include "AudioResamplerFirOps.h" // USE_NEON, USE_SSE and USE_INLINE_ASSEMBLY defined here
#include "AudioResamplerFirProcess.h"
#include "AudioResamplerFirProcessNeon.h"
+#include "AudioResamplerFirProcessSSE.h"
#include "AudioResamplerFirGen.h" // requires math.h
#include "AudioResamplerDyn.h"
diff --git a/services/audioflinger/AudioResamplerFirOps.h b/services/audioflinger/AudioResamplerFirOps.h
index 2a26496..2e4cee3 100644
--- a/services/audioflinger/AudioResamplerFirOps.h
+++ b/services/audioflinger/AudioResamplerFirOps.h
@@ -36,6 +36,13 @@
#include <arm_neon.h>
#endif
+#if defined(__SSSE3__) // Should be supported in x86 ABI for both 32 & 64-bit.
+#define USE_SSE (true)
+#include <tmmintrin.h>
+#else
+#define USE_SSE (false)
+#endif
+
template<typename T, typename U>
struct is_same
{
@@ -119,7 +126,7 @@
static inline
int32_t mulAddRL(int left, uint32_t inRL, int16_t v, int32_t a)
{
-#if USE_INLINE_ASSEMBLY
+#if 0 // USE_INLINE_ASSEMBLY Seems to fail with Clang b/34110890
int32_t out;
if (left) {
asm( "smlabb %[out], %[v], %[inRL], %[a] \n"
@@ -142,7 +149,7 @@
static inline
int32_t mulAddRL(int left, uint32_t inRL, int32_t v, int32_t a)
{
-#if USE_INLINE_ASSEMBLY
+#if 0 // USE_INLINE_ASSEMBLY Seems to fail with Clang b/34110890
int32_t out;
if (left) {
asm( "smlawb %[out], %[v], %[inRL], %[a] \n"
diff --git a/services/audioflinger/AudioResamplerFirProcessNeon.h b/services/audioflinger/AudioResamplerFirProcessNeon.h
index 3de9edd..1ce76a8 100644
--- a/services/audioflinger/AudioResamplerFirProcessNeon.h
+++ b/services/audioflinger/AudioResamplerFirProcessNeon.h
@@ -155,8 +155,8 @@
accum2 = vmlal_s16(accum2, vget_low_s16(negSamp.val[1]), vget_low_s16(negCoef));
accum2 = vmlal_s16(accum2, vget_high_s16(negSamp.val[1]), vget_high_s16(negCoef));
sP -= 16;
- }
} break;
+ }
} while (count -= 8);
// multiply by volume and save
diff --git a/services/audioflinger/AudioResamplerFirProcessSSE.h b/services/audioflinger/AudioResamplerFirProcessSSE.h
new file mode 100644
index 0000000..63ed052
--- /dev/null
+++ b/services/audioflinger/AudioResamplerFirProcessSSE.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_AUDIO_RESAMPLER_FIR_PROCESS_SSE_H
+#define ANDROID_AUDIO_RESAMPLER_FIR_PROCESS_SSE_H
+
+namespace android {
+
+// depends on AudioResamplerFirOps.h, AudioResamplerFirProcess.h
+
+#if USE_SSE
+
+#define TO_STRING2(x) #x
+#define TO_STRING(x) TO_STRING2(x)
+// uncomment to print GCC version, may be relevant for intrinsic optimizations
+/* #pragma message ("GCC version: " TO_STRING(__GNUC__) \
+ "." TO_STRING(__GNUC_MINOR__) \
+ "." TO_STRING(__GNUC_PATCHLEVEL__)) */
+
+//
+// SSEx specializations are enabled for Process() and ProcessL() in AudioResamplerFirProcess.h
+//
+
+template <int CHANNELS, int STRIDE, bool FIXED>
+static inline void ProcessSSEIntrinsic(float* out,
+ int count,
+ const float* coefsP,
+ const float* coefsN,
+ const float* sP,
+ const float* sN,
+ const float* volumeLR,
+ float lerpP,
+ const float* coefsP1,
+ const float* coefsN1)
+{
+ ALOG_ASSERT(count > 0 && (count & 7) == 0); // multiple of 8
+ COMPILE_TIME_ASSERT_FUNCTION_SCOPE(CHANNELS == 1 || CHANNELS == 2);
+
+ sP -= CHANNELS*(4-1); // adjust sP for a loop iteration of four
+
+ __m128 interp;
+ if (!FIXED) {
+ interp = _mm_set1_ps(lerpP);
+ }
+
+ __m128 accL, accR;
+ accL = _mm_setzero_ps();
+ if (CHANNELS == 2) {
+ accR = _mm_setzero_ps();
+ }
+
+ do {
+ __m128 posCoef = _mm_load_ps(coefsP);
+ __m128 negCoef = _mm_load_ps(coefsN);
+ coefsP += 4;
+ coefsN += 4;
+
+ if (!FIXED) { // interpolate
+ __m128 posCoef1 = _mm_load_ps(coefsP1);
+ __m128 negCoef1 = _mm_load_ps(coefsN1);
+ coefsP1 += 4;
+ coefsN1 += 4;
+
+ // Calculate the final coefficient for interpolation
+ // posCoef = interp * (posCoef1 - posCoef) + posCoef
+ // negCoef = interp * (negCoef - negCoef1) + negCoef1
+ posCoef1 = _mm_sub_ps(posCoef1, posCoef);
+ negCoef = _mm_sub_ps(negCoef, negCoef1);
+
+ posCoef1 = _mm_mul_ps(posCoef1, interp);
+ negCoef = _mm_mul_ps(negCoef, interp);
+
+ posCoef = _mm_add_ps(posCoef1, posCoef);
+ negCoef = _mm_add_ps(negCoef, negCoef1);
+ }
+ switch (CHANNELS) {
+ case 1: {
+ __m128 posSamp = _mm_loadu_ps(sP);
+ __m128 negSamp = _mm_loadu_ps(sN);
+ sP -= 4;
+ sN += 4;
+
+ posSamp = _mm_shuffle_ps(posSamp, posSamp, 0x1B);
+ posSamp = _mm_mul_ps(posSamp, posCoef);
+ negSamp = _mm_mul_ps(negSamp, negCoef);
+
+ accL = _mm_add_ps(accL, posSamp);
+ accL = _mm_add_ps(accL, negSamp);
+ } break;
+ case 2: {
+ __m128 posSamp0 = _mm_loadu_ps(sP);
+ __m128 posSamp1 = _mm_loadu_ps(sP+4);
+ __m128 negSamp0 = _mm_loadu_ps(sN);
+ __m128 negSamp1 = _mm_loadu_ps(sN+4);
+ sP -= 8;
+ sN += 8;
+
+ // deinterleave everything and reverse the positives
+ __m128 posSampL = _mm_shuffle_ps(posSamp1, posSamp0, 0x22);
+ __m128 posSampR = _mm_shuffle_ps(posSamp1, posSamp0, 0x77);
+ __m128 negSampL = _mm_shuffle_ps(negSamp0, negSamp1, 0x88);
+ __m128 negSampR = _mm_shuffle_ps(negSamp0, negSamp1, 0xDD);
+
+ posSampL = _mm_mul_ps(posSampL, posCoef);
+ posSampR = _mm_mul_ps(posSampR, posCoef);
+ negSampL = _mm_mul_ps(negSampL, negCoef);
+ negSampR = _mm_mul_ps(negSampR, negCoef);
+
+ accL = _mm_add_ps(accL, posSampL);
+ accR = _mm_add_ps(accR, posSampR);
+ accL = _mm_add_ps(accL, negSampL);
+ accR = _mm_add_ps(accR, negSampR);
+ } break;
+ }
+ } while (count -= 4);
+
+ // multiply by volume and save
+ __m128 vLR = _mm_setzero_ps();
+ __m128 outSamp;
+ vLR = _mm_loadl_pi(vLR, reinterpret_cast<const __m64*>(volumeLR));
+ outSamp = _mm_loadl_pi(vLR, reinterpret_cast<__m64*>(out));
+
+ // combine and funnel down accumulator
+ __m128 outAccum = _mm_setzero_ps();
+ if (CHANNELS == 1) {
+ // duplicate accL to both L and R
+ outAccum = _mm_add_ps(accL, _mm_movehl_ps(accL, accL));
+ outAccum = _mm_add_ps(outAccum, _mm_shuffle_ps(outAccum, outAccum, 0x11));
+ } else if (CHANNELS == 2) {
+ // accR contains R, fold in
+ outAccum = _mm_hadd_ps(accL, accR);
+ outAccum = _mm_hadd_ps(outAccum, outAccum);
+ }
+
+ outAccum = _mm_mul_ps(outAccum, vLR);
+ outSamp = _mm_add_ps(outSamp, outAccum);
+ _mm_storel_pi(reinterpret_cast<__m64*>(out), outSamp);
+}
+
+template<>
+inline void ProcessL<1, 16>(float* const out,
+ int count,
+ const float* coefsP,
+ const float* coefsN,
+ const float* sP,
+ const float* sN,
+ const float* const volumeLR)
+{
+ ProcessSSEIntrinsic<1, 16, true>(out, count, coefsP, coefsN, sP, sN, volumeLR,
+ 0 /*lerpP*/, NULL /*coefsP1*/, NULL /*coefsN1*/);
+}
+
+template<>
+inline void ProcessL<2, 16>(float* const out,
+ int count,
+ const float* coefsP,
+ const float* coefsN,
+ const float* sP,
+ const float* sN,
+ const float* const volumeLR)
+{
+ ProcessSSEIntrinsic<2, 16, true>(out, count, coefsP, coefsN, sP, sN, volumeLR,
+ 0 /*lerpP*/, NULL /*coefsP1*/, NULL /*coefsN1*/);
+}
+
+template<>
+inline void Process<1, 16>(float* const out,
+ int count,
+ const float* coefsP,
+ const float* coefsN,
+ const float* coefsP1,
+ const float* coefsN1,
+ const float* sP,
+ const float* sN,
+ float lerpP,
+ const float* const volumeLR)
+{
+ ProcessSSEIntrinsic<1, 16, false>(out, count, coefsP, coefsN, sP, sN, volumeLR,
+ lerpP, coefsP1, coefsN1);
+}
+
+template<>
+inline void Process<2, 16>(float* const out,
+ int count,
+ const float* coefsP,
+ const float* coefsN,
+ const float* coefsP1,
+ const float* coefsN1,
+ const float* sP,
+ const float* sN,
+ float lerpP,
+ const float* const volumeLR)
+{
+ ProcessSSEIntrinsic<2, 16, false>(out, count, coefsP, coefsN, sP, sN, volumeLR,
+ lerpP, coefsP1, coefsN1);
+}
+
+#endif //USE_SSE
+
+} // namespace android
+
+#endif /*ANDROID_AUDIO_RESAMPLER_FIR_PROCESS_SSE_H*/
diff --git a/services/audioflinger/FastThreadDumpState.cpp b/services/audioflinger/FastThreadDumpState.cpp
index 9df5c4c..964a725 100644
--- a/services/audioflinger/FastThreadDumpState.cpp
+++ b/services/audioflinger/FastThreadDumpState.cpp
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+#include <audio_utils/roundup.h>
#include "FastThreadDumpState.h"
namespace android {
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 724ce3c..abfbf0f 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -3649,6 +3649,7 @@
mFastMixer->run("FastMixer", PRIORITY_URGENT_AUDIO);
pid_t tid = mFastMixer->getTid();
sendPrioConfigEvent(getpid_cached, tid, kPriorityFastMixer);
+ stream()->setHalThreadPriority(kPriorityFastMixer);
#ifdef AUDIO_WATCHDOG
// create and start the watchdog
@@ -5911,6 +5912,7 @@
mFastCapture->run("FastCapture", ANDROID_PRIORITY_URGENT_AUDIO);
pid_t tid = mFastCapture->getTid();
sendPrioConfigEvent(getpid_cached, tid, kPriorityFastCapture);
+ stream()->setHalThreadPriority(kPriorityFastCapture);
#ifdef AUDIO_WATCHDOG
// FIXME
#endif
diff --git a/services/audioflinger/tests/build_and_run_all_unit_tests.sh b/services/audioflinger/tests/build_and_run_all_unit_tests.sh
index 7f4d456..9a71096 100755
--- a/services/audioflinger/tests/build_and_run_all_unit_tests.sh
+++ b/services/audioflinger/tests/build_and_run_all_unit_tests.sh
@@ -15,7 +15,9 @@
echo "waiting for device"
adb root && adb wait-for-device remount
adb push $OUT/system/lib/libaudioresampler.so /system/lib
-adb push $OUT/data/nativetest/resampler_tests /system/bin
+adb push $OUT/system/lib64/libaudioresampler.so /system/lib64
+adb push $OUT/data/nativetest/resampler_tests/resampler_tests /data/nativetest/resampler_tests/resampler_tests
+adb push $OUT/data/nativetest64/resampler_tests/resampler_tests /data/nativetest64/resampler_tests/resampler_tests
sh $ANDROID_BUILD_TOP/frameworks/av/services/audioflinger/tests/run_all_unit_tests.sh
diff --git a/services/audioflinger/tests/resampler_tests.cpp b/services/audioflinger/tests/resampler_tests.cpp
index 406b960..77a265f 100644
--- a/services/audioflinger/tests/resampler_tests.cpp
+++ b/services/audioflinger/tests/resampler_tests.cpp
@@ -39,6 +39,17 @@
#include "AudioResampler.h"
#include "test_utils.h"
+template <typename T>
+static void printData(T *data, size_t size) {
+ const size_t stride = 8;
+ for (size_t i = 0; i < size; ) {
+ for (size_t j = 0; j < stride && i < size; ++j) {
+ std::cout << data[i++] << ' '; // extra space before newline
+ }
+ std::cout << '\n'; // or endl
+ }
+}
+
void resample(int channels, void *output,
size_t outputFrames, const std::vector<size_t> &outputIncr,
android::AudioBufferProvider *provider, android::AudioResampler *resampler)
@@ -91,7 +102,7 @@
// calculate the output size
size_t outputFrames = ((int64_t) provider.getNumFrames() * outputFreq) / inputFreq;
- size_t outputFrameSize = channels * (useFloat ? sizeof(float) : sizeof(int32_t));
+ size_t outputFrameSize = (channels == 1 ? 2 : channels) * (useFloat ? sizeof(float) : sizeof(int32_t));
size_t outputSize = outputFrameSize * outputFrames;
outputSize &= ~7;
@@ -106,7 +117,7 @@
// set up the reference run
std::vector<size_t> refIncr;
refIncr.push_back(outputFrames);
- void* reference = malloc(outputSize);
+ void* reference = calloc(outputFrames, outputFrameSize);
resample(channels, reference, outputFrames, refIncr, &provider, resampler);
provider.reset();
@@ -127,7 +138,7 @@
outIncr.push_back(1);
outIncr.push_back(2);
outIncr.push_back(3);
- void* test = malloc(outputSize);
+ void* test = calloc(outputFrames, outputFrameSize);
inputIncr.push_back(1);
inputIncr.push_back(3);
provider.setIncr(inputIncr);
@@ -177,7 +188,7 @@
// calculate the output size
size_t outputFrames = ((int64_t) provider.getNumFrames() * outputFreq) / inputFreq;
- size_t outputFrameSize = channels * sizeof(TO);
+ size_t outputFrameSize = (channels == 1 ? 2 : channels) * sizeof(TO);
size_t outputSize = outputFrameSize * outputFrames;
outputSize &= ~7;
@@ -194,7 +205,7 @@
// set up the reference run
std::vector<size_t> refIncr;
refIncr.push_back(outputFrames);
- void* reference = malloc(outputSize);
+ void* reference = calloc(outputFrames, outputFrameSize);
resample(channels, reference, outputFrames, refIncr, &provider, resampler);
TO *out = reinterpret_cast<TO *>(reference);
@@ -204,6 +215,8 @@
const unsigned stopbandFrame = stopband * outputFreq / 1000.;
// check each channel separately
+ if (channels == 1) channels = 2; // workaround (mono duplicates output channel)
+
for (size_t i = 0; i < channels; ++i) {
double passbandEnergy = signalEnergy(out, out + passbandFrame * channels, channels);
double stopbandEnergy = signalEnergy(out + stopbandFrame * channels,
@@ -331,6 +344,34 @@
}
}
+TEST(audioflinger_resampler, stopbandresponse_integer_mono) {
+ // not all of these may work (old resamplers fail on downsampling)
+ static const enum android::AudioResampler::src_quality kQualityArray[] = {
+ //android::AudioResampler::LOW_QUALITY,
+ //android::AudioResampler::MED_QUALITY,
+ //android::AudioResampler::HIGH_QUALITY,
+ //android::AudioResampler::VERY_HIGH_QUALITY,
+ android::AudioResampler::DYN_LOW_QUALITY,
+ android::AudioResampler::DYN_MED_QUALITY,
+ android::AudioResampler::DYN_HIGH_QUALITY,
+ };
+
+ // in this test we assume a maximum transition band between 12kHz and 20kHz.
+ // there must be at least 60dB relative attenuation between stopband and passband.
+ for (size_t i = 0; i < ARRAY_SIZE(kQualityArray); ++i) {
+ testStopbandDownconversion<int16_t, int32_t>(
+ 1, 48000, 32000, 12000, 20000, kQualityArray[i]);
+ }
+
+ // in this test we assume a maximum transition band between 7kHz and 15kHz.
+ // there must be at least 60dB relative attenuation between stopband and passband.
+ // (the weird ratio triggers interpolative resampling)
+ for (size_t i = 0; i < ARRAY_SIZE(kQualityArray); ++i) {
+ testStopbandDownconversion<int16_t, int32_t>(
+ 1, 48000, 22101, 7000, 15000, kQualityArray[i]);
+ }
+}
+
TEST(audioflinger_resampler, stopbandresponse_integer_multichannel) {
// not all of these may work (old resamplers fail on downsampling)
static const enum android::AudioResampler::src_quality kQualityArray[] = {
@@ -387,6 +428,34 @@
}
}
+TEST(audioflinger_resampler, stopbandresponse_float_mono) {
+ // not all of these may work (old resamplers fail on downsampling)
+ static const enum android::AudioResampler::src_quality kQualityArray[] = {
+ //android::AudioResampler::LOW_QUALITY,
+ //android::AudioResampler::MED_QUALITY,
+ //android::AudioResampler::HIGH_QUALITY,
+ //android::AudioResampler::VERY_HIGH_QUALITY,
+ android::AudioResampler::DYN_LOW_QUALITY,
+ android::AudioResampler::DYN_MED_QUALITY,
+ android::AudioResampler::DYN_HIGH_QUALITY,
+ };
+
+ // in this test we assume a maximum transition band between 12kHz and 20kHz.
+ // there must be at least 60dB relative attenuation between stopband and passband.
+ for (size_t i = 0; i < ARRAY_SIZE(kQualityArray); ++i) {
+ testStopbandDownconversion<float, float>(
+ 1, 48000, 32000, 12000, 20000, kQualityArray[i]);
+ }
+
+ // in this test we assume a maximum transition band between 7kHz and 15kHz.
+ // there must be at least 60dB relative attenuation between stopband and passband.
+ // (the weird ratio triggers interpolative resampling)
+ for (size_t i = 0; i < ARRAY_SIZE(kQualityArray); ++i) {
+ testStopbandDownconversion<float, float>(
+ 1, 48000, 22101, 7000, 15000, kQualityArray[i]);
+ }
+}
+
TEST(audioflinger_resampler, stopbandresponse_float_multichannel) {
// not all of these may work (old resamplers fail on downsampling)
static const enum android::AudioResampler::src_quality kQualityArray[] = {
diff --git a/services/audioflinger/tests/run_all_unit_tests.sh b/services/audioflinger/tests/run_all_unit_tests.sh
index 113f39e..15a94c2 100755
--- a/services/audioflinger/tests/run_all_unit_tests.sh
+++ b/services/audioflinger/tests/run_all_unit_tests.sh
@@ -8,5 +8,5 @@
echo "waiting for device"
adb root && adb wait-for-device remount
-#adb shell /system/bin/resampler_tests
adb shell /data/nativetest/resampler_tests/resampler_tests
+adb shell /data/nativetest64/resampler_tests/resampler_tests
diff --git a/services/audioflinger/tests/test_utils.h b/services/audioflinger/tests/test_utils.h
index 283c768..b61a929 100644
--- a/services/audioflinger/tests/test_utils.h
+++ b/services/audioflinger/tests/test_utils.h
@@ -17,6 +17,12 @@
#ifndef ANDROID_AUDIO_TEST_UTILS_H
#define ANDROID_AUDIO_TEST_UTILS_H
+#ifndef LOG_TAG
+#define LOG_TAG "test_utils"
+#endif
+
+#include <log/log.h>
+
#include <audio_utils/sndfile.h>
#ifndef ARRAY_SIZE
diff --git a/services/camera/libcameraservice/Android.mk b/services/camera/libcameraservice/Android.mk
index ef2e8d9..d1edb56 100644
--- a/services/camera/libcameraservice/Android.mk
+++ b/services/camera/libcameraservice/Android.mk
@@ -28,6 +28,7 @@
common/Camera2ClientBase.cpp \
common/CameraDeviceBase.cpp \
common/CameraModule.cpp \
+ common/CameraProviderManager.cpp \
common/FrameProcessorBase.cpp \
api1/CameraClient.cpp \
api1/Camera2Client.cpp \
@@ -63,25 +64,36 @@
libmedia \
libmediautils \
libcamera_client \
+ libcamera_metadata \
libgui \
libhardware \
- libcamera_metadata \
+ libhidlbase \
+ libhidltransport \
libjpeg \
libmemunreachable \
- android.hardware.camera.common@1.0
+ 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.hidl.manager@1.0
LOCAL_EXPORT_SHARED_LIBRARY_HEADERS := libbinder libcamera_client
LOCAL_C_INCLUDES += \
system/media/private/camera/include \
- frameworks/native/include/media/openmax \
- external/jpeg
+ frameworks/native/include/media/openmax
LOCAL_EXPORT_C_INCLUDE_DIRS := \
frameworks/av/services/camera/libcameraservice
LOCAL_CFLAGS += -Wall -Wextra -Werror
+ifeq ($(ENABLE_TREBLE), true)
+
+ LOCAL_CFLAGS += -DENABLE_TREBLE
+
+endif # ENABLE_TREBLE
+
LOCAL_MODULE:= libcameraservice
include $(BUILD_SHARED_LIBRARY)
diff --git a/services/camera/libcameraservice/CameraFlashlight.cpp b/services/camera/libcameraservice/CameraFlashlight.cpp
index 6314ba5..07d88f6 100644
--- a/services/camera/libcameraservice/CameraFlashlight.cpp
+++ b/services/camera/libcameraservice/CameraFlashlight.cpp
@@ -36,10 +36,18 @@
// CameraFlashlight implementation begins
// used by camera service to control flashflight.
/////////////////////////////////////////////////////////////////////
-CameraFlashlight::CameraFlashlight(CameraModule& cameraModule,
- const camera_module_callbacks_t& callbacks) :
- mCameraModule(&cameraModule),
- mCallbacks(&callbacks),
+CameraFlashlight::CameraFlashlight(CameraModule* cameraModule,
+ camera_module_callbacks_t* callbacks) :
+ mCameraModule(cameraModule),
+ mCallbacks(callbacks),
+ mFlashlightMapInitialized(false) {
+}
+
+CameraFlashlight::CameraFlashlight(sp<CameraProviderManager> providerManager,
+ camera_module_callbacks_t* callbacks) :
+ mCameraModule(nullptr),
+ mProviderManager(providerManager),
+ mCallbacks(callbacks),
mFlashlightMapInitialized(false) {
}
@@ -55,8 +63,10 @@
status_t res = OK;
- if (mCameraModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4) {
- mFlashControl = new ModuleFlashControl(*mCameraModule, *mCallbacks);
+ if (mCameraModule == nullptr) {
+ mFlashControl = new ProviderFlashControl(mProviderManager);
+ } else if (mCameraModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4) {
+ mFlashControl = new ModuleFlashControl(*mCameraModule);
if (mFlashControl == NULL) {
ALOGV("%s: cannot create flash control for module api v2.4+",
__FUNCTION__);
@@ -69,7 +79,7 @@
CAMERA_MODULE_API_VERSION_2_0) {
camera_info info;
res = mCameraModule->getCameraInfo(
- atoi(String8(cameraId).string()), &info);
+ atoi(cameraId.string()), &info);
if (res) {
ALOGE("%s: failed to get camera info for camera %s",
__FUNCTION__, cameraId.string());
@@ -157,15 +167,27 @@
status_t CameraFlashlight::findFlashUnits() {
Mutex::Autolock l(mLock);
status_t res;
- int32_t numCameras = mCameraModule->getNumberOfCameras();
+
+ std::vector<String8> cameraIds;
+ if (mCameraModule) {
+ cameraIds.resize(mCameraModule->getNumberOfCameras());
+ for (size_t i = 0; i < cameraIds.size(); i++) {
+ cameraIds[i] = String8::format("%zu", i);
+ }
+ } else {
+ // No module, must be provider
+ std::vector<std::string> ids = mProviderManager->getCameraDeviceIds();
+ cameraIds.resize(ids.size());
+ for (size_t i = 0; i < cameraIds.size(); i++) {
+ cameraIds[i] = String8(ids[i].c_str());
+ }
+ }
mHasFlashlightMap.clear();
mFlashlightMapInitialized = false;
- for (int32_t i = 0; i < numCameras; i++) {
+ for (auto &id : cameraIds) {
bool hasFlash = false;
- String8 id = String8::format("%d", i);
-
res = createFlashlightControl(id);
if (res) {
ALOGE("%s: failed to create flash control for %s", __FUNCTION__,
@@ -224,7 +246,7 @@
return NO_INIT;
}
- if (mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) {
+ if (mCameraModule && mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) {
// framework is going to open a camera device, all flash light control
// should be closed for backward compatible support.
mFlashControl.clear();
@@ -274,7 +296,7 @@
if (mOpenedCameraIds.size() != 0)
return OK;
- if (mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) {
+ if (mCameraModule && mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) {
// notify torch available for all cameras with a flash
int numCameras = mCameraModule->getNumberOfCameras();
for (int i = 0; i < numCameras; i++) {
@@ -298,10 +320,35 @@
// ModuleFlashControl implementation begins
// Flash control for camera module v2.4 and above.
/////////////////////////////////////////////////////////////////////
-ModuleFlashControl::ModuleFlashControl(CameraModule& cameraModule,
- const camera_module_callbacks_t& callbacks) :
+ProviderFlashControl::ProviderFlashControl(sp<CameraProviderManager> providerManager) :
+ mProviderManager(providerManager) {
+}
+
+ProviderFlashControl::~ProviderFlashControl() {
+}
+
+status_t ProviderFlashControl::hasFlashUnit(const String8& cameraId, bool *hasFlash) {
+ if (!hasFlash) {
+ return BAD_VALUE;
+ }
+ *hasFlash = mProviderManager->hasFlashUnit(cameraId.string());
+ return OK;
+}
+
+status_t ProviderFlashControl::setTorchMode(const String8& cameraId, bool enabled) {
+ ALOGV("%s: set camera %s torch mode to %d", __FUNCTION__,
+ cameraId.string(), enabled);
+
+ return mProviderManager->setTorchMode(cameraId.string(), enabled);
+}
+// ProviderFlashControl implementation ends
+
+/////////////////////////////////////////////////////////////////////
+// ModuleFlashControl implementation begins
+// Flash control for camera module v2.4 and above.
+/////////////////////////////////////////////////////////////////////
+ModuleFlashControl::ModuleFlashControl(CameraModule& cameraModule) :
mCameraModule(&cameraModule) {
- (void) callbacks;
}
ModuleFlashControl::~ModuleFlashControl() {
@@ -477,7 +524,7 @@
}
sp<CameraDeviceBase> device =
- new Camera3Device(atoi(cameraId.string()));
+ new Camera3Device(cameraId);
if (device == NULL) {
return NO_MEMORY;
}
diff --git a/services/camera/libcameraservice/CameraFlashlight.h b/services/camera/libcameraservice/CameraFlashlight.h
index 59fc87d..b7c7690 100644
--- a/services/camera/libcameraservice/CameraFlashlight.h
+++ b/services/camera/libcameraservice/CameraFlashlight.h
@@ -17,14 +17,17 @@
#ifndef ANDROID_SERVERS_CAMERA_CAMERAFLASHLIGHT_H
#define ANDROID_SERVERS_CAMERA_CAMERAFLASHLIGHT_H
-#include "hardware/camera_common.h"
-#include "utils/KeyedVector.h"
-#include "utils/SortedVector.h"
-#include "gui/GLConsumer.h"
-#include "gui/Surface.h"
+#include <gui/GLConsumer.h>
+#include <gui/Surface.h>
+#include <hardware/camera_common.h>
+#include <utils/KeyedVector.h>
+#include <utils/SortedVector.h>
+#include "common/CameraProviderManager.h"
+#include "common/CameraModule.h"
#include "common/CameraDeviceBase.h"
#include "device1/CameraHardwareInterface.h"
+
namespace android {
/**
@@ -52,8 +55,10 @@
*/
class CameraFlashlight : public virtual VirtualLightRefBase {
public:
- CameraFlashlight(CameraModule& cameraModule,
- const camera_module_callbacks_t& callbacks);
+ CameraFlashlight(CameraModule* cameraModule,
+ camera_module_callbacks_t* callbacks);
+ CameraFlashlight(sp<CameraProviderManager> providerManager,
+ camera_module_callbacks_t* callbacks);
virtual ~CameraFlashlight();
// Find all flash units. This must be called before other methods. All
@@ -88,7 +93,10 @@
bool hasFlashUnitLocked(const String8& cameraId);
sp<FlashControlBase> mFlashControl;
+
CameraModule *mCameraModule;
+ sp<CameraProviderManager> mProviderManager;
+
const camera_module_callbacks_t *mCallbacks;
SortedVector<String8> mOpenedCameraIds;
@@ -100,12 +108,29 @@
};
/**
+ * Flash control for camera provider v2.4 and above.
+ */
+class ProviderFlashControl : public FlashControlBase {
+ public:
+ ProviderFlashControl(sp<CameraProviderManager> providerManager);
+ virtual ~ProviderFlashControl();
+
+ // FlashControlBase
+ status_t hasFlashUnit(const String8& cameraId, bool *hasFlash);
+ status_t setTorchMode(const String8& cameraId, bool enabled);
+
+ private:
+ sp<CameraProviderManager> mProviderManager;
+
+ Mutex mLock;
+};
+
+/**
* Flash control for camera module v2.4 and above.
*/
class ModuleFlashControl : public FlashControlBase {
public:
- ModuleFlashControl(CameraModule& cameraModule,
- const camera_module_callbacks_t& callbacks);
+ ModuleFlashControl(CameraModule& cameraModule);
virtual ~ModuleFlashControl();
// FlashControlBase
diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp
index 1d9ccb1..c92092c 100644
--- a/services/camera/libcameraservice/CameraService.cpp
+++ b/services/camera/libcameraservice/CameraService.cpp
@@ -18,6 +18,12 @@
#define ATRACE_TAG ATRACE_TAG_CAMERA
//#define LOG_NDEBUG 0
+#ifdef ENABLE_TREBLE
+ #define USE_HIDL true
+#else
+ #define USE_HIDL false
+#endif
+
#include <algorithm>
#include <climits>
#include <stdio.h>
@@ -32,6 +38,7 @@
#include <android/hardware/ICameraClient.h>
#include <android-base/macros.h>
+#include <android-base/parseint.h>
#include <binder/AppOpsManager.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
@@ -54,8 +61,12 @@
#include <private/android_filesystem_config.h>
#include <system/camera_vendor_tags.h>
#include <system/camera_metadata.h>
+
#include <system/camera.h>
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <hidl/ServiceManagement.h>
+
#include "CameraService.h"
#include "api1/CameraClient.h"
#include "api1/Camera2Client.h"
@@ -162,16 +173,11 @@
// ----------------------------------------------------------------------------
-// This is ugly and only safe if we never re-create the CameraService, but
-// should be ok for now.
-static CameraService *gCameraService;
-
CameraService::CameraService() :
mEventLog(DEFAULT_EVENT_LOG_LENGTH),
mNumberOfCameras(0), mNumberOfNormalCameras(0),
- mSoundRef(0), mModule(nullptr) {
+ mSoundRef(0), mInitialized(false), mModule(nullptr) {
ALOGI("CameraService started (pid=%d)", getpid());
- gCameraService = this;
this->camera_device_status_change = android::camera_device_status_change;
this->torch_mode_status_change = android::torch_mode_status_change;
@@ -190,13 +196,27 @@
notifier.noteResetCamera();
notifier.noteResetFlashlight();
+ status_t res = INVALID_OPERATION;
+ if (USE_HIDL) {
+ res = enumerateProviders();
+ } else {
+ res = loadLegacyHalModule();
+ }
+ if (res == OK) {
+ mInitialized = true;
+ }
+
+ CameraService::pingCameraServiceProxy();
+}
+
+status_t CameraService::loadLegacyHalModule() {
camera_module_t *rawModule;
int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID,
(const hw_module_t **)&rawModule);
if (err < 0) {
ALOGE("Could not load camera HAL module: %d (%s)", err, strerror(-err));
logServiceError("Could not load camera HAL module", err);
- return;
+ return INVALID_OPERATION;
}
mModule = new CameraModule(rawModule);
@@ -208,7 +228,7 @@
delete mModule;
mModule = nullptr;
- return;
+ return INVALID_OPERATION;
}
ALOGI("Loaded \"%s\" camera module", mModule->getModuleName());
@@ -222,7 +242,7 @@
setUpVendorTags();
}
- mFlashlight = new CameraFlashlight(*mModule, *this);
+ mFlashlight = new CameraFlashlight(mModule, this);
status_t res = mFlashlight->findFlashUnits();
if (res) {
// impossible because we haven't open any camera devices.
@@ -250,7 +270,7 @@
if (checkCameraCapabilities(i, info, &latestStrangeCameraId) != OK) {
delete mModule;
mModule = nullptr;
- return;
+ return INVALID_OPERATION;
}
}
@@ -288,9 +308,59 @@
mModule->setCallbacks(this);
}
- CameraService::pingCameraServiceProxy();
+ return OK;
}
+status_t CameraService::enumerateProviders() {
+ mCameraProviderManager = new CameraProviderManager();
+ status_t res;
+ res = mCameraProviderManager->initialize(this);
+ if (res != OK) {
+ ALOGE("%s: Unable to initialize camera provider manager: %s (%d)",
+ __FUNCTION__, strerror(-res), res);
+ return res;
+ }
+
+ mNumberOfCameras = mCameraProviderManager->getCameraCount();
+ mNumberOfNormalCameras = mCameraProviderManager->getStandardCameraCount();
+
+ // TODO: Set up vendor tags
+
+ mFlashlight = new CameraFlashlight(mCameraProviderManager, this);
+ res = mFlashlight->findFlashUnits();
+ if (res != OK) {
+ ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
+ }
+
+ // TODO: Verify device versions are in support
+
+ for (auto& cameraId : mCameraProviderManager->getCameraDeviceIds()) {
+ hardware::camera::common::V1_0::CameraResourceCost cost;
+ res = mCameraProviderManager->getResourceCost(cameraId, &cost);
+ if (res != OK) {
+ ALOGE("Failed to query device resource cost: %s (%d)", strerror(-res), res);
+ continue;
+ }
+ std::set<String8> conflicting;
+ for (size_t i = 0; i < cost.conflictingDevices.size(); i++) {
+ conflicting.emplace(String8(cost.conflictingDevices[i].c_str()));
+ }
+ String8 id8 = String8(cameraId.c_str());
+
+ Mutex::Autolock lock(mCameraStatesLock);
+ mCameraStates.emplace(id8,
+ std::make_shared<CameraState>(id8, cost.resourceCost, conflicting));
+
+ if (mFlashlight->hasFlashUnit(id8)) {
+ mTorchStatusMap.add(id8,
+ TorchModeStatus::AVAILABLE_OFF);
+ }
+ }
+
+ return OK;
+}
+
+
sp<ICameraServiceProxy> CameraService::getCameraServiceProxy() {
sp<ICameraServiceProxy> proxyBinder = nullptr;
#ifndef __BRILLO__
@@ -318,7 +388,6 @@
mModule = nullptr;
}
VendorTagDescriptor::clearGlobalVendorTagDescriptor();
- gCameraService = nullptr;
}
void CameraService::onDeviceStatusChanged(const String8& id,
@@ -473,7 +542,7 @@
Status CameraService::getCameraInfo(int cameraId,
CameraInfo* cameraInfo) {
ATRACE_CALL();
- if (!mModule) {
+ if (!mInitialized) {
return STATUS_ERROR(ERROR_DISCONNECTED,
"Camera subsystem is not available");
}
@@ -483,34 +552,42 @@
"CameraId is not valid");
}
- struct camera_info info;
- Status rc = filterGetInfoErrorCode(
- mModule->getCameraInfo(cameraId, &info));
+ Status ret = Status::ok();
+ if (mModule != nullptr) {
+ struct camera_info info;
+ ret = filterGetInfoErrorCode(mModule->getCameraInfo(cameraId, &info));
- if (rc.isOk()) {
- cameraInfo->facing = info.facing;
- cameraInfo->orientation = info.orientation;
- // CameraInfo is for android.hardware.Camera which does not
- // support external camera facing. The closest approximation would be
- // front camera.
- if (cameraInfo->facing == CAMERA_FACING_EXTERNAL) {
- cameraInfo->facing = CAMERA_FACING_FRONT;
+ if (ret.isOk()) {
+ cameraInfo->facing = info.facing;
+ cameraInfo->orientation = info.orientation;
+ // CameraInfo is for android.hardware.Camera which does not
+ // support external camera facing. The closest approximation would be
+ // front camera.
+ if (cameraInfo->facing == CAMERA_FACING_EXTERNAL) {
+ cameraInfo->facing = hardware::CAMERA_FACING_FRONT;
+ }
}
- }
- return rc;
-}
-
-int CameraService::cameraIdToInt(const String8& cameraId) {
- errno = 0;
- size_t pos = 0;
- int ret = stoi(std::string{cameraId.string()}, &pos);
- if (errno != 0 || pos != cameraId.size()) {
- return -1;
+ } else {
+ status_t err = mCameraProviderManager->getCameraInfo(std::to_string(cameraId), cameraInfo);
+ if (err != OK) {
+ ret = STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
+ "Error retrieving camera info from device %d: %s (%d)", cameraId,
+ strerror(-err), err);
+ }
}
return ret;
}
-Status CameraService::getCameraCharacteristics(const String16& id,
+int CameraService::cameraIdToInt(const String8& cameraId) {
+ int id;
+ bool success = base::ParseInt(cameraId.string(), &id, 0);
+ if (!success) {
+ return -1;
+ }
+ return id;
+}
+
+Status CameraService::getCameraCharacteristics(const String16& cameraId,
CameraMetadata* cameraInfo) {
ATRACE_CALL();
if (!cameraInfo) {
@@ -518,32 +595,42 @@
return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "cameraInfo is NULL");
}
- if (!mModule) {
- ALOGE("%s: camera hardware module doesn't exist", __FUNCTION__);
+ if (!mInitialized) {
+ ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
return STATUS_ERROR(ERROR_DISCONNECTED,
"Camera subsystem is not available");;
}
- int cameraId = cameraIdToInt(String8(id));
+ Status ret{};
- if (cameraId < 0 || cameraId >= mNumberOfCameras) {
- ALOGE("%s: Invalid camera id: %d", __FUNCTION__, cameraId);
- return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
- "Invalid camera id: %d", cameraId);
- }
+ if (mModule != nullptr) {
+ int id = cameraIdToInt(String8(cameraId));
- int facing;
- Status ret;
- if (mModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_0 ||
- getDeviceVersion(cameraId, &facing) < CAMERA_DEVICE_API_VERSION_3_0) {
- return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, "Can't get camera characteristics"
- " for devices with HAL version < 3.0, %d is version %x", cameraId,
- getDeviceVersion(cameraId, &facing));
- }
- struct camera_info info;
- ret = filterGetInfoErrorCode(mModule->getCameraInfo(cameraId, &info));
- if (ret.isOk()) {
- *cameraInfo = info.static_camera_characteristics;
+ if (id < 0 || id >= mNumberOfCameras) {
+ ALOGE("%s: Invalid camera id: %d", __FUNCTION__, id);
+ return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
+ "Invalid camera id: %d", id);
+ }
+
+ int version = getDeviceVersion(String8(cameraId));
+ if (version < CAMERA_DEVICE_API_VERSION_3_0) {
+ return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, "Can't get camera characteristics"
+ " for devices with HAL version < 3.0, %d is version %x", id, version);
+ }
+
+ struct camera_info info;
+ ret = filterGetInfoErrorCode(mModule->getCameraInfo(id, &info));
+ if (ret.isOk()) {
+ *cameraInfo = info.static_camera_characteristics;
+ }
+ } else {
+ status_t res = mCameraProviderManager->getCameraCharacteristics(
+ String16::std_string(cameraId), cameraInfo);
+ if (res != OK) {
+ return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Unable to retrieve camera "
+ "characteristics for device %s: %s (%d)", String8(cameraId).string(),
+ strerror(-res), res);
+ }
}
return ret;
@@ -584,8 +671,8 @@
/*out*/
hardware::camera2::params::VendorTagDescriptor* desc) {
ATRACE_CALL();
- if (!mModule) {
- ALOGE("%s: camera hardware module doesn't exist", __FUNCTION__);
+ if (!mInitialized) {
+ ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
return STATUS_ERROR(ERROR_DISCONNECTED, "Camera subsystem not available");
}
sp<VendorTagDescriptor> globalDescriptor = VendorTagDescriptor::getGlobalVendorTagDescriptor();
@@ -595,24 +682,37 @@
return Status::ok();
}
-int CameraService::getDeviceVersion(int cameraId, int* facing) {
+int CameraService::getDeviceVersion(const String8& cameraId, int* facing) {
ATRACE_CALL();
struct camera_info info;
- if (mModule->getCameraInfo(cameraId, &info) != OK) {
- return -1;
- }
- int deviceVersion;
- if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
- deviceVersion = info.device_version;
+ int deviceVersion = 0;
+
+ if (mModule != nullptr) {
+ int id = cameraIdToInt(cameraId);
+ if (id < 0) return -1;
+
+ if (mModule->getCameraInfo(id, &info) != OK) {
+ return -1;
+ }
+
+ if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
+ deviceVersion = info.device_version;
+ } else {
+ deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
+ }
+
+ if (facing) {
+ *facing = info.facing;
+ }
} else {
- deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
+ status_t res;
+ hardware::hidl_version maxVersion{0,0};
+ res = mCameraProviderManager->getHighestSupportedVersion(String8::std_string(cameraId),
+ &maxVersion);
+ if (res == NAME_NOT_FOUND) return -1;
+ deviceVersion = HARDWARE_DEVICE_API_VERSION(maxVersion.get_major(), maxVersion.get_minor());
}
-
- if (facing) {
- *facing = info.facing;
- }
-
return deviceVersion;
}
@@ -635,6 +735,8 @@
bool CameraService::setUpVendorTags() {
ATRACE_CALL();
+ if (mModule == nullptr) return false;
+
vendor_tag_ops_t vOps = vendor_tag_ops_t();
// Check if vendor operations have been implemented
@@ -671,7 +773,7 @@
}
Status CameraService::makeClient(const sp<CameraService>& cameraService,
- const sp<IInterface>& cameraCb, const String16& packageName, int cameraId,
+ const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
/*out*/sp<BasicClient>* client) {
@@ -683,13 +785,13 @@
case CAMERA_DEVICE_API_VERSION_1_0:
if (effectiveApiLevel == API_1) { // Camera1 API route
sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
- *client = new CameraClient(cameraService, tmp, packageName, cameraId, facing,
- clientPid, clientUid, getpid(), legacyMode);
+ *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
+ facing, clientPid, clientUid, getpid(), legacyMode);
} else { // Camera2 API route
ALOGW("Camera using old HAL version: %d", deviceVersion);
return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
- "Camera device \"%d\" HAL version %d does not support camera2 API",
- cameraId, deviceVersion);
+ "Camera device \"%s\" HAL version %d does not support camera2 API",
+ cameraId.string(), deviceVersion);
}
break;
case CAMERA_DEVICE_API_VERSION_3_0:
@@ -699,8 +801,8 @@
case CAMERA_DEVICE_API_VERSION_3_4:
if (effectiveApiLevel == API_1) { // Camera1 API route
sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
- *client = new Camera2Client(cameraService, tmp, packageName, cameraId, facing,
- clientPid, clientUid, servicePid, legacyMode);
+ *client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId),
+ facing, clientPid, clientUid, servicePid, legacyMode);
} else { // Camera2 API route
sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
@@ -712,8 +814,8 @@
// Should not be reachable
ALOGE("Unknown camera device HAL version: %d", deviceVersion);
return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
- "Camera device \"%d\" has unknown HAL version %d",
- cameraId, deviceVersion);
+ "Camera device \"%s\" has unknown HAL version %d",
+ cameraId.string(), deviceVersion);
}
} else {
// A particular HAL version is requested by caller. Create CameraClient
@@ -722,16 +824,16 @@
halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
// Only support higher HAL version device opened as HAL1.0 device.
sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
- *client = new CameraClient(cameraService, tmp, packageName, cameraId, facing,
- clientPid, clientUid, servicePid, legacyMode);
+ *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
+ facing, clientPid, clientUid, servicePid, legacyMode);
} else {
// Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
" opened as HAL %x device", halVersion, deviceVersion,
CAMERA_DEVICE_API_VERSION_1_0);
return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
- "Camera device \"%d\" (HAL version %d) cannot be opened as HAL version %d",
- cameraId, deviceVersion, halVersion);
+ "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
+ cameraId.string(), deviceVersion, halVersion);
}
}
return Status::ok();
@@ -922,7 +1024,7 @@
int callingPid = getCallingPid();
- if (!mModule) {
+ if (!mInitialized) {
ALOGE("CameraService::connect X (PID %d) rejected (camera HAL module not loaded)",
callingPid);
return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
@@ -1288,22 +1390,24 @@
ATRACE_CALL();
String8 id = String8::format("%d", cameraId);
- int apiVersion = mModule->getModuleApiVersion();
- if (halVersion != CAMERA_HAL_API_VERSION_UNSPECIFIED &&
- apiVersion < CAMERA_MODULE_API_VERSION_2_3) {
- /*
- * Either the HAL version is unspecified in which case this just creates
- * a camera client selected by the latest device version, or
- * it's a particular version in which case the HAL must supported
- * the open_legacy call
- */
- String8 msg = String8::format("Camera HAL module version %x too old for connectLegacy!",
- apiVersion);
- ALOGE("%s: %s",
- __FUNCTION__, msg.string());
- logRejected(id, getCallingPid(), String8(clientPackageName),
- msg);
- return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
+ if (mModule != nullptr) {
+ int apiVersion = mModule->getModuleApiVersion();
+ if (halVersion != CAMERA_HAL_API_VERSION_UNSPECIFIED &&
+ apiVersion < CAMERA_MODULE_API_VERSION_2_3) {
+ /*
+ * Either the HAL version is unspecified in which case this just creates
+ * a camera client selected by the latest device version, or
+ * it's a particular version in which case the HAL must supported
+ * the open_legacy call
+ */
+ String8 msg = String8::format("Camera HAL module version %x too old for connectLegacy!",
+ apiVersion);
+ ALOGE("%s: %s",
+ __FUNCTION__, msg.string());
+ logRejected(id, getCallingPid(), String8(clientPackageName),
+ msg);
+ return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
+ }
}
Status ret = Status::ok();
@@ -1438,9 +1542,9 @@
}
int facing = -1;
- int deviceVersion = getDeviceVersion(id, /*out*/&facing);
+ int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing);
sp<BasicClient> tmp = nullptr;
- if(!(ret = makeClient(this, cameraCb, clientPackageName, id, facing, clientPid,
+ if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid,
clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,
/*out*/&tmp)).isOk()) {
return ret;
@@ -1450,8 +1554,14 @@
LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
__FUNCTION__);
- if ((err = client->initialize(mModule)) != OK) {
- ALOGE("%s: Could not initialize client from HAL module.", __FUNCTION__);
+ if (mModule != nullptr) {
+ err = client->initialize(mModule);
+ } else {
+ err = client->initialize(mCameraProviderManager);
+ }
+
+ if (err != OK) {
+ ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
// Errors could be from the HAL module open call or from AppOpsManager
switch(err) {
case BAD_VALUE:
@@ -1513,6 +1623,7 @@
Status CameraService::setTorchMode(const String16& cameraId, bool enabled,
const sp<IBinder>& clientBinder) {
+ Mutex::Autolock lock(mServiceLock);
ATRACE_CALL();
if (enabled && clientBinder == nullptr) {
@@ -1534,8 +1645,8 @@
StatusInternal cameraStatus = state->getStatus();
if (cameraStatus != StatusInternal::PRESENT &&
- cameraStatus != StatusInternal::NOT_PRESENT) {
- ALOGE("%s: camera id is invalid %s", __FUNCTION__, id.string());
+ cameraStatus != StatusInternal::NOT_AVAILABLE) {
+ ALOGE("%s: camera id is invalid %s, status %d", __FUNCTION__, id.string(), (int)cameraStatus);
return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
"Camera ID \"%s\" is a not valid camera ID", id.string());
}
@@ -1557,7 +1668,7 @@
}
if (status == TorchModeStatus::NOT_AVAILABLE) {
- if (cameraStatus == StatusInternal::NOT_PRESENT) {
+ if (cameraStatus == StatusInternal::NOT_AVAILABLE) {
ALOGE("%s: torch mode of camera %s is not available because "
"camera is in use", __FUNCTION__, id.string());
return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
@@ -1754,7 +1865,9 @@
/*out*/ bool *isSupported) {
ATRACE_CALL();
- ALOGV("%s: for camera ID = %s", __FUNCTION__, String8(cameraId).string());
+ const String8 id = String8(cameraId);
+
+ ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
switch (apiVersion) {
case API_VERSION_1:
@@ -1768,7 +1881,6 @@
int facing = -1;
- int id = cameraIdToInt(String8(cameraId));
int deviceVersion = getDeviceVersion(id, &facing);
switch(deviceVersion) {
@@ -1776,30 +1888,30 @@
case CAMERA_DEVICE_API_VERSION_3_0:
case CAMERA_DEVICE_API_VERSION_3_1:
if (apiVersion == API_VERSION_2) {
- ALOGV("%s: Camera id %d uses HAL version %d <3.2, doesn't support api2 without shim",
- __FUNCTION__, id, deviceVersion);
+ ALOGV("%s: Camera id %s uses HAL version %d <3.2, doesn't support api2 without shim",
+ __FUNCTION__, id.string(), deviceVersion);
*isSupported = false;
} else { // if (apiVersion == API_VERSION_1) {
- ALOGV("%s: Camera id %d uses older HAL before 3.2, but api1 is always supported",
- __FUNCTION__, id);
+ ALOGV("%s: Camera id %s uses older HAL before 3.2, but api1 is always supported",
+ __FUNCTION__, id.string());
*isSupported = true;
}
break;
case CAMERA_DEVICE_API_VERSION_3_2:
case CAMERA_DEVICE_API_VERSION_3_3:
case CAMERA_DEVICE_API_VERSION_3_4:
- ALOGV("%s: Camera id %d uses HAL3.2 or newer, supports api1/api2 directly",
- __FUNCTION__, id);
+ ALOGV("%s: Camera id %s uses HAL3.2 or newer, supports api1/api2 directly",
+ __FUNCTION__, id.string());
*isSupported = true;
break;
case -1: {
- String8 msg = String8::format("Unknown camera ID %d", id);
+ String8 msg = String8::format("Unknown camera ID %s", id.string());
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
}
default: {
- String8 msg = String8::format("Unknown device version %d for device %d",
- deviceVersion, id);
+ String8 msg = String8::format("Unknown device version %x for device %s",
+ deviceVersion, id.string());
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(ERROR_INVALID_OPERATION, msg.string());
}
@@ -1875,6 +1987,8 @@
* Also check that the device HAL version is still in support
*/
int CameraService::checkCameraCapabilities(int id, camera_info info, int *latestStrangeCameraId) {
+ if (mModule == nullptr) return NO_INIT;
+
// device_version undefined in CAMERA_MODULE_API_VERSION_1_0,
// All CAMERA_MODULE_API_VERSION_1_0 devices are backward-compatible
if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
@@ -2184,24 +2298,25 @@
CameraService::Client::Client(const sp<CameraService>& cameraService,
const sp<ICameraClient>& cameraClient,
const String16& clientPackageName,
- int cameraId, int cameraFacing,
+ const String8& cameraIdStr, int cameraFacing,
int clientPid, uid_t clientUid,
int servicePid) :
CameraService::BasicClient(cameraService,
IInterface::asBinder(cameraClient),
clientPackageName,
- cameraId, cameraFacing,
+ cameraIdStr, cameraFacing,
clientPid, clientUid,
- servicePid)
+ servicePid),
+ mCameraId(CameraService::cameraIdToInt(cameraIdStr))
{
int callingPid = getCallingPid();
- LOG1("Client::Client E (pid %d, id %d)", callingPid, cameraId);
+ LOG1("Client::Client E (pid %d, id %d)", callingPid, mCameraId);
mRemoteCallback = cameraClient;
cameraService->loadSound();
- LOG1("Client::Client X (pid %d, id %d)", callingPid, cameraId);
+ LOG1("Client::Client X (pid %d, id %d)", callingPid, mCameraId);
}
// tear down the client
@@ -2209,26 +2324,28 @@
ALOGV("~Client");
mDestructionStarted = true;
- mCameraService->releaseSound();
+ sCameraService->releaseSound();
// unconditionally disconnect. function is idempotent
Client::disconnect();
}
+sp<CameraService> CameraService::BasicClient::BasicClient::sCameraService;
+
CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService,
const sp<IBinder>& remoteCallback,
const String16& clientPackageName,
- int cameraId, int cameraFacing,
+ const String8& cameraIdStr, int cameraFacing,
int clientPid, uid_t clientUid,
int servicePid):
- mClientPackageName(clientPackageName), mDisconnected(false)
+ mCameraIdStr(cameraIdStr), mCameraFacing(cameraFacing),
+ mClientPackageName(clientPackageName), mClientPid(clientPid), mClientUid(clientUid),
+ mServicePid(servicePid),
+ mDisconnected(false),
+ mRemoteBinder(remoteCallback)
{
- mCameraService = cameraService;
- mRemoteBinder = remoteCallback;
- mCameraId = cameraId;
- mCameraFacing = cameraFacing;
- mClientPid = clientPid;
- mClientUid = clientUid;
- mServicePid = servicePid;
+ if (sCameraService == nullptr) {
+ sCameraService = cameraService;
+ }
mOpsActive = false;
mDestructionStarted = false;
@@ -2276,19 +2393,20 @@
}
mDisconnected = true;
- mCameraService->removeByClient(this);
- mCameraService->logDisconnected(String8::format("%d", mCameraId), mClientPid,
+ sCameraService->removeByClient(this);
+ sCameraService->logDisconnected(mCameraIdStr, mClientPid,
String8(mClientPackageName));
sp<IBinder> remote = getRemote();
if (remote != nullptr) {
- remote->unlinkToDeath(mCameraService);
+ remote->unlinkToDeath(sCameraService);
}
finishCameraOps();
// Notify flashlight that a camera device is closed.
- mCameraService->mFlashlight->deviceClosed(String8::format("%d", mCameraId));
- ALOGI("%s: Disconnected client for camera %d for PID %d", __FUNCTION__, mCameraId, mClientPid);
+ sCameraService->mFlashlight->deviceClosed(mCameraIdStr);
+ ALOGI("%s: Disconnected client for camera %s for PID %d", __FUNCTION__, mCameraIdStr.string(),
+ mClientPid);
// client shouldn't be able to call into us anymore
mClientPid = 0;
@@ -2340,14 +2458,14 @@
mClientUid, mClientPackageName);
if (res == AppOpsManager::MODE_ERRORED) {
- ALOGI("Camera %d: Access for \"%s\" has been revoked",
- mCameraId, String8(mClientPackageName).string());
+ ALOGI("Camera %s: Access for \"%s\" has been revoked",
+ mCameraIdStr.string(), String8(mClientPackageName).string());
return PERMISSION_DENIED;
}
if (res == AppOpsManager::MODE_IGNORED) {
- ALOGI("Camera %d: Access for \"%s\" has been restricted",
- mCameraId, String8(mClientPackageName).string());
+ ALOGI("Camera %s: Access for \"%s\" has been restricted",
+ mCameraIdStr.string(), String8(mClientPackageName).string());
// Return the same error as for device policy manager rejection
return -EACCES;
}
@@ -2355,12 +2473,11 @@
mOpsActive = true;
// Transition device availability listeners from PRESENT -> NOT_AVAILABLE
- mCameraService->updateStatus(StatusInternal::NOT_AVAILABLE,
- String8::format("%d", mCameraId));
+ sCameraService->updateStatus(StatusInternal::NOT_AVAILABLE, mCameraIdStr);
// Transition device state to OPEN
- mCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN,
- String8::format("%d", mCameraId));
+ sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN,
+ mCameraIdStr);
return OK;
}
@@ -2379,12 +2496,12 @@
StatusInternal::ENUMERATING};
// Transition to PRESENT if the camera is not in either of the rejected states
- mCameraService->updateStatus(StatusInternal::PRESENT,
- String8::format("%d", mCameraId), rejected);
+ sCameraService->updateStatus(StatusInternal::PRESENT,
+ mCameraIdStr, rejected);
// Transition device state to CLOSED
- mCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_CLOSED,
- String8::format("%d", mCameraId));
+ sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_CLOSED,
+ mCameraIdStr);
}
// Always stop watching, even if no camera op is active
if (mOpsCallback != NULL) {
@@ -2416,7 +2533,7 @@
"UNKNOWN");
if (res != AppOpsManager::MODE_ALLOWED) {
- ALOGI("Camera %d: Access for \"%s\" revoked", mCameraId,
+ ALOGI("Camera %s: Access for \"%s\" revoked", mCameraIdStr.string(),
myName.string());
// Reset the client PID to allow server-initiated disconnect,
// and to prevent further calls by client.
@@ -2429,17 +2546,6 @@
// ----------------------------------------------------------------------------
-// Provide client strong pointer for callbacks.
-sp<CameraService::Client> CameraService::Client::getClientFromCookie(void* user) {
- String8 cameraId = String8::format("%d", (int)(intptr_t) user);
- auto clientDescriptor = gCameraService->mActiveClientManager.get(cameraId);
- if (clientDescriptor != nullptr) {
- return sp<Client>{
- static_cast<Client*>(clientDescriptor->getValue().get())};
- }
- return sp<Client>{nullptr};
-}
-
void CameraService::Client::notifyError(int32_t errorCode,
const CaptureResultExtras& resultExtras) {
(void) errorCode;
@@ -2645,8 +2751,8 @@
}
bool hasClient = false;
- if (!mModule) {
- result = String8::format("No camera module available!\n");
+ if (!mInitialized) {
+ result = String8::format("No camera HAL available!\n");
write(fd, result.string(), result.size());
// Dump event log for error information
@@ -2655,6 +2761,13 @@
if (locked) mServiceLock.unlock();
return NO_ERROR;
}
+ if (mModule == nullptr) {
+ mCameraProviderManager->dump(fd, args);
+ // TODO - need way more dumping here
+
+ if (locked) mServiceLock.unlock();
+ return NO_ERROR;
+ }
result = String8::format("Camera module HAL API version: 0x%x\n", mModule->getHalApiVersion());
result.appendFormat("Camera module API version: 0x%x\n", mModule->getModuleApiVersion());
@@ -2692,7 +2805,6 @@
result = String8::format("Camera %s information:\n", cameraId.string());
camera_info info;
- // TODO: Change getCameraInfo + HAL to use String cameraIds
status_t rc = mModule->getCameraInfo(cameraIdToInt(cameraId), &info);
if (rc != OK) {
result.appendFormat(" Error reading static information!\n");
diff --git a/services/camera/libcameraservice/CameraService.h b/services/camera/libcameraservice/CameraService.h
index a6c2fa8..d463b59 100644
--- a/services/camera/libcameraservice/CameraService.h
+++ b/services/camera/libcameraservice/CameraService.h
@@ -38,6 +38,7 @@
#include "CameraFlashlight.h"
#include "common/CameraModule.h"
+#include "common/CameraProviderManager.h"
#include "media/RingBuffer.h"
#include "utils/AutoConditionLock.h"
#include "utils/ClientManager.h"
@@ -57,11 +58,13 @@
class CameraService :
public BinderService<CameraService>,
- public ::android::hardware::BnCameraService,
- public IBinder::DeathRecipient,
- public camera_module_callbacks_t
+ public virtual ::android::hardware::BnCameraService,
+ public virtual IBinder::DeathRecipient,
+ public camera_module_callbacks_t,
+ public virtual CameraProviderManager::StatusListener
{
friend class BinderService<CameraService>;
+ friend class CameraClient;
public:
class Client;
class BasicClient;
@@ -96,11 +99,12 @@
virtual ~CameraService();
/////////////////////////////////////////////////////////////////////
- // HAL Callbacks
+ // HAL Callbacks - implements CameraProviderManager::StatusListener
+
virtual void onDeviceStatusChanged(const String8 &cameraId,
- hardware::camera::common::V1_0::CameraDeviceStatus newHalStatus);
+ hardware::camera::common::V1_0::CameraDeviceStatus newHalStatus) override;
virtual void onTorchStatusChanged(const String8& cameraId,
- hardware::camera::common::V1_0::TorchModeStatus newStatus);
+ hardware::camera::common::V1_0::TorchModeStatus newStatus) override;
/////////////////////////////////////////////////////////////////////
// ICameraService
@@ -108,7 +112,7 @@
virtual binder::Status getCameraInfo(int cameraId,
hardware::CameraInfo* cameraInfo);
- virtual binder::Status getCameraCharacteristics(const String16& id,
+ virtual binder::Status getCameraCharacteristics(const String16& cameraId,
CameraMetadata* cameraInfo);
virtual binder::Status getCameraVendorTagDescriptor(
/*out*/
@@ -185,7 +189,7 @@
/////////////////////////////////////////////////////////////////////
// CameraDeviceFactory functionality
- int getDeviceVersion(int cameraId, int* facing = NULL);
+ int getDeviceVersion(const String8& cameraId, int* facing = NULL);
/////////////////////////////////////////////////////////////////////
// Shared utilities
@@ -197,6 +201,7 @@
class BasicClient : public virtual RefBase {
public:
virtual status_t initialize(CameraModule *module) = 0;
+ virtual status_t initialize(sp<CameraProviderManager> manager) = 0;
virtual binder::Status disconnect();
// because we can't virtually inherit IInterface, which breaks
@@ -233,7 +238,7 @@
BasicClient(const sp<CameraService>& cameraService,
const sp<IBinder>& remoteCallback,
const String16& clientPackageName,
- int cameraId,
+ const String8& cameraIdStr,
int cameraFacing,
int clientPid,
uid_t clientUid,
@@ -248,13 +253,13 @@
bool mDestructionStarted;
// these are initialized in the constructor.
- sp<CameraService> mCameraService; // immutable after constructor
- int mCameraId; // immutable after constructor
- int mCameraFacing; // immutable after constructor
- String16 mClientPackageName; // immutable after constructor
+ static sp<CameraService> sCameraService;
+ const String8 mCameraIdStr;
+ const int mCameraFacing;
+ String16 mClientPackageName;
pid_t mClientPid;
- uid_t mClientUid; // immutable after constructor
- pid_t mServicePid; // immutable after constructor
+ const uid_t mClientUid;
+ const pid_t mServicePid;
bool mDisconnected;
// - The app-side Binder interface to receive callbacks from us
@@ -320,7 +325,7 @@
Client(const sp<CameraService>& cameraService,
const sp<hardware::ICameraClient>& cameraClient,
const String16& clientPackageName,
- int cameraId,
+ const String8& cameraIdStr,
int cameraFacing,
int clientPid,
uid_t clientUid,
@@ -343,14 +348,12 @@
// superclass this can be cast to.
virtual bool canCastToApiClient(apiLevel level) const;
protected:
- // Convert client from cookie.
- static sp<CameraService::Client> getClientFromCookie(void* user);
-
// Initialized in constructor
// - The app-side Binder interface to receive callbacks from us
sp<hardware::ICameraClient> mRemoteCallback;
+ int mCameraId; // All API1 clients use integer camera IDs
}; // class Client
/**
@@ -438,6 +441,7 @@
*/
class CameraState {
public:
+
/**
* Make a new CameraState and set the ID, cost, and conflicting devices using the values
* returned in the HAL's camera_info struct for each device.
@@ -506,6 +510,12 @@
// Delay-load the Camera HAL module
virtual void onFirstRef();
+ // Load the legacy HAL module
+ status_t loadLegacyHalModule();
+
+ // Eumerate all camera providers in the system
+ status_t enumerateProviders();
+
// Check if we can connect, before we acquire the service lock.
// The returned originalClientPid is the PID of the original process that wants to connect to
// camera.
@@ -676,7 +686,11 @@
sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS];
int mSoundRef; // reference count (release all MediaPlayer when 0)
- CameraModule* mModule;
+ // Basic flag on whether the camera subsystem is in a usable state
+ bool mInitialized;
+
+ CameraModule* mModule;
+ sp<CameraProviderManager> mCameraProviderManager;
// Guarded by mStatusListenerMutex
std::vector<sp<hardware::ICameraServiceListener>> mListenerList;
@@ -767,7 +781,7 @@
static int getCameraPriorityFromProcState(int procState);
static binder::Status makeClient(const sp<CameraService>& cameraService,
- const sp<IInterface>& cameraCb, const String16& packageName, int cameraId,
+ const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
/*out*/sp<BasicClient>* client);
diff --git a/services/camera/libcameraservice/api1/Camera2Client.cpp b/services/camera/libcameraservice/api1/Camera2Client.cpp
index bfbf640..3aec562 100644
--- a/services/camera/libcameraservice/api1/Camera2Client.cpp
+++ b/services/camera/libcameraservice/api1/Camera2Client.cpp
@@ -56,7 +56,8 @@
int servicePid,
bool legacyMode):
Camera2ClientBase(cameraService, cameraClient, clientPackageName,
- cameraId, cameraFacing, clientPid, clientUid, servicePid),
+ String8::format("%d", cameraId), cameraFacing,
+ clientPid, clientUid, servicePid),
mParameters(cameraId, cameraFacing)
{
ATRACE_CALL();
@@ -67,13 +68,22 @@
mLegacyMode = legacyMode;
}
-status_t Camera2Client::initialize(CameraModule *module)
+status_t Camera2Client::initialize(CameraModule *module) {
+ return initializeImpl(module);
+}
+
+status_t Camera2Client::initialize(sp<CameraProviderManager> manager) {
+ return initializeImpl(manager);
+}
+
+template<typename TProviderPtr>
+status_t Camera2Client::initializeImpl(TProviderPtr providerPtr)
{
ATRACE_CALL();
ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
status_t res;
- res = Camera2ClientBase::initialize(module);
+ res = Camera2ClientBase::initialize(providerPtr);
if (res != OK) {
return res;
}
@@ -1034,7 +1044,7 @@
}
if (!restart) {
- mCameraService->playSound(CameraService::SOUND_RECORDING_START);
+ sCameraService->playSound(CameraService::SOUND_RECORDING_START);
mStreamingProcessor->updateRecordingRequest(params);
if (res != OK) {
ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
@@ -1191,7 +1201,7 @@
return;
};
- mCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
+ sCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
// Remove recording stream because the video target may be abandoned soon.
res = stopStream();
@@ -1621,7 +1631,7 @@
}
status_t Camera2Client::commandPlayRecordingSoundL() {
- mCameraService->playSound(CameraService::SOUND_RECORDING_START);
+ sCameraService->playSound(CameraService::SOUND_RECORDING_START);
return OK;
}
diff --git a/services/camera/libcameraservice/api1/Camera2Client.h b/services/camera/libcameraservice/api1/Camera2Client.h
index e2129f5..87c91a0 100644
--- a/services/camera/libcameraservice/api1/Camera2Client.h
+++ b/services/camera/libcameraservice/api1/Camera2Client.h
@@ -98,7 +98,8 @@
virtual ~Camera2Client();
- status_t initialize(CameraModule *module);
+ virtual status_t initialize(CameraModule *module) override;
+ virtual status_t initialize(sp<CameraProviderManager> manager) override;
virtual status_t dump(int fd, const Vector<String16>& args);
@@ -219,6 +220,9 @@
// Video snapshot jpeg size overriding helper function
status_t overrideVideoSnapshotSize(Parameters ¶ms);
+
+ template<typename TProviderPtr>
+ status_t initializeImpl(TProviderPtr providerPtr);
};
}; // namespace android
diff --git a/services/camera/libcameraservice/api1/CameraClient.cpp b/services/camera/libcameraservice/api1/CameraClient.cpp
index 266fb03..b83d425 100644
--- a/services/camera/libcameraservice/api1/CameraClient.cpp
+++ b/services/camera/libcameraservice/api1/CameraClient.cpp
@@ -41,7 +41,8 @@
int clientPid, int clientUid,
int servicePid, bool legacyMode):
Client(cameraService, cameraClient, clientPackageName,
- cameraId, cameraFacing, clientPid, clientUid, servicePid)
+ String8::format("%d", cameraId), cameraFacing, clientPid,
+ clientUid, servicePid)
{
int callingPid = getCallingPid();
LOG1("CameraClient::CameraClient E (pid %d, id %d)", callingPid, cameraId);
@@ -61,6 +62,15 @@
}
status_t CameraClient::initialize(CameraModule *module) {
+ return initializeImpl<CameraModule*>(module);
+}
+
+status_t CameraClient::initialize(sp<CameraProviderManager> manager) {
+ return initializeImpl<sp<CameraProviderManager>>(manager);
+}
+
+template<typename TProviderPtr>
+status_t CameraClient::initializeImpl(TProviderPtr providerPtr) {
int callingPid = getCallingPid();
status_t res;
@@ -76,7 +86,7 @@
snprintf(camera_device_name, sizeof(camera_device_name), "%d", mCameraId);
mHardware = new CameraHardwareInterface(camera_device_name);
- res = mHardware->initialize(module);
+ res = mHardware->initialize(providerPtr);
if (res != OK) {
ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
__FUNCTION__, mCameraId, strerror(-res), res);
@@ -252,7 +262,7 @@
// Turn off all messages.
disableMsgType(CAMERA_MSG_ALL_MSGS);
mHardware->stopPreview();
- mCameraService->updateProxyDeviceState(
+ sCameraService->updateProxyDeviceState(
ICameraServiceProxy::CAMERA_STATE_IDLE,
String8::format("%d", mCameraId));
mHardware->cancelPicture();
@@ -414,7 +424,7 @@
mHardware->setPreviewWindow(mPreviewWindow);
result = mHardware->startPreview();
if (result == NO_ERROR) {
- mCameraService->updateProxyDeviceState(
+ sCameraService->updateProxyDeviceState(
ICameraServiceProxy::CAMERA_STATE_ACTIVE,
String8::format("%d", mCameraId));
}
@@ -440,7 +450,7 @@
// start recording mode
enableMsgType(CAMERA_MSG_VIDEO_FRAME);
- mCameraService->playSound(CameraService::SOUND_RECORDING_START);
+ sCameraService->playSound(CameraService::SOUND_RECORDING_START);
result = mHardware->startRecording();
if (result != NO_ERROR) {
ALOGE("mHardware->startRecording() failed with status %d", result);
@@ -457,7 +467,7 @@
disableMsgType(CAMERA_MSG_PREVIEW_FRAME);
mHardware->stopPreview();
- mCameraService->updateProxyDeviceState(
+ sCameraService->updateProxyDeviceState(
ICameraServiceProxy::CAMERA_STATE_IDLE,
String8::format("%d", mCameraId));
mPreviewBuffer.clear();
@@ -471,7 +481,7 @@
disableMsgType(CAMERA_MSG_VIDEO_FRAME);
mHardware->stopRecording();
- mCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
+ sCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
mPreviewBuffer.clear();
}
@@ -697,7 +707,7 @@
}
return OK;
} else if (cmd == CAMERA_CMD_PLAY_RECORDING_SOUND) {
- mCameraService->playSound(CameraService::SOUND_RECORDING_START);
+ sCameraService->playSound(CameraService::SOUND_RECORDING_START);
} else if (cmd == CAMERA_CMD_SET_VIDEO_BUFFER_COUNT) {
// Silently ignore this command
return INVALID_OPERATION;
@@ -748,6 +758,16 @@
return false;
}
+sp<CameraClient> CameraClient::getClientFromCookie(void* user) {
+ String8 cameraId = String8::format("%d", (int)(intptr_t) user);
+ auto clientDescriptor = sCameraService->mActiveClientManager.get(cameraId);
+ if (clientDescriptor != nullptr) {
+ return sp<CameraClient>{
+ static_cast<CameraClient*>(clientDescriptor->getValue().get())};
+ }
+ return sp<CameraClient>{nullptr};
+}
+
// Callback messages can be dispatched to internal handlers or pass to our
// client's callback functions, depending on the message type.
//
@@ -767,7 +787,7 @@
int32_t ext2, void* user) {
LOG2("notifyCallback(%d)", msgType);
- sp<CameraClient> client = static_cast<CameraClient*>(getClientFromCookie(user).get());
+ sp<CameraClient> client = getClientFromCookie(user);
if (client.get() == nullptr) return;
if (!client->lockIfMessageWanted(msgType)) return;
@@ -787,7 +807,7 @@
const sp<IMemory>& dataPtr, camera_frame_metadata_t *metadata, void* user) {
LOG2("dataCallback(%d)", msgType);
- sp<CameraClient> client = static_cast<CameraClient*>(getClientFromCookie(user).get());
+ sp<CameraClient> client = getClientFromCookie(user);
if (client.get() == nullptr) return;
if (!client->lockIfMessageWanted(msgType)) return;
@@ -820,7 +840,7 @@
int32_t msgType, const sp<IMemory>& dataPtr, void* user) {
LOG2("dataCallbackTimestamp(%d)", msgType);
- sp<CameraClient> client = static_cast<CameraClient*>(getClientFromCookie(user).get());
+ sp<CameraClient> client = getClientFromCookie(user);
if (client.get() == nullptr) return;
if (!client->lockIfMessageWanted(msgType)) return;
@@ -837,7 +857,7 @@
// snapshot taken callback
void CameraClient::handleShutter(void) {
if (mPlayShutterSound) {
- mCameraService->playSound(CameraService::SOUND_SHUTTER);
+ sCameraService->playSound(CameraService::SOUND_SHUTTER);
}
sp<hardware::ICameraClient> c = mRemoteCallback;
@@ -850,7 +870,7 @@
// Shutters only happen in response to takePicture, so mark device as
// idle now, until preview is restarted
- mCameraService->updateProxyDeviceState(
+ sCameraService->updateProxyDeviceState(
ICameraServiceProxy::CAMERA_STATE_IDLE,
String8::format("%d", mCameraId));
diff --git a/services/camera/libcameraservice/api1/CameraClient.h b/services/camera/libcameraservice/api1/CameraClient.h
index 4f46fc4..91f00e3 100644
--- a/services/camera/libcameraservice/api1/CameraClient.h
+++ b/services/camera/libcameraservice/api1/CameraClient.h
@@ -70,7 +70,8 @@
bool legacyMode = false);
~CameraClient();
- status_t initialize(CameraModule *module);
+ virtual status_t initialize(CameraModule *module) override;
+ virtual status_t initialize(sp<CameraProviderManager> manager) override;
virtual status_t dump(int fd, const Vector<String16>& args);
@@ -78,6 +79,9 @@
private:
+ template<typename TProviderPtr>
+ status_t initializeImpl(TProviderPtr providerPtr);
+
// check whether the calling process matches mClientPid.
status_t checkPid() const;
status_t checkPidAndHardware() const; // also check mHardware != 0
@@ -98,6 +102,8 @@
// internal function used by sendCommand to enable/disable shutter sound.
status_t enableShutterSound(bool enable);
+ static sp<CameraClient> getClientFromCookie(void* user);
+
// these are static callback functions
static void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user);
static void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr,
diff --git a/services/camera/libcameraservice/api1/client2/Parameters.cpp b/services/camera/libcameraservice/api1/client2/Parameters.cpp
index 32b99ca..6efe4e3 100644
--- a/services/camera/libcameraservice/api1/client2/Parameters.cpp
+++ b/services/camera/libcameraservice/api1/client2/Parameters.cpp
@@ -917,6 +917,8 @@
} else {
allowZslMode = true;
}
+ // TODO (b/34131351): turn ZSL back on after fixing the issue
+ allowZslMode = false;
ALOGI("%s: allowZslMode: %d slowJpegMode %d", __FUNCTION__, allowZslMode, slowJpegMode);
diff --git a/services/camera/libcameraservice/api2/CameraDeviceClient.cpp b/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
index 5166eb5..d490119 100644
--- a/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
+++ b/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
@@ -46,7 +46,7 @@
const sp<CameraService>& cameraService,
const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
const String16& clientPackageName,
- int cameraId,
+ const String8& cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
@@ -67,7 +67,7 @@
CameraDeviceClient::CameraDeviceClient(const sp<CameraService>& cameraService,
const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
const String16& clientPackageName,
- int cameraId,
+ const String8& cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
@@ -79,22 +79,30 @@
mRequestIdCounter(0) {
ATRACE_CALL();
- ALOGI("CameraDeviceClient %d: Opened", cameraId);
+ ALOGI("CameraDeviceClient %s: Opened", cameraId.string());
}
-status_t CameraDeviceClient::initialize(CameraModule *module)
-{
+status_t CameraDeviceClient::initialize(CameraModule *module) {
+ return initializeImpl(module);
+}
+
+status_t CameraDeviceClient::initialize(sp<CameraProviderManager> manager) {
+ return initializeImpl(manager);
+}
+
+template<typename TProviderPtr>
+status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr) {
ATRACE_CALL();
status_t res;
- res = Camera2ClientBase::initialize(module);
+ res = Camera2ClientBase::initialize(providerPtr);
if (res != OK) {
return res;
}
String8 threadName;
mFrameProcessor = new FrameProcessorBase(mDevice);
- threadName = String8::format("CDU-%d-FrameProc", mCameraId);
+ threadName = String8::format("CDU-%s-FrameProc", mCameraIdStr.string());
mFrameProcessor->run(threadName.string());
mFrameProcessor->registerListener(FRAME_PROCESSOR_LISTENER_MIN_ID,
@@ -138,8 +146,8 @@
}
if (requests.empty()) {
- ALOGE("%s: Camera %d: Sent null request. Rejecting request.",
- __FUNCTION__, mCameraId);
+ ALOGE("%s: Camera %s: Sent null request. Rejecting request.",
+ __FUNCTION__, mCameraIdStr.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Empty request list");
}
@@ -150,13 +158,14 @@
for (auto&& request: requests) {
if (request.mIsReprocess) {
if (!mInputStream.configured) {
- ALOGE("%s: Camera %d: no input stream is configured.", __FUNCTION__, mCameraId);
+ ALOGE("%s: Camera %s: no input stream is configured.", __FUNCTION__,
+ mCameraIdStr.string());
return STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
- "No input configured for camera %d but request is for reprocessing",
- mCameraId);
+ "No input configured for camera %s but request is for reprocessing",
+ mCameraIdStr.string());
} else if (streaming) {
- ALOGE("%s: Camera %d: streaming reprocess requests not supported.", __FUNCTION__,
- mCameraId);
+ ALOGE("%s: Camera %s: streaming reprocess requests not supported.", __FUNCTION__,
+ mCameraIdStr.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
"Repeating reprocess requests not supported");
}
@@ -164,13 +173,13 @@
CameraMetadata metadata(request.mMetadata);
if (metadata.isEmpty()) {
- ALOGE("%s: Camera %d: Sent empty metadata packet. Rejecting request.",
- __FUNCTION__, mCameraId);
+ ALOGE("%s: Camera %s: Sent empty metadata packet. Rejecting request.",
+ __FUNCTION__, mCameraIdStr.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
"Request settings are empty");
} else if (request.mSurfaceList.isEmpty()) {
- ALOGE("%s: Camera %d: Requests must have at least one surface target. "
- "Rejecting request.", __FUNCTION__, mCameraId);
+ ALOGE("%s: Camera %s: Requests must have at least one surface target. "
+ "Rejecting request.", __FUNCTION__, mCameraIdStr.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
"Request has no output targets");
}
@@ -195,17 +204,17 @@
// Trying to submit request with surface that wasn't created
if (idx == NAME_NOT_FOUND) {
- ALOGE("%s: Camera %d: Tried to submit a request with a surface that"
+ ALOGE("%s: Camera %s: Tried to submit a request with a surface that"
" we have not called createStream on",
- __FUNCTION__, mCameraId);
+ __FUNCTION__, mCameraIdStr.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
"Request targets Surface that is not part of current capture session");
}
int streamId = mStreamMap.valueAt(idx);
outputStreamIds.push_back(streamId);
- ALOGV("%s: Camera %d: Appending output stream %d to request",
- __FUNCTION__, mCameraId, streamId);
+ ALOGV("%s: Camera %s: Appending output stream %d to request",
+ __FUNCTION__, mCameraIdStr.string(), streamId);
}
metadata.update(ANDROID_REQUEST_OUTPUT_STREAMS, &outputStreamIds[0],
@@ -217,8 +226,9 @@
metadata.update(ANDROID_REQUEST_ID, &(submitInfo->mRequestId), /*size*/1);
loopCounter++; // loopCounter starts from 1
- ALOGV("%s: Camera %d: Creating request with ID %d (%d of %zu)",
- __FUNCTION__, mCameraId, submitInfo->mRequestId, loopCounter, requests.size());
+ ALOGV("%s: Camera %s: Creating request with ID %d (%d of %zu)",
+ __FUNCTION__, mCameraIdStr.string(), submitInfo->mRequestId,
+ loopCounter, requests.size());
metadataRequestList.push_back(metadata);
}
@@ -228,8 +238,8 @@
err = mDevice->setStreamingRequestList(metadataRequestList, &(submitInfo->mLastFrameNumber));
if (err != OK) {
String8 msg = String8::format(
- "Camera %d: Got error %s (%d) after trying to set streaming request",
- mCameraId, strerror(-err), err);
+ "Camera %s: Got error %s (%d) after trying to set streaming request",
+ mCameraIdStr.string(), strerror(-err), err);
ALOGE("%s: %s", __FUNCTION__, msg.string());
res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION,
msg.string());
@@ -241,8 +251,8 @@
err = mDevice->captureList(metadataRequestList, &(submitInfo->mLastFrameNumber));
if (err != OK) {
String8 msg = String8::format(
- "Camera %d: Got error %s (%d) after trying to submit capture request",
- mCameraId, strerror(-err), err);
+ "Camera %s: Got error %s (%d) after trying to submit capture request",
+ mCameraIdStr.string(), strerror(-err), err);
ALOGE("%s: %s", __FUNCTION__, msg.string());
res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION,
msg.string());
@@ -250,7 +260,7 @@
ALOGV("%s: requestId = %d ", __FUNCTION__, submitInfo->mRequestId);
}
- ALOGV("%s: Camera %d: End of function", __FUNCTION__, mCameraId);
+ ALOGV("%s: Camera %s: End of function", __FUNCTION__, mCameraIdStr.string());
return res;
}
@@ -274,8 +284,8 @@
Mutex::Autolock idLock(mStreamingRequestIdLock);
if (mStreamingRequestId != requestId) {
- String8 msg = String8::format("Camera %d: Canceling request ID %d doesn't match "
- "current request ID %d", mCameraId, requestId, mStreamingRequestId);
+ String8 msg = String8::format("Camera %s: Canceling request ID %d doesn't match "
+ "current request ID %d", mCameraIdStr.string(), requestId, mStreamingRequestId);
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
}
@@ -283,13 +293,13 @@
err = mDevice->clearStreamingRequest(lastFrameNumber);
if (err == OK) {
- ALOGV("%s: Camera %d: Successfully cleared streaming request",
- __FUNCTION__, mCameraId);
+ ALOGV("%s: Camera %s: Successfully cleared streaming request",
+ __FUNCTION__, mCameraIdStr.string());
mStreamingRequestId = REQUEST_ID_NONE;
} else {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error clearing streaming request: %s (%d)",
- mCameraId, strerror(-err), err);
+ "Camera %s: Error clearing streaming request: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
}
return res;
@@ -328,8 +338,8 @@
}
if (!isConstrainedHighSpeedSupported) {
String8 msg = String8::format(
- "Camera %d: Try to create a constrained high speed configuration on a device"
- " that doesn't support it.", mCameraId);
+ "Camera %s: Try to create a constrained high speed configuration on a device"
+ " that doesn't support it.", mCameraIdStr.string());
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
msg.string());
@@ -338,13 +348,13 @@
status_t err = mDevice->configureStreams(isConstrainedHighSpeed);
if (err == BAD_VALUE) {
- String8 msg = String8::format("Camera %d: Unsupported set of inputs/outputs provided",
- mCameraId);
+ 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 %d: Error configuring streams: %s (%d)",
- mCameraId, strerror(-err), err);
+ 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());
}
@@ -389,8 +399,8 @@
}
}
if (dIndex == NAME_NOT_FOUND) {
- String8 msg = String8::format("Camera %d: Invalid stream ID (%d) specified, no such"
- " stream created yet", mCameraId, streamId);
+ String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no such"
+ " stream created yet", mCameraIdStr.string(), streamId);
ALOGW("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
}
@@ -401,8 +411,8 @@
status_t err = mDevice->deleteStream(streamId);
if (err != OK) {
- String8 msg = String8::format("Camera %d: Unexpected error %s (%d) when deleting stream %d",
- mCameraId, strerror(-err), err, streamId);
+ String8 msg = String8::format("Camera %s: Unexpected error %s (%d) when deleting stream %d",
+ mCameraIdStr.string(), strerror(-err), err, streamId);
ALOGE("%s: %s", __FUNCTION__, msg.string());
res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
} else {
@@ -458,8 +468,8 @@
{
ssize_t index = mStreamMap.indexOfKey(IInterface::asBinder(bufferProducer));
if (index != NAME_NOT_FOUND) {
- String8 msg = String8::format("Camera %d: Surface already has a stream created for it "
- "(ID %zd)", mCameraId, index);
+ String8 msg = String8::format("Camera %s: Surface already has a stream created for it "
+ "(ID %zd)", mCameraIdStr.string(), index);
ALOGW("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ALREADY_EXISTS, msg.string());
}
@@ -471,14 +481,14 @@
bool useAsync = false;
if ((err = bufferProducer->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS,
&consumerUsage)) != OK) {
- String8 msg = String8::format("Camera %d: Failed to query Surface consumer usage: %s (%d)",
- mCameraId, strerror(-err), err);
+ String8 msg = String8::format("Camera %s: Failed to query Surface consumer usage: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
}
if (consumerUsage & GraphicBuffer::USAGE_HW_TEXTURE) {
- ALOGW("%s: Camera %d with consumer usage flag: 0x%x: Forcing asynchronous mode for stream",
- __FUNCTION__, mCameraId, consumerUsage);
+ ALOGW("%s: Camera %s with consumer usage flag: 0x%x: Forcing asynchronous mode for stream",
+ __FUNCTION__, mCameraIdStr.string(), consumerUsage);
useAsync = true;
}
@@ -495,27 +505,27 @@
ANativeWindow *anw = surface.get();
if ((err = anw->query(anw, NATIVE_WINDOW_WIDTH, &width)) != OK) {
- String8 msg = String8::format("Camera %d: Failed to query Surface width: %s (%d)",
- mCameraId, strerror(-err), err);
+ String8 msg = String8::format("Camera %s: Failed to query Surface width: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
}
if ((err = anw->query(anw, NATIVE_WINDOW_HEIGHT, &height)) != OK) {
- String8 msg = String8::format("Camera %d: Failed to query Surface height: %s (%d)",
- mCameraId, strerror(-err), err);
+ String8 msg = String8::format("Camera %s: Failed to query Surface height: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
}
if ((err = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) {
- String8 msg = String8::format("Camera %d: Failed to query Surface format: %s (%d)",
- mCameraId, strerror(-err), err);
+ String8 msg = String8::format("Camera %s: Failed to query Surface format: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
}
if ((err = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE,
reinterpret_cast<int*>(&dataSpace))) != OK) {
- String8 msg = String8::format("Camera %d: Failed to query Surface dataspace: %s (%d)",
- mCameraId, strerror(-err), err);
+ String8 msg = String8::format("Camera %s: Failed to query Surface dataspace: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
}
@@ -524,8 +534,8 @@
// IMPLEMENTATION_DEFINED. b/9487482
if (format >= HAL_PIXEL_FORMAT_RGBA_8888 &&
format <= HAL_PIXEL_FORMAT_BGRA_8888) {
- ALOGW("%s: Camera %d: Overriding format %#x to IMPLEMENTATION_DEFINED",
- __FUNCTION__, mCameraId, format);
+ ALOGW("%s: Camera %s: Overriding format %#x to IMPLEMENTATION_DEFINED",
+ __FUNCTION__, mCameraIdStr.string(), format);
format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
}
@@ -533,8 +543,8 @@
if (flexibleConsumer && isPublicFormat(format) &&
!CameraDeviceClient::roundBufferDimensionNearest(width, height,
format, dataSpace, mDevice->info(), /*out*/&width, /*out*/&height)) {
- String8 msg = String8::format("Camera %d: No supported stream configurations with "
- "format %#x defined, failed to create output stream", mCameraId, format);
+ String8 msg = String8::format("Camera %s: No supported stream configurations with "
+ "format %#x defined, failed to create output stream", mCameraIdStr.string(), format);
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
}
@@ -546,14 +556,14 @@
if (err != OK) {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error creating output stream (%d x %d, fmt %x, dataSpace %x): %s (%d)",
- mCameraId, width, height, format, dataSpace, strerror(-err), err);
+ "Camera %s: Error creating output stream (%d x %d, fmt %x, dataSpace %x): %s (%d)",
+ mCameraIdStr.string(), width, height, format, dataSpace, strerror(-err), err);
} else {
mStreamMap.add(binder, streamId);
- ALOGV("%s: Camera %d: Successfully created a new stream ID %d for output surface"
+ ALOGV("%s: Camera %s: Successfully created a new stream ID %d for output surface"
" (%d x %d) with format 0x%x.",
- __FUNCTION__, mCameraId, streamId, width, height, format);
+ __FUNCTION__, mCameraIdStr.string(), streamId, width, height, format);
// Set transform flags to ensure preview to be rotated correctly.
res = setStreamTransformLocked(streamId);
@@ -596,17 +606,17 @@
if (err != OK) {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error creating output stream (%d x %d, fmt %x, dataSpace %x): %s (%d)",
- mCameraId, width, height, format, dataSpace, strerror(-err), err);
+ "Camera %s: Error creating output stream (%d x %d, fmt %x, dataSpace %x): %s (%d)",
+ mCameraIdStr.string(), width, height, format, dataSpace, strerror(-err), err);
} else {
// Can not add streamId to mStreamMap here, as the surface is deferred. Add it to
// a separate list to track. Once the deferred surface is set, this id will be
// relocated to mStreamMap.
mDeferredStreams.push_back(streamId);
- ALOGV("%s: Camera %d: Successfully created a new stream ID %d for a deferred surface"
+ ALOGV("%s: Camera %s: Successfully created a new stream ID %d for a deferred surface"
" (%d x %d) stream with format 0x%x.",
- __FUNCTION__, mCameraId, streamId, width, height, format);
+ __FUNCTION__, mCameraIdStr.string(), streamId, width, height, format);
// Set transform flags to ensure preview to be rotated correctly.
res = setStreamTransformLocked(streamId);
@@ -661,8 +671,8 @@
}
if (mInputStream.configured) {
- String8 msg = String8::format("Camera %d: Already has an input stream "
- "configured (ID %zd)", mCameraId, mInputStream.id);
+ String8 msg = String8::format("Camera %s: Already has an input stream "
+ "configured (ID %zd)", mCameraIdStr.string(), mInputStream.id);
ALOGE("%s: %s", __FUNCTION__, msg.string() );
return STATUS_ERROR(CameraService::ERROR_ALREADY_EXISTS, msg.string());
}
@@ -676,13 +686,13 @@
mInputStream.format = format;
mInputStream.id = streamId;
- ALOGV("%s: Camera %d: Successfully created a new input stream ID %d",
- __FUNCTION__, mCameraId, streamId);
+ ALOGV("%s: Camera %s: Successfully created a new input stream ID %d",
+ __FUNCTION__, mCameraIdStr.string(), streamId);
*newStreamId = streamId;
} else {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error creating new input stream: %s (%d)", mCameraId,
+ "Camera %s: Error creating new input stream: %s (%d)", mCameraIdStr.string(),
strerror(-err), err);
}
@@ -706,8 +716,8 @@
status_t err = mDevice->getInputBufferProducer(&producer);
if (err != OK) {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error getting input Surface: %s (%d)",
- mCameraId, strerror(-err), err);
+ "Camera %s: Error getting input Surface: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
} else {
inputSurface->name = String16("CameraInput");
inputSurface->graphicBufferProducer = producer;
@@ -828,13 +838,13 @@
request->swap(metadata);
} else if (err == BAD_VALUE) {
res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
- "Camera %d: Template ID %d is invalid or not supported: %s (%d)",
- mCameraId, templateId, strerror(-err), err);
+ "Camera %s: Template ID %d is invalid or not supported: %s (%d)",
+ mCameraIdStr.string(), templateId, strerror(-err), err);
} else {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error creating default request for template %d: %s (%d)",
- mCameraId, templateId, strerror(-err), err);
+ "Camera %s: Error creating default request for template %d: %s (%d)",
+ mCameraIdStr.string(), templateId, strerror(-err), err);
}
return res;
}
@@ -882,16 +892,16 @@
Mutex::Autolock idLock(mStreamingRequestIdLock);
if (mStreamingRequestId != REQUEST_ID_NONE) {
String8 msg = String8::format(
- "Camera %d: Try to waitUntilIdle when there are active streaming requests",
- mCameraId);
+ "Camera %s: Try to waitUntilIdle when there are active streaming requests",
+ mCameraIdStr.string());
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
}
status_t err = mDevice->waitUntilDrained();
if (err != OK) {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error waiting to drain: %s (%d)",
- mCameraId, strerror(-err), err);
+ "Camera %s: Error waiting to drain: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
}
ALOGV("%s Done", __FUNCTION__);
return res;
@@ -917,7 +927,7 @@
status_t err = mDevice->flush(lastFrameNumber);
if (err != OK) {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error flushing device: %s (%d)", mCameraId, strerror(-err), err);
+ "Camera %s: Error flushing device: %s (%d)", mCameraIdStr.string(), strerror(-err), err);
}
return res;
}
@@ -941,8 +951,8 @@
}
if (index == NAME_NOT_FOUND) {
- String8 msg = String8::format("Camera %d: Invalid stream ID (%d) specified, no stream "
- "with that ID exists", mCameraId, streamId);
+ String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream "
+ "with that ID exists", mCameraIdStr.string(), streamId);
ALOGW("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
}
@@ -952,11 +962,11 @@
status_t err = mDevice->prepare(streamId);
if (err == BAD_VALUE) {
res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
- "Camera %d: Stream %d has already been used, and cannot be prepared",
- mCameraId, streamId);
+ "Camera %s: Stream %d has already been used, and cannot be prepared",
+ mCameraIdStr.string(), streamId);
} else if (err != OK) {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error preparing stream %d: %s (%d)", mCameraId, streamId,
+ "Camera %s: Error preparing stream %d: %s (%d)", mCameraIdStr.string(), streamId,
strerror(-err), err);
}
return res;
@@ -981,15 +991,15 @@
}
if (index == NAME_NOT_FOUND) {
- String8 msg = String8::format("Camera %d: Invalid stream ID (%d) specified, no stream "
- "with that ID exists", mCameraId, streamId);
+ String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream "
+ "with that ID exists", mCameraIdStr.string(), streamId);
ALOGW("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
}
if (maxCount <= 0) {
- String8 msg = String8::format("Camera %d: maxCount (%d) must be greater than 0",
- mCameraId, maxCount);
+ String8 msg = String8::format("Camera %s: maxCount (%d) must be greater than 0",
+ mCameraIdStr.string(), maxCount);
ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
}
@@ -999,11 +1009,11 @@
status_t err = mDevice->prepare(maxCount, streamId);
if (err == BAD_VALUE) {
res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
- "Camera %d: Stream %d has already been used, and cannot be prepared",
- mCameraId, streamId);
+ "Camera %s: Stream %d has already been used, and cannot be prepared",
+ mCameraIdStr.string(), streamId);
} else if (err != OK) {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error preparing stream %d: %s (%d)", mCameraId, streamId,
+ "Camera %s: Error preparing stream %d: %s (%d)", mCameraIdStr.string(), streamId,
strerror(-err), err);
}
@@ -1029,8 +1039,8 @@
}
if (index == NAME_NOT_FOUND) {
- String8 msg = String8::format("Camera %d: Invalid stream ID (%d) specified, no stream "
- "with that ID exists", mCameraId, streamId);
+ String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream "
+ "with that ID exists", mCameraIdStr.string(), streamId);
ALOGW("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
}
@@ -1040,11 +1050,11 @@
status_t err = mDevice->tearDown(streamId);
if (err == BAD_VALUE) {
res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
- "Camera %d: Stream %d is still in use, cannot be torn down",
- mCameraId, streamId);
+ "Camera %s: Stream %d is still in use, cannot be torn down",
+ mCameraIdStr.string(), streamId);
} else if (err != OK) {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error tearing down stream %d: %s (%d)", mCameraId, streamId,
+ "Camera %s: Error tearing down stream %d: %s (%d)", mCameraIdStr.string(), streamId,
strerror(-err), err);
}
@@ -1076,8 +1086,8 @@
}
}
if (index == NAME_NOT_FOUND) {
- String8 msg = String8::format("Camera %d: deferred surface is set to a unknown stream"
- "(ID %d)", mCameraId, streamId);
+ String8 msg = String8::format("Camera %s: deferred surface is set to a unknown stream"
+ "(ID %d)", mCameraIdStr.string(), streamId);
ALOGW("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
}
@@ -1090,8 +1100,8 @@
{
ssize_t index = mStreamMap.indexOfKey(IInterface::asBinder(bufferProducer));
if (index != NAME_NOT_FOUND) {
- String8 msg = String8::format("Camera %d: Surface already has a stream created "
- " for it (ID %zd)", mCameraId, index);
+ String8 msg = String8::format("Camera %s: Surface already has a stream created "
+ " for it (ID %zd)", mCameraIdStr.string(), index);
ALOGW("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ALREADY_EXISTS, msg.string());
}
@@ -1110,12 +1120,12 @@
mDeferredStreams.removeItemsAt(index);
} else if (err == NO_INIT) {
res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
- "Camera %d: Deferred surface is invalid: %s (%d)",
- mCameraId, strerror(-err), err);
+ "Camera %s: Deferred surface is invalid: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
} else {
res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
- "Camera %d: Error setting output stream deferred surface: %s (%d)",
- mCameraId, strerror(-err), err);
+ "Camera %s: Error setting output stream deferred surface: %s (%d)",
+ mCameraIdStr.string(), strerror(-err), err);
}
return res;
@@ -1127,8 +1137,8 @@
status_t CameraDeviceClient::dumpClient(int fd, const Vector<String16>& args) {
String8 result;
- result.appendFormat("CameraDeviceClient[%d] (%p) dump:\n",
- mCameraId,
+ result.appendFormat("CameraDeviceClient[%s] (%p) dump:\n",
+ mCameraIdStr.string(),
(getRemoteCallback() != NULL ?
IInterface::asBinder(getRemoteCallback()).get() : NULL) );
result.appendFormat(" Current client UID %u\n", mClientUid);
@@ -1221,15 +1231,15 @@
void CameraDeviceClient::detachDevice() {
if (mDevice == 0) return;
- ALOGV("Camera %d: Stopping processors", mCameraId);
+ ALOGV("Camera %s: Stopping processors", mCameraIdStr.string());
mFrameProcessor->removeListener(FRAME_PROCESSOR_LISTENER_MIN_ID,
FRAME_PROCESSOR_LISTENER_MAX_ID,
/*listener*/this);
mFrameProcessor->requestExit();
- ALOGV("Camera %d: Waiting for threads", mCameraId);
+ ALOGV("Camera %s: Waiting for threads", mCameraIdStr.string());
mFrameProcessor->join();
- ALOGV("Camera %d: Disconnecting device", mCameraId);
+ ALOGV("Camera %s: Disconnecting device", mCameraIdStr.string());
// WORKAROUND: HAL refuses to disconnect while there's streams in flight
{
diff --git a/services/camera/libcameraservice/api2/CameraDeviceClient.h b/services/camera/libcameraservice/api2/CameraDeviceClient.h
index 68e453c..2226dd2 100644
--- a/services/camera/libcameraservice/api2/CameraDeviceClient.h
+++ b/services/camera/libcameraservice/api2/CameraDeviceClient.h
@@ -42,7 +42,7 @@
CameraDeviceClientBase(const sp<CameraService>& cameraService,
const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
const String16& clientPackageName,
- int cameraId,
+ const String8& cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
@@ -142,14 +142,15 @@
CameraDeviceClient(const sp<CameraService>& cameraService,
const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
const String16& clientPackageName,
- int cameraId,
+ const String8& cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
int servicePid);
virtual ~CameraDeviceClient();
- virtual status_t initialize(CameraModule *module);
+ virtual status_t initialize(CameraModule *module) override;
+ virtual status_t initialize(sp<CameraProviderManager> manager) override;
virtual status_t dump(int fd, const Vector<String16>& args);
@@ -186,6 +187,9 @@
static const int32_t FRAME_PROCESSOR_LISTENER_MIN_ID = 0;
static const int32_t FRAME_PROCESSOR_LISTENER_MAX_ID = 0x7fffffffL;
+ template<typename TProviderPtr>
+ status_t initializeImpl(TProviderPtr providerPtr);
+
/** Utility members */
binder::Status checkPidStatus(const char* checkLocation);
bool enforceRequestPermissions(CameraMetadata& metadata);
diff --git a/services/camera/libcameraservice/common/Camera2ClientBase.cpp b/services/camera/libcameraservice/common/Camera2ClientBase.cpp
index 7e26153..93a584b 100644
--- a/services/camera/libcameraservice/common/Camera2ClientBase.cpp
+++ b/services/camera/libcameraservice/common/Camera2ClientBase.cpp
@@ -47,7 +47,7 @@
const sp<CameraService>& cameraService,
const sp<TCamCallbacks>& remoteCallback,
const String16& clientPackageName,
- int cameraId,
+ const String8& cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
@@ -55,10 +55,10 @@
TClientBase(cameraService, remoteCallback, clientPackageName,
cameraId, cameraFacing, clientPid, clientUid, servicePid),
mSharedCameraCallbacks(remoteCallback),
- mDeviceVersion(cameraService->getDeviceVersion(cameraId)),
+ mDeviceVersion(cameraService->getDeviceVersion(TClientBase::mCameraIdStr)),
mDeviceActive(false)
{
- ALOGI("Camera %d: Opened. Client: %s (PID %d, UID %d)", cameraId,
+ ALOGI("Camera %s: Opened. Client: %s (PID %d, UID %d)", cameraId.string(),
String8(clientPackageName).string(), clientPid, clientUid);
mInitialClientPid = clientPid;
@@ -80,9 +80,20 @@
template <typename TClientBase>
status_t Camera2ClientBase<TClientBase>::initialize(CameraModule *module) {
+ return initializeImpl(module);
+}
+
+template <typename TClientBase>
+status_t Camera2ClientBase<TClientBase>::initialize(sp<CameraProviderManager> manager) {
+ return initializeImpl(manager);
+}
+
+template <typename TClientBase>
+template <typename TProviderPtr>
+status_t Camera2ClientBase<TClientBase>::initializeImpl(TProviderPtr providerPtr) {
ATRACE_CALL();
- ALOGV("%s: Initializing client for camera %d", __FUNCTION__,
- TClientBase::mCameraId);
+ ALOGV("%s: Initializing client for camera %s", __FUNCTION__,
+ TClientBase::mCameraIdStr.string());
status_t res;
// Verify ops permissions
@@ -92,15 +103,15 @@
}
if (mDevice == NULL) {
- ALOGE("%s: Camera %d: No device connected",
- __FUNCTION__, TClientBase::mCameraId);
+ ALOGE("%s: Camera %s: No device connected",
+ __FUNCTION__, TClientBase::mCameraIdStr.string());
return NO_INIT;
}
- res = mDevice->initialize(module);
+ res = mDevice->initialize(providerPtr);
if (res != OK) {
- ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
- __FUNCTION__, TClientBase::mCameraId, strerror(-res), res);
+ ALOGE("%s: Camera %s: unable to initialize device: %s (%d)",
+ __FUNCTION__, TClientBase::mCameraIdStr.string(), strerror(-res), res);
return res;
}
@@ -118,8 +129,8 @@
disconnect();
- ALOGI("Closed Camera %d. Client was: %s (PID %d, UID %u)",
- TClientBase::mCameraId,
+ ALOGI("Closed Camera %s. Client was: %s (PID %d, UID %u)",
+ TClientBase::mCameraIdStr.string(),
String8(TClientBase::mClientPackageName).string(),
mInitialClientPid, TClientBase::mClientUid);
}
@@ -128,8 +139,8 @@
status_t Camera2ClientBase<TClientBase>::dumpClient(int fd,
const Vector<String16>& args) {
String8 result;
- result.appendFormat("Camera2ClientBase[%d] (%p) PID: %d, dump:\n",
- TClientBase::mCameraId,
+ result.appendFormat("Camera2ClientBase[%s] (%p) PID: %d, dump:\n",
+ TClientBase::mCameraIdStr.string(),
(TClientBase::getRemoteCallback() != NULL ?
IInterface::asBinder(TClientBase::getRemoteCallback()).get() : NULL),
TClientBase::mClientPid);
@@ -180,13 +191,13 @@
if (callingPid != TClientBase::mClientPid &&
callingPid != TClientBase::mServicePid) return res;
- ALOGV("Camera %d: Shutting down", TClientBase::mCameraId);
+ ALOGV("Camera %s: Shutting down", TClientBase::mCameraIdStr.string());
detachDevice();
CameraService::BasicClient::disconnect();
- ALOGV("Camera %d: Shut down complete complete", TClientBase::mCameraId);
+ ALOGV("Camera %s: Shut down complete complete", TClientBase::mCameraIdStr.string());
return res;
}
@@ -198,7 +209,7 @@
mDevice.clear();
- ALOGV("Camera %d: Detach complete", TClientBase::mCameraId);
+ ALOGV("Camera %s: Detach complete", TClientBase::mCameraIdStr.string());
}
template <typename TClientBase>
@@ -211,10 +222,10 @@
if (TClientBase::mClientPid != 0 &&
getCallingPid() != TClientBase::mClientPid) {
- ALOGE("%s: Camera %d: Connection attempt from pid %d; "
+ ALOGE("%s: Camera %s: Connection attempt from pid %d; "
"current locked to pid %d",
__FUNCTION__,
- TClientBase::mCameraId,
+ TClientBase::mCameraIdStr.string(),
getCallingPid(),
TClientBase::mClientPid);
return BAD_VALUE;
@@ -242,8 +253,7 @@
void Camera2ClientBase<TClientBase>::notifyIdle() {
if (mDeviceActive) {
getCameraService()->updateProxyDeviceState(
- ICameraServiceProxy::CAMERA_STATE_IDLE,
- String8::format("%d", TClientBase::mCameraId));
+ ICameraServiceProxy::CAMERA_STATE_IDLE, TClientBase::mCameraIdStr);
}
mDeviceActive = false;
@@ -258,8 +268,7 @@
if (!mDeviceActive) {
getCameraService()->updateProxyDeviceState(
- ICameraServiceProxy::CAMERA_STATE_ACTIVE,
- String8::format("%d", TClientBase::mCameraId));
+ ICameraServiceProxy::CAMERA_STATE_ACTIVE, TClientBase::mCameraIdStr);
}
mDeviceActive = true;
@@ -322,7 +331,7 @@
template <typename TClientBase>
int Camera2ClientBase<TClientBase>::getCameraId() const {
- return TClientBase::mCameraId;
+ return std::stoi(TClientBase::mCameraIdStr.string());
}
template <typename TClientBase>
@@ -337,7 +346,7 @@
template <typename TClientBase>
const sp<CameraService>& Camera2ClientBase<TClientBase>::getCameraService() {
- return TClientBase::mCameraService;
+ return TClientBase::sCameraService;
}
template <typename TClientBase>
diff --git a/services/camera/libcameraservice/common/Camera2ClientBase.h b/services/camera/libcameraservice/common/Camera2ClientBase.h
index 9fd0a78..a4c08ef 100644
--- a/services/camera/libcameraservice/common/Camera2ClientBase.h
+++ b/services/camera/libcameraservice/common/Camera2ClientBase.h
@@ -49,7 +49,7 @@
Camera2ClientBase(const sp<CameraService>& cameraService,
const sp<TCamCallbacks>& remoteCallback,
const String16& clientPackageName,
- int cameraId,
+ const String8& cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
@@ -57,6 +57,7 @@
virtual ~Camera2ClientBase();
virtual status_t initialize(CameraModule *module);
+ virtual status_t initialize(sp<CameraProviderManager> manager);
virtual status_t dumpClient(int fd, const Vector<String16>& args);
/**
@@ -140,6 +141,10 @@
virtual void detachDevice();
bool mDeviceActive;
+
+private:
+ template<typename TProviderPtr>
+ status_t initializeImpl(TProviderPtr providerPtr);
};
}; // namespace android
diff --git a/services/camera/libcameraservice/common/CameraDeviceBase.h b/services/camera/libcameraservice/common/CameraDeviceBase.h
index f30afe3..40b368e 100644
--- a/services/camera/libcameraservice/common/CameraDeviceBase.h
+++ b/services/camera/libcameraservice/common/CameraDeviceBase.h
@@ -35,6 +35,8 @@
namespace android {
+class CameraProviderManager;
+
/**
* Base interface for version >= 2 camera device classes, which interface to
* camera HAL device versions >= 2.
@@ -46,9 +48,10 @@
/**
* The device's camera ID
*/
- virtual int getId() const = 0;
+ virtual const String8& getId() const = 0;
virtual status_t initialize(CameraModule *module) = 0;
+ virtual status_t initialize(sp<CameraProviderManager> manager) = 0;
virtual status_t disconnect() = 0;
virtual status_t dump(int fd, const Vector<String16> &args) = 0;
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.cpp b/services/camera/libcameraservice/common/CameraProviderManager.cpp
new file mode 100644
index 0000000..cb965b6
--- /dev/null
+++ b/services/camera/libcameraservice/common/CameraProviderManager.cpp
@@ -0,0 +1,974 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "CameraProviderManager"
+#define ATRACE_TAG ATRACE_TAG_CAMERA
+//#define LOG_NDEBUG 0
+
+#include "CameraProviderManager.h"
+
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <hidl/ServiceManagement.h>
+
+namespace android {
+
+using namespace ::android::hardware::camera;
+using namespace ::android::hardware::camera::common::V1_0;
+
+namespace {
+// Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the
+// service manager
+const std::string kLegacyProviderName("legacy/0");
+
+// Slash-separated list of provider types to consider for use via the old camera API
+const std::string kStandardProviderTypes("internal/legacy");
+
+} // anonymous namespace
+
+CameraProviderManager::HardwareServiceInteractionProxy
+CameraProviderManager::sHardwareServiceInteractionProxy{};
+
+CameraProviderManager::~CameraProviderManager() {
+}
+
+status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
+ ServiceInteractionProxy* proxy) {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+ if (proxy == nullptr) {
+ ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
+ return BAD_VALUE;
+ }
+ mListener = listener;
+ mServiceProxy = proxy;
+
+ // Registering will trigger notifications for all already-known providers
+ bool success = mServiceProxy->registerForNotifications(
+ /* instance name, empty means no filter */ "",
+ this);
+ if (!success) {
+ ALOGE("%s: Unable to register with hardware service manager for notifications "
+ "about camera providers", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
+ // Also see if there's a passthrough HAL, but let's not complain if there's not
+ addProvider(kLegacyProviderName, /*expected*/ false);
+
+ return OK;
+}
+
+int CameraProviderManager::getCameraCount() const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+ int count = 0;
+ for (auto& provider : mProviders) {
+ count += provider->mDevices.size();
+ }
+ return count;
+}
+
+int CameraProviderManager::getStandardCameraCount() const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+ int count = 0;
+ for (auto& provider : mProviders) {
+ if (kStandardProviderTypes.find(provider->getType()) != std::string::npos) {
+ count += provider->mDevices.size();
+ }
+ }
+ return count;
+}
+
+std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+ std::vector<std::string> deviceIds;
+ for (auto& provider : mProviders) {
+ for (auto& deviceInfo : provider->mDevices) {
+ deviceIds.push_back(deviceInfo->mId);
+ }
+ }
+ return deviceIds;
+}
+
+bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+ return isValidDeviceLocked(id, majorVersion);
+}
+
+bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
+ for (auto& provider : mProviders) {
+ for (auto& deviceInfo : provider->mDevices) {
+ if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ auto deviceInfo = findDeviceInfoLocked(id);
+ if (deviceInfo == nullptr) return false;
+
+ return deviceInfo->hasFlashUnit();
+}
+
+status_t CameraProviderManager::getResourceCost(const std::string &id,
+ CameraResourceCost* cost) const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ auto deviceInfo = findDeviceInfoLocked(id);
+ if (deviceInfo == nullptr) return NAME_NOT_FOUND;
+
+ *cost = deviceInfo->mResourceCost;
+ return OK;
+}
+
+status_t CameraProviderManager::getCameraInfo(const std::string &id,
+ hardware::CameraInfo* info) const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ auto deviceInfo = findDeviceInfoLocked(id);
+ if (deviceInfo == nullptr) return NAME_NOT_FOUND;
+
+ return deviceInfo->getCameraInfo(info);
+}
+
+status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
+ CameraMetadata* characteristics) const {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
+ if (deviceInfo == nullptr) return NAME_NOT_FOUND;
+
+ return deviceInfo->getCameraCharacteristics(characteristics);
+}
+
+status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
+ hardware::hidl_version *v) {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ hardware::hidl_version maxVersion{0,0};
+ bool found = false;
+ for (auto& provider : mProviders) {
+ for (auto& deviceInfo : provider->mDevices) {
+ if (deviceInfo->mId == id) {
+ if (deviceInfo->mVersion > maxVersion) {
+ maxVersion = deviceInfo->mVersion;
+ found = true;
+ }
+ }
+ }
+ }
+ if (!found) {
+ return NAME_NOT_FOUND;
+ }
+ *v = maxVersion;
+ return OK;
+}
+
+status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ auto deviceInfo = findDeviceInfoLocked(id);
+ if (deviceInfo == nullptr) return NAME_NOT_FOUND;
+
+ return deviceInfo->setTorchMode(enabled);
+}
+
+status_t CameraProviderManager::openSession(const std::string &id,
+ const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
+ /*out*/
+ sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session) {
+
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ auto deviceInfo = findDeviceInfoLocked(id,
+ /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
+ if (deviceInfo == nullptr) return NAME_NOT_FOUND;
+
+ auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
+
+ Status status;
+ deviceInfo3->mInterface->open(callback, [&status, &session]
+ (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
+ status = s;
+ if (status == Status::OK) {
+ *session = cameraSession;
+ }
+ });
+ return mapToStatusT(status);
+}
+
+status_t CameraProviderManager::openSession(const std::string &id,
+ const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,
+ /*out*/
+ sp<hardware::camera::device::V1_0::ICameraDevice> *session) {
+
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ auto deviceInfo = findDeviceInfoLocked(id,
+ /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
+ if (deviceInfo == nullptr) return NAME_NOT_FOUND;
+
+ auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
+
+ Status status = deviceInfo1->mInterface->open(callback);
+ if (status == Status::OK) {
+ *session = deviceInfo1->mInterface;
+ }
+ return mapToStatusT(status);
+}
+
+
+hardware::Return<void> CameraProviderManager::onRegistration(
+ const hardware::hidl_string& /*fqName*/,
+ const hardware::hidl_string& name,
+ bool /*preexisting*/) {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ addProvider(name);
+ return hardware::Return<void>();
+}
+
+status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+
+ dprintf(fd, "Available camera providers and devices:\n");
+ for (auto& provider : mProviders) {
+ provider->dump(fd, args);
+ }
+ return OK;
+}
+
+CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
+ const std::string& id,
+ hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
+ for (auto& provider : mProviders) {
+ for (auto& deviceInfo : provider->mDevices) {
+ if (deviceInfo->mId == id &&
+ minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
+ return deviceInfo.get();
+ }
+ }
+ }
+ return nullptr;
+}
+
+
+status_t CameraProviderManager::addProvider(const std::string& newProvider, bool expected) {
+ for (const auto& providerInfo : mProviders) {
+ if (providerInfo->mProviderName == newProvider) {
+ ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
+ newProvider.c_str());
+ return ALREADY_EXISTS;
+ }
+ }
+ sp<provider::V2_4::ICameraProvider> interface =
+ mServiceProxy->getService(newProvider);
+
+ if (interface == nullptr) {
+ if (expected) {
+ ALOGW("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
+ newProvider.c_str());
+ return BAD_VALUE;
+ } else {
+ // Not guaranteed to be found, so not an error if it wasn't
+ return OK;
+ }
+ }
+
+ sp<ProviderInfo> providerInfo =
+ new ProviderInfo(newProvider, interface, this);
+ status_t res = providerInfo->initialize();
+ if (res != OK) {
+ return res;
+ }
+
+ mProviders.push_back(providerInfo);
+
+ return OK;
+}
+
+status_t CameraProviderManager::removeProvider(const std::string& provider) {
+ for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
+ if ((*it)->mProviderName == provider) {
+ mProviders.erase(it);
+ return OK;
+ }
+ }
+ ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
+ provider.c_str());
+ return NAME_NOT_FOUND;
+}
+
+/**** Methods for ProviderInfo ****/
+
+
+CameraProviderManager::ProviderInfo::ProviderInfo(
+ const std::string &providerName,
+ sp<provider::V2_4::ICameraProvider>& interface,
+ CameraProviderManager *manager) :
+ mProviderName(providerName),
+ mInterface(interface),
+ mManager(manager) {
+ (void) mManager;
+}
+
+status_t CameraProviderManager::ProviderInfo::initialize() {
+ status_t res = parseProviderName(mProviderName, &mType, &mId);
+ if (res != OK) {
+ ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
+ return BAD_VALUE;
+ }
+ ALOGI("Connecting to new camera provider: %s", mProviderName.c_str());
+ Status status = mInterface->setCallback(this);
+ if (status != Status::OK) {
+ ALOGE("%s: Unable to register callbacks with camera provider '%s'",
+ __FUNCTION__, mProviderName.c_str());
+ return mapToStatusT(status);
+ }
+ // TODO: Register for hw binder death notifications as well
+
+ // Get initial list of camera devices, if any
+ std::vector<std::string> devices;
+ mInterface->getCameraIdList([&status, &devices](
+ Status idStatus,
+ const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
+ status = idStatus;
+ if (status == Status::OK) {
+ for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
+ devices.push_back(cameraDeviceNames[i]);
+ }
+ } });
+
+ if (status != Status::OK) {
+ ALOGE("%s: Unable to query for camera devices from provider '%s'",
+ __FUNCTION__, mProviderName.c_str());
+ return mapToStatusT(status);
+ }
+
+ for (auto& device : devices) {
+ status_t res = addDevice(device);
+ if (res != OK) {
+ ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
+ __FUNCTION__, device.c_str(), strerror(-res), res);
+ }
+ }
+
+ ALOGI("Camera provider %s ready with %zu camera devices",
+ mProviderName.c_str(), mDevices.size());
+
+ return OK;
+}
+
+const std::string& CameraProviderManager::ProviderInfo::getType() const {
+ return mType;
+}
+
+status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
+ CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
+
+ ALOGI("Enumerating new camera device: %s", name.c_str());
+
+ uint16_t major, minor;
+ std::string type, id;
+
+ status_t res = parseDeviceName(name, &major, &minor, &type, &id);
+ if (res != OK) {
+ return res;
+ }
+ if (type != mType) {
+ ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
+ type.c_str(), mType.c_str());
+ return BAD_VALUE;
+ }
+ if (mManager->isValidDeviceLocked(id, major)) {
+ ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
+ name.c_str(), id.c_str(), major);
+ return BAD_VALUE;
+ }
+
+ std::unique_ptr<DeviceInfo> deviceInfo;
+ switch (major) {
+ case 1:
+ deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, id, minor);
+ break;
+ case 3:
+ deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, id, minor);
+ break;
+ default:
+ ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
+ name.c_str(), major);
+ return BAD_VALUE;
+ }
+ if (deviceInfo == nullptr) return BAD_VALUE;
+ deviceInfo->mStatus = initialStatus;
+
+ mDevices.push_back(std::move(deviceInfo));
+
+ if (parsedId != nullptr) {
+ *parsedId = id;
+ }
+ return OK;
+}
+
+status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
+ dprintf(fd, " %s: %zu devices:\n", mProviderName.c_str(), mDevices.size());
+
+ for (auto& device : mDevices) {
+ dprintf(fd, " %s: Resource cost: %d\n", device->mName.c_str(),
+ device->mResourceCost.resourceCost);
+ if (device->mResourceCost.conflictingDevices.size() > 0) {
+ dprintf(fd, " Conflicting devices:\n");
+ for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
+ dprintf(fd, " %s\n",
+ device->mResourceCost.conflictingDevices[i].c_str());
+ }
+ }
+ }
+ return OK;
+}
+
+hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
+ const hardware::hidl_string& cameraDeviceName,
+ CameraDeviceStatus newStatus) {
+ sp<StatusListener> listener;
+ std::string id;
+ {
+ std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
+ bool known = false;
+ for (auto& deviceInfo : mDevices) {
+ if (deviceInfo->mName == cameraDeviceName) {
+ ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
+ deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
+ deviceInfo->mStatus = newStatus;
+ // TODO: Handle device removal (NOT_PRESENT)
+ id = deviceInfo->mId;
+ known = true;
+ break;
+ }
+ }
+ // Previously unseen device; status must not be NOT_PRESENT
+ if (!known) {
+ if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
+ ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
+ mProviderName.c_str(), cameraDeviceName.c_str());
+ return hardware::Void();
+ }
+ addDevice(cameraDeviceName, newStatus, &id);
+ }
+ listener = mManager->mListener.promote();
+ }
+ // Call without lock held to allow reentrancy into provider manager
+ if (listener != nullptr) {
+ listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
+ }
+ return hardware::Void();
+}
+
+hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
+ const hardware::hidl_string& cameraDeviceName,
+ TorchModeStatus newStatus) {
+ sp<StatusListener> listener;
+ std::string id;
+ {
+ std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
+ bool known = false;
+ for (auto& deviceInfo : mDevices) {
+ if (deviceInfo->mName == cameraDeviceName) {
+ ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
+ torchStatusToString(newStatus));
+ id = deviceInfo->mId;
+ known = true;
+ break;
+ }
+ }
+ if (!known) {
+ ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
+ mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
+ return hardware::Void();
+ }
+ listener = mManager->mListener.promote();
+ }
+ // Call without lock held to allow reentrancy into provider manager
+ if (listener != nullptr) {
+ listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
+ }
+ return hardware::Void();
+}
+
+
+template<class DeviceInfoT>
+std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
+ CameraProviderManager::ProviderInfo::initializeDeviceInfo(
+ const std::string &name,
+ const std::string &id, uint16_t minorVersion) const {
+ Status status;
+
+ auto cameraInterface =
+ getDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
+ if (cameraInterface == nullptr) return nullptr;
+
+ CameraResourceCost resourceCost;
+ cameraInterface->getResourceCost([&status, &resourceCost](
+ Status s, CameraResourceCost cost) {
+ status = s;
+ resourceCost = cost;
+ });
+ if (status != Status::OK) {
+ ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
+ name.c_str(), statusToString(status));
+ return nullptr;
+ }
+ return std::unique_ptr<DeviceInfo>(
+ new DeviceInfoT(name, id, minorVersion, resourceCost, cameraInterface));
+}
+
+template<class InterfaceT>
+sp<InterfaceT>
+CameraProviderManager::ProviderInfo::getDeviceInterface(const std::string &name) const {
+ ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
+ name.c_str(), InterfaceT::version.get_major());
+ return nullptr;
+}
+
+template<>
+sp<device::V1_0::ICameraDevice>
+CameraProviderManager::ProviderInfo::getDeviceInterface
+ <device::V1_0::ICameraDevice>(const std::string &name) const {
+ Status status;
+ sp<device::V1_0::ICameraDevice> cameraInterface;
+ mInterface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
+ Status s, sp<device::V1_0::ICameraDevice> interface) {
+ status = s;
+ cameraInterface = interface;
+ });
+ if (status != Status::OK) {
+ ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
+ name.c_str(), statusToString(status));
+ return nullptr;
+ }
+ return cameraInterface;
+}
+
+template<>
+sp<device::V3_2::ICameraDevice>
+CameraProviderManager::ProviderInfo::getDeviceInterface
+ <device::V3_2::ICameraDevice>(const std::string &name) const {
+ Status status;
+ sp<device::V3_2::ICameraDevice> cameraInterface;
+ mInterface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
+ Status s, sp<device::V3_2::ICameraDevice> interface) {
+ status = s;
+ cameraInterface = interface;
+ });
+ if (status != Status::OK) {
+ ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
+ name.c_str(), statusToString(status));
+ return nullptr;
+ }
+ return cameraInterface;
+}
+
+CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
+
+template<class InterfaceT>
+status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
+ bool enabled) {
+ Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
+ return mapToStatusT(s);
+}
+
+CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
+ const std::string &id,
+ uint16_t minorVersion,
+ const CameraResourceCost& resourceCost,
+ sp<InterfaceT> interface) :
+ DeviceInfo(name, id, hardware::hidl_version{1, minorVersion}, resourceCost),
+ mInterface(interface) {
+ // Get default parameters and initialize flash unit availability
+ // Requires powering on the camera device
+ Status status = mInterface->open(nullptr);
+ if (status != Status::OK) {
+ ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s (%d)", __FUNCTION__,
+ mId.c_str(), CameraProviderManager::statusToString(status), status);
+ return;
+ }
+ mInterface->getParameters([this](const hardware::hidl_string& parms) {
+ mDefaultParameters.unflatten(String8(parms.c_str()));
+ });
+
+ const char *flashMode =
+ mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
+ if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
+ mHasFlashUnit = true;
+ } else {
+ mHasFlashUnit = false;
+ }
+
+ mInterface->close();
+}
+
+CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
+
+status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
+ return DeviceInfo::setTorchMode(mInterface, enabled);
+}
+
+status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
+ hardware::CameraInfo *info) const {
+ if (info == nullptr) return BAD_VALUE;
+
+ Status status;
+ device::V1_0::CameraInfo cInfo;
+ mInterface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
+ status = s;
+ cInfo = camInfo;
+ });
+ if (status != Status::OK) {
+ return mapToStatusT(status);
+ }
+
+ switch(cInfo.facing) {
+ case device::V1_0::CameraFacing::BACK:
+ info->facing = hardware::CAMERA_FACING_BACK;
+ break;
+ case device::V1_0::CameraFacing::EXTERNAL:
+ // Map external to front for legacy API
+ case device::V1_0::CameraFacing::FRONT:
+ info->facing = hardware::CAMERA_FACING_FRONT;
+ break;
+ default:
+ ALOGW("%s: Unknown camera facing: %d", __FUNCTION__, cInfo.facing);
+ info->facing = hardware::CAMERA_FACING_BACK;
+ }
+ info->orientation = cInfo.orientation;
+
+ return OK;
+}
+
+CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
+ const std::string &id,
+ uint16_t minorVersion,
+ const CameraResourceCost& resourceCost,
+ sp<InterfaceT> interface) :
+ DeviceInfo(name, id, hardware::hidl_version{3, minorVersion}, resourceCost),
+ mInterface(interface) {
+ // Get camera characteristics and initialize flash unit availability
+ Status status;
+ mInterface->getCameraCharacteristics([&status, this](Status s,
+ device::V3_2::CameraMetadata metadata) {
+ status = s;
+ if (s == Status::OK) {
+ camera_metadata_t *buffer =
+ reinterpret_cast<camera_metadata_t*>(metadata.data());
+ mCameraCharacteristics = buffer;
+ }
+ });
+ if (status != Status::OK) {
+ ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
+ __FUNCTION__, mId.c_str(), CameraProviderManager::statusToString(status), status);
+ return;
+ }
+ camera_metadata_entry flashAvailable =
+ mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
+ if (flashAvailable.count == 1 &&
+ flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
+ mHasFlashUnit = true;
+ } else {
+ mHasFlashUnit = false;
+ }
+}
+
+CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
+
+status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
+ return DeviceInfo::setTorchMode(mInterface, enabled);
+}
+
+status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
+ hardware::CameraInfo *info) const {
+ if (info == nullptr) return BAD_VALUE;
+
+ camera_metadata_ro_entry facing =
+ mCameraCharacteristics.find(ANDROID_LENS_FACING);
+ if (facing.count == 1) {
+ switch (facing.data.u8[0]) {
+ case ANDROID_LENS_FACING_BACK:
+ info->facing = hardware::CAMERA_FACING_BACK;
+ break;
+ case ANDROID_LENS_FACING_EXTERNAL:
+ // Map external to front for legacy API
+ case ANDROID_LENS_FACING_FRONT:
+ info->facing = hardware::CAMERA_FACING_FRONT;
+ break;
+ }
+ } else {
+ ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
+ return NAME_NOT_FOUND;
+ }
+
+ camera_metadata_ro_entry orientation =
+ mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
+ if (orientation.count == 1) {
+ info->orientation = orientation.data.i32[0];
+ } else {
+ ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
+ return NAME_NOT_FOUND;
+ }
+
+ return OK;
+}
+
+status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
+ CameraMetadata *characteristics) const {
+ if (characteristics == nullptr) return BAD_VALUE;
+
+ *characteristics = mCameraCharacteristics;
+ return OK;
+}
+
+status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
+ std::string *type, uint32_t *id) {
+ // Format must be "<type>/<id>"
+#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
+ "Should match '<type>/<id>' - "
+
+ if (!type || !id) return INVALID_OPERATION;
+
+ std::string::size_type slashIdx = name.find('/');
+ if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
+ ALOGE(ERROR_MSG_PREFIX
+ "does not have / separator between type and id",
+ __FUNCTION__, name.c_str());
+ return BAD_VALUE;
+ }
+
+ std::string typeVal = name.substr(0, slashIdx);
+
+ char *endPtr;
+ errno = 0;
+ long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
+ if (errno != 0) {
+ ALOGE(ERROR_MSG_PREFIX
+ "cannot parse provider id as an integer: %s (%d)",
+ __FUNCTION__, name.c_str(), strerror(errno), errno);
+ return BAD_VALUE;
+ }
+ if (endPtr != name.c_str() + name.size()) {
+ ALOGE(ERROR_MSG_PREFIX
+ "provider id has unexpected length",
+ __FUNCTION__, name.c_str());
+ return BAD_VALUE;
+ }
+ if (idVal < 0) {
+ ALOGE(ERROR_MSG_PREFIX
+ "id is negative: %ld",
+ __FUNCTION__, name.c_str(), idVal);
+ return BAD_VALUE;
+ }
+
+#undef ERROR_MSG_PREFIX
+
+ *type = typeVal;
+ *id = static_cast<uint32_t>(idVal);
+
+ return OK;
+}
+
+status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
+ uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
+
+ // Format must be "device@<major>.<minor>/<type>/<id>"
+
+#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
+ "Should match 'device@<major>.<minor>/<type>/<id>' - "
+
+ if (!major || !minor || !type || !id) return INVALID_OPERATION;
+
+ // Verify starting prefix
+ const char expectedPrefix[] = "device@";
+
+ if (name.find(expectedPrefix) != 0) {
+ ALOGE(ERROR_MSG_PREFIX
+ "does not start with '%s'",
+ __FUNCTION__, name.c_str(), expectedPrefix);
+ return BAD_VALUE;
+ }
+
+ // Extract major/minor versions
+ constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
+ std::string::size_type dotIdx = name.find('.', atIdx);
+ if (dotIdx == std::string::npos) {
+ ALOGE(ERROR_MSG_PREFIX
+ "does not have @<major>. version section",
+ __FUNCTION__, name.c_str());
+ return BAD_VALUE;
+ }
+ std::string::size_type typeSlashIdx = name.find('/', dotIdx);
+ if (typeSlashIdx == std::string::npos) {
+ ALOGE(ERROR_MSG_PREFIX
+ "does not have .<minor>/ version section",
+ __FUNCTION__, name.c_str());
+ return BAD_VALUE;
+ }
+
+ char *endPtr;
+ errno = 0;
+ long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
+ if (errno != 0) {
+ ALOGE(ERROR_MSG_PREFIX
+ "cannot parse major version: %s (%d)",
+ __FUNCTION__, name.c_str(), strerror(errno), errno);
+ return BAD_VALUE;
+ }
+ if (endPtr != name.c_str() + dotIdx) {
+ ALOGE(ERROR_MSG_PREFIX
+ "major version has unexpected length",
+ __FUNCTION__, name.c_str());
+ return BAD_VALUE;
+ }
+ long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
+ if (errno != 0) {
+ ALOGE(ERROR_MSG_PREFIX
+ "cannot parse minor version: %s (%d)",
+ __FUNCTION__, name.c_str(), strerror(errno), errno);
+ return BAD_VALUE;
+ }
+ if (endPtr != name.c_str() + typeSlashIdx) {
+ ALOGE(ERROR_MSG_PREFIX
+ "minor version has unexpected length",
+ __FUNCTION__, name.c_str());
+ return BAD_VALUE;
+ }
+ if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
+ ALOGE(ERROR_MSG_PREFIX
+ "major/minor version is out of range of uint16_t: %ld.%ld",
+ __FUNCTION__, name.c_str(), majorVal, minorVal);
+ return BAD_VALUE;
+ }
+
+ // Extract type and id
+
+ std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
+ if (instanceSlashIdx == std::string::npos) {
+ ALOGE(ERROR_MSG_PREFIX
+ "does not have /<type>/ component",
+ __FUNCTION__, name.c_str());
+ return BAD_VALUE;
+ }
+ std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
+
+ if (instanceSlashIdx == name.size() - 1) {
+ ALOGE(ERROR_MSG_PREFIX
+ "does not have an /<id> component",
+ __FUNCTION__, name.c_str());
+ return BAD_VALUE;
+ }
+ std::string idVal = name.substr(instanceSlashIdx + 1);
+
+#undef ERROR_MSG_PREFIX
+
+ *major = static_cast<uint16_t>(majorVal);
+ *minor = static_cast<uint16_t>(minorVal);
+ *type = typeVal;
+ *id = idVal;
+
+ return OK;
+}
+
+
+
+CameraProviderManager::ProviderInfo::~ProviderInfo() {
+ // Destruction of ProviderInfo is only supposed to happen when the respective
+ // CameraProvider interface dies, so do not unregister callbacks.
+
+}
+
+status_t CameraProviderManager::mapToStatusT(const Status& s) {
+ switch(s) {
+ case Status::OK:
+ return OK;
+ case Status::ILLEGAL_ARGUMENT:
+ return BAD_VALUE;
+ case Status::CAMERA_IN_USE:
+ return -EBUSY;
+ case Status::MAX_CAMERAS_IN_USE:
+ return -EUSERS;
+ case Status::METHOD_NOT_SUPPORTED:
+ return UNKNOWN_TRANSACTION;
+ case Status::OPERATION_NOT_SUPPORTED:
+ return INVALID_OPERATION;
+ case Status::CAMERA_DISCONNECTED:
+ return DEAD_OBJECT;
+ case Status::INTERNAL_ERROR:
+ return INVALID_OPERATION;
+ }
+ ALOGW("Unexpected HAL status code %d", s);
+ return INVALID_OPERATION;
+}
+
+const char* CameraProviderManager::statusToString(const Status& s) {
+ switch(s) {
+ case Status::OK:
+ return "OK";
+ case Status::ILLEGAL_ARGUMENT:
+ return "ILLEGAL_ARGUMENT";
+ case Status::CAMERA_IN_USE:
+ return "CAMERA_IN_USE";
+ case Status::MAX_CAMERAS_IN_USE:
+ return "MAX_CAMERAS_IN_USE";
+ case Status::METHOD_NOT_SUPPORTED:
+ return "METHOD_NOT_SUPPORTED";
+ case Status::OPERATION_NOT_SUPPORTED:
+ return "OPERATION_NOT_SUPPORTED";
+ case Status::CAMERA_DISCONNECTED:
+ return "CAMERA_DISCONNECTED";
+ case Status::INTERNAL_ERROR:
+ return "INTERNAL_ERROR";
+ }
+ ALOGW("Unexpected HAL status code %d", s);
+ return "UNKNOWN_ERROR";
+}
+
+const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
+ switch(s) {
+ case CameraDeviceStatus::NOT_PRESENT:
+ return "NOT_PRESENT";
+ case CameraDeviceStatus::PRESENT:
+ return "PRESENT";
+ case CameraDeviceStatus::ENUMERATING:
+ return "ENUMERATING";
+ }
+ ALOGW("Unexpected HAL device status code %d", s);
+ return "UNKNOWN_STATUS";
+}
+
+const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
+ switch(s) {
+ case TorchModeStatus::NOT_AVAILABLE:
+ return "NOT_AVAILABLE";
+ case TorchModeStatus::AVAILABLE_OFF:
+ return "AVAILABLE_OFF";
+ case TorchModeStatus::AVAILABLE_ON:
+ return "AVAILABLE_ON";
+ }
+ ALOGW("Unexpected HAL torch mode status code %d", s);
+ return "UNKNOWN_STATUS";
+}
+
+} // namespace android
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.h b/services/camera/libcameraservice/common/CameraProviderManager.h
new file mode 100644
index 0000000..641dab4
--- /dev/null
+++ b/services/camera/libcameraservice/common/CameraProviderManager.h
@@ -0,0 +1,351 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SERVERS_CAMERA_CAMERAPROVIDER_H
+#define ANDROID_SERVERS_CAMERA_CAMERAPROVIDER_H
+
+#include <vector>
+#include <string>
+#include <mutex>
+
+#include <camera/CameraParameters2.h>
+#include <camera/CameraMetadata.h>
+#include <camera/CameraBase.h>
+#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/provider/2.4/ICameraProviderCallbacks.h>
+#include <android/hidl/manager/1.0/IServiceNotification.h>
+
+namespace android {
+
+/**
+ * A manager for all camera providers available on an Android device.
+ *
+ * Responsible for enumerating providers and the individual camera devices
+ * they export, both at startup and as providers and devices are added/removed.
+ *
+ * Provides methods for requesting information about individual devices and for
+ * opening them for active use.
+ *
+ */
+class CameraProviderManager : virtual public hidl::manager::V1_0::IServiceNotification {
+public:
+
+ ~CameraProviderManager();
+
+ // Tiny proxy for the static methods in a HIDL interface that communicate with the hardware
+ // service manager, to be replacable in unit tests with a fake.
+ struct ServiceInteractionProxy {
+ virtual bool registerForNotifications(
+ const std::string &serviceName,
+ const sp<hidl::manager::V1_0::IServiceNotification>
+ ¬ification) = 0;
+ virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
+ const std::string &serviceName) = 0;
+ virtual ~ServiceInteractionProxy() {}
+ };
+
+ // Standard use case - call into the normal generated static methods which invoke
+ // the real hardware service manager
+ struct HardwareServiceInteractionProxy : public ServiceInteractionProxy {
+ virtual bool registerForNotifications(
+ const std::string &serviceName,
+ const sp<hidl::manager::V1_0::IServiceNotification>
+ ¬ification) override {
+ return hardware::camera::provider::V2_4::ICameraProvider::registerForNotifications(
+ serviceName, notification);
+ }
+ virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
+ const std::string &serviceName) override {
+ return hardware::camera::provider::V2_4::ICameraProvider::getService(serviceName);
+ }
+ };
+
+ /**
+ * Listener interface for device/torch status changes
+ */
+ struct StatusListener : virtual public RefBase {
+ ~StatusListener() {}
+
+ virtual void onDeviceStatusChanged(const String8 &cameraId,
+ hardware::camera::common::V1_0::CameraDeviceStatus newStatus) = 0;
+ virtual void onTorchStatusChanged(const String8 &cameraId,
+ hardware::camera::common::V1_0::TorchModeStatus newStatus) = 0;
+ };
+
+ /**
+ * Initialize the manager and give it a status listener; optionally accepts a service
+ * interaction proxy.
+ *
+ * The default proxy communicates via the hardware service manager; alternate proxies can be
+ * used for testing. The lifetime of the proxy must exceed the lifetime of the manager.
+ */
+ status_t initialize(wp<StatusListener> listener,
+ ServiceInteractionProxy *proxy = &sHardwareServiceInteractionProxy);
+
+ /**
+ * Retrieve the total number of available cameras. This value may change dynamically as cameras
+ * are added or removed.
+ */
+ int getCameraCount() const;
+
+ /**
+ * Retrieve the number of 'standard' cameras; these are internal and
+ * backwards-compatible. This is the set of cameras that will be
+ * accessible via the old camera API, with IDs in range of
+ * [0, getStandardCameraCount()-1]. This value is not expected to change dynamically.
+ */
+ int getStandardCameraCount() const;
+
+ std::vector<std::string> getCameraDeviceIds() const;
+
+ /**
+ * Return true if a device with a given ID and major version exists
+ */
+ bool isValidDevice(const std::string &id, uint16_t majorVersion) const;
+
+ /**
+ * Return true if a device with a given ID has a flash unit. Returns false
+ * for devices that are unknown.
+ */
+ bool hasFlashUnit(const std::string &id) const;
+
+ /**
+ * Return the resource cost of this camera device
+ */
+ status_t getResourceCost(const std::string &id,
+ hardware::camera::common::V1_0::CameraResourceCost* cost) const;
+
+ /**
+ * Return the old camera API camera info
+ */
+ status_t getCameraInfo(const std::string &id,
+ hardware::CameraInfo* info) const;
+
+ /**
+ * Return API2 camera characteristics - returns NAME_NOT_FOUND if a device ID does
+ * not have a v3 or newer HAL version.
+ */
+ status_t getCameraCharacteristics(const std::string &id,
+ CameraMetadata* characteristics) const;
+
+ /**
+ * Return the highest supported device interface version for this ID
+ */
+ status_t getHighestSupportedVersion(const std::string &id,
+ hardware::hidl_version *v);
+
+ /**
+ * Turn on or off the flashlight on a given camera device.
+ * May fail if the device is in active use, or if the device doesn't exist, etc.
+ */
+ status_t setTorchMode(const std::string &id, bool enabled);
+
+ /**
+ * Open an active session to a camera device.
+ *
+ * This fully powers on the camera device hardware, and returns a handle to a
+ * session to be used for hardware configuration and operation.
+ */
+ status_t openSession(const std::string &id,
+ const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
+ /*out*/
+ sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session);
+
+ status_t openSession(const std::string &id,
+ const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,
+ /*out*/
+ sp<hardware::camera::device::V1_0::ICameraDevice> *session);
+
+ /**
+ * IServiceNotification::onRegistration
+ * Invoked by the hardware service manager when a new camera provider is registered
+ */
+ virtual hardware::Return<void> onRegistration(const hardware::hidl_string& fqName,
+ const hardware::hidl_string& name,
+ bool preexisting) override;
+
+ /**
+ * Dump out information about available providers and devices
+ */
+ status_t dump(int fd, const Vector<String16>& args);
+
+ /**
+ * Conversion methods between HAL Status and status_t and strings
+ */
+ static status_t mapToStatusT(const hardware::camera::common::V1_0::Status& s);
+ static const char* statusToString(const hardware::camera::common::V1_0::Status& s);
+
+private:
+ // All private members, unless otherwise noted, expect mInterfaceMutex to be locked before use
+ mutable std::mutex mInterfaceMutex;
+
+ // the status listener update callbacks will lock mStatusMutex
+ mutable std::mutex mStatusListenerMutex;
+ wp<StatusListener> mListener;
+ ServiceInteractionProxy* mServiceProxy;
+
+ static HardwareServiceInteractionProxy sHardwareServiceInteractionProxy;
+
+ struct ProviderInfo : virtual public hardware::camera::provider::V2_4::ICameraProviderCallback {
+ const std::string mProviderName;
+ const sp<hardware::camera::provider::V2_4::ICameraProvider> mInterface;
+
+ ProviderInfo(const std::string &providerName,
+ sp<hardware::camera::provider::V2_4::ICameraProvider>& interface,
+ CameraProviderManager *manager);
+ ~ProviderInfo();
+
+ status_t initialize();
+
+ const std::string& getType() const;
+
+ status_t addDevice(const std::string& name,
+ hardware::camera::common::V1_0::CameraDeviceStatus initialStatus =
+ hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT,
+ /*out*/ std::string *parsedId = nullptr);
+
+ status_t dump(int fd, const Vector<String16>& args) const;
+
+ // ICameraProviderCallbacks interface - these lock the parent mInterfaceMutex
+ virtual hardware::Return<void> cameraDeviceStatusChange(
+ const hardware::hidl_string& cameraDeviceName,
+ hardware::camera::common::V1_0::CameraDeviceStatus newStatus) override;
+ virtual hardware::Return<void> torchModeStatusChange(
+ const hardware::hidl_string& cameraDeviceName,
+ hardware::camera::common::V1_0::TorchModeStatus newStatus) override;
+
+ // Basic device information, common to all camera devices
+ struct DeviceInfo {
+ const std::string mName; // Full instance name
+ const std::string mId; // ID section of full name
+ const hardware::hidl_version mVersion;
+
+ const hardware::camera::common::V1_0::CameraResourceCost mResourceCost;
+
+ hardware::camera::common::V1_0::CameraDeviceStatus mStatus;
+
+ bool hasFlashUnit() const { return mHasFlashUnit; }
+ virtual status_t setTorchMode(bool enabled) = 0;
+ virtual status_t getCameraInfo(hardware::CameraInfo *info) const = 0;
+ virtual status_t getCameraCharacteristics(CameraMetadata *characteristics) const {
+ (void) characteristics;
+ return INVALID_OPERATION;
+ }
+
+ DeviceInfo(const std::string& name, const std::string &id,
+ const hardware::hidl_version& version,
+ const hardware::camera::common::V1_0::CameraResourceCost& resourceCost) :
+ mName(name), mId(id), mVersion(version), mResourceCost(resourceCost),
+ mStatus(hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT),
+ mHasFlashUnit(false) {}
+ virtual ~DeviceInfo();
+ protected:
+ bool mHasFlashUnit;
+
+ template<class InterfaceT>
+ static status_t setTorchMode(InterfaceT& interface, bool enabled);
+ };
+ std::vector<std::unique_ptr<DeviceInfo>> mDevices;
+
+ // HALv1-specific camera fields, including the actual device interface
+ struct DeviceInfo1 : public DeviceInfo {
+ typedef hardware::camera::device::V1_0::ICameraDevice InterfaceT;
+ const sp<InterfaceT> mInterface;
+
+ virtual status_t setTorchMode(bool enabled) override;
+ virtual status_t getCameraInfo(hardware::CameraInfo *info) const override;
+
+ DeviceInfo1(const std::string& name, const std::string &id,
+ uint16_t minorVersion,
+ const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
+ sp<InterfaceT> interface);
+ virtual ~DeviceInfo1();
+ private:
+ CameraParameters2 mDefaultParameters;
+ };
+
+ // HALv3-specific camera fields, including the actual device interface
+ struct DeviceInfo3 : public DeviceInfo {
+ typedef hardware::camera::device::V3_2::ICameraDevice InterfaceT;
+ const sp<InterfaceT> mInterface;
+
+ virtual status_t setTorchMode(bool enabled) override;
+ virtual status_t getCameraInfo(hardware::CameraInfo *info) const override;
+ virtual status_t getCameraCharacteristics(
+ CameraMetadata *characteristics) const override;
+
+ DeviceInfo3(const std::string& name, const std::string &id,
+ uint16_t minorVersion,
+ const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
+ sp<InterfaceT> interface);
+ virtual ~DeviceInfo3();
+ private:
+ CameraMetadata mCameraCharacteristics;
+ };
+
+ private:
+ std::string mType;
+ uint32_t mId;
+
+ CameraProviderManager *mManager;
+
+ // Templated method to instantiate the right kind of DeviceInfo and call the
+ // right CameraProvider getCameraDeviceInterface_* method.
+ template<class DeviceInfoT>
+ std::unique_ptr<DeviceInfo> initializeDeviceInfo(const std::string &name,
+ const std::string &id, uint16_t minorVersion) const;
+
+ // Helper for initializeDeviceInfo to use the right CameraProvider get method.
+ template<class InterfaceT>
+ sp<InterfaceT> getDeviceInterface(const std::string &name) const;
+
+ // Parse provider instance name for type and id
+ static status_t parseProviderName(const std::string& name,
+ std::string *type, uint32_t *id);
+
+ // Parse device instance name for device version, type, and id.
+ static status_t parseDeviceName(const std::string& name,
+ uint16_t *major, uint16_t *minor, std::string *type, std::string *id);
+ };
+
+ // Utility to find a DeviceInfo by ID; pointer is only valid while mInterfaceMutex is held
+ // and the calling code doesn't mutate the list of providers or their lists of devices.
+ // Finds the first device of the given ID that falls within the requested version range
+ // minVersion <= deviceVersion < maxVersion
+ // No guarantees on the order of traversal
+ ProviderInfo::DeviceInfo* findDeviceInfoLocked(const std::string& id,
+ hardware::hidl_version minVersion = hardware::hidl_version{0,0},
+ hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const;
+
+ status_t addProvider(const std::string& newProvider, bool expected = true);
+ status_t removeProvider(const std::string& provider);
+
+ bool isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const;
+
+ std::vector<sp<ProviderInfo>> mProviders;
+
+ static const char* deviceStatusToString(
+ const hardware::camera::common::V1_0::CameraDeviceStatus&);
+ static const char* torchStatusToString(
+ const hardware::camera::common::V1_0::TorchModeStatus&);
+
+};
+
+} // namespace android
+
+#endif
diff --git a/services/camera/libcameraservice/common/FrameProcessorBase.cpp b/services/camera/libcameraservice/common/FrameProcessorBase.cpp
index 2ef3057..9e78f88 100644
--- a/services/camera/libcameraservice/common/FrameProcessorBase.cpp
+++ b/services/camera/libcameraservice/common/FrameProcessorBase.cpp
@@ -123,7 +123,7 @@
ATRACE_CALL();
CaptureResult result;
- ALOGV("%s: Camera %d: Process new frames", __FUNCTION__, device->getId());
+ ALOGV("%s: Camera %s: Process new frames", __FUNCTION__, device->getId().string());
while ( (res = device->getNextResult(&result)) == OK) {
@@ -133,8 +133,8 @@
entry = result.mMetadata.find(ANDROID_REQUEST_FRAME_COUNT);
if (entry.count == 0) {
- ALOGE("%s: Camera %d: Error reading frame number",
- __FUNCTION__, device->getId());
+ ALOGE("%s: Camera %s: Error reading frame number",
+ __FUNCTION__, device->getId().string());
break;
}
ATRACE_INT("cam2_frame", entry.data.i32[0]);
@@ -149,8 +149,8 @@
}
}
if (res != NOT_ENOUGH_DATA) {
- ALOGE("%s: Camera %d: Error getting next frame: %s (%d)",
- __FUNCTION__, device->getId(), strerror(-res), res);
+ ALOGE("%s: Camera %s: Error getting next frame: %s (%d)",
+ __FUNCTION__, device->getId().string(), strerror(-res), res);
return;
}
@@ -159,8 +159,8 @@
bool FrameProcessorBase::processSingleFrame(CaptureResult &result,
const sp<CameraDeviceBase> &device) {
- ALOGV("%s: Camera %d: Process single frame (is empty? %d)",
- __FUNCTION__, device->getId(), result.mMetadata.isEmpty());
+ ALOGV("%s: Camera %s: Process single frame (is empty? %d)",
+ __FUNCTION__, device->getId().string(), result.mMetadata.isEmpty());
return processListeners(result, device) == OK;
}
@@ -178,8 +178,8 @@
entry = result.mMetadata.find(ANDROID_QUIRKS_PARTIAL_RESULT);
if (entry.count != 0 &&
entry.data.u8[0] == ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL) {
- ALOGV("%s: Camera %d: This is a partial result",
- __FUNCTION__, device->getId());
+ ALOGV("%s: Camera %s: This is a partial result",
+ __FUNCTION__, device->getId().string());
isPartialResult = true;
}
}
@@ -190,7 +190,7 @@
// include CaptureResultExtras.
entry = result.mMetadata.find(ANDROID_REQUEST_ID);
if (entry.count == 0) {
- ALOGE("%s: Camera %d: Error reading frame id", __FUNCTION__, device->getId());
+ ALOGE("%s: Camera %s: Error reading frame id", __FUNCTION__, device->getId().string());
return BAD_VALUE;
}
int32_t requestId = entry.data.i32[0];
@@ -215,8 +215,8 @@
item++;
}
}
- ALOGV("%s: Camera %d: Got %zu range listeners out of %zu", __FUNCTION__,
- device->getId(), listeners.size(), mRangeListeners.size());
+ ALOGV("%s: Camera %s: Got %zu range listeners out of %zu", __FUNCTION__,
+ device->getId().string(), listeners.size(), mRangeListeners.size());
List<sp<FilteredListener> >::iterator item = listeners.begin();
for (; item != listeners.end(); item++) {
diff --git a/services/camera/libcameraservice/device1/CameraHardwareInterface.h b/services/camera/libcameraservice/device1/CameraHardwareInterface.h
index 952bae1..c8210b7 100644
--- a/services/camera/libcameraservice/device1/CameraHardwareInterface.h
+++ b/services/camera/libcameraservice/device1/CameraHardwareInterface.h
@@ -27,6 +27,9 @@
#include <system/window.h>
#include <hardware/camera.h>
+#include <common/CameraModule.h>
+#include <common/CameraProviderManager.h>
+
namespace android {
typedef void (*notify_callback)(int32_t msgType,
@@ -124,6 +127,12 @@
return rc;
}
+ status_t initialize(sp<CameraProviderManager> manager) {
+ (void) manager;
+ ALOGE("%s: Not supported yet", __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+
/** Set the ANativeWindow to which preview frames are sent */
status_t setPreviewWindow(const sp<ANativeWindow>& buf)
{
diff --git a/services/camera/libcameraservice/device3/Camera3Device.cpp b/services/camera/libcameraservice/device3/Camera3Device.cpp
index 3705e8f..6f64dc3 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Device.cpp
@@ -26,7 +26,7 @@
#endif
// Convenience macro for transient errors
-#define CLOGE(fmt, ...) ALOGE("Camera %d: %s: " fmt, mId, __FUNCTION__, \
+#define CLOGE(fmt, ...) ALOGE("Camera %s: %s: " fmt, mId.string(), __FUNCTION__, \
##__VA_ARGS__)
// Convenience macros for transitioning to the error state
@@ -56,13 +56,14 @@
#include "CameraService.h"
using namespace android::camera3;
+using namespace android::hardware::camera;
+using namespace android::hardware::camera::device::V3_2;
namespace android {
-Camera3Device::Camera3Device(int id):
+Camera3Device::Camera3Device(const String8 &id):
mId(id),
mIsConstrainedHighSpeedConfiguration(false),
- mHal3Device(NULL),
mStatus(STATUS_UNINITIALIZED),
mStatusWaiters(0),
mUsePartialResult(false),
@@ -77,17 +78,17 @@
ATRACE_CALL();
camera3_callback_ops::notify = &sNotify;
camera3_callback_ops::process_capture_result = &sProcessCaptureResult;
- ALOGV("%s: Created device for camera %d", __FUNCTION__, id);
+ ALOGV("%s: Created device for camera %s", __FUNCTION__, mId.string());
}
Camera3Device::~Camera3Device()
{
ATRACE_CALL();
- ALOGV("%s: Tearing down for camera id %d", __FUNCTION__, mId);
+ ALOGV("%s: Tearing down for camera id %s", __FUNCTION__, mId.string());
disconnect();
}
-int Camera3Device::getId() const {
+const String8& Camera3Device::getId() const {
return mId;
}
@@ -101,7 +102,7 @@
Mutex::Autolock il(mInterfaceLock);
Mutex::Autolock l(mLock);
- ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mId);
+ ALOGV("%s: Initializing device for camera %s", __FUNCTION__, mId.string());
if (mStatus != STATUS_UNINITIALIZED) {
CLOGE("Already initialized!");
return INVALID_OPERATION;
@@ -110,12 +111,11 @@
/** Open HAL device */
status_t res;
- String8 deviceName = String8::format("%d", mId);
camera3_device_t *device;
- ATRACE_BEGIN("camera3->open");
- res = module->open(deviceName.string(),
+ ATRACE_BEGIN("CameraHal::open");
+ res = module->open(mId.string(),
reinterpret_cast<hw_device_t**>(&device));
ATRACE_END();
@@ -125,17 +125,17 @@
}
/** Cross-check device version */
- if (device->common.version < CAMERA_DEVICE_API_VERSION_3_0) {
+ if (device->common.version < CAMERA_DEVICE_API_VERSION_3_2) {
SET_ERR_L("Could not open camera: "
"Camera device should be at least %x, reports %x instead",
- CAMERA_DEVICE_API_VERSION_3_0,
+ CAMERA_DEVICE_API_VERSION_3_2,
device->common.version);
device->common.close(&device->common);
return BAD_VALUE;
}
camera_info info;
- res = module->getCameraInfo(mId, &info);
+ res = module->getCameraInfo(atoi(mId), &info);
if (res != OK) return res;
if (info.device_version != device->common.version) {
@@ -148,7 +148,7 @@
/** Initialize device with callback functions */
- ATRACE_BEGIN("camera3->initialize");
+ ATRACE_BEGIN("CameraHal::initialize");
res = device->ops->initialize(device, this);
ATRACE_END();
@@ -156,16 +156,64 @@
SET_ERR_L("Unable to initialize HAL device: %s (%d)",
strerror(-res), res);
device->common.close(&device->common);
- return BAD_VALUE;
+ return res;
}
+ /** Everything is good to go */
+
+ mDeviceVersion = device->common.version;
+ mDeviceInfo = info.static_camera_characteristics;
+ mInterface = std::make_unique<HalInterface>(device);
+
+ return initializeCommonLocked();
+}
+
+status_t Camera3Device::initialize(sp<CameraProviderManager> manager) {
+ ATRACE_CALL();
+ Mutex::Autolock il(mInterfaceLock);
+ Mutex::Autolock l(mLock);
+
+ ALOGV("%s: Initializing HIDL device for camera %s", __FUNCTION__, mId.string());
+ if (mStatus != STATUS_UNINITIALIZED) {
+ CLOGE("Already initialized!");
+ return INVALID_OPERATION;
+ }
+ if (manager == nullptr) return INVALID_OPERATION;
+
+ sp<ICameraDeviceSession> session;
+ ATRACE_BEGIN("CameraHal::openSession");
+ status_t res = manager->openSession(String8::std_string(mId), this,
+ /*out*/ &session);
+ ATRACE_END();
+ if (res != OK) {
+ SET_ERR_L("Could not open camera session: %s (%d)", strerror(-res), res);
+ return res;
+ }
+
+ res = manager->getCameraCharacteristics(String8::std_string(mId), &mDeviceInfo);
+ if (res != OK) {
+ SET_ERR_L("Could not retrive camera characteristics: %s (%d)", strerror(-res), res);
+ session->close();
+ return res;
+ }
+
+ // TODO: camera service will absorb 3_2/3_3/3_4 differences in the future
+ // for now use 3_4 to keep legacy devices working
+ mDeviceVersion = CAMERA_DEVICE_API_VERSION_3_4;
+ mInterface = std::make_unique<HalInterface>(session);
+
+ return initializeCommonLocked();
+}
+
+status_t Camera3Device::initializeCommonLocked() {
+
/** Start up status tracker thread */
mStatusTracker = new StatusTracker(this);
- res = mStatusTracker->run(String8::format("C3Dev-%d-Status", mId).string());
+ status_t res = mStatusTracker->run(String8::format("C3Dev-%s-Status", mId.string()).string());
if (res != OK) {
SET_ERR_L("Unable to start status tracking thread: %s (%d)",
strerror(-res), res);
- device->common.close(&device->common);
+ mInterface->close();
mStatusTracker.clear();
return res;
}
@@ -177,38 +225,31 @@
mBufferManager = new Camera3BufferManager();
bool aeLockAvailable = false;
- camera_metadata_ro_entry aeLockAvailableEntry;
- res = find_camera_metadata_ro_entry(info.static_camera_characteristics,
- ANDROID_CONTROL_AE_LOCK_AVAILABLE, &aeLockAvailableEntry);
- if (res == OK && aeLockAvailableEntry.count > 0) {
+ camera_metadata_entry aeLockAvailableEntry = mDeviceInfo.find(
+ ANDROID_CONTROL_AE_LOCK_AVAILABLE);
+ if (aeLockAvailableEntry.count > 0) {
aeLockAvailable = (aeLockAvailableEntry.data.u8[0] ==
ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE);
}
/** Start up request queue thread */
- mRequestThread = new RequestThread(this, mStatusTracker, device, aeLockAvailable);
- res = mRequestThread->run(String8::format("C3Dev-%d-ReqQueue", mId).string());
+ mRequestThread = new RequestThread(this, mStatusTracker, mInterface.get(), mDeviceVersion,
+ aeLockAvailable);
+ res = mRequestThread->run(String8::format("C3Dev-%s-ReqQueue", mId.string()).string());
if (res != OK) {
SET_ERR_L("Unable to start request queue thread: %s (%d)",
strerror(-res), res);
- device->common.close(&device->common);
+ mInterface->close();
mRequestThread.clear();
return res;
}
mPreparerThread = new PreparerThread();
- /** Everything is good to go */
-
- mDeviceVersion = device->common.version;
- mDeviceInfo = info.static_camera_characteristics;
- mHal3Device = device;
-
// Determine whether we need to derive sensitivity boost values for older devices.
// If post-RAW sensitivity boost range is listed, so should post-raw sensitivity control
// be listed (as the default value 100)
- if (mDeviceVersion < CAMERA_DEVICE_API_VERSION_3_4 &&
- mDeviceInfo.exists(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE)) {
+ if (mDeviceInfo.exists(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE)) {
mDerivePostRawSensKey = true;
}
@@ -312,7 +353,7 @@
mStatusTracker->join();
}
- camera3_device_t *hal3Device;
+ HalInterface* interface;
{
Mutex::Autolock l(mLock);
@@ -320,20 +361,16 @@
mStatusTracker.clear();
mBufferManager.clear();
- hal3Device = mHal3Device;
+ interface = mInterface.get();
}
// Call close without internal mutex held, as the HAL close may need to
// wait on assorted callbacks,etc, to complete before it can return.
- if (hal3Device != NULL) {
- ATRACE_BEGIN("camera3->close");
- hal3Device->common.close(&hal3Device->common);
- ATRACE_END();
- }
+ interface->close();
{
Mutex::Autolock l(mLock);
- mHal3Device = NULL;
+ mInterface->clear();
internalUpdateStatusLocked(STATUS_UNINITIALIZED);
}
@@ -447,12 +484,80 @@
}
}
+hardware::graphics::common::V1_0::PixelFormat Camera3Device::mapToPixelFormat(
+ int frameworkFormat) {
+ return (hardware::graphics::common::V1_0::PixelFormat) frameworkFormat;
+}
+
+DataspaceFlags Camera3Device::mapToHidlDataspace(
+ android_dataspace dataSpace) {
+ return dataSpace;
+}
+
+ConsumerUsageFlags Camera3Device::mapToConsumerUsage(
+ uint32_t usage) {
+ return usage;
+}
+
+StreamRotation Camera3Device::mapToStreamRotation(camera3_stream_rotation_t rotation) {
+ switch (rotation) {
+ case CAMERA3_STREAM_ROTATION_0:
+ return StreamRotation::ROTATION_0;
+ case CAMERA3_STREAM_ROTATION_90:
+ return StreamRotation::ROTATION_90;
+ case CAMERA3_STREAM_ROTATION_180:
+ return StreamRotation::ROTATION_180;
+ case CAMERA3_STREAM_ROTATION_270:
+ return StreamRotation::ROTATION_270;
+ }
+ ALOGE("%s: Unknown stream rotation %d", __FUNCTION__, rotation);
+ return StreamRotation::ROTATION_0;
+}
+
+StreamConfigurationMode Camera3Device::mapToStreamConfigurationMode(
+ camera3_stream_configuration_mode_t operationMode) {
+ switch(operationMode) {
+ case CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE:
+ return StreamConfigurationMode::NORMAL_MODE;
+ case CAMERA3_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE:
+ return StreamConfigurationMode::CONSTRAINED_HIGH_SPEED_MODE;
+ case CAMERA3_VENDOR_STREAM_CONFIGURATION_MODE_START:
+ // Needs to be mapped by vendor extensions
+ break;
+ }
+ ALOGE("%s: Unknown stream configuration mode %d", __FUNCTION__, operationMode);
+ return StreamConfigurationMode::NORMAL_MODE;
+}
+
+camera3_buffer_status_t Camera3Device::mapHidlBufferStatus(BufferStatus status) {
+ switch (status) {
+ case BufferStatus::OK: return CAMERA3_BUFFER_STATUS_OK;
+ case BufferStatus::ERROR: return CAMERA3_BUFFER_STATUS_ERROR;
+ }
+ return CAMERA3_BUFFER_STATUS_ERROR;
+}
+
+int Camera3Device::mapToFrameworkFormat(
+ hardware::graphics::common::V1_0::PixelFormat pixelFormat) {
+ return static_cast<uint32_t>(pixelFormat);
+}
+
+uint32_t Camera3Device::mapConsumerToFrameworkUsage(
+ ConsumerUsageFlags usage) {
+ return usage;
+}
+
+uint32_t Camera3Device::mapProducerToFrameworkUsage(
+ ProducerUsageFlags usage) {
+ return usage;
+}
+
ssize_t Camera3Device::getJpegBufferSize(uint32_t width, uint32_t height) const {
// Get max jpeg size (area-wise).
Size maxJpegResolution = getMaxJpegResolution();
if (maxJpegResolution.width == 0) {
- ALOGE("%s: Camera %d: Can't find valid available jpeg sizes in static metadata!",
- __FUNCTION__, mId);
+ ALOGE("%s: Camera %s: Can't find valid available jpeg sizes in static metadata!",
+ __FUNCTION__, mId.string());
return BAD_VALUE;
}
@@ -460,7 +565,8 @@
ssize_t maxJpegBufferSize = 0;
camera_metadata_ro_entry jpegBufMaxSize = mDeviceInfo.find(ANDROID_JPEG_MAX_SIZE);
if (jpegBufMaxSize.count == 0) {
- ALOGE("%s: Camera %d: Can't find maximum JPEG size in static metadata!", __FUNCTION__, mId);
+ ALOGE("%s: Camera %s: Can't find maximum JPEG size in static metadata!", __FUNCTION__,
+ mId.string());
return BAD_VALUE;
}
maxJpegBufferSize = jpegBufMaxSize.data.i32[0];
@@ -482,8 +588,8 @@
const int FLOATS_PER_POINT=4;
camera_metadata_ro_entry maxPointCount = mDeviceInfo.find(ANDROID_DEPTH_MAX_DEPTH_SAMPLES);
if (maxPointCount.count == 0) {
- ALOGE("%s: Camera %d: Can't find maximum depth point cloud size in static metadata!",
- __FUNCTION__, mId);
+ ALOGE("%s: Camera %s: Can't find maximum depth point cloud size in static metadata!",
+ __FUNCTION__, mId.string());
return BAD_VALUE;
}
ssize_t maxBytesForPointCloud = sizeof(android_depth_points) +
@@ -500,8 +606,8 @@
mDeviceInfo.find(ANDROID_SENSOR_OPAQUE_RAW_SIZE);
size_t count = rawOpaqueSizes.count;
if (count == 0 || (count % PER_CONFIGURATION_SIZE)) {
- ALOGE("%s: Camera %d: bad opaque RAW size static metadata length(%zu)!",
- __FUNCTION__, mId, count);
+ ALOGE("%s: Camera %s: bad opaque RAW size static metadata length(%zu)!",
+ __FUNCTION__, mId.string(), count);
return BAD_VALUE;
}
@@ -512,8 +618,8 @@
}
}
- ALOGE("%s: Camera %d: cannot find size for %dx%d opaque RAW image!",
- __FUNCTION__, mId, width, height);
+ ALOGE("%s: Camera %s: cannot find size for %dx%d opaque RAW image!",
+ __FUNCTION__, mId.string(), width, height);
return BAD_VALUE;
}
@@ -527,11 +633,11 @@
bool gotLock = tryLockSpinRightRound(mLock);
ALOGW_IF(!gotInterfaceLock,
- "Camera %d: %s: Unable to lock interface lock, proceeding anyway",
- mId, __FUNCTION__);
+ "Camera %s: %s: Unable to lock interface lock, proceeding anyway",
+ mId.string(), __FUNCTION__);
ALOGW_IF(!gotLock,
- "Camera %d: %s: Unable to lock main lock, proceeding anyway",
- mId, __FUNCTION__);
+ "Camera %s: %s: Unable to lock main lock, proceeding anyway",
+ mId.string(), __FUNCTION__);
bool dumpTemplates = false;
@@ -624,12 +730,11 @@
};
for (int i = 1; i < CAMERA3_TEMPLATE_COUNT; i++) {
- const camera_metadata_t *templateRequest;
- templateRequest =
- mHal3Device->ops->construct_default_request_settings(
- mHal3Device, i);
+ camera_metadata_t *templateRequest = nullptr;
+ mInterface->constructDefaultRequestSettings(
+ (camera3_request_template_t) i, &templateRequest);
lines = String8::format(" HAL Request %s:\n", templateNames[i-1]);
- if (templateRequest == NULL) {
+ if (templateRequest == nullptr) {
lines.append(" Not supported\n");
write(fd, lines.string(), lines.size());
} else {
@@ -637,15 +742,16 @@
dump_indented_camera_metadata(templateRequest,
fd, /*verbosity*/2, /*indentation*/8);
}
+ free_camera_metadata(templateRequest);
}
}
mTagMonitor.dumpMonitoredMetadata(fd);
- if (mHal3Device != NULL) {
+ if (mInterface->valid()) {
lines = String8(" HAL device dump:\n");
write(fd, lines.string(), lines.size());
- mHal3Device->ops->dump(mHal3Device, fd);
+ mInterface->dump(fd);
}
if (gotLock) mLock.unlock();
@@ -779,7 +885,7 @@
SET_ERR_L("Can't transition to active in %f seconds!",
kActiveTimeout/1e9);
}
- ALOGV("Camera %d: Capture request %" PRId32 " enqueued", mId,
+ ALOGV("Camera %s: Capture request %" PRId32 " enqueued", mId.string(),
(*(requestList.begin()))->mResultExtras.requestId);
} else {
CLOGE("Cannot queue request. Impossible.");
@@ -789,6 +895,145 @@
return res;
}
+hardware::Return<void> Camera3Device::processCaptureResult(
+ const device::V3_2::CaptureResult& result) {
+ camera3_capture_result r;
+ status_t res;
+ r.frame_number = result.frameNumber;
+ if (result.result.size() != 0) {
+ r.result = reinterpret_cast<const camera_metadata_t*>(result.result.data());
+ size_t expected_metadata_size = result.result.size();
+ if ((res = validate_camera_metadata_structure(r.result, &expected_metadata_size)) != OK) {
+ ALOGE("%s: Frame %d: Invalid camera metadata received by camera service from HAL: %s (%d)",
+ __FUNCTION__, result.frameNumber, strerror(-res), res);
+ return hardware::Void();
+ }
+ } else {
+ r.result = nullptr;
+ }
+
+ std::vector<camera3_stream_buffer_t> outputBuffers(result.outputBuffers.size());
+ std::vector<buffer_handle_t> outputBufferHandles(result.outputBuffers.size());
+ for (size_t i = 0; i < result.outputBuffers.size(); i++) {
+ auto& bDst = outputBuffers[i];
+ const StreamBuffer &bSrc = result.outputBuffers[i];
+
+ ssize_t idx = mOutputStreams.indexOfKey(bSrc.streamId);
+ if (idx == -1) {
+ ALOGE("%s: Frame %d: Buffer %zu: Invalid output stream id %d",
+ __FUNCTION__, result.frameNumber, i, bSrc.streamId);
+ return hardware::Void();
+ }
+ bDst.stream = mOutputStreams.valueAt(idx)->asHalStream();
+
+ buffer_handle_t *buffer;
+ res = mInterface->popInflightBuffer(result.frameNumber, bSrc.streamId,
+ &buffer);
+ if (res != OK) {
+ ALOGE("%s: Frame %d: Buffer %zu: No in-flight buffer for stream %d",
+ __FUNCTION__, result.frameNumber, i, bSrc.streamId);
+ return hardware::Void();
+ }
+ bDst.buffer = buffer;
+ bDst.status = mapHidlBufferStatus(bSrc.status);
+ bDst.acquire_fence = -1;
+ if (bSrc.releaseFence == nullptr) {
+ bDst.release_fence = -1;
+ } else if (bSrc.releaseFence->numFds == 1) {
+ bDst.release_fence = dup(bSrc.releaseFence->data[0]);
+ } else {
+ ALOGE("%s: Frame %d: Invalid release fence for buffer %zu, fd count is %d, not 1",
+ __FUNCTION__, result.frameNumber, i, bSrc.releaseFence->numFds);
+ return hardware::Void();
+ }
+ }
+ r.num_output_buffers = outputBuffers.size();
+ r.output_buffers = outputBuffers.data();
+
+ camera3_stream_buffer_t inputBuffer;
+ if (result.inputBuffer.streamId == -1) {
+ r.input_buffer = nullptr;
+ } else {
+ if (mInputStream->getId() != result.inputBuffer.streamId) {
+ ALOGE("%s: Frame %d: Invalid input stream id %d", __FUNCTION__,
+ result.frameNumber, result.inputBuffer.streamId);
+ return hardware::Void();
+ }
+ inputBuffer.stream = mInputStream->asHalStream();
+ buffer_handle_t *buffer;
+ res = mInterface->popInflightBuffer(result.frameNumber, result.inputBuffer.streamId,
+ &buffer);
+ if (res != OK) {
+ ALOGE("%s: Frame %d: Input buffer: No in-flight buffer for stream %d",
+ __FUNCTION__, result.frameNumber, result.inputBuffer.streamId);
+ return hardware::Void();
+ }
+ inputBuffer.buffer = buffer;
+ inputBuffer.status = mapHidlBufferStatus(result.inputBuffer.status);
+ inputBuffer.acquire_fence = -1;
+ if (result.inputBuffer.releaseFence == nullptr) {
+ inputBuffer.release_fence = -1;
+ } else if (result.inputBuffer.releaseFence->numFds == 1) {
+ inputBuffer.release_fence = dup(result.inputBuffer.releaseFence->data[0]);
+ } else {
+ ALOGE("%s: Frame %d: Invalid release fence for input buffer, fd count is %d, not 1",
+ __FUNCTION__, result.frameNumber, result.inputBuffer.releaseFence->numFds);
+ return hardware::Void();
+ }
+ r.input_buffer = &inputBuffer;
+ }
+
+ r.partial_result = result.partialResult;
+
+ processCaptureResult(&r);
+
+ return hardware::Void();
+}
+
+hardware::Return<void> Camera3Device::notify(
+ const NotifyMsg& msg) {
+ camera3_notify_msg m;
+ switch (msg.type) {
+ case MsgType::ERROR:
+ m.type = CAMERA3_MSG_ERROR;
+ m.message.error.frame_number = msg.msg.error.frameNumber;
+ if (msg.msg.error.errorStreamId >= 0) {
+ ssize_t idx = mOutputStreams.indexOfKey(msg.msg.error.errorStreamId);
+ if (idx == -1) {
+ ALOGE("%s: Frame %d: Invalid error stream id %d",
+ __FUNCTION__, m.message.error.frame_number, msg.msg.error.errorStreamId);
+ return hardware::Void();
+ }
+ m.message.error.error_stream = mOutputStreams.valueAt(idx)->asHalStream();
+ } else {
+ m.message.error.error_stream = nullptr;
+ }
+ switch (msg.msg.error.errorCode) {
+ case ErrorCode::ERROR_DEVICE:
+ m.message.error.error_code = CAMERA3_MSG_ERROR_DEVICE;
+ break;
+ case ErrorCode::ERROR_REQUEST:
+ m.message.error.error_code = CAMERA3_MSG_ERROR_REQUEST;
+ break;
+ case ErrorCode::ERROR_RESULT:
+ m.message.error.error_code = CAMERA3_MSG_ERROR_RESULT;
+ break;
+ case ErrorCode::ERROR_BUFFER:
+ m.message.error.error_code = CAMERA3_MSG_ERROR_BUFFER;
+ break;
+ }
+ break;
+ case MsgType::SHUTTER:
+ m.type = CAMERA3_MSG_SHUTTER;
+ m.message.shutter.frame_number = msg.msg.shutter.frameNumber;
+ m.message.shutter.timestamp = msg.msg.shutter.timestamp;
+ break;
+ }
+ notify(&m);
+
+ return hardware::Void();
+}
+
status_t Camera3Device::captureList(const List<const CameraMetadata> &requests,
int64_t *lastFrameNumber) {
ATRACE_CALL();
@@ -854,7 +1099,7 @@
SET_ERR_L("Unexpected status: %d", mStatus);
return INVALID_OPERATION;
}
- ALOGV("Camera %d: Clearing repeating request", mId);
+ ALOGV("Camera %s: Clearing repeating request", mId.string());
return mRequestThread->clearRepeatingRequests(lastFrameNumber);
}
@@ -871,8 +1116,8 @@
ATRACE_CALL();
Mutex::Autolock il(mInterfaceLock);
Mutex::Autolock l(mLock);
- ALOGV("Camera %d: Creating new input stream %d: %d x %d, format %d",
- mId, mNextStreamId, width, height, format);
+ ALOGV("Camera %s: Creating new input stream %d: %d x %d, format %d",
+ mId.string(), mNextStreamId, width, height, format);
status_t res;
bool wasActive = false;
@@ -928,7 +1173,7 @@
internalResumeLocked();
}
- ALOGV("Camera %d: Created input stream", mId);
+ ALOGV("Camera %s: Created input stream", mId.string());
return OK;
}
@@ -942,8 +1187,8 @@
ATRACE_CALL();
Mutex::Autolock il(mInterfaceLock);
Mutex::Autolock l(mLock);
- ALOGV("Camera %d: Creating ZSL stream %d: %d x %d, depth %d",
- mId, mNextStreamId, width, height, depth);
+ ALOGV("Camera %s: Creating ZSL stream %d: %d x %d, depth %d",
+ mId.string(), mNextStreamId, width, height, depth);
status_t res;
bool wasActive = false;
@@ -1008,7 +1253,7 @@
internalResumeLocked();
}
- ALOGV("Camera %d: Created ZSL stream", mId);
+ ALOGV("Camera %s: Created ZSL stream", mId.string());
return OK;
}
@@ -1018,8 +1263,8 @@
ATRACE_CALL();
Mutex::Autolock il(mInterfaceLock);
Mutex::Autolock l(mLock);
- ALOGV("Camera %d: Creating new stream %d: %d x %d, format %d, dataspace %d rotation %d"
- " consumer usage 0x%x", mId, mNextStreamId, width, height, format, dataSpace, rotation,
+ ALOGV("Camera %s: Creating new stream %d: %d x %d, format %d, dataspace %d rotation %d"
+ " consumer usage 0x%x", mId.string(), mNextStreamId, width, height, format, dataSpace, rotation,
consumerUsage);
status_t res;
@@ -1142,7 +1387,7 @@
}
internalResumeLocked();
}
- ALOGV("Camera %d: Created new stream", mId);
+ ALOGV("Camera %s: Created new stream", mId.string());
return OK;
}
@@ -1231,12 +1476,12 @@
Mutex::Autolock l(mLock);
status_t res;
- ALOGV("%s: Camera %d: Deleting stream %d", __FUNCTION__, mId, id);
+ ALOGV("%s: Camera %s: Deleting stream %d", __FUNCTION__, mId.string(), id);
// CameraDevice semantics require device to already be idle before
// deleteStream is called, unlike for createStream.
if (mStatus == STATUS_ACTIVE) {
- ALOGV("%s: Camera %d: Device not idle", __FUNCTION__, mId);
+ ALOGV("%s: Camera %s: Device not idle", __FUNCTION__, mId.string());
return -EBUSY;
}
@@ -1343,18 +1588,20 @@
return OK;
}
- const camera_metadata_t *rawRequest;
- ATRACE_BEGIN("camera3->construct_default_request_settings");
- rawRequest = mHal3Device->ops->construct_default_request_settings(
- mHal3Device, templateId);
- ATRACE_END();
- if (rawRequest == NULL) {
+ camera_metadata_t *rawRequest;
+ status_t res = mInterface->constructDefaultRequestSettings(
+ (camera3_request_template_t) templateId, &rawRequest);
+ if (res == BAD_VALUE) {
ALOGI("%s: template %d is not supported on this camera device",
__FUNCTION__, templateId);
- return BAD_VALUE;
+ return res;
+ } else if (res != OK) {
+ CLOGE("Unable to construct request template %d: %s (%d)",
+ templateId, strerror(-res), res);
+ return res;
}
- mRequestTemplateCache[templateId] = rawRequest;
+ mRequestTemplateCache[templateId].acquire(rawRequest);
// Derive some new keys for backward compatibility
if (mDerivePostRawSensKey && !mRequestTemplateCache[templateId].exists(
@@ -1394,7 +1641,7 @@
return INVALID_OPERATION;
}
- ALOGV("%s: Camera %d: Waiting until idle", __FUNCTION__, mId);
+ ALOGV("%s: Camera %s: Waiting until idle", __FUNCTION__, mId.string());
status_t res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
if (res != OK) {
SET_ERR_L("Error waiting for HAL to drain: %s (%d)", strerror(-res),
@@ -1415,7 +1662,7 @@
mRequestThread->setPaused(true);
mPauseStateNotify = true;
- ALOGV("%s: Camera %d: Internal wait until idle", __FUNCTION__, mId);
+ ALOGV("%s: Camera %s: Internal wait until idle", __FUNCTION__, mId.string());
status_t res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
if (res != OK) {
SET_ERR_L("Can't idle device in %f seconds!",
@@ -1514,8 +1761,8 @@
if (res == TIMED_OUT) {
return res;
} else if (res != OK) {
- ALOGW("%s: Camera %d: No frame in %" PRId64 " ns: %s (%d)",
- __FUNCTION__, mId, timeout, strerror(-res), res);
+ ALOGW("%s: Camera %s: No frame in %" PRId64 " ns: %s (%d)",
+ __FUNCTION__, mId.string(), timeout, strerror(-res), res);
return res;
}
}
@@ -1617,7 +1864,7 @@
status_t Camera3Device::flush(int64_t *frameNumber) {
ATRACE_CALL();
- ALOGV("%s: Camera %d: Flushing all requests", __FUNCTION__, mId);
+ ALOGV("%s: Camera %s: Flushing all requests", __FUNCTION__, mId.string());
Mutex::Autolock il(mInterfaceLock);
{
@@ -1626,7 +1873,7 @@
}
status_t res;
- if (mHal3Device->common.version >= CAMERA_DEVICE_API_VERSION_3_1) {
+ if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_1) {
res = mRequestThread->flush();
} else {
Mutex::Autolock l(mLock);
@@ -1642,7 +1889,7 @@
status_t Camera3Device::prepare(int maxCount, int streamId) {
ATRACE_CALL();
- ALOGV("%s: Camera %d: Preparing stream %d", __FUNCTION__, mId, streamId);
+ ALOGV("%s: Camera %s: Preparing stream %d", __FUNCTION__, mId.string(), streamId);
Mutex::Autolock il(mInterfaceLock);
Mutex::Autolock l(mLock);
@@ -1670,15 +1917,15 @@
status_t Camera3Device::tearDown(int streamId) {
ATRACE_CALL();
- ALOGV("%s: Camera %d: Tearing down stream %d", __FUNCTION__, mId, streamId);
+ ALOGV("%s: Camera %s: Tearing down stream %d", __FUNCTION__, mId.string(), streamId);
Mutex::Autolock il(mInterfaceLock);
Mutex::Autolock l(mLock);
// Teardown can only be accomplished on devices that don't require register_stream_buffers,
// since we cannot call register_stream_buffers except right after configure_streams.
- if (mHal3Device->common.version < CAMERA_DEVICE_API_VERSION_3_2) {
+ if (mDeviceVersion < CAMERA_DEVICE_API_VERSION_3_2) {
ALOGE("%s: Unable to tear down streams on device HAL v%x",
- __FUNCTION__, mHal3Device->common.version);
+ __FUNCTION__, mDeviceVersion);
return NO_INIT;
}
@@ -1702,7 +1949,7 @@
status_t Camera3Device::addBufferListenerForStream(int streamId,
wp<Camera3StreamBufferListener> listener) {
ATRACE_CALL();
- ALOGV("%s: Camera %d: Adding buffer listener for stream %d", __FUNCTION__, mId, streamId);
+ ALOGV("%s: Camera %s: Adding buffer listener for stream %d", __FUNCTION__, mId.string(), streamId);
Mutex::Autolock il(mInterfaceLock);
Mutex::Autolock l(mLock);
@@ -1740,7 +1987,7 @@
if (mStatus != STATUS_ACTIVE && mStatus != STATUS_CONFIGURED) {
return;
}
- ALOGV("%s: Camera %d: Now %s", __FUNCTION__, mId,
+ ALOGV("%s: Camera %s: Now %s", __FUNCTION__, mId.string(),
idle ? "idle" : "active");
internalUpdateStatusLocked(idle ? STATUS_CONFIGURED : STATUS_ACTIVE);
@@ -1761,7 +2008,7 @@
status_t Camera3Device::setConsumerSurface(int streamId, sp<Surface> consumer) {
ATRACE_CALL();
- ALOGV("%s: Camera %d: set consumer surface for stream %d", __FUNCTION__, mId, streamId);
+ ALOGV("%s: Camera %s: set consumer surface for stream %d", __FUNCTION__, mId.string(), streamId);
Mutex::Autolock il(mInterfaceLock);
Mutex::Autolock l(mLock);
@@ -1787,7 +2034,7 @@
return INVALID_OPERATION;
}
- res = stream->finishConfiguration(mHal3Device);
+ res = stream->finishConfiguration();
if (res != OK) {
SET_ERR_L("Can't finish configuring output stream %d: %s (%d)",
stream->getId(), strerror(-res), res);
@@ -1821,7 +2068,7 @@
// Lazy completion of stream configuration (allocation/registration)
// on first use
if (mInputStream->isConfiguring()) {
- res = mInputStream->finishConfiguration(mHal3Device);
+ res = mInputStream->finishConfiguration();
if (res != OK) {
SET_ERR_L("Unable to finish configuring input stream %d:"
" %s (%d)",
@@ -1866,7 +2113,7 @@
// Lazy completion of stream configuration (allocation/registration)
// on first use
if (stream->isConfiguring()) {
- res = stream->finishConfiguration(mHal3Device);
+ res = stream->finishConfiguration();
if (res != OK) {
SET_ERR_L("Unable to finish configuring stream %d: %s (%d)",
stream->getId(), strerror(-res), res);
@@ -1949,7 +2196,7 @@
}
// Start configuring the streams
- ALOGV("%s: Camera %d: Starting stream configuration", __FUNCTION__, mId);
+ ALOGV("%s: Camera %s: Starting stream configuration", __FUNCTION__, mId.string());
camera3_stream_configuration config;
config.operation_mode = mIsConstrainedHighSpeedConfiguration ?
@@ -1995,9 +2242,8 @@
// Do the HAL configuration; will potentially touch stream
// max_buffers, usage, priv fields.
- ATRACE_BEGIN("camera3->configure_streams");
- res = mHal3Device->ops->configure_streams(mHal3Device, &config);
- ATRACE_END();
+
+ res = mInterface->configureStreams(&config);
if (res == BAD_VALUE) {
// HAL rejected this set of streams as unsupported, clean up config
@@ -2018,7 +2264,7 @@
// faster
if (mInputStream != NULL && mInputStream->isConfiguring()) {
- res = mInputStream->finishConfiguration(mHal3Device);
+ res = mInputStream->finishConfiguration();
if (res != OK) {
CLOGE("Can't finish configuring input stream %d: %s (%d)",
mInputStream->getId(), strerror(-res), res);
@@ -2031,7 +2277,7 @@
sp<Camera3OutputStreamInterface> outputStream =
mOutputStreams.editValueAt(i);
if (outputStream->isConfiguring() && !outputStream->isConsumerConfigurationDeferred()) {
- res = outputStream->finishConfiguration(mHal3Device);
+ res = outputStream->finishConfiguration();
if (res != OK) {
CLOGE("Can't finish configuring output stream %d: %s (%d)",
outputStream->getId(), strerror(-res), res);
@@ -2068,7 +2314,7 @@
internalUpdateStatusLocked((mDummyStreamId == NO_STREAM) ?
STATUS_CONFIGURED : STATUS_UNCONFIGURED);
- ALOGV("%s: Camera %d: Stream configuration complete", __FUNCTION__, mId);
+ ALOGV("%s: Camera %s: Stream configuration complete", __FUNCTION__, mId.string());
// tear down the deleted streams after configure streams.
mDeletedStreams.clear();
@@ -2083,12 +2329,12 @@
if (mDummyStreamId != NO_STREAM) {
// Should never be adding a second dummy stream when one is already
// active
- SET_ERR_L("%s: Camera %d: A dummy stream already exists!",
- __FUNCTION__, mId);
+ SET_ERR_L("%s: Camera %s: A dummy stream already exists!",
+ __FUNCTION__, mId.string());
return INVALID_OPERATION;
}
- ALOGV("%s: Camera %d: Adding a dummy stream", __FUNCTION__, mId);
+ ALOGV("%s: Camera %s: Adding a dummy stream", __FUNCTION__, mId.string());
sp<Camera3OutputStreamInterface> dummyStream =
new Camera3DummyStream(mNextStreamId);
@@ -2112,7 +2358,7 @@
if (mDummyStreamId == NO_STREAM) return OK;
if (mOutputStreams.size() == 1) return OK;
- ALOGV("%s: Camera %d: Removing the dummy stream", __FUNCTION__, mId);
+ ALOGV("%s: Camera %s: Removing the dummy stream", __FUNCTION__, mId.string());
// Ok, have a dummy stream and there's at least one other output stream,
// so remove the dummy
@@ -2166,7 +2412,7 @@
void Camera3Device::setErrorStateLockedV(const char *fmt, va_list args) {
// Print out all error messages to log
String8 errorCause = String8::formatV(fmt, args);
- ALOGE("Camera %d: %s", mId, errorCause.string());
+ ALOGE("Camera %s: %s", mId.string(), errorCause.string());
// But only do error state transition steps for the first error
if (mStatus == STATUS_ERROR || mStatus == STATUS_UNINITIALIZED) return;
@@ -2639,8 +2885,8 @@
Camera3Stream::cast(msg.error_stream);
streamId = stream->getId();
}
- ALOGV("Camera %d: %s: HAL error, frame %d, stream %d: %d",
- mId, __FUNCTION__, msg.frame_number,
+ ALOGV("Camera %s: %s: HAL error, frame %d, stream %d: %d",
+ mId.string(), __FUNCTION__, msg.frame_number,
streamId, msg.error_code);
CaptureResultExtras resultExtras;
@@ -2661,8 +2907,8 @@
resultExtras = r.resultExtras;
} else {
resultExtras.frameNumber = msg.frame_number;
- ALOGE("Camera %d: %s: cannot find in-flight request on "
- "frame %" PRId64 " error", mId, __FUNCTION__,
+ ALOGE("Camera %s: %s: cannot find in-flight request on "
+ "frame %" PRId64 " error", mId.string(), __FUNCTION__,
resultExtras.frameNumber);
}
}
@@ -2670,7 +2916,7 @@
if (listener != NULL) {
listener->notifyError(errorCode, resultExtras);
} else {
- ALOGE("Camera %d: %s: no listener available", mId, __FUNCTION__);
+ ALOGE("Camera %s: %s: no listener available", mId.string(), __FUNCTION__);
}
break;
default:
@@ -2715,8 +2961,8 @@
}
}
- ALOGVV("Camera %d: %s: Shutter fired for frame %d (id %d) at %" PRId64,
- mId, __FUNCTION__,
+ ALOGVV("Camera %s: %s: Shutter fired for frame %d (id %d) at %" PRId64,
+ mId.string(), __FUNCTION__,
msg.frame_number, r.resultExtras.requestId, msg.timestamp);
// Call listener, if any
if (listener != NULL) {
@@ -2762,17 +3008,356 @@
}
/**
+ * HalInterface inner class methods
+ */
+
+Camera3Device::HalInterface::HalInterface(camera3_device_t *device) :
+ mHal3Device(device) {}
+
+Camera3Device::HalInterface::HalInterface(sp<ICameraDeviceSession> &session) :
+ mHal3Device(nullptr),
+ mHidlSession(session) {}
+
+Camera3Device::HalInterface::HalInterface() :
+ mHal3Device(nullptr) {}
+
+Camera3Device::HalInterface::HalInterface(const HalInterface& other) :
+ mHal3Device(other.mHal3Device), mHidlSession(other.mHidlSession) {}
+
+bool Camera3Device::HalInterface::valid() {
+ return (mHal3Device != nullptr) || (mHidlSession != nullptr);
+}
+
+void Camera3Device::HalInterface::clear() {
+ mHal3Device = nullptr;
+ mHidlSession.clear();
+}
+
+status_t Camera3Device::HalInterface::constructDefaultRequestSettings(
+ camera3_request_template_t templateId,
+ /*out*/ camera_metadata_t **requestTemplate) {
+ ATRACE_NAME("CameraHal::constructDefaultRequestSettings");
+ if (!valid()) return INVALID_OPERATION;
+ status_t res = OK;
+
+ if (mHal3Device != nullptr) {
+ const camera_metadata *r;
+ r = mHal3Device->ops->construct_default_request_settings(
+ mHal3Device, templateId);
+ if (r == nullptr) return BAD_VALUE;
+ *requestTemplate = clone_camera_metadata(r);
+ if (requestTemplate == nullptr) {
+ ALOGE("%s: Unable to clone camera metadata received from HAL",
+ __FUNCTION__);
+ return INVALID_OPERATION;
+ }
+ } else {
+ common::V1_0::Status status;
+ RequestTemplate id;
+ switch (templateId) {
+ case CAMERA3_TEMPLATE_PREVIEW:
+ id = RequestTemplate::PREVIEW;
+ break;
+ case CAMERA3_TEMPLATE_STILL_CAPTURE:
+ id = RequestTemplate::STILL_CAPTURE;
+ break;
+ case CAMERA3_TEMPLATE_VIDEO_RECORD:
+ id = RequestTemplate::VIDEO_RECORD;
+ break;
+ case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
+ id = RequestTemplate::VIDEO_SNAPSHOT;
+ break;
+ case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
+ id = RequestTemplate::ZERO_SHUTTER_LAG;
+ break;
+ case CAMERA3_TEMPLATE_MANUAL:
+ id = RequestTemplate::MANUAL;
+ break;
+ default:
+ // Unknown template ID
+ return BAD_VALUE;
+ }
+ mHidlSession->constructDefaultRequestSettings(id,
+ [&status, &requestTemplate]
+ (common::V1_0::Status s, const device::V3_2::CameraMetadata& request) {
+ status = s;
+ if (status == common::V1_0::Status::OK) {
+ const camera_metadata *r =
+ reinterpret_cast<const camera_metadata_t*>(request.data());
+ size_t expectedSize = request.size();
+ int ret = validate_camera_metadata_structure(r, &expectedSize);
+ if (ret == OK) {
+ *requestTemplate = clone_camera_metadata(r);
+ if (*requestTemplate == nullptr) {
+ ALOGE("%s: Unable to clone camera metadata received from HAL",
+ __FUNCTION__);
+ status = common::V1_0::Status::INTERNAL_ERROR;
+ }
+ } else {
+ ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
+ status = common::V1_0::Status::INTERNAL_ERROR;
+ }
+ }
+ });
+ res = CameraProviderManager::mapToStatusT(status);
+ }
+ return res;
+}
+
+status_t Camera3Device::HalInterface::configureStreams(camera3_stream_configuration *config) {
+ ATRACE_NAME("CameraHal::configureStreams");
+ if (!valid()) return INVALID_OPERATION;
+ status_t res = OK;
+
+ if (mHal3Device != nullptr) {
+ res = mHal3Device->ops->configure_streams(mHal3Device, config);
+ } else {
+ // Convert stream config to HIDL
+
+ StreamConfiguration requestedConfiguration;
+ requestedConfiguration.streams.resize(config->num_streams);
+ for (size_t i = 0; i < config->num_streams; i++) {
+ Stream &dst = requestedConfiguration.streams[i];
+ camera3_stream_t *src = config->streams[i];
+
+ int streamId = Camera3Stream::cast(src)->getId();
+ StreamType streamType;
+ switch (src->stream_type) {
+ case CAMERA3_STREAM_OUTPUT:
+ streamType = StreamType::OUTPUT;
+ break;
+ case CAMERA3_STREAM_INPUT:
+ streamType = StreamType::INPUT;
+ break;
+ default:
+ ALOGE("%s: Stream %d: Unsupported stream type %d",
+ __FUNCTION__, streamId, config->streams[i]->stream_type);
+ return BAD_VALUE;
+ }
+ dst.id = streamId;
+ dst.streamType = streamType;
+ dst.width = src->width;
+ dst.height = src->height;
+ dst.format = mapToPixelFormat(src->format);
+ dst.usage = mapToConsumerUsage(src->usage);
+ dst.dataSpace = mapToHidlDataspace(src->data_space);
+ dst.rotation = mapToStreamRotation((camera3_stream_rotation_t) src->rotation);
+ }
+ requestedConfiguration.operationMode = mapToStreamConfigurationMode(
+ (camera3_stream_configuration_mode_t) config->operation_mode);
+
+ // Invoke configureStreams
+
+ HalStreamConfiguration finalConfiguration;
+ common::V1_0::Status status;
+ mHidlSession->configureStreams(requestedConfiguration,
+ [&status, &finalConfiguration]
+ (common::V1_0::Status s, const HalStreamConfiguration& halConfiguration) {
+ finalConfiguration = halConfiguration;
+ status = s;
+ });
+ if (status != common::V1_0::Status::OK ) {
+ return CameraProviderManager::mapToStatusT(status);
+ }
+
+ // And convert output stream configuration from HIDL
+
+ for (size_t i = 0; i < config->num_streams; i++) {
+ camera3_stream_t *dst = config->streams[i];
+ int streamId = Camera3Stream::cast(dst)->getId();
+
+ // Start scan at i, with the assumption that the stream order matches
+ size_t realIdx = i;
+ bool found = false;
+ for (size_t idx = 0; idx < finalConfiguration.streams.size(); idx++) {
+ if (finalConfiguration.streams[realIdx].id == streamId) {
+ found = true;
+ break;
+ }
+ realIdx = (realIdx >= finalConfiguration.streams.size()) ? 0 : realIdx + 1;
+ }
+ if (!found) {
+ ALOGE("%s: Stream %d not found in stream configuration response from HAL",
+ __FUNCTION__, streamId);
+ return INVALID_OPERATION;
+ }
+ HalStream &src = finalConfiguration.streams[realIdx];
+
+ int overrideFormat = mapToFrameworkFormat(src.overrideFormat);
+ if (dst->format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
+ if (dst->format != overrideFormat) {
+ ALOGE("%s: Stream %d: Format override not allowed for format 0x%x", __FUNCTION__,
+ streamId, dst->format);
+ }
+ } else {
+ // Override allowed with IMPLEMENTATION_DEFINED
+ dst->format = overrideFormat;
+ }
+
+ if (dst->stream_type == CAMERA3_STREAM_INPUT) {
+ if (src.producerUsage != 0) {
+ ALOGE("%s: Stream %d: INPUT streams must have 0 for producer usage",
+ __FUNCTION__, streamId);
+ return INVALID_OPERATION;
+ }
+ dst->usage = mapConsumerToFrameworkUsage(src.consumerUsage);
+ } else {
+ // OUTPUT
+ if (src.consumerUsage != 0) {
+ ALOGE("%s: Stream %d: OUTPUT streams must have 0 for consumer usage",
+ __FUNCTION__, streamId);
+ return INVALID_OPERATION;
+ }
+ dst->usage = mapProducerToFrameworkUsage(src.producerUsage);
+ }
+ dst->max_buffers = src.maxBuffers;
+ }
+ }
+ return res;
+}
+
+status_t Camera3Device::HalInterface::processCaptureRequest(
+ camera3_capture_request_t *request) {
+ ATRACE_NAME("CameraHal::processCaptureRequest");
+ if (!valid()) return INVALID_OPERATION;
+ status_t res = OK;
+
+ if (mHal3Device != nullptr) {
+ res = mHal3Device->ops->process_capture_request(mHal3Device, request);
+ } else {
+ device::V3_2::CaptureRequest captureRequest;
+ captureRequest.frameNumber = request->frame_number;
+ std::vector<native_handle_t*> handlesCreated;
+ // A null request settings maps to a size-0 CameraMetadata
+ if (request->settings != nullptr) {
+ captureRequest.settings.setToExternal(
+ reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(request->settings)),
+ get_camera_metadata_size(request->settings));
+ }
+
+ {
+ std::lock_guard<std::mutex> lock(mInflightLock);
+ if (request->input_buffer != nullptr) {
+ int32_t streamId = Camera3Stream::cast(request->input_buffer->stream)->getId();
+ captureRequest.inputBuffer.streamId = streamId;
+ captureRequest.inputBuffer.buffer = *(request->input_buffer->buffer);
+ captureRequest.inputBuffer.status = BufferStatus::OK;
+ native_handle_t *acquireFence = nullptr;
+ if (request->input_buffer->acquire_fence != -1) {
+ acquireFence = native_handle_create(1,0);
+ acquireFence->data[0] = request->input_buffer->acquire_fence;
+ handlesCreated.push_back(acquireFence);
+ }
+ captureRequest.inputBuffer.acquireFence = acquireFence;
+ captureRequest.inputBuffer.releaseFence = nullptr;
+
+ pushInflightBufferLocked(captureRequest.frameNumber, streamId,
+ request->input_buffer->buffer);
+ }
+
+ captureRequest.outputBuffers.resize(request->num_output_buffers);
+ for (size_t i = 0; i < request->num_output_buffers; i++) {
+ const camera3_stream_buffer_t *src = request->output_buffers + i;
+ StreamBuffer &dst = captureRequest.outputBuffers[i];
+ int32_t streamId = Camera3Stream::cast(src->stream)->getId();
+ dst.streamId = streamId;
+ dst.buffer = *(src->buffer);
+ dst.status = BufferStatus::OK;
+ native_handle_t *acquireFence = nullptr;
+ if (src->acquire_fence != -1) {
+ acquireFence = native_handle_create(1,0);
+ acquireFence->data[0] = src->acquire_fence;
+ handlesCreated.push_back(acquireFence);
+ }
+ dst.acquireFence = acquireFence;
+ dst.releaseFence = nullptr;
+
+ pushInflightBufferLocked(captureRequest.frameNumber, streamId,
+ src->buffer);
+ }
+ }
+ common::V1_0::Status status = mHidlSession->processCaptureRequest(captureRequest);
+
+ for (auto& handle : handlesCreated) {
+ native_handle_delete(handle);
+ }
+ res = CameraProviderManager::mapToStatusT(status);
+ }
+ return res;
+}
+
+status_t Camera3Device::HalInterface::flush() {
+ ATRACE_NAME("CameraHal::flush");
+ if (!valid()) return INVALID_OPERATION;
+ status_t res = OK;
+
+ if (mHal3Device != nullptr) {
+ res = mHal3Device->ops->flush(mHal3Device);
+ } else {
+ res = CameraProviderManager::mapToStatusT(mHidlSession->flush());
+ }
+ return res;
+}
+
+status_t Camera3Device::HalInterface::dump(int fd) {
+ ATRACE_NAME("CameraHal::dump");
+ if (!valid()) return INVALID_OPERATION;
+ status_t res = OK;
+
+ if (mHal3Device != nullptr) {
+ mHal3Device->ops->dump(mHal3Device, fd);
+ } else {
+ // Handled by CameraProviderManager::dump
+ }
+ return res;
+}
+
+status_t Camera3Device::HalInterface::close() {
+ ATRACE_NAME("CameraHal::close()");
+ if (!valid()) return INVALID_OPERATION;
+ status_t res = OK;
+
+ if (mHal3Device != nullptr) {
+ mHal3Device->common.close(&mHal3Device->common);
+ } else {
+ mHidlSession->close();
+ }
+ return res;
+}
+
+status_t Camera3Device::HalInterface::pushInflightBufferLocked(
+ int32_t frameNumber, int32_t streamId, buffer_handle_t *buffer) {
+ uint64_t key = static_cast<uint64_t>(frameNumber) << 32 | static_cast<uint64_t>(streamId);
+ mInflightBufferMap[key] = buffer;
+ return OK;
+}
+
+status_t Camera3Device::HalInterface::popInflightBuffer(
+ int32_t frameNumber, int32_t streamId, /*out*/ buffer_handle_t **buffer) {
+ std::lock_guard<std::mutex> lock(mInflightLock);
+
+ uint64_t key = static_cast<uint64_t>(frameNumber) << 32 | static_cast<uint64_t>(streamId);
+ auto it = mInflightBufferMap.find(key);
+ if (it == mInflightBufferMap.end()) return NAME_NOT_FOUND;
+ *buffer = it->second;
+ mInflightBufferMap.erase(it);
+ return OK;
+}
+
+/**
* RequestThread inner class methods
*/
Camera3Device::RequestThread::RequestThread(wp<Camera3Device> parent,
sp<StatusTracker> statusTracker,
- camera3_device_t *hal3Device,
+ HalInterface* interface,
+ uint32_t deviceVersion,
bool aeLockAvailable) :
Thread(/*canCallJava*/false),
mParent(parent),
mStatusTracker(statusTracker),
- mHal3Device(hal3Device),
+ mInterface(interface),
+ mDeviceVersion(deviceVersion),
mListener(nullptr),
mId(getId(parent)),
mReconfigured(false),
@@ -2789,6 +3374,8 @@
mStatusId = statusTracker->addComponent();
}
+Camera3Device::RequestThread::~RequestThread() {}
+
void Camera3Device::RequestThread::setNotificationListener(
wp<NotificationListener> listener) {
Mutex::Autolock l(mRequestLock);
@@ -2843,10 +3430,11 @@
return OK;
}
-int Camera3Device::RequestThread::getId(const wp<Camera3Device> &device) {
+const String8& Camera3Device::RequestThread::getId(const wp<Camera3Device> &device) {
+ static String8 deadId("<DeadDevice>");
sp<Camera3Device> d = device.promote();
- if (d != NULL) return d->mId;
- return 0;
+ if (d != nullptr) return d->mId;
+ return deadId;
}
status_t Camera3Device::RequestThread::queueTriggerLocked(
@@ -2976,8 +3564,8 @@
ATRACE_CALL();
Mutex::Autolock l(mFlushLock);
- if (mHal3Device->common.version >= CAMERA_DEVICE_API_VERSION_3_1) {
- return mHal3Device->ops->flush(mHal3Device);
+ if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_1) {
+ return mInterface->flush();
}
return -ENOTSUP;
@@ -3025,7 +3613,7 @@
request->mAeTriggerCancelOverride.applyAeLock = false;
request->mAeTriggerCancelOverride.applyAePrecaptureTrigger = false;
- if (mHal3Device->common.version > CAMERA_DEVICE_API_VERSION_3_2) {
+ if (mDeviceVersion > CAMERA_DEVICE_API_VERSION_3_2) {
return;
}
@@ -3165,9 +3753,7 @@
for (auto& nextRequest : mNextRequests) {
// Submit request and block until ready for next one
ATRACE_ASYNC_BEGIN("frame capture", nextRequest.halRequest.frame_number);
- ATRACE_BEGIN("camera3->process_capture_request");
- res = mHal3Device->ops->process_capture_request(mHal3Device, &nextRequest.halRequest);
- ATRACE_END();
+ res = mInterface->processCaptureRequest(&nextRequest.halRequest);
if (res != OK) {
// Should only get a failure here for malformed requests or device-level
diff --git a/services/camera/libcameraservice/device3/Camera3Device.h b/services/camera/libcameraservice/device3/Camera3Device.h
index ac9dfc2..217c8b7 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.h
+++ b/services/camera/libcameraservice/device3/Camera3Device.h
@@ -17,6 +17,9 @@
#ifndef ANDROID_SERVERS_CAMERA3DEVICE_H
#define ANDROID_SERVERS_CAMERA3DEVICE_H
+#include <utility>
+#include <unordered_map>
+
#include <utils/Condition.h>
#include <utils/Errors.h>
#include <utils/List.h>
@@ -24,7 +27,12 @@
#include <utils/Thread.h>
#include <utils/KeyedVector.h>
#include <utils/Timers.h>
+
+#include <android/hardware/camera/device/3.2/ICameraDevice.h>
+#include <android/hardware/camera/device/3.2/ICameraDeviceSession.h>
+#include <android/hardware/camera/device/3.2/ICameraDeviceCallback.h>
#include <hardware/camera3.h>
+
#include <camera/CaptureResult.h>
#include "common/CameraDeviceBase.h"
@@ -55,17 +63,18 @@
class Camera3OutputStreamInterface;
class Camera3StreamInterface;
-}
+} // namespace camera3
/**
* CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher.
*/
class Camera3Device :
public CameraDeviceBase,
+ virtual public hardware::camera::device::V3_2::ICameraDeviceCallback,
private camera3_callback_ops {
public:
- explicit Camera3Device(int id);
+ explicit Camera3Device(const String8& id);
virtual ~Camera3Device();
@@ -73,91 +82,92 @@
* CameraDeviceBase interface
*/
- virtual int getId() const;
+ const String8& getId() const override;
// Transitions to idle state on success.
- virtual status_t initialize(CameraModule *module);
- virtual status_t disconnect();
- virtual status_t dump(int fd, const Vector<String16> &args);
- virtual const CameraMetadata& info() const;
+ status_t initialize(CameraModule *module) override;
+ status_t initialize(sp<CameraProviderManager> manager) override;
+ status_t disconnect() override;
+ status_t dump(int fd, const Vector<String16> &args) override;
+ const CameraMetadata& info() const override;
// Capture and setStreamingRequest will configure streams if currently in
// idle state
- virtual status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL);
- virtual status_t captureList(const List<const CameraMetadata> &requests,
- int64_t *lastFrameNumber = NULL);
- virtual status_t setStreamingRequest(const CameraMetadata &request,
- int64_t *lastFrameNumber = NULL);
- virtual status_t setStreamingRequestList(const List<const CameraMetadata> &requests,
- int64_t *lastFrameNumber = NULL);
- virtual status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL);
+ status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL) override;
+ status_t captureList(const List<const CameraMetadata> &requests,
+ int64_t *lastFrameNumber = NULL) override;
+ status_t setStreamingRequest(const CameraMetadata &request,
+ int64_t *lastFrameNumber = NULL) override;
+ status_t setStreamingRequestList(const List<const CameraMetadata> &requests,
+ int64_t *lastFrameNumber = NULL) override;
+ status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL) override;
- virtual status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout);
+ status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) override;
// Actual stream creation/deletion is delayed until first request is submitted
// If adding streams while actively capturing, will pause device before adding
// stream, reconfiguring device, and unpausing. If the client create a stream
// with nullptr consumer surface, the client must then call setConsumer()
// and finish the stream configuration before starting output streaming.
- virtual status_t createStream(sp<Surface> consumer,
+ status_t createStream(sp<Surface> consumer,
uint32_t width, uint32_t height, int format,
android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,
int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
- uint32_t consumerUsage = 0);
- virtual status_t createInputStream(
+ uint32_t consumerUsage = 0) override;
+ status_t createInputStream(
uint32_t width, uint32_t height, int format,
- int *id);
- virtual status_t createZslStream(
+ int *id) override;
+ status_t createZslStream(
uint32_t width, uint32_t height,
int depth,
/*out*/
int *id,
sp<camera3::Camera3ZslStream>* zslStream);
- virtual status_t createReprocessStreamFromStream(int outputId, int *id);
+ status_t createReprocessStreamFromStream(int outputId, int *id) override;
- virtual status_t getStreamInfo(int id,
+ status_t getStreamInfo(int id,
uint32_t *width, uint32_t *height,
- uint32_t *format, android_dataspace *dataSpace);
- virtual status_t setStreamTransform(int id, int transform);
+ uint32_t *format, android_dataspace *dataSpace) override;
+ status_t setStreamTransform(int id, int transform) override;
- virtual status_t deleteStream(int id);
- virtual status_t deleteReprocessStream(int id);
+ status_t deleteStream(int id) override;
+ status_t deleteReprocessStream(int id) override;
- virtual status_t configureStreams(bool isConstraiedHighSpeed = false);
- virtual status_t getInputBufferProducer(
- sp<IGraphicBufferProducer> *producer);
+ status_t configureStreams(bool isConstraiedHighSpeed = false) override;
+ status_t getInputBufferProducer(
+ sp<IGraphicBufferProducer> *producer) override;
- virtual status_t createDefaultRequest(int templateId, CameraMetadata *request);
+ status_t createDefaultRequest(int templateId, CameraMetadata *request) override;
// Transitions to the idle state on success
- virtual status_t waitUntilDrained();
+ status_t waitUntilDrained() override;
- virtual status_t setNotifyCallback(wp<NotificationListener> listener);
- virtual bool willNotify3A();
- virtual status_t waitForNextFrame(nsecs_t timeout);
- virtual status_t getNextResult(CaptureResult *frame);
+ status_t setNotifyCallback(wp<NotificationListener> listener) override;
+ bool willNotify3A() override;
+ status_t waitForNextFrame(nsecs_t timeout) override;
+ status_t getNextResult(CaptureResult *frame) override;
- virtual status_t triggerAutofocus(uint32_t id);
- virtual status_t triggerCancelAutofocus(uint32_t id);
- virtual status_t triggerPrecaptureMetering(uint32_t id);
+ status_t triggerAutofocus(uint32_t id) override;
+ status_t triggerCancelAutofocus(uint32_t id) override;
+ status_t triggerPrecaptureMetering(uint32_t id) override;
- virtual status_t pushReprocessBuffer(int reprocessStreamId,
- buffer_handle_t *buffer, wp<BufferReleasedListener> listener);
+ status_t pushReprocessBuffer(int reprocessStreamId,
+ buffer_handle_t *buffer, wp<BufferReleasedListener> listener) override;
- virtual status_t flush(int64_t *lastFrameNumber = NULL);
+ status_t flush(int64_t *lastFrameNumber = NULL) override;
- virtual status_t prepare(int streamId);
+ status_t prepare(int streamId) override;
- virtual status_t tearDown(int streamId);
+ status_t tearDown(int streamId) override;
- virtual status_t addBufferListenerForStream(int streamId,
- wp<camera3::Camera3StreamBufferListener> listener);
+ status_t addBufferListenerForStream(int streamId,
+ wp<camera3::Camera3StreamBufferListener> listener) override;
- virtual status_t prepare(int maxCount, int streamId);
+ status_t prepare(int maxCount, int streamId) override;
- virtual uint32_t getDeviceVersion();
+ uint32_t getDeviceVersion() override;
- virtual ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const;
+ ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const override;
ssize_t getPointCloudBufferSize() const;
ssize_t getRawOpaqueBufferSize(int32_t width, int32_t height) const;
@@ -168,7 +178,7 @@
* Set the deferred consumer surface to the output stream and finish the deferred
* consumer configuration.
*/
- virtual status_t setConsumerSurface(int streamId, sp<Surface> consumer);
+ status_t setConsumerSurface(int streamId, sp<Surface> consumer) override;
private:
static const size_t kDumpLockAttempts = 10;
@@ -198,14 +208,58 @@
Mutex mLock;
// Camera device ID
- const int mId;
+ const String8 mId;
// Flag indicating is the current active stream configuration is constrained high speed.
bool mIsConstrainedHighSpeedConfiguration;
/**** Scope for mLock ****/
- camera3_device_t *mHal3Device;
+ /**
+ * Adapter for legacy HAL / HIDL HAL interface calls; calls either into legacy HALv3 or the
+ * HIDL HALv3 interfaces.
+ */
+ class HalInterface {
+ public:
+ HalInterface(camera3_device_t *device);
+ HalInterface(sp<hardware::camera::device::V3_2::ICameraDeviceSession> &session);
+ HalInterface(const HalInterface &other);
+ HalInterface();
+
+ // Returns true if constructed with a valid device or session, and not yet cleared
+ bool valid();
+
+ // Reset this HalInterface object (does not call close())
+ void clear();
+
+ // Calls into the HAL interface
+
+ // Caller takes ownership of requestTemplate
+ status_t constructDefaultRequestSettings(camera3_request_template_t templateId,
+ /*out*/ camera_metadata_t **requestTemplate);
+ status_t configureStreams(/*inout*/ camera3_stream_configuration *config);
+ status_t processCaptureRequest(camera3_capture_request_t *request);
+ status_t flush();
+ status_t dump(int fd);
+ status_t close();
+
+ // Find a buffer_handle_t based on frame number and stream ID
+ status_t popInflightBuffer(int32_t frameNumber, int32_t streamId,
+ /*out*/ buffer_handle_t **buffer);
+
+ private:
+ camera3_device_t *mHal3Device;
+ sp<hardware::camera::device::V3_2::ICameraDeviceSession> mHidlSession;
+
+ std::mutex mInflightLock;
+
+ status_t pushInflightBufferLocked(int32_t frameNumber, int32_t streamId,
+ buffer_handle_t *buffer);
+ // Cache of buffer handles keyed off (frameNumber << 32 | streamId)
+ std::unordered_map<uint64_t, buffer_handle_t*> mInflightBufferMap;
+ };
+
+ std::unique_ptr<HalInterface> mInterface;
CameraMetadata mDeviceInfo;
@@ -313,10 +367,27 @@
status_t submitRequestsHelper(const List<const CameraMetadata> &requests, bool repeating,
int64_t *lastFrameNumber = NULL);
+
+ /**
+ * Implementation of android::hardware::camera::device::V3_2::ICameraDeviceCallback
+ */
+
+ hardware::Return<void> processCaptureResult(
+ const hardware::camera::device::V3_2::CaptureResult& result) override;
+ hardware::Return<void> notify(
+ const hardware::camera::device::V3_2::NotifyMsg& msg) override;
+
+ /**
+ * Common initialization code shared by both HAL paths
+ *
+ * Must be called with mLock and mInterfaceLock held.
+ */
+ status_t initializeCommonLocked();
+
/**
* Get the last request submitted to the hal by the request thread.
*
- * Takes mLock.
+ * Must be called with mLock held.
*/
virtual CameraMetadata getLatestRequestLocked();
@@ -434,6 +505,24 @@
*/
static android_dataspace mapToLegacyDataspace(android_dataspace dataSpace);
+ /**
+ * 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::ConsumerUsageFlags mapToConsumerUsage(uint32_t usage);
+ static hardware::camera::device::V3_2::StreamRotation mapToStreamRotation(
+ camera3_stream_rotation_t rotation);
+ static hardware::camera::device::V3_2::StreamConfigurationMode mapToStreamConfigurationMode(
+ camera3_stream_configuration_mode_t operationMode);
+ static camera3_buffer_status_t mapHidlBufferStatus(hardware::camera::device::V3_2::BufferStatus status);
+ static int mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat);
+ static uint32_t mapConsumerToFrameworkUsage(
+ hardware::camera::device::V3_2::ConsumerUsageFlags usage);
+ static uint32_t mapProducerToFrameworkUsage(
+ hardware::camera::device::V3_2::ProducerUsageFlags usage);
+
struct RequestTrigger {
// Metadata tag number, e.g. android.control.aePrecaptureTrigger
uint32_t metadataTag;
@@ -460,8 +549,10 @@
RequestThread(wp<Camera3Device> parent,
sp<camera3::StatusTracker> statusTracker,
- camera3_device_t *hal3Device,
+ HalInterface* interface,
+ uint32_t deviceVersion,
bool aeLockAvailable);
+ ~RequestThread();
void setNotificationListener(wp<NotificationListener> listener);
@@ -541,7 +632,7 @@
virtual bool threadLoop();
private:
- static int getId(const wp<Camera3Device> &device);
+ static const String8& getId(const wp<Camera3Device> &device);
status_t queueTriggerLocked(RequestTrigger trigger);
// Mix-in queued triggers into this request
@@ -602,11 +693,12 @@
wp<Camera3Device> mParent;
wp<camera3::StatusTracker> mStatusTracker;
- camera3_device_t *mHal3Device;
+ HalInterface* mInterface;
+ uint32_t mDeviceVersion;
wp<NotificationListener> mListener;
- const int mId; // The camera ID
+ const String8& mId; // The camera ID
int mStatusId; // The RequestThread's component ID for
// status tracking
diff --git a/services/camera/libcameraservice/device3/Camera3Stream.cpp b/services/camera/libcameraservice/device3/Camera3Stream.cpp
index 3ffd9d1..c3b7565 100644
--- a/services/camera/libcameraservice/device3/Camera3Stream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Stream.cpp
@@ -166,7 +166,7 @@
return (mState == STATE_IN_CONFIG) || (mState == STATE_IN_RECONFIG);
}
-status_t Camera3Stream::finishConfiguration(camera3_device *hal3Device) {
+status_t Camera3Stream::finishConfiguration() {
ATRACE_CALL();
Mutex::Autolock l(mLock);
switch (mState) {
@@ -216,14 +216,6 @@
return res;
}
- res = registerBuffersLocked(hal3Device);
- if (res != OK) {
- ALOGE("%s: Unable to register stream buffers with HAL: %s (%d)",
- __FUNCTION__, strerror(-res), res);
- mState = STATE_ERROR;
- return res;
- }
-
mState = STATE_CONFIGURED;
return res;
diff --git a/services/camera/libcameraservice/device3/Camera3Stream.h b/services/camera/libcameraservice/device3/Camera3Stream.h
index 1ff215d..471b393 100644
--- a/services/camera/libcameraservice/device3/Camera3Stream.h
+++ b/services/camera/libcameraservice/device3/Camera3Stream.h
@@ -144,6 +144,10 @@
int getFormat() const;
android_dataspace getDataSpace() const;
+ camera3_stream* asHalStream() override {
+ return this;
+ }
+
/**
* Start the stream configuration process. Returns a handle to the stream's
* information to be passed into the HAL device's configure_streams call.
@@ -165,11 +169,10 @@
bool isConfiguring() const;
/**
- * Completes the stream configuration process. During this call, the stream
- * may call the device's register_stream_buffers() method. The stream
- * information structure returned by startConfiguration() may no longer be
- * modified after this call, but can still be read until the destruction of
- * the stream.
+ * Completes the stream configuration process. The stream information
+ * structure returned by startConfiguration() may no longer be modified
+ * after this call, but can still be read until the destruction of the
+ * stream.
*
* Returns:
* OK on a successful configuration
@@ -178,7 +181,7 @@
* INVALID_OPERATION in case connecting to the consumer failed or consumer
* doesn't exist yet.
*/
- status_t finishConfiguration(camera3_device *hal3Device);
+ status_t finishConfiguration();
/**
* Cancels the stream configuration process. This returns the stream to the
diff --git a/services/camera/libcameraservice/device3/Camera3StreamInterface.h b/services/camera/libcameraservice/device3/Camera3StreamInterface.h
index 6cb7a54..ceea08a 100644
--- a/services/camera/libcameraservice/device3/Camera3StreamInterface.h
+++ b/services/camera/libcameraservice/device3/Camera3StreamInterface.h
@@ -72,6 +72,11 @@
virtual android_dataspace getDataSpace() const = 0;
/**
+ * Get a HAL3 handle for the stream, without starting stream configuration.
+ */
+ virtual camera3_stream* asHalStream() = 0;
+
+ /**
* Start the stream configuration process. Returns a handle to the stream's
* information to be passed into the HAL device's configure_streams call.
*
@@ -104,7 +109,7 @@
* NO_MEMORY in case of an error registering buffers
* INVALID_OPERATION in case connecting to the consumer failed
*/
- virtual status_t finishConfiguration(camera3_device *hal3Device) = 0;
+ virtual status_t finishConfiguration() = 0;
/**
* Cancels the stream configuration process. This returns the stream to the
diff --git a/services/camera/libcameraservice/tests/Android.mk b/services/camera/libcameraservice/tests/Android.mk
new file mode 100644
index 0000000..179643b
--- /dev/null
+++ b/services/camera/libcameraservice/tests/Android.mk
@@ -0,0 +1,38 @@
+# Copyright 2013 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.
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= $(call all-cpp-files-under, .)
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils \
+ libcameraservice \
+ libhidlbase \
+ liblog \
+ libutils \
+ android.hardware.camera.common@1.0 \
+ android.hardware.camera.provider@2.4 \
+ android.hardware.camera.device@1.0 \
+ android.hardware.camera.device@3.2
+
+LOCAL_C_INCLUDES += \
+
+LOCAL_CFLAGS += -Wall -Wextra -Werror
+
+LOCAL_MODULE:= cameraservice_test
+LOCAL_MODULE_TAGS := tests
+
+include $(BUILD_NATIVE_TEST)
diff --git a/services/camera/libcameraservice/tests/CameraProviderManagerTest.cpp b/services/camera/libcameraservice/tests/CameraProviderManagerTest.cpp
new file mode 100644
index 0000000..eb934ba
--- /dev/null
+++ b/services/camera/libcameraservice/tests/CameraProviderManagerTest.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_NDEBUG 0
+#define LOG_TAG "CameraProviderManagerTest"
+
+#include "../common/CameraProviderManager.h"
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <android/hidl/manager/1.0/IServiceNotification.h>
+
+#include <gtest/gtest.h>
+
+using namespace android;
+using namespace android::hardware::camera;
+using android::hardware::camera::common::V1_0::Status;
+
+/**
+ * Basic test implementation of a camera provider
+ */
+struct TestICameraProvider : virtual public provider::V2_4::ICameraProvider {
+ sp<provider::V2_4::ICameraProviderCallbacks> mCallbacks;
+
+ std::vector<hardware::hidl_string> mDeviceNames;
+
+ TestICameraProvider() {
+ mDeviceNames.push_back("device@3.2/test/0");
+ mDeviceNames.push_back("device@1.0/test/0");
+ mDeviceNames.push_back("device@3.2/test/1");
+ }
+
+ virtual hardware::Return<Status> setCallbacks(
+ const sp<provider::V2_4::ICameraProviderCallbacks>& callbacks) override {
+ mCallbacks = callbacks;
+ return hardware::Return<Status>(Status::OK);
+ }
+
+ using getVendorTags_cb = std::function<void(Status status,
+ const hardware::hidl_vec<common::V1_0::VendorTagSection>& sections)>;
+ virtual hardware::Return<void> getVendorTags(getVendorTags_cb _hidl_cb) override {
+ hardware::hidl_vec<common::V1_0::VendorTagSection> sections;
+ _hidl_cb(Status::OK, sections);
+ return hardware::Void();
+ }
+
+ using getCameraIdList_cb = std::function<void(Status status,
+ const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames)>;
+ virtual hardware::Return<void> getCameraIdList(getCameraIdList_cb _hidl_cb) override {
+ _hidl_cb(Status::OK, mDeviceNames);
+ return hardware::Void();
+ }
+
+ using getCameraDeviceInterface_V1_x_cb = std::function<void(Status status,
+ const sp<device::V1_0::ICameraDevice>& device)>;
+ virtual hardware::Return<void> getCameraDeviceInterface_V1_x(
+ const hardware::hidl_string& cameraDeviceName,
+ getCameraDeviceInterface_V1_x_cb _hidl_cb) override {
+ (void) cameraDeviceName;
+ _hidl_cb(Status::OK, nullptr);
+ return hardware::Void();
+ }
+
+ using getCameraDeviceInterface_V3_x_cb = std::function<void(Status status,
+ const sp<device::V3_2::ICameraDevice>& device)>;
+ virtual hardware::Return<void> getCameraDeviceInterface_V3_x(
+ const hardware::hidl_string& cameraDeviceName,
+ getCameraDeviceInterface_V3_x_cb _hidl_cb) override {
+ (void) cameraDeviceName;
+ _hidl_cb(Status::OK, nullptr);
+ return hardware::Void();
+ }
+
+};
+
+/**
+ * Simple test version of the interaction proxy, to use to inject onRegistered calls to the
+ * CameraProviderManager
+ */
+struct TestInteractionProxy : public CameraProviderManager::ServiceInteractionProxy {
+ sp<hidl::manager::V1_0::IServiceNotification> mManagerNotificationInterface;
+ const sp<TestICameraProvider> mTestCameraProvider;
+
+ TestInteractionProxy() :
+ mTestCameraProvider(new TestICameraProvider()) {
+
+ }
+ std::string mLastRequestedServiceName;
+
+ virtual ~TestInteractionProxy() {}
+
+ virtual bool registerForNotifications(
+ const std::string &serviceName,
+ const sp<hidl::manager::V1_0::IServiceNotification> ¬ification) override {
+ (void) serviceName;
+ mManagerNotificationInterface = notification;
+ return true;
+ }
+
+ virtual sp<hardware::camera::provider::V2_4::ICameraProvider> getService(
+ const std::string &serviceName) override {
+ mLastRequestedServiceName = serviceName;
+ return mTestCameraProvider;
+ }
+
+};
+
+TEST(CameraProviderManagerTest, InitializeTest) {
+
+ status_t res;
+ sp<CameraProviderManager> providerManager = new CameraProviderManager();
+ TestInteractionProxy serviceProxy{};
+
+ res = providerManager->initialize(&serviceProxy);
+ ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
+
+ hardware::hidl_string legacyInstanceName = "legacy/0";
+ ASSERT_EQ(serviceProxy.mLastRequestedServiceName, legacyInstanceName) <<
+ "Legacy instance not requested from service manager";
+
+ hardware::hidl_string testProviderFqInterfaceName =
+ "android.hardware.camera.provider@2.4::ICameraProvider";
+ hardware::hidl_string testProviderInstanceName = "test/0";
+ serviceProxy.mManagerNotificationInterface->onRegistration(
+ testProviderFqInterfaceName,
+ testProviderInstanceName, false);
+
+ ASSERT_EQ(serviceProxy.mLastRequestedServiceName, testProviderInstanceName) <<
+ "Incorrect instance requested from service manager";
+}
diff --git a/services/medialog/Android.mk b/services/medialog/Android.mk
index a1da63d..423b186 100644
--- a/services/medialog/Android.mk
+++ b/services/medialog/Android.mk
@@ -4,7 +4,7 @@
LOCAL_SRC_FILES := MediaLogService.cpp IMediaLogService.cpp
-LOCAL_SHARED_LIBRARIES := libbinder libutils liblog libnbaio
+LOCAL_SHARED_LIBRARIES := libbinder libutils liblog libnbaio libaudioutils
LOCAL_MULTILIB := $(AUDIOSERVER_MULTILIB)
diff --git a/services/medialog/MediaLogService.cpp b/services/medialog/MediaLogService.cpp
index f85aa13..ab2f925 100644
--- a/services/medialog/MediaLogService.cpp
+++ b/services/medialog/MediaLogService.cpp
@@ -35,7 +35,7 @@
shared->size() < NBLog::Timeline::sharedSize(size)) {
return;
}
- sp<NBLog::Reader> reader(new NBLog::Reader(size, shared));
+ sp<NBLog::Reader> reader(new NBLog::Reader(shared, size));
NamedReader namedReader(reader, name);
Mutex::Autolock _l(mLock);
mNamedReaders.add(namedReader);
diff --git a/services/radio/HidlUtils.cpp b/services/radio/HidlUtils.cpp
index bfced7a..3b33386 100644
--- a/services/radio/HidlUtils.cpp
+++ b/services/radio/HidlUtils.cpp
@@ -122,8 +122,7 @@
//static
void HidlUtils::convertProgramInfoFromHal(radio_program_info_t *info,
- const ProgramInfo *halInfo,
- bool withMetadata)
+ const ProgramInfo *halInfo)
{
info->channel = halInfo->channel;
info->sub_channel = halInfo->subChannel;
@@ -131,10 +130,8 @@
info->stereo = halInfo->stereo;
info->digital = halInfo->digital;
info->signal_strength = halInfo->signalStrength;
- if (withMetadata && halInfo->metadata.size() != 0) {
- convertMetaDataFromHal(&info->metadata, halInfo->metadata,
- halInfo->channel, halInfo->subChannel);
- }
+ convertMetaDataFromHal(&info->metadata, halInfo->metadata,
+ halInfo->channel, halInfo->subChannel);
}
//static
diff --git a/services/radio/HidlUtils.h b/services/radio/HidlUtils.h
index 091abb7..c771060 100644
--- a/services/radio/HidlUtils.h
+++ b/services/radio/HidlUtils.h
@@ -38,8 +38,7 @@
static void convertBandConfigToHal(BandConfig *halConfig,
const radio_hal_band_config_t *config);
static void convertProgramInfoFromHal(radio_program_info_t *info,
- const ProgramInfo *halInfo,
- bool withMetadata);
+ const ProgramInfo *halInfo);
static void convertMetaDataFromHal(radio_metadata_t **metadata,
const hidl_vec<MetaData>& halMetadata,
uint32_t channel,
diff --git a/services/radio/RadioHalHidl.cpp b/services/radio/RadioHalHidl.cpp
index c7a899a..34a6db7 100644
--- a/services/radio/RadioHalHidl.cpp
+++ b/services/radio/RadioHalHidl.cpp
@@ -39,11 +39,6 @@
return new RadioHalHidl(classId);
}
-void RadioHalHidl::crashIfHalIsDead(const Status& status) {
- LOG_ALWAYS_FATAL_IF(
- status.transactionError() == DEAD_OBJECT, "HAL server crashed, need to restart");
-}
-
int RadioHalHidl::getProperties(radio_hal_properties_t *properties)
{
ALOGV("%s IN", __FUNCTION__);
@@ -52,7 +47,7 @@
return -ENODEV;
}
Properties halProperties;
- Result halResult;
+ Result halResult = Result::NOT_INITIALIZED;
Return<void> hidlReturn =
module->getProperties([&](Result result, const Properties& properties) {
halResult = result;
@@ -61,7 +56,6 @@
}
});
- crashIfHalIsDead(hidlReturn.getStatus());
if (halResult == Result::OK) {
HidlUtils::convertPropertiesFromHal(properties, &halProperties);
}
@@ -80,7 +74,7 @@
sp<Tuner> tunerImpl = new Tuner(callback, this);
BandConfig halConfig;
- Result halResult;
+ Result halResult = Result::NOT_INITIALIZED;
sp<ITuner> halTuner;
HidlUtils::convertBandConfigToHal(&halConfig, config);
@@ -93,7 +87,6 @@
}
});
- crashIfHalIsDead(hidlReturn.getStatus());
if (halResult == Result::OK) {
tunerImpl->setHalTuner(halTuner);
tuner = tunerImpl;
@@ -154,7 +147,6 @@
HidlUtils::convertBandConfigToHal(&halConfig, config);
Return<Result> hidlResult = mHalTuner->setConfiguration(halConfig);
- checkHidlStatus(hidlResult.getStatus());
return HidlUtils::convertHalResult(hidlResult);
}
@@ -173,8 +165,7 @@
halConfig = config;
}
});
- status_t status = checkHidlStatus(hidlReturn.getStatus());
- if (status == NO_ERROR && halResult == Result::OK) {
+ if (hidlReturn.isOk() && halResult == Result::OK) {
HidlUtils::convertBandConfigFromHal(config, &halConfig);
}
return HidlUtils::convertHalResult(halResult);
@@ -188,7 +179,6 @@
}
Return<Result> hidlResult =
mHalTuner->scan(static_cast<Direction>(direction), skip_sub_channel);
- checkHidlStatus(hidlResult.getStatus());
return HidlUtils::convertHalResult(hidlResult);
}
@@ -200,7 +190,6 @@
}
Return<Result> hidlResult =
mHalTuner->step(static_cast<Direction>(direction), skip_sub_channel);
- checkHidlStatus(hidlResult.getStatus());
return HidlUtils::convertHalResult(hidlResult);
}
@@ -212,7 +201,6 @@
}
Return<Result> hidlResult =
mHalTuner->tune(channel, sub_channel);
- checkHidlStatus(hidlResult.getStatus());
return HidlUtils::convertHalResult(hidlResult);
}
@@ -223,7 +211,6 @@
return -ENODEV;
}
Return<Result> hidlResult = mHalTuner->cancel();
- checkHidlStatus(hidlResult.getStatus());
return HidlUtils::convertHalResult(hidlResult);
}
@@ -233,19 +220,20 @@
if (mHalTuner == 0) {
return -ENODEV;
}
+ if (info == nullptr || info->metadata == nullptr) {
+ return BAD_VALUE;
+ }
ProgramInfo halInfo;
Result halResult;
- bool withMetaData = (info->metadata != NULL);
Return<void> hidlReturn = mHalTuner->getProgramInformation(
- withMetaData, [&](Result result, const ProgramInfo& info) {
- halResult = result;
- if (result == Result::OK) {
- halInfo = info;
- }
- });
- status_t status = checkHidlStatus(hidlReturn.getStatus());
- if (status == NO_ERROR && halResult == Result::OK) {
- HidlUtils::convertProgramInfoFromHal(info, &halInfo, withMetaData);
+ [&](Result result, const ProgramInfo& info) {
+ halResult = result;
+ if (result == Result::OK) {
+ halInfo = info;
+ }
+ });
+ if (hidlReturn.isOk() && halResult == Result::OK) {
+ HidlUtils::convertProgramInfoFromHal(info, &halInfo);
}
return HidlUtils::convertHalResult(halResult);
}
@@ -276,11 +264,9 @@
memset(&event, 0, sizeof(radio_hal_event_t));
event.type = RADIO_EVENT_TUNED;
event.status = HidlUtils::convertHalResult(result);
- HidlUtils::convertProgramInfoFromHal(&event.info, &info, true);
+ HidlUtils::convertProgramInfoFromHal(&event.info, &info);
onCallback(&event);
- if (event.info.metadata != NULL) {
- radio_metadata_deallocate(event.info.metadata);
- }
+ radio_metadata_deallocate(event.info.metadata);
return Return<void>();
}
@@ -290,7 +276,7 @@
radio_hal_event_t event;
memset(&event, 0, sizeof(radio_hal_event_t));
event.type = RADIO_EVENT_AF_SWITCH;
- HidlUtils::convertProgramInfoFromHal(&event.info, &info, true);
+ HidlUtils::convertProgramInfoFromHal(&event.info, &info);
onCallback(&event);
if (event.info.metadata != NULL) {
radio_metadata_deallocate(event.info.metadata);
@@ -368,16 +354,6 @@
mHalTuner.clear();
}
-status_t RadioHalHidl::Tuner::checkHidlStatus(Status hidlStatus)
-{
- status_t status = hidlStatus.transactionError();
- if (status == DEAD_OBJECT) {
- handleHwFailure();
- }
- RadioHalHidl::crashIfHalIsDead(hidlStatus);
- return status;
-}
-
void RadioHalHidl::Tuner::onCallback(radio_hal_event_t *halEvent)
{
if (mCallback != 0) {
diff --git a/services/radio/RadioHalHidl.h b/services/radio/RadioHalHidl.h
index 1657a40..b60a95e 100644
--- a/services/radio/RadioHalHidl.h
+++ b/services/radio/RadioHalHidl.h
@@ -45,8 +45,6 @@
public:
RadioHalHidl(radio_class_t classId);
- static void crashIfHalIsDead(const Status& status);
-
// RadioInterface
virtual int getProperties(radio_hal_properties_t *properties);
virtual int openTuner(const radio_hal_band_config_t *config,
@@ -88,7 +86,6 @@
void onCallback(radio_hal_event_t *halEvent);
void handleHwFailure();
- status_t checkHidlStatus(Status hidlStatus);
sp<ITuner> mHalTuner;
sp<TunerCallbackInterface> mCallback;
diff --git a/services/soundtrigger/SoundTriggerHalHidl.cpp b/services/soundtrigger/SoundTriggerHalHidl.cpp
index c027799..eb9d38d 100644
--- a/services/soundtrigger/SoundTriggerHalHidl.cpp
+++ b/services/soundtrigger/SoundTriggerHalHidl.cpp
@@ -53,13 +53,13 @@
});
}
- if (hidlReturn.getStatus().isOk()) {
+ if (hidlReturn.isOk()) {
if (ret == 0) {
convertPropertiesFromHal(properties, &halProperties);
}
} else {
- ret = (int)hidlReturn.getStatus().transactionError();
- crashIfHalIsDead(ret);
+ ALOGE("getProperties error %s", hidlReturn.description().c_str());
+ return UNKNOWN_ERROR;
}
ALOGI("getProperties ret %d", ret);
return ret;
@@ -123,7 +123,7 @@
delete halSoundModel;
- if (hidlReturn.getStatus().isOk()) {
+ if (hidlReturn.isOk()) {
if (ret == 0) {
AutoMutex lock(mLock);
*handle = (sound_model_handle_t)modelId;
@@ -131,12 +131,10 @@
mSoundModels.add(*handle, model);
}
} else {
- ret = (int)hidlReturn.getStatus().transactionError();
- ALOGE("loadSoundModel error %d", ret);
- crashIfHalIsDead(ret);
+ ALOGE("loadSoundModel error %s", hidlReturn.description().c_str());
+ return UNKNOWN_ERROR;
}
-
return ret;
}
@@ -158,13 +156,13 @@
AutoMutex lock(mHalLock);
hidlReturn = soundtrigger->unloadSoundModel(model->mHalHandle);
}
- int ret = (int)hidlReturn.getStatus().transactionError();
- ALOGE_IF(ret != 0, "unloadSoundModel error %d", ret);
- crashIfHalIsDead(ret);
- if (ret == 0) {
- ret = hidlReturn;
+
+ if (!hidlReturn.isOk()) {
+ ALOGE("unloadSoundModel error %s", hidlReturn.description().c_str());
+ return UNKNOWN_ERROR;
}
- return ret;
+
+ return hidlReturn;
}
int SoundTriggerHalHidl::startRecognition(sound_model_handle_t handle,
@@ -197,13 +195,11 @@
delete halConfig;
- int ret = (int)hidlReturn.getStatus().transactionError();
- ALOGE_IF(ret != 0, "startRecognition error %d", ret);
- crashIfHalIsDead(ret);
- if (ret == 0) {
- ret = hidlReturn;
+ if (!hidlReturn.isOk()) {
+ ALOGE("startRecognition error %s", hidlReturn.description().c_str());
+ return UNKNOWN_ERROR;
}
- return ret;
+ return hidlReturn;
}
int SoundTriggerHalHidl::stopRecognition(sound_model_handle_t handle)
@@ -225,13 +221,11 @@
hidlReturn = soundtrigger->stopRecognition(model->mHalHandle);
}
- int ret = (int)hidlReturn.getStatus().transactionError();
- ALOGE_IF(ret != 0, "stopRecognition error %d", ret);
- crashIfHalIsDead(ret);
- if (ret == 0) {
- ret = hidlReturn;
+ if (!hidlReturn.isOk()) {
+ ALOGE("stopRecognition error %s", hidlReturn.description().c_str());
+ return UNKNOWN_ERROR;
}
- return ret;
+ return hidlReturn;
}
int SoundTriggerHalHidl::stopAllRecognitions()
@@ -247,13 +241,11 @@
hidlReturn = soundtrigger->stopAllRecognitions();
}
- int ret = (int)hidlReturn.getStatus().transactionError();
- ALOGE_IF(ret != 0, "stopAllRecognitions error %d", ret);
- crashIfHalIsDead(ret);
- if (ret == 0) {
- ret = hidlReturn;
+ if (!hidlReturn.isOk()) {
+ ALOGE("stopAllRecognitions error %s", hidlReturn.description().c_str());
+ return UNKNOWN_ERROR;
}
- return ret;
+ return hidlReturn;
}
SoundTriggerHalHidl::SoundTriggerHalHidl(const char *moduleName)
@@ -279,11 +271,6 @@
return mISoundTrigger;
}
-void SoundTriggerHalHidl::crashIfHalIsDead(int ret)
-{
- LOG_ALWAYS_FATAL_IF(ret == -EPIPE, "HAL server crashed, need to restart");
-}
-
sp<SoundTriggerHalHidl::SoundModel> SoundTriggerHalHidl::getModel(sound_model_handle_t handle)
{
AutoMutex lock(mLock);
diff --git a/services/soundtrigger/SoundTriggerHalHidl.h b/services/soundtrigger/SoundTriggerHalHidl.h
index b235e1c..f084b2b 100644
--- a/services/soundtrigger/SoundTriggerHalHidl.h
+++ b/services/soundtrigger/SoundTriggerHalHidl.h
@@ -143,7 +143,6 @@
uint32_t nextUniqueId();
sp<ISoundTriggerHw> getService();
- void crashIfHalIsDead(int ret);
sp<SoundModel> getModel(sound_model_handle_t handle);
sp<SoundModel> removeModel(sound_model_handle_t handle);