ipc_frame_ug.h File Reference

#include "ipc_frame.h"
#include "types.h"

Include dependency graph for ipc_frame_ug.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
bool	ipc_frame_from_ug_frame (struct Ipc_frame *dst, const struct video_frame *src, codec_t codec, unsigned scale_factor)
	Make an ipc frame from ultragrid frame.
bool	ipc_frame_from_ug_frame_hq (struct Ipc_frame *dst, const struct video_frame *src, codec_t codec, unsigned scale_factor)
	Same as ipc_frame_from_ug_frame, but convert pixfmt first and scale later.
int	ipc_frame_get_scale_factor (int src_w, int src_h, int target_w, int target_h)
bool	ipc_frame_write_to_fd (const struct Ipc_frame *f, int fd)

Function Documentation

ipc_frame_from_ug_frame()

bool ipc_frame_from_ug_frame	(	struct Ipc_frame *	dst,
		const struct video_frame *	src,
		codec_t	codec,
		unsigned	scale_factor )

Make an ipc frame from ultragrid frame.

Data is copied, src frame can be freed afterwards.

Parameters

[out]	dst	destination ipc frame
[in]	src	source ultragrid frame
[in]	codec	codec to convert into, VIDEO_CODEC_NONE for no conversion
[in]	scale_factor	frame dimensions are divided by this amount. 0 for original size

Definition at line 107 of file ipc_frame_ug.cpp.

{
        if(!src)
                return false;
 
        decoder_t dec = nullptr;
        if(codec != VIDEO_CODEC_NONE){
                dec = get_decoder_from_to(src->color_spec, codec);
                if(!dec){
                        return false;
                }
        } else {
                codec = src->color_spec;
                dec = vc_memcpy;
        }
 
        dst->header.width = src->tiles[0].width;
        dst->header.height = src->tiles[0].height;
        dst->header.color_spec = static_cast<Ipc_frame_color_spec>(codec);
 
        int dst_frame_to_allocate = 0;
 
        if(scale_factor != 0){
                int block_size_px = get_pf_block_pixels(src->color_spec);
                int block_count = (dst->header.width + block_size_px - 1) / block_size_px;
                dst->header.width = (block_count / scale_factor) * block_size_px;
                dst->header.height /= scale_factor;
 
                if(dec != vc_memcpy){
                        //When both scaling and converting we need a tmp space - allocate extra
                        dst_frame_to_allocate += vc_get_linesize(dst->header.width, src->color_spec) * dst->header.height;
                }
        }
 
        int dst_frame_size = get_bpp(codec) * dst->header.width * dst->header.height;
        dst_frame_to_allocate += dst_frame_size;
 
        if(!ipc_frame_reserve(dst, dst_frame_to_allocate))
                return false;
 
        dst->header.data_len = dst_frame_size;
 
        char *scale_dst = dst->data;
        unsigned char *dec_dst = (unsigned char *) dst->data;
        unsigned char *dec_src = (unsigned char *) src->tiles[0].data;
 
        if(scale_factor != 0){
                if(dec != vc_memcpy){
                        scale_dst = dst->data + dst_frame_size;
                }
                dec_src = (unsigned char *) scale_dst;
 
                scale_frame(scale_dst, src->tiles[0].data,
                                src->tiles[0].width, src->tiles[0].height,
                                scale_factor, src->color_spec);
 
        }
 
 
        if(dec_src == dec_dst){
                assert(dec == vc_memcpy);
                return true;
        }
 
        int dst_line_len = vc_get_linesize(dst->header.width, codec);
        int src_line_len = vc_get_linesize(dst->header.width, src->color_spec);
        for(int i = 0; i < dst->header.height; i++){
                dec(dec_dst + dst_line_len * i,
                                dec_src + src_line_len * i,
                                dst_line_len,
                                0, 8, 16);
        }
 
        return true;
}

References Ipc_frame_header::color_spec, video_frame::color_spec, Ipc_frame::data, tile::data, Ipc_frame_header::data_len, get_bpp(), get_decoder_from_to(), get_pf_block_pixels(), Ipc_frame::header, Ipc_frame_header::height, tile::height, ipc_frame_reserve(), video_frame::tiles, vc_get_linesize(), vc_memcpy, VIDEO_CODEC_NONE, Ipc_frame_header::width, and tile::width.

Here is the call graph for this function:

ipc_frame_from_ug_frame_hq()

bool ipc_frame_from_ug_frame_hq	(	struct Ipc_frame *	dst,
		const struct video_frame *	src,
		codec_t	codec,
		unsigned	scale_factor )

Same as ipc_frame_from_ug_frame, but convert pixfmt first and scale later.

Definition at line 41 of file ipc_frame_ug.cpp.

{
        assert(codec == RGB);
 
        if(!src)
                return false;
 
        decoder_t dec = get_decoder_from_to(src->color_spec, codec);
        if(!dec){
                return false;
        }
 
        dst->header.width = src->tiles[0].width;
        dst->header.height = src->tiles[0].height;
        dst->header.color_spec = static_cast<Ipc_frame_color_spec>(codec);
 
        if(scale_factor != 0){
                int block_size_px = get_pf_block_pixels(codec);
                int block_count = (dst->header.width + block_size_px - 1) / block_size_px;
                dst->header.width = (block_count / scale_factor) * block_size_px;
                dst->header.height /= scale_factor;
        }
 
        int dst_frame_size = get_bpp(codec) * dst->header.width * dst->header.height;
        if(!ipc_frame_reserve(dst, dst_frame_size))
                return false;
 
        dst->header.data_len = dst_frame_size;
 
        char *scale_src = nullptr;
        std::vector<unsigned char> rgb_frame;
 
        if(dec == vc_memcpy)
                scale_src = src->tiles[0].data;
        else{
                auto rgb_line_len = vc_get_linesize(src->tiles[0].width, codec);
                unsigned char *dec_dst = nullptr;
                if(scale_factor != 0){
                        rgb_frame.resize(rgb_line_len * src->tiles[0].height);
                        scale_src = (char *) rgb_frame.data();
                        dec_dst = (unsigned char *) scale_src;
                } else {
                        dec_dst = (unsigned char *) dst->data;
                }
 
                for(unsigned i = 0; i < src->tiles[0].height; i++){
                        dec(dec_dst + rgb_line_len * i,
                                        (unsigned char *) src->tiles[0].data + vc_get_linesize(src->tiles[0].width, src->color_spec) * i,
                                        rgb_line_len,
                                        0, 8, 16);
                }
        }
 
        if(scale_factor == 0)
                return true;
 
        scale_frame(dst->data, scale_src,
                        src->tiles[0].width, src->tiles[0].height,
                        scale_factor, codec);
 
        return true;
}

References Ipc_frame_header::color_spec, video_frame::color_spec, Ipc_frame::data, tile::data, Ipc_frame_header::data_len, get_bpp(), get_decoder_from_to(), get_pf_block_pixels(), Ipc_frame::header, Ipc_frame_header::height, tile::height, ipc_frame_reserve(), RGB, video_frame::tiles, vc_get_linesize(), vc_memcpy, Ipc_frame_header::width, and tile::width.

Referenced by display_unix_sock_init(), and init().

Here is the call graph for this function:

ipc_frame_get_scale_factor()

int ipc_frame_get_scale_factor	(	int	src_w,
		int	src_h,
		int	target_w,
		int	target_h )

Definition at line 186 of file ipc_frame_ug.cpp.

                                                                                {
        if(target_w== -1 || target_h== -1)
                return 0;
 
        float scale = std::sqrt((static_cast<float>(src_w) * src_h)
                        / (static_cast<float>(target_w) * target_h));
 
        if(scale < 1)
                scale = 1;
 
        return std::round(scale);
}

Referenced by display_unix_sock_run(), and filter().

ipc_frame_write_to_fd()

bool ipc_frame_write_to_fd	(	const struct Ipc_frame *	f,
		int	fd )