gamma.cpp File Reference

#include <iostream>
#include <stdexcept>
#include <thread>
#include <vector>
#include "capture_filter.h"
#include "debug.h"
#include "lib_common.h"
#include "utils/color_out.h"
#include "utils/worker.h"
#include "video.h"
#include "video_codec.h"
#include "vo_postprocess/capture_filter_wrapper.h"

Include dependency graph for gamma.cpp:

Go to the source code of this file.

Classes
struct	state_capture_filter_gamma
struct	state_capture_filter_gamma::data< inT, outT >

Functions
static void	done (void *state)
static auto	filter (void *state, struct video_frame *in) -> video_frame *
static auto	init (struct module *parent, const char *cfg, void **state)
	REGISTER_MODULE (gamma, &capture_filter_gamma, LIBRARY_CLASS_CAPTURE_FILTER, CAPTURE_FILTER_ABI_VERSION)
static void	vo_pp_set_out_buffer (void *state, char *buffer)

Variables
static const struct capture_filter_info	capture_filter_gamma
constexpr const char *	MOD_NAME = "[gamma cap. f.] "

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file gamma.cpp.

Function Documentation

done()

static void done ( void * state )

static

Definition at line 189 of file gamma.cpp.

{
        delete static_cast<state_capture_filter_gamma *>(state);
}

References state.

filter()

static auto filter ( void * state, struct video_frame * in ) -> video_frame *

static

Definition at line 194 of file gamma.cpp.

{
        if (in->color_spec != RGB && in->color_spec != RG48) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Unable to apply lut on: " << get_codec_name(in->color_spec) << "\n";
                VIDEO_FRAME_DISPOSE(in);
                return nullptr;
        }
 
        auto *s = static_cast<state_capture_filter_gamma *>(state);
        struct video_desc out_desc = video_desc_from_frame(in);
        if (s->out_depth != 0) {
                out_desc.color_spec = s->out_depth == 8 ? RGB : RG48;
        }
        struct video_frame *out = vf_alloc_desc(out_desc);
        if (s->vo_pp_out_buffer != nullptr) {
                out->tiles[0].data = (char *) s->vo_pp_out_buffer;
        } else {
                out->tiles[0].data = (char *) malloc(out->tiles[0].data_len);
                out->callbacks.data_deleter = vf_data_deleter;
        }
        out->callbacks.dispose = vf_free;
 
        try {
                s->apply_gamma(get_bits_per_component(in->color_spec), get_bits_per_component(out_desc.color_spec), in->tiles[0].data_len, in->tiles[0].data, out->tiles[0].data);
        } catch(...) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Only 8-bit and 16-bit codecs are currently supported!\n";
                vf_free(out);
                out = nullptr;
        }
 
        VIDEO_FRAME_DISPOSE(in);
 
        return out;
}

References video_frame::callbacks, video_desc::color_spec, tile::data, video_frame_callbacks::data_deleter, tile::data_len, video_frame_callbacks::dispose, get_bits_per_component(), get_codec_name(), LOG, LOG_LEVEL_ERROR, MOD_NAME, RG48, RGB, state, video_frame::tiles, vf_alloc_desc(), vf_data_deleter(), vf_free(), video_desc_from_frame(), and VIDEO_FRAME_DISPOSE.

Here is the call graph for this function:

init()

static auto init ( struct module * parent, const char * cfg, void ** state )

static

Definition at line 151 of file gamma.cpp.

{
        UNUSED(parent);
 
        if (strlen(cfg) == 0 || strcmp(cfg, "help") == 0) {
                col() << "Performs gamma transformation.\n\n"
                       "usage:\n";
                col() << "\t" << SBOLD("-F gamma:value[:8|:16]") << "\n";
                col() << "where:\n";
                col() << SBOLD("8|16")
                     << " - force output to 8 (16) bits regardless the input\n";
                return 1;
        }
        char *endptr = nullptr;
        errno = 0;
        double gamma = strtod(cfg, &endptr);
 
        if (gamma <= 0.0 || errno != 0 || (*endptr != '\0' && *endptr != ':')) {
                LOG(LOG_LEVEL_WARNING) << MOD_NAME << "Using gamma value " << gamma << "\n";
        }
 
        long int bits = 0;
        if (*endptr != '\0') {
                endptr += 1;
                errno = 0;
                bits = strtol(endptr, &endptr, 0);
                if ((bits != 8 && bits != 16) || *endptr != '\0') {
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Wrong number of bits (only 8 or 16)!\n";
                        return -1;
                }
        }
 
        auto *s = new state_capture_filter_gamma(gamma, bits);
 
        *state = s;
        return 0;
}

References LOG, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, MOD_NAME, parent, SBOLD, state, and UNUSED.

REGISTER_MODULE()

REGISTER_MODULE	(	gamma	,
		&	capture_filter_gamma,
		LIBRARY_CLASS_CAPTURE_FILTER	,
		CAPTURE_FILTER_ABI_VERSION	)

vo_pp_set_out_buffer()

static void vo_pp_set_out_buffer ( void * state, char * buffer )

static

Definition at line 229 of file gamma.cpp.

{
        auto *s = (state_capture_filter_gamma *) state;
        s->vo_pp_out_buffer = buffer;
}

References state.

Variable Documentation

capture_filter_gamma

const struct capture_filter_info capture_filter_gamma

static

Initial value:

= {
        .init = init,
        .done = done,
        .filter = filter,
}

Definition at line 235 of file gamma.cpp.

                                                               {
        .init = init,
        .done = done,
        .filter = filter,
};

MOD_NAME

const char* MOD_NAME = "[gamma cap. f.] "

constexpr

Definition at line 58 of file gamma.cpp.

Referenced by filter(), and init().