video_codec.c File Reference

This file contains video codec-related functions. More...

#include "config_unix.h"
#include "config_win32.h"
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "color.h"
#include "compat/qsort_s.h"
#include "debug.h"
#include "host.h"
#include "hwaccel_vdpau.h"
#include "hwaccel_drm.h"
#include "utils/macros.h"
#include "video_codec.h"

Include dependency graph for video_codec.c:

Go to the source code of this file.

Classes
struct	alternative_codec_name
struct	alternative_fourcc
struct	codec_info_t
struct	pixfmt_plane_info_t
	for planar pixel formats More...

Macros
#define	__STDC_WANT_LIB_EXT1__   1
#define	BYTE_SWAP(x)
#define	HW_VDPAU_FRAME_SZ   0

Functions
bool	clear_video_buffer (unsigned char *data, size_t linesize, size_t pitch, size_t height, codec_t color_spec)
void	codec_get_planes_subsampling (codec_t pix_fmt, int *sub)
bool	codec_is_420 (codec_t pix_fmt)
bool	codec_is_a_rgb (codec_t codec)
	Returns TRUE if specified pixelformat is some form of RGB (not YUV).
bool	codec_is_const_size (codec_t codec)
	Returns TRUE if specified pixelformat has constant size regardles of resolution. If so the block_size value represents the size.
bool	codec_is_hw_accelerated (codec_t codec)
bool	codec_is_in_set (codec_t codec, const codec_t *set)
bool	codec_is_planar (codec_t codec)
int	compare_pixdesc (const struct pixfmt_desc *desc_a, const struct pixfmt_desc *desc_b, const struct pixfmt_desc *src_desc)
int	get_bits_per_component (codec_t codec)
double	get_bpp (codec_t codec)
const char *	get_codec_file_extension (codec_t codec)
codec_t	get_codec_from_fcc (uint32_t fourcc)
codec_t	get_codec_from_file_extension (const char *ext)
codec_t	get_codec_from_name (const char *name)
static codec_t	get_codec_from_name_wo_alias (const char *name)
const char *	get_codec_name (codec_t codec)
const char *	get_codec_name_long (codec_t codec)
uint32_t	get_fourcc (codec_t codec)
int	get_pf_block_bytes (codec_t codec)
	returns codec_info_t::block_size_bytes
int	get_pf_block_pixels (codec_t codec)
	returns codec_info_t::block_size_pixels
const char *	get_pixdesc_desc (struct pixfmt_desc desc)
struct pixfmt_desc	get_pixfmt_desc (codec_t pixfmt)
int	get_subsampling (codec_t codec)
void	i420_16_to_y416 (int width, int height, const unsigned char *in, unsigned char *out, int in_depth)
void	i420_8_to_uyvy (int width, int height, const unsigned char *in, unsigned char *out)
void	i422_16_to_y416 (int width, int height, const unsigned char *in, unsigned char *out, int in_depth)
void	i422_8_to_uyvy (int width, int height, const unsigned char *in, unsigned char *out)
void	i444_16_to_y416 (int width, int height, const unsigned char *in, unsigned char *out, int in_depth)
void	i444_8_to_uyvy (int width, int height, const unsigned char *in, unsigned char *out)
bool	is_codec_interframe (codec_t codec)
bool	is_codec_opaque (codec_t codec)
bool	pixdesc_equals (struct pixfmt_desc desc_a, struct pixfmt_desc desc_b)
void	show_codec_help (const char *module, const codec_t *codecs8, const codec_t *codecs10, const codec_t *codecs_ge12)
	Prints list of suppored codecs for video module.
void	uyvy_to_i422 (int width, int height, const unsigned char *in, unsigned char *out)
void	vc_deinterlace (unsigned char *src, long src_linesize, int lines)
	Deinterlaces framebuffer.
bool	vc_deinterlace_ex (codec_t codec, unsigned char *src, size_t src_linesize, unsigned char *dst, size_t dst_pitch, size_t lines)
size_t	vc_get_datalen (unsigned int width, unsigned int height, codec_t codec)
int	vc_get_linesize (unsigned int width, codec_t codec)
int	vc_get_size (unsigned int width, codec_t codec)
void	watch_pixfmt_degrade (const char *mod_name, struct pixfmt_desc desc_src, struct pixfmt_desc desc_dst)
void	y416_to_i444 (int width, int height, const unsigned char *in, unsigned char *out, int depth)

Variables
static const struct codec_info_t	codec_info []
static const struct alternative_codec_name	codec_name_aliases []
static const struct alternative_fourcc	fourcc_aliases []
char	pixfmt_conv_pref [] = "dsc"
	bitdepth, subsampling, color space
static const struct pixfmt_plane_info_t	pixfmt_plane_info []

Detailed Description

This file contains video codec-related functions.

Author

Martin Benes marti.nosp@m.nben.nosp@m.esh@g.nosp@m.mail.nosp@m..com

Lukas Hejtmanek xhejt.nosp@m.man@.nosp@m.ics.m.nosp@m.uni..nosp@m.cz

Petr Holub hopet.nosp@m.@ics.nosp@m..muni.nosp@m..cz

Milos Liska xlisk.nosp@m.a@fi.nosp@m..muni.nosp@m..cz

Jiri Matela matel.nosp@m.a@ic.nosp@m.s.mun.nosp@m.i.cz

Dalibor Matura 25589.nosp@m.9@ma.nosp@m.il.mu.nosp@m.ni.c.nosp@m.z

Ian Wesley-Smith iwsmi.nosp@m.th@c.nosp@m.ct.ls.nosp@m.u.ed.nosp@m.u

This file contains video codecs' metadata and helper functions as well as pixelformat converting functions.

Definition in file video_codec.c.

Macro Definition Documentation

__STDC_WANT_LIB_EXT1__

#define __STDC_WANT_LIB_EXT1__   1

Definition at line 53 of file video_codec.c.

BYTE_SWAP

#define BYTE_SWAP

(

x

)

Value:

x

Definition at line 85 of file video_codec.c.

HW_VDPAU_FRAME_SZ

#define HW_VDPAU_FRAME_SZ   0

Definition at line 118 of file video_codec.c.

Function Documentation

clear_video_buffer()

bool clear_video_buffer	(	unsigned char *	data,
		size_t	linesize,
		size_t	pitch,
		size_t	height,
		codec_t	color_spec )

Definition at line 862 of file video_codec.c.

{
        uint32_t pattern[4];
 
        switch (color_spec) {
                case BGR:
                case RGB:
                case RGBA:
                        memset(pattern, 0, sizeof(pattern));
                        break;
                case UYVY:
                        for (int i = 0; i < 4; i++) {
                                pattern[i] = 0x00800080;
                        }
                        break;
                case v210:
                        pattern[0] = 0x20000200;
                        pattern[1] = 0x00080000;
                        pattern[2] = 0x20000200;
                        pattern[3] = 0x00080000;
                        break;
#ifdef HWACC_VDPAU
                case HW_VDPAU:
                        memset(data, 0,sizeof(hw_vdpau_frame));
                        return true;
#endif
                default:
                        return false;
        }
 
        for (size_t y = 0; y < height; ++y) {
                uintptr_t i;
                for( i = 0; i < (linesize & (~15)); i+=16)
                {
                        memcpy(data + i, pattern, 16);
                }
                for( ; i < linesize; i++ )
                {
                        ((char*)data)[i] = ((char*)pattern)[i&15];
                }
 
                data += pitch;
        }
 
        return true;
}

References BGR, HW_VDPAU, RGB, RGBA, UYVY, and v210.

Referenced by vf_clear().

codec_get_planes_subsampling()

void codec_get_planes_subsampling	(	codec_t	pix_fmt,
		int *	sub )

Returns subsampling of individual planes of planar pixel format

Undefined if pix_fmt is not a planar pixel format

Parameters

[out]

sub

subsampling, allocated array must be able to hold 8 members

Definition at line 924 of file video_codec.c.

                                                             {
        for (size_t i = 0; i < 8; ++i) {
                *sub++ = pixfmt_plane_info[pix_fmt].plane_info[i];
        }
}

References pixfmt_plane_info, and pixfmt_plane_info_t::plane_info.

Referenced by buf_get_linesizes(), buf_get_planes(), same_linesizes(), to_lavc_vid_conv(), and vc_get_datalen().

codec_is_420()

bool codec_is_420

(

codec_t

pix_fmt

)

Definition at line 930 of file video_codec.c.

{
        return pixfmt_plane_info[pix_fmt].plane_info[0] == 1 &&
                pixfmt_plane_info[pix_fmt].plane_info[1] == 1 &&
                pixfmt_plane_info[pix_fmt].plane_info[2] == 2 &&
                pixfmt_plane_info[pix_fmt].plane_info[3] == 2 &&
                pixfmt_plane_info[pix_fmt].plane_info[4] == 2 &&
                pixfmt_plane_info[pix_fmt].plane_info[5] == 2;
}

References pixfmt_plane_info, and pixfmt_plane_info_t::plane_info.

codec_is_a_rgb()

bool codec_is_a_rgb

(

codec_t

codec

)

Returns TRUE if specified pixelformat is some form of RGB (not YUV).

Unspecified for compressed codecs.

Return values

TRUE	if pixelformat is RGB
FALSE	if pixelformat is not a RGB

Definition at line 463 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                return codec_info[i].rgb;
        }
        return false;
}

References codec_info, and codec_info_t::rgb.

Referenced by check_duration(), cleanup_screen(), compute_dst_rect(), configure_with(), display_decklink_reconfigure(), display_frame(), display_sdl_reconfigure_real(), gpujpeg_decompress_get_priority(), j2k_decompress_get_priority(), libavcodec_decompress_get_priority(), print_pixel_formats(), and save_video_frame().

codec_is_const_size()

bool codec_is_const_size

(

codec_t

codec

)

Returns TRUE if specified pixelformat has constant size regardles of resolution. If so the block_size value represents the size.

Unspecified for compressed codecs.

Return values

TRUE	if pixelformat is const size
FALSE	if pixelformat is not const size

Definition at line 479 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                return codec_info[i].const_size;
        }
        return false;
}

References codec_info, and codec_info_t::const_size.

Referenced by av_to_uv_convert(), vf_alloc_desc(), and vf_alloc_desc_data().

codec_is_hw_accelerated()

bool codec_is_hw_accelerated

(

codec_t

codec

)

Definition at line 489 of file video_codec.c.

                                            {
        return codec == HW_VDPAU;
}

References HW_VDPAU.

Referenced by video_decoder_order_output_codecs().

codec_is_in_set()

bool codec_is_in_set	(	codec_t	codec,
		const codec_t *	set )

Tries to find specified codec in set of video codecs. The set must by ended by VIDEO_CODEC_NONE.

Definition at line 851 of file video_codec.c.

{
        assert (codec != VIDEO_CODEC_NONE);
        assert (set != NULL);
        while (*set != VIDEO_CODEC_NONE) {
                if (*(set++) == codec)
                        return true;
        }
        return false;
}

References VIDEO_CODEC_NONE.

Referenced by check_for_slave_format_change(), get_best_decoder_from(), load_texture(), reconfigure_if_needed(), and select_display_codec().

codec_is_planar()

bool codec_is_planar

(

codec_t

codec

)

Returns

true if codec is a pixel format and is planar

Definition at line 912 of file video_codec.c.

                                    {
        return pixfmt_plane_info[codec].plane_info[0] != 0;
}

References pixfmt_plane_info, and pixfmt_plane_info_t::plane_info.

Referenced by avg_lines(), display_sdl2_get_property(), get_av_to_uv_conversion(), same_linesizes(), to_lavc_vid_conv(), vc_deinterlace_ex(), vc_get_datalen(), vidcap_dshow_probe_internal(), vidcap_testcard_init(), and write_mode().

compare_pixdesc()

int compare_pixdesc	(	const struct pixfmt_desc *	desc_a,
		const struct pixfmt_desc *	desc_b,
		const struct pixfmt_desc *	src_desc )

qsort(_s)-compatible comparator

Definition at line 1138 of file video_codec.c.

{
        for (char *feature = pixfmt_conv_pref; *feature != '\0'; ++feature) {
                switch (*feature) {
                        case 'd':
                                if (desc_a->depth != desc_b->depth &&
                                                (desc_a->depth < src_desc->depth || desc_b->depth < src_desc->depth)) { // either a or b is lower than orig - sort higher bit depth first
                                        return desc_b->depth - desc_a->depth;
                                }
                                break;
                        case 's':
                                if (desc_a->subsampling != desc_b->subsampling &&
                                                (desc_a->subsampling < src_desc->subsampling || desc_b->subsampling < src_desc->subsampling)) {
                                        return desc_b->subsampling - desc_a->subsampling; // return better subs
                                }
                                break;
                        case 'c':
                                if (desc_a->rgb != desc_b->rgb) {
                                        return desc_a->rgb == src_desc->rgb ? -1 : 1;
                                }
                                break;
                }
        }
 
        // if both A and B are either undistinguishable or better than src, return closer ("worse") pixfmt
        for (char *feature = pixfmt_conv_pref; *feature != '\0'; ++feature) {
                switch (*feature) {
                        case 'd':
                                if (desc_a->depth != desc_b->depth) {
                                        return desc_a->depth - desc_b->depth;
                                }
                                break;
                        case 's':
                                if (desc_a->subsampling != desc_b->subsampling) {
                                        return desc_a->subsampling - desc_b->subsampling;
                                }
                                break;
                        case 'c':
                                // will be a tie here
                                break;
                }
        }
 
        return 0;
}

References pixfmt_desc::depth, pixfmt_conv_pref, pixfmt_desc::rgb, and pixfmt_desc::subsampling.

Referenced by lavc_compare_convs_inner(), QSORT_S_COMP_DEFINE(), QSORT_S_COMP_DEFINE(), QSORT_S_COMP_DEFINE(), QSORT_S_COMP_DEFINE(), and set_convertible_formats().

get_bits_per_component()

int get_bits_per_component

(

codec_t

codec

)

Definition at line 280 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                return codec_info[i].bits_per_channel;
        }
        assert(0);
}

References codec_info_t::bits_per_channel, and codec_info.

Referenced by avg_lines(), display_gl_get_property(), display_gl_reconfigure(), filter(), get_16_bit_pnm_data(), get_out_cv_data_type(), j2k_decompress_reconfigure(), print_pixel_formats(), reconfigure_if_needed(), resize_frame_dimensions(), same_linesizes(), save_video_frame(), save_video_frame_as_pnm(), save_video_frame_as_y4m(), testcard_show_codec_help(), to_lavc_vid_conv(), vc_deinterlace_ex(), vc_get_datalen(), vidcap_decklink_init(), vidcap_testcard_init(), and video_pattern_generator_create().

get_bpp()

double get_bpp

(

codec_t

codec

)

Definition at line 301 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
        double bpp = 0;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                bpp = (double) codec_info[i].block_size_bytes /
                      codec_info[i].block_size_pixels;
        }
        assert(bpp != 0);
        return bpp;
}

References codec_info.

Referenced by border_postprocess(), crop_postprocess(), crop_postprocess_reconfigure(), display_frame(), filter(), ipc_frame_from_ug_frame(), ipc_frame_from_ug_frame_hq(), j2k_decompress_reconfigure(), reconfigure(), vf_split(), vidcap_dvs_init(), and vidcap_testcard2_thread().

get_codec_file_extension()

const char * get_codec_file_extension

(

codec_t

codec

)

Definition at line 406 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                return codec_info[i].file_extension;
        } else {
                return 0;
        }
}

References codec_info, and codec_info_t::file_extension.

Referenced by get_tile_count(), save_video_frame(), video_export(), and video_reading_thread().

get_codec_from_fcc()

codec_t get_codec_from_fcc

(

uint32_t

fourcc

)

Definition at line 350 of file video_codec.c.

{
        for (unsigned int i = 0; i < sizeof codec_info / sizeof(struct codec_info_t); ++i) {
                if (fourcc == codec_info[i].fcc)
                        return i;
        }
 
        // try to look through aliases
        for (size_t i = 0; i < sizeof(fourcc_aliases) / sizeof(struct alternative_fourcc); ++i) {
                if (fourcc == fourcc_aliases[i].alias) {
                        for (unsigned int j = 0; j < sizeof codec_info / sizeof(struct codec_info_t); ++j) {
                                if (fourcc_aliases[i].primary_fcc == codec_info[j].fcc)
                                        return j;
                        }
                }
        }
        return VIDEO_CODEC_NONE;
}

References alternative_fourcc::alias, codec_info, codec_info_t::fcc, fourcc_aliases, and VIDEO_CODEC_NONE.

Referenced by display_sage_init(), parse_video_desc_info(), and parse_video_hdr().

get_codec_from_file_extension()

codec_t get_codec_from_file_extension

(

const char *

ext

)

Definition at line 417 of file video_codec.c.

{
        for (unsigned int i = 0; i < sizeof codec_info / sizeof(struct codec_info_t); ++i) {
                if (codec_info[i].file_extension && strcasecmp(codec_info[i].file_extension, ext) == 0) {
                        return i;
                }
        }
 
        return VIDEO_CODEC_NONE;
}

References codec_info, codec_info_t::file_extension, and VIDEO_CODEC_NONE.

Referenced by testcard_load_from_file(), and write_to_container().

get_codec_from_name()

codec_t get_codec_from_name

(

const char *

name

)

Definition at line 387 of file video_codec.c.

{
        codec_t ret = get_codec_from_name_wo_alias(name);
        if (ret != VIDEO_CODEC_NONE) {
                return ret;
        }
 
        // try to find if this is not an alias
        for (size_t i = 0; i < sizeof(codec_name_aliases) / sizeof(struct alternative_codec_name); ++i) {
                if (strcasecmp(name, codec_name_aliases[i].alias) == 0) {
                        ret = get_codec_from_name_wo_alias(codec_name_aliases[i].primary_name);
                        if (ret != VIDEO_CODEC_NONE) {
                                return ret;
                        }
                }
        }
        return VIDEO_CODEC_NONE;
}

References alternative_codec_name::alias, codec_name_aliases, get_codec_from_name_wo_alias(), name, alternative_codec_name::primary_name, and VIDEO_CODEC_NONE.

Here is the call graph for this function:

get_codec_from_name_wo_alias()

static codec_t get_codec_from_name_wo_alias ( const char * name )

static

Helper codec finding function

Iterates through codec list and finds appropriate codec.

Returns

codec

Definition at line 376 of file video_codec.c.

{
        for (unsigned int i = 0; i < sizeof codec_info / sizeof(struct codec_info_t); ++i) {
                if (codec_info[i].name && strcasecmp(codec_info[i].name, name) == 0) {
                        return i;
                }
        }
 
        return VIDEO_CODEC_NONE;
}

References codec_info, name, and VIDEO_CODEC_NONE.

Referenced by get_codec_from_name().

get_codec_name()

const char * get_codec_name

(

codec_t

codec

)

Definition at line 326 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
        const char *name = NULL;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                name = codec_info[i].name;
        }
        assert(name != NULL);
        return name;
}

References codec_info, codec_info_t::name, and name.

get_codec_name_long()

const char * get_codec_name_long

(

codec_t

codec

)

Definition at line 338 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
        const char *name_long = NULL;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                name_long = codec_info[i].name_long;
        }
        assert(name_long != NULL);
        return name_long;
}

References codec_info, and codec_info_t::name_long.

Referenced by print_pixel_formats(), print_video_codecs(), and testcard_show_codec_help().

get_fourcc()

uint32_t get_fourcc

(

codec_t

codec

)

Definition at line 314 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
        uint32_t fourcc = 0;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                fourcc = codec_info[i].fcc;
        }
        assert(fourcc != 0);
        return fourcc;
}

References codec_info, and codec_info_t::fcc.

Referenced by configure_with(), format_video_header(), and output_summary().

get_pf_block_bytes()

int get_pf_block_bytes

(

codec_t

codec

)

returns codec_info_t::block_size_bytes

Definition at line 556 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
 
        if (i >= sizeof codec_info / sizeof(struct codec_info_t)) {
                abort();
        }
        assert(codec_info[i].block_size_bytes > 0);
        return codec_info[i].block_size_bytes;
}

References codec_info_t::block_size_bytes, and codec_info.

Referenced by crop_postprocess(), crop_postprocess_reconfigure(), display_dummy_putf(), filter(), filter(), get_packet_sizes(), reconfigure_decoder(), upload_to_cuda_buf(), vf_alloc_desc(), and vf_alloc_desc_data().

get_pf_block_pixels()

int get_pf_block_pixels

(

codec_t

codec

)

returns codec_info_t::block_size_pixels

Definition at line 568 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
 
        if (i >= sizeof codec_info / sizeof(struct codec_info_t)) {
                abort();
        }
        assert(codec_info[i].block_size_pixels > 0);
        return codec_info[i].block_size_pixels;
}

References codec_info_t::block_size_pixels, and codec_info.

Referenced by get_packet_sizes(), ipc_frame_from_ug_frame(), ipc_frame_from_ug_frame_hq(), and reconfigure_decoder().

get_pixdesc_desc()

const char * get_pixdesc_desc

(

struct pixfmt_desc

desc

)

Definition at line 1203 of file video_codec.c.

{
        if (desc.depth == 0) {
                return "(undefined)";
        }
        _Thread_local static char buf[128];
        snprintf(buf, sizeof buf, "%s %d:%d:%d", desc.rgb ? "RGB" : "YCbCr", desc.subsampling / 1000, desc.subsampling % 1000 / 100, desc.subsampling % 100 / 10);
        if (desc.subsampling % 10 != 0) {
                snprintf(buf + strlen(buf), sizeof buf - strlen(buf), ":%d", desc.subsampling % 10);
        }
        snprintf(buf + strlen(buf), sizeof buf - strlen(buf), " %d bit", desc.depth);
        return buf;
}

References desc.

Referenced by choose_codec_and_decoder(), decompress_thread(), j2k_probe_internal_codec(), and video_decoder_order_output_codecs().

get_pixfmt_desc()

struct pixfmt_desc get_pixfmt_desc

(

codec_t

pixfmt

)

Definition at line 1125 of file video_codec.c.

{
        assert(pixfmt >= VIDEO_CODEC_FIRST && pixfmt < VIDEO_CODEC_END);
        struct pixfmt_desc ret = { 0 };
        ret.depth = codec_info[pixfmt].bits_per_channel;
        ret.subsampling = codec_info[pixfmt].subsampling;
        ret.rgb = codec_info[pixfmt].rgb;
        return ret;
}

References codec_info_t::bits_per_channel, codec_info, pixfmt_desc::depth, codec_info_t::rgb, pixfmt_desc::rgb, codec_info_t::subsampling, pixfmt_desc::subsampling, VIDEO_CODEC_END, and VIDEO_CODEC_FIRST.

Referenced by get_av_to_uv_conversion(), get_available_pix_fmts(), get_best_decoder_from(), get_decoder_from_uv_to_uv(), pick_av_convertible_to_ug(), probe_internal(), probe_internal_cineform(), QSORT_S_COMP_DEFINE(), QSORT_S_COMP_DEFINE(), QSORT_S_COMP_DEFINE(), QSORT_S_COMP_DEFINE(), set_convertible_formats(), to_lavc_vid_conv_init(), and video_decoder_order_output_codecs().

get_subsampling()

int get_subsampling

(

codec_t

codec

)

Returns

subsampling in format (int) JabA (A is alpha), eg 4440

Definition at line 291 of file video_codec.c.

{
        int subsampling = 0;
        if (codec < sizeof codec_info / sizeof(struct codec_info_t)) {
                subsampling = codec_info[codec].subsampling;
        }
        assert(subsampling != 0);
        return subsampling;
}

References codec_info, and codec_info_t::subsampling.

i420_16_to_y416()

void i420_16_to_y416	(	int	width,
		int	height,
		const unsigned char *	in,
		unsigned char *	out,
		int	in_depth )

Definition at line 1022 of file video_codec.c.

{
        enum { ALPHA16_OPAQUE = 0xFFFF };
        const uint16_t *in_y1 = (const void *) in;
        const uint16_t *in_y2 = in_y1 + width;
        const uint16_t *in_cb =
            (const uint16_t *) (const void *) in + (ptrdiff_t) width * height;
        const uint16_t *in_cr =
            in_cb + (ptrdiff_t) ((width + 1) / 2) * ((height + 1) / 2);
        const size_t out_line_len = vc_get_linesize(width, Y416) / 2;
        uint16_t    *outp1        = (void *) out;
        uint16_t    *outp2        = outp1 + out_line_len;
        for (int y = 0; y < (height + 1) / 2; ++y) {
                for (int x = 0; x < (width + 1) / 2; ++x) {
                        *outp1++ = *in_cb << (DEPTH16 - in_depth);
                        *outp1++ = *in_y1++ << (DEPTH16 - in_depth);
                        *outp1++ = *in_cr << (DEPTH16 - in_depth);
                        *outp1++ = ALPHA16_OPAQUE;
 
                        *outp2++ = *in_cb << (DEPTH16 - in_depth);
                        *outp2++ = *in_y2++ << (DEPTH16 - in_depth);
                        *outp2++ = *in_cr << (DEPTH16 - in_depth);
                        *outp2++ = ALPHA16_OPAQUE;
 
                        *outp1++ = *in_cb << (DEPTH16 - in_depth);
                        *outp1++ = *in_y1++ << (DEPTH16 - in_depth);
                        *outp1++ = *in_cr << (DEPTH16 - in_depth);
                        *outp1++ = ALPHA16_OPAQUE;
 
                        *outp2++ = *in_cb++ << (DEPTH16 - in_depth);
                        *outp2++ = *in_y2++ << (DEPTH16 - in_depth);
                        *outp2++ = *in_cr++ << (DEPTH16 - in_depth);
                        *outp2++ = ALPHA16_OPAQUE;
                }
                outp1 += out_line_len;
                outp2 += out_line_len;
                in_y1 += width;
                in_y2 += width;
        }
}

References DEPTH16, vc_get_linesize(), and Y416.

Referenced by testcard_load_from_file_y4m().

Here is the call graph for this function:

i420_8_to_uyvy()

void i420_8_to_uyvy	(	int	width,
		int	height,
		const unsigned char *	in,
		unsigned char *	out )

Definition at line 1064 of file video_codec.c.

{
        const int                  uyvy_linesize = vc_get_linesize(width, UYVY);
        const unsigned char *const cb = in + (ptrdiff_t) width * height;
        const unsigned char *const cr =
            cb + (ptrdiff_t) (width / 2) * (height / 2);
 
        for (ptrdiff_t y = 0; y < height; ++y) {
                const unsigned char *src_y  = in + width * y;
                const unsigned char *src_cb = cb + (width / 2) * (y / 2);
                const unsigned char *src_cr = cr + (width / 2) * (y / 2);
                unsigned char       *dst    = out + y * uyvy_linesize;
 
                OPTIMIZED_FOR(int x = 0; x < width / 2; ++x)
                {
                        *dst++ = *src_cb++;
                        *dst++ = *src_y++;
                        *dst++ = *src_cr++;
                        *dst++ = *src_y++;
                }
        }
}

References OPTIMIZED_FOR, UYVY, and vc_get_linesize().

Referenced by i420_decompress(), and testcard_load_from_file_y4m().

Here is the call graph for this function:

i422_16_to_y416()

void i422_16_to_y416	(	int	width,
		int	height,
		const unsigned char *	in,
		unsigned char *	out,
		int	in_depth )

Definition at line 999 of file video_codec.c.

{
        enum { ALPHA16_OPAQUE = 0xFFFF };
        const uint16_t *in_y  = (const uint16_t *) (const void *) in;
        const uint16_t *in_cb = in_y + (ptrdiff_t) width * height;
        const uint16_t *in_cr = in_cb + (ptrdiff_t) ((width + 1) / 2) * height;
        uint16_t       *outp  = (void *) out;
        for (int y = 0; y < height; ++y) {
                for (int x = 0; x < (width + 1) / 2; ++x) {
                        *outp++ = *in_cb << (DEPTH16 - in_depth);
                        *outp++ = *in_y++ << (DEPTH16 - in_depth);
                        *outp++ = *in_cr << (DEPTH16 - in_depth);
                        *outp++ = ALPHA16_OPAQUE;
                        *outp++ = *in_cb++ << (DEPTH16 - in_depth);
                        *outp++ = *in_y++ << (DEPTH16 - in_depth);
                        *outp++ = *in_cr++ << (DEPTH16 - in_depth);
                        *outp++ = ALPHA16_OPAQUE;
                }
        }
}

References DEPTH16.

Referenced by testcard_load_from_file_y4m().

i422_8_to_uyvy()

void i422_8_to_uyvy	(	int	width,
		int	height,
		const unsigned char *	in,
		unsigned char *	out )

Definition at line 1088 of file video_codec.c.

{
        const unsigned char *in_y  = in;
        const unsigned char *in_cb = in + width * height;
        const unsigned char *in_cr = in_cb + (((width + 1) / 2) * height);
        unsigned char       *outp  = out;
        for (int y = 0; y < height; ++y) {
                for (int x = 0; x < (width + 1) / 2; ++x) {
                        *outp++ = *in_cb++;
                        *outp++ = *in_y++;
                        *outp++ = *in_cr++;
                        *outp++ = *in_y++;
                }
        }
}

Referenced by testcard_load_from_file_y4m().

i444_16_to_y416()

void i444_16_to_y416	(	int	width,
		int	height,
		const unsigned char *	in,
		unsigned char *	out,
		int	in_depth )

Definition at line 981 of file video_codec.c.

{
        const uint16_t *in_y = (const uint16_t *)(const void *) in;
        const uint16_t *in_cb = (const uint16_t *)(const void *) in + width * height;
        const uint16_t *in_cr = (const uint16_t *)(const void *) in + 2 * width * height;
        uint16_t *outp = (uint16_t *)(void *) out;
        for (int y = 0; y < height; ++y) {
                for (int x = 0; x < width; ++x) {
                        *outp++ = *in_cb++ << (16 - in_depth);
                        *outp++ = *in_y++ << (16 - in_depth);
                        *outp++ = *in_cr++ << (16 - in_depth);
                        *outp++ = 0xFFFFU; // alpha
                }
        }
}

Referenced by testcard_load_from_file_y4m().

i444_8_to_uyvy()

void i444_8_to_uyvy	(	int	width,
		int	height,
		const unsigned char *	in,
		unsigned char *	out )

Definition at line 1106 of file video_codec.c.

{
        const unsigned char *in_y = in;
        const unsigned char *in_cb = in + width * height;
        const unsigned char *in_cr = in_cb + width * height;
        unsigned char *outp = out;
        for (int y = 0; y < height; ++y) {
                for (int x = 0; x < (width + 1) / 2; ++x) {
                        *outp++ = *in_cb;
                        *outp++ = *in_y++;
                        *outp++ = *in_cr;
                        *outp++ = *in_y++;
                        in_cb += 2;
                        in_cr += 2;
                }
        }
}

Referenced by testcard_load_from_file_y4m().

is_codec_interframe()

bool is_codec_interframe

(

codec_t

codec

)

Returns whether specified codec is an interframe compression. Not defined for pixelformats

Return values

TRUE	if compression is interframe
FALSE	if compression is not interframe

Definition at line 448 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                return codec_info[i].interframe;
        }
        return false;
}

References codec_info, and codec_info_t::interframe.

Referenced by print_video_codecs().

is_codec_opaque()

bool is_codec_opaque

(

codec_t

codec

)

Return values

TRUE	if codec is compressed
FALSE	if codec is pixelformat

Definition at line 432 of file video_codec.c.

{
        unsigned int i = (unsigned int) codec;
 
        if (i < sizeof codec_info / sizeof(struct codec_info_t)) {
                return codec_info[i].opaque;
        }
        return false;
}

References codec_info, and codec_info_t::opaque.

Referenced by avg_lines(), display_dump_getf(), display_dump_reconfigure(), get_codecs(), get_packet_sizes(), print_pixel_formats(), print_video_codecs(), probe_cuda_ug_to_av(), save_video_frame(), h264_sdp_video_rxtx::send_frame(), testcard_show_codec_help(), vc_deinterlace_ex(), vidcap_dshow_grab(), vidcap_dshow_init(), vidcap_dshow_probe_internal(), vidcap_ndi_grab(), and write_mode().

pixdesc_equals()

bool pixdesc_equals	(	struct pixfmt_desc	desc_a,
		struct pixfmt_desc	desc_b )

Definition at line 1217 of file video_codec.c.

                                                                          {
        return desc_a.depth == desc_b.depth &&
                desc_a.subsampling == desc_b.subsampling &&
                desc_a.rgb == desc_b.rgb;
}

References pixfmt_desc::depth, pixfmt_desc::rgb, and pixfmt_desc::subsampling.

Referenced by reconfigure_if_needed(), and video_decoder_order_output_codecs().

show_codec_help()

void show_codec_help	(	const char *	module,
		const codec_t *	codecs8,
		const codec_t *	codecs10,
		const codec_t *	codecs_ge12 )

Prints list of suppored codecs for video module.

Definition at line 250 of file video_codec.c.

{
        printf("Supported codecs (%s):\n", module);
 
        if (codecs8) {
                printf("\t8bits\n");
 
                while (*codecs8 != VIDEO_CODEC_NONE) {
                        printf("\t\t'%s' - %s\n", codec_info[*codecs8].name, codec_info[*codecs8].name_long);
                        codecs8++;
                }
        }
 
        if (codecs10) {
                printf("\t10bits\n");
                while (*codecs10 != VIDEO_CODEC_NONE) {
                        printf("\t\t'%s' - %s\n", codec_info[*codecs10].name, codec_info[*codecs10].name_long);
                        codecs10++;
                }
        }
 
        if (codecs_ge12) {
                printf("\t12+ bits\n");
                while (*codecs_ge12 != VIDEO_CODEC_NONE) {
                        printf("\t\t'%s' - %s\n", codec_info[*codecs_ge12].name, codec_info[*codecs_ge12].name_long);
                        codecs_ge12++;
                }
        }
}

References codec_info, name, and VIDEO_CODEC_NONE.

Referenced by show_help().

uyvy_to_i422()

void uyvy_to_i422	(	int	width,
		int	height,
		const unsigned char *	in,
		unsigned char *	out )

Definition at line 941 of file video_codec.c.

{
        unsigned char *out_y  = out;
        unsigned char *out_cb = out + width * height;
        unsigned char *out_cr =
            out + width * height + ((width + 1) / 2) * height;
        for (int y = 0; y < height; ++y) {
                for (int x = 0; x < width / 2; ++x) {
                        *out_cb++ = *in++;
                        *out_y++  = *in++;
                        *out_cr++ = *in++;
                        *out_y++  = *in++;
                }
                if (width % 2 == 1) {
                        *out_cb++ = *in++;
                        *out_y++  = *in++;
                        *out_cr++ = *in++;
                }
        }
}

Referenced by save_video_frame_as_y4m().

vc_deinterlace()

void vc_deinterlace	(	unsigned char *	src,
		long	src_linesize,
		int	lines )

Deinterlaces framebuffer.

vc_deinterlace performs linear blend deinterlace on a framebuffer.

Parameters

[in,out]	src	framebuffer to be deinterlaced
[in]	src_linesize	length of a line (bytes)
[in]	lines	number of lines

See also

vc_deinterlace_aligned

vc_deinterlace_unaligned

Definition at line 588 of file video_codec.c.

{
#ifdef __SSE2__
        if(((uintptr_t) src & 0x0Fu) == 0u && src_linesize % 16 == 0) {
                vc_deinterlace_aligned(src, src_linesize, lines);
        } else {
                vc_deinterlace_unaligned(src, src_linesize, lines);
        }
#else
        for (int y = 0; y < lines; y += 2) {
                for (int x = 0; x < src_linesize; ++x) {
                        int val = (*src + src[src_linesize] + 1) >> 1;
                        *src = src[src_linesize]  = val;
                        src++;
                }
                src += src_linesize;
        }
#endif
}

References val.

Referenced by display_frame(), display_sage_run(), and slave_worker().

vc_deinterlace_ex()

bool vc_deinterlace_ex	(	codec_t	codec,
		unsigned char *	src,
		size_t	src_linesize,
		unsigned char *	dst,
		size_t	dst_pitch,
		size_t	lines )

Extended version of vc_deinterlace(). The former version was in-place only. This allows to output to a different buffer while it can still be used in-place.

Returns

false on unsupported codecs

Definition at line 713 of file video_codec.c.

{
        if (is_codec_opaque(codec) && codec_is_planar(codec)) {
                return false;
        }
        if (lines == 1) {
                memcpy(dst, src, src_linesize);
                return true;
        }
        DEBUG_TIMER_START(vc_deinterlace_ex);
        int bpp = get_bits_per_component(codec);
        for (size_t y = 0; y < lines - 1; y += 1) {
                unsigned char *s = src + y * src_linesize;
                unsigned char *d = dst + y * dst_pitch;
                if (bpp == 8 || bpp == 16) {
                        size_t x = 0;
#ifdef __SSSE3__
                        if (bpp == 8) {
                                for ( ; x < src_linesize / 16; ++x) {
                                        __m128i i1 = _mm_lddqu_si128((__m128i const*)(const void *) s);
                                        __m128i i2 = _mm_lddqu_si128((__m128i const*)(const void *) (s + src_linesize));
                                        __m128i res = _mm_avg_epu8(i1, i2);
                                        _mm_storeu_si128((__m128i *)(void *) d, res);
                                        s += 16;
                                        d += 16;
                                }
                        } else {
                                for ( ; x < src_linesize / 16; ++x) {
                                        __m128i i1 = _mm_lddqu_si128((__m128i const*)(const void *) s);
                                        __m128i i2 = _mm_lddqu_si128((__m128i const*)(const void *) (s + src_linesize));
                                        __m128i res = _mm_avg_epu16(i1, i2);
                                        _mm_storeu_si128((__m128i *)(void *) d, res);
                                        s += 16;
                                        d += 16;
                                }
                        }
#endif
                        x *= 16;
                        if (bpp  == 8) {
                                for ( ; x < src_linesize; ++x) {
                                        int val = (*s + s[src_linesize] + 1) >> 1;
                                        *d++ = val;
                                        s++;
                                }
                        } else {
                                uint16_t *d16 = (void *) d;
                                uint16_t *s16 = (void *) s;
                                for ( ; x < src_linesize / 2; ++x) {
                                        int val = (*s16 + s16[src_linesize / 2] + 1) >> 1;
                                        *d16++ = val;
                                        s16++;
                                }
                        }
                } else if (codec == v210) {
                        uint32_t *s32 = (void *) s;
                        uint32_t *d32 = (void *) d;
                        for (size_t x = 0; x < src_linesize / 16; ++x) {
                                #pragma GCC unroll 4
                                for (size_t y = 0; y < 4; ++y) {
                                        uint32_t v1 = *s32;
                                        uint32_t v2 = s32[src_linesize / 4];
                                        uint32_t out =
                                                (((v1 >> 20        ) + (v2 >> 20        ) + 1) / 2) << 20 |
                                                (((v1 >> 10 & 0x3ff) + (v2 >> 10 & 0x3ff) + 1) / 2) << 10 |
                                                (((v1       & 0x3ff) + (v2       & 0x3ff) + 1) / 2);
                                        *d32++ = out;
                                        s32++;
                                }
                        }
                } else if (codec == R10k) {
                        uint32_t *s32 = (void *) s;
                        uint32_t *d32 = (void *) d;
                        for (size_t x = 0; x < src_linesize / 16; ++x) {
                                #pragma GCC unroll 4
                                for (size_t y = 0; y < 4; ++y) {
                                        uint32_t v1 = ntohl(*s32);
                                        uint32_t v2 = ntohl(s32[src_linesize / 4]);
                                        uint32_t out =
                                                (((v1 >> 22        ) + (v2 >> 22        ) + 1) / 2) << 22 |
                                                (((v1 >> 12 & 0x3ff) + (v2 >> 12 & 0x3ff) + 1) / 2) << 12 |
                                                (((v1 >>  2 & 0x3ff) + (v2 >>  2 & 0x3ff) + 1) / 2) << 2;
                                        *d32++ = htonl(out);
                                        s32++;
                                }
                        }
                } else if (codec == R12L) {
                        uint32_t *s32 = (void *) s;
                        uint32_t *d32 = (void *) d;
                        int shift = 0;
                        uint32_t remain1 = 0;
                        uint32_t remain2 = 0;
                        uint32_t out = 0;
                        for (size_t x = 0; x < src_linesize / 36; ++x) {
                                #pragma GCC unroll 8
                                for (size_t y = 0; y < 8; ++y) {
                                        uint32_t in1 = *s32;
                                        uint32_t in2 = s32[src_linesize / 4];
                                        if (shift > 0) {
                                                remain1 = remain1 | (in1 & ((1<<((shift + 12) % 32)) - 1)) << (32-shift);
                                                remain2 = remain2 | (in2 & ((1<<((shift + 12) % 32)) - 1)) << (32-shift);
                                                uint32_t ret = (remain1 + remain2 + 1) / 2;
                                                out |= ret << shift;
                                                *d32++ = out;
                                                out = ret >> (32-shift);
                                                shift = (shift + 12) % 32;
                                                in1 >>= shift;
                                                in2 >>= shift;
                                        }
                                        while (shift <= 32 - 12) {
                                                out |= ((((in1 & 0xfff) + (in2 & 0xfff)) + 1) / 2) << shift;
                                                in1 >>= 12;
                                                in2 >>= 12;
                                                shift += 12;
                                        }
                                        if (shift == 32) {
                                                *d32++ = out;
                                                out = 0;
                                                shift = 0;
                                        } else {
                                                remain1 = in1;
                                                remain2 = in2;
                                        }
                                        s32++;
                                }
                        }
                } else {
                        return false;
                }
        }
        memcpy(dst + (lines - 1) * dst_pitch, dst + (lines - 2) * dst_pitch, src_linesize); // last line
        DEBUG_TIMER_STOP(vc_deinterlace_ex);
        return true;
}

References codec_is_planar(), DEBUG_TIMER_START, DEBUG_TIMER_STOP, get_bits_per_component(), is_codec_opaque(), R10k, R12L, v210, val, and vc_deinterlace_ex().

Referenced by deinterlace_postprocess(), display_frame(), perform_df(), and vc_deinterlace_ex().

Here is the call graph for this function:

vc_get_datalen()

size_t vc_get_datalen	(	unsigned int	width,
		unsigned int	height,
		codec_t	codec )

Returns storage requirements for given parameters

Definition at line 534 of file video_codec.c.

{
        if (!codec_is_planar(codec)) {
                return vc_get_linesize(width, codec) * height;
        }
 
        assert(get_bits_per_component(codec) == 8);
        size_t ret = 0;
        int sub[8];
        codec_get_planes_subsampling(codec, sub);
        for (int i = 0; i < 4; ++i) {
                if (sub[i * 2] == 0) { // less than 4 planes
                        break;
                }
                ret += ((width + sub[i * 2] - 1) / sub[i * 2])
                        * ((height + sub[i * 2 + 1] - 1) / sub[i * 2 + 1]);
        }
 
        return ret;
}

References codec_get_planes_subsampling(), codec_is_planar(), get_bits_per_component(), and vc_get_linesize().

Referenced by still_image_video_pattern_generator::still_image_video_pattern_generator(), SampleGrabberCallback::BufferCB(), codec_conversion_test_testcard_uyvy_to_i420(), do_av_to_uv_convert(), get_16_bit_pnm_data(), j2k_compress_push(), main(), r12l_postprocessor_get_sz(), save_video_frame_as_y4m(), testcard_load_from_file(), testcard_load_from_file_pam(), testcard_load_from_file_y4m(), vf_alloc_desc(), vidcap_dshow_grab(), vidcap_testcard2_init(), and vidcap_testcard2_thread().

Here is the call graph for this function:

vc_get_linesize()

int vc_get_linesize	(	unsigned int	width,
		codec_t	codec )

Returns

aligned linesize according to pixelformat specification (in bytes)

See also

vc_get_size that should be used eg. as decoder_t linesize parameter instead

Definition at line 498 of file video_codec.c.

{
        if (codec >= sizeof codec_info / sizeof(struct codec_info_t)) {
                return 0;
        }
 
        if (codec_info[codec].h_align) {
                width =
                    ((width + codec_info[codec].h_align -
                      1) / codec_info[codec].h_align) *
                    codec_info[codec].h_align;
        }
        int pixs = codec_info[codec].block_size_pixels;
        return (width + pixs - 1) / pixs * codec_info[codec].block_size_bytes;
}

References codec_info_t::block_size_bytes, codec_info_t::block_size_pixels, codec_info, and codec_info_t::h_align.

Referenced by i420_16_to_y416(), i420_8_to_uyvy(), and vc_get_datalen().

vc_get_size()

int vc_get_size	(	unsigned int	width,
		codec_t	codec )

Returns

size of "width" pixels in codec excluding line padding

This differs from vc_get_linesize for v210, eg. for width=1 that function returns 128, while this function 16. Also for R10k, lines are aligned to 256 B (64 pixels), while single pixel is only 4 B.

Definition at line 521 of file video_codec.c.

{
        if (codec >= sizeof codec_info / sizeof(struct codec_info_t)) {
                return 0;
        }
 
        int pixs = codec_info[codec].block_size_pixels;
        return (width + pixs - 1) / pixs * codec_info[codec].block_size_bytes;
}

References codec_info_t::block_size_bytes, codec_info_t::block_size_pixels, and codec_info.

Referenced by do_av_to_uv_convert(), draw_frame(), testcard_convert_buffer(), and to_lavc_memcpy_data().

watch_pixfmt_degrade()

void watch_pixfmt_degrade	(	const char *	mod_name,
		struct pixfmt_desc	desc_src,
		struct pixfmt_desc	desc_dst )

Definition at line 1184 of file video_codec.c.

{
        char message[1024];
        message[0] = '\0';
        if (desc_dst.depth < desc_src.depth) {
                snprintf(message, sizeof message, "conversion is reducing bit depth from %d to %d", desc_src.depth, desc_dst.depth);
        }
        if (desc_dst.subsampling < desc_src.subsampling) {
                if (strlen(message) > 0) {
                        snprintf(message + strlen(message), sizeof message - strlen(message), " and subsampling from %d to %d", desc_src.subsampling, desc_dst.subsampling);
                } else {
                        snprintf(message, sizeof message, "conversion is reducing subsampling from %d to %d", desc_src.subsampling, desc_dst.subsampling);
                }
        }
        if (strlen(message) > 0) {
                log_msg(LOG_LEVEL_WARNING, "%s%s\n", mod_name, message);
        }
}

References pixfmt_desc::depth, LOG_LEVEL_WARNING, log_msg(), and pixfmt_desc::subsampling.

Referenced by get_av_to_uv_conversion(), and to_lavc_vid_conv_init().

Here is the call graph for this function:

y416_to_i444()

void y416_to_i444	(	int	width,
		int	height,
		const unsigned char *	in,
		unsigned char *	out,
		int	depth )

Definition at line 963 of file video_codec.c.

{
        const uint16_t *inp    = (const uint16_t *) (const void *) in;
        uint16_t       *out_y  = (uint16_t *) (void *) out;
        uint16_t       *out_cb = (uint16_t *) (void *) out + width * height;
        uint16_t       *out_cr = (uint16_t *) (void *) out + 2 * width * height;
        for (int y = 0; y < height; ++y) {
                for (int x = 0; x < width; ++x) {
                        *out_cb++ = *inp++ >> (16 - depth);
                        *out_y++  = *inp++ >> (16 - depth);
                        *out_cr++ = *inp++ >> (16 - depth);
                        inp++; // alpha
                }
        }
}

Referenced by save_video_frame_as_y4m().

Variable Documentation

codec_info

const struct codec_info_t codec_info[]

static

Definition at line 121 of file video_codec.c.

                                                {
        [VIDEO_CODEC_NONE] = {"(none)", "Undefined Codec",
                0, 0, 0.0, 0, 0, FALSE, FALSE, FALSE, FALSE, 0, NULL},
        [RGBA] = {"RGBA", "Red Green Blue Alpha 32bit",
                to_fourcc('R','G','B','A'), 4, 1, 1, 8, TRUE, FALSE, FALSE, FALSE, 4444, "rgba"},
        [UYVY] = {"UYVY", "YUV 4:2:2",
                to_fourcc('U','Y','V','Y'), 4, 2, 2, 8, FALSE, FALSE, FALSE, FALSE, 4220, "yuv"},
        [YUYV] = {"YUYV", "YUV 4:2:2",
                to_fourcc('Y','U','Y','V'), 4, 2, 2, 8, FALSE, FALSE, FALSE, FALSE, 4220, "yuv"},
        [R10k] = {"R10k", "10-bit RGB 4:4:4", // called 'R10b' in BMD SDK
                to_fourcc('R','1','0','k'), 4, 1, 64, 10, TRUE, FALSE, FALSE, FALSE, 4440, "r10k"},
        [R12L] = {"R12L", "12-bit packed RGB 4:4:4 little-endian", // SMPTE 268M DPX v1, Annex C, Method C4
                to_fourcc('R','1','2','l'), 36, 8, 8, 12, TRUE, FALSE, FALSE, FALSE, 4440, "r12l"},
        [v210] = {"v210", "10-bit YUV 4:2:2",
                to_fourcc('v','2','1','0'), 16, 6, 48, 10, FALSE, FALSE, FALSE, FALSE, 4220, "v210"},
        [DVS10] = {"DVS10", "Centaurus 10bit YUV 4:2:2",
                to_fourcc('D','S','1','0'), 16, 6, 48, 10, FALSE, FALSE, FALSE, FALSE, 4220, "dvs10"},
        [DXT1] = {"DXT1", "S3 Compressed Texture DXT1",
                to_fourcc('D','X','T','1'), 1, 2, 0, 2, TRUE, TRUE, FALSE, FALSE, 0, "dxt1"},
        [DXT1_YUV] = {"DXT1_YUV", "S3 Compressed Texture DXT1 YUV",
                to_fourcc('D','X','T','Y'), 1, 2, 0, 2, FALSE, TRUE, FALSE, FALSE, 0, "dxt1y"}, /* packet YCbCr inside DXT1 channels */
        [DXT5] = {"DXT5", "S3 Compressed Texture DXT5 YCoCg",
                to_fourcc('D','X','T','5'), 1, 1, 0, 4, FALSE, TRUE, FALSE, FALSE, 0, "yog"},/* DXT5 YCoCg */
        [RGB] = {"RGB", "Red Green Blue 24bit",
                to_fourcc('R','G','B','2'), 3, 1, 1, 8, TRUE, FALSE, FALSE, FALSE, 4440, "rgb"},
        [JPEG] = {"JPEG",  "JPEG",
                to_fourcc('J','P','E','G'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "jpg"},
        [RAW] = {"raw", "Raw SDI video",
                to_fourcc('r','a','w','s'), 1, 1, 0, 0, FALSE, TRUE, FALSE, FALSE, 0, "raw"}, /* raw SDI */
        [H264] = {"H.264", "H.264/AVC",
                to_fourcc('A','V','C','1'), 1, 1, 0, 8, FALSE, TRUE, TRUE, FALSE, 0, "h264"},
        [H265] = {"H.265", "H.265/HEVC",
                to_fourcc('H','E','V','C'), 1, 1, 0, 8, FALSE, TRUE, TRUE, FALSE, 0, "h265"},
        [MJPG] = {"MJPEG", "MJPEG",
                to_fourcc('M','J','P','G'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "jpg"},
        [VP8] = {"VP8", "Google VP8",
                to_fourcc('V','P','8','0'), 1, 1, 0, 8, FALSE, TRUE, TRUE, FALSE, 0, "vp8"},
        [VP9] = {"VP9", "Google VP9",
                to_fourcc('V','P','9','0'), 1, 1, 0, 8, FALSE, TRUE, TRUE, FALSE, 0, "vp9"},
        [BGR] = {"BGR", "Blue Green Red 24bit",
                to_fourcc('B','G','R','2'), 3, 1, 1, 8, TRUE, FALSE, FALSE, FALSE, 4440, "bgr"},
        [J2K] = {"J2K", "JPEG 2000",
                to_fourcc('M','J','2','C'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "j2k"},
        [J2KR] = {"J2KR", "JPEG 2000 RGB",
                to_fourcc('M','J','2','R'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "j2k"},
        [HW_VDPAU] = {"HW_VDPAU", "VDPAU hardware surface",
                to_fourcc('V', 'D', 'P', 'S'), HW_VDPAU_FRAME_SZ, 1, 0, 8, FALSE, TRUE, FALSE, TRUE, 4440, "vdpau"},
        [HFYU] = {"HFYU", "HuffYUV",
                to_fourcc('H','F','Y','U'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "hfyu"},
        [FFV1] = {"FFV1", "FFV1",
                to_fourcc('F','F','V','1'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "ffv1"},
        [CFHD] = {"CFHD", "Cineform",
                to_fourcc('C','F','H','D'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "cfhd"},
        [RG48] = {"RG48", "16-bit RGB little-endian",
                to_fourcc('R','G','4','8'), 6, 1, 1, 16, TRUE, FALSE, FALSE, FALSE, 4440, "rg48"},
        [AV1] =  {"AV1", "AOMedia Video 1",
                to_fourcc('a','v','0','1'), 1, 1, 0, 8, FALSE, TRUE, TRUE, FALSE, 0, "av1"},
        [I420] =  {"I420", "planar YUV 4:2:0",
                to_fourcc('I','4','2','0'), 3, 2, 2, 8, FALSE, FALSE, FALSE, FALSE, 4200, "yuv"},
        [Y216] =  {"Y216", "Packed 16-bit YUV 4:2:2 little-endian",
                to_fourcc('Y','2','1','6'), 8, 2, 2, 16, FALSE, FALSE, FALSE, FALSE, 4220, "y216"},
        [Y416] =  {"Y416", "Packed 16-bit YUV 4:4:4:4 little-endian",
                to_fourcc('Y','4','1','6'), 8, 1, 1, 16, FALSE, FALSE, FALSE, FALSE, 4444, "y416"},
        [PRORES] =  {"PRORES", "Apple ProRes",
                0, 1, 1, 0, 8, FALSE, TRUE, TRUE, FALSE, 0, "pror"},
        [PRORES_4444] =  {"PRORES_4444", "Apple ProRes 4444",
                to_fourcc('a','p','4','h'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "ap4h"},
        [PRORES_4444_XQ] =  {"PRORES_4444_XQ", "Apple ProRes 4444 (XQ)",
                to_fourcc('a','p','4','x'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "ap4x"},
        [PRORES_422_HQ] =  {"PRORES_422_HQ", "Apple ProRes 422 (HQ)",
                to_fourcc('a','p','c','h'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "apch"},
        [PRORES_422] =  {"PRORES_422", "Apple ProRes 422",
                to_fourcc('a','p','c','n'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "apcn"},
        [PRORES_422_PROXY] =  {"PRORES_422_PROXY", "Apple ProRes 422 (Proxy)",
                to_fourcc('a','p','c','o'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "apco"},
        [PRORES_422_LT] =  {"PRORES_422_LT", "Apple ProRes 422 (LT)",
                to_fourcc('a','p','c','s'), 1, 1, 0, 8, FALSE, TRUE, FALSE, FALSE, 0, "apcs"},
        [DRM_PRIME] = {"DRM_PRIME", "DRM Prime buffer",
                to_fourcc('D', 'R', 'M', 'P'), sizeof(struct drm_prime_frame), 1, 0, 8, FALSE, TRUE, FALSE, TRUE, 0, "drm_prime"},
};

Referenced by codec_is_a_rgb(), codec_is_const_size(), get_bits_per_component(), get_bpp(), get_cineform_module_info(), get_cmpto_j2k_module_info(), get_codec_file_extension(), get_codec_from_fcc(), get_codec_from_file_extension(), get_codec_from_name_wo_alias(), get_codec_name(), get_codec_name_long(), get_fourcc(), get_pf_block_bytes(), get_pf_block_pixels(), get_pixfmt_desc(), get_subsampling(), is_codec_interframe(), is_codec_opaque(), show_codec_help(), vc_get_linesize(), and vc_get_size().

codec_name_aliases

const struct alternative_codec_name codec_name_aliases[]

static

Initial value:

= {
        {"2vuy", "UYVY"},
        {"AVC", "H.264"},
        {"H264", "H.264"},
        {"HEVC", "H.265"},
}

Definition at line 243 of file video_codec.c.

                                                                  {
        {"2vuy", "UYVY"},
        {"AVC", "H.264"},
        {"H264", "H.264"},
        {"HEVC", "H.265"},
};

Referenced by get_codec_from_name().

fourcc_aliases

const struct alternative_fourcc fourcc_aliases[]

static

Initial value:

= {
        
        {to_fourcc('A', 'B', 'G', 'R'), to_fourcc('R', 'G', 'B', 'A')},
        {to_fourcc('2', 'B', 'G', 'R'), to_fourcc('R', 'G', 'B', '2')},
        
        {to_fourcc('M', 'J', 'P', 'G'), to_fourcc('J', 'P', 'E', 'G')},
 
        {to_fourcc('2', 'V', 'u', 'y'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('2', 'v', 'u', 'y'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('d', 'v', 's', '8'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('D', 'V', 'S', '8'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('y', 'u', 'v', '2'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('y', 'u', 'V', '2'), to_fourcc('U', 'Y', 'V', 'Y')},
}

This array contains FourCC aliases mapping

Definition at line 223 of file video_codec.c.

                                                          {
        // the following two are here because it was sent with wrong endiannes in past
        {to_fourcc('A', 'B', 'G', 'R'), to_fourcc('R', 'G', 'B', 'A')},
        {to_fourcc('2', 'B', 'G', 'R'), to_fourcc('R', 'G', 'B', '2')},
        // following ones are rather for further compatibility (proposed codecs rename)
        {to_fourcc('M', 'J', 'P', 'G'), to_fourcc('J', 'P', 'E', 'G')},
 
        {to_fourcc('2', 'V', 'u', 'y'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('2', 'v', 'u', 'y'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('d', 'v', 's', '8'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('D', 'V', 'S', '8'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('y', 'u', 'v', '2'), to_fourcc('U', 'Y', 'V', 'Y')},
        {to_fourcc('y', 'u', 'V', '2'), to_fourcc('U', 'Y', 'V', 'Y')},
};

Referenced by get_codec_from_fcc().

pixfmt_conv_pref

char pixfmt_conv_pref[] = "dsc"

bitdepth, subsampling, color space

Definition at line 80 of file video_codec.c.

Referenced by compare_pixdesc(), and set_pixfmt_conv_policy().

pixfmt_plane_info

const struct pixfmt_plane_info_t pixfmt_plane_info[]

static

Initial value:

= {
        [I420] = {{1, 1, 2, 2, 2, 2, 0, 0}},
        [VIDEO_CODEC_END] = {{0}}, 
}

Definition at line 207 of file video_codec.c.

                                                              {
        [I420] = {{1, 1, 2, 2, 2, 2, 0, 0}},
        [VIDEO_CODEC_END] = {{0}}, // end must be present to all codecs to have the metadata defined
};

Referenced by codec_get_planes_subsampling(), codec_is_420(), and codec_is_planar().