cineform.cpp File Reference

#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "module.h"
#include "tv.h"
#include "video_compress.h"
#include <CFHDTypes.h>
#include <CFHDEncoder.h>
#include "video.h"
#include "video_codec.h"
#include <memory>
#include <map>
#include <mutex>
#include <thread>
#include <vector>
#include <queue>
#include <condition_variable>
#include "utils/misc.h"

Include dependency graph for cineform.cpp:

Go to the source code of this file.

Classes
struct	state_video_compress_cineform

Macros
#define	DEFAULT_POOL_SIZE   16
#define	DEFAULT_THREAD_COUNT   8
#define	MOD_NAME   "[cineform] "

Functions
static void	cineform_compress_done (struct module *mod)
static struct module *	cineform_compress_init (struct module *parent, const char *opts)
static std::shared_ptr< video_frame >	cineform_compress_pop (struct module *state)
static void	cineform_compress_push (struct module *state, std::shared_ptr< video_frame > tx)
static bool	configure_with (struct state_video_compress_cineform *s, struct video_desc desc)
static compress_module_info	get_cineform_module_info ()
static video_frame *	get_copy (struct state_video_compress_cineform *s, video_frame *frame)
static int	parse_fmt (struct state_video_compress_cineform *s, char *fmt)
	REGISTER_MODULE (cineform, &cineform_info, LIBRARY_CLASS_VIDEO_COMPRESS, VIDEO_COMPRESS_ABI_VERSION)
static void	usage ()

Variables
const struct video_compress_info	cineform_info
struct {
CFHD_EncodedFormat   cfhd_encoded_format
CFHD_PixelFormat   cfhd_pixel_format
codec_t   ug_codec
}	codecs []
struct {
const char *   description
const char *   key
const char *   label
const char *   opt_str
const char *   placeholder
}	usage_opts []

Detailed Description

Author

Martin Piatka piatk.nosp@m.a@ce.nosp@m.snet..nosp@m.cz

Definition in file cineform.cpp.

Macro Definition Documentation

DEFAULT_POOL_SIZE

#define DEFAULT_POOL_SIZE   16

Definition at line 74 of file cineform.cpp.

Referenced by cineform_compress_init().

DEFAULT_THREAD_COUNT

#define DEFAULT_THREAD_COUNT   8

Definition at line 75 of file cineform.cpp.

Referenced by cineform_compress_init().

MOD_NAME

#define MOD_NAME   "[cineform] "

Definition at line 76 of file cineform.cpp.

Referenced by configure_with().

Function Documentation

cineform_compress_done()

static void cineform_compress_done ( struct module * mod )

static

Definition at line 110 of file cineform.cpp.

                                                      {
        struct state_video_compress_cineform *s = (struct state_video_compress_cineform *) mod->priv_data;
 
        s->mutex.lock();
 
        CFHD_StopEncoderPool(s->encoderPoolRef);
        CFHD_ReleaseEncoderPool(s->encoderPoolRef);
        CFHD_MetadataClose(s->metadataRef);
 
        s->mutex.unlock();
        delete s;
}

References state_video_compress_cineform::encoderPoolRef, state_video_compress_cineform::metadataRef, state_video_compress_cineform::mutex, and module::priv_data.

Referenced by cineform_compress_init().

cineform_compress_init()

static struct module * cineform_compress_init ( struct module * parent, const char * opts )

static

Definition at line 178 of file cineform.cpp.

{
        struct state_video_compress_cineform *s;
 
        s = new state_video_compress_cineform();
 
        memset(&s->saved_desc, 0, sizeof(s->saved_desc));
        s->requested_quality = CFHD_ENCODING_QUALITY_DEFAULT;
        s->requested_threads = DEFAULT_THREAD_COUNT;
        s->requested_pool_size = DEFAULT_POOL_SIZE;
 
        char *fmt = strdup(opts);
        int ret = parse_fmt(s, fmt);
        free(fmt);
        if(ret != 0) {
                delete s;
                return ret > 0 ? static_cast<module*>(INIT_NOERR) : nullptr;
        }
 
        log_msg(LOG_LEVEL_NOTICE, "[cineform] : Threads: %d.\n", s->requested_threads);
        CFHD_Error status = CFHD_ERROR_OKAY;
        status = CFHD_CreateEncoderPool(&s->encoderPoolRef,
                        s->requested_threads,
                        s->requested_pool_size,
                        nullptr);
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to create encoder pool\n");
                delete s;
                return nullptr;
        }
        status = CFHD_MetadataOpen(&s->metadataRef);
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to create metadataRef\n");
                CFHD_ReleaseEncoderPool(s->encoderPoolRef);
                delete s;
                return nullptr;
        }
 
        s->frame_seq_in = 0;
        s->frame_seq_out = 0;
        s->started = false;
        s->stop = false;
 
        module_init_default(&s->module_data);
        s->module_data.cls = MODULE_CLASS_DATA;
        s->module_data.priv_data = s;
        s->module_data.deleter = cineform_compress_done;
        module_register(&s->module_data, parent);
 
        return &s->module_data;
}

References cineform_compress_done(), module::cls, DEFAULT_POOL_SIZE, DEFAULT_THREAD_COUNT, module::deleter, state_video_compress_cineform::encoderPoolRef, fmt, state_video_compress_cineform::frame_seq_in, state_video_compress_cineform::frame_seq_out, INIT_NOERR, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, log_msg(), state_video_compress_cineform::metadataRef, MODULE_CLASS_DATA, state_video_compress_cineform::module_data, module_init_default(), module_register(), parent, parse_fmt(), module::priv_data, state_video_compress_cineform::requested_pool_size, state_video_compress_cineform::requested_quality, state_video_compress_cineform::requested_threads, state_video_compress_cineform::saved_desc, state_video_compress_cineform::started, and state_video_compress_cineform::stop.

Here is the call graph for this function:

cineform_compress_pop()

static std::shared_ptr< video_frame > cineform_compress_pop ( struct module * state )

static

Definition at line 438 of file cineform.cpp.

{
        struct state_video_compress_cineform *s = (struct state_video_compress_cineform *) state->priv_data;
 
        std::unique_lock<std::mutex> lock(s->mutex);
 
        if(s->stop){
                CFHD_SampleBufferRef buf;
                uint32_t frame_num;
                while(CFHD_TestForSample(s->encoderPoolRef, &frame_num, &buf) == CFHD_ERROR_OKAY){
                        CFHD_ReleaseSampleBuffer(s->encoderPoolRef, buf);
                }
                return {};
        }
 
        const auto& started = s->started;
        while(!started)
                s->cv.wait(lock, [&started](){return started;});
 
        lock.unlock();
 
        CFHD_Error status = CFHD_ERROR_OKAY;
        uint32_t frame_num;
        CFHD_SampleBufferRef buf;
        status = CFHD_WaitForSample(s->encoderPoolRef,
                        &frame_num,
                        &buf);
#if MEASUREMENT
        struct timespec t_0, t_1, t_res;
        clock_gettime(CLOCK_MONOTONIC_RAW, &t_1);
        t_0 = s->times_map[frame_num];
 
        timespec_diff(&t_0, &t_1, &t_res);
 
        printf("[cineform] Encoding %u frame took %f miliseconds.\n", frame_num, t_res.tv_nsec / 1000000.0);
#endif
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to wait for sample %d\n", status);
                return {};
        }
 
        static auto dispose = [](struct video_frame *frame) {
                std::tuple<CFHD_EncoderPoolRef, CFHD_SampleBufferRef> *t = 
                        static_cast<std::tuple<CFHD_EncoderPoolRef, CFHD_SampleBufferRef> *>(frame->callbacks.dispose_udata);
                if(t)
                        CFHD_ReleaseSampleBuffer(std::get<0>(*t), std::get<1>(*t));
                vf_free(frame);
        };
 
        std::shared_ptr<video_frame> out = std::shared_ptr<video_frame>(vf_alloc_desc(s->compressed_desc), dispose);
        size_t encoded_len;
        status = CFHD_GetEncodedSample(buf,
                        (void **) &out->tiles[0].data,
                        &encoded_len);
        out->tiles[0].data_len = encoded_len;
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to get sample data\n");
                return {};
        }
        out->callbacks.dispose_udata = new std::tuple<CFHD_EncoderPoolRef, CFHD_SampleBufferRef>(s->encoderPoolRef, buf);
        out->seq = frame_num;
 
        lock.lock();
        if(s->frame_queue.empty()){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to pop\n");
        } else {
                auto &src = s->frame_queue.front();
                vf_copy_metadata(out.get(), src.get());
        }
        s->frame_queue.pop();
 
        out->compress_end = get_time_in_ns();
 
        return out;
}

References lock::lock(), video_frame::callbacks, state_video_compress_cineform::compressed_desc, state_video_compress_cineform::cv, video_frame_callbacks::dispose_udata, state_video_compress_cineform::encoderPoolRef, frame, state_video_compress_cineform::frame_queue, get_time_in_ns(), LOG_LEVEL_ERROR, log_msg(), state_video_compress_cineform::mutex, state_video_compress_cineform::started, state, state_video_compress_cineform::stop, vf_alloc_desc(), vf_copy_metadata(), and vf_free().

Here is the call graph for this function:

cineform_compress_push()

static void cineform_compress_push ( struct module * state, std::shared_ptr< video_frame > tx )

static

Definition at line 352 of file cineform.cpp.

{
        struct state_video_compress_cineform *s = (struct state_video_compress_cineform *) state->priv_data;
 
        CFHD_Error status = CFHD_ERROR_OKAY;
        std::unique_lock<std::mutex> lock(s->mutex);
 
        if(s->stop)
                return;
 
        if(!tx){
                if (!s->started) {
                        video_desc desc{1920, 1080, UYVY, 25.0, PROGRESSIVE, 1};
                        configure_with(s, desc);
                }
                std::unique_ptr<video_frame, decltype(&vf_free)> dummy(vf_alloc_desc_data(s->precompress_desc), vf_free);
                video_frame *dummy_ptr = dummy.get();
                vf_clear(dummy_ptr);
 
                s->stop = true;
                s->frame_queue.push(std::move(dummy));
                lock.unlock();
 
                status = CFHD_EncodeAsyncSample(s->encoderPoolRef,
                                s->frame_seq_in++,
                                dummy_ptr->tiles[0].data,
                                vc_get_linesize(s->precompress_desc.width, s->precompress_desc.color_spec),
                                nullptr);
                if(status != CFHD_ERROR_OKAY){
                        log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to push null %i pool\n", status);
                }
                return;
        }
 
        assert(tx->tile_count == 1); // TODO
 
        if(!video_desc_eq_excl_param(video_desc_from_frame(tx.get()),
                                s->saved_desc, PARAM_TILE_COUNT))
        {
                //cleanup(s);
                int ret = configure_with(s, video_desc_from_frame(tx.get()));
                if(!ret) {
                        return;
                }
        }
 
        std::unique_ptr<video_frame, decltype(&vf_free)> frame_copy(get_copy(s, tx.get()), vf_free);
        video_frame *frame_ptr = frame_copy.get();
 
        s->frame_queue.push(std::move(frame_copy));
 
#ifdef MEASUREMENT
        struct timespec t_0;
        clock_gettime(CLOCK_MONOTONIC_RAW, &t_0);
 
        s->times_map[s->frame_seq_in] = t_0;
#endif
        lock.unlock();
 
        status = CFHD_EncodeAsyncSample(s->encoderPoolRef,
                        s->frame_seq_in++,
                        frame_ptr->tiles[0].data,
                        vc_get_linesize(s->precompress_desc.width, s->precompress_desc.color_spec),
                        nullptr);
 
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to push sample to encode pool\n");
                return;
        }
}

References video_desc::color_spec, configure_with(), tile::data, desc, state_video_compress_cineform::encoderPoolRef, state_video_compress_cineform::frame_queue, state_video_compress_cineform::frame_seq_in, get_copy(), LOG_LEVEL_ERROR, log_msg(), state_video_compress_cineform::mutex, PARAM_TILE_COUNT, state_video_compress_cineform::precompress_desc, PROGRESSIVE, state_video_compress_cineform::saved_desc, state_video_compress_cineform::started, state, state_video_compress_cineform::stop, video_frame::tiles, UYVY, vc_get_linesize(), vf_alloc_desc_data(), vf_clear(), vf_free(), video_desc_eq_excl_param(), video_desc_from_frame(), and video_desc::width.

Here is the call graph for this function:

configure_with()

static bool configure_with ( struct state_video_compress_cineform * s, struct video_desc desc )

static

Definition at line 243 of file cineform.cpp.

{
        CFHD_Error status = CFHD_ERROR_OKAY;
 
        if(s->started){
                status = CFHD_StopEncoderPool(s->encoderPoolRef);
                if(status != CFHD_ERROR_OKAY){
                        log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to stop encoder pool\n");
                        return false;
                }
        }
 
        codec_t to_convs[VIDEO_CODEC_COUNT] = { VIDEO_CODEC_NONE };
        int i = 0;
        for(const auto &codec : codecs) {
                to_convs[i++] = codec.ug_codec;
        }
        s->precompress_desc = desc;
        s->dec = get_best_decoder_from(desc.color_spec, to_convs, &s->precompress_desc.color_spec);
        LOG(LOG_LEVEL_VERBOSE) << MOD_NAME << "Using " << get_codec_name(s->precompress_desc.color_spec) << " as intermediate.\n";
 
        CFHD_PixelFormat pix_fmt = CFHD_PIXEL_FORMAT_UNKNOWN;
        CFHD_EncodedFormat enc_fmt = CFHD_ENCODED_FORMAT_UNKNOWN;
        for(const auto &codec : codecs){
                if (codec.ug_codec == s->precompress_desc.color_spec){
                        pix_fmt = codec.cfhd_pixel_format;
                        enc_fmt = codec.cfhd_encoded_format;
                        break;
                }
        }
 
        if(pix_fmt == CFHD_PIXEL_FORMAT_UNKNOWN){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to find suitable pixel format\n");
                return false;
        }
 
        status = CFHD_PrepareEncoderPool(s->encoderPoolRef,
                        desc.width,
                        desc.height,
                        pix_fmt,
                        enc_fmt,
                        CFHD_ENCODING_FLAGS_NONE,
                        s->requested_quality);
 
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to prepare to encode\n");
                return false;
        }
 
        s->compressed_desc = desc;
        s->compressed_desc.color_spec = CFHD;
        s->compressed_desc.tile_count = 1;
 
        s->saved_desc = desc;
 
        status = CFHD_AttachEncoderPoolMetadata(s->encoderPoolRef, s->metadataRef);
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to attach metadata to encoder pool\n");
        }
 
        uint32_t fcc_tag = to_fourcc('U', 'G', 'P', 'F');
        uint32_t val = desc.color_spec;
        status = CFHD_MetadataAdd(s->metadataRef,
                                  fcc_tag,
                                  METADATATYPE_UINT32,
                                  sizeof(uint32_t),
                                  &val,
                                  false);
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to add metadata %u\n", status);
        }
 
        status = CFHD_AttachEncoderPoolMetadata(s->encoderPoolRef, s->metadataRef);
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to attach metadata to encoder pool\n");
        }
 
        log_msg(LOG_LEVEL_INFO, "[cineform] start encoder pool\n");
        status = CFHD_StartEncoderPool(s->encoderPoolRef);
        if(status != CFHD_ERROR_OKAY){
                log_msg(LOG_LEVEL_ERROR, "[cineform] Failed to start encoder pool\n");
                return false;
        }
 
        s->started = true;
        s->cv.notify_all();
 
        return true;
}

References CFHD, codecs, video_desc::color_spec, state_video_compress_cineform::compressed_desc, state_video_compress_cineform::cv, state_video_compress_cineform::dec, desc, state_video_compress_cineform::encoderPoolRef, get_best_decoder_from(), get_codec_name(), video_desc::height, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE, log_msg(), state_video_compress_cineform::metadataRef, MOD_NAME, state_video_compress_cineform::precompress_desc, state_video_compress_cineform::requested_quality, state_video_compress_cineform::saved_desc, state_video_compress_cineform::started, video_desc::tile_count, to_fourcc, val, VIDEO_CODEC_COUNT, VIDEO_CODEC_NONE, and video_desc::width.

Referenced by cineform_compress_push(), and cineform_decompress_reconfigure().

Here is the call graph for this function:

get_cineform_module_info()

static compress_module_info get_cineform_module_info ( )

static

Definition at line 514 of file cineform.cpp.

                                                      {
        compress_module_info module_info;
        module_info.name = "cineform";
 
        for(const auto& opt : usage_opts){
                module_info.opts.emplace_back(module_option{opt.label,
                                opt.description, opt.placeholder, opt.key, opt.opt_str, false});
        }
 
        codec codec_info;
        codec_info.name = "Cineform";
        codec_info.priority = 400;
        codec_info.encoders.emplace_back(encoder{"default", ""});
 
        module_info.codecs.emplace_back(std::move(codec_info));
 
        return module_info;
}

References codec_info, compress_module_info::codecs, codec_info_t::name, compress_module_info::name, compress_module_info::opts, and usage_opts.

get_copy()

static video_frame * get_copy ( struct state_video_compress_cineform * s, video_frame * frame )

static

Definition at line 333 of file cineform.cpp.

                                                                                         {
        video_frame *ret = vf_alloc_desc_data(s->precompress_desc);
        vf_copy_metadata(ret, frame); // seq and compress_start
        int src_linesize = vc_get_linesize(frame->tiles[0].width, frame->color_spec);
        int dst_linesize = vc_get_linesize(frame->tiles[0].width, ret->color_spec);
        auto *dst = (unsigned char *) ret->tiles[0].data;
        int dst_sign = 1;
        if (s->precompress_desc.color_spec == RGB) { // upside down
                dst += static_cast<size_t>(dst_linesize) *
                       (frame->tiles[0].height - 1);
                dst_sign = -1;
        }
        for (long int i = 0; i < (long int) frame->tiles[0].height; ++i) {
                s->dec(dst + dst_sign * i * dst_linesize, (unsigned char *) frame->tiles[0].data + i * src_linesize, dst_linesize, 16, 8, 0);
        }
 
        return ret;
}

References video_desc::color_spec, video_frame::color_spec, tile::data, state_video_compress_cineform::dec, frame, tile::height, state_video_compress_cineform::precompress_desc, RGB, video_frame::tiles, vc_get_linesize(), vf_alloc_desc_data(), vf_copy_metadata(), and tile::width.

Referenced by cineform_compress_push().

Here is the call graph for this function:

parse_fmt()

static int parse_fmt ( struct state_video_compress_cineform * s, char * fmt )

static

Definition at line 144 of file cineform.cpp.

                                                                         {
        char *item, *save_ptr = NULL;
        if(fmt) {
                while((item = strtok_r(fmt, ":", &save_ptr)) != NULL) {
                        if(strncasecmp("help", item, strlen("help")) == 0) {
                                usage();
                                return 1;
                        } else if(strncasecmp("quality=", item, strlen("quality=")) == 0) {
                                char *quality = item + strlen("quality=");
                                int qual = atoi(quality);
                                if(qual >= 1 && qual <= 6){
                                        s->requested_quality = static_cast<CFHD_EncodingQuality>(qual);
                                } else {
                                        log_msg(LOG_LEVEL_ERROR, "[cineform] Error: Quality must be in range 1-6.\n");
                                        return -1;
                                }
                        } else if(strncasecmp("threads=", item, strlen("threads=")) == 0) {
                                char *threads = item + strlen("threads=");
                                s->requested_threads = atoi(threads);
                        } else if(strncasecmp("pool_size=", item, strlen("pool_size=")) == 0) {
                                char *pool_size = item + strlen("pool_size=");
                                s->requested_pool_size = atoi(pool_size);
                        } else {
                                log_msg(LOG_LEVEL_ERROR, "[cineform] Error: unknown option %s.\n",
                                                item);
                                return -1;
                        }
                        fmt = NULL;
                }
        }
 
        return 0;
}

References fmt, LOG_LEVEL_ERROR, log_msg(), state_video_compress_cineform::requested_pool_size, state_video_compress_cineform::requested_quality, state_video_compress_cineform::requested_threads, and usage().

Referenced by cineform_compress_init().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	cineform	,
		&	cineform_info,
		LIBRARY_CLASS_VIDEO_COMPRESS	,
		VIDEO_COMPRESS_ABI_VERSION	)

usage()

static void usage ( void )

static

Definition at line 135 of file cineform.cpp.

                    {
        printf("Cineform encoder usage:\n");
        printf("\t-c cineform[:quality=<quality>][:threads=<num_threads>][:pool_size=<pool_size>]\n");
 
        for(const auto& opt : usage_opts){
                printf("\t\t<%s> %s\n", opt.key, opt.description);
        }
}

References usage_opts.

Referenced by parse_fmt().

Variable Documentation

cfhd_encoded_format

CFHD_EncodedFormat cfhd_encoded_format

Definition at line 233 of file cineform.cpp.

cfhd_pixel_format

CFHD_PixelFormat cfhd_pixel_format

Definition at line 232 of file cineform.cpp.

cineform_info

const struct video_compress_info cineform_info

Initial value:

= {
        "cineform",
        cineform_compress_init,
        NULL,
        NULL,
        NULL,
        NULL,
        cineform_compress_push,
        cineform_compress_pop,
        get_cineform_module_info,
}

Definition at line 533 of file cineform.cpp.

                                                 {
        "cineform",
        cineform_compress_init,
        NULL,
        NULL,
        NULL,
        NULL,
        cineform_compress_push,
        cineform_compress_pop,
        get_cineform_module_info,
};

[struct]

struct { ... } codecs[]

Initial value:

= {
        {UYVY, CFHD_PIXEL_FORMAT_2VUY, CFHD_ENCODED_FORMAT_YUV_422},
        {RGB, CFHD_PIXEL_FORMAT_RG24, CFHD_ENCODED_FORMAT_RGB_444},
        {RGBA, CFHD_PIXEL_FORMAT_BGRa, CFHD_ENCODED_FORMAT_RGBA_4444},
        {v210, CFHD_PIXEL_FORMAT_V210, CFHD_ENCODED_FORMAT_YUV_422},
        {R10k, CFHD_PIXEL_FORMAT_DPX0, CFHD_ENCODED_FORMAT_RGB_444},
        {RG48, CFHD_PIXEL_FORMAT_RG48, CFHD_ENCODED_FORMAT_RGB_444},
}

Referenced by codec_list_to_str(), configure_with(), delay_get_property(), display_aggregate_get_property(), display_aja_get_property(), display_bluefish444_get_property(), display_conference_get_property(), display_decklink_get_property(), display_deltacast_get_property(), display_dump_get_property(), display_dvs_get_property(), display_file_get_property(), display_ndi_get_property(), display_panogl_get_property(), display_pw_get_property(), display_sage_get_property(), display_sdl2_get_property(), display_sdl_get_property(), display_unix_sock_get_property(), display_v4l2_get_property(), display_xrgl_get_property(), get_supported_pfs(), parse_codecs(), and print_capabilities().

description

const char* description

Definition at line 126 of file cineform.cpp.

Referenced by vulkan_display::VulkanDisplay::acquire_image(), vulkan_display::VulkanDisplay::copy_and_queue_image(), vulkan_display_detail::get_buffer_size(), get_configured_capture_aliases(), glfw_print_error(), vulkan_display::VulkanDisplay::is_image_description_supported(), keycontrol_register_key(), playback_register_keyboard_ctl(), and vulkan_display_detail::TransferImageImpl::recreate().

key

const char* key

Definition at line 125 of file cineform.cpp.

Referenced by image_pattern_diagonal::image_pattern_diagonal(), audio_cap_pipewire_init(), audio_play_pw_init(), blockDecrypt(), blockEncrypt(), check_av_opt_set(), cipherUpdateRounds(), des_initialize(), dev_add_option(), display_conference_worker(), display_drm_init(), display_gl_process_key(), display_gl_set_window_hints(), display_pw_init(), display_unix_sock_init(), dxt_display_keyboard(), keyboard_control::impl::exec_local_command(), get_commandline_param(), get_if_supported_key_val(), gl_process_frames(), glfw_key_callback(), init(), keycontrol_register_key(), keycontrol_send_key(), UltragridWindow::loadSettingsFile(), makeKey(), maybeWriteString(), on_registry_event_global(), padDecrypt(), padEncrypt(), parse_hints(), parse_holepunch_conf(), parse_pam(), pdb_search(), playback_register_keyboard_ctl(), print_bmd_attribute(), print_module_usage(), qfDES(), qfDES_checkWeakKeys(), AvailableSettings::queryDevice(), set_commandline_param(), set_key_from_str(), set_winreg_key(), PreviewWidget::setKey(), test_des(), translate_glfw_to_ug(), and vidcap_screen_win_process_params().

label

const char* label

Definition at line 124 of file cineform.cpp.

Referenced by SettingsUi::addDeviceTabs(), and SettingsUi::fillFormOptions().

opt_str

const char* opt_str

Definition at line 127 of file cineform.cpp.

Referenced by dev_add_option().

placeholder

const char* placeholder

Definition at line 128 of file cineform.cpp.

Referenced by LineEditUi::setPlaceholder(), and videoCompressBitrateCallback().

ug_codec

codec_t ug_codec

Definition at line 231 of file cineform.cpp.

[struct]

struct { ... } usage_opts[]

Initial value:

= {
        {"Quality", "quality", "specifies encode quality, range 1-6 (default: 4)", ":quality=", "4"},
        {"Threads", "num_threads", "specifies number of threads for encoding (default: " TOSTRING(DEFAULT_THREAD_COUNT) ")", ":num_threads=", ""},
        {"Pool size", "pool_size", "specifies the size of encoding pool (default: " TOSTRING(DEFAULT_POOL_SIZE) ")", ":pool_size=", ""},
}

Referenced by get_cineform_module_info(), and usage().