/*
|
* test-soft-image.cpp - test soft image
|
*
|
* Copyright (c) 2017 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 <buffer_pool.h>
|
#include <image_handler.h>
|
#include <image_file_handle.h>
|
#include <soft/soft_video_buf_allocator.h>
|
#include <interface/blender.h>
|
#include <interface/geo_mapper.h>
|
#include <interface/stitcher.h>
|
#include <calibration_parser.h>
|
#include <string>
|
|
#if (!defined(ANDROID) && (HAVE_OPENCV))
|
#include <ocl/cv_base_class.h>
|
#endif
|
|
#define XCAM_TEST_SOFT_IMAGE_DEBUG 0
|
|
#if (!defined(ANDROID) && (HAVE_OPENCV))
|
#define XCAM_TEST_OPENCV 1
|
#else
|
#define XCAM_TEST_OPENCV 0
|
#endif
|
|
#define XCAM_TEST_MAX_STR_SIZE 1024
|
|
#define FISHEYE_CONFIG_PATH "./"
|
|
#define MAP_WIDTH 3
|
#define MAP_HEIGHT 4
|
|
static PointFloat2 map_table[MAP_HEIGHT * MAP_WIDTH] = {
|
{160.0f, 120.0f}, {480.0f, 120.0f}, {796.0f, 120.0f},
|
{60.0f, 240.0f}, {480.0f, 240.0f}, {900.0f, 240.0f},
|
{16.0f, 360.0f}, {480.0f, 360.0f}, {944.0f, 360.0f},
|
{0.0f, 480.0f}, {480.0f, 480.0f}, {960.0f, 480.0f},
|
};
|
|
using namespace XCam;
|
|
enum SoftType {
|
SoftTypeNone = 0,
|
SoftTypeBlender,
|
SoftTypeRemap,
|
SoftTypeStitch,
|
};
|
|
#define RUN_N(statement, loop, msg, ...) \
|
for (int i = 0; i < loop; ++i) { \
|
CHECK (statement, msg, ## __VA_ARGS__); \
|
FPS_CALCULATION (soft-image, XCAM_OBJ_DUR_FRAME_NUM); \
|
}
|
|
#define ADD_ENELEMT(elements, file_name) \
|
{ \
|
SmartPtr<SoftElement> element = new SoftElement (file_name); \
|
elements.push_back (element); \
|
}
|
|
#if XCAM_TEST_OPENCV
|
const static cv::Scalar color = cv::Scalar (0, 0, 255);
|
const static int fontFace = cv::FONT_HERSHEY_COMPLEX;
|
#endif
|
|
class SoftElement {
|
public:
|
explicit SoftElement (const char *file_name = NULL, uint32_t width = 0, uint32_t height = 0);
|
~SoftElement ();
|
|
void set_buf_size (uint32_t width, uint32_t height);
|
uint32_t get_width () const {
|
return _width;
|
}
|
uint32_t get_height () const {
|
return _height;
|
}
|
|
const char *get_file_name () const {
|
return _file_name;
|
}
|
|
SmartPtr<VideoBuffer> &get_buf () {
|
return _buf;
|
}
|
|
XCamReturn open_file (const char *option);
|
XCamReturn close_file ();
|
XCamReturn rewind_file ();
|
|
XCamReturn read_buf ();
|
XCamReturn write_buf ();
|
|
XCamReturn create_buf_pool (const VideoBufferInfo &info, uint32_t count);
|
|
#if XCAM_TEST_OPENCV
|
XCamReturn cv_open_writer ();
|
void cv_write_image (char *img_name, char *frame_str, char *idx_str = NULL);
|
#endif
|
|
private:
|
char *_file_name;
|
uint32_t _width;
|
uint32_t _height;
|
SmartPtr<VideoBuffer> _buf;
|
|
ImageFileHandle _file;
|
SmartPtr<BufferPool> _pool;
|
#if XCAM_TEST_OPENCV
|
cv::VideoWriter _writer;
|
#endif
|
};
|
|
typedef std::vector<SmartPtr<SoftElement>> SoftElements;
|
|
SoftElement::SoftElement (const char *file_name, uint32_t width, uint32_t height)
|
: _file_name (NULL)
|
, _width (width)
|
, _height (height)
|
{
|
if (file_name)
|
_file_name = strndup (file_name, XCAM_TEST_MAX_STR_SIZE);
|
}
|
|
SoftElement::~SoftElement ()
|
{
|
_file.close ();
|
|
if (_file_name)
|
xcam_free (_file_name);
|
}
|
|
void
|
SoftElement::set_buf_size (uint32_t width, uint32_t height)
|
{
|
_width = width;
|
_height = height;
|
}
|
|
XCamReturn
|
SoftElement::open_file (const char *option)
|
{
|
if (_file.open (_file_name, option) != XCAM_RETURN_NO_ERROR) {
|
XCAM_LOG_ERROR ("open %s failed.", _file_name);
|
return XCAM_RETURN_ERROR_FILE;
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
SoftElement::close_file ()
|
{
|
return _file.close ();
|
}
|
|
XCamReturn
|
SoftElement::rewind_file ()
|
{
|
return _file.rewind ();
|
}
|
|
XCamReturn
|
SoftElement::create_buf_pool (const VideoBufferInfo &info, uint32_t count)
|
{
|
_pool = new SoftVideoBufAllocator ();
|
_pool->set_video_info (info);
|
if (!_pool->reserve (count)) {
|
XCAM_LOG_ERROR ("create buffer pool failed");
|
return XCAM_RETURN_ERROR_MEM;
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
SoftElement::read_buf ()
|
{
|
_buf = _pool->get_buffer (_pool);
|
XCAM_ASSERT (_buf.ptr ());
|
|
return _file.read_buf (_buf);
|
}
|
|
XCamReturn
|
SoftElement::write_buf () {
|
return _file.write_buf (_buf);
|
}
|
|
#if XCAM_TEST_OPENCV
|
XCamReturn
|
SoftElement::cv_open_writer ()
|
{
|
XCAM_FAIL_RETURN (
|
ERROR,
|
_width && _height,
|
XCAM_RETURN_ERROR_PARAM,
|
"invalid size width:%d height:%d", _width, _height);
|
|
cv::Size frame_size = cv::Size (_width, _height);
|
if (!_writer.open (_file_name, CV_FOURCC('X', '2', '6', '4'), 30, frame_size)) {
|
XCAM_LOG_ERROR ("open file %s failed", _file_name);
|
return XCAM_RETURN_ERROR_FILE;
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
void
|
SoftElement::cv_write_image (char *img_name, char *frame_str, char *idx_str)
|
{
|
cv::Mat mat;
|
|
#if XCAM_TEST_SOFT_IMAGE_DEBUG
|
convert_to_mat (_buf, mat);
|
|
cv::putText (mat, frame_str, cv::Point(20, 50), fontFace, 2.0, color, 2, 8, false);
|
if(idx_str)
|
cv::putText (mat, idx_str, cv::Point(20, 110), fontFace, 2.0, color, 2, 8, false);
|
|
cv::imwrite (img_name, mat);
|
#else
|
XCAM_UNUSED (img_name);
|
XCAM_UNUSED (frame_str);
|
XCAM_UNUSED (idx_str);
|
#endif
|
|
if (_writer.isOpened ()) {
|
if (mat.empty())
|
convert_to_mat (_buf, mat);
|
|
_writer.write (mat);
|
}
|
}
|
#endif
|
|
static int
|
parse_camera_info (const char *path, uint32_t idx, CameraInfo &info, uint32_t camera_count)
|
{
|
static const char *instrinsic_names[] = {
|
"intrinsic_camera_front.txt", "intrinsic_camera_right.txt",
|
"intrinsic_camera_rear.txt", "intrinsic_camera_left.txt"
|
};
|
static const char *exstrinsic_names[] = {
|
"extrinsic_camera_front.txt", "extrinsic_camera_right.txt",
|
"extrinsic_camera_rear.txt", "extrinsic_camera_left.txt"
|
};
|
static const float viewpoints_range[] = {64.0f, 160.0f, 64.0f, 160.0f};
|
|
char intrinsic_path[XCAM_TEST_MAX_STR_SIZE] = {'\0'};
|
char extrinsic_path[XCAM_TEST_MAX_STR_SIZE] = {'\0'};
|
snprintf (intrinsic_path, XCAM_TEST_MAX_STR_SIZE, "%s/%s", path, instrinsic_names[idx]);
|
snprintf (extrinsic_path, XCAM_TEST_MAX_STR_SIZE, "%s/%s", path, exstrinsic_names[idx]);
|
|
CalibrationParser parser;
|
CHECK (
|
parser.parse_intrinsic_file (intrinsic_path, info.calibration.intrinsic),
|
"parse intrinsic params (%s)failed.", intrinsic_path);
|
|
CHECK (
|
parser.parse_extrinsic_file (extrinsic_path, info.calibration.extrinsic),
|
"parse extrinsic params (%s)failed.", extrinsic_path);
|
info.calibration.extrinsic.trans_x += TEST_CAMERA_POSITION_OFFSET_X;
|
|
info.angle_range = viewpoints_range[idx];
|
info.round_angle_start = (idx * 360.0f / camera_count) - info.angle_range / 2.0f;
|
return 0;
|
}
|
|
static void
|
combine_name (const char *orig_name, const char *embedded_str, char *new_name)
|
{
|
const char *dir_delimiter = std::strrchr (orig_name, '/');
|
|
if (dir_delimiter) {
|
std::string path (orig_name, dir_delimiter - orig_name + 1);
|
XCAM_ASSERT (path.c_str ());
|
snprintf (new_name, XCAM_TEST_MAX_STR_SIZE, "%s%s_%s", path.c_str (), embedded_str, dir_delimiter + 1);
|
} else {
|
snprintf (new_name, XCAM_TEST_MAX_STR_SIZE, "%s_%s", embedded_str, orig_name);
|
}
|
}
|
|
static void
|
add_element (SoftElements &elements, const char *element_name, uint32_t width, uint32_t height)
|
{
|
char file_name[XCAM_TEST_MAX_STR_SIZE] = {'\0'};
|
combine_name (elements[0]->get_file_name (), element_name, file_name);
|
|
SmartPtr<SoftElement> element = new SoftElement (file_name, width, height);
|
elements.push_back (element);
|
}
|
|
static XCamReturn
|
elements_open_file (const SoftElements &elements, const char *option, const bool &nv12_output)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
for (uint32_t i = 0; i < elements.size (); ++i) {
|
if (nv12_output)
|
ret = elements[i]->open_file (option);
|
#if XCAM_TEST_OPENCV
|
else
|
ret = elements[i]->cv_open_writer ();
|
#endif
|
|
if (ret != XCAM_RETURN_NO_ERROR) {
|
XCAM_LOG_ERROR ("open file(%s) failed", elements[i]->get_file_name ());
|
break;
|
}
|
}
|
|
return ret;
|
}
|
|
static XCamReturn
|
remap_topview_buf (
|
BowlModel &model,
|
const SmartPtr<VideoBuffer> &buf,
|
SmartPtr<VideoBuffer> &topview_buf,
|
uint32_t topview_width, uint32_t topview_height)
|
{
|
BowlModel::PointMap points;
|
|
uint32_t lut_w = topview_width / 4, lut_h = topview_height / 4;
|
float length_mm = 0.0f, width_mm = 0.0f;
|
|
model.get_max_topview_area_mm (length_mm, width_mm);
|
XCAM_LOG_INFO ("Max Topview Area (L%.2fmm, W%.2fmm)", length_mm, width_mm);
|
|
model.get_topview_rect_map (points, lut_w, lut_h);
|
SmartPtr<GeoMapper> mapper = GeoMapper::create_soft_geo_mapper ();
|
XCAM_ASSERT (mapper.ptr ());
|
mapper->set_output_size (topview_width, topview_height);
|
mapper->set_lookup_table (points.data (), lut_w, lut_h);
|
|
XCamReturn ret = mapper->remap (buf, topview_buf);
|
if (ret != XCAM_RETURN_NO_ERROR) {
|
XCAM_LOG_ERROR ("remap stitched image to topview failed.");
|
return ret;
|
}
|
|
#if 0
|
BowlModel::VertexMap bowl_vertices;
|
BowlModel::PointMap bowl_points;
|
uint32_t bowl_lut_w = 15, bowl_lut_h = 10;
|
model.get_bowlview_vertex_map (bowl_vertices, bowl_points, bowl_lut_w, bowl_lut_h);
|
for (uint32_t i = 0; i < bowl_lut_h; ++i) {
|
for (uint32_t j = 0; j < bowl_lut_w; ++j)
|
{
|
PointFloat3 &vetex = bowl_vertices[i * bowl_lut_w + j];
|
printf ("(%4.0f, %4.0f, %4.0f), ", vetex.x, vetex.y, vetex.z );
|
}
|
printf ("\n");
|
}
|
#endif
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
static void
|
write_image (const SoftElements &ins, const SoftElements &outs, const bool &nv12_output) {
|
if (nv12_output) {
|
for (uint32_t i = 0; i < outs.size (); ++i)
|
outs[i]->write_buf ();
|
}
|
#if XCAM_TEST_OPENCV
|
else {
|
static uint32_t frame_num = 0;
|
char img_name[XCAM_TEST_MAX_STR_SIZE] = {'\0'};
|
char frame_str[XCAM_TEST_MAX_STR_SIZE] = {'\0'};
|
std::snprintf (frame_str, XCAM_TEST_MAX_STR_SIZE, "frame:%d", frame_num);
|
|
char idx_str[XCAM_TEST_MAX_STR_SIZE] = {'\0'};
|
for (uint32_t i = 0; i < ins.size (); ++i) {
|
std::snprintf (idx_str, XCAM_TEST_MAX_STR_SIZE, "idx:%d", i);
|
std::snprintf (img_name, XCAM_TEST_MAX_STR_SIZE, "orig_fisheye_%d_%d.jpg", frame_num, i);
|
ins[i]->cv_write_image (img_name, frame_str, idx_str);
|
}
|
|
for (uint32_t i = 0; i < outs.size (); ++i) {
|
std::snprintf (img_name, XCAM_TEST_MAX_STR_SIZE, "%s_%d.jpg", outs[i]->get_file_name (), frame_num);
|
outs[i]->cv_write_image (img_name, frame_str);
|
}
|
frame_num++;
|
}
|
#endif
|
}
|
|
static XCamReturn
|
ensure_output_format (const char *file_name, const SoftType &type, bool &nv12_output)
|
{
|
char suffix[XCAM_TEST_MAX_STR_SIZE] = {'\0'};
|
const char *ptr = std::strrchr (file_name, '.');
|
std::snprintf (suffix, XCAM_TEST_MAX_STR_SIZE, "%s", ptr + 1);
|
if (!strcasecmp (suffix, "mp4")) {
|
#if XCAM_TEST_OPENCV
|
if (type != SoftTypeStitch) {
|
XCAM_LOG_ERROR ("only stitch type supports MP4 output format");
|
return XCAM_RETURN_ERROR_PARAM;
|
}
|
nv12_output = false;
|
#else
|
XCAM_LOG_ERROR ("only supports NV12 output format");
|
return XCAM_RETURN_ERROR_PARAM;
|
#endif
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
static bool
|
check_element (const SoftElements &elements, const uint32_t &idx)
|
{
|
if (idx >= elements.size ())
|
return false;
|
|
if (!elements[idx].ptr()) {
|
XCAM_LOG_ERROR ("SoftElement(idx:%d) ptr is NULL", idx);
|
return false;
|
}
|
|
XCAM_FAIL_RETURN (
|
ERROR,
|
elements[idx]->get_width () && elements[idx]->get_height (),
|
false,
|
"SoftElement(idx:%d): invalid parameters width:%d height:%d",
|
idx, elements[idx]->get_width (), elements[idx]->get_height ());
|
|
return true;
|
}
|
|
static XCamReturn
|
check_elements (const SoftElements &elements)
|
{
|
for (uint32_t i = 0; i < elements.size (); ++i) {
|
XCAM_FAIL_RETURN (
|
ERROR,
|
check_element (elements, i),
|
XCAM_RETURN_ERROR_PARAM,
|
"invalid SoftElement index:%d\n", i);
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
static XCamReturn
|
run_topview (const SmartPtr<Stitcher> &stitcher, const SoftElements &outs)
|
{
|
BowlModel bowl_model (stitcher->get_bowl_config (), outs[0]->get_width (), outs[0]->get_height ());
|
return remap_topview_buf (bowl_model, outs[0]->get_buf (), outs[1]->get_buf (),
|
outs[1]->get_width (), outs[1]->get_height ());
|
}
|
|
static int
|
run_stitcher (
|
const SmartPtr<Stitcher> &stitcher,
|
const SoftElements &ins, const SoftElements &outs,
|
bool nv12_output, bool save_output, int loop)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
CHECK (check_elements (ins), "invalid input elements");
|
CHECK (check_elements (outs), "invalid output elements");
|
|
VideoBufferList in_buffers;
|
while (loop--) {
|
for (uint32_t i = 0; i < ins.size (); ++i) {
|
CHECK (ins[i]->rewind_file (), "rewind buffer from file(%s) failed", ins[i]->get_file_name ());
|
}
|
|
do {
|
in_buffers.clear ();
|
|
for (uint32_t i = 0; i < ins.size (); ++i) {
|
ret = ins[i]->read_buf();
|
if (ret == XCAM_RETURN_BYPASS)
|
break;
|
CHECK (ret, "read buffer from file(%s) failed.", ins[i]->get_file_name ());
|
|
in_buffers.push_back (ins[i]->get_buf ());
|
}
|
if (ret == XCAM_RETURN_BYPASS)
|
break;
|
|
CHECK (
|
stitcher->stitch_buffers (in_buffers, outs[0]->get_buf ()),
|
"stitch buffer failed.");
|
|
if (save_output) {
|
if (check_element (outs, 1)) {
|
CHECK (run_topview (stitcher, outs), "run topview failed");
|
}
|
|
write_image (ins, outs, nv12_output);
|
}
|
|
FPS_CALCULATION (soft - stitcher, XCAM_OBJ_DUR_FRAME_NUM);
|
} while (true);
|
}
|
|
return 0;
|
}
|
|
static void usage(const char* arg0)
|
{
|
printf ("Usage:\n"
|
"%s --type TYPE--input0 file0 --input1 file1 --output file\n"
|
"\t--type processing type, selected from: blend, remap, stitch, ...\n"
|
"\t-- [stitch]: read calibration files from exported path $FISHEYE_CONFIG_PATH\n"
|
"\t--input0 input image(NV12)\n"
|
"\t--input1 input image(NV12)\n"
|
"\t--input2 input image(NV12)\n"
|
"\t--input3 input image(NV12)\n"
|
"\t--output output image(NV12)\n"
|
"\t--in-w optional, input width, default: 1920\n"
|
"\t--in-h optional, input height, default: 1080\n"
|
"\t--out-w optional, output width, default: 1920\n"
|
"\t--out-h optional, output height, default: 960\n"
|
"\t--topview-w optional, output width, default: 1280\n"
|
"\t--topview-h optional, output height, default: 720\n"
|
"\t--save optional, save file or not, select from [true/false], default: true\n"
|
"\t--loop optional, how many loops need to run, default: 1\n"
|
"\t--help usage\n",
|
arg0);
|
}
|
|
int main (int argc, char *argv[])
|
{
|
uint32_t input_width = 1920;
|
uint32_t input_height = 1080;
|
uint32_t output_width = 1920; //output_height * 2;
|
uint32_t output_height = 960; //960;
|
uint32_t topview_width = 1280;
|
uint32_t topview_height = 720;
|
SoftType type = SoftTypeNone;
|
|
SoftElements ins;
|
SoftElements outs;
|
|
int loop = 1;
|
bool save_output = true;
|
bool nv12_output = true;
|
|
const struct option long_opts[] = {
|
{"type", required_argument, NULL, 't'},
|
{"input0", required_argument, NULL, 'i'},
|
{"input1", required_argument, NULL, 'j'},
|
{"input2", required_argument, NULL, 'k'},
|
{"input3", required_argument, NULL, 'l'},
|
{"output", required_argument, NULL, 'o'},
|
{"in-w", required_argument, NULL, 'w'},
|
{"in-h", required_argument, NULL, 'h'},
|
{"out-w", required_argument, NULL, 'W'},
|
{"out-h", required_argument, NULL, 'H'},
|
{"topview-w", required_argument, NULL, 'P'},
|
{"topview-h", required_argument, NULL, 'V'},
|
{"save", required_argument, NULL, 's'},
|
{"loop", required_argument, NULL, 'L'},
|
{"help", no_argument, NULL, 'e'},
|
{NULL, 0, NULL, 0},
|
};
|
|
int opt = -1;
|
while ((opt = getopt_long(argc, argv, "", long_opts, NULL)) != -1) {
|
switch (opt) {
|
case 't':
|
XCAM_ASSERT (optarg);
|
if (!strcasecmp (optarg, "blend"))
|
type = SoftTypeBlender;
|
else if (!strcasecmp (optarg, "remap"))
|
type = SoftTypeRemap;
|
else if (!strcasecmp (optarg, "stitch"))
|
type = SoftTypeStitch;
|
else {
|
XCAM_LOG_ERROR ("unknown type:%s", optarg);
|
usage (argv[0]);
|
return -1;
|
}
|
break;
|
|
case 'i':
|
XCAM_ASSERT (optarg);
|
ADD_ENELEMT(ins, optarg);
|
break;
|
case 'j':
|
XCAM_ASSERT (optarg);
|
ADD_ENELEMT(ins, optarg);
|
break;
|
case 'k':
|
XCAM_ASSERT (optarg);
|
ADD_ENELEMT(ins, optarg);
|
break;
|
case 'l':
|
XCAM_ASSERT (optarg);
|
ADD_ENELEMT(ins, optarg);
|
break;
|
case 'o':
|
XCAM_ASSERT (optarg);
|
ADD_ENELEMT(outs, optarg);
|
break;
|
case 'w':
|
input_width = atoi(optarg);
|
break;
|
case 'h':
|
input_height = atoi(optarg);
|
break;
|
case 'W':
|
output_width = atoi(optarg);
|
break;
|
case 'H':
|
output_height = atoi(optarg);
|
break;
|
case 'P':
|
topview_width = atoi(optarg);
|
break;
|
case 'V':
|
topview_height = atoi(optarg);
|
break;
|
case 's':
|
save_output = (strcasecmp (optarg, "false") == 0 ? false : true);
|
break;
|
case 'L':
|
loop = atoi(optarg);
|
break;
|
default:
|
XCAM_LOG_ERROR ("getopt_long return unknown value:%c", opt);
|
usage (argv[0]);
|
return -1;
|
}
|
}
|
|
if (optind < argc || argc < 2) {
|
XCAM_LOG_ERROR ("unknown option %s", argv[optind]);
|
usage (argv[0]);
|
return -1;
|
}
|
|
if (SoftTypeNone == type) {
|
XCAM_LOG_ERROR ("Type was not set");
|
usage (argv[0]);
|
return -1;
|
}
|
|
if (ins.empty () || outs.empty () ||
|
!strlen (ins[0]->get_file_name ()) || !strlen (outs[0]->get_file_name ())) {
|
XCAM_LOG_ERROR ("input or output file name was not set");
|
usage (argv[0]);
|
return -1;
|
}
|
|
for (uint32_t i = 0; i < ins.size (); ++i) {
|
printf ("input%d file:\t\t%s\n", i, ins[i]->get_file_name ());
|
}
|
printf ("output file:\t\t%s\n", outs[0]->get_file_name ());
|
printf ("input width:\t\t%d\n", input_width);
|
printf ("input height:\t\t%d\n", input_height);
|
printf ("output width:\t\t%d\n", output_width);
|
printf ("output height:\t\t%d\n", output_height);
|
printf ("topview width:\t\t%d\n", topview_width);
|
printf ("topview height:\t\t%d\n", topview_height);
|
printf ("save output:\t\t%s\n", save_output ? "true" : "false");
|
printf ("loop count:\t\t%d\n", loop);
|
|
VideoBufferInfo in_info, out_info;
|
in_info.init (V4L2_PIX_FMT_NV12, input_width, input_height);
|
out_info.init (V4L2_PIX_FMT_NV12, output_width, output_height);
|
|
for (uint32_t i = 0; i < ins.size (); ++i) {
|
ins[i]->set_buf_size (input_width, input_height);
|
CHECK (ins[i]->create_buf_pool (in_info, 6), "create buffer pool failed");
|
CHECK (ins[i]->open_file ("rb"), "open file(%s) failed", ins[i]->get_file_name ());
|
}
|
|
outs[0]->set_buf_size (output_width, output_height);
|
if (save_output) {
|
CHECK (ensure_output_format (outs[0]->get_file_name (), type, nv12_output), "unsupported output format");
|
if (nv12_output) {
|
CHECK (outs[0]->open_file ("wb"), "open file(%s) failed", outs[0]->get_file_name ());
|
}
|
}
|
|
switch (type) {
|
case SoftTypeBlender: {
|
CHECK_EXP (ins.size () >= 2, "blender need 2 input files.");
|
SmartPtr<Blender> blender = Blender::create_soft_blender ();
|
XCAM_ASSERT (blender.ptr ());
|
blender->set_output_size (output_width, output_height);
|
Rect merge_window;
|
merge_window.pos_x = 0;
|
merge_window.pos_y = 0;
|
merge_window.width = out_info.width;
|
merge_window.height = out_info.height;
|
blender->set_merge_window (merge_window);
|
|
CHECK (ins[0]->read_buf(), "read buffer from file(%s) failed.", ins[0]->get_file_name ());
|
CHECK (ins[1]->read_buf(), "read buffer from file(%s) failed.", ins[1]->get_file_name ());
|
RUN_N (blender->blend (ins[0]->get_buf (), ins[1]->get_buf (), outs[0]->get_buf ()), loop, "blend buffer failed.");
|
if (save_output)
|
outs[0]->write_buf ();
|
break;
|
}
|
case SoftTypeRemap: {
|
SmartPtr<GeoMapper> mapper = GeoMapper::create_soft_geo_mapper ();
|
XCAM_ASSERT (mapper.ptr ());
|
mapper->set_output_size (output_width, output_height);
|
mapper->set_lookup_table (map_table, MAP_WIDTH, MAP_HEIGHT);
|
//mapper->set_factors ((output_width - 1.0f) / (MAP_WIDTH - 1.0f), (output_height - 1.0f) / (MAP_HEIGHT - 1.0f));
|
|
CHECK (ins[0]->read_buf(), "read buffer from file(%s) failed.", ins[0]->get_file_name ());
|
RUN_N (mapper->remap (ins[0]->get_buf (), outs[0]->get_buf ()), loop, "remap buffer failed.");
|
if (save_output)
|
outs[0]->write_buf ();
|
break;
|
}
|
case SoftTypeStitch: {
|
CHECK_EXP (ins.size () >= 2 && ins.size () <= 4, "stitcher need at 2~4 input files.");
|
|
uint32_t camera_count = ins.size ();
|
SmartPtr<Stitcher> stitcher = Stitcher::create_soft_stitcher ();
|
XCAM_ASSERT (stitcher.ptr ());
|
|
CameraInfo cam_info[4];
|
const char *fisheye_config_path = getenv ("FISHEYE_CONFIG_PATH");
|
if (!fisheye_config_path)
|
fisheye_config_path = FISHEYE_CONFIG_PATH;
|
|
for (uint32_t i = 0; i < camera_count; ++i) {
|
if (parse_camera_info (fisheye_config_path, i, cam_info[i], camera_count) != 0) {
|
XCAM_LOG_ERROR ("parse fisheye dewarp info(idx:%d) failed.", i);
|
return -1;
|
}
|
}
|
|
PointFloat3 bowl_coord_offset;
|
if (camera_count == 4) {
|
centralize_bowl_coord_from_cameras (
|
cam_info[0].calibration.extrinsic, cam_info[1].calibration.extrinsic,
|
cam_info[2].calibration.extrinsic, cam_info[3].calibration.extrinsic,
|
bowl_coord_offset);
|
}
|
|
stitcher->set_camera_num (camera_count);
|
for (uint32_t i = 0; i < camera_count; ++i) {
|
stitcher->set_camera_info (i, cam_info[i]);
|
}
|
|
BowlDataConfig bowl;
|
bowl.wall_height = 3000.0f;
|
bowl.ground_length = 2000.0f;
|
//bowl.a = 5000.0f;
|
//bowl.b = 3600.0f;
|
//bowl.c = 3000.0f;
|
bowl.angle_start = 0.0f;
|
bowl.angle_end = 360.0f;
|
stitcher->set_bowl_config (bowl);
|
stitcher->set_output_size (output_width, output_height);
|
|
if (save_output) {
|
add_element (outs, "topview", topview_width, topview_height);
|
elements_open_file (outs, "wb", nv12_output);
|
}
|
CHECK_EXP (
|
run_stitcher (stitcher, ins, outs, nv12_output, save_output, loop) == 0,
|
"run stitcher failed.");
|
break;
|
}
|
|
default: {
|
XCAM_LOG_ERROR ("unsupported type:%d", type);
|
usage (argv[0]);
|
return -1;
|
}
|
}
|
|
return 0;
|
}
|
