modules/ocl/cl_image_scaler.cpp - platform/external/libxcam - Git at Google

 /*
  * cl_image_scaler.cpp - CL image scaler
  *
  *  Copyright (c) 2015 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: Zong Wei <wei.zong@intel.com>
  */

 #include "cl_utils.h"
 #include "cl_image_scaler.h"

 namespace XCam {

 static const XCamKernelInfo kernel_scale_info = {
     "kernel_image_scaler",
 #include "kernel_image_scaler.clx"
     , 0,
 };

 CLScalerKernel::CLScalerKernel (
     const SmartPtr<CLContext> &context,
     CLImageScalerMemoryLayout mem_layout
 )
     : CLImageKernel (context, "kernel_image_scaler")
     , _mem_layout (mem_layout)
 {
 }

 XCamReturn
 CLScalerKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
 {
     XCamReturn ret = XCAM_RETURN_NO_ERROR;
     SmartPtr<CLContext> context = get_context ();

     SmartPtr<VideoBuffer> input = get_input_buffer ();
     SmartPtr<VideoBuffer> output = get_output_buffer ();
     SmartPtr<CLImage> image_in, image_out;

     XCAM_FAIL_RETURN (
         WARNING,
         input.ptr () && output.ptr (),
         XCAM_RETURN_ERROR_MEM,
         "cl image kernel(%s) get input/output buffer failed", XCAM_STR(get_kernel_name ()));

     const VideoBufferInfo &input_info = input->get_video_info ();
     const VideoBufferInfo &output_info = output->get_video_info ();

     uint32_t output_width = 0, output_height = 0;
     CLImageDesc output_imageDesc;

     uint32_t channel_bits = XCAM_ALIGN_UP (output_info.color_bits, 8);
     if (channel_bits == 8)
         output_imageDesc.format.image_channel_data_type = CL_UNSIGNED_INT8;
     else if (channel_bits == 16)
         output_imageDesc.format.image_channel_data_type = CL_UNSIGNED_INT16;

     if ((CL_IMAGE_SCALER_NV12_UV == get_mem_layout ()) && (V4L2_PIX_FMT_NV12 == input_info.format)) {
         output_imageDesc.format.image_channel_order = CL_RG;
         output_imageDesc.width = output_info.width / 2;
         output_imageDesc.height = output_info.height / 2;
         output_imageDesc.row_pitch = output_info.strides[1];

         image_out = convert_to_climage (context, output, output_imageDesc, output_info.offsets[1]);
         output_width = output_info.width / 2;
         output_height = output_info.height / 2;
     } else {
         output_imageDesc.format.image_channel_order = CL_R;
         output_imageDesc.width = output_info.width;
         output_imageDesc.height = output_info.height;
         output_imageDesc.row_pitch = output_info.strides[0];

         image_out = convert_to_climage (context, output, output_imageDesc, output_info.offsets[0]);
         output_width = output_info.width;
         output_height = output_info.height;
     }

     CLImageDesc input_imageDesc;
     channel_bits = XCAM_ALIGN_UP (input_info.color_bits, 8);
     if (channel_bits == 8)
         input_imageDesc.format.image_channel_data_type = CL_UNSIGNED_INT8;
     else if (channel_bits == 16)
         input_imageDesc.format.image_channel_data_type = CL_UNSIGNED_INT16;

     if ((CL_IMAGE_SCALER_NV12_UV == get_mem_layout ()) && (V4L2_PIX_FMT_NV12 == input_info.format)) {
         input_imageDesc.format.image_channel_order = CL_RG;
         input_imageDesc.width = input_info.width / 2;
         input_imageDesc.height = input_info.height / 2;
         input_imageDesc.row_pitch = input_info.strides[1];

         image_in = convert_to_climage (context, input, input_imageDesc, input_info.offsets[1]);
     } else {
         input_imageDesc.format.image_channel_order = CL_R;
         input_imageDesc.width = input_info.width;
         input_imageDesc.height = input_info.height;
         input_imageDesc.row_pitch = input_info.strides[0];

         image_in = convert_to_climage (context, input, input_imageDesc, input_info.offsets[0]);
     }

     //set args;
     args.push_back (new CLMemArgument (image_in));
     args.push_back (new CLMemArgument (image_out));
     args.push_back (new CLArgumentT<uint32_t> (output_width));
     args.push_back (new CLArgumentT<uint32_t> (output_height));

     work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
     work_size.global[0] = XCAM_ALIGN_UP (output_width, XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE0);
     work_size.global[1] = XCAM_ALIGN_UP (output_height, XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE1);
     work_size.local[0] = XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE0;
     work_size.local[1] = XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE1;

     return ret;
 }

 CLImageScalerKernel::CLImageScalerKernel (
     const SmartPtr<CLContext> &context,
     CLImageScalerMemoryLayout mem_layout,
     SmartPtr<CLImageScaler> &scaler
 )
     : CLScalerKernel (context, mem_layout)
     , _scaler (scaler)
 {
 }

 SmartPtr<VideoBuffer>
 CLImageScalerKernel::get_input_buffer ()
 {
     return _scaler->get_input_buf ();
 }

 SmartPtr<VideoBuffer>
 CLImageScalerKernel::get_output_buffer ()
 {
     return _scaler->get_scaler_buf ();
 }

 CLImageScaler::CLImageScaler (const SmartPtr<CLContext> &context)
     : CLImageHandler (context, "CLImageScaler")
     , _h_scaler_factor (0.5)
     , _v_scaler_factor (0.5)
 {
 }

 void
 CLImageScaler::emit_stop ()
 {
     if (_scaler_buf_pool.ptr ())
         _scaler_buf_pool->stop ();
 }

 bool
 CLImageScaler::set_scaler_factor (const double h_factor, const double v_factor)
 {
     _h_scaler_factor = h_factor;
     _v_scaler_factor = v_factor;

     return true;
 }

 bool
 CLImageScaler::get_scaler_factor (double &h_factor, double &v_factor) const
 {
     h_factor = _h_scaler_factor;
     v_factor = _v_scaler_factor;

     return true;
 };

 XCamReturn
 CLImageScaler::prepare_output_buf (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
 {
     XCamReturn ret = XCAM_RETURN_NO_ERROR;
     output = input;

     ret = prepare_scaler_buf (input->get_video_info (), _scaler_buf);
     XCAM_FAIL_RETURN(
         WARNING,
         ret == XCAM_RETURN_NO_ERROR,
         ret,
         "CLImageScalerKernel prepare scaled video buf failed");

     _scaler_buf->set_timestamp (input->get_timestamp ());

     return ret;
 }

 XCamReturn
 CLImageScaler::execute_done (SmartPtr<VideoBuffer> &output)
 {
     XCAM_UNUSED (output);
     get_context ()->finish();
     XCAM_ASSERT (_scaler_buf.ptr ());

     //post buffer out
     return post_buffer (_scaler_buf);
 }

 XCamReturn
 CLImageScaler::prepare_scaler_buf (const VideoBufferInfo &video_info, SmartPtr<VideoBuffer> &output)
 {
     if (!_scaler_buf_pool.ptr ()) {
         VideoBufferInfo scaler_video_info;
         uint32_t new_width = XCAM_ALIGN_UP ((uint32_t)(video_info.width * _h_scaler_factor),
                                             2 * XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE0);
         uint32_t new_height = XCAM_ALIGN_UP ((uint32_t)(video_info.height * _v_scaler_factor),
                                              2 * XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE1);

         scaler_video_info.init (video_info.format, new_width, new_height);

         _scaler_buf_pool = new CLVideoBufferPool ();
         XCAM_ASSERT (_scaler_buf_pool.ptr ());
         _scaler_buf_pool->set_video_info (scaler_video_info);
         _scaler_buf_pool->reserve (6);
     }

     output = _scaler_buf_pool->get_buffer (_scaler_buf_pool);
     XCAM_ASSERT (output.ptr ());

     return XCAM_RETURN_NO_ERROR;
 }

 XCamReturn
 CLImageScaler::post_buffer (const SmartPtr<VideoBuffer> &buffer)
 {
     if (_scaler_callback.ptr ())
         return _scaler_callback->scaled_image_ready (buffer);

     return XCAM_RETURN_NO_ERROR;
 }

 static SmartPtr<CLImageKernel>
 create_scale_kernel (
     const SmartPtr<CLContext> &context, SmartPtr<CLImageScaler> &handler, CLImageScalerMemoryLayout layout)
 {
     SmartPtr<CLImageKernel> kernel;
     kernel = new CLImageScalerKernel (context, layout, handler);
     XCAM_ASSERT (kernel.ptr ());
     XCAM_FAIL_RETURN (
         ERROR, kernel->build_kernel (kernel_scale_info, NULL) == XCAM_RETURN_NO_ERROR, NULL,
         "build scaler kernel(%s) failed", kernel_scale_info.kernel_name);
     XCAM_ASSERT (kernel->is_valid ());
     return kernel;
 }

 SmartPtr<CLImageHandler>
 create_cl_image_scaler_handler (const SmartPtr<CLContext> &context, const uint32_t format)
 {
     SmartPtr<CLImageScaler> scaler_handler;
     SmartPtr<CLImageKernel> scaler_kernel;

     scaler_handler = new CLImageScaler (context);
     XCAM_ASSERT (scaler_handler.ptr ());

     if (V4L2_PIX_FMT_NV12 == format) {
         //Y
         scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_NV12_Y);
         XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_NV12_Y kernel failed");
         scaler_handler->add_kernel (scaler_kernel);
         //UV
         scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_NV12_UV);
         XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_NV12_UV kernel failed");
         scaler_handler->add_kernel (scaler_kernel);
     } else if (XCAM_PIX_FMT_RGBA64 == format) {
         scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_RGBA);
         XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_RGBA kernel failed");
         scaler_handler->add_kernel (scaler_kernel);
     } else {
         XCAM_LOG_ERROR ("create cl image scaler failed, unknown format:0x%08x", format);
         return NULL;
     }

     return scaler_handler;
 }

 };
	/*
	* cl_image_scaler.cpp - CL image scaler
	*
	* Copyright (c) 2015 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: Zong Wei <wei.zong@intel.com>
	*/

	#include "cl_utils.h"
	#include "cl_image_scaler.h"

	namespace XCam {

	static const XCamKernelInfo kernel_scale_info = {
	"kernel_image_scaler",
	#include "kernel_image_scaler.clx"
	, 0,
	};

	CLScalerKernel::CLScalerKernel (
	const SmartPtr<CLContext> &context,
	CLImageScalerMemoryLayout mem_layout
	)
	: CLImageKernel (context, "kernel_image_scaler")
	, _mem_layout (mem_layout)
	{
	}

	XCamReturn
	CLScalerKernel::prepare_arguments (CLArgList &args, CLWorkSize &work_size)
	{
	XCamReturn ret = XCAM_RETURN_NO_ERROR;
	SmartPtr<CLContext> context = get_context ();

	SmartPtr<VideoBuffer> input = get_input_buffer ();
	SmartPtr<VideoBuffer> output = get_output_buffer ();
	SmartPtr<CLImage> image_in, image_out;

	XCAM_FAIL_RETURN (
	WARNING,
	input.ptr () && output.ptr (),
	XCAM_RETURN_ERROR_MEM,
	"cl image kernel(%s) get input/output buffer failed", XCAM_STR(get_kernel_name ()));

	const VideoBufferInfo &input_info = input->get_video_info ();
	const VideoBufferInfo &output_info = output->get_video_info ();

	uint32_t output_width = 0, output_height = 0;
	CLImageDesc output_imageDesc;

	uint32_t channel_bits = XCAM_ALIGN_UP (output_info.color_bits, 8);
	if (channel_bits == 8)
	output_imageDesc.format.image_channel_data_type = CL_UNSIGNED_INT8;
	else if (channel_bits == 16)
	output_imageDesc.format.image_channel_data_type = CL_UNSIGNED_INT16;

	if ((CL_IMAGE_SCALER_NV12_UV == get_mem_layout ()) && (V4L2_PIX_FMT_NV12 == input_info.format)) {
	output_imageDesc.format.image_channel_order = CL_RG;
	output_imageDesc.width = output_info.width / 2;
	output_imageDesc.height = output_info.height / 2;
	output_imageDesc.row_pitch = output_info.strides[1];

	image_out = convert_to_climage (context, output, output_imageDesc, output_info.offsets[1]);
	output_width = output_info.width / 2;
	output_height = output_info.height / 2;
	} else {
	output_imageDesc.format.image_channel_order = CL_R;
	output_imageDesc.width = output_info.width;
	output_imageDesc.height = output_info.height;
	output_imageDesc.row_pitch = output_info.strides[0];

	image_out = convert_to_climage (context, output, output_imageDesc, output_info.offsets[0]);
	output_width = output_info.width;
	output_height = output_info.height;
	}

	CLImageDesc input_imageDesc;
	channel_bits = XCAM_ALIGN_UP (input_info.color_bits, 8);
	if (channel_bits == 8)
	input_imageDesc.format.image_channel_data_type = CL_UNSIGNED_INT8;
	else if (channel_bits == 16)
	input_imageDesc.format.image_channel_data_type = CL_UNSIGNED_INT16;

	if ((CL_IMAGE_SCALER_NV12_UV == get_mem_layout ()) && (V4L2_PIX_FMT_NV12 == input_info.format)) {
	input_imageDesc.format.image_channel_order = CL_RG;
	input_imageDesc.width = input_info.width / 2;
	input_imageDesc.height = input_info.height / 2;
	input_imageDesc.row_pitch = input_info.strides[1];

	image_in = convert_to_climage (context, input, input_imageDesc, input_info.offsets[1]);
	} else {
	input_imageDesc.format.image_channel_order = CL_R;
	input_imageDesc.width = input_info.width;
	input_imageDesc.height = input_info.height;
	input_imageDesc.row_pitch = input_info.strides[0];

	image_in = convert_to_climage (context, input, input_imageDesc, input_info.offsets[0]);
	}

	//set args;
	args.push_back (new CLMemArgument (image_in));
	args.push_back (new CLMemArgument (image_out));
	args.push_back (new CLArgumentT<uint32_t> (output_width));
	args.push_back (new CLArgumentT<uint32_t> (output_height));

	work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
	work_size.global[0] = XCAM_ALIGN_UP (output_width, XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE0);
	work_size.global[1] = XCAM_ALIGN_UP (output_height, XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE1);
	work_size.local[0] = XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE0;
	work_size.local[1] = XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE1;

	return ret;
	}

	CLImageScalerKernel::CLImageScalerKernel (
	const SmartPtr<CLContext> &context,
	CLImageScalerMemoryLayout mem_layout,
	SmartPtr<CLImageScaler> &scaler
	)
	: CLScalerKernel (context, mem_layout)
	, _scaler (scaler)
	{
	}

	SmartPtr<VideoBuffer>
	CLImageScalerKernel::get_input_buffer ()
	{
	return _scaler->get_input_buf ();
	}

	SmartPtr<VideoBuffer>
	CLImageScalerKernel::get_output_buffer ()
	{
	return _scaler->get_scaler_buf ();
	}

	CLImageScaler::CLImageScaler (const SmartPtr<CLContext> &context)
	: CLImageHandler (context, "CLImageScaler")
	, _h_scaler_factor (0.5)
	, _v_scaler_factor (0.5)
	{
	}

	void
	CLImageScaler::emit_stop ()
	{
	if (_scaler_buf_pool.ptr ())
	_scaler_buf_pool->stop ();
	}

	bool
	CLImageScaler::set_scaler_factor (const double h_factor, const double v_factor)
	{
	_h_scaler_factor = h_factor;
	_v_scaler_factor = v_factor;

	return true;
	}

	bool
	CLImageScaler::get_scaler_factor (double &h_factor, double &v_factor) const
	{
	h_factor = _h_scaler_factor;
	v_factor = _v_scaler_factor;

	return true;
	};

	XCamReturn
	CLImageScaler::prepare_output_buf (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output)
	{
	XCamReturn ret = XCAM_RETURN_NO_ERROR;
	output = input;

	ret = prepare_scaler_buf (input->get_video_info (), _scaler_buf);
	XCAM_FAIL_RETURN(
	WARNING,
	ret == XCAM_RETURN_NO_ERROR,
	ret,
	"CLImageScalerKernel prepare scaled video buf failed");

	_scaler_buf->set_timestamp (input->get_timestamp ());

	return ret;
	}

	XCamReturn
	CLImageScaler::execute_done (SmartPtr<VideoBuffer> &output)
	{
	XCAM_UNUSED (output);
	get_context ()->finish();
	XCAM_ASSERT (_scaler_buf.ptr ());

	//post buffer out
	return post_buffer (_scaler_buf);
	}

	XCamReturn
	CLImageScaler::prepare_scaler_buf (const VideoBufferInfo &video_info, SmartPtr<VideoBuffer> &output)
	{
	if (!_scaler_buf_pool.ptr ()) {
	VideoBufferInfo scaler_video_info;
	uint32_t new_width = XCAM_ALIGN_UP ((uint32_t)(video_info.width * _h_scaler_factor),
	2 * XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE0);
	uint32_t new_height = XCAM_ALIGN_UP ((uint32_t)(video_info.height * _v_scaler_factor),
	2 * XCAM_CL_IMAGE_SCALER_KERNEL_LOCAL_WORK_SIZE1);

	scaler_video_info.init (video_info.format, new_width, new_height);

	_scaler_buf_pool = new CLVideoBufferPool ();
	XCAM_ASSERT (_scaler_buf_pool.ptr ());
	_scaler_buf_pool->set_video_info (scaler_video_info);
	_scaler_buf_pool->reserve (6);
	}

	output = _scaler_buf_pool->get_buffer (_scaler_buf_pool);
	XCAM_ASSERT (output.ptr ());

	return XCAM_RETURN_NO_ERROR;
	}

	XCamReturn
	CLImageScaler::post_buffer (const SmartPtr<VideoBuffer> &buffer)
	{
	if (_scaler_callback.ptr ())
	return _scaler_callback->scaled_image_ready (buffer);

	return XCAM_RETURN_NO_ERROR;
	}

	static SmartPtr<CLImageKernel>
	create_scale_kernel (
	const SmartPtr<CLContext> &context, SmartPtr<CLImageScaler> &handler, CLImageScalerMemoryLayout layout)
	{
	SmartPtr<CLImageKernel> kernel;
	kernel = new CLImageScalerKernel (context, layout, handler);
	XCAM_ASSERT (kernel.ptr ());
	XCAM_FAIL_RETURN (
	ERROR, kernel->build_kernel (kernel_scale_info, NULL) == XCAM_RETURN_NO_ERROR, NULL,
	"build scaler kernel(%s) failed", kernel_scale_info.kernel_name);
	XCAM_ASSERT (kernel->is_valid ());
	return kernel;
	}

	SmartPtr<CLImageHandler>
	create_cl_image_scaler_handler (const SmartPtr<CLContext> &context, const uint32_t format)
	{
	SmartPtr<CLImageScaler> scaler_handler;
	SmartPtr<CLImageKernel> scaler_kernel;

	scaler_handler = new CLImageScaler (context);
	XCAM_ASSERT (scaler_handler.ptr ());

	if (V4L2_PIX_FMT_NV12 == format) {
	//Y
	scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_NV12_Y);
	XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_NV12_Y kernel failed");
	scaler_handler->add_kernel (scaler_kernel);
	//UV
	scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_NV12_UV);
	XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_NV12_UV kernel failed");
	scaler_handler->add_kernel (scaler_kernel);
	} else if (XCAM_PIX_FMT_RGBA64 == format) {
	scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_RGBA);
	XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_RGBA kernel failed");
	scaler_handler->add_kernel (scaler_kernel);
	} else {
	XCAM_LOG_ERROR ("create cl image scaler failed, unknown format:0x%08x", format);
	return NULL;
	}

	return scaler_handler;
	}

	};