state_capture_filter_gamma Struct Reference

Collaboration diagram for state_capture_filter_gamma:

Classes
struct	data

Public Member Functions
	state_capture_filter_gamma (double gamma, int out_depth)
void	apply_gamma (int in_depth, int out_depth, size_t in_len, void const *__restrict in, void *__restrict out)

Public Attributes
int	out_depth
	0, 8 or 16 (0 menas keep)
void *	vo_pp_out_buffer {}
	buffer to write to if we use vo_pp wrapper (otherwise unused)

Private Member Functions
template<typename inT , typename outT >
void	apply_lut (size_t in_len, const vector< outT > &lut, void const *in, void *out)

Static Private Member Functions
template<typename inT , typename outT >
static void *	compute (void *arg)

Private Attributes
vector< uint16_t >	lut16
vector< uint8_t >	lut16_8
vector< uint8_t >	lut8
vector< uint16_t >	lut8_16

Detailed Description

Definition at line 66 of file gamma.cpp.

Constructor & Destructor Documentation

state_capture_filter_gamma()

state_capture_filter_gamma::state_capture_filter_gamma ( double gamma, int out_depth )

inlineexplicit

Definition at line 71 of file gamma.cpp.

                                                                         : out_depth(out_depth) {
                for (int i = 0; i <= numeric_limits<uint8_t>::max(); ++i) { // 8->8
                        lut8.push_back(pow(static_cast<double>(i)
                                        / numeric_limits<uint8_t>::max(), gamma)
                                * numeric_limits<uint8_t>::max());
                }
                for (int i = 0; i <= numeric_limits<uint16_t>::max(); ++i) { // 8->16
                        lut16.push_back(pow(static_cast<double>(i)
                                        / numeric_limits<uint16_t>::max(), gamma)
                                * numeric_limits<uint16_t>::max());
                }
                for (int i = 0; i <= numeric_limits<uint8_t>::max(); ++i) { // 8->16
                        lut8_16.push_back(pow(static_cast<double>(i)
                                        / numeric_limits<uint8_t>::max(), gamma)
                                * numeric_limits<uint16_t>::max());
                }
                for (int i = 0; i <= numeric_limits<uint16_t>::max(); ++i) { // 16->8
                        lut16_8.push_back(pow(static_cast<double>(i)
                                        / numeric_limits<uint16_t>::max(), gamma)
                                * numeric_limits<uint8_t>::max());
                }
        }

References lut16, lut16_8, lut8, and lut8_16.

Member Function Documentation

apply_gamma()

void state_capture_filter_gamma::apply_gamma ( int in_depth, int out_depth, size_t in_len, void const *__restrict in, void *__restrict out )

inline

Definition at line 94 of file gamma.cpp.

                                                                                                                        {
                if (in_depth == CHAR_BIT && out_depth == CHAR_BIT) {
                        apply_lut<uint8_t, uint8_t>(in_len, lut8, in, out);
                } else if (in_depth == 2 * CHAR_BIT && out_depth == 2 * CHAR_BIT) {
                        apply_lut<uint16_t, uint16_t>(in_len, lut16, in, out);
                } else if (in_depth == CHAR_BIT && out_depth == 2 * CHAR_BIT) {
                        apply_lut<uint8_t, uint16_t>(in_len, lut8_16, in, out);
                } else if (in_depth == 2 * CHAR_BIT && out_depth == CHAR_BIT) {
                        apply_lut<uint16_t, uint8_t>(in_len, lut16_8, in, out);
                } else {
                        throw exception();
                }
        }

References apply_lut(), lut16, lut16_8, lut8, lut8_16, and out_depth.

Here is the call graph for this function:

apply_lut()

template<typename inT , typename outT >

void state_capture_filter_gamma::apply_lut ( size_t in_len, const vector< outT > & lut, void const * in, void * out )

inlineprivate

Definition at line 126 of file gamma.cpp.

        {
                auto *in_data = static_cast<const inT*>(in);
                auto *out_data = static_cast<outT*>(out);
                unsigned int cpus = thread::hardware_concurrency();
                in_len /= sizeof(inT);
                vector<data<inT, outT>> d;
                vector<task_result_handle_t> handles(cpus);
                for (unsigned int i = 0; i < cpus; i++) {
                        d.push_back({in_len / cpus, lut, in_data + i * (in_len / cpus), out_data + i * (in_len / cpus)});
                }
                for (unsigned int i = 0; i < cpus; i++) {
                        handles[i] = task_run_async(state_capture_filter_gamma::compute<inT, outT>, static_cast<void *>(&(d[i])));
                }
                for (unsigned int i = 0; i < cpus; i++) {
                        wait_task(handles[i]);
                }
        }

References compute(), task_run_async(), and wait_task().

Referenced by apply_gamma().

Here is the call graph for this function:

compute()

template<typename inT , typename outT >

static void * state_capture_filter_gamma::compute ( void * arg )

inlinestaticprivate

Definition at line 118 of file gamma.cpp.

                                        {
                auto *d = static_cast<struct data<inT, outT> *>(arg);
                for (size_t i = 0; i < d->len; ++i) {
                        d->out[i] = d->lut[d->in[i]];
                }
                return nullptr;
        }

Referenced by apply_lut().

Member Data Documentation

lut16

vector<uint16_t> state_capture_filter_gamma::lut16

private

Definition at line 146 of file gamma.cpp.

Referenced by state_capture_filter_gamma(), and apply_gamma().

lut16_8

vector<uint8_t> state_capture_filter_gamma::lut16_8

private

Definition at line 147 of file gamma.cpp.

Referenced by state_capture_filter_gamma(), and apply_gamma().

lut8

vector<uint8_t> state_capture_filter_gamma::lut8

private

Definition at line 145 of file gamma.cpp.

Referenced by state_capture_filter_gamma(), and apply_gamma().

lut8_16

vector<uint16_t> state_capture_filter_gamma::lut8_16

private

Definition at line 148 of file gamma.cpp.

Referenced by state_capture_filter_gamma(), and apply_gamma().

out_depth

int state_capture_filter_gamma::out_depth

0, 8 or 16 (0 menas keep)

Definition at line 68 of file gamma.cpp.

Referenced by apply_gamma().

vo_pp_out_buffer

void* state_capture_filter_gamma::vo_pp_out_buffer {}

buffer to write to if we use vo_pp wrapper (otherwise unused)

Definition at line 69 of file gamma.cpp.

{}; 

---

The documentation for this struct was generated from the following file:

• src/capture_filter/gamma.cpp