254 lines
7.2 KiB
C++
254 lines
7.2 KiB
C++
/*
|
|
* 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;
|
|
}
|
|
|