video_compress.cpp File Reference

Video compress functions. More...

#include <cassert>
#include <cinttypes>
#include <cstdio>
#include <cstring>
#include <memory>
#include <string>
#include <thread>
#include <vector>
#include "messaging.h"
#include "module.h"
#include "tv.h"
#include "utils/synchronized_queue.h"
#include "utils/thread.h"
#include "utils/vf_split.h"
#include "utils/worker.h"
#include "video.h"
#include "video_compress.h"
#include "lib_common.h"
#include "debug.h"

Include dependency graph for video_compress.cpp:

Go to the source code of this file.

Classes
struct	compress_state
	Video compress state. More...
struct	compress_worker_data
	Auxiliary structure passed to worker thread. More...

Macros
#define	MOD_NAME   "[vcompress] "

Functions
static void	async_poison (struct compress_state_real *s)
static bool	check_state_count (unsigned tile_count, struct compress_state *proxy)
void	compress_done (struct compress_state *proxy)
	Video compression cleanup function.
void	compress_frame (struct compress_state *proxy, shared_ptr< video_frame > frame)
int	compress_init (struct module *parent, const char *config_string, struct compress_state **state)
	This function initializes video compression.
shared_ptr< video_frame >	compress_pop (struct compress_state *proxy)
static void	compress_process_message (struct compress_state *proxy, struct msg_change_compress_data *data)
	Processes message.
void	show_compress_help (bool full)
	Displays list of available compressions.
Tile API Routines
The worker callbacks here are optimization - all tiles are processed concurrently.
static shared_ptr< video_frame >	compress_frame_tiles (struct compress_state *proxy, shared_ptr< video_frame > frame)
static void *	compress_tile_callback (void *arg)
	This function is callback passed to a "thread pool".

Detailed Description

Video compress functions.

Author

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

Definition in file video_compress.cpp.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[vcompress] "

Definition at line 62 of file video_compress.cpp.

Function Documentation

async_poison()

static void async_poison ( struct compress_state_real * s )

static

Definition at line 117 of file video_compress.cpp.

                                                       {
        if (s->funcs->compress_frame_async_push_func) {
                s->funcs->compress_frame_async_push_func(s->state[0], {}); // poison
        } else if (s->funcs->compress_tile_async_push_func){
                for(size_t i = 0; i < s->state.size(); i++){
                        s->funcs->compress_tile_async_push_func(s->state[i], {}); // poison
                }
        }
}

References video_compress_info::compress_frame_async_push_func, and video_compress_info::compress_tile_async_push_func.

Referenced by compress_frame(), and compress_process_message().

check_state_count()

static bool check_state_count ( unsigned tile_count, struct compress_state * proxy )

static

Checks if there are at least as many states as there are tiles. If there are not enough states it initializes new ones.

Parameters

	proxy	compress state
[in]	frame	uncompressed frame

Returns

false in case of failure

Definition at line 287 of file video_compress.cpp.

{
        struct compress_state_real *s = proxy->ptr;
 
        if(tile_count != s->state.size()) {
                size_t old_size = s->state.size();
                s->state.resize(tile_count);
                for (unsigned int i = old_size; i < s->state.size(); ++i) {
                        s->state[i] = s->funcs->init_func(&proxy->mod, s->compress_options.c_str());
                        if(!s->state[i]) {
                                LOG(LOG_LEVEL_ERROR) << MOD_NAME
                                    "Compression initialization failed\n";
                                return false;
                        }
                }
        }
        return true;
}

References video_compress_info::init_func, LOG, LOG_LEVEL_ERROR, compress_state::mod, MOD_NAME, and compress_state::ptr.

Referenced by compress_frame(), and compress_frame_tiles().

compress_frame_tiles()

static shared_ptr< video_frame > compress_frame_tiles ( struct compress_state * proxy, shared_ptr< video_frame > frame )

static

Compresses video frame with tiles API

Parameters

	proxy	compress state
[in]	frame	uncompressed frame

Returns

compressed video frame, may be NULL if compression failed

Definition at line 424 of file video_compress.cpp.

{
        struct compress_state_real *s = proxy->ptr;
        const int tile_cnt = (int) proxy->ptr->state.size();
        vector<shared_ptr<video_frame>> separate_tiles;
        if (frame) {
                if (!check_state_count(frame->tile_count, proxy)) {
                        return nullptr;
                }
                separate_tiles = vf_separate_tiles(frame);
        } else {
                separate_tiles.resize(tile_cnt);
        }
 
        // frame pointer may no longer be valid
        frame = NULL;
 
        vector<task_result_handle_t> task_handle(tile_cnt);
 
        vector <compress_worker_data> data_tile(tile_cnt);
        for (int i = 0; i < tile_cnt; ++i) {
                struct compress_worker_data *data = &data_tile[i];
                data->state = s->state[i];
                data->frame = separate_tiles[i];
                data->callback = s->funcs->compress_tile_func;
 
                task_handle[i] = task_run_async(compress_tile_callback, data);
        }
 
        vector<shared_ptr<video_frame>> compressed_tiles(separate_tiles.size());
 
        bool failed = false;
        for(unsigned int i = 0; i < separate_tiles.size(); ++i) {
                struct compress_worker_data *data = (struct compress_worker_data *)
                        wait_task(task_handle[i]);
 
                if(!data->ret) {
                        failed = true;
                }
 
                compressed_tiles[i] = data->ret;
        }
 
        if (failed) {
                return NULL;
        }
 
        return vf_merge_tiles(compressed_tiles);
}

References compress_worker_data::callback, check_state_count(), compress_tile_callback(), video_compress_info::compress_tile_func, compress_worker_data::frame, frame, compress_state::ptr, compress_worker_data::ret, compress_worker_data::state, task_run_async(), video_frame::tile_count, vf_merge_tiles(), vf_separate_tiles(), and wait_task().

Referenced by compress_frame().

Here is the call graph for this function:

compress_process_message()

static void compress_process_message ( struct compress_state * proxy, struct msg_change_compress_data * data )

static

Processes message.

This function is a callback called from control thread to change some parameters of compression.

Parameters

[in]	receiver	pointer to the compress module
[in]	msg	message to process

Todo

Handle responses more inteligently (eg. aggregate).

Definition at line 136 of file video_compress.cpp.

{
        struct response *r = NULL;
        /* In this case we are only changing some parameter of compression.
         * This means that we pass the parameter to compress driver. */
        if(data->what == CHANGE_PARAMS) {
                for(unsigned int i = 0; i < proxy->ptr->state.size(); ++i) {
                        struct msg_change_compress_data *tmp_data =
                                (struct msg_change_compress_data *)
                                new_message(sizeof(struct msg_change_compress_data));
                        tmp_data->what = data->what;
                        strncpy(tmp_data->config_string, data->config_string,
                                        sizeof(tmp_data->config_string));
                        struct response *resp = send_message_to_receiver(proxy->ptr->state[i],
                                        (struct message *) tmp_data);
                        free_response(r); // frees previous response
                        r = resp;
                }
 
        } else {
                struct compress_state_real *new_state;
                char config[1024];
                strncpy(config, data->config_string, sizeof(config));
 
                try {
                        new_state = compress_state_real::create(&proxy->mod, config, proxy);
                } catch (int i) {
                        free_message((struct message *) data,
                                        new_response(RESPONSE_INT_SERV_ERR, NULL));
                        return;
                }
 
                struct compress_state_real *old = proxy->ptr;
                // let the async processing finish
                old->discard_frames = true;
                async_poison(old);
                delete old;
                proxy->ptr = new_state;
                r = new_response(RESPONSE_OK, NULL);
        }
 
        free_message((struct message *) data, r);
}

References async_poison(), CHANGE_PARAMS, msg_change_compress_data::config_string, free_message(), free_response(), compress_state::mod, new_message(), new_response(), compress_state::ptr, RESPONSE_INT_SERV_ERR, RESPONSE_OK, send_message_to_receiver(), and msg_change_compress_data::what.

Referenced by compress_frame().

Here is the call graph for this function:

compress_tile_callback()

static void * compress_tile_callback ( void * arg )

static

This function is callback passed to a "thread pool".

Parameters

arg	compress_worker_data

Returns

compress_worker_data (same as input)

Definition at line 409 of file video_compress.cpp.

                                               {
        compress_worker_data *s = (compress_worker_data *) arg;
 
        s->ret = s->callback(s->state, s->frame);
 
        return s;
}

References compress_worker_data::callback, compress_worker_data::frame, compress_worker_data::ret, and compress_worker_data::state.

Referenced by compress_frame_tiles().