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