| /* |
| ** Copyright (c) 2012 The Linux Foundation. All rights reserved. |
| ** |
| ** Not a Contribution, Apache license notifications and license are retained |
| ** for attribution purposes only. |
| ** |
| ** 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. |
| */ |
| |
| /*#error uncomment this for compiler test!*/ |
| |
| //#define ALOG_NDEBUG 0 |
| #define ALOG_NIDEBUG 0 |
| #define LOG_TAG "QCameraHWI_Mem" |
| #include <utils/Log.h> |
| |
| #include <utils/Errors.h> |
| #include <utils/threads.h> |
| #include <utils/String16.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <cutils/properties.h> |
| #include <math.h> |
| #if __ANDROID__ |
| #include <linux/android_pmem.h> |
| #endif |
| #include <linux/ioctl.h> |
| #include <camera/QCameraParameters.h> |
| #include <media/mediarecorder.h> |
| #include <gralloc_priv.h> |
| |
| #include "QCameraHWI_Mem.h" |
| |
| #define CAMERA_HAL_UNUSED(expr) do { (void)(expr); } while (0) |
| |
| /* QCameraHardwareInterface class implementation goes here*/ |
| /* following code implement the contol logic of this class*/ |
| |
| namespace android { |
| |
| |
| static bool register_buf(int size, |
| int frame_size, |
| int cbcr_offset, |
| int yoffset, |
| int pmempreviewfd, |
| uint32_t offset, |
| uint8_t *buf, |
| int pmem_type, |
| bool vfe_can_write, |
| bool register_buffer = true); |
| |
| MemPool::MemPool(int buffer_size, int num_buffers, |
| int frame_size, |
| const char *name) : |
| mBufferSize(buffer_size), |
| mNumBuffers(num_buffers), |
| mFrameSize(frame_size), |
| mBuffers(NULL), mName(name) |
| { |
| int page_size_minus_1 = getpagesize() - 1; |
| mAlignedBufferSize = (buffer_size + page_size_minus_1) & (~page_size_minus_1); |
| } |
| |
| void MemPool::completeInitialization() |
| { |
| // If we do not know how big the frame will be, we wait to allocate |
| // the buffers describing the individual frames until we do know their |
| // size. |
| |
| if (mFrameSize > 0) { |
| mBuffers = new sp<MemoryBase>[mNumBuffers]; |
| for (int i = 0; i < mNumBuffers; i++) { |
| mBuffers[i] = new |
| MemoryBase(mHeap, |
| i * mAlignedBufferSize, |
| mFrameSize); |
| } |
| } |
| } |
| |
| AshmemPool::AshmemPool(int buffer_size, int num_buffers, |
| int frame_size, |
| const char *name) : |
| MemPool(buffer_size, |
| num_buffers, |
| frame_size, |
| name) |
| { |
| ALOGV("constructing MemPool %s backed by ashmem: " |
| "%d frames @ %d uint8_ts, " |
| "buffer size %d", |
| mName, |
| num_buffers, frame_size, buffer_size); |
| |
| int page_mask = getpagesize() - 1; |
| int ashmem_size = buffer_size * num_buffers; |
| ashmem_size += page_mask; |
| ashmem_size &= ~page_mask; |
| |
| mHeap = new MemoryHeapBase(ashmem_size); |
| |
| completeInitialization(); |
| } |
| |
| static bool register_buf(int size, |
| int frame_size, |
| int cbcr_offset, |
| int yoffset, |
| int pmempreviewfd, |
| uint32_t offset, |
| uint8_t *buf, |
| int pmem_type, |
| bool vfe_can_write, |
| bool register_buffer) |
| { |
| return true; |
| |
| } |
| |
| PmemPool::~PmemPool() |
| { |
| ALOGI("%s: %s E", __FUNCTION__, mName); |
| |
| ALOGI("%s: %s X", __FUNCTION__, mName); |
| } |
| MemPool::~MemPool() |
| { |
| ALOGV("destroying MemPool %s", mName); |
| if (mFrameSize > 0) |
| delete [] mBuffers; |
| mHeap.clear(); |
| ALOGV("destroying MemPool %s completed", mName); |
| } |
| |
| |
| status_t MemPool::dump(int fd, const Vector<String16>& args) const |
| { |
| const size_t SIZE = 256; |
| char buffer[SIZE]; |
| String8 result; |
| CAMERA_HAL_UNUSED(args); |
| snprintf(buffer, 255, "QualcommCameraHardware::AshmemPool::dump\n"); |
| result.append(buffer); |
| if (mName) { |
| snprintf(buffer, 255, "mem pool name (%s)\n", mName); |
| result.append(buffer); |
| } |
| if (mHeap != 0) { |
| snprintf(buffer, 255, "heap base(%p), size(%d), flags(%d), device(%s)\n", |
| mHeap->getBase(), mHeap->getSize(), |
| mHeap->getFlags(), mHeap->getDevice()); |
| result.append(buffer); |
| } |
| snprintf(buffer, 255, |
| "buffer size (%d), number of buffers (%d), frame size(%d)", |
| mBufferSize, mNumBuffers, mFrameSize); |
| result.append(buffer); |
| write(fd, result.string(), result.size()); |
| return NO_ERROR; |
| } |
| |
| }; |