vf_split.cpp File Reference

#include <stdio.h>
#include <string.h>
#include "utils/vf_split.h"
#include "video.h"
#include "video_codec.h"

Include dependency graph for vf_split.cpp:

Go to the source code of this file.

Functions
shared_ptr< video_frame >	vf_merge_tiles (std::vector< shared_ptr< video_frame > > const &tiles)
vector< shared_ptr< video_frame > >	vf_separate_tiles (shared_ptr< video_frame > frame)
void	vf_split (struct video_frame *out, struct video_frame *src, unsigned int x_count, unsigned int y_count, int preallocate)

Detailed Description

Author

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

Definition in file vf_split.cpp.

Function Documentation

vf_merge_tiles()

shared_ptr< video_frame > vf_merge_tiles

(

std::vector< shared_ptr< video_frame > > const &

tiles

)

Definition at line 135 of file vf_split.cpp.

{
        struct video_desc desc = video_desc_from_frame(tiles[0].get());
        desc.tile_count = tiles.size();
 
        auto holder = new decay<decltype(tiles)>::type(tiles);
        shared_ptr<video_frame> ret(vf_alloc_desc(desc),
                        [holder](struct video_frame *frame) {
                                delete holder;
                                vf_free(frame);
                        });
 
        int64_t t0 = INT64_MAX;
        int64_t t1 = 0;
        for (unsigned int i = 0; i < tiles.size(); ++i) {
                ret->tiles[i].data = tiles[i]->tiles[0].data;
                ret->tiles[i].data_len = tiles[i]->tiles[0].data_len;
                t0 = tiles[i]->compress_start < t0 ? tiles[i]->compress_start : t0;
                t1 = tiles[i]->compress_end > t1 ? tiles[i]->compress_end : t1;
        }
        vf_copy_metadata(ret.get(), tiles.at(0).get());
        ret->compress_start = t0;
        ret->compress_end = t1;
 
        return ret;
}

References desc, frame, video_desc::tile_count, type, vf_alloc_desc(), vf_copy_metadata(), vf_free(), and video_desc_from_frame().

Referenced by compress_frame_tiles().

Here is the call graph for this function:

vf_separate_tiles()

vector< shared_ptr< video_frame > > vf_separate_tiles

(

shared_ptr< video_frame >

frame

)

Definition at line 114 of file vf_split.cpp.

{
        vector<shared_ptr<video_frame>> ret(frame->tile_count);
        struct video_desc desc = video_desc_from_frame(frame.get());
        desc.tile_count = 1;
 
        for (unsigned int i = 0; i < frame->tile_count; ++i) {
                auto holder = new shared_ptr<video_frame>(frame);
                ret[i] = shared_ptr<video_frame>(vf_alloc_desc(desc), [holder](struct video_frame *frame) {
                        delete holder;
                        vf_free(frame);
                });
 
                ret[i]->tiles[0].data_len = frame->tiles[i].data_len;
                ret[i]->tiles[0].data = frame->tiles[i].data;
                vf_copy_metadata(ret[i].get(), frame.get());
        }
 
        return ret;
}

References tile::data, tile::data_len, desc, frame, video_desc::tile_count, video_frame::tile_count, video_frame::tiles, vf_alloc_desc(), vf_copy_metadata(), vf_free(), and video_desc_from_frame().

Referenced by compress_frame(), and compress_frame_tiles().

Here is the call graph for this function:

vf_split()

void vf_split	(	struct video_frame *	out,
		struct video_frame *	src,
		unsigned int	x_count,
		unsigned int	y_count,
		int	preallocate )

vf_split splits the frame into multiple tiles. Caller is responsible for allocating memory for all of these: out (to hold all elements), out elements and theirs data member to hold tile data.

width must be divisible by x_count && heigth by y_count (!)

Parameters

out	output video frames array the resulting matrix will be stored row-dominant
src	source video frame
x_count	number of columns
y_count	number of rows
preallocate	used for preallocating buffers because determining right size can be cumbersome. Anyway only .data are allocated.

Deprecated

this function should not be used

Definition at line 51 of file vf_split.cpp.

{
        unsigned int        tile_idx, line_idx;
        struct tile        *cur_tiles;
        unsigned int        tile_line = 0;
        int                 out_linesize = 0;
        int                 src_linesize;
 
        out->color_spec = src->color_spec;
        out->fps = src->fps;
        //out->aux = src->aux | AUX_TILED;
 
        assert(vf_get_tile(src, 0)->width % x_count == 0u && vf_get_tile(src, 0)->height % y_count == 0u);
 
        src_linesize = vc_get_linesize(src->tiles[0].width,
                        src->color_spec);
 
        assert(x_count * y_count > 0);
        for(tile_idx = 0u; tile_idx < x_count * y_count; ++tile_idx) {
                out->tiles[tile_idx].width = vf_get_tile(src, 0)->width / x_count;
                out->tiles[tile_idx].height = vf_get_tile(src, 0)->height / y_count;
 
                out_linesize = vc_get_linesize(out->tiles[tile_idx].width,
                                src->color_spec);
                out->tiles[tile_idx].data_len = out_linesize * out->tiles[tile_idx].height;
        }
 
        cur_tiles = &out->tiles[0];
        for(line_idx = 0u; line_idx < vf_get_tile(src, 0)->height; ++line_idx, ++tile_line) {
                unsigned int cur_tile_idx;
                unsigned int byte = 0u;
 
                if (line_idx % (vf_get_tile(src, 0)->height / y_count) == 0u) /* next tiles*/
                {
                        tile_line = 0u;
                        if (line_idx != 0u)
                                cur_tiles += x_count;
                        if (preallocate) {
                                for (cur_tile_idx = 0u; cur_tile_idx < x_count;
                                               ++cur_tile_idx) {
                                        cur_tiles[cur_tile_idx].data = (char *)
                                                malloc(cur_tiles[cur_tile_idx].
                                                                data_len);
                                }
                        }
                }
 
                for(cur_tile_idx = 0u; cur_tile_idx < x_count; ++cur_tile_idx) {
                        memcpy((void *) &cur_tiles[cur_tile_idx].data[
                                        tile_line *
                                        out_linesize],
                                        (void *) &src->tiles[0].data[line_idx *
                                        src_linesize + byte],
                                        cur_tiles[cur_tile_idx].width *
                                        get_bpp(src->color_spec));
                        byte += cur_tiles[cur_tile_idx].width * get_bpp(src->color_spec);
                }
        }
}

References video_frame::color_spec, tile::data, tile::data_len, video_frame::fps, get_bpp(), tile::height, video_frame::tiles, vc_get_linesize(), vf_get_tile(), and tile::width.

Referenced by filter(), and split_postprocess().

Here is the call graph for this function: