#include "types.h"
#include "pixfmt_conv.h"

Include dependency graph for video_codec.h:

Macros
#define	MAX_BPS 8 /* for Y416 */
	maximal (average) number of pixels per know pixel formats (up-round if needed)

#define	MAX_PADDING 64

#define	MAX_PFB_SIZE 8
	maximal pixfmt block size (R12L - 8 B)

#define	PIX_BLOCK_LCM 24
	least common multiple of all pixfmt block sizes in pixels (codec_info_t::block_size/codec_info_t::bpp). "contributors:" 8 R12L, 6 v210

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) __attribute__((const))

bool	codec_is_const_size (codec_t codec) __attribute__((const))

bool	codec_is_hw_accelerated (codec_t codec) __attribute__((const))

bool	codec_is_in_set (codec_t codec, const codec_t *set) __attribute__((pure))

bool	codec_is_planar (codec_t codec) __attribute__((const))

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) __attribute__((const))

double	get_bpp (codec_t codec) __attribute__((const))

const char *	get_codec_file_extension (codec_t codec) __attribute__((const))

codec_t	get_codec_from_fcc (uint32_t fourcc) __attribute__((const))

codec_t	get_codec_from_file_extension (const char *ext) __attribute__((const))

codec_t	get_codec_from_name (const char *name) __attribute__((const))

const char *	get_codec_name (codec_t codec) __attribute__((const))

const char *	get_codec_name_long (codec_t codec) __attribute__((const))

uint32_t	get_fourcc (codec_t codec) __attribute__((const))

int	get_pf_block_bytes (codec_t codec) __attribute__((const))

int	get_pf_block_pixels (codec_t codec) __attribute__((const))

const char *	get_pixdesc_desc (struct pixfmt_desc)

struct pixfmt_desc	get_pixfmt_desc (codec_t pixfmt)

int	get_subsampling (codec_t codec) __attribute__((const))

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) __attribute__((const))

bool	is_codec_opaque (codec_t codec) __attribute__((const))

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) __attribute__((const))

int	vc_get_linesize (unsigned int width, codec_t codec) __attribute__((const))

int	vc_get_size (unsigned int width, codec_t codec) __attribute__((const))

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)

Detailed Description

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

Definition in file video_codec.h.

Macro Definition Documentation

◆ MAX_BPS

#define MAX_BPS 8 /* for Y416 */

maximal (average) number of pixels per know pixel formats (up-round if needed)

Definition at line 62 of file video_codec.h.

Referenced by benchmark(), decompress_thread(), and display_ndi_reconfigure().

◆ MAX_PADDING

#define MAX_PADDING 64

maximal padding in bytes that may be needed to align to pixfmt block size for Y416->R12L: 64 = vc_linesize(8 /*maximal block pix count (R12L)*‍/, Y416 /*codec with maximal lenght of 1st arg-sized block*‍/)

Definition at line 63 of file video_codec.h.

Referenced by interlaced_video_pattern_generator::interlaced_video_pattern_generator(), benchmark(), display_ndi_reconfigure(), do_av_to_uv_convert(), filter(), filter(), video_frame_pool::impl::get_frame(), to_lavc_vid_conv_init(), vf_alloc_desc_data(), and vidcap_testcard2_thread().

◆ MAX_PFB_SIZE

#define MAX_PFB_SIZE 8

maximal pixfmt block size (R12L - 8 B)

Definition at line 65 of file video_codec.h.

◆ PIX_BLOCK_LCM

#define PIX_BLOCK_LCM 24

least common multiple of all pixfmt block sizes in pixels (codec_info_t::block_size/codec_info_t::bpp). "contributors:" 8 R12L, 6 v210

Definition at line 66 of file video_codec.h.

Referenced by get_packet_sizes().

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 ) const

◆ codec_is_const_size()

bool codec_is_const_size ( codec_t codec ) const

◆ codec_is_hw_accelerated()

bool codec_is_hw_accelerated ( codec_t codec ) const

◆ 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 ) const

◆ 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 ) const

Returns: number of bits per color component

◆ get_bpp()

double get_bpp ( codec_t codec ) const

Returns: number of bytes per pixel

◆ get_codec_file_extension()

const char * get_codec_file_extension ( codec_t codec ) const

◆ get_codec_from_fcc()

codec_t get_codec_from_fcc ( uint32_t fourcc ) const

◆ get_codec_from_file_extension()

codec_t get_codec_from_file_extension ( const char * ext ) const

◆ get_codec_from_name()

codec_t get_codec_from_name ( const char * name ) const

◆ get_codec_name()

const char * get_codec_name ( codec_t codec ) const

◆ get_codec_name_long()

const char * get_codec_name_long ( codec_t codec ) const

◆ get_fourcc()

uint32_t get_fourcc ( codec_t codec ) const

◆ get_pf_block_bytes()

int get_pf_block_bytes ( codec_t codec ) const

◆ get_pf_block_pixels()

int get_pf_block_pixels ( codec_t codec ) const

◆ 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 ) const

◆ 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 ) const

◆ is_codec_opaque()

bool is_codec_opaque ( codec_t codec ) const

◆ 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 ) const

◆ vc_get_linesize()

int vc_get_linesize	(	unsigned int	width,
		codec_t	codec ) const

◆ vc_get_size()

int vc_get_size	(	unsigned int	width,
		codec_t	codec ) const

◆ 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().

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ MAX_BPS

◆ MAX_PADDING

◆ MAX_PFB_SIZE

◆ PIX_BLOCK_LCM

Function Documentation

◆ clear_video_buffer()

◆ codec_get_planes_subsampling()

◆ codec_is_420()

◆ codec_is_a_rgb()

◆ codec_is_const_size()

◆ codec_is_hw_accelerated()

◆ codec_is_in_set()

◆ codec_is_planar()

◆ compare_pixdesc()

◆ get_bits_per_component()

◆ get_bpp()

◆ get_codec_file_extension()

◆ get_codec_from_fcc()

◆ get_codec_from_file_extension()

◆ get_codec_from_name()

◆ get_codec_name()

◆ get_codec_name_long()

◆ get_fourcc()

◆ get_pf_block_bytes()

◆ get_pf_block_pixels()

◆ get_pixdesc_desc()

◆ get_pixfmt_desc()

◆ get_subsampling()

◆ i420_16_to_y416()

◆ i420_8_to_uyvy()

◆ i422_16_to_y416()

◆ i422_8_to_uyvy()

◆ i444_16_to_y416()

◆ i444_8_to_uyvy()

◆ is_codec_interframe()

◆ is_codec_opaque()

◆ pixdesc_equals()

◆ show_codec_help()

◆ uyvy_to_i422()

◆ vc_deinterlace()

◆ vc_deinterlace_ex()

◆ vc_get_datalen()

◆ vc_get_linesize()

◆ vc_get_size()

◆ watch_pixfmt_degrade()

◆ y416_to_i444()