video.cpp File Reference

This file defines some common video functions. More...

#include "debug.h"
#include "rtp/rtp_types.h"
#include "utils/macros.h"
#include "video.h"
#include <iomanip>
#include <sstream>
#include <map>

Include dependency graph for video.cpp:

Go to the source code of this file.

Classes
struct	video_mode_info_t

Macros
#define	MOD_NAME   "[video] "

Functions
struct video_desc	get_video_desc_from_string (const char *string)
const char *	get_video_mode_description (enum video_mode video_mode)
enum video_mode	get_video_mode_from_str (const char *requested_mode)
int	get_video_mode_tiles_x (enum video_mode video_mode)
int	get_video_mode_tiles_y (enum video_mode video_mode)
enum video_mode	guess_video_mode (int num_substreams)
	Tries to guess video mode from number of substreams.
std::ostream &	operator<< (std::ostream &os, const codec_t &color_spec)
std::ostream &	operator<< (std::ostream &os, const video_desc &desc)
std::istream &	operator>> (std::istream &is, video_desc &desc)
static double	parse_fps (const char *string, bool interlaced)
const char *	video_desc_to_string (struct video_desc d)

Variables
static const map< enum video_mode, video_mode_info_t >	video_mode_info

Detailed Description

This file defines some common video functions.

Author

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

These function are neither video frame nor video codec related.

Definition in file video.cpp.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[video] "

Definition at line 57 of file video.cpp.

Function Documentation

get_video_desc_from_string()

struct video_desc get_video_desc_from_string

(

const char *

string

)

Returns

video description according to the configuration string, allowing BMD-like FourCC (pal, ntsc, Hi59 etc.)

Definition at line 291 of file video.cpp.

{
        const struct {
                const char *name;
                struct video_desc desc;
        } map[] = {
                {"microvision", { 16, 16, UYVY, 10, PROGRESSIVE, 1 }},
                {"sqcif", { 126, 96, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"qcif", { 176, 144, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"cif", { 352, 288, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"4cif", { 704, 576, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"ntsc", { 720, 480, UYVY, 29.97, INTERLACED_MERGED, 1 }},
                {"pal", { 720, 576, UYVY, 25, INTERLACED_MERGED, 1 }},
                {"cga", { 320, 200, UYVY, 60, PROGRESSIVE, 1 }},
                {"vga", { 640, 480, UYVY, 60, PROGRESSIVE, 1 }},
                {"svga", { 800, 600, UYVY, 60, PROGRESSIVE, 1 }},
                {"xga", { 1024, 768, UYVY, 60, PROGRESSIVE, 1 }},
                {"wxga", { 1280, 768, UYVY, 60, PROGRESSIVE, 1 }},
                {"sxga", { 1280, 1024, UYVY, 60, PROGRESSIVE, 1 }},
                {"uxga", { 1600, 1200, UYVY, 60, PROGRESSIVE, 1 }},
                {"wuxga", { 1920, 1200, UYVY, 60, PROGRESSIVE, 1 }},
                {"23ps", { 1920, 1080, UYVY, 23.98, PROGRESSIVE, 1 }},
                {"24ps", { 1920, 1080, UYVY, 24, PROGRESSIVE, 1 }},
                {"hd", { 1280, 720, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"720p", { 1280, 720, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"fhd", { 1920, 1080, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"1080p", { 1920, 1080, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"uhd", { 3840, 2160, UYVY, 29.97, PROGRESSIVE, 1 }},
                {"dci", { 2048, 1080, UYVY, 23.98, PROGRESSIVE, 1 }},
                {"dci4", { 4096, 2160, UYVY, 23.98, PROGRESSIVE, 1 }},
        };
        if (strcasecmp(string, "help") == 0) {
                printf("Recognized video formats: ");
                for (unsigned i = 0; i < sizeof map / sizeof map[0]; ++i) {
                        color_printf(TBOLD("%s") ", ", map[i].name);
                }
                color_printf(TBOLD("{Hp,Hi,hp,2d,4k,4d,1080i,1080p,720p,2160p}{23,24,25,29,30,59,60}") "\n");
                return {};
 
        }
        for (unsigned i = 0; i < sizeof map / sizeof map[0]; ++i) {
                if (strcasecmp(map[i].name, string) == 0 || (strlen(string) == 4 && string[3] == ' ' && strncasecmp(map[i].name, string, 3) == 0)) {
                        return map[i].desc;
                }
        }
        // BMD-like syntax (+ line-counted syntax like 1080p<FPS>)
        struct video_desc ret{};
        ret.color_spec = UYVY;
        ret.tile_count  = 1;
        if (strncmp(string, "Hp", 2) == 0 || STARTS_WITH(string, "1080p")) {
                ret.width = 1920;
                ret.height = 1080;
        } else if (strncmp(string, "Hi", 2) == 0 ||
                   STARTS_WITH(string, "1080i")) {
                ret.width = 1920;
                ret.height = 1080;
                ret.interlacing = INTERLACED_MERGED;
        } else if (strncmp(string, "hp", 2) == 0 ||
                   STARTS_WITH(string, "720p")) {
                ret.width = 1280;
                ret.height = 720;
        } else if (strncasecmp(string, "2d", 2) == 0) {
                ret.width = 2048;
                ret.height = 1080;
        } else if (strncasecmp(string, "4k", 2) == 0 ||
                   STARTS_WITH(string, "2160p")) {
                ret.width = 3860;
                ret.height = 2160;
        } else if (strncasecmp(string, "4d", 2) == 0) {
                ret.width = 4096;
                ret.height = 2160;
        }
        if (ret.width == 0) {
                MSG(ERROR, "Unrecognized video mode: %s\n", string);
                return {};
        }
        ret.fps = parse_fps(string, ret.interlacing == INTERLACED_MERGED);
        if (ret.fps < .0) {
                return {};
        }
 
        return ret;
}

References color_printf(), video_desc::color_spec, desc, video_desc::fps, video_desc::height, INTERLACED_MERGED, video_desc::interlacing, MSG, name, parse_fps(), PROGRESSIVE, STARTS_WITH, TBOLD, video_desc::tile_count, UYVY, and video_desc::width.

Referenced by vidcap_testcard2_init(), and vidcap_testcard_init().

Here is the call graph for this function:

get_video_mode_description()

const char * get_video_mode_description

(

enum video_mode video_mode

)

Definition at line 118 of file video.cpp.

{
        return video_mode_info.at(video_mode).name;
}

References video_mode_info.

Referenced by decode_video_frame().

get_video_mode_from_str()

enum video_mode get_video_mode_from_str

(

const char *

requested_mode

)

This function matches string representation of video mode with its respective enumeration value.

Parameters

reuqested_mode

textual representation of video mode

Returns

valid member of enum video mode

Definition at line 83 of file video.cpp.

                                                                    {
        if(strcasecmp(requested_mode, "help") == 0) {
                printf("Video mode options:\n");
                auto it = video_mode_info.begin();
                while (it != video_mode_info.end()) {
                        if (it == video_mode_info.begin()) { // omit unknown
                                ++it;
                                continue;
                        }
                        printf("\t%s\n", it->second.name);
                        if (++it != video_mode_info.end()) {
                        }
                }
                return VIDEO_UNKNOWN;
        } else {
                for (auto const &it : video_mode_info) {
                        if (strcasecmp(requested_mode, it.second.name) == 0) {
                                return it.first;
                        }
                }
                fprintf(stderr, "Unknown video mode (see -M help)\n");
                return VIDEO_UNKNOWN;
        }
}

References video_mode_info, and VIDEO_UNKNOWN.

Referenced by parse_options_internal().

get_video_mode_tiles_x()

int get_video_mode_tiles_x

(

enum video_mode video_mode

)

Definition at line 108 of file video.cpp.

{
        return video_mode_info.at(video_mode).x;
}

References video_mode_info, and video_mode_info_t::x.

Referenced by decoder_set_video_mode(), decompress_thread(), display_reconfigure(), fec_thread(), and reconfigure_decoder().

get_video_mode_tiles_y()

int get_video_mode_tiles_y

(

enum video_mode video_mode

)

Definition at line 113 of file video.cpp.

{
        return video_mode_info.at(video_mode).y;
}

References video_mode_info.

Referenced by decoder_set_video_mode(), decompress_thread(), display_reconfigure(), fec_thread(), and reconfigure_decoder().

guess_video_mode()

enum video_mode guess_video_mode

(

int

num_substreams

)

Tries to guess video mode from number of substreams.

Note

The guessed video mode may not be correct (some modes may have the same number of substreams).

Parameters

num_substreams

number of received substreams

Returns

guessed video mode

Return values

VIDEO_UNKNOWN

if the mode was not guessed.

Definition at line 123 of file video.cpp.

{
        assert(num_substreams > 0);
 
        switch (num_substreams) {
                case 1:
                        return VIDEO_NORMAL;
                case 2:
                        return VIDEO_STEREO;
                case 3:
                        return VIDEO_3X1;
                case 4:
                        return VIDEO_4K;
                default:
                        return VIDEO_UNKNOWN;
        }
}

References VIDEO_3X1, VIDEO_4K, VIDEO_NORMAL, VIDEO_STEREO, and VIDEO_UNKNOWN.

Referenced by decode_video_frame().

operator<<() [1/2]

std::ostream & operator<<	(	std::ostream &	os,
		const codec_t &	color_spec )

Definition at line 157 of file video.cpp.

{
        os << get_codec_name(color_spec);
        return os;
}

References get_codec_name().

Here is the call graph for this function:

operator<<() [2/2]

std::ostream & operator<<	(	std::ostream &	os,
		const video_desc &	desc )

Definition at line 141 of file video.cpp.

{
        std::streamsize p = os.precision();
        ios_base::fmtflags f = os.flags();
        if (desc.tile_count > 1) {
                os << desc.tile_count << "*";
        }
        os << desc.width << "x" << desc.height << " @" << setprecision(2) << setiosflags(ios_base::fixed)
                << desc.fps * (desc.interlacing == PROGRESSIVE || desc.interlacing == SEGMENTED_FRAME ? 1 : 2)
                << get_interlacing_suffix(desc.interlacing) << ", codec "
                << get_codec_name(desc.color_spec);
        os.precision(p);
        os.flags(f);
        return os;
}

References video_desc::color_spec, desc, video_desc::fps, get_codec_name(), get_interlacing_suffix(), video_desc::height, video_desc::interlacing, PROGRESSIVE, SEGMENTED_FRAME, video_desc::tile_count, and video_desc::width.

Here is the call graph for this function:

operator>>()

std::istream & operator>>	(	std::istream &	is,
		video_desc &	desc )

Todo

regex matching would be better

Definition at line 163 of file video.cpp.

{
        video_desc out;
        char buf[1024];
        char *line = buf;
 
        char interl_suffix[4] = "";
        char codec_name[11] = "";
 
        out.tile_count = 1;
 
        unsigned int i = 0;
        int num_spaces = 0;
        while (is.good() && i < sizeof buf - 1) {
                char c;
                is.get(c);
                if (!is.good()) {
                        break;
                }
                if (num_spaces == 3 &&
                                !(isalnum(c) || c == '.')) // allowed symbols in codec name
                {
                        is.unget();
                        break;
                } else {
                        buf[i++] = c;
                }
                if (c == ' ') {
                        num_spaces += 1;
                }
        }
        buf[i] = '\0';
 
        if (strchr(line, '*')) {
                out.tile_count = atoi(line);
                line = strchr(line, '*') + 1;
        }
        int ret = sscanf(line, "%dx%d @%lf%3[a-z], codec %10s", &out.width, &out.height,
                &out.fps, interl_suffix, codec_name);
 
        if (ret != 5) {
                is.setstate(std::ios::failbit);
                log_msg(LOG_LEVEL_ERROR, "Malformed video_desc representation!\n");
                return is;
        }
 
        out.color_spec = get_codec_from_name(codec_name);
        out.interlacing = get_interlacing_from_suffix(interl_suffix);
        out.fps = out.fps / (out.interlacing == PROGRESSIVE || out.interlacing == SEGMENTED_FRAME ? 1 : 2);
        desc = out;
        return is;
}

References video_desc::color_spec, desc, video_desc::fps, get_codec_from_name(), get_interlacing_from_suffix(), video_desc::height, video_desc::interlacing, LOG_LEVEL_ERROR, log_msg(), PROGRESSIVE, SEGMENTED_FRAME, video_desc::tile_count, and video_desc::width.

Here is the call graph for this function:

parse_fps()

static double parse_fps ( const char * string, bool interlaced )

static

Return values

0.0	FPS not specified
<0.0	wrong FPS specification

Definition at line 253 of file video.cpp.

{
        const char *fps_str = strpbrk(string, "DKdikp");
        assert(fps_str != nullptr);
        fps_str += 1;
        if (strlen(fps_str) == 0) {
                return 0.0;
        }
        char      *endptr = nullptr;
        const long fps_l  = strtol(fps_str, &endptr, 10);
        if (fps_l <= 0 || fps_l > FPS_MAX || *endptr != '\0') {
                MSG(ERROR, "Wrong mode FPS specification: %s\n", string);
                return -1;
        }
        double fps = 0;
        // adjust FPS (Hi29 has FPS 29.97)
        switch (fps_l) {
        case 23:
                fps = 23.98;
                break;
        case 29:
                fps = 29.97;
                break;
        case 59:
                fps = 59.94;
                break;
        default:
                fps = (double) fps_l;
                break;
        }
        // convert field per sec to FPS if needed (interlaced)
        return interlaced ? fps / 2.0 : fps;
}

References FPS_MAX, and MSG.

Referenced by get_video_desc_from_string(), init(), parse_fmt(), parse_format(), vidcap_testcard2_init(), and vidcap_testcard_init().

video_desc_to_string()

const char * video_desc_to_string

(

struct video_desc

d

)

Definition at line 241 of file video.cpp.

{
        thread_local string desc_str;
        desc_str = d;
        return desc_str.c_str();
}

Referenced by display_reconfigure(), show_help(), vidcap_file_init(), vidcap_testcard_init(), and worker().

Variable Documentation

video_mode_info

const map<enum video_mode, video_mode_info_t> video_mode_info

static

Initial value:

= {
        { VIDEO_UNKNOWN, { "(unknown)", 0, 0 }},
        { VIDEO_NORMAL, { "normal", 1, 1 }},
        { VIDEO_DUAL, { "dual-link", 1, 2 }},
        { VIDEO_STEREO, { "3D", 2, 1 }},
        { VIDEO_4K, { "tiled-2x2", 2, 2 }},
        { VIDEO_3X1, { "3x1", 3, 1 }},
}

Definition at line 67 of file video.cpp.

                                                                       {
        { VIDEO_UNKNOWN, { "(unknown)", 0, 0 }},
        { VIDEO_NORMAL, { "normal", 1, 1 }},
        { VIDEO_DUAL, { "dual-link", 1, 2 }},
        { VIDEO_STEREO, { "3D", 2, 1 }},
        { VIDEO_4K, { "tiled-2x2", 2, 2 }},
        { VIDEO_3X1, { "3x1", 3, 1 }},
};

Referenced by get_video_mode_description(), get_video_mode_from_str(), get_video_mode_tiles_x(), and get_video_mode_tiles_y().