/*
|
* test-image-blend.cpp - test cl image
|
*
|
* Copyright (c) 2016 Intel Corporation
|
*
|
* 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.
|
*
|
* Author: Wind Yuan <feng.yuan@intel.com>
|
*/
|
|
#include "test_common.h"
|
#include "test_inline.h"
|
#include <unistd.h>
|
#include <getopt.h>
|
#include <ocl/cl_device.h>
|
#include <ocl/cl_context.h>
|
#include <ocl/cl_blender.h>
|
#include <image_file_handle.h>
|
#include <ocl/cl_geo_map_handler.h>
|
#if HAVE_LIBDRM
|
#include <drm_display.h>
|
#endif
|
#include <dma_video_buffer.h>
|
|
using namespace XCam;
|
|
#define ENABLE_DMA_TEST 0
|
|
static uint32_t input_format = V4L2_PIX_FMT_NV12;
|
//static uint32_t output_format = V4L2_PIX_FMT_NV12;
|
static uint32_t input_width0 = 1280, input_width1 = 1280;
|
static uint32_t input_height = 960;
|
static uint32_t output_width = 1920;
|
static uint32_t output_height;
|
static bool need_save_output = true;
|
static bool enable_geo = false;
|
static bool enable_seam = false;
|
|
static int loop = 0;
|
static uint32_t map_width = 51, map_height = 43;
|
static const char *map0 = "fisheye0.csv";
|
static const char *map1 = "fisheye1.csv";
|
static char file_in0_name[XCAM_MAX_STR_SIZE], file_in1_name[XCAM_MAX_STR_SIZE], file_out_name[XCAM_MAX_STR_SIZE];
|
|
static int read_map_data (const char* file, GeoPos *map, int width, int height);
|
|
static void
|
usage(const char* arg0)
|
{
|
printf ("Usage:\n"
|
"%s --input0 file --input1 file --output file"
|
" [--input-w0 width] [--input-w1 width] [--input-h height] [--output-w width] \n"
|
"\t--input0, first image(NV12)\n"
|
"\t--input1, second image(NV12)\n"
|
"\t--output, output image(NV12) PREFIX\n"
|
"\t--input-w0, optional, input width; default:1280\n"
|
"\t--input-w1, optional, input width; default:1280\n"
|
"\t--input-h, optional, input height; default:960\n"
|
"\t--output-w, optional, output width; default:1920, output height is same as input height.\n"
|
"\t--loop, optional, how many loops need to run for performance test, default 0; \n"
|
"\t--save, optional, save file or not, default true; select from [true/false]\n"
|
"\t--enable-geo, optional, enable geo map image frist. default: no\n"
|
"\t--enable-seam, optional, enable seam finder in blending area. default: no\n"
|
"\t--help, usage\n",
|
arg0);
|
}
|
|
static int
|
geo_correct_image (
|
SmartPtr<CLGeoMapHandler> geo_map_handler, SmartPtr<VideoBuffer> &in_out,
|
GeoPos *geo_map0, uint32_t map_width, uint32_t map_height,
|
char *file_name, bool need_save_output)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<VideoBuffer> geo_out;
|
geo_map_handler->set_map_data (geo_map0, map_width, map_height);
|
ret = geo_map_handler->execute (in_out, geo_out);
|
CHECK (ret, "geo map handler execute inpu0 failed");
|
XCAM_ASSERT (geo_out.ptr ());
|
in_out = geo_out;
|
|
if (need_save_output) {
|
char gdc_dump_name[1024];
|
snprintf (gdc_dump_name, 1024, "gdc-%s", file_name);
|
ImageFileHandle file_out;
|
file_out.open (gdc_dump_name, "wb");
|
file_out.write_buf (geo_out);
|
file_out.close ();
|
printf ("write gdc output buffer to: %s done\n", gdc_dump_name);
|
}
|
return 0;
|
}
|
|
#if (ENABLE_DMA_TEST) && (HAVE_LIBDRM)
|
static SmartPtr<VideoBuffer>
|
dma_buf_to_xcam_buf (
|
SmartPtr<DrmDisplay> display, int dma_fd,
|
uint32_t width, uint32_t height, uint32_t size,
|
uint32_t aligned_width = 0, uint32_t aligned_height = 0)
|
{
|
/*
|
*
|
* XCAM_ASSERT (native_handle_t.numFds == 1);
|
* XCAM_ASSERT (native_handle_t.data[0] > 0);
|
* dma_fd = native_handle_t.data[0] ;
|
*/;
|
VideoBufferInfo info;
|
SmartPtr<VideoBuffer> dma_buf;
|
SmartPtr<VideoBuffer> output;
|
|
XCAM_ASSERT (dma_fd > 0);
|
|
if (aligned_width == 0)
|
aligned_width = XCAM_ALIGN_UP(width, 16);
|
if (aligned_height == 0)
|
aligned_height = XCAM_ALIGN_UP(height, 16);
|
|
info.init (V4L2_PIX_FMT_NV12, width, height, aligned_width, aligned_height, size);
|
dma_buf = new DmaVideoBuffer (info, dma_fd);
|
output = display->convert_to_drm_bo_buf (display, dma_buf);
|
if (!output.ptr ()) {
|
XCAM_LOG_ERROR ("dma_buf(%d) convert to xcam_buf failed", dma_fd);
|
}
|
|
return output;
|
}
|
|
static SmartPtr<VideoBuffer>
|
create_dma_buffer (SmartPtr<DrmDisplay> &display, const VideoBufferInfo &info)
|
{
|
SmartPtr<BufferPool> buf_pool = new DrmBoBufferPool (display);
|
buf_pool->set_video_info (info);
|
buf_pool->reserve (1);
|
return buf_pool->get_buffer (buf_pool);
|
}
|
#endif
|
|
static XCamReturn
|
blend_images (
|
SmartPtr<VideoBuffer> input0, SmartPtr<VideoBuffer> input1,
|
SmartPtr<VideoBuffer> &output_buf,
|
SmartPtr<CLBlender> blender)
|
{
|
blender->set_output_size (output_width, output_height);
|
input0->attach_buffer (input1);
|
return blender->execute (input0, output_buf);
|
}
|
|
int main (int argc, char *argv[])
|
{
|
GeoPos *geo_map0 = NULL, *geo_map1 = NULL;
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<CLImageHandler> image_handler;
|
SmartPtr<CLGeoMapHandler> geo_map_handler;
|
SmartPtr<CLBlender> blender;
|
VideoBufferInfo input_buf_info0, input_buf_info1, output_buf_info;
|
SmartPtr<CLContext> context;
|
SmartPtr<BufferPool> buf_pool0, buf_pool1;
|
ImageFileHandle file_in0, file_in1, file_out;
|
SmartPtr<VideoBuffer> input0, input1;
|
SmartPtr<VideoBuffer> output_buf;
|
SmartPtr<VideoBuffer> read_buf;
|
|
#define FAILED_GEO_FREE { delete [] geo_map0; delete [] geo_map1; return -1; }
|
|
const struct option long_opts[] = {
|
{"input0", required_argument, NULL, 'i'},
|
{"input1", required_argument, NULL, 'I'},
|
{"output", required_argument, NULL, 'o'},
|
{"input-w0", required_argument, NULL, 'w'},
|
{"input-w1", required_argument, NULL, 'W'},
|
{"input-h", required_argument, NULL, 'H'},
|
{"output-w", required_argument, NULL, 'x'},
|
{"loop", required_argument, NULL, 'l'},
|
{"save", required_argument, NULL, 's'},
|
{"enable-geo", no_argument, NULL, 'g'},
|
{"enable-seam", no_argument, NULL, 'm'},
|
{"help", no_argument, NULL, 'h'},
|
{0, 0, 0, 0},
|
};
|
|
int opt = -1;
|
while ((opt = getopt_long(argc, argv, "", long_opts, NULL)) != -1) {
|
switch (opt) {
|
case 'i':
|
strncpy (file_in0_name, optarg, XCAM_MAX_STR_SIZE);
|
break;
|
case 'I':
|
strncpy (file_in1_name, optarg, XCAM_MAX_STR_SIZE);
|
break;
|
case 'o':
|
strncpy (file_out_name, optarg, XCAM_MAX_STR_SIZE);
|
break;
|
case 'w':
|
input_width0 = atoi(optarg);
|
break;
|
case 'W':
|
input_width1 = atoi(optarg);
|
break;
|
case 'H':
|
input_height = atoi(optarg);
|
break;
|
case 'x':
|
output_width = atoi(optarg);
|
break;
|
case 'l':
|
loop = atoi(optarg);
|
break;
|
case 's':
|
need_save_output = (strcasecmp (optarg, "false") == 0 ? false : true);
|
break;
|
case 'g':
|
enable_geo = true;
|
break;
|
case 'm':
|
enable_seam = true;
|
break;
|
case 'h':
|
usage (argv[0]);
|
return -1;
|
default:
|
printf ("getopt_long return unknown value:%c\n", opt);
|
usage (argv[0]);
|
return -1;
|
|
}
|
}
|
|
if (optind < argc || argc < 2) {
|
printf("unknown option %s\n", argv[optind]);
|
usage (argv[0]);
|
return -1;
|
}
|
|
printf ("Description-----------\n");
|
printf ("input0 file:%s\n", file_in0_name);
|
printf ("input1 file:%s\n", file_in1_name);
|
printf ("output file PREFIX:%s\n", file_out_name);
|
printf ("input0 width:%d\n", input_width0);
|
printf ("input1 width:%d\n", input_width1);
|
printf ("input/output height:%d\n", input_height);
|
printf ("output width:%d\n", output_width);
|
printf ("loop count:%d\n", loop);
|
printf ("need save file:%s\n", need_save_output ? "true" : "false");
|
printf ("enable seam mask:%s\n", (enable_seam ? "true" : "false"));
|
printf ("----------------------\n");
|
|
output_height = input_height;
|
input_buf_info0.init (input_format, input_width0, input_height);
|
input_buf_info1.init (input_format, input_width1, input_height);
|
output_buf_info.init (input_format, output_width, output_height);
|
#if (ENABLE_DMA_TEST) && (HAVE_LIBDRM)
|
SmartPtr<DrmDisplay> display = DrmDisplay::instance ();
|
buf_pool0 = new DrmBoBufferPool (display);
|
buf_pool1 = new DrmBoBufferPool (display);
|
#else
|
buf_pool0 = new CLVideoBufferPool ();
|
buf_pool1 = new CLVideoBufferPool ();
|
#endif
|
XCAM_ASSERT (buf_pool0.ptr () && buf_pool1.ptr ());
|
buf_pool0->set_video_info (input_buf_info0);
|
buf_pool1->set_video_info (input_buf_info1);
|
if (!buf_pool0->reserve (2)) {
|
XCAM_LOG_ERROR ("init buffer pool failed");
|
return -1;
|
}
|
if (!buf_pool1->reserve (2)) {
|
XCAM_LOG_ERROR ("init buffer pool failed");
|
return -1;
|
}
|
|
context = CLDevice::instance ()->get_context ();
|
blender = create_pyramid_blender (context, 2, true, enable_seam).dynamic_cast_ptr<CLBlender> ();
|
XCAM_ASSERT (blender.ptr ());
|
|
#if (ENABLE_DMA_TEST) && (HAVE_LIBDRM)
|
int dma_fd0 = 30, dma_fd1 = 31, dma_fd_out = 32;
|
input_buf_info0.init (
|
input_format, input_width0, input_height, XCAM_ALIGN_UP (input_width0, 16), XCAM_ALIGN_UP(input_height, 16));
|
input_buf_info1.init (
|
input_format, input_width1, input_height, XCAM_ALIGN_UP (input_width1, 16), XCAM_ALIGN_UP(input_height, 16));
|
output_buf_info.init (
|
input_format, output_width, output_height, XCAM_ALIGN_UP (output_width, 16), XCAM_ALIGN_UP(output_height, 16));
|
uint32_t in_size = input_buf_info0.aligned_width * input_buf_info0.aligned_height * 3 / 2;
|
uint32_t out_size = output_buf_info.aligned_width * output_buf_info.aligned_height * 3 / 2;
|
/* create dma fd, for buffer_handle_t just skip this segment, directly goto dma_buf_to_xcam_buf */
|
SmartPtr<VideoBuffer> dma_buf0, dma_buf1, dma_buf_out;
|
dma_buf0 = create_dma_buffer (display, input_buf_info0); //unit test
|
dma_buf1 = create_dma_buffer (display, input_buf_info1); //unit test
|
dma_buf_out = create_dma_buffer (display, output_buf_info); //unit test
|
dma_fd0 = dma_buf0->get_fd (); //unit test
|
dma_fd1 = dma_buf1->get_fd (); //unit test
|
dma_fd_out = dma_buf_out->get_fd (); //unit test
|
/*
|
buffer_handle_t just go to here,
|
dma_fd0 = native_handle_t.data[0];
|
dma_fd1 = native_handle_t.data[0];
|
dma_fd_out = native_handle_t.data[0];
|
*/
|
printf ("DMA handles, buf0:%d, buf1:%d, buf_out:%d\n", dma_fd0, dma_fd1, dma_fd_out);
|
input0 = dma_buf_to_xcam_buf (
|
display, dma_fd0, input_width0, input_height, in_size,
|
input_buf_info0.aligned_width, input_buf_info0.aligned_height);
|
input1 = dma_buf_to_xcam_buf (
|
display, dma_fd1, input_width0, input_height, in_size,
|
input_buf_info1.aligned_width, input_buf_info1.aligned_height);
|
output_buf = dma_buf_to_xcam_buf (
|
display, dma_fd_out, output_width, output_height, out_size,
|
output_buf_info.aligned_width, output_buf_info.aligned_height);
|
blender->disable_buf_pool (true);
|
#else
|
input0 = buf_pool0->get_buffer (buf_pool0);
|
input1 = buf_pool1->get_buffer (buf_pool1);
|
XCAM_ASSERT (input0.ptr () && input1.ptr ());
|
#endif
|
//
|
ret = file_in0.open (file_in0_name, "rb");
|
CHECK_STATEMENT (ret, FAILED_GEO_FREE, "open input file(%s) failed", file_in0_name);
|
read_buf = input0;
|
ret = file_in0.read_buf (read_buf);
|
CHECK_STATEMENT (ret, FAILED_GEO_FREE, "read buffer0 from (%s) failed", file_in0_name);
|
|
ret = file_in1.open (file_in1_name, "rb");
|
CHECK_STATEMENT (ret, FAILED_GEO_FREE, "open input file(%s) failed", file_in1_name);
|
read_buf = input1;
|
ret = file_in1.read_buf (read_buf);
|
CHECK_STATEMENT (ret, FAILED_GEO_FREE, "read buffer1 from (%s) failed", file_in1_name);
|
|
if (enable_geo) {
|
geo_map_handler = create_geo_map_handler (context).dynamic_cast_ptr<CLGeoMapHandler> ();
|
XCAM_ASSERT (geo_map_handler.ptr ());
|
|
geo_map0 = new GeoPos[map_width * map_height];
|
geo_map1 = new GeoPos[map_width * map_height];
|
XCAM_ASSERT (geo_map0 && geo_map1);
|
if (read_map_data (map0, geo_map0, map_width, map_height) <= 0 ||
|
read_map_data (map1, geo_map1, map_width, map_height) <= 0) {
|
delete [] geo_map0;
|
delete [] geo_map1;
|
return -1;
|
}
|
|
geo_map_handler->set_map_uint (28.0f, 28.0f);
|
}
|
|
int i = 0;
|
do {
|
input0->clear_attached_buffers ();
|
input1->clear_attached_buffers ();
|
|
if (enable_geo) {
|
geo_correct_image (geo_map_handler, input0, geo_map0, map_width, map_height, file_in0_name, need_save_output);
|
geo_correct_image (geo_map_handler, input1, geo_map1, map_width, map_height, file_in1_name, need_save_output);
|
}
|
|
ret = blend_images (input0, input1, output_buf, blender);
|
CHECK_STATEMENT (ret, FAILED_GEO_FREE, "blend_images execute failed");
|
//printf ("DMA handles, output_buf:%d\n", output_buf->get_fd ());
|
|
if (need_save_output) {
|
char out_name[1024];
|
snprintf (out_name, 1023, "%s.%02d", file_out_name, i);
|
|
ret = file_out.open (out_name, "wb");
|
CHECK_STATEMENT (ret, FAILED_GEO_FREE, "open output file(%s) failed", out_name);
|
ret = file_out.write_buf (output_buf);
|
CHECK_STATEMENT (ret, FAILED_GEO_FREE, "write buffer to (%s) failed", out_name);
|
printf ("write output buffer to: %s done\n", out_name);
|
} else {
|
// check info
|
ensure_gpu_buffer_done (output_buf);
|
}
|
|
FPS_CALCULATION (image_blend, XCAM_OBJ_DUR_FRAME_NUM);
|
++i;
|
} while (i < loop);
|
|
delete [] geo_map0;
|
delete [] geo_map1;
|
|
return ret;
|
}
|
|
//return count
|
int read_map_data (const char* file, GeoPos *map, int width, int height)
|
{
|
char *ptr = NULL;
|
FILE *p_f = fopen (file, "rb");
|
CHECK_EXP (p_f, "open geo-map file(%s) failed", file);
|
|
#define FAILED_READ_MAP { if (p_f) fclose(p_f); if (ptr) xcam_free (ptr); return -1; }
|
|
CHECK_DECLARE (ERROR, fseek(p_f, 0L, SEEK_END) == 0, FAILED_READ_MAP, "seek to file(%s) end failed", file);
|
size_t size = ftell (p_f);
|
XCAM_ASSERT ((int)size != -1);
|
fseek (p_f, 0L, SEEK_SET);
|
|
ptr = (char*)xcam_malloc (size + 1);
|
XCAM_ASSERT (ptr);
|
CHECK_DECLARE (ERROR, fread (ptr, 1, size, p_f) == size, FAILED_READ_MAP, "read map file(%s)failed", file);
|
ptr[size] = 0;
|
fclose (p_f);
|
p_f = NULL;
|
|
char *str_num = NULL;
|
char tokens[] = "\t ,\r\n";
|
str_num = strtok (ptr, tokens);
|
int count = 0;
|
int x = 0, y = 0;
|
while (str_num != NULL) {
|
float num = strtof (str_num, NULL);
|
//printf ("%.3f\n", num);
|
|
x = count % width;
|
y = count / (width * 2); // x,y
|
if (y >= height)
|
break;
|
|
if (count % (width * 2) >= width)
|
map[y * width + x].y = num;
|
else
|
map[y * width + x].x = num;
|
|
++count;
|
str_num = strtok (NULL, tokens);
|
}
|
xcam_free (ptr);
|
ptr = NULL;
|
CHECK_EXP (y < height, "map data(%s) count larger than expected(%dx%dx2)", file, width, height);
|
CHECK_EXP (count >= width * height * 2, "map data(%s) count less than expected(%dx%dx2)", file, width, height);
|
|
printf ("read map(%s) x/y data count:%d\n", file, count);
|
return count;
|
}
|
