path: root/tests/test-soft-image.cpp

/*
 * 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;
}