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

 /*
  * cl_3a_stats_context.cpp - CL 3a stats context
  *
  *  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: Wind Yuan <feng.yuan@intel.com>
  * Author: Jia Meng <jia.meng@intel.com>
  */

 #include <xcam_std.h>
 #include "cl_3a_stats_context.h"

 namespace XCam {
 CL3AStatsCalculatorContext::CL3AStatsCalculatorContext (const SmartPtr<CLContext> &context)
     : _context (context)
     , _width_factor (1)
     , _height_factor (1)
     , _factor_shift (0)
     , _data_allocated (false)
 {
     _stats_pool = new X3aStatsPool ();
 }

 CL3AStatsCalculatorContext::~CL3AStatsCalculatorContext ()
 {
     clean_up_data ();
 }

 void
 CL3AStatsCalculatorContext::set_bit_depth (uint32_t bits)
 {
     XCAM_ASSERT (_stats_pool.ptr ());
     _stats_pool->set_bit_depth (bits);
 }

 bool
 CL3AStatsCalculatorContext::allocate_data (const VideoBufferInfo &buffer_info, uint32_t width_factor, uint32_t height_factor)
 {
     uint32_t multiply_factor = 0;

     _stats_pool->set_video_info (buffer_info);

     XCAM_FAIL_RETURN (
         WARNING,
         _stats_pool->reserve (32), // need reserve more if as attachement
         false,
         "reserve cl stats buffer failed");

     _stats_info = _stats_pool->get_stats_info ();
     XCAM_ASSERT ((width_factor & (width_factor - 1)) == 0 &&
                  (height_factor & (height_factor - 1)) == 0);
     _width_factor = width_factor;
     _height_factor = height_factor;
     multiply_factor = width_factor * height_factor;
     _factor_shift = 0;
     while ((multiply_factor >>= 1) != 0) {
         ++_factor_shift;
     }

     _stats_mem_size =
         _stats_info.aligned_width * _width_factor *
         _stats_info.aligned_height * _height_factor * sizeof (CL3AStatsStruct);

     for (uint32_t i = 0; i < XCAM_CL_3A_STATS_BUFFER_COUNT; ++i) {
         SmartPtr<CLBuffer> buf_new = new CLBuffer (
             _context, _stats_mem_size);

         XCAM_ASSERT (buf_new.ptr ());
         XCAM_FAIL_RETURN (
             WARNING,
             buf_new->is_valid (),
             false,
             "allocate cl stats buffer failed");
         _stats_cl_buffers.push (buf_new);
     }
     _data_allocated = true;

     return true;
 }

 void
 CL3AStatsCalculatorContext::pre_stop ()
 {
     if (_stats_pool.ptr ())
         _stats_pool->stop ();
     _stats_cl_buffers.pause_pop ();
     _stats_cl_buffers.wakeup ();
 }

 void
 CL3AStatsCalculatorContext::clean_up_data ()
 {
     _data_allocated = false;

     _stats_cl_buffers.pause_pop ();
     _stats_cl_buffers.wakeup ();
     _stats_cl_buffers.clear ();
 }

 SmartPtr<CLBuffer>
 CL3AStatsCalculatorContext::get_buffer ()
 {
     SmartPtr<CLBuffer> buf = _stats_cl_buffers.pop ();
     return buf;
 }

 bool
 CL3AStatsCalculatorContext::release_buffer (SmartPtr<CLBuffer> &buf)
 {
     XCAM_ASSERT (buf.ptr ());
     if (!buf.ptr ())
         return false;
     return _stats_cl_buffers.push (buf);
 }

 void debug_print_3a_stats (XCam3AStats *stats_ptr)
 {
     static int frames = 0;
     frames++;
     printf ("********frame(%d) debug 3a stats(%dbits) \n", frames, stats_ptr->info.bit_depth);
     for (int y = 30; y < 60; ++y) {
         printf ("---- y ");
         for (int x = 40; x < 80; ++x)
             printf ("%4d ", stats_ptr->stats[y * stats_ptr->info.aligned_width + x].avg_y);
         printf ("\n");
     }

 #if 0
 #define DUMP_STATS(ch, w, h, aligned_w, stats) do {                 \
          printf ("stats " #ch ":");                                  \
          for (uint32_t y = 0; y < h; ++y) {                          \
              for (uint32_t x = 0; x < w; ++x)                        \
                  printf ("%3d ", stats[y * aligned_w + x].avg_##ch); \
          }                                                           \
          printf ("\n");                           \
      } while (0)
     DUMP_STATS (r,  stats_ptr->info.width, stats_ptr->info.height,
                 stats_ptr->info.aligned_width, stats_ptr->stats);
     DUMP_STATS (gr, stats_ptr->info.width, stats_ptr->info.height,
                 stats_ptr->info.aligned_width, stats_ptr->stats);
     DUMP_STATS (gb, stats_ptr->info.width, stats_ptr->info.height,
                 stats_ptr->info.aligned_width, stats_ptr->stats);
     DUMP_STATS (b,  stats_ptr->info.width, stats_ptr->info.height,
                 stats_ptr->info.aligned_width, stats_ptr->stats);
     DUMP_STATS (y,  stats_ptr->info.width, stats_ptr->info.height,
                 stats_ptr->info.aligned_width, stats_ptr->stats);
 #endif
 }

 void debug_print_histogram (XCam3AStats *stats_ptr)
 {
 #define DUMP_HISTOGRAM(ch, bins, hist) do {      \
          printf ("histogram " #ch ":");           \
          for (uint32_t i = 0; i < bins; i++) {    \
              if (i % 16 == 0) printf ("\n");      \
              printf ("%4d ", hist[i].ch);         \
          }                                        \
          printf ("\n");                           \
      } while (0)

     DUMP_HISTOGRAM (r,  stats_ptr->info.histogram_bins, stats_ptr->hist_rgb);
     DUMP_HISTOGRAM (gr, stats_ptr->info.histogram_bins, stats_ptr->hist_rgb);
     DUMP_HISTOGRAM (gb, stats_ptr->info.histogram_bins, stats_ptr->hist_rgb);
     DUMP_HISTOGRAM (b,  stats_ptr->info.histogram_bins, stats_ptr->hist_rgb);

     printf ("histogram y:");
     for (uint32_t i = 0; i < stats_ptr->info.histogram_bins; i++) {
         if (i % 16 == 0) printf ("\n");
         printf ("%4d ", stats_ptr->hist_y[i]);
     }
     printf ("\n");
 }

 SmartPtr<X3aStats>
 CL3AStatsCalculatorContext::copy_stats_out (const SmartPtr<CLBuffer> &stats_cl_buf)
 {
     SmartPtr<VideoBuffer> buffer;
     SmartPtr<X3aStats> stats;
     SmartPtr<CLEvent>  event = new CLEvent;
     XCam3AStats *stats_ptr = NULL;
     XCamReturn ret = XCAM_RETURN_NO_ERROR;
     void *buf_ptr = NULL;
     const CL3AStatsStruct *cl_buf_ptr = NULL;

     XCAM_ASSERT (stats_cl_buf.ptr ());

     buffer = _stats_pool->get_buffer (_stats_pool);
     XCAM_FAIL_RETURN (WARNING, buffer.ptr (), NULL, "3a stats pool stopped.");

     stats = buffer.dynamic_cast_ptr<X3aStats> ();
     XCAM_ASSERT (stats.ptr ());
     stats_ptr = stats->get_stats ();

     ret = stats_cl_buf->enqueue_map (
               buf_ptr,
               0, _stats_mem_size,
               CL_MAP_READ,
               CLEvent::EmptyList,
               event);
     XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, NULL, "3a stats enqueue read buffer failed.");
     XCAM_ASSERT (event->get_event_id ());
     ret = event->wait ();
     XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, NULL, "3a stats buffer enqueue event wait failed");

     cl_buf_ptr = (const CL3AStatsStruct*)buf_ptr;

     XCAM_ASSERT (stats_ptr);
     memset (stats_ptr->stats, 0, sizeof (XCamGridStat) * _stats_info.aligned_width * _stats_info.aligned_height);
     //uint32_t avg_factor = _width_factor * _height_factor;
     //uint32_t avg_round_pading = avg_factor / 2;
     uint32_t cl_stats_width = _stats_info.aligned_width * _width_factor;

     for (uint32_t h = 0; h < _stats_info.height; ++h) {
         XCamGridStat *grid_stats_line = &stats_ptr->stats[_stats_info.aligned_width * h];
         uint32_t end_i_h = (h + 1) * _height_factor;
         for (uint32_t i_h = h * _height_factor; i_h < end_i_h; ++i_h) {
             const CL3AStatsStruct *cl_stats_line = &cl_buf_ptr[cl_stats_width * i_h];
             for (uint32_t w = 0; w < _stats_info.width; ++w) {
                 uint32_t end_i_w = (w + 1) * _width_factor;
                 for (uint32_t i_w = w * _width_factor; i_w < end_i_w; ++i_w) {
                     //grid_stats_line[w].avg_y += (cl_stats_line[i_w].avg_y + avg_round_pading) / avg_factor;
                     grid_stats_line[w].avg_y += (cl_stats_line[i_w].avg_y >> _factor_shift);
                     grid_stats_line[w].avg_r += (cl_stats_line[i_w].avg_r >> _factor_shift);
                     grid_stats_line[w].avg_gr += (cl_stats_line[i_w].avg_gr >> _factor_shift);
                     grid_stats_line[w].avg_gb += (cl_stats_line[i_w].avg_gb >> _factor_shift);
                     grid_stats_line[w].avg_b += (cl_stats_line[i_w].avg_b >> _factor_shift);
                     grid_stats_line[w].valid_wb_count += cl_stats_line[i_w].valid_wb_count;
                     grid_stats_line[w].f_value1 += cl_stats_line[i_w].f_value1;
                     grid_stats_line[w].f_value2 += cl_stats_line[i_w].f_value2;
                 }
             }
         }
     }

     event.release ();

     SmartPtr<CLEvent>  unmap_event = new CLEvent;
     ret = stats_cl_buf->enqueue_unmap (buf_ptr, CLEvent::EmptyList, unmap_event);
     XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, NULL, "3a stats buffer enqueue unmap failed");
     ret = unmap_event->wait ();
     XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, NULL, "3a stats buffer enqueue unmap event wait failed");
     unmap_event.release ();
     //debug_print_3a_stats (stats_ptr);
     fill_histogram (stats_ptr);
     //debug_print_histogram (stats_ptr);

     return stats;
 }

 bool
 CL3AStatsCalculatorContext::fill_histogram (XCam3AStats * stats)
 {
     const XCam3AStatsInfo &stats_info = stats->info;
     const XCamGridStat *grid_stat;
     XCamHistogram *hist_rgb = stats->hist_rgb;
     uint32_t *hist_y = stats->hist_y;

     memset (hist_rgb, 0, sizeof(XCamHistogram) * stats_info.histogram_bins);
     memset (hist_y, 0, sizeof(uint32_t) * stats_info.histogram_bins);
     for (uint32_t i = 0; i < stats_info.width; i++) {
         for (uint32_t j = 0; j < stats_info.height; j++) {
             grid_stat = &stats->stats[j * stats_info.aligned_width + i];
             hist_rgb[grid_stat->avg_r].r++;
             hist_rgb[grid_stat->avg_gr].gr++;
             hist_rgb[grid_stat->avg_gb].gb++;
             hist_rgb[grid_stat->avg_b].b++;
             hist_y[grid_stat->avg_y]++;
         }
     }
     return true;
 }

 }
	/*
	* cl_3a_stats_context.cpp - CL 3a stats context
	*
	* 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: Wind Yuan <feng.yuan@intel.com>
	* Author: Jia Meng <jia.meng@intel.com>
	*/

	#include <xcam_std.h>
	#include "cl_3a_stats_context.h"

	namespace XCam {
	CL3AStatsCalculatorContext::CL3AStatsCalculatorContext (const SmartPtr<CLContext> &context)
	: _context (context)
	, _width_factor (1)
	, _height_factor (1)
	, _factor_shift (0)
	, _data_allocated (false)
	{
	_stats_pool = new X3aStatsPool ();
	}

	CL3AStatsCalculatorContext::~CL3AStatsCalculatorContext ()
	{
	clean_up_data ();
	}

	void
	CL3AStatsCalculatorContext::set_bit_depth (uint32_t bits)
	{
	XCAM_ASSERT (_stats_pool.ptr ());
	_stats_pool->set_bit_depth (bits);
	}

	bool
	CL3AStatsCalculatorContext::allocate_data (const VideoBufferInfo &buffer_info, uint32_t width_factor, uint32_t height_factor)
	{
	uint32_t multiply_factor = 0;

	_stats_pool->set_video_info (buffer_info);

	XCAM_FAIL_RETURN (
	WARNING,
	_stats_pool->reserve (32), // need reserve more if as attachement
	false,
	"reserve cl stats buffer failed");

	_stats_info = _stats_pool->get_stats_info ();
	XCAM_ASSERT ((width_factor & (width_factor - 1)) == 0 &&
	(height_factor & (height_factor - 1)) == 0);
	_width_factor = width_factor;
	_height_factor = height_factor;
	multiply_factor = width_factor * height_factor;
	_factor_shift = 0;
	while ((multiply_factor >>= 1) != 0) {
	++_factor_shift;
	}

	_stats_mem_size =
	_stats_info.aligned_width * _width_factor *
	_stats_info.aligned_height * _height_factor * sizeof (CL3AStatsStruct);

	for (uint32_t i = 0; i < XCAM_CL_3A_STATS_BUFFER_COUNT; ++i) {
	SmartPtr<CLBuffer> buf_new = new CLBuffer (
	_context, _stats_mem_size);

	XCAM_ASSERT (buf_new.ptr ());
	XCAM_FAIL_RETURN (
	WARNING,
	buf_new->is_valid (),
	false,
	"allocate cl stats buffer failed");
	_stats_cl_buffers.push (buf_new);
	}
	_data_allocated = true;

	return true;
	}

	void
	CL3AStatsCalculatorContext::pre_stop ()
	{
	if (_stats_pool.ptr ())
	_stats_pool->stop ();
	_stats_cl_buffers.pause_pop ();
	_stats_cl_buffers.wakeup ();
	}

	void
	CL3AStatsCalculatorContext::clean_up_data ()
	{
	_data_allocated = false;

	_stats_cl_buffers.pause_pop ();
	_stats_cl_buffers.wakeup ();
	_stats_cl_buffers.clear ();
	}

	SmartPtr<CLBuffer>
	CL3AStatsCalculatorContext::get_buffer ()
	{
	SmartPtr<CLBuffer> buf = _stats_cl_buffers.pop ();
	return buf;
	}

	bool
	CL3AStatsCalculatorContext::release_buffer (SmartPtr<CLBuffer> &buf)
	{
	XCAM_ASSERT (buf.ptr ());
	if (!buf.ptr ())
	return false;
	return _stats_cl_buffers.push (buf);
	}

	void debug_print_3a_stats (XCam3AStats *stats_ptr)
	{
	static int frames = 0;
	frames++;
	printf ("********frame(%d) debug 3a stats(%dbits) \n", frames, stats_ptr->info.bit_depth);
	for (int y = 30; y < 60; ++y) {
	printf ("---- y ");
	for (int x = 40; x < 80; ++x)
	printf ("%4d ", stats_ptr->stats[y * stats_ptr->info.aligned_width + x].avg_y);
	printf ("\n");
	}

	#if 0
	#define DUMP_STATS(ch, w, h, aligned_w, stats) do { \
	printf ("stats " #ch ":"); \
	for (uint32_t y = 0; y < h; ++y) { \
	for (uint32_t x = 0; x < w; ++x) \
	printf ("%3d ", stats[y * aligned_w + x].avg_##ch); \
	} \
	printf ("\n"); \
	} while (0)
	DUMP_STATS (r, stats_ptr->info.width, stats_ptr->info.height,
	stats_ptr->info.aligned_width, stats_ptr->stats);
	DUMP_STATS (gr, stats_ptr->info.width, stats_ptr->info.height,
	stats_ptr->info.aligned_width, stats_ptr->stats);
	DUMP_STATS (gb, stats_ptr->info.width, stats_ptr->info.height,
	stats_ptr->info.aligned_width, stats_ptr->stats);
	DUMP_STATS (b, stats_ptr->info.width, stats_ptr->info.height,
	stats_ptr->info.aligned_width, stats_ptr->stats);
	DUMP_STATS (y, stats_ptr->info.width, stats_ptr->info.height,
	stats_ptr->info.aligned_width, stats_ptr->stats);
	#endif
	}

	void debug_print_histogram (XCam3AStats *stats_ptr)
	{
	#define DUMP_HISTOGRAM(ch, bins, hist) do { \
	printf ("histogram " #ch ":"); \
	for (uint32_t i = 0; i < bins; i++) { \
	if (i % 16 == 0) printf ("\n"); \
	printf ("%4d ", hist[i].ch); \
	} \
	printf ("\n"); \
	} while (0)

	DUMP_HISTOGRAM (r, stats_ptr->info.histogram_bins, stats_ptr->hist_rgb);
	DUMP_HISTOGRAM (gr, stats_ptr->info.histogram_bins, stats_ptr->hist_rgb);
	DUMP_HISTOGRAM (gb, stats_ptr->info.histogram_bins, stats_ptr->hist_rgb);
	DUMP_HISTOGRAM (b, stats_ptr->info.histogram_bins, stats_ptr->hist_rgb);

	printf ("histogram y:");
	for (uint32_t i = 0; i < stats_ptr->info.histogram_bins; i++) {
	if (i % 16 == 0) printf ("\n");
	printf ("%4d ", stats_ptr->hist_y[i]);
	}
	printf ("\n");
	}

	SmartPtr<X3aStats>
	CL3AStatsCalculatorContext::copy_stats_out (const SmartPtr<CLBuffer> &stats_cl_buf)
	{
	SmartPtr<VideoBuffer> buffer;
	SmartPtr<X3aStats> stats;
	SmartPtr<CLEvent> event = new CLEvent;
	XCam3AStats *stats_ptr = NULL;
	XCamReturn ret = XCAM_RETURN_NO_ERROR;
	void *buf_ptr = NULL;
	const CL3AStatsStruct *cl_buf_ptr = NULL;

	XCAM_ASSERT (stats_cl_buf.ptr ());

	buffer = _stats_pool->get_buffer (_stats_pool);
	XCAM_FAIL_RETURN (WARNING, buffer.ptr (), NULL, "3a stats pool stopped.");

	stats = buffer.dynamic_cast_ptr<X3aStats> ();
	XCAM_ASSERT (stats.ptr ());
	stats_ptr = stats->get_stats ();

	ret = stats_cl_buf->enqueue_map (
	buf_ptr,
	0, _stats_mem_size,
	CL_MAP_READ,
	CLEvent::EmptyList,
	event);
	XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, NULL, "3a stats enqueue read buffer failed.");
	XCAM_ASSERT (event->get_event_id ());
	ret = event->wait ();
	XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, NULL, "3a stats buffer enqueue event wait failed");

	cl_buf_ptr = (const CL3AStatsStruct*)buf_ptr;

	XCAM_ASSERT (stats_ptr);
	memset (stats_ptr->stats, 0, sizeof (XCamGridStat) * _stats_info.aligned_width * _stats_info.aligned_height);
	//uint32_t avg_factor = _width_factor * _height_factor;
	//uint32_t avg_round_pading = avg_factor / 2;
	uint32_t cl_stats_width = _stats_info.aligned_width * _width_factor;

	for (uint32_t h = 0; h < _stats_info.height; ++h) {
	XCamGridStat grid_stats_line = &stats_ptr->stats[_stats_info.aligned_width h];
	uint32_t end_i_h = (h + 1) * _height_factor;
	for (uint32_t i_h = h * _height_factor; i_h < end_i_h; ++i_h) {
	const CL3AStatsStruct cl_stats_line = &cl_buf_ptr[cl_stats_width i_h];
	for (uint32_t w = 0; w < _stats_info.width; ++w) {
	uint32_t end_i_w = (w + 1) * _width_factor;
	for (uint32_t i_w = w * _width_factor; i_w < end_i_w; ++i_w) {
	//grid_stats_line[w].avg_y += (cl_stats_line[i_w].avg_y + avg_round_pading) / avg_factor;
	grid_stats_line[w].avg_y += (cl_stats_line[i_w].avg_y >> _factor_shift);
	grid_stats_line[w].avg_r += (cl_stats_line[i_w].avg_r >> _factor_shift);
	grid_stats_line[w].avg_gr += (cl_stats_line[i_w].avg_gr >> _factor_shift);
	grid_stats_line[w].avg_gb += (cl_stats_line[i_w].avg_gb >> _factor_shift);
	grid_stats_line[w].avg_b += (cl_stats_line[i_w].avg_b >> _factor_shift);
	grid_stats_line[w].valid_wb_count += cl_stats_line[i_w].valid_wb_count;
	grid_stats_line[w].f_value1 += cl_stats_line[i_w].f_value1;
	grid_stats_line[w].f_value2 += cl_stats_line[i_w].f_value2;
	}
	}
	}
	}

	event.release ();

	SmartPtr<CLEvent> unmap_event = new CLEvent;
	ret = stats_cl_buf->enqueue_unmap (buf_ptr, CLEvent::EmptyList, unmap_event);
	XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, NULL, "3a stats buffer enqueue unmap failed");
	ret = unmap_event->wait ();
	XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, NULL, "3a stats buffer enqueue unmap event wait failed");
	unmap_event.release ();
	//debug_print_3a_stats (stats_ptr);
	fill_histogram (stats_ptr);
	//debug_print_histogram (stats_ptr);

	return stats;
	}

	bool
	CL3AStatsCalculatorContext::fill_histogram (XCam3AStats * stats)
	{
	const XCam3AStatsInfo &stats_info = stats->info;
	const XCamGridStat *grid_stat;
	XCamHistogram *hist_rgb = stats->hist_rgb;
	uint32_t *hist_y = stats->hist_y;

	memset (hist_rgb, 0, sizeof(XCamHistogram) * stats_info.histogram_bins);
	memset (hist_y, 0, sizeof(uint32_t) * stats_info.histogram_bins);
	for (uint32_t i = 0; i < stats_info.width; i++) {
	for (uint32_t j = 0; j < stats_info.height; j++) {
	grid_stat = &stats->stats[j * stats_info.aligned_width + i];
	hist_rgb[grid_stat->avg_r].r++;
	hist_rgb[grid_stat->avg_gr].gr++;
	hist_rgb[grid_stat->avg_gb].gb++;
	hist_rgb[grid_stat->avg_b].b++;
	hist_y[grid_stat->avg_y]++;
	}
	}
	return true;
	}

	}