Merge "MediaCas: fixes for playback tests" into oc-dev
diff --git a/camera/Camera.cpp b/camera/Camera.cpp
index bf9904c..c6c35ef 100644
--- a/camera/Camera.cpp
+++ b/camera/Camera.cpp
@@ -240,6 +240,14 @@
c->releaseRecordingFrameHandle(handle);
}
+void Camera::releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*> handles) {
+ ALOGV("releaseRecordingFrameHandleBatch");
+ sp <::android::hardware::ICamera> c = mCamera;
+ if (c == 0) return;
+ c->releaseRecordingFrameHandleBatch(handles);
+}
+
// get preview state
bool Camera::previewEnabled()
{
@@ -418,6 +426,37 @@
}
}
+void Camera::recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles)
+{
+ // If recording proxy listener is registered, forward the frame and return.
+ // The other listener (mListener) is ignored because the receiver needs to
+ // call releaseRecordingFrameHandle.
+ sp<ICameraRecordingProxyListener> proxylistener;
+ {
+ Mutex::Autolock _l(mLock);
+ proxylistener = mRecordingProxyListener;
+ }
+ if (proxylistener != NULL) {
+ proxylistener->recordingFrameHandleCallbackTimestampBatch(timestamps, handles);
+ return;
+ }
+
+ sp<CameraListener> listener;
+ {
+ Mutex::Autolock _l(mLock);
+ listener = mListener;
+ }
+
+ if (listener != NULL) {
+ listener->postRecordingFrameHandleTimestampBatch(timestamps, handles);
+ } else {
+ ALOGW("No listener was set. Drop a batch of recording frames.");
+ releaseRecordingFrameHandleBatch(handles);
+ }
+}
+
sp<ICameraRecordingProxy> Camera::getRecordingProxy() {
ALOGV("getProxy");
return new RecordingProxy(this);
@@ -448,6 +487,12 @@
mCamera->releaseRecordingFrameHandle(handle);
}
+void Camera::RecordingProxy::releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*>& handles) {
+ ALOGV("RecordingProxy::releaseRecordingFrameHandleBatch");
+ mCamera->releaseRecordingFrameHandleBatch(handles);
+}
+
Camera::RecordingProxy::RecordingProxy(const sp<Camera>& camera)
{
mCamera = camera;
diff --git a/camera/CameraMetadata.cpp b/camera/CameraMetadata.cpp
index 373b94e..e143e05 100644
--- a/camera/CameraMetadata.cpp
+++ b/camera/CameraMetadata.cpp
@@ -170,7 +170,7 @@
}
status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) {
- int tagType = get_camera_metadata_tag_type(tag);
+ int tagType = get_local_camera_metadata_tag_type(tag, mBuffer);
if ( CC_UNLIKELY(tagType == -1)) {
ALOGE("Update metadata entry: Unknown tag %d", tag);
return INVALID_OPERATION;
@@ -178,7 +178,7 @@
if ( CC_UNLIKELY(tagType != expectedType) ) {
ALOGE("Mismatched tag type when updating entry %s (%d) of type %s; "
"got type %s data instead ",
- get_camera_metadata_tag_name(tag), tag,
+ get_local_camera_metadata_tag_name(tag, mBuffer), tag,
camera_metadata_type_names[tagType],
camera_metadata_type_names[expectedType]);
return INVALID_OPERATION;
@@ -297,7 +297,7 @@
ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
return INVALID_OPERATION;
}
- int type = get_camera_metadata_tag_type(tag);
+ int type = get_local_camera_metadata_tag_type(tag, mBuffer);
if (type == -1) {
ALOGE("%s: Tag %d not found", __FUNCTION__, tag);
return BAD_VALUE;
@@ -332,8 +332,9 @@
if (res != OK) {
ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)",
- __FUNCTION__, get_camera_metadata_section_name(tag),
- get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
+ __FUNCTION__, get_local_camera_metadata_section_name(tag, mBuffer),
+ get_local_camera_metadata_tag_name(tag, mBuffer), tag,
+ strerror(-res), res);
}
IF_ALOGV() {
@@ -392,16 +393,18 @@
} else if (res != OK) {
ALOGE("%s: Error looking for entry %s.%s (%x): %s %d",
__FUNCTION__,
- get_camera_metadata_section_name(tag),
- get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
+ get_local_camera_metadata_section_name(tag, mBuffer),
+ get_local_camera_metadata_tag_name(tag, mBuffer),
+ tag, strerror(-res), res);
return res;
}
res = delete_camera_metadata_entry(mBuffer, entry.index);
if (res != OK) {
ALOGE("%s: Error deleting entry %s.%s (%x): %s %d",
__FUNCTION__,
- get_camera_metadata_section_name(tag),
- get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
+ get_local_camera_metadata_section_name(tag, mBuffer),
+ get_local_camera_metadata_tag_name(tag, mBuffer),
+ tag, strerror(-res), res);
}
return res;
}
diff --git a/camera/ICamera.cpp b/camera/ICamera.cpp
index 2bf956d..f0945c7 100644
--- a/camera/ICamera.cpp
+++ b/camera/ICamera.cpp
@@ -55,6 +55,7 @@
SET_VIDEO_BUFFER_MODE,
SET_VIDEO_BUFFER_TARGET,
RELEASE_RECORDING_FRAME_HANDLE,
+ RELEASE_RECORDING_FRAME_HANDLE_BATCH,
};
class BpCamera: public BpInterface<ICamera>
@@ -172,6 +173,24 @@
native_handle_delete(handle);
}
+ void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {
+ ALOGV("releaseRecordingFrameHandleBatch");
+ Parcel data, reply;
+ data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
+ uint32_t n = handles.size();
+ data.writeUint32(n);
+ for (auto& handle : handles) {
+ data.writeNativeHandle(handle);
+ }
+ remote()->transact(RELEASE_RECORDING_FRAME_HANDLE_BATCH, data, &reply);
+
+ // Close the native handle because camera received a dup copy.
+ for (auto& handle : handles) {
+ native_handle_close(handle);
+ native_handle_delete(handle);
+ }
+ }
+
status_t setVideoBufferMode(int32_t videoBufferMode)
{
ALOGV("setVideoBufferMode: %d", videoBufferMode);
@@ -378,6 +397,19 @@
releaseRecordingFrameHandle(data.readNativeHandle());
return NO_ERROR;
} break;
+ case RELEASE_RECORDING_FRAME_HANDLE_BATCH: {
+ ALOGV("RELEASE_RECORDING_FRAME_HANDLE_BATCH");
+ CHECK_INTERFACE(ICamera, data, reply);
+ // releaseRecordingFrameHandle will be responsble to close the native handle.
+ uint32_t n = data.readUint32();
+ std::vector<native_handle_t*> handles;
+ handles.reserve(n);
+ for (uint32_t i = 0; i < n; i++) {
+ handles.push_back(data.readNativeHandle());
+ }
+ releaseRecordingFrameHandleBatch(handles);
+ return NO_ERROR;
+ } break;
case SET_VIDEO_BUFFER_MODE: {
ALOGV("SET_VIDEO_BUFFER_MODE");
CHECK_INTERFACE(ICamera, data, reply);
diff --git a/camera/ICameraClient.cpp b/camera/ICameraClient.cpp
index 1b6fac4..7e6297c 100644
--- a/camera/ICameraClient.cpp
+++ b/camera/ICameraClient.cpp
@@ -32,6 +32,7 @@
DATA_CALLBACK,
DATA_CALLBACK_TIMESTAMP,
RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP,
+ RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH,
};
class BpCameraClient: public BpInterface<ICameraClient>
@@ -91,6 +92,29 @@
remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP, data, &reply,
IBinder::FLAG_ONEWAY);
}
+
+ void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles) {
+ ALOGV("recordingFrameHandleCallbackTimestampBatch");
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
+ uint32_t n = timestamps.size();
+ if (n != handles.size()) {
+ ALOGE("%s: size of timestamps(%zu) and handles(%zu) mismatch!",
+ __FUNCTION__, timestamps.size(), handles.size());
+ return;
+ }
+ data.writeUint32(n);
+ for (auto ts : timestamps) {
+ data.writeInt64(ts);
+ }
+ for (auto& handle : handles) {
+ data.writeNativeHandle(handle);
+ }
+ remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH, data, &reply,
+ IBinder::FLAG_ONEWAY);
+ }
};
IMPLEMENT_META_INTERFACE(CameraClient, "android.hardware.ICameraClient");
@@ -154,6 +178,41 @@
recordingFrameHandleCallbackTimestamp(timestamp, handle);
return NO_ERROR;
} break;
+ case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH: {
+ ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH");
+ CHECK_INTERFACE(ICameraClient, data, reply);
+ uint32_t n = 0;
+ status_t res = data.readUint32(&n);
+ if (res != OK) {
+ ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);
+ return BAD_VALUE;
+ }
+ std::vector<nsecs_t> timestamps;
+ std::vector<native_handle_t*> handles;
+ timestamps.reserve(n);
+ handles.reserve(n);
+ for (uint32_t i = 0; i < n; i++) {
+ res = data.readInt64(×tamps[i]);
+ if (res != OK) {
+ ALOGE("%s: Failed to read timestamp[%d]: %s (%d)",
+ __FUNCTION__, i, strerror(-res), res);
+ return BAD_VALUE;
+ }
+ }
+ for (uint32_t i = 0; i < n; i++) {
+ native_handle_t* handle = data.readNativeHandle();
+ if (handle == nullptr) {
+ ALOGE("%s: Received a null native handle at handles[%d]",
+ __FUNCTION__, i);
+ return BAD_VALUE;
+ }
+ handles.push_back(handle);
+ }
+
+ // The native handle will be freed in BpCamera::releaseRecordingFrameHandleBatch.
+ recordingFrameHandleCallbackTimestampBatch(timestamps, handles);
+ return NO_ERROR;
+ } break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/camera/ICameraRecordingProxy.cpp b/camera/ICameraRecordingProxy.cpp
index c9f8b5c..bd6af75 100644
--- a/camera/ICameraRecordingProxy.cpp
+++ b/camera/ICameraRecordingProxy.cpp
@@ -32,6 +32,7 @@
STOP_RECORDING,
RELEASE_RECORDING_FRAME,
RELEASE_RECORDING_FRAME_HANDLE,
+ RELEASE_RECORDING_FRAME_HANDLE_BATCH,
};
@@ -82,6 +83,24 @@
native_handle_close(handle);
native_handle_delete(handle);
}
+
+ void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {
+ ALOGV("releaseRecordingFrameHandleBatch");
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());
+ uint32_t n = handles.size();
+ data.writeUint32(n);
+ for (auto& handle : handles) {
+ data.writeNativeHandle(handle);
+ }
+ remote()->transact(RELEASE_RECORDING_FRAME_HANDLE_BATCH, data, &reply);
+
+ // Close the native handle because camera received a dup copy.
+ for (auto& handle : handles) {
+ native_handle_close(handle);
+ native_handle_delete(handle);
+ }
+ }
};
IMPLEMENT_META_INTERFACE(CameraRecordingProxy, "android.hardware.ICameraRecordingProxy");
@@ -121,6 +140,31 @@
releaseRecordingFrameHandle(data.readNativeHandle());
return NO_ERROR;
} break;
+ case RELEASE_RECORDING_FRAME_HANDLE_BATCH: {
+ ALOGV("RELEASE_RECORDING_FRAME_HANDLE_BATCH");
+ CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
+ uint32_t n = 0;
+ status_t res = data.readUint32(&n);
+ if (res != OK) {
+ ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);
+ return BAD_VALUE;
+ }
+ std::vector<native_handle_t*> handles;
+ handles.reserve(n);
+ for (uint32_t i = 0; i < n; i++) {
+ native_handle_t* handle = data.readNativeHandle();
+ if (handle == nullptr) {
+ ALOGE("%s: Received a null native handle at handles[%d]",
+ __FUNCTION__, i);
+ return BAD_VALUE;
+ }
+ handles.push_back(handle);
+ }
+
+ // releaseRecordingFrameHandleBatch will be responsble to close the native handle.
+ releaseRecordingFrameHandleBatch(handles);
+ return NO_ERROR;
+ } break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/camera/ICameraRecordingProxyListener.cpp b/camera/ICameraRecordingProxyListener.cpp
index 8529d3e..c954241 100644
--- a/camera/ICameraRecordingProxyListener.cpp
+++ b/camera/ICameraRecordingProxyListener.cpp
@@ -28,6 +28,7 @@
enum {
DATA_CALLBACK_TIMESTAMP = IBinder::FIRST_CALL_TRANSACTION,
RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP,
+ RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH
};
class BpCameraRecordingProxyListener: public BpInterface<ICameraRecordingProxyListener>
@@ -62,6 +63,36 @@
native_handle_close(handle);
native_handle_delete(handle);
}
+
+ void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles) {
+ ALOGV("recordingFrameHandleCallbackTimestampBatch");
+ Parcel data, reply;
+ data.writeInterfaceToken(ICameraRecordingProxyListener::getInterfaceDescriptor());
+
+ uint32_t n = timestamps.size();
+ if (n != handles.size()) {
+ ALOGE("%s: size of timestamps(%zu) and handles(%zu) mismatch!",
+ __FUNCTION__, timestamps.size(), handles.size());
+ return;
+ }
+ data.writeUint32(n);
+ for (auto ts : timestamps) {
+ data.writeInt64(ts);
+ }
+ for (auto& handle : handles) {
+ data.writeNativeHandle(handle);
+ }
+ remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH, data, &reply,
+ IBinder::FLAG_ONEWAY);
+
+ // The native handle is dupped in ICameraClient so we need to free it here.
+ for (auto& handle : handles) {
+ native_handle_close(handle);
+ native_handle_delete(handle);
+ }
+ }
};
IMPLEMENT_META_INTERFACE(CameraRecordingProxyListener, "android.hardware.ICameraRecordingProxyListener");
@@ -101,6 +132,41 @@
recordingFrameHandleCallbackTimestamp(timestamp, handle);
return NO_ERROR;
} break;
+ case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH: {
+ ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH");
+ CHECK_INTERFACE(ICameraRecordingProxyListener, data, reply);
+ uint32_t n = 0;
+ status_t res = data.readUint32(&n);
+ if (res != OK) {
+ ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);
+ return BAD_VALUE;
+ }
+ std::vector<nsecs_t> timestamps;
+ std::vector<native_handle_t*> handles;
+ timestamps.reserve(n);
+ handles.reserve(n);
+ for (uint32_t i = 0; i < n; i++) {
+ res = data.readInt64(×tamps[i]);
+ if (res != OK) {
+ ALOGE("%s: Failed to read timestamp[%d]: %s (%d)",
+ __FUNCTION__, i, strerror(-res), res);
+ return BAD_VALUE;
+ }
+ }
+ for (uint32_t i = 0; i < n; i++) {
+ native_handle_t* handle = data.readNativeHandle();
+ if (handle == nullptr) {
+ ALOGE("%s: Received a null native handle at handles[%d]",
+ __FUNCTION__, i);
+ return BAD_VALUE;
+ }
+ handles.push_back(handle);
+ }
+ // The native handle will be freed in
+ // BpCameraRecordingProxy::releaseRecordingFrameHandleBatch.
+ recordingFrameHandleCallbackTimestampBatch(timestamps, handles);
+ return NO_ERROR;
+ } break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/camera/VendorTagDescriptor.cpp b/camera/VendorTagDescriptor.cpp
index ed09b60..4c28789 100644
--- a/camera/VendorTagDescriptor.cpp
+++ b/camera/VendorTagDescriptor.cpp
@@ -29,6 +29,7 @@
#include <stdio.h>
#include <string.h>
+#include <inttypes.h>
namespace android {
@@ -40,11 +41,22 @@
static const char* vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t* v, uint32_t tag);
static int vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t* v, uint32_t tag);
+static int vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id);
+static void vendor_tag_descriptor_cache_get_all_tags(uint32_t* tagArray,
+ metadata_vendor_id_t id);
+static const char* vendor_tag_descriptor_cache_get_section_name(uint32_t tag,
+ metadata_vendor_id_t id);
+static const char* vendor_tag_descriptor_cache_get_tag_name(uint32_t tag,
+ metadata_vendor_id_t id);
+static int vendor_tag_descriptor_cache_get_tag_type(uint32_t tag,
+ metadata_vendor_id_t id);
+
} /* extern "C" */
static Mutex sLock;
static sp<VendorTagDescriptor> sGlobalVendorTagDescriptor;
+static sp<VendorTagDescriptorCache> sGlobalVendorTagDescriptorCache;
namespace hardware {
namespace camera2 {
@@ -333,11 +345,166 @@
}
+status_t VendorTagDescriptorCache::writeToParcel(Parcel* parcel) const {
+ status_t res = OK;
+ if (parcel == NULL) {
+ ALOGE("%s: parcel argument was NULL.", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ if ((res = parcel->writeInt32(mVendorMap.size())) != OK) {
+ return res;
+ }
+
+ for (const auto &iter : mVendorMap) {
+ if ((res = parcel->writeUint64(iter.first)) != OK) break;
+ if ((res = parcel->writeParcelable(*iter.second)) != OK) break;
+ }
+
+ return res;
+}
+
+
+status_t VendorTagDescriptorCache::readFromParcel(const Parcel* parcel) {
+ status_t res = OK;
+ if (parcel == NULL) {
+ ALOGE("%s: parcel argument was NULL.", __FUNCTION__);
+ return BAD_VALUE;
+ }
+
+ int32_t vendorCount = 0;
+ if ((res = parcel->readInt32(&vendorCount)) != OK) {
+ ALOGE("%s: could not read vendor count from parcel", __FUNCTION__);
+ return res;
+ }
+
+ if (vendorCount < 0 || vendorCount > INT32_MAX) {
+ ALOGE("%s: vendor count %d from is invalid.", __FUNCTION__, vendorCount);
+ return BAD_VALUE;
+ }
+
+ metadata_vendor_id_t id;
+ for (int32_t i = 0; i < vendorCount; i++) {
+ if ((res = parcel->readUint64(&id)) != OK) {
+ ALOGE("%s: could not read vendor id from parcel for index %d",
+ __FUNCTION__, i);
+ break;
+ }
+ sp<android::VendorTagDescriptor> desc = new android::VendorTagDescriptor();
+ if ((res = parcel->readParcelable(desc.get())) != OK) {
+ ALOGE("%s: could not read vendor tag descriptor from parcel for index %d rc = %d",
+ __FUNCTION__, i, res);
+ break;
+ }
+
+ if ((res = addVendorDescriptor(id, desc)) != OK) {
+ ALOGE("%s: failed to add vendor tag descriptor for index: %d ",
+ __FUNCTION__, i);
+ break;
+ }
+ }
+
+ return res;
+}
+
+int VendorTagDescriptorCache::getTagCount(metadata_vendor_id_t id) const {
+ int ret = 0;
+ auto desc = mVendorMap.find(id);
+ if (desc != mVendorMap.end()) {
+ ret = desc->second->getTagCount();
+ } else {
+ ALOGE("%s: Vendor descriptor id is missing!", __func__);
+ }
+
+ return ret;
+}
+
+void VendorTagDescriptorCache::getTagArray(uint32_t* tagArray,
+ metadata_vendor_id_t id) const {
+ auto desc = mVendorMap.find(id);
+ if (desc != mVendorMap.end()) {
+ desc->second->getTagArray(tagArray);
+ } else {
+ ALOGE("%s: Vendor descriptor id is missing!", __func__);
+ }
+}
+
+const char* VendorTagDescriptorCache::getSectionName(uint32_t tag,
+ metadata_vendor_id_t id) const {
+ const char *ret = nullptr;
+ auto desc = mVendorMap.find(id);
+ if (desc != mVendorMap.end()) {
+ ret = desc->second->getSectionName(tag);
+ } else {
+ ALOGE("%s: Vendor descriptor id is missing!", __func__);
+ }
+
+ return ret;
+}
+
+const char* VendorTagDescriptorCache::getTagName(uint32_t tag,
+ metadata_vendor_id_t id) const {
+ const char *ret = nullptr;
+ auto desc = mVendorMap.find(id);
+ if (desc != mVendorMap.end()) {
+ ret = desc->second->getTagName(tag);
+ } else {
+ ALOGE("%s: Vendor descriptor id is missing!", __func__);
+ }
+
+ return ret;
+}
+
+int VendorTagDescriptorCache::getTagType(uint32_t tag,
+ metadata_vendor_id_t id) const {
+ int ret = 0;
+ auto desc = mVendorMap.find(id);
+ if (desc != mVendorMap.end()) {
+ ret = desc->second->getTagType(tag);
+ } else {
+ ALOGE("%s: Vendor descriptor id is missing!", __func__);
+ }
+
+ return ret;
+}
+
+void VendorTagDescriptorCache::dump(int fd, int verbosity,
+ int indentation) const {
+ for (const auto &desc : mVendorMap) {
+ dprintf(fd, "%*sDumping vendor tag descriptors for vendor with"
+ " id %" PRIu64 " \n", indentation, "", desc.first);
+ desc.second->dump(fd, verbosity, indentation);
+ }
+}
+
+int32_t VendorTagDescriptorCache::addVendorDescriptor(metadata_vendor_id_t id,
+ sp<android::VendorTagDescriptor> desc) {
+ auto entry = mVendorMap.find(id);
+ if (entry != mVendorMap.end()) {
+ ALOGE("%s: Vendor descriptor with same id already present!", __func__);
+ return BAD_VALUE;
+ }
+
+ mVendorMap.emplace(id, desc);
+ return NO_ERROR;
+}
+
+int32_t VendorTagDescriptorCache::getVendorTagDescriptor(
+ metadata_vendor_id_t id, sp<android::VendorTagDescriptor> *desc /*out*/) {
+ auto entry = mVendorMap.find(id);
+ if (entry == mVendorMap.end()) {
+ return NAME_NOT_FOUND;
+ }
+
+ *desc = entry->second;
+
+ return NO_ERROR;
+}
+
} // namespace params
} // namespace camera2
} // namespace hardware
-
status_t VendorTagDescriptor::createDescriptorFromOps(const vendor_tag_ops_t* vOps,
/*out*/
sp<VendorTagDescriptor>& descriptor) {
@@ -451,6 +618,39 @@
return sGlobalVendorTagDescriptor;
}
+status_t VendorTagDescriptorCache::setAsGlobalVendorTagCache(
+ const sp<VendorTagDescriptorCache>& cache) {
+ status_t res = OK;
+ Mutex::Autolock al(sLock);
+ sGlobalVendorTagDescriptorCache = cache;
+
+ struct vendor_tag_cache_ops* opsPtr = NULL;
+ if (cache != NULL) {
+ opsPtr = &(cache->mVendorCacheOps);
+ opsPtr->get_tag_count = vendor_tag_descriptor_cache_get_tag_count;
+ opsPtr->get_all_tags = vendor_tag_descriptor_cache_get_all_tags;
+ opsPtr->get_section_name = vendor_tag_descriptor_cache_get_section_name;
+ opsPtr->get_tag_name = vendor_tag_descriptor_cache_get_tag_name;
+ opsPtr->get_tag_type = vendor_tag_descriptor_cache_get_tag_type;
+ }
+ if((res = set_camera_metadata_vendor_cache_ops(opsPtr)) != OK) {
+ ALOGE("%s: Could not set vendor tag cache, received error %s (%d)."
+ , __FUNCTION__, strerror(-res), res);
+ }
+ return res;
+}
+
+void VendorTagDescriptorCache::clearGlobalVendorTagCache() {
+ Mutex::Autolock al(sLock);
+ set_camera_metadata_vendor_cache_ops(NULL);
+ sGlobalVendorTagDescriptorCache.clear();
+}
+
+sp<VendorTagDescriptorCache> VendorTagDescriptorCache::getGlobalVendorTagCache() {
+ Mutex::Autolock al(sLock);
+ return sGlobalVendorTagDescriptorCache;
+}
+
extern "C" {
int vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t* /*v*/) {
@@ -498,5 +698,53 @@
return sGlobalVendorTagDescriptor->getTagType(tag);
}
+int vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id) {
+ Mutex::Autolock al(sLock);
+ if (sGlobalVendorTagDescriptorCache == NULL) {
+ ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
+ return VENDOR_TAG_COUNT_ERR;
+ }
+ return sGlobalVendorTagDescriptorCache->getTagCount(id);
+}
+
+void vendor_tag_descriptor_cache_get_all_tags(uint32_t* tagArray,
+ metadata_vendor_id_t id) {
+ Mutex::Autolock al(sLock);
+ if (sGlobalVendorTagDescriptorCache == NULL) {
+ ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
+ }
+ sGlobalVendorTagDescriptorCache->getTagArray(tagArray, id);
+}
+
+const char* vendor_tag_descriptor_cache_get_section_name(uint32_t tag,
+ metadata_vendor_id_t id) {
+ Mutex::Autolock al(sLock);
+ if (sGlobalVendorTagDescriptorCache == NULL) {
+ ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
+ return VENDOR_SECTION_NAME_ERR;
+ }
+ return sGlobalVendorTagDescriptorCache->getSectionName(tag, id);
+}
+
+const char* vendor_tag_descriptor_cache_get_tag_name(uint32_t tag,
+ metadata_vendor_id_t id) {
+ Mutex::Autolock al(sLock);
+ if (sGlobalVendorTagDescriptorCache == NULL) {
+ ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
+ return VENDOR_TAG_NAME_ERR;
+ }
+ return sGlobalVendorTagDescriptorCache->getTagName(tag, id);
+}
+
+int vendor_tag_descriptor_cache_get_tag_type(uint32_t tag,
+ metadata_vendor_id_t id) {
+ Mutex::Autolock al(sLock);
+ if (sGlobalVendorTagDescriptorCache == NULL) {
+ ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
+ return VENDOR_TAG_NAME_ERR;
+ }
+ return sGlobalVendorTagDescriptorCache->getTagType(tag, id);
+}
+
} /* extern "C" */
} /* namespace android */
diff --git a/camera/aidl/android/hardware/ICameraService.aidl b/camera/aidl/android/hardware/ICameraService.aidl
index 99c479c..9c0f28b 100644
--- a/camera/aidl/android/hardware/ICameraService.aidl
+++ b/camera/aidl/android/hardware/ICameraService.aidl
@@ -21,6 +21,7 @@
import android.hardware.camera2.ICameraDeviceUser;
import android.hardware.camera2.ICameraDeviceCallbacks;
import android.hardware.camera2.params.VendorTagDescriptor;
+import android.hardware.camera2.params.VendorTagDescriptorCache;
import android.hardware.camera2.impl.CameraMetadataNative;
import android.hardware.ICameraServiceListener;
import android.hardware.CameraInfo;
@@ -130,6 +131,14 @@
VendorTagDescriptor getCameraVendorTagDescriptor();
/**
+ * Retrieve the vendor tag descriptor cache which can have multiple vendor
+ * providers.
+ * Intended to be used by the native code of CameraMetadataNative to correctly
+ * interpret camera metadata with vendor tags.
+ */
+ VendorTagDescriptorCache getCameraVendorTagCache();
+
+ /**
* Read the legacy camera1 parameters into a String
*/
String getLegacyParameters(int cameraId);
diff --git a/camera/aidl/android/hardware/camera2/params/VendorTagDescriptorCache.aidl b/camera/aidl/android/hardware/camera2/params/VendorTagDescriptorCache.aidl
new file mode 100644
index 0000000..d212207
--- /dev/null
+++ b/camera/aidl/android/hardware/camera2/params/VendorTagDescriptorCache.aidl
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.camera2.params;
+
+/** @hide */
+parcelable VendorTagDescriptorCache cpp_header "camera/VendorTagDescriptor.h";
diff --git a/camera/include/camera/Camera.h b/camera/include/camera/Camera.h
index 57dc228..430aa1c 100644
--- a/camera/include/camera/Camera.h
+++ b/camera/include/camera/Camera.h
@@ -44,6 +44,9 @@
camera_frame_metadata_t *metadata) = 0;
virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) = 0;
virtual void postRecordingFrameHandleTimestamp(nsecs_t timestamp, native_handle_t* handle) = 0;
+ virtual void postRecordingFrameHandleTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles) = 0;
};
class Camera;
@@ -118,6 +121,10 @@
// release a recording frame handle
void releaseRecordingFrameHandle(native_handle_t *handle);
+ // release a batch of recording frame handles
+ void releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*> handles);
+
// autoFocus - status returned from callback
status_t autoFocus();
@@ -166,6 +173,10 @@
camera_frame_metadata_t *metadata);
virtual void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
virtual void recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_handle_t* handle);
+ virtual void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles);
+
class RecordingProxy : public BnCameraRecordingProxy
{
@@ -177,6 +188,8 @@
virtual void stopRecording();
virtual void releaseRecordingFrame(const sp<IMemory>& mem);
virtual void releaseRecordingFrameHandle(native_handle_t* handle);
+ virtual void releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*>& handles);
private:
sp<Camera> mCamera;
diff --git a/camera/include/camera/ICameraRecordingProxy.h b/camera/include/camera/ICameraRecordingProxy.h
index cb6824a..02af2f3 100644
--- a/camera/include/camera/ICameraRecordingProxy.h
+++ b/camera/include/camera/ICameraRecordingProxy.h
@@ -17,6 +17,7 @@
#ifndef ANDROID_HARDWARE_ICAMERA_RECORDING_PROXY_H
#define ANDROID_HARDWARE_ICAMERA_RECORDING_PROXY_H
+#include <vector>
#include <binder/IInterface.h>
#include <cutils/native_handle.h>
#include <utils/RefBase.h>
@@ -85,6 +86,8 @@
virtual void stopRecording() = 0;
virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0;
virtual void releaseRecordingFrameHandle(native_handle_t *handle) = 0;
+ virtual void releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*>& handles) = 0;
};
// ----------------------------------------------------------------------------
diff --git a/camera/include/camera/ICameraRecordingProxyListener.h b/camera/include/camera/ICameraRecordingProxyListener.h
index 1fee5b9..da03c56 100644
--- a/camera/include/camera/ICameraRecordingProxyListener.h
+++ b/camera/include/camera/ICameraRecordingProxyListener.h
@@ -17,6 +17,7 @@
#ifndef ANDROID_HARDWARE_ICAMERA_RECORDING_PROXY_LISTENER_H
#define ANDROID_HARDWARE_ICAMERA_RECORDING_PROXY_LISTENER_H
+#include <vector>
#include <binder/IInterface.h>
#include <cutils/native_handle.h>
#include <stdint.h>
@@ -38,6 +39,10 @@
virtual void recordingFrameHandleCallbackTimestamp(nsecs_t timestamp,
native_handle_t* handle) = 0;
+
+ virtual void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles) = 0;
};
// ----------------------------------------------------------------------------
diff --git a/camera/include/camera/VendorTagDescriptor.h b/camera/include/camera/VendorTagDescriptor.h
index adfc8c7..904fba2 100644
--- a/camera/include/camera/VendorTagDescriptor.h
+++ b/camera/include/camera/VendorTagDescriptor.h
@@ -22,7 +22,7 @@
#include <utils/String8.h>
#include <utils/RefBase.h>
#include <system/camera_vendor_tags.h>
-
+#include <unordered_map>
#include <stdint.h>
namespace android {
@@ -166,8 +166,84 @@
};
-} /* namespace android */
+namespace hardware {
+namespace camera2 {
+namespace params {
+class VendorTagDescriptorCache : public Parcelable {
+ public:
+
+ VendorTagDescriptorCache() {};
+
+ int32_t addVendorDescriptor(metadata_vendor_id_t id,
+ sp<android::VendorTagDescriptor> desc);
+
+ int32_t getVendorTagDescriptor(
+ metadata_vendor_id_t id,
+ sp<android::VendorTagDescriptor> *desc /*out*/);
+
+ // Parcelable interface
+ status_t writeToParcel(Parcel* parcel) const override;
+ status_t readFromParcel(const Parcel* parcel) override;
+
+ // Returns the number of vendor tags defined.
+ int getTagCount(metadata_vendor_id_t id) const;
+
+ // Returns an array containing the id's of vendor tags defined.
+ void getTagArray(uint32_t* tagArray, metadata_vendor_id_t id) const;
+
+ // Returns the section name string for a given vendor tag id.
+ const char* getSectionName(uint32_t tag, metadata_vendor_id_t id) const;
+
+ // Returns the tag name string for a given vendor tag id.
+ const char* getTagName(uint32_t tag, metadata_vendor_id_t id) const;
+
+ // Returns the tag type for a given vendor tag id.
+ int getTagType(uint32_t tag, metadata_vendor_id_t id) const;
+
+ /**
+ * Dump the currently configured vendor tags to a file descriptor.
+ */
+ void dump(int fd, int verbosity, int indentation) const;
+
+ protected:
+ std::unordered_map<metadata_vendor_id_t, sp<android::VendorTagDescriptor>> mVendorMap;
+ struct vendor_tag_cache_ops mVendorCacheOps;
+};
+
+} /* namespace params */
+} /* namespace camera2 */
+} /* namespace hardware */
+
+class VendorTagDescriptorCache :
+ public ::android::hardware::camera2::params::VendorTagDescriptorCache,
+ public LightRefBase<VendorTagDescriptorCache> {
+ public:
+
+ /**
+ * Sets the global vendor tag descriptor cache to use for this process.
+ * Camera metadata operations that access vendor tags will use the
+ * vendor tag definitions set this way.
+ *
+ * Returns OK on success, or a negative error code.
+ */
+ static status_t setAsGlobalVendorTagCache(
+ const sp<VendorTagDescriptorCache>& cache);
+
+ /**
+ * Returns the global vendor tag cache used by this process.
+ * This will contain NULL if no vendor tags are defined.
+ */
+ static sp<VendorTagDescriptorCache> getGlobalVendorTagCache();
+
+ /**
+ * Clears the global vendor tag cache used by this process.
+ */
+ static void clearGlobalVendorTagCache();
+
+};
+
+} /* namespace android */
#define VENDOR_TAG_DESCRIPTOR_H
#endif /* VENDOR_TAG_DESCRIPTOR_H */
diff --git a/camera/include/camera/android/hardware/ICamera.h b/camera/include/camera/android/hardware/ICamera.h
index 315669e..80823d6 100644
--- a/camera/include/camera/android/hardware/ICamera.h
+++ b/camera/include/camera/android/hardware/ICamera.h
@@ -101,6 +101,11 @@
// ICameraClient::recordingFrameHandleCallbackTimestamp.
virtual void releaseRecordingFrameHandle(native_handle_t *handle) = 0;
+ // Release a batch of recording frame handles that was received via
+ // ICameraClient::recordingFrameHandleCallbackTimestampBatch
+ virtual void releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*>& handles) = 0;
+
// auto focus
virtual status_t autoFocus() = 0;
diff --git a/camera/include/camera/android/hardware/ICameraClient.h b/camera/include/camera/android/hardware/ICameraClient.h
index f6ee311..8e46d17 100644
--- a/camera/include/camera/android/hardware/ICameraClient.h
+++ b/camera/include/camera/android/hardware/ICameraClient.h
@@ -41,6 +41,13 @@
// ICamera::releaseRecordingFrameHandle to release the frame handle.
virtual void recordingFrameHandleCallbackTimestamp(nsecs_t timestamp,
native_handle_t* handle) = 0;
+
+ // Invoked to send a batch of recording frame handles with timestamp. Call
+ // ICamera::releaseRecordingFrameHandleBatch to release the frame handles.
+ // Size of timestamps and handles must match
+ virtual void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles) = 0;
};
// ----------------------------------------------------------------------------
diff --git a/camera/ndk/impl/ACameraManager.cpp b/camera/ndk/impl/ACameraManager.cpp
index ba2100c..3f64bcc 100644
--- a/camera/ndk/impl/ACameraManager.cpp
+++ b/camera/ndk/impl/ACameraManager.cpp
@@ -131,10 +131,36 @@
binder::Status ret = mCameraService->getCameraVendorTagDescriptor(/*out*/desc.get());
if (ret.isOk()) {
- status_t err = VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
- if (err != OK) {
- ALOGE("%s: Failed to set vendor tag descriptors, received error %s (%d)",
- __FUNCTION__, strerror(-err), err);
+ if (0 < desc->getTagCount()) {
+ status_t err = VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
+ if (err != OK) {
+ ALOGE("%s: Failed to set vendor tag descriptors, received error %s (%d)",
+ __FUNCTION__, strerror(-err), err);
+ }
+ } else {
+ sp<VendorTagDescriptorCache> cache =
+ new VendorTagDescriptorCache();
+ binder::Status res =
+ mCameraService->getCameraVendorTagCache(
+ /*out*/cache.get());
+ if (res.serviceSpecificErrorCode() ==
+ hardware::ICameraService::ERROR_DISCONNECTED) {
+ // No camera module available, not an error on devices with no cameras
+ VendorTagDescriptorCache::clearGlobalVendorTagCache();
+ } else if (res.isOk()) {
+ status_t err =
+ VendorTagDescriptorCache::setAsGlobalVendorTagCache(
+ cache);
+ if (err != OK) {
+ ALOGE("%s: Failed to set vendor tag cache,"
+ "received error %s (%d)", __FUNCTION__,
+ strerror(-err), err);
+ }
+ } else {
+ VendorTagDescriptorCache::clearGlobalVendorTagCache();
+ ALOGE("%s: Failed to setup vendor tag cache: %s",
+ __FUNCTION__, res.toString8().string());
+ }
}
} else if (ret.serviceSpecificErrorCode() ==
hardware::ICameraService::ERROR_DEPRECATED_HAL) {
diff --git a/camera/tests/CameraZSLTests.cpp b/camera/tests/CameraZSLTests.cpp
index 6c91fdc..ecca354 100644
--- a/camera/tests/CameraZSLTests.cpp
+++ b/camera/tests/CameraZSLTests.cpp
@@ -51,6 +51,9 @@
const sp<IMemory>&) override {};
void recordingFrameHandleCallbackTimestamp(nsecs_t,
native_handle_t*) override {};
+ void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<nsecs_t>&,
+ const std::vector<native_handle_t*>&) override {};
status_t waitForPreviewStart();
status_t waitForEvent(Mutex &mutex, Condition &condition, bool &flag);
diff --git a/cmds/stagefright/stagefright.cpp b/cmds/stagefright/stagefright.cpp
index 4d8dd3c..80aad2f 100644
--- a/cmds/stagefright/stagefright.cpp
+++ b/cmds/stagefright/stagefright.cpp
@@ -908,9 +908,7 @@
if (listComponents) {
sp<IOMX> omx;
- int32_t trebleOmx = property_get_int32("persist.media.treble_omx", -1);
- if ((trebleOmx == 1) || ((trebleOmx == -1) &&
- property_get_bool("persist.hal.binderization", 0))) {
+ if (property_get_bool("persist.media.treble_omx", true)) {
using namespace ::android::hardware::media::omx::V1_0;
sp<IOmx> tOmx = IOmx::getService();
diff --git a/drm/libmediadrm/Android.mk b/drm/libmediadrm/Android.mk
index 590622e..5b56501 100644
--- a/drm/libmediadrm/Android.mk
+++ b/drm/libmediadrm/Android.mk
@@ -18,6 +18,7 @@
LOCAL_SRC_FILES += \
CasImpl.cpp \
DescramblerImpl.cpp \
+ DrmPluginPath.cpp \
DrmSessionManager.cpp \
ICrypto.cpp \
IDrm.cpp \
diff --git a/drm/libmediadrm/Crypto.cpp b/drm/libmediadrm/Crypto.cpp
index d93dad6..a5d7346 100644
--- a/drm/libmediadrm/Crypto.cpp
+++ b/drm/libmediadrm/Crypto.cpp
@@ -22,6 +22,7 @@
#include <binder/IMemory.h>
#include <media/Crypto.h>
+#include <media/DrmPluginPath.h>
#include <media/hardware/CryptoAPI.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AString.h>
@@ -102,7 +103,7 @@
}
// no luck, have to search
- String8 dirPath("/vendor/lib/mediadrm");
+ String8 dirPath(getDrmPluginPath());
String8 pluginPath;
DIR* pDir = opendir(dirPath.string());
diff --git a/drm/libmediadrm/Drm.cpp b/drm/libmediadrm/Drm.cpp
index e3176e3..1004eb8 100644
--- a/drm/libmediadrm/Drm.cpp
+++ b/drm/libmediadrm/Drm.cpp
@@ -21,6 +21,7 @@
#include <dirent.h>
#include <dlfcn.h>
+#include <media/DrmPluginPath.h>
#include <media/DrmSessionClientInterface.h>
#include <media/DrmSessionManager.h>
#include <media/Drm.h>
@@ -220,7 +221,7 @@
}
// no luck, have to search
- String8 dirPath("/vendor/lib/mediadrm");
+ String8 dirPath(getDrmPluginPath());
DIR* pDir = opendir(dirPath.string());
if (pDir == NULL) {
diff --git a/drm/libmediadrm/DrmHal.cpp b/drm/libmediadrm/DrmHal.cpp
index 16035c0..ddbc83d 100644
--- a/drm/libmediadrm/DrmHal.cpp
+++ b/drm/libmediadrm/DrmHal.cpp
@@ -291,6 +291,9 @@
case EventType::VENDOR_DEFINED:
eventType = DrmPlugin::kDrmPluginEventVendorDefined;
break;
+ case EventType::SESSION_RECLAIMED:
+ eventType = DrmPlugin::kDrmPluginEventSessionReclaimed;
+ break;
default:
return Void();
}
diff --git a/drm/libmediadrm/DrmPluginPath.cpp b/drm/libmediadrm/DrmPluginPath.cpp
new file mode 100644
index 0000000..c760825
--- /dev/null
+++ b/drm/libmediadrm/DrmPluginPath.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017 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 "DrmPluginPath"
+#include <utils/Log.h>
+
+#include <cutils/properties.h>
+#include <media/DrmPluginPath.h>
+
+namespace android {
+
+const char* getDrmPluginPath() {
+ char value[PROPERTY_VALUE_MAX];
+ if (property_get("drm.64bit.enabled", value, NULL) == 0) {
+ return "/vendor/lib/mediadrm";
+ } else {
+ return "/vendor/lib64/mediadrm";
+ }
+}
+
+} // namespace android
diff --git a/drm/mediadrm/plugins/clearkey/DrmPlugin.cpp b/drm/mediadrm/plugins/clearkey/DrmPlugin.cpp
index 8cc5ee9..5fdac5c 100644
--- a/drm/mediadrm/plugins/clearkey/DrmPlugin.cpp
+++ b/drm/mediadrm/plugins/clearkey/DrmPlugin.cpp
@@ -37,6 +37,9 @@
status_t DrmPlugin::closeSession(const Vector<uint8_t>& sessionId) {
sp<Session> session = mSessionLibrary->findSession(sessionId);
+ if (sessionId.size() == 0) {
+ return android::BAD_VALUE;
+ }
if (session.get()) {
mSessionLibrary->destroySession(session);
return android::OK;
@@ -54,6 +57,9 @@
String8& defaultUrl,
DrmPlugin::KeyRequestType *keyRequestType) {
UNUSED(optionalParameters);
+ if (scope.size() == 0) {
+ return android::BAD_VALUE;
+ }
if (keyType != kKeyType_Streaming) {
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -70,6 +76,9 @@
const Vector<uint8_t>& scope,
const Vector<uint8_t>& response,
Vector<uint8_t>& keySetId) {
+ if (scope.size() == 0 || response.size() == 0) {
+ return android::BAD_VALUE;
+ }
sp<Session> session = mSessionLibrary->findSession(scope);
if (!session.get()) {
return android::ERROR_DRM_SESSION_NOT_OPENED;
diff --git a/drm/mediadrm/plugins/clearkey/DrmPlugin.h b/drm/mediadrm/plugins/clearkey/DrmPlugin.h
index c4d934e..58421b9 100644
--- a/drm/mediadrm/plugins/clearkey/DrmPlugin.h
+++ b/drm/mediadrm/plugins/clearkey/DrmPlugin.h
@@ -63,22 +63,28 @@
Vector<uint8_t>& keySetId);
virtual status_t removeKeys(const Vector<uint8_t>& sessionId) {
- UNUSED(sessionId);
+ if (sessionId.size() == 0) {
+ return android::BAD_VALUE;
+ }
+
return android::ERROR_DRM_CANNOT_HANDLE;
}
virtual status_t restoreKeys(
const Vector<uint8_t>& sessionId,
const Vector<uint8_t>& keySetId) {
- UNUSED(sessionId);
- UNUSED(keySetId);
+ if (sessionId.size() == 0 || keySetId.size() == 0) {
+ return android::BAD_VALUE;
+ }
return android::ERROR_DRM_CANNOT_HANDLE;
}
virtual status_t queryKeyStatus(
const Vector<uint8_t>& sessionId,
KeyedVector<String8, String8>& infoMap) const {
- UNUSED(sessionId);
+ if (sessionId.size() == 0) {
+ return android::BAD_VALUE;
+ }
UNUSED(infoMap);
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -99,9 +105,12 @@
const Vector<uint8_t>& response,
Vector<uint8_t>& certificate,
Vector<uint8_t>& wrappedKey) {
- UNUSED(response);
UNUSED(certificate);
UNUSED(wrappedKey);
+ if (response.size() == 0) {
+ // empty response
+ return android::BAD_VALUE;
+ }
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -111,13 +120,18 @@
}
virtual status_t getSecureStop(Vector<uint8_t> const &ssid, Vector<uint8_t> &secureStop) {
- UNUSED(ssid);
+ if (ssid.size() == 0) {
+ return android::BAD_VALUE;
+ }
+
UNUSED(secureStop);
return android::ERROR_DRM_CANNOT_HANDLE;
}
virtual status_t releaseSecureStops(const Vector<uint8_t>& ssRelease) {
- UNUSED(ssRelease);
+ if (ssRelease.size() == 0) {
+ return android::BAD_VALUE;
+ }
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -151,15 +165,17 @@
virtual status_t setCipherAlgorithm(
const Vector<uint8_t>& sessionId, const String8& algorithm) {
- UNUSED(sessionId);
- UNUSED(algorithm);
+ if (sessionId.size() == 0 || algorithm.size() == 0) {
+ return android::BAD_VALUE;
+ }
return android::ERROR_DRM_CANNOT_HANDLE;
}
virtual status_t setMacAlgorithm(
const Vector<uint8_t>& sessionId, const String8& algorithm) {
- UNUSED(sessionId);
- UNUSED(algorithm);
+ if (sessionId.size() == 0 || algorithm.size() == 0) {
+ return android::BAD_VALUE;
+ }
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -169,10 +185,10 @@
const Vector<uint8_t>& input,
const Vector<uint8_t>& iv,
Vector<uint8_t>& output) {
- UNUSED(sessionId);
- UNUSED(keyId);
- UNUSED(input);
- UNUSED(iv);
+ if (sessionId.size() == 0 || keyId.size() == 0 ||
+ input.size() == 0 || iv.size() == 0) {
+ return android::BAD_VALUE;
+ }
UNUSED(output);
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -183,10 +199,10 @@
const Vector<uint8_t>& input,
const Vector<uint8_t>& iv,
Vector<uint8_t>& output) {
- UNUSED(sessionId);
- UNUSED(keyId);
- UNUSED(input);
- UNUSED(iv);
+ if (sessionId.size() == 0 || keyId.size() == 0 ||
+ input.size() == 0 || iv.size() == 0) {
+ return android::BAD_VALUE;
+ }
UNUSED(output);
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -196,9 +212,10 @@
const Vector<uint8_t>& keyId,
const Vector<uint8_t>& message,
Vector<uint8_t>& signature) {
- UNUSED(sessionId);
- UNUSED(keyId);
- UNUSED(message);
+ if (sessionId.size() == 0 || keyId.size() == 0 ||
+ message.size() == 0) {
+ return android::BAD_VALUE;
+ }
UNUSED(signature);
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -208,10 +225,10 @@
const Vector<uint8_t>& keyId,
const Vector<uint8_t>& message,
const Vector<uint8_t>& signature, bool& match) {
- UNUSED(sessionId);
- UNUSED(keyId);
- UNUSED(message);
- UNUSED(signature);
+ if (sessionId.size() == 0 || keyId.size() == 0 ||
+ message.size() == 0 || signature.size() == 0) {
+ return android::BAD_VALUE;
+ }
UNUSED(match);
return android::ERROR_DRM_CANNOT_HANDLE;
}
@@ -222,10 +239,10 @@
const Vector<uint8_t>& message,
const Vector<uint8_t>& wrappedKey,
Vector<uint8_t>& signature) {
- UNUSED(sessionId);
- UNUSED(algorithm);
- UNUSED(message);
- UNUSED(wrappedKey);
+ if (sessionId.size() == 0 || algorithm.size() == 0 ||
+ message.size() == 0 || wrappedKey.size() == 0) {
+ return android::BAD_VALUE;
+ }
UNUSED(signature);
return android::ERROR_DRM_CANNOT_HANDLE;
}
diff --git a/include/media/DrmPluginPath.h b/include/media/DrmPluginPath.h
new file mode 120000
index 0000000..06b12cf
--- /dev/null
+++ b/include/media/DrmPluginPath.h
@@ -0,0 +1 @@
+../../media/libmedia/include/DrmPluginPath.h
\ No newline at end of file
diff --git a/include/media/IMediaAnalyticsService.h b/include/media/IMediaAnalyticsService.h
index 97915e4..a596d60 120000
--- a/include/media/IMediaAnalyticsService.h
+++ b/include/media/IMediaAnalyticsService.h
@@ -1 +1 @@
-../../media/libmedia/include/IMediaAnalyticsService.h
\ No newline at end of file
+../../media/libmediametrics/include/IMediaAnalyticsService.h
\ No newline at end of file
diff --git a/include/media/MediaAnalyticsItem.h b/include/media/MediaAnalyticsItem.h
index 71957a5..e8124e0 120000
--- a/include/media/MediaAnalyticsItem.h
+++ b/include/media/MediaAnalyticsItem.h
@@ -1 +1 @@
-../../media/libmedia/include/MediaAnalyticsItem.h
\ No newline at end of file
+../../media/libmediametrics/include/MediaAnalyticsItem.h
\ No newline at end of file
diff --git a/include/ndk/NdkMediaDrm.h b/include/ndk/NdkMediaDrm.h
index 9dd6283..cba4380 100644
--- a/include/ndk/NdkMediaDrm.h
+++ b/include/ndk/NdkMediaDrm.h
@@ -159,8 +159,7 @@
* to obtain or release keys used to decrypt encrypted content.
* AMediaDrm_getKeyRequest is used to obtain an opaque key request byte array that
* is delivered to the license server. The opaque key request byte array is
- * returned in KeyRequest.data. The recommended URL to deliver the key request to
- * is returned in KeyRequest.defaultUrl.
+ * returned in KeyRequest.data.
*
* After the app has received the key request response from the server,
* it should deliver to the response to the DRM engine plugin using the method
diff --git a/media/libaaudio/examples/write_sine/src/write_sine.cpp b/media/libaaudio/examples/write_sine/src/write_sine.cpp
index 511fe94..80b6252 100644
--- a/media/libaaudio/examples/write_sine/src/write_sine.cpp
+++ b/media/libaaudio/examples/write_sine/src/write_sine.cpp
@@ -27,6 +27,7 @@
#define NUM_SECONDS 10
#define NANOS_PER_MICROSECOND ((int64_t)1000)
#define NANOS_PER_MILLISECOND (NANOS_PER_MICROSECOND * 1000)
+#define NANOS_PER_SECOND (NANOS_PER_MILLISECOND * 1000)
static const char *getSharingModeText(aaudio_sharing_mode_t mode) {
const char *modeText = "unknown";
@@ -43,6 +44,15 @@
return modeText;
}
+static int64_t getNanoseconds(clockid_t clockId = CLOCK_MONOTONIC) {
+ struct timespec time;
+ int result = clock_gettime(clockId, &time);
+ if (result < 0) {
+ return -errno;
+ }
+ return (time.tv_sec * NANOS_PER_SECOND) + time.tv_nsec;
+}
+
int main(int argc, char **argv)
{
(void)argc; // unused
@@ -56,7 +66,8 @@
const aaudio_audio_format_t requestedDataFormat = AAUDIO_FORMAT_PCM_I16;
aaudio_audio_format_t actualDataFormat = AAUDIO_FORMAT_PCM_I16;
- const aaudio_sharing_mode_t requestedSharingMode = AAUDIO_SHARING_MODE_EXCLUSIVE;
+ //const aaudio_sharing_mode_t requestedSharingMode = AAUDIO_SHARING_MODE_EXCLUSIVE;
+ const aaudio_sharing_mode_t requestedSharingMode = AAUDIO_SHARING_MODE_SHARED;
aaudio_sharing_mode_t actualSharingMode = AAUDIO_SHARING_MODE_SHARED;
AAudioStreamBuilder *aaudioBuilder = nullptr;
@@ -172,6 +183,26 @@
goto finish;
}
framesLeft -= actual;
+
+ // Use timestamp to estimate latency.
+ {
+ int64_t presentationFrame;
+ int64_t presentationTime;
+ result = AAudioStream_getTimestamp(aaudioStream,
+ CLOCK_MONOTONIC,
+ &presentationFrame,
+ &presentationTime
+ );
+ if (result == AAUDIO_OK) {
+ int64_t elapsedNanos = getNanoseconds() - presentationTime;
+ int64_t elapsedFrames = actualSampleRate * elapsedNanos / NANOS_PER_SECOND;
+ int64_t currentFrame = presentationFrame + elapsedFrames;
+ int64_t framesWritten = AAudioStream_getFramesWritten(aaudioStream);
+ int64_t estimatedLatencyFrames = framesWritten - currentFrame;
+ int64_t estimatedLatencyMillis = estimatedLatencyFrames * 1000 / actualSampleRate;
+ printf("estimatedLatencyMillis %d\n", (int)estimatedLatencyMillis);
+ }
+ }
}
xRunCount = AAudioStream_getXRunCount(aaudioStream);
diff --git a/media/libaaudio/include/aaudio/AAudio.h b/media/libaaudio/include/aaudio/AAudio.h
index 921248a..551dcc9 100644
--- a/media/libaaudio/include/aaudio/AAudio.h
+++ b/media/libaaudio/include/aaudio/AAudio.h
@@ -15,7 +15,16 @@
*/
/**
- * This is the 'C' ABI for AAudio.
+ * @addtogroup Audio
+ * @{
+ */
+
+/**
+ * @file AAudio.h
+ */
+
+/**
+ * This is the 'C' API for AAudio.
*/
#ifndef AAUDIO_AAUDIO_H
#define AAUDIO_AAUDIO_H
@@ -525,3 +534,5 @@
#endif
#endif //AAUDIO_AAUDIO_H
+
+/** @} */
diff --git a/media/libaaudio/include/aaudio/AAudioDefinitions.h b/media/libaaudio/include/aaudio/AAudioDefinitions.h
index e5b7d7a..fbd284c 100644
--- a/media/libaaudio/include/aaudio/AAudioDefinitions.h
+++ b/media/libaaudio/include/aaudio/AAudioDefinitions.h
@@ -14,6 +14,15 @@
* limitations under the License.
*/
+/**
+ * @addtogroup Audio
+ * @{
+ */
+
+/**
+ * @file AAudioDefinitions.h
+ */
+
#ifndef AAUDIO_AAUDIODEFINITIONS_H
#define AAUDIO_AAUDIODEFINITIONS_H
@@ -46,6 +55,12 @@
AAUDIO_FORMAT_PCM_I8_24,
AAUDIO_FORMAT_PCM_I32
};
+typedef int32_t aaudio_format_t;
+
+/**
+ * @deprecated use aaudio_format_t instead
+ * TODO remove when tests and examples are updated
+ */
typedef int32_t aaudio_audio_format_t;
enum {
@@ -111,3 +126,5 @@
#endif
#endif // AAUDIO_AAUDIODEFINITIONS_H
+
+/** @} */
diff --git a/media/libaaudio/src/core/AudioStream.h b/media/libaaudio/src/core/AudioStream.h
index af0593d..6ac8554 100644
--- a/media/libaaudio/src/core/AudioStream.h
+++ b/media/libaaudio/src/core/AudioStream.h
@@ -50,7 +50,6 @@
virtual aaudio_result_t requestFlush() = 0;
virtual aaudio_result_t requestStop() = 0;
- // TODO use aaudio_clockid_t all the way down to AudioClock
virtual aaudio_result_t getTimestamp(clockid_t clockId,
int64_t *framePosition,
int64_t *timeNanoseconds) = 0;
diff --git a/media/libaaudio/src/legacy/AudioStreamRecord.cpp b/media/libaaudio/src/legacy/AudioStreamRecord.cpp
index dd040a0..d380eb8 100644
--- a/media/libaaudio/src/legacy/AudioStreamRecord.cpp
+++ b/media/libaaudio/src/legacy/AudioStreamRecord.cpp
@@ -25,6 +25,7 @@
#include "AudioClock.h"
#include "AudioStreamRecord.h"
+#include "utility/AAudioUtilities.h"
using namespace android;
using namespace aaudio;
@@ -224,5 +225,28 @@
return 192; // TODO add query to AudioRecord.cpp
}
-// TODO implement getTimestamp
-
+aaudio_result_t AudioStreamRecord::getTimestamp(clockid_t clockId,
+ int64_t *framePosition,
+ int64_t *timeNanoseconds) {
+ ExtendedTimestamp extendedTimestamp;
+ status_t status = mAudioRecord->getTimestamp(&extendedTimestamp);
+ if (status != NO_ERROR) {
+ return AAudioConvert_androidToAAudioResult(status);
+ }
+ // TODO Merge common code into AudioStreamLegacy after rebasing.
+ int timebase;
+ switch(clockId) {
+ case CLOCK_BOOTTIME:
+ timebase = ExtendedTimestamp::TIMEBASE_BOOTTIME;
+ break;
+ case CLOCK_MONOTONIC:
+ timebase = ExtendedTimestamp::TIMEBASE_MONOTONIC;
+ break;
+ default:
+ ALOGE("getTimestamp() - Unrecognized clock type %d", (int) clockId);
+ return AAUDIO_ERROR_UNEXPECTED_VALUE;
+ break;
+ }
+ status = extendedTimestamp.getBestTimestamp(framePosition, timeNanoseconds, timebase);
+ return AAudioConvert_androidToAAudioResult(status);
+}
diff --git a/media/libaaudio/src/legacy/AudioStreamRecord.h b/media/libaaudio/src/legacy/AudioStreamRecord.h
index c8d389b..4667f05 100644
--- a/media/libaaudio/src/legacy/AudioStreamRecord.h
+++ b/media/libaaudio/src/legacy/AudioStreamRecord.h
@@ -44,10 +44,8 @@
virtual aaudio_result_t requestStop() override;
virtual aaudio_result_t getTimestamp(clockid_t clockId,
- int64_t *framePosition,
- int64_t *timeNanoseconds) override {
- return AAUDIO_ERROR_UNIMPLEMENTED; // TODO
- }
+ int64_t *framePosition,
+ int64_t *timeNanoseconds) override;
virtual aaudio_result_t read(void *buffer,
int32_t numFrames,
diff --git a/media/libaaudio/src/legacy/AudioStreamTrack.cpp b/media/libaaudio/src/legacy/AudioStreamTrack.cpp
index e0a04c3..8bb6aee 100644
--- a/media/libaaudio/src/legacy/AudioStreamTrack.cpp
+++ b/media/libaaudio/src/legacy/AudioStreamTrack.cpp
@@ -20,11 +20,11 @@
#include <stdint.h>
#include <media/AudioTrack.h>
-
#include <aaudio/AAudio.h>
-#include "AudioClock.h"
-#include "AudioStreamTrack.h"
+#include "utility/AudioClock.h"
+#include "AudioStreamTrack.h"
+#include "utility/AAudioUtilities.h"
using namespace android;
using namespace aaudio;
@@ -292,3 +292,29 @@
}
return AudioStream::getFramesRead();
}
+
+aaudio_result_t AudioStreamTrack::getTimestamp(clockid_t clockId,
+ int64_t *framePosition,
+ int64_t *timeNanoseconds) {
+ ExtendedTimestamp extendedTimestamp;
+ status_t status = mAudioTrack->getTimestamp(&extendedTimestamp);
+ if (status != NO_ERROR) {
+ return AAudioConvert_androidToAAudioResult(status);
+ }
+ // TODO Merge common code into AudioStreamLegacy after rebasing.
+ int timebase;
+ switch(clockId) {
+ case CLOCK_BOOTTIME:
+ timebase = ExtendedTimestamp::TIMEBASE_BOOTTIME;
+ break;
+ case CLOCK_MONOTONIC:
+ timebase = ExtendedTimestamp::TIMEBASE_MONOTONIC;
+ break;
+ default:
+ ALOGE("getTimestamp() - Unrecognized clock type %d", (int) clockId);
+ return AAUDIO_ERROR_UNEXPECTED_VALUE;
+ break;
+ }
+ status = extendedTimestamp.getBestTimestamp(framePosition, timeNanoseconds, timebase);
+ return AAudioConvert_androidToAAudioResult(status);
+}
diff --git a/media/libaaudio/src/legacy/AudioStreamTrack.h b/media/libaaudio/src/legacy/AudioStreamTrack.h
index 1de07ce..7a53022 100644
--- a/media/libaaudio/src/legacy/AudioStreamTrack.h
+++ b/media/libaaudio/src/legacy/AudioStreamTrack.h
@@ -47,9 +47,7 @@
virtual aaudio_result_t getTimestamp(clockid_t clockId,
int64_t *framePosition,
- int64_t *timeNanoseconds) override {
- return AAUDIO_ERROR_UNIMPLEMENTED; // TODO call getTimestamp(ExtendedTimestamp *timestamp);
- }
+ int64_t *timeNanoseconds) override;
virtual aaudio_result_t write(const void *buffer,
int32_t numFrames,
diff --git a/media/libeffects/factory/EffectsFactory.c b/media/libeffects/factory/EffectsFactory.c
index 554c14d..523b6e1 100644
--- a/media/libeffects/factory/EffectsFactory.c
+++ b/media/libeffects/factory/EffectsFactory.c
@@ -48,6 +48,7 @@
static int gCanQueryEffect; // indicates that call to EffectQueryEffect() is valid, i.e. that the list of effects
// was not modified since last call to EffectQueryNumberEffects()
+static list_elem_t *gLibraryFailedList; //list of lib_failed_entry_t: libraries failed to load
/////////////////////////////////////////////////
// Local functions prototypes
@@ -584,6 +585,17 @@
if (hdl != NULL) {
dlclose(hdl);
}
+ //add entry for library errors in gLibraryFailedList
+ lib_failed_entry_t *fl = malloc(sizeof(lib_failed_entry_t));
+ fl->name = strndup(name, PATH_MAX);
+ fl->path = strndup(path, PATH_MAX);
+
+ list_elem_t *fe = malloc(sizeof(list_elem_t));
+ fe->object = fl;
+ fe->next = gLibraryFailedList;
+ gLibraryFailedList = fe;
+ ALOGV("getLibrary() linked error in library %p for path %s", fl, path);
+
return -EINVAL;
}
@@ -986,16 +998,31 @@
int EffectDumpEffects(int fd) {
char s[512];
+
+ list_elem_t *fe = gLibraryFailedList;
+ lib_failed_entry_t *fl = NULL;
+
+ dprintf(fd, "Libraries NOT loaded:\n");
+
+ while (fe) {
+ fl = (lib_failed_entry_t *)fe->object;
+ dprintf(fd, " Library %s\n", fl->name);
+ dprintf(fd, " path: %s\n", fl->path);
+ fe = fe->next;
+ }
+
list_elem_t *e = gLibraryList;
lib_entry_t *l = NULL;
effect_descriptor_t *d = NULL;
int found = 0;
int ret = 0;
+ dprintf(fd, "Libraries loaded:\n");
while (e) {
l = (lib_entry_t *)e->object;
list_elem_t *efx = l->effects;
- dprintf(fd, "Library %s\n", l->name);
+ dprintf(fd, " Library %s\n", l->name);
+ dprintf(fd, " path: %s\n", l->path);
if (!efx) {
dprintf(fd, " (no effects)\n");
}
diff --git a/media/libeffects/factory/EffectsFactory.h b/media/libeffects/factory/EffectsFactory.h
index b7936e0..72e0931 100644
--- a/media/libeffects/factory/EffectsFactory.h
+++ b/media/libeffects/factory/EffectsFactory.h
@@ -58,6 +58,11 @@
lib_entry_t *lib;
} effect_entry_t;
+typedef struct lib_failed_entry_s {
+ char *name;
+ char *path;
+} lib_failed_entry_t;
+
// Structure used to store the lib entry
// and the descriptor of the sub effects.
// The library entry is to be stored in case of
@@ -69,6 +74,7 @@
} sub_effect_entry_t;
+
////////////////////////////////////////////////////////////////////////////////
//
// Function: EffectGetSubEffects
diff --git a/media/libeffects/lvm/wrapper/Bundle/EffectBundle.h b/media/libeffects/lvm/wrapper/Bundle/EffectBundle.h
index 9459b87..ee604eb 100644
--- a/media/libeffects/lvm/wrapper/Bundle/EffectBundle.h
+++ b/media/libeffects/lvm/wrapper/Bundle/EffectBundle.h
@@ -140,7 +140,7 @@
{120001, 460000},
{460001, 1800000},
{1800001, 7000000},
- {7000001, 1}};
+ {7000001, 20000000}};
//Note: If these frequencies change, please update LimitLevel values accordingly.
static const LVM_UINT16 EQNB_5BandPresetsFrequencies[] = {
diff --git a/media/libmedia/Android.mk b/media/libmedia/Android.mk
index 8a1ce22..b0bd22e 100644
--- a/media/libmedia/Android.mk
+++ b/media/libmedia/Android.mk
@@ -26,7 +26,6 @@
IMediaPlayer.cpp \
IMediaRecorder.cpp \
IMediaSource.cpp \
- IMediaAnalyticsService.cpp \
IRemoteDisplay.cpp \
IRemoteDisplayClient.cpp \
IResourceManagerClient.cpp \
@@ -35,7 +34,6 @@
MediaCodecBuffer.cpp \
MediaCodecInfo.cpp \
MediaDefs.cpp \
- MediaAnalyticsItem.cpp \
MediaUtils.cpp \
Metadata.cpp \
mediarecorder.cpp \
@@ -66,6 +64,7 @@
libcamera_client libstagefright_foundation \
libgui libdl libaudioutils libaudioclient \
libmedia_helper libmediadrm \
+ libmediametrics \
libbase \
libhidlbase \
libhidltransport \
diff --git a/media/libmedia/IMediaExtractorService.cpp b/media/libmedia/IMediaExtractorService.cpp
index 8b00d85..7c0d08d 100644
--- a/media/libmedia/IMediaExtractorService.cpp
+++ b/media/libmedia/IMediaExtractorService.cpp
@@ -23,11 +23,13 @@
#include <sys/types.h>
#include <binder/Parcel.h>
#include <media/IMediaExtractorService.h>
+#include <media/stagefright/MediaExtractor.h>
namespace android {
enum {
- MAKE_EXTRACTOR = IBinder::FIRST_CALL_TRANSACTION
+ MAKE_EXTRACTOR = IBinder::FIRST_CALL_TRANSACTION,
+ MAKE_IDATA_SOURCE_FD,
};
class BpMediaExtractorService : public BpInterface<IMediaExtractorService>
@@ -52,6 +54,21 @@
return NULL;
}
+ virtual sp<IDataSource> makeIDataSource(int fd, int64_t offset, int64_t length)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IMediaExtractorService::getInterfaceDescriptor());
+ data.writeFileDescriptor(fd);
+ data.writeInt64(offset);
+ data.writeInt64(length);
+ status_t ret = remote()->transact(MAKE_IDATA_SOURCE_FD, data, &reply);
+ ALOGV("fd:%d offset:%lld length:%lld ret:%d",
+ fd, (long long)offset, (long long)length, ret);
+ if (ret == NO_ERROR) {
+ return interface_cast<IDataSource>(reply.readStrongBinder());
+ }
+ return nullptr;
+ }
};
IMPLEMENT_META_INTERFACE(MediaExtractorService, "android.media.IMediaExtractorService");
@@ -80,6 +97,23 @@
reply->writeStrongBinder(IInterface::asBinder(ex));
return NO_ERROR;
}
+
+ case MAKE_IDATA_SOURCE_FD: {
+ CHECK_INTERFACE(IMediaExtractorService, data, reply);
+ const int fd = dup(data.readFileDescriptor()); // -1 fd checked in makeIDataSource
+ const int64_t offset = data.readInt64();
+ const int64_t length = data.readInt64();
+ ALOGV("fd %d offset%lld length:%lld", fd, (long long)offset, (long long)length);
+ sp<IDataSource> source = makeIDataSource(fd, offset, length);
+ reply->writeStrongBinder(IInterface::asBinder(source));
+ // The FileSource closes the descriptor, so if it is not created
+ // we need to close the descriptor explicitly.
+ if (source.get() == nullptr && fd != -1) {
+ close(fd);
+ }
+ return NO_ERROR;
+ }
+
default:
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/media/libmedia/include/DrmPluginPath.h b/media/libmedia/include/DrmPluginPath.h
new file mode 100644
index 0000000..51ba26e
--- /dev/null
+++ b/media/libmedia/include/DrmPluginPath.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2017 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 DRM_PLUGIN_PATH_H_
+
+#define DRM_PLUGIN_PATH_H_
+
+namespace android {
+
+const char* getDrmPluginPath();
+
+} // namespace android
+
+#endif // DRM_PLUGIN_PATH_H_
diff --git a/media/libmedia/include/IMediaExtractorService.h b/media/libmedia/include/IMediaExtractorService.h
index 4d7b317..45e9620 100644
--- a/media/libmedia/include/IMediaExtractorService.h
+++ b/media/libmedia/include/IMediaExtractorService.h
@@ -32,6 +32,7 @@
virtual sp<IMediaExtractor> makeExtractor(const sp<IDataSource> &source, const char *mime) = 0;
+ virtual sp<IDataSource> makeIDataSource(int fd, int64_t offset, int64_t length) = 0;
};
class BnMediaExtractorService: public BnInterface<IMediaExtractorService>
diff --git a/media/libmedia/omx/1.0/WOmxNode.cpp b/media/libmedia/omx/1.0/WOmxNode.cpp
index b5186b5..6c92b52 100644
--- a/media/libmedia/omx/1.0/WOmxNode.cpp
+++ b/media/libmedia/omx/1.0/WOmxNode.cpp
@@ -411,7 +411,7 @@
getExtensionIndex_cb _hidl_cb) {
OMX_INDEXTYPE index;
Status status = toStatus(mBase->getExtensionIndex(
- parameterName, &index));
+ parameterName.c_str(), &index));
_hidl_cb(status, toRawIndexType(index));
return Void();
}
diff --git a/media/libmediametrics/Android.mk b/media/libmediametrics/Android.mk
new file mode 100644
index 0000000..f8c4bb3
--- /dev/null
+++ b/media/libmediametrics/Android.mk
@@ -0,0 +1,34 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES += \
+ IMediaAnalyticsService.cpp \
+ MediaAnalyticsItem.cpp \
+
+LOCAL_SHARED_LIBRARIES := \
+ liblog libcutils libutils libbinder \
+ libstagefright_foundation \
+ libbase \
+
+LOCAL_MODULE:= libmediametrics
+
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
+
+LOCAL_C_INCLUDES := \
+ $(TOP)/system/libhidl/base/include \
+ $(TOP)/frameworks/native/include/media/openmax \
+ $(TOP)/frameworks/av/include/media/ \
+ $(TOP)/frameworks/av/media/libmedia/aidl \
+ $(TOP)/frameworks/av/include \
+ $(TOP)/frameworks/native/include \
+ $(call include-path-for, audio-utils)
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := \
+ frameworks/av/include/media \
+
+LOCAL_CFLAGS += -Werror -Wno-error=deprecated-declarations -Wall
+LOCAL_SANITIZE := unsigned-integer-overflow signed-integer-overflow cfi
+LOCAL_SANITIZE_DIAG := cfi
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/media/libmedia/IMediaAnalyticsService.cpp b/media/libmediametrics/IMediaAnalyticsService.cpp
similarity index 94%
rename from media/libmedia/IMediaAnalyticsService.cpp
rename to media/libmediametrics/IMediaAnalyticsService.cpp
index 340cf19..68bafe1 100644
--- a/media/libmedia/IMediaAnalyticsService.cpp
+++ b/media/libmediametrics/IMediaAnalyticsService.cpp
@@ -23,15 +23,6 @@
#include <binder/Parcel.h>
#include <binder/IMemory.h>
#include <binder/IPCThreadState.h>
-#include <media/IHDCP.h>
-#include <media/IMediaCodecList.h>
-#include <media/IMediaHTTPService.h>
-#include <media/IMediaPlayerService.h>
-#include <media/IMediaRecorder.h>
-#include <media/IOMX.h>
-#include <media/IRemoteDisplay.h>
-#include <media/IRemoteDisplayClient.h>
-#include <media/IStreamSource.h>
#include <utils/Errors.h> // for status_t
#include <utils/List.h>
diff --git a/media/libmedia/MediaAnalyticsItem.cpp b/media/libmediametrics/MediaAnalyticsItem.cpp
similarity index 100%
rename from media/libmedia/MediaAnalyticsItem.cpp
rename to media/libmediametrics/MediaAnalyticsItem.cpp
diff --git a/media/libmedia/include/IMediaAnalyticsService.h b/media/libmediametrics/include/IMediaAnalyticsService.h
similarity index 100%
rename from media/libmedia/include/IMediaAnalyticsService.h
rename to media/libmediametrics/include/IMediaAnalyticsService.h
diff --git a/media/libmedia/include/MediaAnalyticsItem.h b/media/libmediametrics/include/MediaAnalyticsItem.h
similarity index 100%
rename from media/libmedia/include/MediaAnalyticsItem.h
rename to media/libmediametrics/include/MediaAnalyticsItem.h
diff --git a/media/libmediaplayerservice/Android.mk b/media/libmediaplayerservice/Android.mk
index f7e1ff5..7af7031 100644
--- a/media/libmediaplayerservice/Android.mk
+++ b/media/libmediaplayerservice/Android.mk
@@ -27,6 +27,7 @@
libgui \
libaudioclient \
libmedia \
+ libmediametrics \
libmediadrm \
libmediautils \
libmemunreachable \
diff --git a/media/libmediaplayerservice/MediaPlayerService.cpp b/media/libmediaplayerservice/MediaPlayerService.cpp
index f3fc924..b082654 100644
--- a/media/libmediaplayerservice/MediaPlayerService.cpp
+++ b/media/libmediaplayerservice/MediaPlayerService.cpp
@@ -736,9 +736,7 @@
mExtractorDeathListener = new ServiceDeathNotifier(binder, p, MEDIAEXTRACTOR_PROCESS_DEATH);
binder->linkToDeath(mExtractorDeathListener);
- int32_t trebleOmx = property_get_int32("persist.media.treble_omx", -1);
- if ((trebleOmx == 1) || ((trebleOmx == -1) &&
- property_get_bool("persist.hal.binderization", 0))) {
+ if (property_get_bool("persist.media.treble_omx", true)) {
// Treble IOmx
sp<IOmx> omx = IOmx::getService();
if (omx == nullptr) {
diff --git a/media/libmediaplayerservice/MediaRecorderClient.cpp b/media/libmediaplayerservice/MediaRecorderClient.cpp
index 638eec3..6400481 100644
--- a/media/libmediaplayerservice/MediaRecorderClient.cpp
+++ b/media/libmediaplayerservice/MediaRecorderClient.cpp
@@ -450,9 +450,7 @@
}
sCameraChecked = true;
- int32_t trebleOmx = property_get_int32("persist.media.treble_omx", -1);
- if ((trebleOmx == 1) || ((trebleOmx == -1) &&
- property_get_bool("persist.hal.binderization", 0))) {
+ if (property_get_bool("persist.media.treble_omx", true)) {
// Treble IOmx
sp<IOmx> omx = IOmx::getService();
if (omx == nullptr) {
diff --git a/media/libmediaplayerservice/StagefrightRecorder.cpp b/media/libmediaplayerservice/StagefrightRecorder.cpp
index f689ac9..95f378f 100644
--- a/media/libmediaplayerservice/StagefrightRecorder.cpp
+++ b/media/libmediaplayerservice/StagefrightRecorder.cpp
@@ -397,13 +397,13 @@
// Attempt to parse an float literal optionally surrounded by whitespace,
// returns true on success, false otherwise.
-static bool safe_strtof(const char *s, float *val) {
+static bool safe_strtod(const char *s, double *val) {
char *end;
// It is lame, but according to man page, we have to set errno to 0
- // before calling strtof().
+ // before calling strtod().
errno = 0;
- *val = strtof(s, &end);
+ *val = strtod(s, &end);
if (end == s || errno == ERANGE) {
return false;
@@ -706,13 +706,23 @@
return OK;
}
-status_t StagefrightRecorder::setParamCaptureFps(float fps) {
+status_t StagefrightRecorder::setParamCaptureFps(double fps) {
ALOGV("setParamCaptureFps: %.2f", fps);
- int64_t timeUs = (int64_t) (1000000.0 / fps + 0.5f);
+ constexpr int64_t k1E12 = 1000000000000ll;
+ int64_t fpsx1e12 = k1E12 * fps;
+ if (fpsx1e12 == 0) {
+ ALOGE("FPS is zero or too small");
+ return BAD_VALUE;
+ }
- // Not allowing time more than a day
- if (timeUs <= 0 || timeUs > 86400*1E6) {
+ // This does not overflow since 10^6 * 10^12 < 2^63
+ int64_t timeUs = 1000000ll * k1E12 / fpsx1e12;
+
+ // Not allowing time more than a day and a millisecond for error margin.
+ // Note: 1e12 / 86400 = 11574074.(074) and 1e18 / 11574074 = 86400000553;
+ // therefore 1 ms of margin should be sufficient.
+ if (timeUs <= 0 || timeUs > 86400001000ll) {
ALOGE("Time between frame capture (%lld) is out of range [0, 1 Day]", (long long)timeUs);
return BAD_VALUE;
}
@@ -846,8 +856,8 @@
return setParamCaptureFpsEnable(captureFpsEnable);
}
} else if (key == "time-lapse-fps") {
- float fps;
- if (safe_strtof(value.string(), &fps)) {
+ double fps;
+ if (safe_strtod(value.string(), &fps)) {
return setParamCaptureFps(fps);
}
} else {
@@ -2073,7 +2083,7 @@
mMaxFileSizeBytes = 0;
mTrackEveryTimeDurationUs = 0;
mCaptureFpsEnable = false;
- mCaptureFps = 0.0f;
+ mCaptureFps = 0.0;
mTimeBetweenCaptureUs = -1;
mCameraSourceTimeLapse = NULL;
mMetaDataStoredInVideoBuffers = kMetadataBufferTypeInvalid;
diff --git a/media/libmediaplayerservice/StagefrightRecorder.h b/media/libmediaplayerservice/StagefrightRecorder.h
index 38377d2..9a6c4da 100644
--- a/media/libmediaplayerservice/StagefrightRecorder.h
+++ b/media/libmediaplayerservice/StagefrightRecorder.h
@@ -122,7 +122,7 @@
int32_t mTotalBitRate;
bool mCaptureFpsEnable;
- float mCaptureFps;
+ double mCaptureFps;
int64_t mTimeBetweenCaptureUs;
sp<CameraSourceTimeLapse> mCameraSourceTimeLapse;
@@ -172,7 +172,7 @@
status_t setParamAudioSamplingRate(int32_t sampleRate);
status_t setParamAudioTimeScale(int32_t timeScale);
status_t setParamCaptureFpsEnable(int32_t timeLapseEnable);
- status_t setParamCaptureFps(float fps);
+ status_t setParamCaptureFps(double fps);
status_t setParamVideoEncodingBitRate(int32_t bitRate);
status_t setParamVideoIFramesInterval(int32_t seconds);
status_t setParamVideoEncoderProfile(int32_t profile);
diff --git a/media/libmediaplayerservice/nuplayer/GenericSource.cpp b/media/libmediaplayerservice/nuplayer/GenericSource.cpp
index 8378d24..aedca3f 100644
--- a/media/libmediaplayerservice/nuplayer/GenericSource.cpp
+++ b/media/libmediaplayerservice/nuplayer/GenericSource.cpp
@@ -21,7 +21,9 @@
#include "NuPlayerDrm.h"
#include "AnotherPacketSource.h"
-
+#include <binder/IServiceManager.h>
+#include <cutils/properties.h>
+#include <media/IMediaExtractorService.h>
#include <media/IMediaHTTPService.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h>
@@ -361,7 +363,32 @@
mHTTPService, uri, &mUriHeaders, &contentType,
static_cast<HTTPBase *>(mHttpSource.get()));
} else {
- mDataSource = new FileSource(mFd, mOffset, mLength);
+ if (property_get_bool("media.stagefright.extractremote", true) &&
+ !FileSource::requiresDrm(mFd, mOffset, mLength, nullptr /* mime */)) {
+ sp<IBinder> binder =
+ defaultServiceManager()->getService(String16("media.extractor"));
+ if (binder != nullptr) {
+ ALOGD("FileSource remote");
+ sp<IMediaExtractorService> mediaExService(
+ interface_cast<IMediaExtractorService>(binder));
+ sp<IDataSource> source =
+ mediaExService->makeIDataSource(mFd, mOffset, mLength);
+ ALOGV("IDataSource(FileSource): %p %d %lld %lld",
+ source.get(), mFd, (long long)mOffset, (long long)mLength);
+ if (source.get() != nullptr) {
+ mDataSource = DataSource::CreateFromIDataSource(source);
+ } else {
+ ALOGW("extractor service cannot make data source");
+ }
+ } else {
+ ALOGW("extractor service not running");
+ }
+ }
+ if (mDataSource == nullptr) {
+ ALOGD("FileSource local");
+ mDataSource = new FileSource(mFd, mOffset, mLength);
+ }
+
mFd = -1;
}
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
index 50d5343..2c37aed 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
@@ -1535,8 +1535,6 @@
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);
}
@@ -1619,7 +1617,8 @@
// is possible; otherwise the decoders call the renderer openAudioSink directly.
status_t err = mRenderer->openAudioSink(
- format, true /* offloadOnly */, hasVideo, AUDIO_OUTPUT_FLAG_NONE, &mOffloadAudio);
+ format, true /* offloadOnly */, hasVideo,
+ AUDIO_OUTPUT_FLAG_NONE, &mOffloadAudio, mSource->isStreaming());
if (err != OK) {
// Any failure we turn off mOffloadAudio.
mOffloadAudio = false;
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp
index 9a2224e..9e579f9 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerDecoder.cpp
@@ -762,8 +762,7 @@
int64_t durationUs;
bool hasVideo = (mSource->getFormat(false /* audio */) != NULL);
if (getAudioDeepBufferSetting() // override regardless of source duration
- || (!hasVideo
- && mSource->getDuration(&durationUs) == OK
+ || (mSource->getDuration(&durationUs) == OK
&& durationUs > AUDIO_SINK_MIN_DEEP_BUFFER_DURATION_US)) {
flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
} else {
@@ -773,7 +772,8 @@
sp<AMessage> reply = new AMessage(kWhatAudioOutputFormatChanged, this);
reply->setInt32("generation", mBufferGeneration);
mRenderer->changeAudioFormat(
- format, false /* offloadOnly */, hasVideo, flags, reply);
+ format, false /* offloadOnly */, hasVideo,
+ flags, mSource->isStreaming(), reply);
}
}
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDecoderPassThrough.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerDecoderPassThrough.cpp
index cb668e4..6b05b53 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerDecoderPassThrough.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerDecoderPassThrough.cpp
@@ -76,7 +76,7 @@
// format is different.
status_t err = mRenderer->openAudioSink(
format, true /* offloadOnly */, hasVideo,
- AUDIO_OUTPUT_FLAG_NONE /* flags */, NULL /* isOffloaded */);
+ AUDIO_OUTPUT_FLAG_NONE /* flags */, NULL /* isOffloaded */, mSource->isStreaming());
if (err != OK) {
handleError(err);
}
@@ -294,6 +294,9 @@
return;
}
+ if (streamErr != ERROR_END_OF_STREAM) {
+ handleError(streamErr);
+ }
mReachedEOS = true;
if (mRenderer != NULL) {
mRenderer->queueEOS(true /* audio */, ERROR_END_OF_STREAM);
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
index 66b64f8..01008b4 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
@@ -583,8 +583,12 @@
return;
}
- // only bother to log non-empty records
- if (mAnalyticsItem->count() > 0) {
+ // log only non-empty records
+ // we always updateMetrics() before we get here
+ // and that always injects 2 fields (duration and playing time) into
+ // the record.
+ // So the canonical "empty" record has 2 elements in it.
+ if (mAnalyticsItem->count() > 2) {
mAnalyticsItem->setFinalized(true);
mAnalyticsItem->selfrecord();
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp
index 9350440..9fe61703 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp
@@ -397,12 +397,14 @@
bool offloadOnly,
bool hasVideo,
uint32_t flags,
- bool *isOffloaded) {
+ bool *isOffloaded,
+ bool isStreaming) {
sp<AMessage> msg = new AMessage(kWhatOpenAudioSink, this);
msg->setMessage("format", format);
msg->setInt32("offload-only", offloadOnly);
msg->setInt32("has-video", hasVideo);
msg->setInt32("flags", flags);
+ msg->setInt32("isStreaming", isStreaming);
sp<AMessage> response;
status_t postStatus = msg->postAndAwaitResponse(&response);
@@ -430,12 +432,14 @@
bool offloadOnly,
bool hasVideo,
uint32_t flags,
+ bool isStreaming,
const sp<AMessage> ¬ify) {
sp<AMessage> meta = new AMessage;
meta->setMessage("format", format);
meta->setInt32("offload-only", offloadOnly);
meta->setInt32("has-video", hasVideo);
meta->setInt32("flags", flags);
+ meta->setInt32("isStreaming", isStreaming);
sp<AMessage> msg = new AMessage(kWhatChangeAudioFormat, this);
msg->setInt32("queueGeneration", getQueueGeneration(true /* audio */));
@@ -460,7 +464,10 @@
uint32_t flags;
CHECK(msg->findInt32("flags", (int32_t *)&flags));
- status_t err = onOpenAudioSink(format, offloadOnly, hasVideo, flags);
+ uint32_t isStreaming;
+ CHECK(msg->findInt32("isStreaming", (int32_t *)&isStreaming));
+
+ status_t err = onOpenAudioSink(format, offloadOnly, hasVideo, flags, isStreaming);
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
@@ -1838,7 +1845,8 @@
const sp<AMessage> &format,
bool offloadOnly,
bool hasVideo,
- uint32_t flags) {
+ uint32_t flags,
+ bool isStreaming) {
ALOGV("openAudioSink: offloadOnly(%d) offloadingAudio(%d)",
offloadOnly, offloadingAudio());
bool audioSinkChanged = false;
@@ -1891,7 +1899,7 @@
offloadInfo.stream_type = AUDIO_STREAM_MUSIC;
offloadInfo.bit_rate = avgBitRate;
offloadInfo.has_video = hasVideo;
- offloadInfo.is_streaming = true;
+ offloadInfo.is_streaming = isStreaming;
if (memcmp(&mCurrentOffloadInfo, &offloadInfo, sizeof(offloadInfo)) == 0) {
ALOGV("openAudioSink: no change in offload mode");
@@ -2043,7 +2051,10 @@
uint32_t flags;
CHECK(meta->findInt32("flags", (int32_t *)&flags));
- status_t err = onOpenAudioSink(format, offloadOnly, hasVideo, flags);
+ uint32_t isStreaming;
+ CHECK(meta->findInt32("isStreaming", (int32_t *)&isStreaming));
+
+ status_t err = onOpenAudioSink(format, offloadOnly, hasVideo, flags, isStreaming);
if (err != OK) {
notify->setInt32("err", err);
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.h b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.h
index 385bb06..e6850b5 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.h
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.h
@@ -76,7 +76,8 @@
bool offloadOnly,
bool hasVideo,
uint32_t flags,
- bool *isOffloaded);
+ bool *isOffloaded,
+ bool isStreaming);
void closeAudioSink();
// re-open audio sink after all pending audio buffers played.
@@ -85,6 +86,7 @@
bool offloadOnly,
bool hasVideo,
uint32_t flags,
+ bool isStreaming,
const sp<AMessage> ¬ify);
enum {
@@ -267,7 +269,8 @@
const sp<AMessage> &format,
bool offloadOnly,
bool hasVideo,
- uint32_t flags);
+ uint32_t flags,
+ bool isStreaming);
void onCloseAudioSink();
void onChangeAudioFormat(const sp<AMessage> &meta, const sp<AMessage> ¬ify);
diff --git a/media/libstagefright/ACodec.cpp b/media/libstagefright/ACodec.cpp
index 37e1546..f2cc4f7 100644
--- a/media/libstagefright/ACodec.cpp
+++ b/media/libstagefright/ACodec.cpp
@@ -1211,7 +1211,7 @@
break;
}
- sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(buf, false));
+ sp<GraphicBuffer> graphicBuffer(GraphicBuffer::from(buf));
BufferInfo info;
info.mStatus = BufferInfo::OWNED_BY_US;
info.mFenceFd = fenceFd;
@@ -1515,7 +1515,7 @@
CHECK(storingMetadataInDecodedBuffers());
// discard buffer in LRU info and replace with new buffer
- oldest->mGraphicBuffer = new GraphicBuffer(buf, false);
+ oldest->mGraphicBuffer = GraphicBuffer::from(buf);
oldest->mNewGraphicBuffer = true;
oldest->mStatus = BufferInfo::OWNED_BY_US;
oldest->setWriteFence(fenceFd, "dequeueBufferFromNativeWindow for oldest");
@@ -5728,8 +5728,7 @@
case IOMX::kPortModeDynamicANWBuffer:
if (info->mCodecData->size() >= sizeof(VideoNativeMetadata)) {
VideoNativeMetadata *vnmd = (VideoNativeMetadata*)info->mCodecData->base();
- sp<GraphicBuffer> graphicBuffer = new GraphicBuffer(
- vnmd->pBuffer, false /* keepOwnership */);
+ sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(vnmd->pBuffer);
err2 = mCodec->mOMXNode->emptyBuffer(
bufferID, graphicBuffer, flags, timeUs, info->mFenceFd);
}
diff --git a/media/libstagefright/Android.mk b/media/libstagefright/Android.mk
index 18cfc0e..bdc37a5 100644
--- a/media/libstagefright/Android.mk
+++ b/media/libstagefright/Android.mk
@@ -86,6 +86,7 @@
liblog \
libmedia \
libaudioclient \
+ libmediametrics \
libmediautils \
libnetd_client \
libsonivox \
diff --git a/media/libstagefright/CallbackDataSource.cpp b/media/libstagefright/CallbackDataSource.cpp
index 0434bab..4309372 100644
--- a/media/libstagefright/CallbackDataSource.cpp
+++ b/media/libstagefright/CallbackDataSource.cpp
@@ -113,6 +113,10 @@
return mIDataSource->DrmInitialization(mime);
}
+sp<IDataSource> CallbackDataSource::getIDataSource() const {
+ return mIDataSource;
+}
+
TinyCacheSource::TinyCacheSource(const sp<DataSource>& source)
: mSource(source), mCachedOffset(0), mCachedSize(0) {
mName = String8::format("TinyCacheSource(%s)", mSource->toString().string());
@@ -190,4 +194,9 @@
mCachedSize = 0;
return mSource->DrmInitialization(mime);
}
+
+sp<IDataSource> TinyCacheSource::getIDataSource() const {
+ return mSource->getIDataSource();
+}
+
} // namespace android
diff --git a/media/libstagefright/CameraSource.cpp b/media/libstagefright/CameraSource.cpp
index 0fe44eb..a569f5d 100644
--- a/media/libstagefright/CameraSource.cpp
+++ b/media/libstagefright/CameraSource.cpp
@@ -58,6 +58,10 @@
virtual void postRecordingFrameHandleTimestamp(nsecs_t timestamp, native_handle_t* handle);
+ virtual void postRecordingFrameHandleTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles);
+
protected:
virtual ~CameraSourceListener();
@@ -110,6 +114,20 @@
}
}
+void CameraSourceListener::postRecordingFrameHandleTimestampBatch(
+ const std::vector<nsecs_t>& timestamps,
+ const std::vector<native_handle_t*>& handles) {
+ sp<CameraSource> source = mSource.promote();
+ if (source.get() != nullptr) {
+ int n = timestamps.size();
+ std::vector<nsecs_t> modifiedTimestamps(n);
+ for (int i = 0; i < n; i++) {
+ modifiedTimestamps[i] = timestamps[i] / 1000;
+ }
+ source->recordingFrameHandleCallbackTimestampBatch(modifiedTimestamps, handles);
+ }
+}
+
static int32_t getColorFormat(const char* colorFormat) {
if (!colorFormat) {
ALOGE("Invalid color format");
@@ -952,10 +970,35 @@
}
if (handle != nullptr) {
- // Frame contains a VideoNativeHandleMetadata. Send the handle back to camera.
- releaseRecordingFrameHandle(handle);
- mMemoryBases.push_back(frame);
- mMemoryBaseAvailableCond.signal();
+ uint32_t batchSize = 0;
+ {
+ Mutex::Autolock autoLock(mBatchLock);
+ if (mInflightBatchSizes.size() > 0) {
+ batchSize = mInflightBatchSizes[0];
+ }
+ }
+ if (batchSize == 0) { // return buffers one by one
+ // Frame contains a VideoNativeHandleMetadata. Send the handle back to camera.
+ releaseRecordingFrameHandle(handle);
+ mMemoryBases.push_back(frame);
+ mMemoryBaseAvailableCond.signal();
+ } else { // Group buffers in batch then return
+ Mutex::Autolock autoLock(mBatchLock);
+ mInflightReturnedHandles.push_back(handle);
+ mInflightReturnedMemorys.push_back(frame);
+ if (mInflightReturnedHandles.size() == batchSize) {
+ releaseRecordingFrameHandleBatch(mInflightReturnedHandles);
+
+ mInflightBatchSizes.pop_front();
+ mInflightReturnedHandles.clear();
+ for (const auto& mem : mInflightReturnedMemorys) {
+ mMemoryBases.push_back(mem);
+ mMemoryBaseAvailableCond.signal();
+ }
+ mInflightReturnedMemorys.clear();
+ }
+ }
+
} else if (mCameraRecordingProxy != nullptr) {
// mCamera is created by application. Return the frame back to camera via camera
// recording proxy.
@@ -1126,6 +1169,21 @@
}
}
+void CameraSource::releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {
+ if (mCameraRecordingProxy != nullptr) {
+ mCameraRecordingProxy->releaseRecordingFrameHandleBatch(handles);
+ } else if (mCamera != nullptr) {
+ int64_t token = IPCThreadState::self()->clearCallingIdentity();
+ mCamera->releaseRecordingFrameHandleBatch(handles);
+ IPCThreadState::self()->restoreCallingIdentity(token);
+ } else {
+ for (auto& handle : handles) {
+ native_handle_close(handle);
+ native_handle_delete(handle);
+ }
+ }
+}
+
void CameraSource::recordingFrameHandleCallbackTimestamp(int64_t timestampUs,
native_handle_t* handle) {
ALOGV("%s: timestamp %lld us", __FUNCTION__, (long long)timestampUs);
@@ -1163,6 +1221,62 @@
mFrameAvailableCondition.signal();
}
+void CameraSource::recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<int64_t>& timestampsUs,
+ const std::vector<native_handle_t*>& handles) {
+ size_t n = timestampsUs.size();
+ if (n != handles.size()) {
+ ALOGE("%s: timestampsUs(%zu) and handles(%zu) size mismatch!",
+ __FUNCTION__, timestampsUs.size(), handles.size());
+ }
+
+ Mutex::Autolock autoLock(mLock);
+ int batchSize = 0;
+ for (size_t i = 0; i < n; i++) {
+ int64_t timestampUs = timestampsUs[i];
+ native_handle_t* handle = handles[i];
+
+ ALOGV("%s: timestamp %lld us", __FUNCTION__, (long long)timestampUs);
+ if (handle == nullptr) continue;
+
+ if (shouldSkipFrameLocked(timestampUs)) {
+ releaseRecordingFrameHandle(handle);
+ continue;
+ }
+
+ while (mMemoryBases.empty()) {
+ if (mMemoryBaseAvailableCond.waitRelative(mLock, kMemoryBaseAvailableTimeoutNs) ==
+ TIMED_OUT) {
+ ALOGW("Waiting on an available memory base timed out. Dropping a recording frame.");
+ releaseRecordingFrameHandle(handle);
+ continue;
+ }
+ }
+ ++batchSize;
+ ++mNumFramesReceived;
+ sp<IMemory> data = *mMemoryBases.begin();
+ mMemoryBases.erase(mMemoryBases.begin());
+
+ // Wrap native handle in sp<IMemory> so it can be pushed to mFramesReceived.
+ VideoNativeHandleMetadata *metadata = (VideoNativeHandleMetadata*)(data->pointer());
+ metadata->eType = kMetadataBufferTypeNativeHandleSource;
+ metadata->pHandle = handle;
+
+ mFramesReceived.push_back(data);
+ int64_t timeUs = mStartTimeUs + (timestampUs - mFirstFrameTimeUs);
+ mFrameTimes.push_back(timeUs);
+ ALOGV("initial delay: %" PRId64 ", current time stamp: %" PRId64, mStartTimeUs, timeUs);
+
+ }
+ if (batchSize > 0) {
+ Mutex::Autolock autoLock(mBatchLock);
+ mInflightBatchSizes.push_back(batchSize);
+ }
+ for (int i = 0; i < batchSize; i++) {
+ mFrameAvailableCondition.signal();
+ }
+}
+
CameraSource::BufferQueueListener::BufferQueueListener(const sp<BufferItemConsumer>& consumer,
const sp<CameraSource>& cameraSource) {
mConsumer = consumer;
@@ -1279,6 +1393,17 @@
mSource->recordingFrameHandleCallbackTimestamp(timestamp / 1000, handle);
}
+void CameraSource::ProxyListener::recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<int64_t>& timestampsUs,
+ const std::vector<native_handle_t*>& handles) {
+ int n = timestampsUs.size();
+ std::vector<nsecs_t> modifiedTimestamps(n);
+ for (int i = 0; i < n; i++) {
+ modifiedTimestamps[i] = timestampsUs[i] / 1000;
+ }
+ mSource->recordingFrameHandleCallbackTimestampBatch(modifiedTimestamps, handles);
+}
+
void CameraSource::DeathNotifier::binderDied(const wp<IBinder>& who __unused) {
ALOGI("Camera recording proxy died");
}
diff --git a/media/libstagefright/CameraSourceTimeLapse.cpp b/media/libstagefright/CameraSourceTimeLapse.cpp
index 390c556..970526a 100644
--- a/media/libstagefright/CameraSourceTimeLapse.cpp
+++ b/media/libstagefright/CameraSourceTimeLapse.cpp
@@ -315,6 +315,17 @@
CameraSource::recordingFrameHandleCallbackTimestamp(timestampUs, handle);
}
+void CameraSourceTimeLapse::recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<int64_t>& timestampsUs,
+ const std::vector<native_handle_t*>& handles) {
+ ALOGV("recordingFrameHandleCallbackTimestampBatch");
+ int n = timestampsUs.size();
+ for (int i = 0; i < n; i++) {
+ // Don't do batching for CameraSourceTimeLapse for now
+ recordingFrameHandleCallbackTimestamp(timestampsUs[i], handles[i]);
+ }
+}
+
void CameraSourceTimeLapse::processBufferQueueFrame(BufferItem& buffer) {
ALOGV("processBufferQueueFrame");
int64_t timestampUs = buffer.mTimestamp / 1000;
diff --git a/media/libstagefright/DataSource.cpp b/media/libstagefright/DataSource.cpp
index ded79f3..a5760d1 100644
--- a/media/libstagefright/DataSource.cpp
+++ b/media/libstagefright/DataSource.cpp
@@ -20,6 +20,7 @@
#include "include/HTTPBase.h"
#include "include/NuCachedSource2.h"
+#include <media/IDataSource.h>
#include <media/IMediaHTTPConnection.h>
#include <media/IMediaHTTPService.h>
#include <media/stagefright/foundation/ADebug.h>
@@ -29,6 +30,7 @@
#include <media/stagefright/FileSource.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MediaHTTP.h>
+#include <media/stagefright/RemoteDataSource.h>
#include <media/stagefright/Utils.h>
#include <utils/String8.h>
@@ -36,8 +38,6 @@
#include <private/android_filesystem_config.h>
-#include <arpa/inet.h>
-
namespace android {
bool DataSource::getUInt16(off64_t offset, uint16_t *x) {
@@ -98,6 +98,10 @@
return ERROR_UNSUPPORTED;
}
+sp<IDataSource> DataSource::getIDataSource() const {
+ return nullptr;
+}
+
////////////////////////////////////////////////////////////////////////////////
// static
@@ -167,6 +171,11 @@
return source;
}
+sp<DataSource> DataSource::CreateFromFd(int fd, int64_t offset, int64_t length) {
+ sp<FileSource> source = new FileSource(fd, offset, length);
+ return source->initCheck() != OK ? nullptr : source;
+}
+
sp<DataSource> DataSource::CreateMediaHTTP(const sp<IMediaHTTPService> &httpService) {
if (httpService == NULL) {
return NULL;
@@ -188,4 +197,8 @@
return String8("application/octet-stream");
}
+sp<IDataSource> DataSource::asIDataSource() {
+ return RemoteDataSource::wrap(sp<DataSource>(this));
+}
+
} // namespace android
diff --git a/media/libstagefright/FileSource.cpp b/media/libstagefright/FileSource.cpp
index 5b92f91..97d8988 100644
--- a/media/libstagefright/FileSource.cpp
+++ b/media/libstagefright/FileSource.cpp
@@ -21,6 +21,7 @@
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/FileSource.h>
#include <media/stagefright/Utils.h>
+#include <private/android_filesystem_config.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/types.h>
@@ -171,6 +172,7 @@
}
sp<DecryptHandle> FileSource::DrmInitialization(const char *mime) {
+ if (getuid() == AID_MEDIA_EX) return nullptr; // no DRM in media extractor
if (mDrmManagerClient == NULL) {
mDrmManagerClient = new DrmManagerClient();
}
@@ -227,4 +229,18 @@
return mDrmManagerClient->pread(mDecryptHandle, data, size, offset + mOffset);
}
}
+
+/* static */
+bool FileSource::requiresDrm(int fd, int64_t offset, int64_t length, const char *mime) {
+ std::unique_ptr<DrmManagerClient> drmClient(new DrmManagerClient());
+ sp<DecryptHandle> decryptHandle =
+ drmClient->openDecryptSession(fd, offset, length, mime);
+ bool requiresDrm = false;
+ if (decryptHandle != nullptr) {
+ requiresDrm = decryptHandle->decryptApiType == DecryptApiType::CONTAINER_BASED;
+ drmClient->closeDecryptSession(decryptHandle);
+ }
+ return requiresDrm;
+}
+
} // namespace android
diff --git a/media/libstagefright/MP3Extractor.cpp b/media/libstagefright/MP3Extractor.cpp
index 82e7a26..22df522 100644
--- a/media/libstagefright/MP3Extractor.cpp
+++ b/media/libstagefright/MP3Extractor.cpp
@@ -538,7 +538,7 @@
buffer->release();
buffer = NULL;
- return ERROR_END_OF_STREAM;
+ return (n < 0 ? n : ERROR_END_OF_STREAM);
}
uint32_t header = U32_AT((const uint8_t *)buffer->data());
@@ -582,7 +582,7 @@
buffer->release();
buffer = NULL;
- return ERROR_END_OF_STREAM;
+ return (n < 0 ? n : ERROR_END_OF_STREAM);
}
buffer->set_range(0, frame_size);
diff --git a/media/libstagefright/MPEG4Extractor.cpp b/media/libstagefright/MPEG4Extractor.cpp
index a017737..f2a4d06 100644
--- a/media/libstagefright/MPEG4Extractor.cpp
+++ b/media/libstagefright/MPEG4Extractor.cpp
@@ -3914,7 +3914,8 @@
while (true) {
if (mDataSource->readAt(*offset, hdr, 8) < 8) {
- return ERROR_END_OF_STREAM;
+ // no more box to the end of file.
+ break;
}
chunk_size = ntohl(hdr[0]);
chunk_type = ntohl(hdr[1]);
diff --git a/media/libstagefright/MediaCodecSource.cpp b/media/libstagefright/MediaCodecSource.cpp
index 059a730..bb20850 100644
--- a/media/libstagefright/MediaCodecSource.cpp
+++ b/media/libstagefright/MediaCodecSource.cpp
@@ -940,6 +940,10 @@
CHECK(msg->findInt32("err", &err));
ALOGE("Encoder (%s) reported error : 0x%x",
mIsVideo ? "video" : "audio", err);
+ if (!(mFlags & FLAG_USE_SURFACE_INPUT)) {
+ mStopping = true;
+ mPuller->stop();
+ }
signalEOS();
}
break;
diff --git a/media/libstagefright/MediaExtractor.cpp b/media/libstagefright/MediaExtractor.cpp
index 76775c2..9965462 100644
--- a/media/libstagefright/MediaExtractor.cpp
+++ b/media/libstagefright/MediaExtractor.cpp
@@ -117,74 +117,6 @@
return CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_PAUSE | CAN_SEEK;
}
-
-
-class RemoteDataSource : public BnDataSource {
-public:
- enum {
- kBufferSize = 64 * 1024,
- };
-
- static sp<IDataSource> wrap(const sp<DataSource> &source);
- virtual ~RemoteDataSource();
-
- virtual sp<IMemory> getIMemory();
- virtual ssize_t readAt(off64_t offset, size_t size);
- virtual status_t getSize(off64_t* size);
- virtual void close();
- virtual uint32_t getFlags();
- virtual String8 toString();
- virtual sp<DecryptHandle> DrmInitialization(const char *mime);
-
-private:
- sp<IMemory> mMemory;
- sp<DataSource> mSource;
- String8 mName;
- explicit RemoteDataSource(const sp<DataSource> &source);
- DISALLOW_EVIL_CONSTRUCTORS(RemoteDataSource);
-};
-
-
-sp<IDataSource> RemoteDataSource::wrap(const sp<DataSource> &source) {
- return new RemoteDataSource(source);
-}
-RemoteDataSource::RemoteDataSource(const sp<DataSource> &source) {
- mSource = source;
- sp<MemoryDealer> memoryDealer = new MemoryDealer(kBufferSize, "RemoteDataSource");
- mMemory = memoryDealer->allocate(kBufferSize);
- if (mMemory == NULL) {
- ALOGE("Failed to allocate memory!");
- }
- mName = String8::format("RemoteDataSource(%s)", mSource->toString().string());
-}
-RemoteDataSource::~RemoteDataSource() {
- close();
-}
-sp<IMemory> RemoteDataSource::getIMemory() {
- return mMemory;
-}
-ssize_t RemoteDataSource::readAt(off64_t offset, size_t size) {
- ALOGV("readAt(%" PRId64 ", %zu)", offset, size);
- return mSource->readAt(offset, mMemory->pointer(), size);
-}
-status_t RemoteDataSource::getSize(off64_t* size) {
- return mSource->getSize(size);
-}
-void RemoteDataSource::close() {
- mSource = NULL;
-}
-uint32_t RemoteDataSource::getFlags() {
- return mSource->flags();
-}
-
-String8 RemoteDataSource::toString() {
- return mName;
-}
-
-sp<DecryptHandle> RemoteDataSource::DrmInitialization(const char *mime) {
- return mSource->DrmInitialization(mime);
-}
-
// static
sp<IMediaExtractor> MediaExtractor::Create(
const sp<DataSource> &source, const char *mime) {
@@ -201,7 +133,7 @@
if (binder != 0) {
sp<IMediaExtractorService> mediaExService(interface_cast<IMediaExtractorService>(binder));
- sp<IMediaExtractor> ex = mediaExService->makeExtractor(RemoteDataSource::wrap(source), mime);
+ sp<IMediaExtractor> ex = mediaExService->makeExtractor(source->asIDataSource(), mime);
return ex;
} else {
ALOGE("extractor service not running");
@@ -218,7 +150,7 @@
RegisterDefaultSniffers();
// initialize source decryption if needed
- source->DrmInitialization();
+ source->DrmInitialization(nullptr /* mime */);
sp<AMessage> meta;
diff --git a/media/libstagefright/OMXClient.cpp b/media/libstagefright/OMXClient.cpp
index 1706221..02d275b 100644
--- a/media/libstagefright/OMXClient.cpp
+++ b/media/libstagefright/OMXClient.cpp
@@ -38,9 +38,7 @@
}
status_t OMXClient::connect(bool* trebleFlag) {
- int32_t trebleOmx = property_get_int32("persist.media.treble_omx", -1);
- if ((trebleOmx == 1) || ((trebleOmx == -1) &&
- property_get_bool("persist.hal.binderization", 0))) {
+ if (property_get_bool("persist.media.treble_omx", true)) {
if (trebleFlag != nullptr) {
*trebleFlag = true;
}
diff --git a/media/libstagefright/SurfaceUtils.cpp b/media/libstagefright/SurfaceUtils.cpp
index 82e959e..b6b315d 100644
--- a/media/libstagefright/SurfaceUtils.cpp
+++ b/media/libstagefright/SurfaceUtils.cpp
@@ -176,7 +176,7 @@
break;
}
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+ sp<GraphicBuffer> buf(GraphicBuffer::from(anb));
// Fill the buffer with the a 1x1 checkerboard pattern ;)
uint32_t *img = NULL;
diff --git a/media/libstagefright/include/CallbackDataSource.h b/media/libstagefright/include/CallbackDataSource.h
index 80cd1f7..0d775e6 100644
--- a/media/libstagefright/include/CallbackDataSource.h
+++ b/media/libstagefright/include/CallbackDataSource.h
@@ -42,6 +42,7 @@
return mName;
}
virtual sp<DecryptHandle> DrmInitialization(const char *mime = NULL);
+ virtual sp<IDataSource> getIDataSource() const;
private:
sp<IDataSource> mIDataSource;
@@ -70,6 +71,7 @@
return mName;
}
virtual sp<DecryptHandle> DrmInitialization(const char *mime = NULL);
+ virtual sp<IDataSource> getIDataSource() const;
private:
// 2kb comes from experimenting with the time-to-first-frame from a MediaPlayer
diff --git a/media/libstagefright/include/CameraSource.h b/media/libstagefright/include/CameraSource.h
index c604f2d..aa56d27 100644
--- a/media/libstagefright/include/CameraSource.h
+++ b/media/libstagefright/include/CameraSource.h
@@ -18,6 +18,7 @@
#define CAMERA_SOURCE_H_
+#include <deque>
#include <media/stagefright/MediaBuffer.h>
#include <media/stagefright/MediaSource.h>
#include <camera/android/hardware/ICamera.h>
@@ -141,6 +142,9 @@
const sp<IMemory> &data);
virtual void recordingFrameHandleCallbackTimestamp(int64_t timestampUs,
native_handle_t* handle);
+ virtual void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<int64_t>& timestampsUs,
+ const std::vector<native_handle_t*>& handles);
private:
sp<CameraSource> mSource;
@@ -213,6 +217,8 @@
virtual status_t startCameraRecording();
virtual void releaseRecordingFrame(const sp<IMemory>& frame);
virtual void releaseRecordingFrameHandle(native_handle_t* handle);
+ // stagefright recorder not using this for now
+ virtual void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles);
// Returns true if need to skip the current frame.
// Called from dataCallbackTimestamp.
@@ -227,6 +233,10 @@
virtual void recordingFrameHandleCallbackTimestamp(int64_t timestampUs,
native_handle_t* handle);
+ virtual void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<int64_t>& timestampsUs,
+ const std::vector<native_handle_t*>& handles);
+
// Process a buffer item received in BufferQueueListener.
virtual void processBufferQueueFrame(BufferItem& buffer);
@@ -271,6 +281,13 @@
KeyedVector<ANativeWindowBuffer*, BufferItem> mReceivedBufferItemMap;
sp<BufferQueueListener> mBufferQueueListener;
+ Mutex mBatchLock; // protecting access to mInflightXXXXX members below
+ // Start of members protected by mBatchLock
+ std::deque<uint32_t> mInflightBatchSizes;
+ std::vector<native_handle_t*> mInflightReturnedHandles;
+ std::vector<const sp<IMemory>> mInflightReturnedMemorys;
+ // End of members protected by mBatchLock
+
void releaseQueuedFrames();
void releaseOneRecordingFrame(const sp<IMemory>& frame);
void createVideoBufferMemoryHeap(size_t size, uint32_t bufferCount);
diff --git a/media/libstagefright/include/CameraSourceTimeLapse.h b/media/libstagefright/include/CameraSourceTimeLapse.h
index 871c1d9..b066f9a 100644
--- a/media/libstagefright/include/CameraSourceTimeLapse.h
+++ b/media/libstagefright/include/CameraSourceTimeLapse.h
@@ -147,12 +147,23 @@
// In the video camera case calls skipFrameAndModifyTimeStamp() to modify
// timestamp and set mSkipCurrentFrame.
- // Then it calls the base CameraSource::recordingFrameHandleCallbackTimestamp()
+ // Then it calls the base CameraSource::recordingFrameHandleCallbackTimestamp() or
+ // CameraSource::recordingFrameHandleCallbackTimestampBatch()
// This will be called in VIDEO_BUFFER_MODE_DATA_CALLBACK_METADATA mode when
// the metadata is VideoNativeHandleMetadata.
virtual void recordingFrameHandleCallbackTimestamp(int64_t timestampUs,
native_handle_t* handle);
+ // In the video camera case calls skipFrameAndModifyTimeStamp() to modify
+ // timestamp and set mSkipCurrentFrame.
+ // Then it calls the base CameraSource::recordingFrameHandleCallbackTimestamp() or
+ // CameraSource::recordingFrameHandleCallbackTimestampBatch()
+ // This will be called in VIDEO_BUFFER_MODE_DATA_CALLBACK_METADATA mode when
+ // the metadata is VideoNativeHandleMetadata.
+ virtual void recordingFrameHandleCallbackTimestampBatch(
+ const std::vector<int64_t>& timestampsUs,
+ const std::vector<native_handle_t*>& handles);
+
// Process a buffer item received in CameraSource::BufferQueueListener.
// This will be called in VIDEO_BUFFER_MODE_BUFFER_QUEUE mode.
virtual void processBufferQueueFrame(BufferItem& buffer);
diff --git a/media/libstagefright/include/DataSource.h b/media/libstagefright/include/DataSource.h
index e7135a2..8f2c7eb 100644
--- a/media/libstagefright/include/DataSource.h
+++ b/media/libstagefright/include/DataSource.h
@@ -56,6 +56,7 @@
static sp<DataSource> CreateMediaHTTP(const sp<IMediaHTTPService> &httpService);
static sp<DataSource> CreateFromIDataSource(const sp<IDataSource> &source);
+ static sp<DataSource> CreateFromFd(int fd, int64_t offset, int64_t length);
DataSource() {}
@@ -117,6 +118,12 @@
virtual void close() {};
+ // creates an IDataSource wrapper to the DataSource.
+ virtual sp<IDataSource> asIDataSource();
+
+ // returns a pointer to IDataSource if it is wrapped.
+ virtual sp<IDataSource> getIDataSource() const;
+
protected:
virtual ~DataSource() {}
diff --git a/media/libstagefright/include/FileSource.h b/media/libstagefright/include/FileSource.h
index 9f3bb5e..7267e9a 100644
--- a/media/libstagefright/include/FileSource.h
+++ b/media/libstagefright/include/FileSource.h
@@ -51,6 +51,8 @@
return mName;
}
+ static bool requiresDrm(int fd, int64_t offset, int64_t length, const char *mime);
+
protected:
virtual ~FileSource();
diff --git a/media/libstagefright/include/RemoteDataSource.h b/media/libstagefright/include/RemoteDataSource.h
new file mode 100644
index 0000000..255b7ae
--- /dev/null
+++ b/media/libstagefright/include/RemoteDataSource.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2016, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef REMOTE_DATA_SOURCE_H_
+#define REMOTE_DATA_SOURCE_H_
+
+#include <binder/IMemory.h>
+#include <binder/MemoryDealer.h>
+#include <media/IDataSource.h>
+#include <media/stagefright/DataSource.h>
+
+namespace android {
+
+// Originally in MediaExtractor.cpp
+class RemoteDataSource : public BnDataSource {
+public:
+ static sp<IDataSource> wrap(const sp<DataSource> &source) {
+ if (source.get() == nullptr) {
+ return nullptr;
+ }
+ if (source->getIDataSource().get() != nullptr) {
+ return source->getIDataSource();
+ }
+ return new RemoteDataSource(source);
+ }
+
+ virtual ~RemoteDataSource() {
+ close();
+ }
+ virtual sp<IMemory> getIMemory() {
+ return mMemory;
+ }
+ virtual ssize_t readAt(off64_t offset, size_t size) {
+ ALOGV("readAt(%lld, %zu)", (long long)offset, size);
+ if (size > kBufferSize) {
+ size = kBufferSize;
+ }
+ return mSource->readAt(offset, mMemory->pointer(), size);
+ }
+ virtual status_t getSize(off64_t *size) {
+ return mSource->getSize(size);
+ }
+ virtual void close() {
+ mSource = nullptr;
+ mMemory = nullptr;
+ }
+ virtual uint32_t getFlags() {
+ return mSource->flags();
+ }
+ virtual String8 toString() {
+ return mName;
+ }
+ virtual sp<DecryptHandle> DrmInitialization(const char *mime) {
+ return mSource->DrmInitialization(mime);
+ }
+
+private:
+ enum {
+ kBufferSize = 64 * 1024,
+ };
+
+ sp<IMemory> mMemory;
+ sp<DataSource> mSource;
+ String8 mName;
+
+ explicit RemoteDataSource(const sp<DataSource> &source) {
+ mSource = source;
+ sp<MemoryDealer> memoryDealer = new MemoryDealer(kBufferSize, "RemoteDataSource");
+ mMemory = memoryDealer->allocate(kBufferSize);
+ if (mMemory.get() == nullptr) {
+ ALOGE("Failed to allocate memory!");
+ }
+ mName = String8::format("RemoteDataSource(%s)", mSource->toString().string());
+ }
+
+ DISALLOW_EVIL_CONSTRUCTORS(RemoteDataSource);
+};
+
+} // namespace android
+
+#endif // REMOTE_DATA_SOURCE_H_
diff --git a/media/libstagefright/omx/1.0/Omx.cpp b/media/libstagefright/omx/1.0/Omx.cpp
index 134c661..e5b89da 100644
--- a/media/libstagefright/omx/1.0/Omx.cpp
+++ b/media/libstagefright/omx/1.0/Omx.cpp
@@ -95,11 +95,11 @@
}
sp<OMXNodeInstance> instance = new OMXNodeInstance(
- this, new LWOmxObserver(observer), name);
+ this, new LWOmxObserver(observer), name.c_str());
OMX_COMPONENTTYPE *handle;
OMX_ERRORTYPE err = mMaster->makeComponentInstance(
- name, &OMXNodeInstance::kCallbacks,
+ name.c_str(), &OMXNodeInstance::kCallbacks,
instance.get(), &handle);
if (err != OMX_ErrorNone) {
diff --git a/media/libstagefright/omx/1.0/WOmxNode.cpp b/media/libstagefright/omx/1.0/WOmxNode.cpp
index dc5c8e1..ea9fb35 100644
--- a/media/libstagefright/omx/1.0/WOmxNode.cpp
+++ b/media/libstagefright/omx/1.0/WOmxNode.cpp
@@ -414,7 +414,7 @@
getExtensionIndex_cb _hidl_cb) {
OMX_INDEXTYPE index;
Status status = toStatus(mBase->getExtensionIndex(
- parameterName, &index));
+ parameterName.c_str(), &index));
_hidl_cb(status, toRawIndexType(index));
return Void();
}
diff --git a/media/libstagefright/omx/GraphicBufferSource.cpp b/media/libstagefright/omx/GraphicBufferSource.cpp
index dae1ee9..afbde6a 100644
--- a/media/libstagefright/omx/GraphicBufferSource.cpp
+++ b/media/libstagefright/omx/GraphicBufferSource.cpp
@@ -384,6 +384,7 @@
// to be handled and [pause, 1us], [resume 2us] will be discarded.
bool dropped = false;
bool done = false;
+ bool seeStopAction = false;
if (!mActionQueue.empty()) {
// First scan to check if bufferTimestamp is smaller than first action's timestamp.
ActionItem nextAction = *(mActionQueue.begin());
@@ -431,7 +432,7 @@
dropped = true;
// Clear the whole ActionQueue as recording is done
mActionQueue.clear();
- submitEndOfInputStream_l();
+ seeStopAction = true;
break;
}
default:
@@ -443,6 +444,14 @@
if (dropped) {
releaseBuffer(item.mSlot, item.mFrameNumber, item.mFence);
+ if (seeStopAction) {
+ // Clear all the buffers before setting mEndOfStream and signal EndOfInputStream.
+ if (!releaseAllBuffers()) {
+ ALOGW("Failed to release all the buffers when handling STOP action");
+ }
+ mEndOfStream = true;
+ submitEndOfInputStream_l();
+ }
return true;
}
@@ -922,18 +931,8 @@
if (suspend) {
mSuspended = true;
- while (mNumFramesAvailable > 0) {
- BufferItem item;
- status_t err = acquireBuffer(&item);
-
- if (err != OK) {
- ALOGE("setSuspend: acquireBuffer returned err=%d", err);
- break;
- }
-
- --mNumFramesAvailable;
-
- releaseBuffer(item.mSlot, item.mFrameNumber, item.mFence);
+ if (!releaseAllBuffers()) {
+ ALOGW("Failed to release all the buffers during suspend");
}
return OK;
} else {
@@ -954,6 +953,23 @@
return OK;
}
+bool GraphicBufferSource::releaseAllBuffers() {
+ while (mNumFramesAvailable > 0) {
+ BufferItem item;
+ status_t err = acquireBuffer(&item);
+
+ if (err != OK) {
+ ALOGE("releaseAllBuffers: acquireBuffer fail returned err=%d", err);
+ return false;;
+ }
+
+ --mNumFramesAvailable;
+
+ releaseBuffer(item.mSlot, item.mFrameNumber, item.mFence);
+ }
+ return true;
+}
+
status_t GraphicBufferSource::setRepeatPreviousFrameDelayUs(int64_t repeatAfterUs) {
ALOGV("setRepeatPreviousFrameDelayUs: delayUs=%lld", (long long)repeatAfterUs);
diff --git a/media/libstagefright/omx/GraphicBufferSource.h b/media/libstagefright/omx/GraphicBufferSource.h
index 371c5ed..ab52ce2 100644
--- a/media/libstagefright/omx/GraphicBufferSource.h
+++ b/media/libstagefright/omx/GraphicBufferSource.h
@@ -220,6 +220,8 @@
// Acquire buffer from the consumer
status_t acquireBuffer(BufferItem *bi);
+ bool releaseAllBuffers();
+
// Release buffer to the consumer
void releaseBuffer(int id, uint64_t frameNum, const sp<Fence> &fence);
diff --git a/media/libstagefright/omx/OMXNodeInstance.cpp b/media/libstagefright/omx/OMXNodeInstance.cpp
index 39ed759..807c2ea 100644
--- a/media/libstagefright/omx/OMXNodeInstance.cpp
+++ b/media/libstagefright/omx/OMXNodeInstance.cpp
@@ -902,6 +902,9 @@
? kMetadataBufferTypeGrallocSource : requestedType;
err = OMX_SetParameter(mHandle, index, ¶ms);
}
+ if (err == OMX_ErrorBadParameter) {
+ err = OMX_ErrorUnsupportedIndex;
+ }
}
// don't log loud error if component does not support metadata mode on the output
diff --git a/media/libstagefright/omx/SoftVideoEncoderOMXComponent.cpp b/media/libstagefright/omx/SoftVideoEncoderOMXComponent.cpp
index c49403d..9fe6018 100644
--- a/media/libstagefright/omx/SoftVideoEncoderOMXComponent.cpp
+++ b/media/libstagefright/omx/SoftVideoEncoderOMXComponent.cpp
@@ -30,9 +30,12 @@
#include <media/stagefright/foundation/AUtils.h>
#include <media/stagefright/MediaDefs.h>
+#include <ui/Fence.h>
#include <ui/GraphicBufferMapper.h>
#include <ui/Rect.h>
+#include <hardware/gralloc.h>
+
#include <OMX_IndexExt.h>
namespace android {
diff --git a/media/libstagefright/omx/tests/OMXHarness.cpp b/media/libstagefright/omx/tests/OMXHarness.cpp
index cbca461..fcc44d8 100644
--- a/media/libstagefright/omx/tests/OMXHarness.cpp
+++ b/media/libstagefright/omx/tests/OMXHarness.cpp
@@ -78,9 +78,7 @@
}
status_t Harness::initOMX() {
- int32_t trebleOmx = property_get_int32("persist.media.treble_omx", -1);
- if ((trebleOmx == 1) || ((trebleOmx == -1) &&
- property_get_bool("persist.hal.binderization", 0))) {
+ if (property_get_bool("persist.media.treble_omx", true)) {
using namespace ::android::hardware::media::omx::V1_0;
sp<IOmx> tOmx = IOmx::getService();
if (tOmx == nullptr) {
diff --git a/media/libstagefright/tests/SurfaceMediaSource_test.cpp b/media/libstagefright/tests/SurfaceMediaSource_test.cpp
index ea58343..7c464ff 100644
--- a/media/libstagefright/tests/SurfaceMediaSource_test.cpp
+++ b/media/libstagefright/tests/SurfaceMediaSource_test.cpp
@@ -510,7 +510,7 @@
// Fill the buffer with the a checkerboard pattern
uint8_t* img = NULL;
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+ sp<GraphicBuffer> buf(GraphicBuffer::from(anb));
buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
SurfaceMediaSourceTest::fillYV12Buffer(img, width, height, buf->getStride());
buf->unlock();
@@ -527,7 +527,7 @@
ASSERT_TRUE(anb != NULL);
// We do not fill the buffer in. Just queue it back.
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+ sp<GraphicBuffer> buf(GraphicBuffer::from(anb));
ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(),
-1));
}
diff --git a/media/mtp/AsyncIO.cpp b/media/mtp/AsyncIO.cpp
index e77ad38..bfb07dc 100644
--- a/media/mtp/AsyncIO.cpp
+++ b/media/mtp/AsyncIO.cpp
@@ -96,6 +96,10 @@
} // end anonymous namespace
+aiocb::~aiocb() {
+ CHECK(!thread.joinable());
+}
+
void aio_pool_init(void(f)(int)) {
CHECK(done == 1);
done = 0;
diff --git a/media/mtp/AsyncIO.h b/media/mtp/AsyncIO.h
index f7515a2..ed80828 100644
--- a/media/mtp/AsyncIO.h
+++ b/media/mtp/AsyncIO.h
@@ -48,6 +48,8 @@
std::thread thread;
ssize_t ret;
int error;
+
+ ~aiocb();
};
// Submit a request for IO to be completed
@@ -58,9 +60,13 @@
// Suspend current thread until given IO is complete, at which point
// its return value and any errors can be accessed
+// All submitted requests must have a corresponding suspend.
+// aiocb->aio_buf must refer to valid memory until after the suspend call
int aio_suspend(struct aiocb *[], int, const struct timespec *);
int aio_error(const struct aiocb *);
ssize_t aio_return(struct aiocb *);
+
+// (Currently unimplemented)
int aio_cancel(int, struct aiocb *);
// Initialize a threadpool to perform IO. Only one pool can be
diff --git a/media/mtp/MtpFfsHandle.cpp b/media/mtp/MtpFfsHandle.cpp
index 35dd10f..565a2fe 100644
--- a/media/mtp/MtpFfsHandle.cpp
+++ b/media/mtp/MtpFfsHandle.cpp
@@ -490,7 +490,11 @@
int MtpFfsHandle::configure(bool usePtp) {
// Wait till previous server invocation has closed
- std::lock_guard<std::mutex> lk(mLock);
+ if (!mLock.try_lock_for(std::chrono::milliseconds(1000))) {
+ LOG(ERROR) << "MtpServer was unable to get configure lock";
+ return -1;
+ }
+ int ret = 0;
// If ptp is changed, the configuration must be rewritten
if (mPtp != usePtp) {
@@ -500,10 +504,10 @@
mPtp = usePtp;
if (!initFunctionfs()) {
- return -1;
+ ret = -1;
}
-
- return 0;
+ mLock.unlock();
+ return ret;
}
void MtpFfsHandle::close() {
@@ -537,14 +541,12 @@
if (file_length > 0) {
length = std::min(static_cast<uint32_t>(MAX_FILE_CHUNK_SIZE), file_length);
- // Read data from USB
- if ((ret = readHandle(mBulkOut, data, length)) == -1) {
- return -1;
- }
+ // Read data from USB, handle errors after waiting for write thread.
+ ret = readHandle(mBulkOut, data, length);
if (file_length != MAX_MTP_FILE_SIZE && ret < static_cast<int>(length)) {
+ ret = -1;
errno = EIO;
- return -1;
}
read = true;
}
@@ -565,6 +567,11 @@
write = false;
}
+ // If there was an error reading above
+ if (ret == -1) {
+ return -1;
+ }
+
if (read) {
// Enqueue a new write request
aio.aio_buf = data;
@@ -622,6 +629,7 @@
aio.aio_fildes = mfr.fd;
struct aiocb *aiol[] = {&aio};
int ret, length;
+ int error = 0;
bool read = false;
bool write = false;
@@ -665,6 +673,10 @@
write = true;
}
+ if (error == -1) {
+ return -1;
+ }
+
if (file_length > 0) {
length = std::min(static_cast<uint64_t>(MAX_FILE_CHUNK_SIZE), file_length);
// Queue up another read
@@ -676,8 +688,9 @@
}
if (write) {
- if (writeHandle(mBulkIn, data2, ret) == -1)
- return -1;
+ if (writeHandle(mBulkIn, data2, ret) == -1) {
+ error = -1;
+ }
write = false;
}
}
diff --git a/media/mtp/MtpFfsHandle.h b/media/mtp/MtpFfsHandle.h
index b4d5a97..7491a1b 100644
--- a/media/mtp/MtpFfsHandle.h
+++ b/media/mtp/MtpFfsHandle.h
@@ -36,7 +36,7 @@
bool mPtp;
- std::mutex mLock;
+ std::timed_mutex mLock;
android::base::unique_fd mControl;
// "in" from the host's perspective => sink for mtp server
diff --git a/media/ndk/Android.mk b/media/ndk/Android.mk
index 0984ca4..2c070af 100644
--- a/media/ndk/Android.mk
+++ b/media/ndk/Android.mk
@@ -47,6 +47,9 @@
LOCAL_CFLAGS += -Werror -Wall
+LOCAL_STATIC_LIBRARIES := \
+ libgrallocusage \
+
LOCAL_SHARED_LIBRARIES := \
libbinder \
libmedia \
diff --git a/media/ndk/NdkImageReader.cpp b/media/ndk/NdkImageReader.cpp
index c0aee90..c449611 100644
--- a/media/ndk/NdkImageReader.cpp
+++ b/media/ndk/NdkImageReader.cpp
@@ -27,6 +27,7 @@
#include <android_media_Utils.h>
#include <android_runtime/android_view_Surface.h>
#include <android_runtime/android_hardware_HardwareBuffer.h>
+#include <grallocusage/GrallocUsageConversion.h>
using namespace android;
@@ -260,7 +261,8 @@
uint64_t consumerUsage;
android_hardware_HardwareBuffer_convertToGrallocUsageBits(
&producerUsage, &consumerUsage, mUsage0, mUsage1);
- mHalUsage = consumerUsage;
+ // Strip out producerUsage here.
+ mHalUsage = android_convertGralloc1To0Usage(0, consumerUsage);
sp<IGraphicBufferProducer> gbProducer;
sp<IGraphicBufferConsumer> gbConsumer;
@@ -411,11 +413,9 @@
}
// Check if the producer buffer configurations match what ImageReader configured.
- if ((bufferFmt != HAL_PIXEL_FORMAT_BLOB) && (readerFmt != HAL_PIXEL_FORMAT_BLOB) &&
- (readerWidth != bufferWidth || readerHeight != bufferHeight)) {
- ALOGW("%s: Buffer size: %dx%d, doesn't match AImageReader configured size: %dx%d",
- __FUNCTION__, bufferWidth, bufferHeight, readerWidth, readerHeight);
- }
+ ALOGV_IF(readerWidth != bufferWidth || readerHeight != bufferHeight,
+ "%s: Buffer size: %dx%d, doesn't match AImageReader configured size: %dx%d",
+ __FUNCTION__, bufferWidth, bufferHeight, readerWidth, readerHeight);
// Check if the buffer usage is a super set of reader's usage bits, aka all usage bits that
// ImageReader requested has been supported from the producer side.
diff --git a/services/camera/libcameraservice/CameraFlashlight.cpp b/services/camera/libcameraservice/CameraFlashlight.cpp
index 0ff9314..4537ae6 100644
--- a/services/camera/libcameraservice/CameraFlashlight.cpp
+++ b/services/camera/libcameraservice/CameraFlashlight.cpp
@@ -944,7 +944,7 @@
}
// need to set __get_memory in set_callbacks().
- device->setCallbacks(NULL, NULL, NULL, NULL);
+ device->setCallbacks(NULL, NULL, NULL, NULL, NULL);
mParameters = device->getParameters();
diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp
index 4318a11..39351e7 100644
--- a/services/camera/libcameraservice/CameraService.cpp
+++ b/services/camera/libcameraservice/CameraService.cpp
@@ -661,6 +661,22 @@
return Status::ok();
}
+Status CameraService::getCameraVendorTagCache(
+ /*out*/ hardware::camera2::params::VendorTagDescriptorCache* cache) {
+ ATRACE_CALL();
+ if (!mInitialized) {
+ ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
+ return STATUS_ERROR(ERROR_DISCONNECTED,
+ "Camera subsystem not available");
+ }
+ sp<VendorTagDescriptorCache> globalCache =
+ VendorTagDescriptorCache::getGlobalVendorTagCache();
+ if (globalCache != nullptr) {
+ *cache = *(globalCache.get());
+ }
+ return Status::ok();
+}
+
int CameraService::getDeviceVersion(const String8& cameraId, int* facing) {
ATRACE_CALL();
@@ -2859,7 +2875,13 @@
sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor();
if (desc == NULL) {
- dprintf(fd, "No vendor tags.\n");
+ sp<VendorTagDescriptorCache> cache =
+ VendorTagDescriptorCache::getGlobalVendorTagCache();
+ if (cache == NULL) {
+ dprintf(fd, "No vendor tags.\n");
+ } else {
+ cache->dump(fd, /*verbosity*/2, /*indentation*/2);
+ }
} else {
desc->dump(fd, /*verbosity*/2, /*indentation*/2);
}
diff --git a/services/camera/libcameraservice/CameraService.h b/services/camera/libcameraservice/CameraService.h
index c7acdc9..e49fe62 100644
--- a/services/camera/libcameraservice/CameraService.h
+++ b/services/camera/libcameraservice/CameraService.h
@@ -112,6 +112,9 @@
virtual binder::Status getCameraVendorTagDescriptor(
/*out*/
hardware::camera2::params::VendorTagDescriptor* desc);
+ virtual binder::Status getCameraVendorTagCache(
+ /*out*/
+ hardware::camera2::params::VendorTagDescriptorCache* cache);
virtual binder::Status connect(const sp<hardware::ICameraClient>& cameraClient,
int32_t cameraId, const String16& clientPackageName,
diff --git a/services/camera/libcameraservice/api1/Camera2Client.cpp b/services/camera/libcameraservice/api1/Camera2Client.cpp
index 3aec562..335e999 100644
--- a/services/camera/libcameraservice/api1/Camera2Client.cpp
+++ b/services/camera/libcameraservice/api1/Camera2Client.cpp
@@ -1261,6 +1261,13 @@
ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
}
+void Camera2Client::releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*>& handles) {
+ (void)handles;
+ ATRACE_CALL();
+ ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
+}
+
status_t Camera2Client::autoFocus() {
ATRACE_CALL();
Mutex::Autolock icl(mBinderSerializationLock);
diff --git a/services/camera/libcameraservice/api1/Camera2Client.h b/services/camera/libcameraservice/api1/Camera2Client.h
index 87c91a0..9738aca 100644
--- a/services/camera/libcameraservice/api1/Camera2Client.h
+++ b/services/camera/libcameraservice/api1/Camera2Client.h
@@ -72,6 +72,8 @@
virtual bool recordingEnabled();
virtual void releaseRecordingFrame(const sp<IMemory>& mem);
virtual void releaseRecordingFrameHandle(native_handle_t *handle);
+ virtual void releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*>& handles);
virtual status_t autoFocus();
virtual status_t cancelAutoFocus();
virtual status_t takePicture(int msgType);
diff --git a/services/camera/libcameraservice/api1/CameraClient.cpp b/services/camera/libcameraservice/api1/CameraClient.cpp
index ffb657e..df8726e 100644
--- a/services/camera/libcameraservice/api1/CameraClient.cpp
+++ b/services/camera/libcameraservice/api1/CameraClient.cpp
@@ -98,6 +98,7 @@
mHardware->setCallbacks(notifyCallback,
dataCallback,
dataCallbackTimestamp,
+ handleCallbackTimestampBatch,
(void *)(uintptr_t)mCameraId);
// Enable zoom, error, focus, and metadata messages by default
@@ -533,6 +534,50 @@
mHardware->releaseRecordingFrame(dataPtr);
}
+void CameraClient::releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {
+ size_t n = handles.size();
+ std::vector<sp<IMemory>> frames;
+ frames.reserve(n);
+ bool error = false;
+ for (auto& handle : handles) {
+ sp<IMemory> dataPtr;
+ {
+ Mutex::Autolock l(mAvailableCallbackBuffersLock);
+ if (!mAvailableCallbackBuffers.empty()) {
+ dataPtr = mAvailableCallbackBuffers.back();
+ mAvailableCallbackBuffers.pop_back();
+ }
+ }
+
+ if (dataPtr == nullptr) {
+ ALOGE("%s: %d: No callback buffer available. Dropping frames.", __FUNCTION__,
+ __LINE__);
+ error = true;
+ break;
+ } else if (dataPtr->size() != sizeof(VideoNativeHandleMetadata)) {
+ ALOGE("%s: %d: Callback buffer must be VideoNativeHandleMetadata", __FUNCTION__,
+ __LINE__);
+ error = true;
+ break;
+ }
+
+ VideoNativeHandleMetadata *metadata = (VideoNativeHandleMetadata*)(dataPtr->pointer());
+ metadata->eType = kMetadataBufferTypeNativeHandleSource;
+ metadata->pHandle = handle;
+ frames.push_back(dataPtr);
+ }
+
+ if (error) {
+ for (auto& handle : handles) {
+ native_handle_close(handle);
+ native_handle_delete(handle);
+ }
+ } else {
+ mHardware->releaseRecordingFrameBatch(frames);
+ }
+ return;
+}
+
status_t CameraClient::setVideoBufferMode(int32_t videoBufferMode) {
LOG1("setVideoBufferMode: %d", videoBufferMode);
bool enableMetadataInBuffers = false;
@@ -855,6 +900,49 @@
client->handleGenericDataTimestamp(timestamp, msgType, dataPtr);
}
+void CameraClient::handleCallbackTimestampBatch(
+ int32_t msgType, const std::vector<HandleTimestampMessage>& msgs, void* user) {
+ LOG2("dataCallbackTimestampBatch");
+ sp<CameraClient> client = getClientFromCookie(user);
+ if (client.get() == nullptr) return;
+ if (!client->lockIfMessageWanted(msgType)) return;
+
+ sp<hardware::ICameraClient> c = client->mRemoteCallback;
+ client->mLock.unlock();
+ if (c != 0 && msgs.size() > 0) {
+ size_t n = msgs.size();
+ std::vector<nsecs_t> timestamps;
+ std::vector<native_handle_t*> handles;
+ timestamps.reserve(n);
+ handles.reserve(n);
+ for (auto& msg : msgs) {
+ native_handle_t* handle = nullptr;
+ if (msg.dataPtr->size() != sizeof(VideoNativeHandleMetadata)) {
+ ALOGE("%s: dataPtr does not contain VideoNativeHandleMetadata!", __FUNCTION__);
+ return;
+ }
+ VideoNativeHandleMetadata *metadata =
+ (VideoNativeHandleMetadata*)(msg.dataPtr->pointer());
+ if (metadata->eType == kMetadataBufferTypeNativeHandleSource) {
+ handle = metadata->pHandle;
+ }
+
+ if (handle == nullptr) {
+ ALOGE("%s: VideoNativeHandleMetadata type mismatch or null handle passed!",
+ __FUNCTION__);
+ return;
+ }
+ {
+ Mutex::Autolock l(client->mAvailableCallbackBuffersLock);
+ client->mAvailableCallbackBuffers.push_back(msg.dataPtr);
+ }
+ timestamps.push_back(msg.timestamp);
+ handles.push_back(handle);
+ }
+ c->recordingFrameHandleCallbackTimestampBatch(timestamps, handles);
+ }
+}
+
// snapshot taken callback
void CameraClient::handleShutter(void) {
if (mPlayShutterSound) {
diff --git a/services/camera/libcameraservice/api1/CameraClient.h b/services/camera/libcameraservice/api1/CameraClient.h
index 91f00e3..1073384 100644
--- a/services/camera/libcameraservice/api1/CameraClient.h
+++ b/services/camera/libcameraservice/api1/CameraClient.h
@@ -50,6 +50,8 @@
virtual bool recordingEnabled();
virtual void releaseRecordingFrame(const sp<IMemory>& mem);
virtual void releaseRecordingFrameHandle(native_handle_t *handle);
+ virtual void releaseRecordingFrameHandleBatch(
+ const std::vector<native_handle_t*>& handles);
virtual status_t autoFocus();
virtual status_t cancelAutoFocus();
virtual status_t takePicture(int msgType);
@@ -109,6 +111,8 @@
static void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr,
camera_frame_metadata_t *metadata, void* user);
static void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr, void* user);
+ static void handleCallbackTimestampBatch(
+ int32_t msgType, const std::vector<HandleTimestampMessage>&, void* user);
// handlers for messages
void handleShutter(void);
void handlePreviewData(int32_t msgType, const sp<IMemory>& mem,
diff --git a/services/camera/libcameraservice/api1/client2/FrameProcessor.cpp b/services/camera/libcameraservice/api1/client2/FrameProcessor.cpp
index 394eb4c..733a78e 100644
--- a/services/camera/libcameraservice/api1/client2/FrameProcessor.cpp
+++ b/services/camera/libcameraservice/api1/client2/FrameProcessor.cpp
@@ -367,9 +367,12 @@
entry = result.find(tag);
if (entry.count == 0) {
+ const camera_metadata *metaBuffer = result.getAndLock();
ALOGV("%s: Camera %d: No %s provided by HAL for frame %d in this result!",
__FUNCTION__, cameraId,
- get_camera_metadata_tag_name(tag), frameNumber);
+ get_local_camera_metadata_tag_name(tag, metaBuffer),
+ frameNumber);
+ result.unlock(metaBuffer);
return false;
} else {
switch(sizeof(Src)){
diff --git a/services/camera/libcameraservice/api1/client2/Parameters.cpp b/services/camera/libcameraservice/api1/client2/Parameters.cpp
index 83c84af..6aaca7e 100644
--- a/services/camera/libcameraservice/api1/client2/Parameters.cpp
+++ b/services/camera/libcameraservice/api1/client2/Parameters.cpp
@@ -1198,11 +1198,14 @@
camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag,
size_t minCount, size_t maxCount, bool required) const {
camera_metadata_ro_entry_t entry = info->find(tag);
+ const camera_metadata_t *metaBuffer = info->getAndLock();
if (CC_UNLIKELY( entry.count == 0 ) && required) {
- const char* tagSection = get_camera_metadata_section_name(tag);
+ const char* tagSection = get_local_camera_metadata_section_name(tag,
+ metaBuffer);
if (tagSection == NULL) tagSection = "<unknown>";
- const char* tagName = get_camera_metadata_tag_name(tag);
+ const char* tagName = get_local_camera_metadata_tag_name(tag,
+ metaBuffer);
if (tagName == NULL) tagName = "<unknown>";
ALOGE("Error finding static metadata entry '%s.%s' (%x)",
@@ -1210,14 +1213,17 @@
} else if (CC_UNLIKELY(
(minCount != 0 && entry.count < minCount) ||
(maxCount != 0 && entry.count > maxCount) ) ) {
- const char* tagSection = get_camera_metadata_section_name(tag);
+ const char* tagSection = get_local_camera_metadata_section_name(tag,
+ metaBuffer);
if (tagSection == NULL) tagSection = "<unknown>";
- const char* tagName = get_camera_metadata_tag_name(tag);
+ const char* tagName = get_local_camera_metadata_tag_name(tag,
+ metaBuffer);
if (tagName == NULL) tagName = "<unknown>";
ALOGE("Malformed static metadata entry '%s.%s' (%x):"
"Expected between %zu and %zu values, but got %zu values",
tagSection, tagName, tag, minCount, maxCount, entry.count);
}
+ info->unlock(metaBuffer);
return entry;
}
diff --git a/services/camera/libcameraservice/common/CameraDeviceBase.h b/services/camera/libcameraservice/common/CameraDeviceBase.h
index f9b062a..4f788ae 100644
--- a/services/camera/libcameraservice/common/CameraDeviceBase.h
+++ b/services/camera/libcameraservice/common/CameraDeviceBase.h
@@ -145,12 +145,6 @@
int32_t format, /*out*/ int32_t *id) = 0;
/**
- * Create an input reprocess stream that uses buffers from an existing
- * output stream.
- */
- virtual status_t createReprocessStreamFromStream(int outputId, int *id) = 0;
-
- /**
* Get information about a given stream.
*/
virtual status_t getStreamInfo(int id,
@@ -169,12 +163,6 @@
virtual status_t deleteStream(int id) = 0;
/**
- * Delete reprocess stream. Must not be called if there are requests in
- * flight which reference that stream.
- */
- virtual status_t deleteReprocessStream(int id) = 0;
-
- /**
* Take the currently-defined set of streams and configure the HAL to use
* them. This is a long-running operation (may be several hundered ms).
*
@@ -289,21 +277,6 @@
virtual status_t triggerPrecaptureMetering(uint32_t id) = 0;
/**
- * Abstract interface for clients that want to listen to reprocess buffer
- * release events
- */
- struct BufferReleasedListener : public virtual RefBase {
- virtual void onBufferReleased(buffer_handle_t *handle) = 0;
- };
-
- /**
- * Push a buffer to be reprocessed into a reprocessing stream, and
- * provide a listener to call once the buffer is returned by the HAL
- */
- virtual status_t pushReprocessBuffer(int reprocessStreamId,
- buffer_handle_t *buffer, wp<BufferReleasedListener> listener) = 0;
-
- /**
* Flush all pending and in-flight requests. Blocks until flush is
* complete.
* Output lastFrameNumber is the last frame number of the previous streaming request.
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.cpp b/services/camera/libcameraservice/common/CameraProviderManager.cpp
index bbeeca6..56ba5b6 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.cpp
+++ b/services/camera/libcameraservice/common/CameraProviderManager.cpp
@@ -23,6 +23,8 @@
#include <chrono>
#include <inttypes.h>
#include <hidl/ServiceManagement.h>
+#include <functional>
+#include <camera_metadata_hidden.h>
namespace android {
@@ -221,7 +223,9 @@
}
status_t CameraProviderManager::setUpVendorTags() {
- // TODO (b/34275821): support aggregating vendor tags for more than one provider
+ sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
+
+ VendorTagDescriptorCache::clearGlobalVendorTagCache();
for (auto& provider : mProviders) {
hardware::hidl_vec<VendorTagSection> vts;
Status status;
@@ -242,8 +246,6 @@
return mapToStatusT(status);
}
- VendorTagDescriptor::clearGlobalVendorTagDescriptor();
-
// Read all vendor tag definitions into a descriptor
sp<VendorTagDescriptor> desc;
status_t res;
@@ -255,9 +257,11 @@
return res;
}
- // Set the global descriptor to use with camera metadata
- VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
+ tagCache->addVendorDescriptor(provider->mProviderTagid, desc);
}
+
+ VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
+
return OK;
}
@@ -350,6 +354,24 @@
return nullptr;
}
+metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
+ const std::string& id, hardware::hidl_version minVersion,
+ hardware::hidl_version maxVersion) const {
+ metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
+
+ std::lock_guard<std::mutex> lock(mInterfaceMutex);
+ for (auto& provider : mProviders) {
+ for (auto& deviceInfo : provider->mDevices) {
+ if (deviceInfo->mId == id &&
+ minVersion <= deviceInfo->mVersion &&
+ maxVersion >= deviceInfo->mVersion) {
+ return provider->mProviderTagid;
+ }
+ }
+ }
+
+ return ret;
+}
status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
for (const auto& providerInfo : mProviders) {
@@ -430,6 +452,7 @@
CameraProviderManager *manager) :
mProviderName(providerName),
mInterface(interface),
+ mProviderTagid(generateVendorTagId(providerName)),
mManager(manager) {
(void) mManager;
}
@@ -542,10 +565,12 @@
std::unique_ptr<DeviceInfo> deviceInfo;
switch (major) {
case 1:
- deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, id, minor);
+ deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
+ id, minor);
break;
case 3:
- deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, id, minor);
+ deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
+ id, minor);
break;
default:
ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
@@ -691,7 +716,7 @@
template<class DeviceInfoT>
std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
CameraProviderManager::ProviderInfo::initializeDeviceInfo(
- const std::string &name,
+ const std::string &name, const metadata_vendor_id_t tagId,
const std::string &id, uint16_t minorVersion) const {
Status status;
@@ -711,7 +736,8 @@
return nullptr;
}
return std::unique_ptr<DeviceInfo>(
- new DeviceInfoT(name, id, minorVersion, resourceCost, cameraInterface));
+ new DeviceInfoT(name, tagId, id, minorVersion, resourceCost,
+ cameraInterface));
}
template<class InterfaceT>
@@ -782,11 +808,12 @@
}
CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
- const std::string &id,
+ const metadata_vendor_id_t tagId, const std::string &id,
uint16_t minorVersion,
const CameraResourceCost& resourceCost,
sp<InterfaceT> interface) :
- DeviceInfo(name, id, hardware::hidl_version{1, minorVersion}, resourceCost),
+ DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
+ resourceCost),
mInterface(interface) {
// Get default parameters and initialize flash unit availability
// Requires powering on the camera device
@@ -869,11 +896,12 @@
}
CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
- const std::string &id,
+ const metadata_vendor_id_t tagId, const std::string &id,
uint16_t minorVersion,
const CameraResourceCost& resourceCost,
sp<InterfaceT> interface) :
- DeviceInfo(name, id, hardware::hidl_version{3, minorVersion}, resourceCost),
+ DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
+ resourceCost),
mInterface(interface) {
// Get camera characteristics and initialize flash unit availability
Status status;
@@ -884,6 +912,7 @@
if (s == Status::OK) {
camera_metadata_t *buffer =
reinterpret_cast<camera_metadata_t*>(metadata.data());
+ set_camera_metadata_vendor_id(buffer, mProviderTagid);
mCameraCharacteristics = buffer;
}
});
@@ -1004,6 +1033,17 @@
return OK;
}
+metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
+ const std::string &name) {
+ metadata_vendor_id_t ret = std::hash<std::string> {} (name);
+ // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
+ if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
+ ret = 0;
+ }
+
+ return ret;
+}
+
status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.h b/services/camera/libcameraservice/common/CameraProviderManager.h
index a388db5..2df4fd5 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.h
+++ b/services/camera/libcameraservice/common/CameraProviderManager.h
@@ -224,6 +224,13 @@
static status_t mapToStatusT(const hardware::camera::common::V1_0::Status& s);
static const char* statusToString(const hardware::camera::common::V1_0::Status& s);
+ /*
+ * Return provider type for a specific device.
+ */
+ metadata_vendor_id_t getProviderTagIdLocked(const std::string& id,
+ hardware::hidl_version minVersion = hardware::hidl_version{0,0},
+ hardware::hidl_version maxVersion = hardware::hidl_version{1000,0}) const;
+
private:
// All private members, unless otherwise noted, expect mInterfaceMutex to be locked before use
mutable std::mutex mInterfaceMutex;
@@ -241,6 +248,7 @@
{
const std::string mProviderName;
const sp<hardware::camera::provider::V2_4::ICameraProvider> mInterface;
+ const metadata_vendor_id_t mProviderTagid;
ProviderInfo(const std::string &providerName,
sp<hardware::camera::provider::V2_4::ICameraProvider>& interface,
@@ -274,6 +282,7 @@
const std::string mName; // Full instance name
const std::string mId; // ID section of full name
const hardware::hidl_version mVersion;
+ const metadata_vendor_id_t mProviderTagid;
const hardware::camera::common::V1_0::CameraResourceCost mResourceCost;
@@ -287,10 +296,11 @@
return INVALID_OPERATION;
}
- DeviceInfo(const std::string& name, const std::string &id,
- const hardware::hidl_version& version,
+ DeviceInfo(const std::string& name, const metadata_vendor_id_t tagId,
+ 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),
+ mName(name), mId(id), mVersion(version), mProviderTagid(tagId),
+ mResourceCost(resourceCost),
mStatus(hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT),
mHasFlashUnit(false) {}
virtual ~DeviceInfo();
@@ -312,8 +322,8 @@
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,
+ DeviceInfo1(const std::string& name, const metadata_vendor_id_t tagId,
+ const std::string &id, uint16_t minorVersion,
const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
sp<InterfaceT> interface);
virtual ~DeviceInfo1();
@@ -331,8 +341,8 @@
virtual status_t getCameraCharacteristics(
CameraMetadata *characteristics) const override;
- DeviceInfo3(const std::string& name, const std::string &id,
- uint16_t minorVersion,
+ DeviceInfo3(const std::string& name, const metadata_vendor_id_t tagId,
+ const std::string &id, uint16_t minorVersion,
const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
sp<InterfaceT> interface);
virtual ~DeviceInfo3();
@@ -352,7 +362,8 @@
// right CameraProvider getCameraDeviceInterface_* method.
template<class DeviceInfoT>
std::unique_ptr<DeviceInfo> initializeDeviceInfo(const std::string &name,
- const std::string &id, uint16_t minorVersion) const;
+ const metadata_vendor_id_t tagId, const std::string &id,
+ uint16_t minorVersion) const;
// Helper for initializeDeviceInfo to use the right CameraProvider get method.
template<class InterfaceT>
@@ -365,6 +376,9 @@
// 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);
+
+ // Generate vendor tag id
+ static metadata_vendor_id_t generateVendorTagId(const std::string &name);
};
// Utility to find a DeviceInfo by ID; pointer is only valid while mInterfaceMutex is held
diff --git a/services/camera/libcameraservice/device1/CameraHardwareInterface.cpp b/services/camera/libcameraservice/device1/CameraHardwareInterface.cpp
index b52c0d8..9c058bc 100644
--- a/services/camera/libcameraservice/device1/CameraHardwareInterface.cpp
+++ b/services/camera/libcameraservice/device1/CameraHardwareInterface.cpp
@@ -193,6 +193,36 @@
return hardware::Void();
}
+hardware::Return<void> CameraHardwareInterface::handleCallbackTimestampBatch(
+ DataCallbackMsg msgType,
+ const hardware::hidl_vec<hardware::camera::device::V1_0::HandleTimestampMessage>& messages) {
+ std::vector<android::HandleTimestampMessage> msgs;
+ msgs.reserve(messages.size());
+
+ for (const auto& hidl_msg : messages) {
+ if (mHidlMemPoolMap.count(hidl_msg.data) == 0) {
+ ALOGE("%s: memory pool ID %d not found", __FUNCTION__, hidl_msg.data);
+ return hardware::Void();
+ }
+ sp<CameraHeapMemory> mem(
+ static_cast<CameraHeapMemory *>(mHidlMemPoolMap.at(hidl_msg.data)->handle));
+
+ if (hidl_msg.bufferIndex >= mem->mNumBufs) {
+ ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
+ hidl_msg.bufferIndex, mem->mNumBufs);
+ return hardware::Void();
+ }
+ VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
+ mem->mBuffers[hidl_msg.bufferIndex]->pointer();
+ md->pHandle = const_cast<native_handle_t*>(hidl_msg.frameData.getNativeHandle());
+
+ msgs.push_back({hidl_msg.timestamp, mem->mBuffers[hidl_msg.bufferIndex]});
+ }
+
+ mDataCbTimestampBatch((int32_t) msgType, msgs, mCbUser);
+ return hardware::Void();
+}
+
std::pair<bool, uint64_t> CameraHardwareInterface::getBufferId(
ANativeWindowBuffer* anb) {
std::lock_guard<std::mutex> lock(mBufferIdMapLock);
@@ -468,11 +498,13 @@
void CameraHardwareInterface::setCallbacks(notify_callback notify_cb,
data_callback data_cb,
data_callback_timestamp data_cb_timestamp,
+ data_callback_timestamp_batch data_cb_timestamp_batch,
void* user)
{
mNotifyCb = notify_cb;
mDataCb = data_cb;
mDataCbTimestamp = data_cb_timestamp;
+ mDataCbTimestampBatch = data_cb_timestamp_batch;
mCbUser = user;
ALOGV("%s(%s)", __FUNCTION__, mName.string());
@@ -628,6 +660,44 @@
}
}
+void CameraHardwareInterface::releaseRecordingFrameBatch(const std::vector<sp<IMemory>>& frames)
+{
+ ALOGV("%s(%s)", __FUNCTION__, mName.string());
+ size_t n = frames.size();
+ std::vector<VideoFrameMessage> msgs;
+ msgs.reserve(n);
+ for (auto& mem : frames) {
+ if (CC_LIKELY(mHidlDevice != nullptr)) {
+ ssize_t offset;
+ size_t size;
+ sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
+ if (size == sizeof(VideoNativeHandleMetadata)) {
+ uint32_t heapId = heap->getHeapID();
+ uint32_t bufferIndex = offset / size;
+ VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) mem->pointer();
+ // Caching the handle here because md->pHandle will be subject to HAL's edit
+ native_handle_t* nh = md->pHandle;
+ VideoFrameMessage msg;
+ msgs.push_back({nh, heapId, bufferIndex});
+ } else {
+ ALOGE("%s only supports VideoNativeHandleMetadata mode", __FUNCTION__);
+ return;
+ }
+ } else {
+ ALOGE("Non HIDL mode do not support %s", __FUNCTION__);
+ return;
+ }
+ }
+
+ mHidlDevice->releaseRecordingFrameHandleBatch(msgs);
+
+ for (auto& msg : msgs) {
+ native_handle_t* nh = const_cast<native_handle_t*>(msg.frameData.getNativeHandle());
+ native_handle_close(nh);
+ native_handle_delete(nh);
+ }
+}
+
status_t CameraHardwareInterface::autoFocus()
{
ALOGV("%s(%s)", __FUNCTION__, mName.string());
diff --git a/services/camera/libcameraservice/device1/CameraHardwareInterface.h b/services/camera/libcameraservice/device1/CameraHardwareInterface.h
index 88ab2e9..c2b0e9c 100644
--- a/services/camera/libcameraservice/device1/CameraHardwareInterface.h
+++ b/services/camera/libcameraservice/device1/CameraHardwareInterface.h
@@ -48,6 +48,15 @@
const sp<IMemory> &dataPtr,
void *user);
+struct HandleTimestampMessage {
+ nsecs_t timestamp;
+ const sp<IMemory> dataPtr;
+};
+
+typedef void (*data_callback_timestamp_batch)(
+ int32_t msgType,
+ const std::vector<HandleTimestampMessage>&, void* user);
+
/**
* CameraHardwareInterface.h defines the interface to the
* camera hardware abstraction layer, used for setting and getting
@@ -112,6 +121,7 @@
void setCallbacks(notify_callback notify_cb,
data_callback data_cb,
data_callback_timestamp data_cb_timestamp,
+ data_callback_timestamp_batch data_cb_timestamp_batch,
void* user);
/**
@@ -227,6 +237,20 @@
void releaseRecordingFrame(const sp<IMemory>& mem);
/**
+ * Release a batch of recording frames previously returned by
+ * CAMERA_MSG_VIDEO_FRAME. This method only supports frames that are
+ * stored as VideoNativeHandleMetadata.
+ *
+ * It is camera hal client's responsibility to release video recording
+ * frames sent out by the camera hal before the camera hal receives
+ * a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives
+ * the call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is camera hal's
+ * responsibility of managing the life-cycle of the video recording
+ * frames.
+ */
+ void releaseRecordingFrameBatch(const std::vector<sp<IMemory>>& frames);
+
+ /**
* Start auto focus, the notification callback routine is called
* with CAMERA_MSG_FOCUS once when focusing is complete. autoFocus()
* will be called again if another auto focus is needed.
@@ -416,6 +440,10 @@
hardware::camera::device::V1_0::DataCallbackMsg msgType,
const hardware::hidl_handle& frameData, uint32_t data,
uint32_t bufferIndex, int64_t timestamp) override;
+ hardware::Return<void> handleCallbackTimestampBatch(
+ hardware::camera::device::V1_0::DataCallbackMsg msgType,
+ const hardware::hidl_vec<
+ hardware::camera::device::V1_0::HandleTimestampMessage>&) override;
/**
* Implementation of android::hardware::camera::device::V1_0::ICameraDevicePreviewCallback
@@ -450,9 +478,10 @@
struct camera_preview_window mHalPreviewWindow;
- notify_callback mNotifyCb;
- data_callback mDataCb;
- data_callback_timestamp mDataCbTimestamp;
+ notify_callback mNotifyCb;
+ data_callback mDataCb;
+ data_callback_timestamp mDataCbTimestamp;
+ data_callback_timestamp_batch mDataCbTimestampBatch;
void *mCbUser;
// Cached values for preview stream parameters
diff --git a/services/camera/libcameraservice/device3/Camera3Device.cpp b/services/camera/libcameraservice/device3/Camera3Device.cpp
index 1de2edc..c35dab6 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Device.cpp
@@ -74,7 +74,8 @@
mNextReprocessResultFrameNumber(0),
mNextShutterFrameNumber(0),
mNextReprocessShutterFrameNumber(0),
- mListener(NULL)
+ mListener(NULL),
+ mVendorTagId(CAMERA_METADATA_INVALID_VENDOR_ID)
{
ATRACE_CALL();
camera3_callback_ops::notify = &sNotify;
@@ -202,6 +203,8 @@
// for now use 3_4 to keep legacy devices working
mDeviceVersion = CAMERA_DEVICE_API_VERSION_3_4;
mInterface = std::make_unique<HalInterface>(session);
+ std::string providerType;
+ mVendorTagId = manager->getProviderTagIdLocked(mId.string());
return initializeCommonLocked();
}
@@ -225,6 +228,8 @@
/** Create buffer manager */
mBufferManager = new Camera3BufferManager();
+ mTagMonitor.initialize(mVendorTagId);
+
bool aeLockAvailable = false;
camera_metadata_entry aeLockAvailableEntry = mDeviceInfo.find(
ANDROID_CONTROL_AE_LOCK_AVAILABLE);
@@ -1399,15 +1404,6 @@
return OK;
}
-status_t Camera3Device::createReprocessStreamFromStream(int outputId, int *id) {
- ATRACE_CALL();
- (void)outputId; (void)id;
-
- CLOGE("Unimplemented");
- return INVALID_OPERATION;
-}
-
-
status_t Camera3Device::getStreamInfo(int id,
uint32_t *width, uint32_t *height,
uint32_t *format, android_dataspace *dataSpace) {
@@ -1523,14 +1519,6 @@
return res;
}
-status_t Camera3Device::deleteReprocessStream(int id) {
- ATRACE_CALL();
- (void)id;
-
- CLOGE("Unimplemented");
- return INVALID_OPERATION;
-}
-
status_t Camera3Device::configureStreams(int operatingMode) {
ATRACE_CALL();
ALOGV("%s: E", __FUNCTION__);
@@ -1604,6 +1592,7 @@
return res;
}
+ set_camera_metadata_vendor_id(rawRequest, mVendorTagId);
mRequestTemplateCache[templateId].acquire(rawRequest);
// Derive some new keys for backward compatibility
@@ -1856,15 +1845,6 @@
sizeof(trigger)/sizeof(trigger[0]));
}
-status_t Camera3Device::pushReprocessBuffer(int reprocessStreamId,
- buffer_handle_t *buffer, wp<BufferReleasedListener> listener) {
- ATRACE_CALL();
- (void)reprocessStreamId; (void)buffer; (void)listener;
-
- CLOGE("Unimplemented");
- return INVALID_OPERATION;
-}
-
status_t Camera3Device::flush(int64_t *frameNumber) {
ATRACE_CALL();
ALOGV("%s: Camera %s: Flushing all requests", __FUNCTION__, mId.string());
@@ -2563,6 +2543,11 @@
const AeTriggerCancelOverride_t &aeTriggerCancelOverride) {
if (result == nullptr) return;
+ camera_metadata_t *meta = const_cast<camera_metadata_t *>(
+ result->mMetadata.getAndLock());
+ set_camera_metadata_vendor_id(meta, mVendorTagId);
+ result->mMetadata.unlock(meta);
+
if (result->mMetadata.update(ANDROID_REQUEST_FRAME_COUNT,
(int32_t*)&frameNumber, 1) != OK) {
SET_ERR("Failed to set frame number %d in metadata", frameNumber);
@@ -2934,6 +2919,13 @@
InFlightRequest &r = mInFlightMap.editValueAt(idx);
r.requestStatus = msg.error_code;
resultExtras = r.resultExtras;
+ if (hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT ==
+ errorCode) {
+ // In case of missing result check whether the buffers
+ // returned. If they returned, then remove inflight
+ // request.
+ removeInFlightRequestIfReadyLocked(idx);
+ }
} else {
resultExtras.frameNumber = msg.frame_number;
ALOGE("Camera %s: %s: cannot find in-flight request on "
@@ -3154,7 +3146,9 @@
Stream &dst = requestedConfiguration.streams[i];
camera3_stream_t *src = config->streams[i];
- int streamId = Camera3Stream::cast(src)->getId();
+ Camera3Stream* cam3stream = Camera3Stream::cast(src);
+ cam3stream->setBufferFreedListener(this);
+ int streamId = cam3stream->getId();
StreamType streamType;
switch (src->stream_type) {
case CAMERA3_STREAM_OUTPUT:
@@ -3359,9 +3353,21 @@
wrapAsHidlRequest(requests[i], /*out*/&captureRequests[i], /*out*/&handlesCreated);
}
+ std::vector<device::V3_2::BufferCache> cachesToRemove;
+ {
+ std::lock_guard<std::mutex> lock(mBufferIdMapLock);
+ for (auto& pair : mFreedBuffers) {
+ // The stream might have been removed since onBufferFreed
+ if (mBufferIdMaps.find(pair.first) != mBufferIdMaps.end()) {
+ cachesToRemove.push_back({pair.first, pair.second});
+ }
+ }
+ mFreedBuffers.clear();
+ }
+
common::V1_0::Status status = common::V1_0::Status::INTERNAL_ERROR;
*numRequestProcessed = 0;
- mHidlSession->processCaptureRequest(captureRequests,
+ mHidlSession->processCaptureRequest(captureRequests, cachesToRemove,
[&status, &numRequestProcessed] (auto s, uint32_t n) {
status = s;
*numRequestProcessed = n;
@@ -3469,12 +3475,40 @@
auto it = bIdMap.find(buf);
if (it == bIdMap.end()) {
bIdMap[buf] = mNextBufferId++;
+ ALOGV("stream %d now have %zu buffer caches, buf %p",
+ streamId, bIdMap.size(), buf);
return std::make_pair(true, mNextBufferId - 1);
} else {
return std::make_pair(false, it->second);
}
}
+void Camera3Device::HalInterface::onBufferFreed(
+ int streamId, const native_handle_t* handle) {
+ std::lock_guard<std::mutex> lock(mBufferIdMapLock);
+ uint64_t bufferId = BUFFER_ID_NO_BUFFER;
+ auto mapIt = mBufferIdMaps.find(streamId);
+ if (mapIt == mBufferIdMaps.end()) {
+ // streamId might be from a deleted stream here
+ ALOGI("%s: stream %d has been removed",
+ __FUNCTION__, streamId);
+ return;
+ }
+ BufferIdMap& bIdMap = mapIt->second;
+ auto it = bIdMap.find(handle);
+ if (it == bIdMap.end()) {
+ ALOGW("%s: cannot find buffer %p in stream %d",
+ __FUNCTION__, handle, streamId);
+ return;
+ } else {
+ bufferId = it->second;
+ bIdMap.erase(it);
+ ALOGV("%s: stream %d now have %zu buffer caches after removing buf %p",
+ __FUNCTION__, streamId, bIdMap.size(), handle);
+ }
+ mFreedBuffers.push_back(std::make_pair(streamId, bufferId));
+}
+
/**
* RequestThread inner class methods
*/
diff --git a/services/camera/libcameraservice/device3/Camera3Device.h b/services/camera/libcameraservice/device3/Camera3Device.h
index d873b27..5d731ed 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.h
+++ b/services/camera/libcameraservice/device3/Camera3Device.h
@@ -39,6 +39,7 @@
#include "device3/StatusTracker.h"
#include "device3/Camera3BufferManager.h"
#include "utils/TagMonitor.h"
+#include <camera_metadata_hidden.h>
/**
* Function pointer types with C calling convention to
@@ -125,7 +126,6 @@
status_t createInputStream(
uint32_t width, uint32_t height, int format,
int *id) override;
- status_t createReprocessStreamFromStream(int outputId, int *id) override;
status_t getStreamInfo(int id,
uint32_t *width, uint32_t *height,
@@ -133,7 +133,6 @@
status_t setStreamTransform(int id, int transform) override;
status_t deleteStream(int id) override;
- status_t deleteReprocessStream(int id) override;
status_t configureStreams(int operatingMode =
static_cast<int>(hardware::camera::device::V3_2::StreamConfigurationMode::NORMAL_MODE))
@@ -155,9 +154,6 @@
status_t triggerCancelAutofocus(uint32_t id) override;
status_t triggerPrecaptureMetering(uint32_t id) override;
- status_t pushReprocessBuffer(int reprocessStreamId,
- buffer_handle_t *buffer, wp<BufferReleasedListener> listener) override;
-
status_t flush(int64_t *lastFrameNumber = NULL) override;
status_t prepare(int streamId) override;
@@ -228,7 +224,7 @@
* Adapter for legacy HAL / HIDL HAL interface calls; calls either into legacy HALv3 or the
* HIDL HALv3 interfaces.
*/
- class HalInterface {
+ class HalInterface : public camera3::Camera3StreamBufferFreedListener {
public:
HalInterface(camera3_device_t *device);
HalInterface(sp<hardware::camera::device::V3_2::ICameraDeviceSession> &session);
@@ -326,6 +322,10 @@
// buffer_handle_t's FD won't change.
// return pair of (newlySeenBuffer?, bufferId)
std::pair<bool, uint64_t> getBufferId(const buffer_handle_t& buf, int streamId);
+
+ virtual void onBufferFreed(int streamId, const native_handle_t* handle) override;
+
+ std::vector<std::pair<int, uint64_t>> mFreedBuffers;
};
std::unique_ptr<HalInterface> mInterface;
@@ -1065,6 +1065,8 @@
void monitorMetadata(TagMonitor::eventSource source, int64_t frameNumber,
nsecs_t timestamp, const CameraMetadata& metadata);
+ metadata_vendor_id_t mVendorTagId;
+
/**
* Static callback forwarding methods from HAL to instance
*/
diff --git a/services/camera/libcameraservice/device3/Camera3InputStream.cpp b/services/camera/libcameraservice/device3/Camera3InputStream.cpp
index 1469b74..4eb15ad 100644
--- a/services/camera/libcameraservice/device3/Camera3InputStream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3InputStream.cpp
@@ -263,6 +263,8 @@
mConsumer->setName(String8::format("Camera3-InputStream-%d", mId));
mProducer = producer;
+
+ mConsumer->setBufferFreedListener(this);
}
res = mConsumer->setDefaultBufferSize(camera3_stream::width,
@@ -288,6 +290,17 @@
return OK;
}
+void Camera3InputStream::onBufferFreed(const wp<GraphicBuffer>& gb) {
+ const sp<GraphicBuffer> buffer = gb.promote();
+ if (buffer != nullptr) {
+ if (mBufferFreedListener != nullptr) {
+ mBufferFreedListener->onBufferFreed(mId, buffer->handle);
+ }
+ } else {
+ ALOGE("%s: GraphicBuffer is freed before onBufferFreed callback finishes!", __FUNCTION__);
+ }
+}
+
}; // namespace camera3
}; // namespace android
diff --git a/services/camera/libcameraservice/device3/Camera3InputStream.h b/services/camera/libcameraservice/device3/Camera3InputStream.h
index 9f3de10..8f5b431 100644
--- a/services/camera/libcameraservice/device3/Camera3InputStream.h
+++ b/services/camera/libcameraservice/device3/Camera3InputStream.h
@@ -34,7 +34,8 @@
* buffers by feeding them into the HAL, as well as releasing the buffers back
* the buffers once the HAL is done with them.
*/
-class Camera3InputStream : public Camera3IOStreamBase {
+class Camera3InputStream : public Camera3IOStreamBase,
+ public BufferItemConsumer::BufferFreedListener {
public:
/**
* Set up a stream for formats that have fixed size, such as RAW and YUV.
@@ -77,6 +78,11 @@
virtual status_t getEndpointUsage(uint32_t *usage) const;
+ /**
+ * BufferItemConsumer::BufferFreedListener interface
+ */
+ virtual void onBufferFreed(const wp<GraphicBuffer>&) override;
+
}; // class Camera3InputStream
}; // namespace camera3
diff --git a/services/camera/libcameraservice/device3/Camera3OutputStream.cpp b/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
index 51dc20a..e46d55e 100644
--- a/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
@@ -347,7 +347,9 @@
// Configure consumer-side ANativeWindow interface. The listener may be used
// to notify buffer manager (if it is used) of the returned buffers.
- res = mConsumer->connect(NATIVE_WINDOW_API_CAMERA, /*listener*/mBufferReleasedListener);
+ res = mConsumer->connect(NATIVE_WINDOW_API_CAMERA,
+ /*listener*/mBufferReleasedListener,
+ /*reportBufferRemoval*/true);
if (res != OK) {
ALOGE("%s: Unable to connect to native window for stream %d",
__FUNCTION__, mId);
@@ -543,6 +545,14 @@
}
}
+ if (res == OK) {
+ std::vector<sp<GraphicBuffer>> removedBuffers;
+ res = mConsumer->getAndFlushRemovedBuffers(&removedBuffers);
+ if (res == OK) {
+ onBuffersRemovedLocked(removedBuffers);
+ }
+ }
+
return res;
}
@@ -686,6 +696,16 @@
}
}
+void Camera3OutputStream::onBuffersRemovedLocked(
+ const std::vector<sp<GraphicBuffer>>& removedBuffers) {
+ Camera3StreamBufferFreedListener* callback = mBufferFreedListener;
+ if (callback != nullptr) {
+ for (auto gb : removedBuffers) {
+ callback->onBufferFreed(mId, gb->handle);
+ }
+ }
+}
+
status_t Camera3OutputStream::detachBuffer(sp<GraphicBuffer>* buffer, int* fenceFd) {
Mutex::Autolock l(mLock);
@@ -718,7 +738,12 @@
}
}
- return OK;
+ std::vector<sp<GraphicBuffer>> removedBuffers;
+ res = mConsumer->getAndFlushRemovedBuffers(&removedBuffers);
+ if (res == OK) {
+ onBuffersRemovedLocked(removedBuffers);
+ }
+ return res;
}
status_t Camera3OutputStream::notifyBufferReleased(ANativeWindowBuffer* /*anwBuffer*/) {
diff --git a/services/camera/libcameraservice/device3/Camera3OutputStream.h b/services/camera/libcameraservice/device3/Camera3OutputStream.h
index 24e4e05..86676e4 100644
--- a/services/camera/libcameraservice/device3/Camera3OutputStream.h
+++ b/services/camera/libcameraservice/device3/Camera3OutputStream.h
@@ -263,6 +263,8 @@
virtual status_t getEndpointUsage(uint32_t *usage) const;
+ void onBuffersRemovedLocked(const std::vector<sp<GraphicBuffer>>&);
+
}; // class Camera3OutputStream
} // namespace camera3
diff --git a/services/camera/libcameraservice/device3/Camera3Stream.cpp b/services/camera/libcameraservice/device3/Camera3Stream.cpp
index 53a3168..2b1a899 100644
--- a/services/camera/libcameraservice/device3/Camera3Stream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Stream.cpp
@@ -812,6 +812,18 @@
}
}
+void Camera3Stream::setBufferFreedListener(
+ Camera3StreamBufferFreedListener* listener) {
+ Mutex::Autolock l(mLock);
+ // Only allow set listener during stream configuration because stream is guaranteed to be IDLE
+ // at this state, so setBufferFreedListener won't collide with onBufferFreed callbacks
+ if (mState != STATE_IN_CONFIG && mState != STATE_IN_RECONFIG) {
+ ALOGE("%s: listener must be set during stream configuration!",__FUNCTION__);
+ return;
+ }
+ mBufferFreedListener = listener;
+}
+
}; // namespace camera3
}; // namespace android
diff --git a/services/camera/libcameraservice/device3/Camera3Stream.h b/services/camera/libcameraservice/device3/Camera3Stream.h
index 56cb827..27ef86d 100644
--- a/services/camera/libcameraservice/device3/Camera3Stream.h
+++ b/services/camera/libcameraservice/device3/Camera3Stream.h
@@ -365,6 +365,11 @@
void removeBufferListener(
const sp<Camera3StreamBufferListener>& listener);
+
+ // Setting listener will remove previous listener (if exists)
+ virtual void setBufferFreedListener(
+ Camera3StreamBufferFreedListener* listener) override;
+
/**
* Return if the buffer queue of the stream is abandoned.
*/
@@ -408,6 +413,8 @@
android_dataspace dataSpace, camera3_stream_rotation_t rotation,
int setId);
+ Camera3StreamBufferFreedListener* mBufferFreedListener;
+
/**
* Interface to be implemented by derived classes
*/
diff --git a/services/camera/libcameraservice/device3/Camera3StreamBufferFreedListener.h b/services/camera/libcameraservice/device3/Camera3StreamBufferFreedListener.h
new file mode 100644
index 0000000..478a752
--- /dev/null
+++ b/services/camera/libcameraservice/device3/Camera3StreamBufferFreedListener.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2017 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_CAMERA3_STREAMBUFFERFREEDLISTENER_H
+#define ANDROID_SERVERS_CAMERA3_STREAMBUFFERFREEDLISTENER_H
+
+#include <gui/Surface.h>
+#include <utils/RefBase.h>
+
+namespace android {
+
+namespace camera3 {
+
+class Camera3StreamBufferFreedListener {
+public:
+ // onBufferFreed is called when a buffer is no longer being managed
+ // by this stream. This will not be called in events when all
+ // buffers are freed due to stream disconnection.
+ //
+ // The input handle may be deleted after this callback ends, so attempting
+ // to dereference handle post this callback is illegal and might lead to
+ // crash.
+ //
+ // This callback will be called while holding Camera3Stream's lock, so
+ // calling into other Camera3Stream APIs within this callback will
+ // lead to deadlock.
+ virtual void onBufferFreed(int streamId, const native_handle_t* handle) = 0;
+
+ virtual ~Camera3StreamBufferFreedListener() {}
+};
+
+}; //namespace camera3
+}; //namespace android
+
+#endif
diff --git a/services/camera/libcameraservice/device3/Camera3StreamInterface.h b/services/camera/libcameraservice/device3/Camera3StreamInterface.h
index f7b092f..37b7c36 100644
--- a/services/camera/libcameraservice/device3/Camera3StreamInterface.h
+++ b/services/camera/libcameraservice/device3/Camera3StreamInterface.h
@@ -19,6 +19,7 @@
#include <utils/RefBase.h>
#include "Camera3StreamBufferListener.h"
+#include "Camera3StreamBufferFreedListener.h"
struct camera3_stream_buffer;
@@ -287,6 +288,15 @@
wp<Camera3StreamBufferListener> listener) = 0;
virtual void removeBufferListener(
const sp<Camera3StreamBufferListener>& listener) = 0;
+
+ /**
+ * Setting listner will remove previous listener (if exists)
+ * Only allow set listener during stream configuration because stream is guaranteed to be IDLE
+ * at this state, so setBufferFreedListener won't collide with onBufferFreed callbacks.
+ * Client is responsible to keep the listener object alive throughout the lifecycle of this
+ * Camera3Stream.
+ */
+ virtual void setBufferFreedListener(Camera3StreamBufferFreedListener* listener) = 0;
};
} // namespace camera3
diff --git a/services/camera/libcameraservice/tests/Android.mk b/services/camera/libcameraservice/tests/Android.mk
index 179643b..37a05c2 100644
--- a/services/camera/libcameraservice/tests/Android.mk
+++ b/services/camera/libcameraservice/tests/Android.mk
@@ -22,6 +22,9 @@
libcameraservice \
libhidlbase \
liblog \
+ libhidltransport \
+ libcamera_client \
+ libcamera_metadata \
libutils \
android.hardware.camera.common@1.0 \
android.hardware.camera.provider@2.4 \
@@ -29,6 +32,7 @@
android.hardware.camera.device@3.2
LOCAL_C_INCLUDES += \
+ system/media/private/camera/include \
LOCAL_CFLAGS += -Wall -Wextra -Werror
diff --git a/services/camera/libcameraservice/tests/CameraProviderManagerTest.cpp b/services/camera/libcameraservice/tests/CameraProviderManagerTest.cpp
index eb934ba..b18df5f 100644
--- a/services/camera/libcameraservice/tests/CameraProviderManagerTest.cpp
+++ b/services/camera/libcameraservice/tests/CameraProviderManagerTest.cpp
@@ -20,38 +20,104 @@
#include "../common/CameraProviderManager.h"
#include <android/hidl/manager/1.0/IServiceManager.h>
#include <android/hidl/manager/1.0/IServiceNotification.h>
-
+#include <android/hardware/camera/device/3.2/ICameraDeviceCallback.h>
+#include <android/hardware/camera/device/3.2/ICameraDeviceSession.h>
+#include <camera_metadata_hidden.h>
#include <gtest/gtest.h>
using namespace android;
using namespace android::hardware::camera;
using android::hardware::camera::common::V1_0::Status;
+using android::hardware::camera::common::V1_0::VendorTag;
+using android::hardware::camera::common::V1_0::VendorTagSection;
+using android::hardware::camera::common::V1_0::CameraMetadataType;
+using android::hardware::camera::device::V3_2::ICameraDeviceCallback;
+using android::hardware::camera::device::V3_2::ICameraDeviceSession;
+
+/**
+ * Basic test implementation of a camera ver. 3.2 device interface
+ */
+struct TestDeviceInterface : public device::V3_2::ICameraDevice {
+ std::vector<hardware::hidl_string> mDeviceNames;
+ TestDeviceInterface(std::vector<hardware::hidl_string> deviceNames) :
+ mDeviceNames(deviceNames) {}
+ using getResourceCost_cb = std::function<void(
+ hardware::camera::common::V1_0::Status status,
+ const hardware::camera::common::V1_0::CameraResourceCost& resourceCost)>;
+ virtual ::android::hardware::Return<void> getResourceCost(
+ getResourceCost_cb _hidl_cb) override {
+ hardware::camera::common::V1_0::CameraResourceCost resourceCost = {100,
+ mDeviceNames};
+ _hidl_cb(Status::OK, resourceCost);
+ return hardware::Void();
+ }
+
+ using getCameraCharacteristics_cb = std::function<void(
+ hardware::camera::common::V1_0::Status status,
+ const hardware::hidl_vec<uint8_t>& cameraCharacteristics)>;
+ hardware::Return<void> getCameraCharacteristics(
+ getCameraCharacteristics_cb _hidl_cb) override {
+ hardware::hidl_vec<uint8_t> cameraCharacteristics;
+ _hidl_cb(Status::OK, cameraCharacteristics);
+ return hardware::Void();
+ }
+
+ hardware::Return<hardware::camera::common::V1_0::Status> setTorchMode(
+ ::android::hardware::camera::common::V1_0::TorchMode) override {
+ return Status::OK;
+ }
+
+ using open_cb = std::function<void(
+ ::android::hardware::camera::common::V1_0::Status status,
+ const ::android::sp<ICameraDeviceSession>& session)>;
+ hardware::Return<void> open(
+ const ::android::sp<ICameraDeviceCallback>&,
+ open_cb _hidl_cb) override {
+ sp<ICameraDeviceSession> deviceSession = nullptr;
+ _hidl_cb(Status::OK, deviceSession);
+ return hardware::Void();
+ }
+
+ hardware::Return<void> dumpState(
+ const ::android::hardware::hidl_handle&) override {
+ return hardware::Void();
+ }
+};
/**
* Basic test implementation of a camera provider
*/
struct TestICameraProvider : virtual public provider::V2_4::ICameraProvider {
- sp<provider::V2_4::ICameraProviderCallbacks> mCallbacks;
-
+ sp<provider::V2_4::ICameraProviderCallback> mCallbacks;
std::vector<hardware::hidl_string> mDeviceNames;
+ sp<device::V3_2::ICameraDevice> mDeviceInterface;
+ hardware::hidl_vec<common::V1_0::VendorTagSection> mVendorTagSections;
- 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");
- }
+ TestICameraProvider(const std::vector<hardware::hidl_string> &devices,
+ const hardware::hidl_vec<common::V1_0::VendorTagSection> &vendorSection) :
+ mDeviceNames(devices),
+ mDeviceInterface(new TestDeviceInterface(devices)),
+ mVendorTagSections (vendorSection) {}
- virtual hardware::Return<Status> setCallbacks(
- const sp<provider::V2_4::ICameraProviderCallbacks>& callbacks) override {
+ virtual hardware::Return<Status> setCallback(
+ const sp<provider::V2_4::ICameraProviderCallback>& 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);
+ hardware::Return<void> getVendorTags(getVendorTags_cb _hidl_cb) override {
+ _hidl_cb(Status::OK, mVendorTagSections);
+ return hardware::Void();
+ }
+
+ using isSetTorchModeSupported_cb = std::function<void(
+ ::android::hardware::camera::common::V1_0::Status status,
+ bool support)>;
+ virtual ::hardware::Return<void> isSetTorchModeSupported(
+ isSetTorchModeSupported_cb _hidl_cb) override {
+ _hidl_cb(Status::OK, false);
return hardware::Void();
}
@@ -68,17 +134,17 @@
const hardware::hidl_string& cameraDeviceName,
getCameraDeviceInterface_V1_x_cb _hidl_cb) override {
(void) cameraDeviceName;
- _hidl_cb(Status::OK, nullptr);
+ _hidl_cb(Status::OK, nullptr); //TODO: impl. of ver. 1.0 device interface
+ // otherwise enumeration will fail.
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,
+ const hardware::hidl_string&,
getCameraDeviceInterface_V3_x_cb _hidl_cb) override {
- (void) cameraDeviceName;
- _hidl_cb(Status::OK, nullptr);
+ _hidl_cb(Status::OK, mDeviceInterface);
return hardware::Void();
}
@@ -90,12 +156,13 @@
*/
struct TestInteractionProxy : public CameraProviderManager::ServiceInteractionProxy {
sp<hidl::manager::V1_0::IServiceNotification> mManagerNotificationInterface;
- const sp<TestICameraProvider> mTestCameraProvider;
+ sp<TestICameraProvider> mTestCameraProvider;
- TestInteractionProxy() :
- mTestCameraProvider(new TestICameraProvider()) {
-
+ TestInteractionProxy() {}
+ void setProvider(sp<TestICameraProvider> provider) {
+ mTestCameraProvider = provider;
}
+
std::string mLastRequestedServiceName;
virtual ~TestInteractionProxy() {}
@@ -116,13 +183,30 @@
};
-TEST(CameraProviderManagerTest, InitializeTest) {
+struct TestStatusListener : public CameraProviderManager::StatusListener {
+ ~TestStatusListener() {}
+ void onDeviceStatusChanged(const String8 &,
+ hardware::camera::common::V1_0::CameraDeviceStatus) override {}
+ void onTorchStatusChanged(const String8 &,
+ hardware::camera::common::V1_0::TorchModeStatus) override {}
+};
+
+TEST(CameraProviderManagerTest, InitializeTest) {
+ std::vector<hardware::hidl_string> deviceNames;
+ deviceNames.push_back("device@3.2/test/0");
+ deviceNames.push_back("device@1.0/test/0");
+ deviceNames.push_back("device@3.2/test/1");
+ hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
status_t res;
sp<CameraProviderManager> providerManager = new CameraProviderManager();
- TestInteractionProxy serviceProxy{};
+ sp<TestStatusListener> statusListener = new TestStatusListener();
+ TestInteractionProxy serviceProxy;
+ sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
+ vendorSection);
+ serviceProxy.setProvider(provider);
- res = providerManager->initialize(&serviceProxy);
+ res = providerManager->initialize(statusListener, &serviceProxy);
ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
hardware::hidl_string legacyInstanceName = "legacy/0";
@@ -139,3 +223,145 @@
ASSERT_EQ(serviceProxy.mLastRequestedServiceName, testProviderInstanceName) <<
"Incorrect instance requested from service manager";
}
+
+TEST(CameraProviderManagerTest, MultipleVendorTagTest) {
+ hardware::hidl_string sectionName = "VendorTestSection";
+ hardware::hidl_string tagName = "VendorTestTag";
+ uint32_t tagId = VENDOR_SECTION << 16;
+ hardware::hidl_vec<common::V1_0::VendorTagSection> vendorSection;
+ CameraMetadataType tagType = CameraMetadataType::BYTE;
+ vendorSection.resize(1);
+ vendorSection[0].sectionName = sectionName;
+ vendorSection[0].tags.resize(1);
+ vendorSection[0].tags[0].tagId = tagId;
+ vendorSection[0].tags[0].tagName = tagName;
+ vendorSection[0].tags[0].tagType = tagType;
+ std::vector<hardware::hidl_string> deviceNames = {"device@3.2/test/0"};
+
+ sp<CameraProviderManager> providerManager = new CameraProviderManager();
+ sp<TestStatusListener> statusListener = new TestStatusListener();
+ TestInteractionProxy serviceProxy;
+
+ sp<TestICameraProvider> provider = new TestICameraProvider(deviceNames,
+ vendorSection);
+ serviceProxy.setProvider(provider);
+
+ auto res = providerManager->initialize(statusListener, &serviceProxy);
+ ASSERT_EQ(res, OK) << "Unable to initialize provider manager";
+
+ hardware::hidl_string testProviderInstanceName = "test/0";
+ hardware::hidl_string testProviderFqInterfaceName =
+ "android.hardware.camera.provider@2.4::ICameraProvider";
+ serviceProxy.mManagerNotificationInterface->onRegistration(
+ testProviderFqInterfaceName, testProviderInstanceName, false);
+ ASSERT_EQ(serviceProxy.mLastRequestedServiceName, testProviderInstanceName) <<
+ "Incorrect instance requested from service manager";
+
+ hardware::hidl_string sectionNameSecond = "SecondVendorTestSection";
+ hardware::hidl_string secondTagName = "SecondVendorTestTag";
+ CameraMetadataType secondTagType = CameraMetadataType::DOUBLE;
+ vendorSection[0].sectionName = sectionNameSecond;
+ vendorSection[0].tags[0].tagId = tagId;
+ vendorSection[0].tags[0].tagName = secondTagName;
+ vendorSection[0].tags[0].tagType = secondTagType;
+ deviceNames = {"device@3.2/test2/1"};
+
+ sp<TestICameraProvider> secondProvider = new TestICameraProvider(
+ deviceNames, vendorSection);
+ serviceProxy.setProvider(secondProvider);
+ hardware::hidl_string testProviderSecondInstanceName = "test2/0";
+ serviceProxy.mManagerNotificationInterface->onRegistration(
+ testProviderFqInterfaceName, testProviderSecondInstanceName, false);
+ ASSERT_EQ(serviceProxy.mLastRequestedServiceName,
+ testProviderSecondInstanceName) <<
+ "Incorrect instance requested from service manager";
+
+ ASSERT_EQ(NO_ERROR , providerManager->setUpVendorTags());
+ sp<VendorTagDescriptorCache> vendorCache =
+ VendorTagDescriptorCache::getGlobalVendorTagCache();
+ ASSERT_NE(nullptr, vendorCache.get());
+
+ metadata_vendor_id_t vendorId = std::hash<std::string> {} (
+ testProviderInstanceName.c_str());
+ metadata_vendor_id_t vendorIdSecond = std::hash<std::string> {} (
+ testProviderSecondInstanceName.c_str());
+
+ hardware::hidl_string resultTag = vendorCache->getTagName(tagId, vendorId);
+ ASSERT_EQ(resultTag, tagName);
+
+ resultTag = vendorCache->getTagName(tagId, vendorIdSecond);
+ ASSERT_EQ(resultTag, secondTagName);
+
+ // Check whether we can create two separate CameraMetadata instances
+ // using different tag vendor vendors.
+ camera_metadata *metaBuffer = allocate_camera_metadata(10, 20);
+ ASSERT_NE(nullptr, metaBuffer);
+ set_camera_metadata_vendor_id(metaBuffer, vendorId);
+ CameraMetadata metadata(metaBuffer);
+
+ uint8_t byteVal = 10;
+ ASSERT_TRUE(metadata.isEmpty());
+ ASSERT_EQ(OK, metadata.update(tagId, &byteVal, 1));
+ ASSERT_FALSE(metadata.isEmpty());
+ ASSERT_TRUE(metadata.exists(tagId));
+
+ metaBuffer = allocate_camera_metadata(10, 20);
+ ASSERT_NE(nullptr, metaBuffer);
+ set_camera_metadata_vendor_id(metaBuffer, vendorIdSecond);
+ CameraMetadata secondMetadata(metaBuffer);
+
+ ASSERT_TRUE(secondMetadata.isEmpty());
+ double doubleVal = 1.0f;
+ ASSERT_EQ(OK, secondMetadata.update(tagId, &doubleVal, 1));
+ ASSERT_FALSE(secondMetadata.isEmpty());
+ ASSERT_TRUE(secondMetadata.exists(tagId));
+
+ // Check whether CameraMetadata copying works as expected
+ CameraMetadata metadataCopy(metadata);
+ ASSERT_FALSE(metadataCopy.isEmpty());
+ ASSERT_TRUE(metadataCopy.exists(tagId));
+ ASSERT_EQ(OK, metadataCopy.update(tagId, &byteVal, 1));
+ ASSERT_TRUE(metadataCopy.exists(tagId));
+
+ // Check whether values are as expected
+ camera_metadata_entry_t entry = metadata.find(tagId);
+ ASSERT_EQ(1u, entry.count);
+ ASSERT_EQ(byteVal, entry.data.u8[0]);
+ entry = secondMetadata.find(tagId);
+ ASSERT_EQ(1u, entry.count);
+ ASSERT_EQ(doubleVal, entry.data.d[0]);
+
+ // Swap and erase
+ secondMetadata.swap(metadataCopy);
+ ASSERT_TRUE(metadataCopy.exists(tagId));
+ ASSERT_TRUE(secondMetadata.exists(tagId));
+ ASSERT_EQ(OK, secondMetadata.erase(tagId));
+ ASSERT_TRUE(secondMetadata.isEmpty());
+ doubleVal = 0.0f;
+ ASSERT_EQ(OK, metadataCopy.update(tagId, &doubleVal, 1));
+ entry = metadataCopy.find(tagId);
+ ASSERT_EQ(1u, entry.count);
+ ASSERT_EQ(doubleVal, entry.data.d[0]);
+
+ // Append
+ uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_ACTION;
+ secondMetadata.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
+ // Append from two different vendor tag providers is not supported!
+ ASSERT_NE(OK, metadataCopy.append(secondMetadata));
+ ASSERT_EQ(OK, metadataCopy.erase(tagId));
+ metadataCopy.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
+ // However appending from same vendor tag provider should be fine
+ ASSERT_EQ(OK, metadata.append(secondMetadata));
+ // Append from a metadata without vendor tag provider should not be supported
+ CameraMetadata regularMetadata(10, 20);
+ uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
+ regularMetadata.update(ANDROID_CONTROL_MODE, &controlMode, 1);
+ ASSERT_NE(OK, secondMetadata.append(regularMetadata));
+ ASSERT_EQ(1u, secondMetadata.entryCount());
+ ASSERT_EQ(2u, metadata.entryCount());
+
+ // Dump
+ metadata.dump(1, 2);
+ metadataCopy.dump(1, 2);
+ secondMetadata.dump(1, 2);
+}
diff --git a/services/camera/libcameraservice/utils/TagMonitor.cpp b/services/camera/libcameraservice/utils/TagMonitor.cpp
index f1b65bd..dec97d7 100644
--- a/services/camera/libcameraservice/utils/TagMonitor.cpp
+++ b/services/camera/libcameraservice/utils/TagMonitor.cpp
@@ -23,12 +23,14 @@
#include <inttypes.h>
#include <utils/Log.h>
#include <camera/VendorTagDescriptor.h>
+#include <camera_metadata_hidden.h>
namespace android {
TagMonitor::TagMonitor():
mMonitoringEnabled(false),
- mMonitoringEvents(kMaxMonitorEvents)
+ mMonitoringEvents(kMaxMonitorEvents),
+ mVendorTagId(CAMERA_METADATA_INVALID_VENDOR_ID)
{}
const char* TagMonitor::k3aTags =
@@ -55,6 +57,13 @@
sp<VendorTagDescriptor> vTags =
VendorTagDescriptor::getGlobalVendorTagDescriptor();
+ if ((nullptr == vTags.get()) || (0 >= vTags->getTagCount())) {
+ sp<VendorTagDescriptorCache> cache =
+ VendorTagDescriptorCache::getGlobalVendorTagCache();
+ if (cache.get()) {
+ cache->getVendorTagDescriptor(mVendorTagId, &vTags);
+ }
+ }
bool gotTag = false;
@@ -104,6 +113,15 @@
camera_metadata_ro_entry entry = metadata.find(tag);
CameraMetadata &lastValues = (source == REQUEST) ?
mLastMonitoredRequestValues : mLastMonitoredResultValues;
+ if (lastValues.isEmpty()) {
+ lastValues = CameraMetadata(mMonitoredTagList.size());
+ const camera_metadata_t *metaBuffer =
+ lastValues.getAndLock();
+ set_camera_metadata_vendor_id(
+ const_cast<camera_metadata_t *> (metaBuffer), mVendorTagId);
+ lastValues.unlock(metaBuffer);
+ }
+
camera_metadata_entry lastEntry = lastValues.find(tag);
if (entry.count > 0) {
@@ -129,16 +147,21 @@
}
if (isDifferent) {
- ALOGV("%s: Tag %s changed", __FUNCTION__, get_camera_metadata_tag_name(tag));
+ ALOGV("%s: Tag %s changed", __FUNCTION__,
+ get_local_camera_metadata_tag_name_vendor_id(
+ tag, mVendorTagId));
lastValues.update(entry);
mMonitoringEvents.emplace(source, frameNumber, timestamp, entry);
}
} else if (lastEntry.count > 0) {
// Value has been removed
- ALOGV("%s: Tag %s removed", __FUNCTION__, get_camera_metadata_tag_name(tag));
+ ALOGV("%s: Tag %s removed", __FUNCTION__,
+ get_local_camera_metadata_tag_name_vendor_id(
+ tag, mVendorTagId));
lastValues.erase(tag);
entry.tag = tag;
- entry.type = get_camera_metadata_tag_type(tag);
+ entry.type = get_local_camera_metadata_tag_type_vendor_id(tag,
+ mVendorTagId);
entry.count = 0;
mMonitoringEvents.emplace(source, frameNumber, timestamp, entry);
}
@@ -152,8 +175,10 @@
dprintf(fd, " Tag monitoring enabled for tags:\n");
for (uint32_t tag : mMonitoredTagList) {
dprintf(fd, " %s.%s\n",
- get_camera_metadata_section_name(tag),
- get_camera_metadata_tag_name(tag));
+ get_local_camera_metadata_section_name_vendor_id(tag,
+ mVendorTagId),
+ get_local_camera_metadata_tag_name_vendor_id(tag,
+ mVendorTagId));
}
} else {
dprintf(fd, " Tag monitoring disabled (enable with -m <name1,..,nameN>)\n");
@@ -166,8 +191,10 @@
event.frameNumber, event.timestamp,
indentation,
event.source == REQUEST ? "REQ:" : "RES:",
- get_camera_metadata_section_name(event.tag),
- get_camera_metadata_tag_name(event.tag));
+ get_local_camera_metadata_section_name_vendor_id(event.tag,
+ mVendorTagId),
+ get_local_camera_metadata_tag_name_vendor_id(event.tag,
+ mVendorTagId));
if (event.newData.size() == 0) {
dprintf(fd, " (Removed)\n");
} else {
diff --git a/services/camera/libcameraservice/utils/TagMonitor.h b/services/camera/libcameraservice/utils/TagMonitor.h
index d7aa419..7155314 100644
--- a/services/camera/libcameraservice/utils/TagMonitor.h
+++ b/services/camera/libcameraservice/utils/TagMonitor.h
@@ -27,6 +27,7 @@
#include <media/RingBuffer.h>
#include <system/camera_metadata.h>
+#include <system/camera_vendor_tags.h>
#include <camera/CameraMetadata.h>
namespace android {
@@ -44,6 +45,8 @@
TagMonitor();
+ void initialize(metadata_vendor_id_t id) { mVendorTagId = id; }
+
// Parse tag name list (comma-separated) and if valid, enable monitoring
// If invalid, do nothing.
// Recognizes "3a" as a shortcut for enabling tracking 3A state, mode, and
@@ -100,6 +103,7 @@
// 3A fields to use with the "3a" option
static const char *k3aTags;
+ metadata_vendor_id_t mVendorTagId;
};
} // namespace android
diff --git a/services/mediaanalytics/Android.mk b/services/mediaanalytics/Android.mk
index ef49df4..f7197af 100644
--- a/services/mediaanalytics/Android.mk
+++ b/services/mediaanalytics/Android.mk
@@ -18,6 +18,7 @@
libgui \
libmedia \
libmediautils \
+ libmediametrics \
libstagefright_foundation \
libutils
diff --git a/services/mediacodec/main_codecservice.cpp b/services/mediacodec/main_codecservice.cpp
index 38717b5..3a4546b 100644
--- a/services/mediacodec/main_codecservice.cpp
+++ b/services/mediacodec/main_codecservice.cpp
@@ -54,9 +54,7 @@
::android::hardware::configureRpcThreadpool(64, false);
sp<ProcessState> proc(ProcessState::self());
- int32_t trebleOmx = property_get_int32("persist.media.treble_omx", -1);
- if ((trebleOmx == 1) || ((trebleOmx == -1) &&
- property_get_bool("persist.hal.binderization", 0))) {
+ if (property_get_bool("persist.media.treble_omx", true)) {
using namespace ::android::hardware::media::omx::V1_0;
sp<IOmx> omx = new implementation::Omx();
if (omx == nullptr) {
diff --git a/services/mediadrm/Android.mk b/services/mediadrm/Android.mk
index 87fddd4..1d5fa07 100644
--- a/services/mediadrm/Android.mk
+++ b/services/mediadrm/Android.mk
@@ -40,7 +40,13 @@
endif
LOCAL_MODULE:= mediadrmserver
+
+# TODO: Some legacy DRM plugins only support 32-bit. They need to be migrated to
+# 64-bit. (b/18948909) Once all of a device's legacy DRM plugins support 64-bit,
+# that device can turn on ENABLE_MEDIADRM_64 to build this service as 64-bit.
+ifneq ($(ENABLE_MEDIADRM_64), true)
LOCAL_32_BIT_ONLY := true
+endif
LOCAL_INIT_RC := mediadrmserver.rc
diff --git a/services/mediaextractor/MediaExtractorService.cpp b/services/mediaextractor/MediaExtractorService.cpp
index 4a80166..08cbef6 100644
--- a/services/mediaextractor/MediaExtractorService.cpp
+++ b/services/mediaextractor/MediaExtractorService.cpp
@@ -22,6 +22,7 @@
#include <media/stagefright/DataSource.h>
#include <media/stagefright/MediaExtractor.h>
+#include <media/stagefright/RemoteDataSource.h>
#include "MediaExtractorService.h"
namespace android {
@@ -45,6 +46,12 @@
return ret;
}
+sp<IDataSource> MediaExtractorService::makeIDataSource(int fd, int64_t offset, int64_t length)
+{
+ sp<DataSource> source = DataSource::CreateFromFd(fd, offset, length);
+ return source.get() != nullptr ? source->asIDataSource() : nullptr;
+}
+
status_t MediaExtractorService::dump(int fd, const Vector<String16>& args) {
return dumpExtractors(fd, args);
}
diff --git a/services/mediaextractor/MediaExtractorService.h b/services/mediaextractor/MediaExtractorService.h
index 078af0c..9df3ecd 100644
--- a/services/mediaextractor/MediaExtractorService.h
+++ b/services/mediaextractor/MediaExtractorService.h
@@ -34,6 +34,9 @@
static const char* getServiceName() { return "media.extractor"; }
virtual sp<IMediaExtractor> makeExtractor(const sp<IDataSource> &source, const char *mime);
+
+ virtual sp<IDataSource> makeIDataSource(int fd, int64_t offset, int64_t length);
+
virtual status_t dump(int fd, const Vector<String16>& args);
virtual status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply,
diff --git a/services/mediaextractor/seccomp_policy/mediaextractor-arm.policy b/services/mediaextractor/seccomp_policy/mediaextractor-arm.policy
index 96840a0..4e4ce30 100644
--- a/services/mediaextractor/seccomp_policy/mediaextractor-arm.policy
+++ b/services/mediaextractor/seccomp_policy/mediaextractor-arm.policy
@@ -37,6 +37,11 @@
getgid32: 1
getegid32: 1
getgroups32: 1
+nanosleep: 1
+
+# for FileSource
+readlinkat: 1
+_llseek: 1
# for attaching to debuggerd on process crash
sigaction: 1
diff --git a/services/mediaextractor/seccomp_policy/mediaextractor-arm64.policy b/services/mediaextractor/seccomp_policy/mediaextractor-arm64.policy
index c95ddb7..1683adb 100644
--- a/services/mediaextractor/seccomp_policy/mediaextractor-arm64.policy
+++ b/services/mediaextractor/seccomp_policy/mediaextractor-arm64.policy
@@ -26,6 +26,11 @@
exit_group: 1
rt_sigreturn: 1
getrlimit: 1
+nanosleep: 1
+
+# for FileSource
+readlinkat: 1
+_llseek: 1
# for attaching to debuggerd on process crash
tgkill: 1
diff --git a/services/mediaextractor/seccomp_policy/mediaextractor-x86.policy b/services/mediaextractor/seccomp_policy/mediaextractor-x86.policy
index 2ce6cf8..83725cd 100644
--- a/services/mediaextractor/seccomp_policy/mediaextractor-x86.policy
+++ b/services/mediaextractor/seccomp_policy/mediaextractor-x86.policy
@@ -37,6 +37,10 @@
getgroups32: 1
nanosleep: 1
+# for FileSource
+readlinkat: 1
+_llseek: 1
+
# for attaching to debuggerd on process crash
socketcall: 1
sigaction: 1