tests/test-pipe-manager.cpp - platform/external/libxcam - Git at Google

 /*
   * test-pipe-manager.cpp -test pipe manager
   *
   *  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: Yinhang Liu <yinhangx.liu@intel.com>
   */

 #include <pipe_manager.h>
 #include <smart_analyzer_loader.h>
 #include <ocl/cl_post_image_processor.h>
 #if HAVE_LIBDRM
 #include <drm_display.h>
 #endif
 #include <getopt.h>
 #include <test_common.h>
 #include <signal.h>
 #include <stdio.h>

 #define DEFAULT_FPT_BUF_COUNT 32

 using namespace XCam;

 static bool is_stop = false;

 struct FileFP {
     FILE *fp;
     FileFP ()
         : fp (NULL)
     {}
     ~FileFP ()
     {
         if (fp)
             fclose (fp);
         fp = NULL;
     }
 };

 class MainPipeManager
     : public PipeManager
 {
 public:
     MainPipeManager ()
         : _image_width (0)
         , _image_height (0)
         , _enable_display (false)
     {
 #if HAVE_LIBDRM
         _display = DrmDisplay::instance ();
 #endif
         XCAM_OBJ_PROFILING_INIT;
     }

     void set_image_width (uint32_t image_width) {
         _image_width = image_width;
     }

     void set_image_height (uint32_t image_height) {
         _image_height = image_height;
     }

     void enable_display (bool value) {
         _enable_display = value;
     }

 #if HAVE_LIBDRM
     void set_display_mode (DrmDisplayMode mode) {
         _display->set_display_mode (mode);
     }
 #endif

 protected:
     virtual void post_buffer (const SmartPtr<VideoBuffer> &buf);
     int display_buf (const SmartPtr<VideoBuffer> &buf);

 private:
     uint32_t              _image_width;
     uint32_t              _image_height;
     bool                  _enable_display;
 #if HAVE_LIBDRM
     SmartPtr<DrmDisplay>  _display;
 #endif
     XCAM_OBJ_PROFILING_DEFINES;
 };

 void
 MainPipeManager::post_buffer (const SmartPtr<VideoBuffer> &buf)
 {
     FPS_CALCULATION (fps_buf, XCAM_OBJ_DUR_FRAME_NUM);

     XCAM_OBJ_PROFILING_START;

     if (_enable_display)
         display_buf (buf);

     XCAM_OBJ_PROFILING_END("main_pipe_manager_display", XCAM_OBJ_DUR_FRAME_NUM);
 }

 int
 MainPipeManager::display_buf (const SmartPtr<VideoBuffer> &data)
 {
 #if HAVE_LIBDRM
     XCamReturn ret = XCAM_RETURN_NO_ERROR;
     SmartPtr<VideoBuffer> buf = data;
     const VideoBufferInfo & frame_info = buf->get_video_info ();
     struct v4l2_rect rect = { 0, 0, frame_info.width, frame_info.height};

     if (!_display->is_render_inited ()) {
         ret = _display->render_init (0, 0, this->_image_width, this->_image_height,
                                      frame_info.format, &rect);
         CHECK (ret, "display failed on render_init");
     }
     ret = _display->render_setup_frame_buffer (buf);
     CHECK (ret, "display failed on framebuf set");
     ret = _display->render_buffer (buf);
     CHECK (ret, "display failed on rendering");
 #else
     XCAM_UNUSED (data);
 #endif

     return 0;
 }

 XCamReturn
 read_buf (SmartPtr<VideoBuffer> &buf, FileFP &file)
 {
     const VideoBufferInfo info = buf->get_video_info ();
     VideoBufferPlanarInfo planar;
     XCamReturn ret = XCAM_RETURN_NO_ERROR;

     uint8_t *memory = buf->map ();
     for (uint32_t index = 0; index < info.components; index++) {
         info.get_planar_info (planar, index);
         uint32_t line_bytes = planar.width * planar.pixel_bytes;

         for (uint32_t i = 0; i < planar.height; i++) {
             if (fread (memory + info.offsets [index] + i * info.strides [index], 1, line_bytes, file.fp) != line_bytes) {
                 if (feof (file.fp)) {
                     fseek (file.fp, 0, SEEK_SET);
                     ret = XCAM_RETURN_BYPASS;
                 } else {
                     XCAM_LOG_ERROR ("read file failed, size doesn't match");
                     ret = XCAM_RETURN_ERROR_FILE;
                 }
                 goto done;
             }
         }
     }
 done:
     buf->unmap ();
     return ret;
 }

 void pipe_stop_handler(int sig)
 {
     XCAM_UNUSED (sig);
     is_stop = true;
 }

 void print_help (const char *bin_name)
 {
     printf ("Usage: %s [--format=NV12] [--width=1920] ...\n"
             "\t --format           specify output pixel format, default is NV12\n"
             "\t --width            specify input image width, default is 1920\n"
             "\t --height           specify input image height, default is 1080\n"
             "\t --fake-input       specify the path of image as fake source\n"
             "\t --defog-mode       specify defog mode\n"
             "\t                    select from [disabled, retinex, dcp], default is [disabled]\n"
             "\t --wavelet-mode     specify wavelet denoise mode, default is disable\n"
             "\t                    select from [0:disable, 1:Hat Y, 2:Hat UV, 3:Haar Y, 4:Haar UV, 5:Haar YUV, 6:Haar Bayes Shrink]\n"
             "\t --3d-denoise       specify 3D Denoise mode\n"
             "\t                    select from [disabled, yuv, uv], default is [disabled]\n"
             "\t --enable-wireframe enable wire frame\n"
             "\t --enable-warp      enable image warp\n"
             "\t --display-mode     display mode\n"
             "\t                    select from [primary, overlay], default is [primary]\n"
             "\t -p                 enable local display, need root privilege\n"
             "\t -h                 help\n"
             , bin_name);
 }

 int main (int argc, char *argv[])
 {
     const char *bin_name = argv[0];

     XCamReturn ret = XCAM_RETURN_NO_ERROR;
     VideoBufferInfo buf_info;
     SmartPtr<VideoBuffer> video_buf;
     SmartPtr<SmartAnalyzer> smart_analyzer;
     SmartPtr<CLPostImageProcessor> cl_post_processor;
     SmartPtr<BufferPool> buf_pool;

     uint32_t pixel_format = V4L2_PIX_FMT_NV12;
     uint32_t image_width = 1920;
     uint32_t image_height = 1080;
     bool need_display = false;
 #if HAVE_LIBDRM
     DrmDisplayMode display_mode = DRM_DISPLAY_MODE_PRIMARY;
 #endif
     const char *input_path = NULL;
     FileFP input_fp;

     uint32_t defog_mode = 0;
     CLWaveletBasis wavelet_mode = CL_WAVELET_DISABLED;
     uint32_t wavelet_channel = CL_IMAGE_CHANNEL_UV;
     bool wavelet_bayes_shrink = false;
     uint32_t denoise_3d_mode = 0;
     uint8_t denoise_3d_ref_count = 3;
     bool enable_wireframe = false;
     bool enable_image_warp = false;

     int opt;
     const char *short_opts = "ph";
     const struct option long_opts [] = {
         {"format", required_argument, NULL, 'F'},
         {"width", required_argument, NULL, 'W'},
         {"height", required_argument, NULL, 'H'},
         {"fake-input", required_argument, NULL, 'A'},
         {"defog-mode", required_argument, NULL, 'D'},
         {"wavelet-mode", required_argument, NULL, 'V'},
         {"3d-denoise", required_argument, NULL, 'N'},
         {"enable-wireframe", no_argument, NULL, 'I'},
         {"enable-warp", no_argument, NULL, 'S'},
         {"display-mode", required_argument, NULL, 'P'},
         {NULL, 0, NULL, 0}
     };

     while ((opt = getopt_long (argc, argv, short_opts, long_opts, NULL)) != -1) {
         switch (opt) {
         case 'F': {
             XCAM_ASSERT (optarg);
             CHECK_EXP ((strlen (optarg) == 4), "invalid pixel format\n");
             pixel_format = v4l2_fourcc ((unsigned) optarg[0],
                                         (unsigned) optarg[1],
                                         (unsigned) optarg[2],
                                         (unsigned) optarg[3]);
             break;
         }
         case 'W': {
             XCAM_ASSERT (optarg);
             image_width = atoi (optarg);
             break;
         }
         case 'H': {
             XCAM_ASSERT (optarg);
             image_height = atoi (optarg);
             break;
         }
         case 'A': {
             XCAM_ASSERT (optarg);
             XCAM_LOG_INFO ("use image %s as input source", optarg);
             input_path = optarg;
             break;
         }
         case 'D': {
             XCAM_ASSERT (optarg);
             if (!strcmp (optarg, "disabled"))
                 defog_mode = CLPostImageProcessor::DefogDisabled;
             else if (!strcmp (optarg, "retinex"))
                 defog_mode = CLPostImageProcessor::DefogRetinex;
             else if (!strcmp (optarg, "dcp"))
                 defog_mode = CLPostImageProcessor::DefogDarkChannelPrior;
             else {
                 print_help (bin_name);
                 return -1;
             }
             break;
         }
         case 'V': {
             XCAM_ASSERT (optarg);
             if (atoi(optarg) < 0 || atoi(optarg) > 255) {
                 print_help (bin_name);
                 return -1;
             }
             if (atoi(optarg) == 1) {
                 wavelet_mode = CL_WAVELET_HAT;
                 wavelet_channel = CL_IMAGE_CHANNEL_Y;
             } else if (atoi(optarg) == 2) {
                 wavelet_mode = CL_WAVELET_HAT;
                 wavelet_channel = CL_IMAGE_CHANNEL_UV;
             } else if (atoi(optarg) == 3) {
                 wavelet_mode = CL_WAVELET_HAAR;
                 wavelet_channel = CL_IMAGE_CHANNEL_Y;
             } else if (atoi(optarg) == 4) {
                 wavelet_mode = CL_WAVELET_HAAR;
                 wavelet_channel = CL_IMAGE_CHANNEL_UV;
             } else if (atoi(optarg) == 5) {
                 wavelet_mode = CL_WAVELET_HAAR;
                 wavelet_channel = CL_IMAGE_CHANNEL_UV | CL_IMAGE_CHANNEL_Y;
             } else if (atoi(optarg) == 6) {
                 wavelet_mode = CL_WAVELET_HAAR;
                 wavelet_channel = CL_IMAGE_CHANNEL_UV | CL_IMAGE_CHANNEL_Y;
                 wavelet_bayes_shrink = true;
             } else {
                 wavelet_mode = CL_WAVELET_DISABLED;
             }
             break;
         }
         case 'N': {
             XCAM_ASSERT (optarg);
             if (!strcmp (optarg, "disabled"))
                 denoise_3d_mode = CLPostImageProcessor::Denoise3DDisabled;
             else if (!strcmp (optarg, "yuv"))
                 denoise_3d_mode = CLPostImageProcessor::Denoise3DYuv;
             else if (!strcmp (optarg, "uv"))
                 denoise_3d_mode = CLPostImageProcessor::Denoise3DUV;
             else {
                 print_help (bin_name);
                 return -1;
             }
             break;
         }
         case 'I': {
             enable_wireframe = true;
             break;
         }
         case 'S': {
             enable_image_warp = true;
             break;
         }
         case 'P': {
 #if HAVE_LIBDRM
             XCAM_ASSERT (optarg);
             if (!strcmp (optarg, "primary"))
                 display_mode = DRM_DISPLAY_MODE_PRIMARY;
             else if (!strcmp (optarg, "overlay"))
                 display_mode = DRM_DISPLAY_MODE_OVERLAY;
             else {
                 print_help (bin_name);
                 return -1;
             }
 #else
             XCAM_LOG_WARNING ("preview is not supported");
 #endif
             break;
         }
         case 'p': {
 #if HAVE_LIBDRM
             need_display = true;
 #else
             XCAM_LOG_WARNING ("preview is not supported, disable preview now");
             need_display = false;
 #endif
             break;
         }
         case 'h':
             print_help (bin_name);
             return 0;
         default:
             print_help (bin_name);
             return -1;
         }
     }

     signal (SIGINT, pipe_stop_handler);

     if (!input_path) {
         XCAM_LOG_ERROR ("path of image is NULL");
         return -1;
     }
     input_fp.fp = fopen (input_path, "rb");
     if (!input_fp.fp) {
         XCAM_LOG_ERROR ("failed to open file: %s", XCAM_STR (input_path));
         return -1;
     }

     SmartPtr<MainPipeManager> pipe_manager = new MainPipeManager ();
     pipe_manager->set_image_width (image_width);
     pipe_manager->set_image_height (image_height);

     SmartHandlerList smart_handlers = SmartAnalyzerLoader::load_smart_handlers (DEFAULT_SMART_ANALYSIS_LIB_DIR);
     if (!smart_handlers.empty () ) {
         smart_analyzer = new SmartAnalyzer ();
         if (smart_analyzer.ptr ()) {
             SmartHandlerList::iterator i_handler = smart_handlers.begin ();
             for (; i_handler != smart_handlers.end (); ++i_handler) {
                 XCAM_ASSERT ((*i_handler).ptr ());
                 smart_analyzer->add_handler (*i_handler);
             }
         } else {
             XCAM_LOG_INFO ("load smart analyzer(%s) failed", DEFAULT_SMART_ANALYSIS_LIB_DIR);
         }
     }
     if (smart_analyzer.ptr ()) {
         if (smart_analyzer->prepare_handlers () != XCAM_RETURN_NO_ERROR) {
             XCAM_LOG_WARNING ("analyzer(%s) prepare handlers failed", smart_analyzer->get_name ());
         }
         pipe_manager->set_smart_analyzer (smart_analyzer);
     }

     cl_post_processor = new CLPostImageProcessor ();
     cl_post_processor->set_stats_callback (pipe_manager);
     cl_post_processor->set_defog_mode ((CLPostImageProcessor::CLDefogMode) defog_mode);
     cl_post_processor->set_wavelet (wavelet_mode, wavelet_channel, wavelet_bayes_shrink);
     cl_post_processor->set_3ddenoise_mode ((CLPostImageProcessor::CL3DDenoiseMode) denoise_3d_mode, denoise_3d_ref_count);

     cl_post_processor->set_wireframe (enable_wireframe);
     cl_post_processor->set_image_warp (enable_image_warp);
     if (smart_analyzer.ptr () && (enable_wireframe || enable_image_warp)) {
         cl_post_processor->set_scaler (true);
         cl_post_processor->set_scaler_factor (640.0 / image_width);
     }

     pipe_manager->add_image_processor (cl_post_processor);

     buf_info.init (pixel_format, image_width, image_height);
     buf_pool = new CLVideoBufferPool ();
     XCAM_ASSERT (buf_pool.ptr ());
     if (!buf_pool->set_video_info (buf_info) || !buf_pool->reserve (DEFAULT_FPT_BUF_COUNT)) {
         XCAM_LOG_ERROR ("init buffer pool failed");
         return -1;
     }

     if (need_display) {
         need_display = false;
         XCAM_LOG_WARNING ("CLVideoBuffer doesn't support local preview, disable local preview now");
     }

     if (need_display) {
 #if HAVE_LIBDRM
         if (DrmDisplay::set_preview (need_display)) {
             pipe_manager->set_display_mode (display_mode);
             cl_post_processor->set_output_format (V4L2_PIX_FMT_XBGR32);
         } else {
             need_display = false;
             XCAM_LOG_WARNING ("set preview failed, disable local preview now");
         }
 #else
         XCAM_LOG_WARNING ("preview is not supported, disable preview now");
         need_display = false;
 #endif
     }
     pipe_manager->enable_display (need_display);

     ret = pipe_manager->start ();
     CHECK (ret, "pipe manager start failed");

     while (!is_stop) {
         video_buf = buf_pool->get_buffer (buf_pool);
         XCAM_ASSERT (video_buf.ptr ());

         ret = read_buf (video_buf, input_fp);
         if (ret == XCAM_RETURN_BYPASS) {
             ret = read_buf (video_buf, input_fp);
         }

         if (ret == XCAM_RETURN_NO_ERROR)
             pipe_manager->push_buffer (video_buf);
     }

     ret = pipe_manager->stop();
     CHECK (ret, "pipe manager stop failed");

     return 0;
 }
	/*
	* test-pipe-manager.cpp -test pipe manager
	*
	* 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: Yinhang Liu <yinhangx.liu@intel.com>
	*/

	#include <pipe_manager.h>
	#include <smart_analyzer_loader.h>
	#include <ocl/cl_post_image_processor.h>
	#if HAVE_LIBDRM
	#include <drm_display.h>
	#endif
	#include <getopt.h>
	#include <test_common.h>
	#include <signal.h>
	#include <stdio.h>

	#define DEFAULT_FPT_BUF_COUNT 32

	using namespace XCam;

	static bool is_stop = false;

	struct FileFP {
	FILE *fp;
	FileFP ()
	: fp (NULL)
	{}
	~FileFP ()
	{
	if (fp)
	fclose (fp);
	fp = NULL;
	}
	};

	class MainPipeManager
	: public PipeManager
	{
	public:
	MainPipeManager ()
	: _image_width (0)
	, _image_height (0)
	, _enable_display (false)
	{
	#if HAVE_LIBDRM
	_display = DrmDisplay::instance ();
	#endif
	XCAM_OBJ_PROFILING_INIT;
	}

	void set_image_width (uint32_t image_width) {
	_image_width = image_width;
	}

	void set_image_height (uint32_t image_height) {
	_image_height = image_height;
	}

	void enable_display (bool value) {
	_enable_display = value;
	}

	#if HAVE_LIBDRM
	void set_display_mode (DrmDisplayMode mode) {
	_display->set_display_mode (mode);
	}
	#endif

	protected:
	virtual void post_buffer (const SmartPtr<VideoBuffer> &buf);
	int display_buf (const SmartPtr<VideoBuffer> &buf);

	private:
	uint32_t _image_width;
	uint32_t _image_height;
	bool _enable_display;
	#if HAVE_LIBDRM
	SmartPtr<DrmDisplay> _display;
	#endif
	XCAM_OBJ_PROFILING_DEFINES;
	};

	void
	MainPipeManager::post_buffer (const SmartPtr<VideoBuffer> &buf)
	{
	FPS_CALCULATION (fps_buf, XCAM_OBJ_DUR_FRAME_NUM);

	XCAM_OBJ_PROFILING_START;

	if (_enable_display)
	display_buf (buf);

	XCAM_OBJ_PROFILING_END("main_pipe_manager_display", XCAM_OBJ_DUR_FRAME_NUM);
	}

	int
	MainPipeManager::display_buf (const SmartPtr<VideoBuffer> &data)
	{
	#if HAVE_LIBDRM
	XCamReturn ret = XCAM_RETURN_NO_ERROR;
	SmartPtr<VideoBuffer> buf = data;
	const VideoBufferInfo & frame_info = buf->get_video_info ();
	struct v4l2_rect rect = { 0, 0, frame_info.width, frame_info.height};

	if (!_display->is_render_inited ()) {
	ret = _display->render_init (0, 0, this->_image_width, this->_image_height,
	frame_info.format, &rect);
	CHECK (ret, "display failed on render_init");
	}
	ret = _display->render_setup_frame_buffer (buf);
	CHECK (ret, "display failed on framebuf set");
	ret = _display->render_buffer (buf);
	CHECK (ret, "display failed on rendering");
	#else
	XCAM_UNUSED (data);
	#endif

	return 0;
	}

	XCamReturn
	read_buf (SmartPtr<VideoBuffer> &buf, FileFP &file)
	{
	const VideoBufferInfo info = buf->get_video_info ();
	VideoBufferPlanarInfo planar;
	XCamReturn ret = XCAM_RETURN_NO_ERROR;

	uint8_t *memory = buf->map ();
	for (uint32_t index = 0; index < info.components; index++) {
	info.get_planar_info (planar, index);
	uint32_t line_bytes = planar.width * planar.pixel_bytes;

	for (uint32_t i = 0; i < planar.height; i++) {
	if (fread (memory + info.offsets [index] + i * info.strides [index], 1, line_bytes, file.fp) != line_bytes) {
	if (feof (file.fp)) {
	fseek (file.fp, 0, SEEK_SET);
	ret = XCAM_RETURN_BYPASS;
	} else {
	XCAM_LOG_ERROR ("read file failed, size doesn't match");
	ret = XCAM_RETURN_ERROR_FILE;
	}
	goto done;
	}
	}
	}
	done:
	buf->unmap ();
	return ret;
	}

	void pipe_stop_handler(int sig)
	{
	XCAM_UNUSED (sig);
	is_stop = true;
	}

	void print_help (const char *bin_name)
	{
	printf ("Usage: %s [--format=NV12] [--width=1920] ...\n"
	"\t --format specify output pixel format, default is NV12\n"
	"\t --width specify input image width, default is 1920\n"
	"\t --height specify input image height, default is 1080\n"
	"\t --fake-input specify the path of image as fake source\n"
	"\t --defog-mode specify defog mode\n"
	"\t select from [disabled, retinex, dcp], default is [disabled]\n"
	"\t --wavelet-mode specify wavelet denoise mode, default is disable\n"
	"\t select from [0:disable, 1:Hat Y, 2:Hat UV, 3:Haar Y, 4:Haar UV, 5:Haar YUV, 6:Haar Bayes Shrink]\n"
	"\t --3d-denoise specify 3D Denoise mode\n"
	"\t select from [disabled, yuv, uv], default is [disabled]\n"
	"\t --enable-wireframe enable wire frame\n"
	"\t --enable-warp enable image warp\n"
	"\t --display-mode display mode\n"
	"\t select from [primary, overlay], default is [primary]\n"
	"\t -p enable local display, need root privilege\n"
	"\t -h help\n"
	, bin_name);
	}

	int main (int argc, char *argv[])
	{
	const char *bin_name = argv[0];

	XCamReturn ret = XCAM_RETURN_NO_ERROR;
	VideoBufferInfo buf_info;
	SmartPtr<VideoBuffer> video_buf;
	SmartPtr<SmartAnalyzer> smart_analyzer;
	SmartPtr<CLPostImageProcessor> cl_post_processor;
	SmartPtr<BufferPool> buf_pool;

	uint32_t pixel_format = V4L2_PIX_FMT_NV12;
	uint32_t image_width = 1920;
	uint32_t image_height = 1080;
	bool need_display = false;
	#if HAVE_LIBDRM
	DrmDisplayMode display_mode = DRM_DISPLAY_MODE_PRIMARY;
	#endif
	const char *input_path = NULL;
	FileFP input_fp;

	uint32_t defog_mode = 0;
	CLWaveletBasis wavelet_mode = CL_WAVELET_DISABLED;
	uint32_t wavelet_channel = CL_IMAGE_CHANNEL_UV;
	bool wavelet_bayes_shrink = false;
	uint32_t denoise_3d_mode = 0;
	uint8_t denoise_3d_ref_count = 3;
	bool enable_wireframe = false;
	bool enable_image_warp = false;

	int opt;
	const char *short_opts = "ph";
	const struct option long_opts [] = {
	{"format", required_argument, NULL, 'F'},
	{"width", required_argument, NULL, 'W'},
	{"height", required_argument, NULL, 'H'},
	{"fake-input", required_argument, NULL, 'A'},
	{"defog-mode", required_argument, NULL, 'D'},
	{"wavelet-mode", required_argument, NULL, 'V'},
	{"3d-denoise", required_argument, NULL, 'N'},
	{"enable-wireframe", no_argument, NULL, 'I'},
	{"enable-warp", no_argument, NULL, 'S'},
	{"display-mode", required_argument, NULL, 'P'},
	{NULL, 0, NULL, 0}
	};

	while ((opt = getopt_long (argc, argv, short_opts, long_opts, NULL)) != -1) {
	switch (opt) {
	case 'F': {
	XCAM_ASSERT (optarg);
	CHECK_EXP ((strlen (optarg) == 4), "invalid pixel format\n");
	pixel_format = v4l2_fourcc ((unsigned) optarg[0],
	(unsigned) optarg[1],
	(unsigned) optarg[2],
	(unsigned) optarg[3]);
	break;
	}
	case 'W': {
	XCAM_ASSERT (optarg);
	image_width = atoi (optarg);
	break;
	}
	case 'H': {
	XCAM_ASSERT (optarg);
	image_height = atoi (optarg);
	break;
	}
	case 'A': {
	XCAM_ASSERT (optarg);
	XCAM_LOG_INFO ("use image %s as input source", optarg);
	input_path = optarg;
	break;
	}
	case 'D': {
	XCAM_ASSERT (optarg);
	if (!strcmp (optarg, "disabled"))
	defog_mode = CLPostImageProcessor::DefogDisabled;
	else if (!strcmp (optarg, "retinex"))
	defog_mode = CLPostImageProcessor::DefogRetinex;
	else if (!strcmp (optarg, "dcp"))
	defog_mode = CLPostImageProcessor::DefogDarkChannelPrior;
	else {
	print_help (bin_name);
	return -1;
	}
	break;
	}
	case 'V': {
	XCAM_ASSERT (optarg);
	if (atoi(optarg) < 0 \|\| atoi(optarg) > 255) {
	print_help (bin_name);
	return -1;
	}
	if (atoi(optarg) == 1) {
	wavelet_mode = CL_WAVELET_HAT;
	wavelet_channel = CL_IMAGE_CHANNEL_Y;
	} else if (atoi(optarg) == 2) {
	wavelet_mode = CL_WAVELET_HAT;
	wavelet_channel = CL_IMAGE_CHANNEL_UV;
	} else if (atoi(optarg) == 3) {
	wavelet_mode = CL_WAVELET_HAAR;
	wavelet_channel = CL_IMAGE_CHANNEL_Y;
	} else if (atoi(optarg) == 4) {
	wavelet_mode = CL_WAVELET_HAAR;
	wavelet_channel = CL_IMAGE_CHANNEL_UV;
	} else if (atoi(optarg) == 5) {
	wavelet_mode = CL_WAVELET_HAAR;
	wavelet_channel = CL_IMAGE_CHANNEL_UV \| CL_IMAGE_CHANNEL_Y;
	} else if (atoi(optarg) == 6) {
	wavelet_mode = CL_WAVELET_HAAR;
	wavelet_channel = CL_IMAGE_CHANNEL_UV \| CL_IMAGE_CHANNEL_Y;
	wavelet_bayes_shrink = true;
	} else {
	wavelet_mode = CL_WAVELET_DISABLED;
	}
	break;
	}
	case 'N': {
	XCAM_ASSERT (optarg);
	if (!strcmp (optarg, "disabled"))
	denoise_3d_mode = CLPostImageProcessor::Denoise3DDisabled;
	else if (!strcmp (optarg, "yuv"))
	denoise_3d_mode = CLPostImageProcessor::Denoise3DYuv;
	else if (!strcmp (optarg, "uv"))
	denoise_3d_mode = CLPostImageProcessor::Denoise3DUV;
	else {
	print_help (bin_name);
	return -1;
	}
	break;
	}
	case 'I': {
	enable_wireframe = true;
	break;
	}
	case 'S': {
	enable_image_warp = true;
	break;
	}
	case 'P': {
	#if HAVE_LIBDRM
	XCAM_ASSERT (optarg);
	if (!strcmp (optarg, "primary"))
	display_mode = DRM_DISPLAY_MODE_PRIMARY;
	else if (!strcmp (optarg, "overlay"))
	display_mode = DRM_DISPLAY_MODE_OVERLAY;
	else {
	print_help (bin_name);
	return -1;
	}
	#else
	XCAM_LOG_WARNING ("preview is not supported");
	#endif
	break;
	}
	case 'p': {
	#if HAVE_LIBDRM
	need_display = true;
	#else
	XCAM_LOG_WARNING ("preview is not supported, disable preview now");
	need_display = false;
	#endif
	break;
	}
	case 'h':
	print_help (bin_name);
	return 0;
	default:
	print_help (bin_name);
	return -1;
	}
	}

	signal (SIGINT, pipe_stop_handler);

	if (!input_path) {
	XCAM_LOG_ERROR ("path of image is NULL");
	return -1;
	}
	input_fp.fp = fopen (input_path, "rb");
	if (!input_fp.fp) {
	XCAM_LOG_ERROR ("failed to open file: %s", XCAM_STR (input_path));
	return -1;
	}

	SmartPtr<MainPipeManager> pipe_manager = new MainPipeManager ();
	pipe_manager->set_image_width (image_width);
	pipe_manager->set_image_height (image_height);

	SmartHandlerList smart_handlers = SmartAnalyzerLoader::load_smart_handlers (DEFAULT_SMART_ANALYSIS_LIB_DIR);
	if (!smart_handlers.empty () ) {
	smart_analyzer = new SmartAnalyzer ();
	if (smart_analyzer.ptr ()) {
	SmartHandlerList::iterator i_handler = smart_handlers.begin ();
	for (; i_handler != smart_handlers.end (); ++i_handler) {
	XCAM_ASSERT ((*i_handler).ptr ());
	smart_analyzer->add_handler (*i_handler);
	}
	} else {
	XCAM_LOG_INFO ("load smart analyzer(%s) failed", DEFAULT_SMART_ANALYSIS_LIB_DIR);
	}
	}
	if (smart_analyzer.ptr ()) {
	if (smart_analyzer->prepare_handlers () != XCAM_RETURN_NO_ERROR) {
	XCAM_LOG_WARNING ("analyzer(%s) prepare handlers failed", smart_analyzer->get_name ());
	}
	pipe_manager->set_smart_analyzer (smart_analyzer);
	}

	cl_post_processor = new CLPostImageProcessor ();
	cl_post_processor->set_stats_callback (pipe_manager);
	cl_post_processor->set_defog_mode ((CLPostImageProcessor::CLDefogMode) defog_mode);
	cl_post_processor->set_wavelet (wavelet_mode, wavelet_channel, wavelet_bayes_shrink);
	cl_post_processor->set_3ddenoise_mode ((CLPostImageProcessor::CL3DDenoiseMode) denoise_3d_mode, denoise_3d_ref_count);

	cl_post_processor->set_wireframe (enable_wireframe);
	cl_post_processor->set_image_warp (enable_image_warp);
	if (smart_analyzer.ptr () && (enable_wireframe \|\| enable_image_warp)) {
	cl_post_processor->set_scaler (true);
	cl_post_processor->set_scaler_factor (640.0 / image_width);
	}

	pipe_manager->add_image_processor (cl_post_processor);

	buf_info.init (pixel_format, image_width, image_height);
	buf_pool = new CLVideoBufferPool ();
	XCAM_ASSERT (buf_pool.ptr ());
	if (!buf_pool->set_video_info (buf_info) \|\| !buf_pool->reserve (DEFAULT_FPT_BUF_COUNT)) {
	XCAM_LOG_ERROR ("init buffer pool failed");
	return -1;
	}

	if (need_display) {
	need_display = false;
	XCAM_LOG_WARNING ("CLVideoBuffer doesn't support local preview, disable local preview now");
	}

	if (need_display) {
	#if HAVE_LIBDRM
	if (DrmDisplay::set_preview (need_display)) {
	pipe_manager->set_display_mode (display_mode);
	cl_post_processor->set_output_format (V4L2_PIX_FMT_XBGR32);
	} else {
	need_display = false;
	XCAM_LOG_WARNING ("set preview failed, disable local preview now");
	}
	#else
	XCAM_LOG_WARNING ("preview is not supported, disable preview now");
	need_display = false;
	#endif
	}
	pipe_manager->enable_display (need_display);

	ret = pipe_manager->start ();
	CHECK (ret, "pipe manager start failed");

	while (!is_stop) {
	video_buf = buf_pool->get_buffer (buf_pool);
	XCAM_ASSERT (video_buf.ptr ());

	ret = read_buf (video_buf, input_fp);
	if (ret == XCAM_RETURN_BYPASS) {
	ret = read_buf (video_buf, input_fp);
	}

	if (ret == XCAM_RETURN_NO_ERROR)
	pipe_manager->push_buffer (video_buf);
	}

	ret = pipe_manager->stop();
	CHECK (ret, "pipe manager stop failed");

	return 0;
	}