/** * \brief Convert `HGraphicBufferProducer::FrameEventHistoryDelta` to * `::android::FrameEventHistoryDelta`. * * \param[out] l The destination `::android::FrameEventHistoryDelta`. * \param[in] t The source `HGraphicBufferProducer::FrameEventHistoryDelta`. * * This function will duplicate all file descriptors contained in \p t. */ inline bool convertTo( ::android::FrameEventHistoryDelta* l, HGraphicBufferProducer::FrameEventHistoryDelta const& t) { size_t const baseSize = getFlattenedSize(t); std::unique_ptr<uint8_t[]> baseBuffer( new (std::nothrow) uint8_t[baseSize]); if (!baseBuffer) { return false; } size_t const baseNumFds = getFdCount(t); std::unique_ptr<int[]> baseFds( new (std::nothrow) int[baseNumFds]); if (!baseFds) { return false; } void* buffer = static_cast<void*>(baseBuffer.get()); size_t size = baseSize; int* fds = static_cast<int*>(baseFds.get()); size_t numFds = baseNumFds; std::vector<std::vector<native_handle_t*> > nhAA; if (flatten(t, &nhAA, buffer, size, fds, numFds) != NO_ERROR) { return false; } void const* constBuffer = static_cast<void const*>(baseBuffer.get()); size = baseSize; int const* constFds = static_cast<int const*>(baseFds.get()); numFds = baseNumFds; if (l->unflatten(constBuffer, size, constFds, numFds) != NO_ERROR) { for (auto nhA : nhAA) { for (auto nh : nhA) { if (nh != nullptr) { native_handle_close(nh); native_handle_delete(nh); } } } return false; } for (auto nhA : nhAA) { for (auto nh : nhA) { if (nh != nullptr) { native_handle_delete(nh); } } } return true; }
OverlayRef::~OverlayRef() { if (mOwnHandle) { native_handle_close(mOverlayHandle); native_handle_delete(const_cast<native_handle*>(mOverlayHandle)); } }
static int data__data_open(struct sensors_data_device_t *dev, native_handle_t* handle) { SensorData* data = (void*)dev; int i; D("%s: dev=%p", __FUNCTION__, dev); memset(&data->sensors, 0, sizeof(data->sensors)); for (i=0 ; i<MAX_NUM_SENSORS ; i++) { data->sensors[i].vector.status = SENSOR_STATUS_ACCURACY_HIGH; } if (acc_event_fd < 0 || mag_event_fd < 0) { acc_event_fd = dup(handle->data[0]); mag_event_fd = dup(handle->data[1]);; if ((acc_event_fd < 0) || (mag_event_fd < 0)) { LOGE("%s fail to open input devices",__FUNCTION__); return -1; } else { int mx, my, mz; MEMSAlgLib_eCompass_Init(1000,1000); //if find the last record of calibration data if(!read_sensor_calibration_data(&mx, &my, &mz)) //platform related API MEMSAlgLib_eCompass_SetCalibration(mx, my, mz); } } data->pendingSensors = 0; native_handle_close(handle); native_handle_delete(handle); return 0; }
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); } }
// --------------------------------------------------------------------------- // QCameraStream_record // --------------------------------------------------------------------------- void QCameraStream_record::stop() { status_t ret = NO_ERROR; ALOGE("%s: BEGIN", __func__); mHalCamCtrl->mStartRecording = false; Mutex::Autolock l(&mHalCamCtrl->mRecordLock); Mutex::Autolock lock(mStopCallbackLock); { mHalCamCtrl->mRecordFrameLock.lock(); mHalCamCtrl->mReleasedRecordingFrame = true; mHalCamCtrl->mRecordWait.signal(); mHalCamCtrl-> mRecordFrameLock.unlock(); } for(int cnt = 0; cnt < mHalCamCtrl->mPreviewMemory.buffer_count; cnt++) { if (mHalCamCtrl->mStoreMetaDataInFrame) { struct encoder_media_buffer_type * packet = (struct encoder_media_buffer_type *) mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->data; native_handle_delete(const_cast<native_handle_t *>(packet->meta_handle)); mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->release( mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]); } } ALOGV("%s: END", __func__); }
void OMXVideoDecoderAVCSecure::MemFreeDataBuffer(OMX_U8 *pBuffer) { if (pBuffer == NULL) { ALOGE("%s: trying to free NULL pointer", __FUNCTION__); return; } if (mNumInportBuffers == 0) { ALOGE("%s: allocated inport buffer count is already 0, cannot delete buffer %p", __FUNCTION__, pBuffer); return; } native_handle_t *native_handle = (native_handle_t *) pBuffer; ProtectedDataBuffer *dataBuffer = (ProtectedDataBuffer *) native_handle->data[1]; if (dataBuffer->magic != PROTECTED_DATA_BUFFER_MAGIC) { ALOGE("%s: attempting to free buffer with a wrong magic 0x%08x", __FUNCTION__, dataBuffer->magic); return; } if (munmap(dataBuffer, sizeof(ProtectedDataBuffer)) != 0) { ALOGE("%s: Faild to munmap %p",__FUNCTION__, dataBuffer); return; } native_handle_close(native_handle); native_handle_delete(native_handle); ALOGV("Free databuffer %p with data = %p", dataBuffer, dataBuffer->data); --mNumInportBuffers; }
status_t H2BGraphicBufferProducer::queueBuffer( int slot, const QueueBufferInput& input, QueueBufferOutput* output) { HGraphicBufferProducer::QueueBufferInput tInput; native_handle_t* nh; if (!wrapAs(&tInput, &nh, input)) { ALOGE("H2BGraphicBufferProducer::queueBuffer - " "Invalid input"); return BAD_VALUE; } status_t fnStatus; status_t transStatus = toStatusT(mBase->queueBuffer(slot, tInput, [&fnStatus, output] ( Status status, HGraphicBufferProducer::QueueBufferOutput const& tOutput) { fnStatus = toStatusT(status); if (!convertTo(output, tOutput)) { ALOGE("H2BGraphicBufferProducer::queueBuffer - " "Invalid output"); fnStatus = fnStatus == NO_ERROR ? BAD_VALUE : fnStatus; } })); native_handle_delete(nh); return transStatus == NO_ERROR ? fnStatus : transStatus; }
LayerBuffer::Buffer::~Buffer() { NativeBuffer& src(mNativeBuffer); if (src.img.handle) { native_handle_delete(src.img.handle); } }
/** * \brief Flatten `FrameEventHistoryDelta`. * * \param[in] t The source `FrameEventHistoryDelta`. * \param[out] nh The array of arrays of cloned native handles. * \param[in,out] buffer The pointer to the flat non-fd buffer. * \param[in,out] size The size of the flat non-fd buffer. * \param[in,out] fds The pointer to the flat fd buffer. * \param[in,out] numFds The size of the flat fd buffer. * \return `NO_ERROR` on success; other value on failure. * * On success, this function will duplicate file descriptors contained in \p t. * The cloned native handles will be stored in \p nh. Before making the call, \p * nh should have enough space to store `n` pointers to arrays of native * handles, where `n` is the length of `t.deltas`, and each `nh[i]` should have * enough space to store `4` native handles. */ inline status_t flatten( HGraphicBufferProducer::FrameEventHistoryDelta const& t, std::vector<std::vector<native_handle_t*> >* nh, void*& buffer, size_t& size, int*& fds, size_t& numFds) { if (t.deltas.size() > ::android::FrameEventHistory::MAX_FRAME_HISTORY) { return BAD_VALUE; } if (size < getFlattenedSize(t)) { return NO_MEMORY; } FlattenableUtils::write(buffer, size, t.compositorTiming); FlattenableUtils::write(buffer, size, static_cast<uint32_t>(t.deltas.size())); nh->resize(t.deltas.size()); for (size_t deltaIndex = 0; deltaIndex < t.deltas.size(); ++deltaIndex) { status_t status = flatten( t.deltas[deltaIndex], &((*nh)[deltaIndex]), buffer, size, fds, numFds); if (status != NO_ERROR) { while (deltaIndex > 0) { --deltaIndex; for (size_t snapshotIndex = 0; snapshotIndex < 4; ++snapshotIndex) { native_handle_close((*nh)[deltaIndex][snapshotIndex]); native_handle_delete((*nh)[deltaIndex][snapshotIndex]); (*nh)[deltaIndex][snapshotIndex] = nullptr; } } return status; } } return NO_ERROR; }
status_t StreamHalHidl::dump(int fd) { if (!mStream) return NO_INIT; native_handle_t* hidlHandle = native_handle_create(1, 0); hidlHandle->data[0] = fd; Return<void> ret = mStream->debugDump(hidlHandle); native_handle_delete(hidlHandle); return processReturn("dump", ret); }
void GraphicBuffer::free_handle() { if (mOwner == ownHandle) { native_handle_close(handle); native_handle_delete(const_cast<native_handle*>(handle)); } else if (mOwner == ownData) { GraphicBufferAllocator& allocator(GraphicBufferAllocator::get()); allocator.free(handle); } }
ServerWaylandBuffer::~ServerWaylandBuffer() { if (m_buf) wl_buffer_destroy(m_buf); m_gralloc->unregisterBuffer(m_gralloc, handle); native_handle_close(handle); native_handle_delete(const_cast<native_handle_t *>(handle)); wl_array_release(&ints); wl_array_release(&fds); }
void GraphicBuffer::free_handle() { if (mOwner == ownHandle) { mBufferMapper.unregisterBuffer(handle); native_handle_close(handle); native_handle_delete(const_cast<native_handle*>(handle)); } else if (mOwner == ownData) { GraphicBufferAllocator& allocator(GraphicBufferAllocator::get()); allocator.free(handle); } mWrappedBuffer = 0; }
void releaseRecordingFrameHandle(native_handle_t *handle) { ALOGV("releaseRecordingFrameHandle"); Parcel data, reply; data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor()); data.writeNativeHandle(handle); remote()->transact(RELEASE_RECORDING_FRAME_HANDLE, data, &reply); // Close the native handle because camera received a dup copy. native_handle_close(handle); native_handle_delete(handle); }
void recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_handle_t* handle) { ALOGV("recordingFrameHandleCallbackTimestamp"); Parcel data, reply; data.writeInterfaceToken(ICameraRecordingProxyListener::getInterfaceDescriptor()); data.writeInt64(timestamp); data.writeNativeHandle(handle); remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP, data, &reply, IBinder::FLAG_ONEWAY); // The native handle is dupped in ICameraClient so we need to free it here. native_handle_close(handle); native_handle_delete(handle); }
void QCameraStream_record::releaseEncodeBuffer() { for(int cnt = 0; cnt < mHalCamCtrl->mPreviewMemory.buffer_count; cnt++) { if (mHalCamCtrl->mStoreMetaDataInFrame) { struct encoder_media_buffer_type * packet = (struct encoder_media_buffer_type *) mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->data; native_handle_delete(const_cast<native_handle_t *>(packet->meta_handle)); mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]->release( mHalCamCtrl->mRecordingMemory.metadata_memory[cnt]); } } }
int hybris_gralloc_release(buffer_handle_t handle, int was_allocated) { int ret = -ENOSYS; if GRALLOC1( ret = gralloc1_release(gralloc1_device, handle); // this needs to happen if the last reference is gone, this function is // only called in such cases. if (!gralloc1_release_implies_delete) { native_handle_close((native_handle_t*)handle); native_handle_delete((native_handle_t*)handle); } ) else if GRALLOC0(
status_t H2BGraphicBufferProducer::cancelBuffer(int slot, const sp<Fence>& fence) { hidl_handle tFence; native_handle_t* nh = nullptr; if ((fence == nullptr) || !wrapAs(&tFence, &nh, *fence)) { ALOGE("H2BGraphicBufferProducer::cancelBuffer - " "Invalid input fence"); return BAD_VALUE; } status_t status = toStatusT(mBase->cancelBuffer( static_cast<int32_t>(slot), tFence)); native_handle_delete(nh); return status; }
static int sensors_open(struct sensors_data_device_t *dev, native_handle_t* hd) { event_fd = open(SYSFS_PATH "coord", O_RDONLY | O_NONBLOCK); if (event_fd < 0) { LOGE("coord open failed in %s: %s", __FUNCTION__, strerror(errno)); return -1; } sensors.vector.status = SENSOR_STATUS_ACCURACY_HIGH; LOGD("%s\n", __func__); write_int("ths", DEFAULT_THRESHOLD); native_handle_close(hd); native_handle_delete(hd); return 0; }
native_handle_t* sensors_proxy_open_all_dev(SensorsProxy* proxy) { int i=0; native_handle_t* handle = native_handle_create(2, 0);; for(i=0;i<numSensorDrivers;i++) { handle->data[i]= sensor_open_dev(proxy->mSensors[i]); if(handle->data[i]<0) { native_handle_close(handle); native_handle_delete(handle); handle = NULL; break; } } return handle; }
static int data__data_open(struct sensors_poll_device_t *dev, native_handle_t* handle) { SensorPoll* data = (void*)dev; int i; D("%s: dev=%p fd=%d", __FUNCTION__, dev, handle->data[0]); memset(&data->sensors, 0, sizeof(data->sensors)); data->pendingSensors = 0; data->timeStart = 0; data->timeOffset = 0; data->events_fd = dup(handle->data[0]); D("%s: dev=%p fd=%d (was %d)", __FUNCTION__, dev, data->events_fd, handle->data[0]); native_handle_close(handle); native_handle_delete(handle); return 0; }
static jobject android_open(JNIEnv *env, jclass clazz) { native_handle_t* handle = sSensorDevice->open_data_source(sSensorDevice); if (!handle) { return NULL; } // new Bundle() jobject bundle = env->NewObject( gBundleOffsets.mClass, gBundleOffsets.mConstructor); if (handle->numFds > 0) { jobjectArray fdArray = env->NewObjectArray(handle->numFds, gParcelFileDescriptorOffsets.mClass, NULL); for (int i = 0; i < handle->numFds; i++) { // new FileDescriptor() jobject fd = env->NewObject(gFileDescriptorOffsets.mClass, gFileDescriptorOffsets.mConstructor); env->SetIntField(fd, gFileDescriptorOffsets.mDescriptor, handle->data[i]); // new ParcelFileDescriptor() jobject pfd = env->NewObject(gParcelFileDescriptorOffsets.mClass, gParcelFileDescriptorOffsets.mConstructor, fd); env->SetObjectArrayElement(fdArray, i, pfd); } // bundle.putParcelableArray("fds", fdArray); env->CallVoidMethod(bundle, gBundleOffsets.mPutParcelableArray, env->NewStringUTF("fds"), fdArray); } if (handle->numInts > 0) { jintArray intArray = env->NewIntArray(handle->numInts); env->SetIntArrayRegion(intArray, 0, handle->numInts, &handle->data[handle->numInts]); // bundle.putIntArray("ints", intArray); env->CallVoidMethod(bundle, gBundleOffsets.mPutIntArray, env->NewStringUTF("ints"), intArray); } // delete the file handle, but don't close any file descriptors native_handle_delete(handle); return bundle; }
native_handle_t* native_handle_clone(const native_handle_t* handle) { native_handle_t* clone = native_handle_create(handle->numFds, handle->numInts); if (clone == NULL) return NULL; for (int i = 0; i < handle->numFds; i++) { clone->data[i] = dup(handle->data[i]); if (clone->data[i] == -1) { clone->numFds = i; native_handle_close(clone); native_handle_delete(clone); return NULL; } } memcpy(&clone->data[handle->numFds], &handle->data[handle->numFds], sizeof(int) * handle->numInts); return clone; }
static void server_wlegl_create_buffer(struct wl_client *client, struct wl_resource *resource, uint32_t id, int32_t width, int32_t height, int32_t stride, int32_t format, int32_t usage, struct wl_resource *hnd) { server_wlegl *wlegl = server_wlegl_from(resource); server_wlegl_handle *handle = server_wlegl_handle_from(hnd); server_wlegl_buffer *buffer; buffer_handle_t native; if (width < 1 || height < 1) { wl_resource_post_error(resource, ANDROID_WLEGL_ERROR_BAD_VALUE, "bad width (%d) or height (%d)", width, height); return; } native = server_wlegl_handle_to_native(handle); if (!native) { wl_resource_post_error(resource, ANDROID_WLEGL_ERROR_BAD_HANDLE, "fd count mismatch"); return; } buffer = server_wlegl_buffer_create(client, id, width, height, stride, format, usage, native, wlegl); if (!buffer) { native_handle_close((native_handle_t *)native); native_handle_delete((native_handle_t *)native); wl_resource_post_error(resource, ANDROID_WLEGL_ERROR_BAD_HANDLE, "invalid native handle"); return; } }
static int data__data_open(struct sensors_data_context_t *dev, native_handle_t* handle) { int i; struct input_absinfo absinfo; memset(&dev->sensors, 0, sizeof(dev->sensors)); for (i = 0; i < MAX_NUM_SENSORS; i++) { // by default all sensors have high accuracy // (we do this because we don't get an update if the value doesn't // change). dev->sensors[i].vector.status = SENSOR_STATUS_ACCURACY_HIGH; } dev->sensors[ID_A].sensor = SENSOR_TYPE_ACCELEROMETER; dev->sensors[ID_M].sensor = SENSOR_TYPE_MAGNETIC_FIELD; dev->sensors[ID_O].sensor = SENSOR_TYPE_ORIENTATION; dev->sensors[ID_T].sensor = SENSOR_TYPE_TEMPERATURE; dev->sensors[ID_P].sensor = SENSOR_TYPE_PROXIMITY; dev->sensors[ID_L].sensor = SENSOR_TYPE_LIGHT; dev->events_fd[0] = dup(handle->data[0]); dev->events_fd[1] = dup(handle->data[1]); //dev->events_fd[2] = dup(handle->data[2]); LOGV("data__data_open: accelerometer fd = %d, dup=%d", handle->data[0], dev->events_fd[0] ); LOGV("data__data_open: compass fd = %d, dup=%d", handle->data[1], dev->events_fd[1] ); //LOGV("data__data_open: light fd = %d, dup=%d", handle->data[2], dev->events_fd[2] ); // Framework will close the handle native_handle_delete(handle); dev->pendingSensors = 0; /* if (!ioctl(dev->events_fd[1], EVIOCGABS(ABS_DISTANCE), &absinfo)) { */ /* LOGV("proximity sensor initial value %d\n", absinfo.value); */ /* dev->pendingSensors |= SENSORS_CM_PROXIMITY; */ /* // FIXME: we should save here absinfo.{minimum, maximum, etc} */ /* // and use them to scale the return value according to */ /* // the sensor description. */ /* dev->sensors[ID_P].distance = (float)absinfo.value; */ /* } */ /* else LOGE("Cannot get proximity sensor initial value: %s\n", */ /* strerror(errno)); */ return 0; }
void GraphicBuffer::free_handle() { if (mOwner == ownHandle) { #ifndef MTK_DEFAULT_AOSP ALOGD("close handle(%p) (w:%d h:%d f:%d)", handle, stride, height, format); #endif mBufferMapper.unregisterBuffer(handle); native_handle_close(handle); native_handle_delete(const_cast<native_handle*>(handle)); } else if (mOwner == ownData) { #ifndef MTK_DEFAULT_AOSP ALOGI("free buffer (w:%d h:%d f:%d) handle(%p)", stride, height, format, handle); #endif GraphicBufferAllocator& allocator(GraphicBufferAllocator::get()); allocator.free(handle); } mWrappedBuffer = 0; }
static int data__data_open(struct sensors_data_context_t *dev, native_handle_t* handle) { int i; struct input_absinfo absinfo; memset(&dev->sensors, 0, sizeof(dev->sensors)); for (i = 0; i < MAX_NUM_SENSORS; i++) { // by default all sensors have high accuracy // (we do this because we don't get an update if the value doesn't // change). dev->sensors[i].vector.status = SENSOR_STATUS_ACCURACY_HIGH; } dev->sensors[ID_A].sensor = SENSOR_TYPE_ACCELEROMETER; dev->sensors[ID_M].sensor = SENSOR_TYPE_MAGNETIC_FIELD; dev->sensors[ID_O].sensor = SENSOR_TYPE_ORIENTATION; dev->sensors[ID_T].sensor = SENSOR_TYPE_TEMPERATURE; dev->sensors[ID_P].sensor = SENSOR_TYPE_PROXIMITY; dev->sensors[ID_L].sensor = SENSOR_TYPE_LIGHT; dev->events_fd[0] = dup(handle->data[0]); dev->events_fd[1] = dup(handle->data[1]); dev->events_fd[2] = dup(handle->data[2]); LOGV("data__data_open: compass fd = %d", handle->data[0]); LOGV("data__data_open: proximity fd = %d", handle->data[1]); LOGV("data__data_open: light fd = %d", handle->data[2]); // Framework will close the handle native_handle_delete(handle); dev->pendingSensors = 0; if (!ioctl(dev->events_fd[1], EVIOCGABS(ABS_DISTANCE), &absinfo)) { LOGV("proximity sensor initial value %d\n", absinfo.value); dev->pendingSensors |= SENSORS_GP_PROXIMITY; dev->sensors[ID_P].distance = (absinfo.value == 1.0f ? 0.0f : 1.0f); } else LOGE("Cannot get proximity sensor initial value: %s\n", strerror(errno)); return 0; }
arxstatus_t ImageBuffer::free() { if (mRemote) { if (mImage.memType == DVP_MTYPE_GRALLOC_2DTILED || mImage.memType == DVP_MTYPE_DISPLAY_2DTILED) { native_handle_t *handle = reinterpret_cast<native_handle_t *>(mImage.reserved); if (!mUsingTexture) { GraphicBufferMapper &mapper = GraphicBufferMapper::get(); mapper.unlock(handle); mapper.unregisterBuffer(handle); } native_handle_close(handle); native_handle_delete(handle); } else { DVP_Image_Free_Import(mDvp, &mImage, mImportHdls); if (mImage.memType != DVP_MTYPE_MPUCACHED_VIRTUAL_SHARED) { for (uint32_t i = 0; i < mImage.planes; i++) { close(mSharedFds[i]); } } } return NOERROR; } if (mAnw) { anativewindow_release(mAnw, &(mImage.reserved)); } else { DVP_Image_Free(mDvp, &mImage); if (mImage.memType != DVP_MTYPE_MPUCACHED_VIRTUAL_SHARED) { for (uint32_t i = 0; i < mImage.planes; i++) { close(mSharedFds[i]); } } } return NOERROR; }
RemoteWindowBuffer::~RemoteWindowBuffer() { this->m_gralloc->unregisterBuffer(this->m_gralloc, this->handle); native_handle_close(this->handle); native_handle_delete(const_cast<native_handle_t*>(this->handle)); }