| /* |
| * Copyright (c) 2010, Texas Instruments Incorporated |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * * Neither the name of Texas Instruments Incorporated nor the names of |
| * its contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <time.h> |
| #include <semaphore.h> |
| #include <pthread.h> |
| #include <string.h> |
| #include <climits> |
| |
| #include <gui/GLConsumer.h> |
| #include <gui/Surface.h> |
| #include <ui/GraphicBuffer.h> |
| #include <ui/GraphicBufferMapper.h> |
| |
| #include <camera/Camera.h> |
| #include <camera/ICamera.h> |
| #include <media/mediarecorder.h> |
| |
| #include <binder/IPCThreadState.h> |
| #include <binder/ProcessState.h> |
| #include <binder/IServiceManager.h> |
| #include <cutils/properties.h> |
| #include <camera/CameraParameters.h> |
| #include <camera/ShotParameters.h> |
| #include <camera/CameraMetadata.h> |
| #include <system/audio.h> |
| #include <system/camera.h> |
| |
| #include <cutils/memory.h> |
| #include <utils/Log.h> |
| |
| #include <sys/wait.h> |
| |
| #include <sys/mman.h> |
| |
| #ifdef ANDROID_API_JB_OR_LATER |
| #include <gui/Surface.h> |
| #include <gui/ISurface.h> |
| #include <gui/ISurfaceComposer.h> |
| #include <gui/ISurfaceComposerClient.h> |
| #include <gui/SurfaceComposerClient.h> |
| #include <ion/ion.h> |
| #else |
| #include <surfaceflinger/Surface.h> |
| #include <surfaceflinger/ISurface.h> |
| #include <surfaceflinger/ISurfaceComposer.h> |
| #include <surfaceflinger/ISurfaceComposerClient.h> |
| #include <surfaceflinger/SurfaceComposerClient.h> |
| #include "ion.h" |
| #endif |
| |
| #include "camera_test.h" |
| |
| #define ASSERT(X) \ |
| do { \ |
| if(!(X)) { \ |
| printf("error: %s():%d", __FUNCTION__, __LINE__); \ |
| return; \ |
| } \ |
| } while(0); |
| |
| #define ALIGN_DOWN(x, n) ((x) & (~((n) - 1))) |
| #define ALIGN_UP(x, n) ((((x) + (n) - 1)) & (~((n) - 1))) |
| #define ALIGN_WIDTH 32 // Should be 32...but the calculated dimension causes an ion crash |
| #define ALIGN_HEIGHT 2 // Should be 2...but the calculated dimension causes an ion crash |
| |
| //temporarily define format here |
| #define HAL_PIXEL_FORMAT_TI_NV12 0x100 |
| #define HAL_PIXEL_FORMAT_TI_NV12_1D 0x102 |
| #define HAL_PIXEL_FORMAT_TI_Y8 0x103 |
| #define HAL_PIXEL_FORMAT_TI_Y16 0x104 |
| |
| using namespace android; |
| |
| #define N_BUFFERS 15 |
| |
| static void |
| test_format (int format, int page_mode, int width, int height) |
| { |
| sp<GLConsumer> st; |
| Surface *stc; |
| GLint tex_id = 0; |
| sp<ANativeWindow> anw; |
| ANativeWindowBuffer* anb[30] = { 0 }; |
| int i; |
| unsigned int usage; |
| GraphicBufferMapper &mapper = GraphicBufferMapper::get(); |
| |
| printf("testing format %x, page_mode %d\n", format, page_mode); |
| |
| sp<BufferQueue> bq = new BufferQueue(); |
| st = new GLConsumer (bq, tex_id, GL_TEXTURE_EXTERNAL_OES); |
| |
| st->setDefaultBufferSize (width, height); |
| |
| stc = new Surface(st); |
| anw = stc; |
| |
| usage = GRALLOC_USAGE_SW_READ_RARELY | |
| GRALLOC_USAGE_SW_WRITE_NEVER; |
| if (page_mode) { |
| usage |= GRALLOC_USAGE_PRIVATE_0; |
| } |
| |
| native_window_set_usage(anw.get(), usage); |
| native_window_set_buffer_count(anw.get(), N_BUFFERS); |
| native_window_set_buffers_geometry(anw.get(), |
| width, height, format); |
| |
| for(i=0;i<N_BUFFERS;i++) { |
| void *data = NULL; |
| Rect bounds(width, height); |
| |
| anb[i] = NULL; |
| anw->dequeueBuffer(anw.get(), &anb[i]); |
| printf("%d: %p\n", i, anb[i]); |
| if (anb[i] == NULL) { |
| printf ("FAILED: buffer should be non-NULL\n"); |
| break; |
| } |
| |
| mapper.lock(anb[i]->handle, GRALLOC_USAGE_SW_READ_RARELY, |
| bounds, &data); |
| if (data == NULL) { |
| printf ("FAILED: mapping should be non-NULL\n"); |
| break; |
| } |
| |
| mapper.unlock(anb[i]->handle); |
| } |
| for(i=0;i<N_BUFFERS;i++) { |
| if (anb[i]) { |
| anw->cancelBuffer (anw.get(), anb[i]); |
| } |
| } |
| |
| //delete stc; |
| st.clear(); |
| } |
| |
| void |
| ion_test (void) |
| { |
| struct ion_handle *handle; |
| int fd; |
| int map_fd; |
| unsigned char *ptr; |
| int i; |
| int ret; |
| int share_fd; |
| |
| fd = ion_open (); |
| |
| #define SIZE (10*1024*1024) |
| for(i=0;i<10;i++){ |
| handle = NULL; |
| ret = ion_alloc (fd, SIZE, 4096, (1<<0), &handle); |
| if (ret < 0) { |
| printf("ion_alloc returned error %d, %s\n", ret, strerror(errno)); |
| break; |
| } |
| printf("ion_alloc returned %d\n", ret); |
| |
| ret = ion_share (fd, handle, &share_fd); |
| if (ret < 0) { |
| printf("ion_share returned error %d, %s\n", ret, strerror(errno)); |
| break; |
| } |
| printf("ion_share returned %d\n", ret); |
| |
| ptr = (unsigned char *)mmap (NULL, SIZE, PROT_READ|PROT_WRITE, |
| MAP_SHARED, share_fd, 0); |
| printf("mmap returned %p\n", ptr); |
| |
| ptr = (unsigned char *)mmap (NULL, SIZE, PROT_READ|PROT_WRITE, |
| MAP_SHARED, share_fd, 0); |
| printf("mmap returned %p\n", ptr); |
| |
| #if 0 |
| ret = ion_map (fd, handle, SIZE, PROT_READ, 0, 0, &ptr, &map_fd); |
| if (ret < 0) { |
| printf("ion_map returned error %d, %s\n", ret, strerror(errno)); |
| break; |
| } |
| printf("ion_map returned %d\n", ret); |
| #endif |
| |
| printf("%d: %p\n", i, ptr); |
| |
| ion_free (fd, handle); |
| } |
| |
| } |
| |
| |
| int |
| main (int argc, char *argv[]) |
| { |
| int width, height; |
| |
| width = 640; |
| height = 480; |
| test_format (HAL_PIXEL_FORMAT_TI_NV12, 0, width, height); |
| test_format (HAL_PIXEL_FORMAT_TI_NV12, 1, width, height); |
| test_format (HAL_PIXEL_FORMAT_TI_NV12_1D, 0, width, height); |
| test_format (HAL_PIXEL_FORMAT_TI_Y8, 1, width, height); |
| test_format (HAL_PIXEL_FORMAT_TI_Y16, 1, width, height); |
| |
| width = 2608; |
| height = 1960; |
| test_format (HAL_PIXEL_FORMAT_TI_NV12, 1, width, height); |
| test_format (HAL_PIXEL_FORMAT_TI_NV12_1D, 0, width, height); |
| test_format (HAL_PIXEL_FORMAT_TI_Y8, 1, width, height); |
| test_format (HAL_PIXEL_FORMAT_TI_Y16, 1, width, height); |
| |
| ion_test(); |
| |
| return 0; |
| } |
| |