modules/soft/soft_image.h - platform/external/libxcam - Git at Google

 /*
  * soft_image.h - soft image class
  *
  *  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>
  */

 #ifndef XCAM_SOFT_IMAGE_H
 #define XCAM_SOFT_IMAGE_H

 #include <xcam_std.h>
 #include <video_buffer.h>
 #include <vec_mat.h>
 #include <file_handle.h>

 namespace XCam {

 typedef uint8_t Uchar;
 typedef int8_t Char;
 typedef Vector2<uint8_t> Uchar2;
 typedef Vector2<int8_t> Char2;
 typedef Vector2<float> Float2;
 typedef Vector2<int> Int2;

 enum BorderType {
     BorderTypeNearest,
     BorderTypeConst,
     BorderTypeRewind,
 };

 template <typename T>
 class SoftImage
 {
 public:
     typedef T Type;
 private:
     uint8_t    *_buf_ptr;
     uint32_t    _width;
     uint32_t    _height;
     uint32_t    _pitch;

     SmartPtr<VideoBuffer> _bind;

 public:
     explicit SoftImage (const SmartPtr<VideoBuffer> &buf, const uint32_t plane);
     explicit SoftImage (
         const uint32_t width, const uint32_t height,
         uint32_t aligned_width = 0);
     explicit SoftImage (
         const SmartPtr<VideoBuffer> &buf,
         const uint32_t width, const uint32_t height, const uint32_t pictch, const uint32_t offset = 0);

     ~SoftImage () {
         if (!_bind.ptr ()) {
             xcam_free (_buf_ptr);
         }
     }

     uint32_t pixel_size () const {
         return sizeof (T);
     }

     uint32_t get_width () const {
         return _width;
     }
     uint32_t get_height () const {
         return _height;
     }
     uint32_t get_pitch () const {
         return _pitch;
     }
     bool is_valid () const {
         return (_buf_ptr && _width && _height);
     }

     const SmartPtr<VideoBuffer> &get_bind_buf () const {
         return _bind;
     }
     T *get_buf_ptr (int32_t x, int32_t y) {
         return (T *)(_buf_ptr + y * _pitch) + x;
     }
     const T *get_buf_ptr (int32_t x, int32_t y) const {
         return (const T *)(_buf_ptr + y * _pitch) + x;
     }

     inline T read_data_no_check (int32_t x, int32_t y) const {
         const T *t_ptr = (const T *)(_buf_ptr + y * _pitch);
         return t_ptr[x];
     }

     inline T read_data (int32_t x, int32_t y) const {
         border_check (x, y);
         return read_data_no_check (x, y);
     }

     template<typename O>
     inline O read_interpolate_data (float x, float y) const;

     template<typename O, uint32_t N>
     inline void read_interpolate_array (Float2 *pos, O *array) const;

     template<uint32_t N>
     inline void read_array_no_check (const int32_t x, const int32_t y, T *array) const {
         XCAM_ASSERT (N <= 8);
         const T *t_ptr = ((const T *)(_buf_ptr + y * _pitch)) + x;
         memcpy (array, t_ptr, sizeof (T) * N);
     }

     template<typename O, uint32_t N>
     inline void read_array_no_check (const int32_t x, const int32_t y, O *array) const {
         XCAM_ASSERT (N <= 8);
         const T *t_ptr = ((const T *)(_buf_ptr + y * _pitch)) + x;
         for (uint32_t i = 0; i < N; ++i) {
             array[i] = t_ptr[i];
         }
     }

     template<uint32_t N>
     inline void read_array (int32_t x, int32_t y, T *array) const {
         XCAM_ASSERT (N <= 8);
         border_check_y (y);
         if (x + N < _width) {
             read_array_no_check<N> (x, y, array);
         } else {
             const T *t_ptr = ((const T *)(_buf_ptr + y * _pitch));
             for (uint32_t i = 0; i < N; ++i, ++x) {
                 border_check_x (x);
                 array[i] = t_ptr[x];
             }
         }
     }

     template<typename O, uint32_t N>
     inline void read_array (int32_t x, int32_t y, O *array) const {
         XCAM_ASSERT (N <= 8);
         border_check_y (y);
         const T *t_ptr = ((const T *)(_buf_ptr + y * _pitch));
         for (uint32_t i = 0; i < N; ++i, ++x) {
             border_check_x (x);
             array[i] = t_ptr[x];
         }
     }

     inline void write_data (int32_t x, int32_t y, const T &v) {
         if (x < 0 || x >= (int32_t)_width)
             return;
         if (y < 0 || y >= (int32_t)_height)
             return;
         write_data_no_check (x, y, v);
     }

     inline void write_data_no_check (int32_t x, int32_t y, const T &v) {
         T *t_ptr = (T *)(_buf_ptr + y * _pitch);
         t_ptr[x] = v;
     }

     template<uint32_t N>
     inline void write_array_no_check (int32_t x, int32_t y, const T *array) {
         T *t_ptr = (T *)(_buf_ptr + y * _pitch);
         memcpy (t_ptr + x, array, sizeof (T) * N);
     }

     template<uint32_t N>
     inline void write_array (int32_t x, int32_t y, const T *array) {
         if (y < 0 || y >= (int32_t)_height)
             return;

         if (x >= 0 && x + N <= _width) {
             write_array_no_check<N> (x, y, array);
         } else {
             T *t_ptr = ((T *)(_buf_ptr + y * _pitch));
             for (uint32_t i = 0; i < N; ++i, ++x) {
                 if (x < 0 || x >= (int32_t)_width) continue;
                 t_ptr[x] = array[i];
             }
         }
     }

 private:
     inline void border_check_x (int32_t &x) const {
         if (x < 0) x = 0;
         else if (x >= (int32_t)_width) x = (int32_t)(_width - 1);
     }

     inline void border_check_y (int32_t &y) const {
         if (y < 0) y = 0;
         else if (y >= (int32_t)_height) y = (int32_t)(_height - 1);
     }

     inline void border_check (int32_t &x, int32_t &y) const {
         border_check_x (x);
         border_check_y (y);
     }
 };


 template <typename T>
 SoftImage<T>::SoftImage (const SmartPtr<VideoBuffer> &buf, const uint32_t plane)
     : _buf_ptr (NULL)
     , _width (0) , _height (0) , _pitch (0)
 {
     XCAM_ASSERT (buf.ptr ());
     const VideoBufferInfo &info = buf->get_video_info ();
     VideoBufferPlanarInfo planar;
     if (!info.get_planar_info(planar, plane)) {
         XCAM_LOG_ERROR (
             "videobuf to soft image failed. buf format:%s, plane:%d", xcam_fourcc_to_string (info.format), plane);
         return;
     }
     _buf_ptr = buf->map () + info.offsets[plane];
     XCAM_ASSERT (_buf_ptr);
     _pitch = info.strides[plane];
     _height = planar.height;
     _width = planar.pixel_bytes * planar.width / sizeof (T);
     XCAM_ASSERT (_width * sizeof(T) == planar.pixel_bytes * planar.width);
     _bind = buf;
 }

 template <typename T>
 SoftImage<T>::SoftImage (
     const uint32_t width, const uint32_t height, uint32_t aligned_width)
     : _buf_ptr (NULL)
     , _width (0) , _height (0) , _pitch (0)
 {
     if (!aligned_width)
         aligned_width = width;

     XCAM_ASSERT (aligned_width >= width);
     XCAM_ASSERT (width > 0 && height > 0);
     _pitch = aligned_width * sizeof (T);
     _buf_ptr = (uint8_t *)xcam_malloc (_pitch * height);
     XCAM_ASSERT (_buf_ptr);
     _width = width;
     _height = height;
 }

 template <typename T>
 SoftImage<T>::SoftImage (
     const SmartPtr<VideoBuffer> &buf,
     const uint32_t width, const uint32_t height, const uint32_t pictch, const uint32_t offset)
     : _buf_ptr (NULL)
     , _width (width) , _height (height)
     , _pitch (pictch)
     , _bind (buf)
 {
     XCAM_ASSERT (buf.ptr ());
     XCAM_ASSERT (buf->map ());
     _buf_ptr = buf->map () + offset;
 }

 template <typename T>
 inline Uchar convert_to_uchar (const T& v) {
     if (v < 0.0f) return 0;
     else if (v > 255.0f) return 255;
     return (Uchar)(v + 0.5f);
 }

 template <typename T, uint32_t N>
 inline void convert_to_uchar_N (const T *in, Uchar *out) {
     for (uint32_t i = 0; i < N; ++i) {
         out[i] = convert_to_uchar<T> (in[i]);
     }
 }

 template <typename Vec2>
 inline Uchar2 convert_to_uchar2 (const Vec2& v) {
     return Uchar2 (convert_to_uchar(v.x), convert_to_uchar(v.y));
 }

 template <typename Vec2, uint32_t N>
 inline void convert_to_uchar2_N (const Vec2 *in, Uchar2 *out) {
     for (uint32_t i = 0; i < N; ++i) {
         out[i].x = convert_to_uchar (in[i].x);
         out[i].y = convert_to_uchar (in[i].y);
     }
 }

 typedef SoftImage<Uchar> UcharImage;
 typedef SoftImage<Uchar2> Uchar2Image;
 typedef SoftImage<float> FloatImage;
 typedef SoftImage<Float2> Float2Image;

 template <class SoftImageT>
 class SoftImageFile
     : public FileHandle
 {
 public:
     SoftImageFile () {}
     explicit SoftImageFile (const char *name, const char *option)
         : FileHandle (name, option)
     {}

     inline XCamReturn read_buf (const SmartPtr<SoftImageT> &buf);
     inline XCamReturn write_buf (const SmartPtr<SoftImageT> &buf);
 };

 template <class SoftImageT>
 inline XCamReturn
 SoftImageFile<SoftImageT>::read_buf (const SmartPtr<SoftImageT> &buf)
 {
     XCAM_FAIL_RETURN (
         WARNING, is_valid (), XCAM_RETURN_ERROR_PARAM,
         "soft image file(%s) read buf failed, file is not open", XCAM_STR (get_file_name ()));

     XCAM_FAIL_RETURN (
         WARNING, buf->is_valid (), XCAM_RETURN_ERROR_PARAM,
         "soft image file(%s) read buf failed, buf is not valid", XCAM_STR (get_file_name ()));

     XCAM_ASSERT (is_valid ());
     uint32_t height = buf->get_height ();
     uint32_t line_bytes = buf->get_width () * buf->pixel_size ();

     for (uint32_t index = 0; index < height; index++) {
         uint8_t *line_ptr = buf->get_buf_ptr (0, index);
         XCAM_FAIL_RETURN (
             WARNING, fread (line_ptr, 1, line_bytes, _fp) == line_bytes, XCAM_RETURN_ERROR_FILE,
             "soft image file(%s) read buf failed, image_line:%d", XCAM_STR (get_file_name ()), index);
     }
     return XCAM_RETURN_NO_ERROR;
 }

 template <class SoftImageT>
 inline XCamReturn
 SoftImageFile<SoftImageT>::write_buf (const SmartPtr<SoftImageT> &buf)
 {
     XCAM_FAIL_RETURN (
         WARNING, is_valid (), XCAM_RETURN_ERROR_PARAM,
         "soft image file(%s) write buf failed, file is not open", XCAM_STR (get_file_name ()));

     XCAM_FAIL_RETURN (
         WARNING, buf->is_valid (), XCAM_RETURN_ERROR_PARAM,
         "soft image file(%s) write buf failed, buf is not valid", XCAM_STR (get_file_name ()));

     XCAM_ASSERT (is_valid ());
     uint32_t height = buf->get_height ();
     uint32_t line_bytes = buf->get_width () * buf->pixel_size ();

     for (uint32_t index = 0; index < height; index++) {
         uint8_t *line_ptr = buf->get_buf_ptr (0, index);
         XCAM_FAIL_RETURN (
             WARNING, fwrite (line_ptr, 1, line_bytes, _fp) == line_bytes, XCAM_RETURN_ERROR_FILE,
             "soft image file(%s) write buf failed, image_line:%d", XCAM_STR (get_file_name ()), index);
     }
     return XCAM_RETURN_NO_ERROR;
 }

 template <typename T> template <typename O>
 O
 SoftImage<T>::read_interpolate_data (float x, float y) const
 {
     int32_t x0 = (int32_t)(x), y0 = (int32_t)(y);
     float a = x - x0, b = y - y0;
     O l0[2], l1[2];
     read_array<O, 2> (x0, y0, l0);
     read_array<O, 2> (x0, y0 + 1, l1);

     return l1[1] * (a * b) + l0[0] * ((1 - a) * (1 - b)) +
            l1[0] * ((1 - a) * b) + l0[1] * (a * (1 - b));
 }

 template <typename T> template<typename O, uint32_t N>
 void
 SoftImage<T>::read_interpolate_array (Float2 *pos, O *array) const
 {
     for (uint32_t i = 0; i < N; ++i) {
         array[i] = read_interpolate_data<O> (pos[i].x, pos[i].y);
     }
 }

 }
 #endif //XCAM_SOFT_IMAGE_H
	/*
	* soft_image.h - soft image class
	*
	* 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>
	*/

	#ifndef XCAM_SOFT_IMAGE_H
	#define XCAM_SOFT_IMAGE_H

	#include <xcam_std.h>
	#include <video_buffer.h>
	#include <vec_mat.h>
	#include <file_handle.h>

	namespace XCam {

	typedef uint8_t Uchar;
	typedef int8_t Char;
	typedef Vector2<uint8_t> Uchar2;
	typedef Vector2<int8_t> Char2;
	typedef Vector2<float> Float2;
	typedef Vector2<int> Int2;

	enum BorderType {
	BorderTypeNearest,
	BorderTypeConst,
	BorderTypeRewind,
	};

	template <typename T>
	class SoftImage
	{
	public:
	typedef T Type;
	private:
	uint8_t *_buf_ptr;
	uint32_t _width;
	uint32_t _height;
	uint32_t _pitch;

	SmartPtr<VideoBuffer> _bind;

	public:
	explicit SoftImage (const SmartPtr<VideoBuffer> &buf, const uint32_t plane);
	explicit SoftImage (
	const uint32_t width, const uint32_t height,
	uint32_t aligned_width = 0);
	explicit SoftImage (
	const SmartPtr<VideoBuffer> &buf,
	const uint32_t width, const uint32_t height, const uint32_t pictch, const uint32_t offset = 0);

	~SoftImage () {
	if (!_bind.ptr ()) {
	xcam_free (_buf_ptr);
	}
	}

	uint32_t pixel_size () const {
	return sizeof (T);
	}

	uint32_t get_width () const {
	return _width;
	}
	uint32_t get_height () const {
	return _height;
	}
	uint32_t get_pitch () const {
	return _pitch;
	}
	bool is_valid () const {
	return (_buf_ptr && _width && _height);
	}

	const SmartPtr<VideoBuffer> &get_bind_buf () const {
	return _bind;
	}
	T *get_buf_ptr (int32_t x, int32_t y) {
	return (T )(_buf_ptr + y _pitch) + x;
	}
	const T *get_buf_ptr (int32_t x, int32_t y) const {
	return (const T )(_buf_ptr + y _pitch) + x;
	}

	inline T read_data_no_check (int32_t x, int32_t y) const {
	const T t_ptr = (const T )(_buf_ptr + y * _pitch);
	return t_ptr[x];
	}

	inline T read_data (int32_t x, int32_t y) const {
	border_check (x, y);
	return read_data_no_check (x, y);
	}

	template<typename O>
	inline O read_interpolate_data (float x, float y) const;

	template<typename O, uint32_t N>
	inline void read_interpolate_array (Float2 pos, O array) const;

	template<uint32_t N>
	inline void read_array_no_check (const int32_t x, const int32_t y, T *array) const {
	XCAM_ASSERT (N <= 8);
	const T t_ptr = ((const T )(_buf_ptr + y * _pitch)) + x;
	memcpy (array, t_ptr, sizeof (T) * N);
	}

	template<typename O, uint32_t N>
	inline void read_array_no_check (const int32_t x, const int32_t y, O *array) const {
	XCAM_ASSERT (N <= 8);
	const T t_ptr = ((const T )(_buf_ptr + y * _pitch)) + x;
	for (uint32_t i = 0; i < N; ++i) {
	array[i] = t_ptr[i];
	}
	}

	template<uint32_t N>
	inline void read_array (int32_t x, int32_t y, T *array) const {
	XCAM_ASSERT (N <= 8);
	border_check_y (y);
	if (x + N < _width) {
	read_array_no_check<N> (x, y, array);
	} else {
	const T t_ptr = ((const T )(_buf_ptr + y * _pitch));
	for (uint32_t i = 0; i < N; ++i, ++x) {
	border_check_x (x);
	array[i] = t_ptr[x];
	}
	}
	}

	template<typename O, uint32_t N>
	inline void read_array (int32_t x, int32_t y, O *array) const {
	XCAM_ASSERT (N <= 8);
	border_check_y (y);
	const T t_ptr = ((const T )(_buf_ptr + y * _pitch));
	for (uint32_t i = 0; i < N; ++i, ++x) {
	border_check_x (x);
	array[i] = t_ptr[x];
	}
	}

	inline void write_data (int32_t x, int32_t y, const T &v) {
	if (x < 0 \|\| x >= (int32_t)_width)
	return;
	if (y < 0 \|\| y >= (int32_t)_height)
	return;
	write_data_no_check (x, y, v);
	}

	inline void write_data_no_check (int32_t x, int32_t y, const T &v) {
	T t_ptr = (T )(_buf_ptr + y * _pitch);
	t_ptr[x] = v;
	}

	template<uint32_t N>
	inline void write_array_no_check (int32_t x, int32_t y, const T *array) {
	T t_ptr = (T )(_buf_ptr + y * _pitch);
	memcpy (t_ptr + x, array, sizeof (T) * N);
	}

	template<uint32_t N>
	inline void write_array (int32_t x, int32_t y, const T *array) {
	if (y < 0 \|\| y >= (int32_t)_height)
	return;

	if (x >= 0 && x + N <= _width) {
	write_array_no_check<N> (x, y, array);
	} else {
	T t_ptr = ((T )(_buf_ptr + y * _pitch));
	for (uint32_t i = 0; i < N; ++i, ++x) {
	if (x < 0 \|\| x >= (int32_t)_width) continue;
	t_ptr[x] = array[i];
	}
	}
	}

	private:
	inline void border_check_x (int32_t &x) const {
	if (x < 0) x = 0;
	else if (x >= (int32_t)_width) x = (int32_t)(_width - 1);
	}

	inline void border_check_y (int32_t &y) const {
	if (y < 0) y = 0;
	else if (y >= (int32_t)_height) y = (int32_t)(_height - 1);
	}

	inline void border_check (int32_t &x, int32_t &y) const {
	border_check_x (x);
	border_check_y (y);
	}
	};


	template <typename T>
	SoftImage<T>::SoftImage (const SmartPtr<VideoBuffer> &buf, const uint32_t plane)
	: _buf_ptr (NULL)
	, _width (0) , _height (0) , _pitch (0)
	{
	XCAM_ASSERT (buf.ptr ());
	const VideoBufferInfo &info = buf->get_video_info ();
	VideoBufferPlanarInfo planar;
	if (!info.get_planar_info(planar, plane)) {
	XCAM_LOG_ERROR (
	"videobuf to soft image failed. buf format:%s, plane:%d", xcam_fourcc_to_string (info.format), plane);
	return;
	}
	_buf_ptr = buf->map () + info.offsets[plane];
	XCAM_ASSERT (_buf_ptr);
	_pitch = info.strides[plane];
	_height = planar.height;
	_width = planar.pixel_bytes * planar.width / sizeof (T);
	XCAM_ASSERT (_width * sizeof(T) == planar.pixel_bytes * planar.width);
	_bind = buf;
	}

	template <typename T>
	SoftImage<T>::SoftImage (
	const uint32_t width, const uint32_t height, uint32_t aligned_width)
	: _buf_ptr (NULL)
	, _width (0) , _height (0) , _pitch (0)
	{
	if (!aligned_width)
	aligned_width = width;

	XCAM_ASSERT (aligned_width >= width);
	XCAM_ASSERT (width > 0 && height > 0);
	_pitch = aligned_width * sizeof (T);
	_buf_ptr = (uint8_t )xcam_malloc (_pitch height);
	XCAM_ASSERT (_buf_ptr);
	_width = width;
	_height = height;
	}

	template <typename T>
	SoftImage<T>::SoftImage (
	const SmartPtr<VideoBuffer> &buf,
	const uint32_t width, const uint32_t height, const uint32_t pictch, const uint32_t offset)
	: _buf_ptr (NULL)
	, _width (width) , _height (height)
	, _pitch (pictch)
	, _bind (buf)
	{
	XCAM_ASSERT (buf.ptr ());
	XCAM_ASSERT (buf->map ());
	_buf_ptr = buf->map () + offset;
	}

	template <typename T>
	inline Uchar convert_to_uchar (const T& v) {
	if (v < 0.0f) return 0;
	else if (v > 255.0f) return 255;
	return (Uchar)(v + 0.5f);
	}

	template <typename T, uint32_t N>
	inline void convert_to_uchar_N (const T in, Uchar out) {
	for (uint32_t i = 0; i < N; ++i) {
	out[i] = convert_to_uchar<T> (in[i]);
	}
	}

	template <typename Vec2>
	inline Uchar2 convert_to_uchar2 (const Vec2& v) {
	return Uchar2 (convert_to_uchar(v.x), convert_to_uchar(v.y));
	}

	template <typename Vec2, uint32_t N>
	inline void convert_to_uchar2_N (const Vec2 in, Uchar2 out) {
	for (uint32_t i = 0; i < N; ++i) {
	out[i].x = convert_to_uchar (in[i].x);
	out[i].y = convert_to_uchar (in[i].y);
	}
	}

	typedef SoftImage<Uchar> UcharImage;
	typedef SoftImage<Uchar2> Uchar2Image;
	typedef SoftImage<float> FloatImage;
	typedef SoftImage<Float2> Float2Image;

	template <class SoftImageT>
	class SoftImageFile
	: public FileHandle
	{
	public:
	SoftImageFile () {}
	explicit SoftImageFile (const char name, const char option)
	: FileHandle (name, option)
	{}

	inline XCamReturn read_buf (const SmartPtr<SoftImageT> &buf);
	inline XCamReturn write_buf (const SmartPtr<SoftImageT> &buf);
	};

	template <class SoftImageT>
	inline XCamReturn
	SoftImageFile<SoftImageT>::read_buf (const SmartPtr<SoftImageT> &buf)
	{
	XCAM_FAIL_RETURN (
	WARNING, is_valid (), XCAM_RETURN_ERROR_PARAM,
	"soft image file(%s) read buf failed, file is not open", XCAM_STR (get_file_name ()));

	XCAM_FAIL_RETURN (
	WARNING, buf->is_valid (), XCAM_RETURN_ERROR_PARAM,
	"soft image file(%s) read buf failed, buf is not valid", XCAM_STR (get_file_name ()));

	XCAM_ASSERT (is_valid ());
	uint32_t height = buf->get_height ();
	uint32_t line_bytes = buf->get_width () * buf->pixel_size ();

	for (uint32_t index = 0; index < height; index++) {
	uint8_t *line_ptr = buf->get_buf_ptr (0, index);
	XCAM_FAIL_RETURN (
	WARNING, fread (line_ptr, 1, line_bytes, _fp) == line_bytes, XCAM_RETURN_ERROR_FILE,
	"soft image file(%s) read buf failed, image_line:%d", XCAM_STR (get_file_name ()), index);
	}
	return XCAM_RETURN_NO_ERROR;
	}

	template <class SoftImageT>
	inline XCamReturn
	SoftImageFile<SoftImageT>::write_buf (const SmartPtr<SoftImageT> &buf)
	{
	XCAM_FAIL_RETURN (
	WARNING, is_valid (), XCAM_RETURN_ERROR_PARAM,
	"soft image file(%s) write buf failed, file is not open", XCAM_STR (get_file_name ()));

	XCAM_FAIL_RETURN (
	WARNING, buf->is_valid (), XCAM_RETURN_ERROR_PARAM,
	"soft image file(%s) write buf failed, buf is not valid", XCAM_STR (get_file_name ()));

	XCAM_ASSERT (is_valid ());
	uint32_t height = buf->get_height ();
	uint32_t line_bytes = buf->get_width () * buf->pixel_size ();

	for (uint32_t index = 0; index < height; index++) {
	uint8_t *line_ptr = buf->get_buf_ptr (0, index);
	XCAM_FAIL_RETURN (
	WARNING, fwrite (line_ptr, 1, line_bytes, _fp) == line_bytes, XCAM_RETURN_ERROR_FILE,
	"soft image file(%s) write buf failed, image_line:%d", XCAM_STR (get_file_name ()), index);
	}
	return XCAM_RETURN_NO_ERROR;
	}

	template <typename T> template <typename O>
	O
	SoftImage<T>::read_interpolate_data (float x, float y) const
	{
	int32_t x0 = (int32_t)(x), y0 = (int32_t)(y);
	float a = x - x0, b = y - y0;
	O l0[2], l1[2];
	read_array<O, 2> (x0, y0, l0);
	read_array<O, 2> (x0, y0 + 1, l1);

	return l1[1] * (a * b) + l0[0] * ((1 - a) * (1 - b)) +
	l1[0] * ((1 - a) * b) + l0[1] * (a * (1 - b));
	}

	template <typename T> template<typename O, uint32_t N>
	void
	SoftImage<T>::read_interpolate_array (Float2 pos, O array) const
	{
	for (uint32_t i = 0; i < N; ++i) {
	array[i] = read_interpolate_data<O> (pos[i].x, pos[i].y);
	}
	}

	}
	#endif //XCAM_SOFT_IMAGE_H