pipe.cpp File Reference

#include <cassert>
#include <cstring>
#include <iostream>
#include <list>
#include <mutex>
#include "audio/types.h"
#include "audio/utils.h"
#include "debug.h"
#include "lib_common.h"
#include "video.h"
#include "video_display.h"
#include "video_display/pipe.hpp"

Include dependency graph for pipe.cpp:

Go to the source code of this file.

Classes
struct	state_pipe
struct	state_pipe::desc

Macros
#define	MOD_NAME   "[pipe] "

Functions
static void	display_pipe_dispose_audio (struct audio_frame *f)
static void	display_pipe_done (void *state)
static struct audio_frame *	display_pipe_get_audio (struct state_pipe *s)
static bool	display_pipe_get_property (void *state, int property, void *val, size_t *len)
static struct video_frame *	display_pipe_getf (void *state)
static void *	display_pipe_init (struct module *parent, const char *fmt, unsigned int flags)
static void	display_pipe_probe (struct device_info **available_cards, int *count, void(**deleter)(void *))
static void	display_pipe_put_audio_frame (void *state, const struct audio_frame *frame)
static bool	display_pipe_putf (void *state, struct video_frame *frame, long long flags)
static bool	display_pipe_reconfigure (void *state, struct video_desc desc)
static bool	display_pipe_reconfigure_audio (void *state, int quant_samples, int channels, int sample_rate)
static void	display_pipe_usage ()
static bool	get_codecs (struct state_pipe *s, void *val, size_t *len)
	REGISTER_HIDDEN_MODULE (pipe, &display_pipe_info, LIBRARY_CLASS_VIDEO_DISPLAY, VIDEO_DISPLAY_ABI_VERSION)

Variables
static const struct video_display_info	display_pipe_info

Detailed Description

Author

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

Definition in file pipe.cpp.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[pipe] "

Definition at line 52 of file pipe.cpp.

Function Documentation

display_pipe_dispose_audio()

static void display_pipe_dispose_audio ( struct audio_frame * f )

static

Definition at line 134 of file pipe.cpp.

                                                              {
        free(f->data);
        free(f);
}

References audio_frame::data.

Referenced by display_pipe_get_audio().

display_pipe_done()

static void display_pipe_done ( void * state )

static

Definition at line 112 of file pipe.cpp.

{
        struct state_pipe *s = (struct state_pipe *)state;
 
        for (auto & a : s->audio_frames) {
                free(a->data);
                free(a);
        }
        delete s;
}

References state_pipe::audio_frames, and state.

display_pipe_get_audio()

static struct audio_frame * display_pipe_get_audio ( struct state_pipe * s )

static

Definition at line 139 of file pipe.cpp.

{
        lock_guard<mutex> lk(s->audio_lock);
        size_t len = 0;
        if (s->audio_frames.empty()) {
                return nullptr;
        }
        struct audio_desc desc = audio_desc_from_frame(s->audio_frames.front());
        for (auto it = s->audio_frames.begin(); it != s->audio_frames.end(); ) {
                if (!audio_desc_eq(desc, audio_desc_from_frame(*it))) {
                        LOG(LOG_LEVEL_WARNING) << "[pipe] Discarding audio - incompatible format!\n";
                        free((*it)->data);
                        free(*it);
                        it = s->audio_frames.erase(it);
                        continue;
                }
                len += (*it)->data_len;
                ++it;
        }
        if (len == 0) {
                return nullptr;
        }
        auto out = (struct audio_frame *) calloc(1, sizeof(struct audio_frame));
        audio_frame_write_desc(out, desc);
        out->max_size = len;
        out->data = (char *) malloc(len);
        for (auto it = s->audio_frames.begin(); it != s->audio_frames.end(); ) {
                append_audio_frame(out, (*it)->data, (*it)->data_len);
                free((*it)->data);
                free(*it);
                it = s->audio_frames.erase(it);
        }
        out->dispose = display_pipe_dispose_audio;
        return out;
}

References append_audio_frame(), audio_desc_eq(), audio_desc_from_frame(), audio_frame_write_desc(), state_pipe::audio_frames, state_pipe::audio_lock, desc, display_pipe_dispose_audio(), len, LOG, and LOG_LEVEL_WARNING.

Referenced by display_pipe_putf().

Here is the call graph for this function:

display_pipe_get_property()

static bool display_pipe_get_property ( void * state, int property, void * val, size_t * len )

static

Definition at line 219 of file pipe.cpp.

{
        auto *s = static_cast<struct state_pipe *>(state);
        enum interlacing_t supported_il_modes[] = {PROGRESSIVE, INTERLACED_MERGED, SEGMENTED_FRAME};
        int rgb_shift[] = {0, 8, 16};
 
        switch (property) {
                case DISPLAY_PROPERTY_CODECS:
                        return get_codecs(s, val, len);
                        break;
                case DISPLAY_PROPERTY_RGB_SHIFT:
                        if(sizeof(rgb_shift) > *len) {
                                return false;
                        }
                        memcpy(val, rgb_shift, sizeof(rgb_shift));
                        *len = sizeof(rgb_shift);
                        break;
                case DISPLAY_PROPERTY_BUF_PITCH:
                        *(int *) val = PITCH_DEFAULT;
                        *len = sizeof(int);
                        break;
                case DISPLAY_PROPERTY_SUPPORTED_IL_MODES:
                        if(sizeof(supported_il_modes) <= *len) {
                                memcpy(val, supported_il_modes, sizeof(supported_il_modes));
                        } else {
                                return false;
                        }
                        *len = sizeof(supported_il_modes);
                        break;
                case DISPLAY_PROPERTY_VIDEO_MODE:
                        *(int *) val = DISPLAY_PROPERTY_VIDEO_SEPARATE_TILES;
                        *len = sizeof(int);
                        break;
                case DISPLAY_PROPERTY_AUDIO_FORMAT:
                        {
                                assert (*len >= sizeof(struct audio_desc));
                                struct audio_desc *desc = (struct audio_desc *) val;
                                desc->codec = AC_PCM; // decompress
                        }
                        break;
                default:
                        return false;
        }
        return true;
}

References AC_PCM, desc, DISPLAY_PROPERTY_AUDIO_FORMAT, DISPLAY_PROPERTY_BUF_PITCH, DISPLAY_PROPERTY_CODECS, DISPLAY_PROPERTY_RGB_SHIFT, DISPLAY_PROPERTY_SUPPORTED_IL_MODES, DISPLAY_PROPERTY_VIDEO_MODE, DISPLAY_PROPERTY_VIDEO_SEPARATE_TILES, get_codecs(), INTERLACED_MERGED, len, PITCH_DEFAULT, PROGRESSIVE, property, SEGMENTED_FRAME, state, and val.

Here is the call graph for this function:

display_pipe_getf()

static struct video_frame * display_pipe_getf ( void * state )

static

Definition at line 123 of file pipe.cpp.

{
        struct state_pipe *s = (struct state_pipe *)state;
 
        struct video_frame *out = vf_alloc_desc_data(s->desc);
        // explicit dispose is needed because we do not process the frame
        // by ourselves but it is passed to further processing
        out->callbacks.dispose = vf_free;
        return out;
}

References video_frame::callbacks, video_frame_callbacks::dispose, state, vf_alloc_desc_data(), and vf_free().

Here is the call graph for this function:

display_pipe_init()

static void * display_pipe_init ( struct module * parent, const char * fmt, unsigned int flags )

static

Note

Audio is always received regardless if enabled in flags.

Definition at line 77 of file pipe.cpp.

{
        UNUSED(flags);
        codec_t decode_to = VIDEO_CODEC_NONE;
        frame_recv_delegate *delegate;
 
        if (!fmt || strlen(fmt) == 0 || strcmp(fmt, "help") == 0) {
                fprintf(stderr, "Pipe dummy video driver. For internal usage - please do not use.\n");
                if (fmt != nullptr && strcmp(fmt, "help") == 0) {
                        display_pipe_usage();
                }
                return nullptr;
        }
 
        sscanf(fmt, "%p", &delegate);
        if (strchr(fmt, ':') != nullptr) {
                fmt = strchr(fmt, ':') + 1;
                if (strstr(fmt, "codec=") == fmt) {
                        const char *codec_name = fmt + strlen("codec=");
                        decode_to = get_codec_from_name(codec_name);
                        if (decode_to == VIDEO_CODEC_NONE) {
                                LOG(LOG_LEVEL_ERROR) << "Wrong codec name: " << codec_name << "\n";
                                return nullptr;
                        }
                } else {
                        display_pipe_usage();
                        return nullptr;
                }
        }
 
        auto *s = new state_pipe{parent, delegate, decode_to};
 
        return s;
}

References display_pipe_usage(), flags, fmt, get_codec_from_name(), LOG, LOG_LEVEL_ERROR, parent, UNUSED, and VIDEO_CODEC_NONE.

Here is the call graph for this function:

display_pipe_probe()

static void display_pipe_probe ( struct device_info ** available_cards, int * count, void(** deleter )(void *) )

static

Definition at line 292 of file pipe.cpp.

                                                                                                           {
        UNUSED(deleter);
        *available_cards = nullptr;
        *count = 0;
}

References count, deleter, and UNUSED.

display_pipe_put_audio_frame()

static void display_pipe_put_audio_frame ( void * state, const struct audio_frame * frame )

static

Definition at line 274 of file pipe.cpp.

{
        auto s = (struct state_pipe *) state;
        lock_guard<mutex> lk(s->audio_lock);
        s->audio_frames.push_back(audio_frame_copy(frame, false));
}

References audio_frame_copy(), frame, and state.

Here is the call graph for this function:

display_pipe_putf()

static bool display_pipe_putf ( void * state, struct video_frame * frame, long long flags )

static

Definition at line 175 of file pipe.cpp.

{
        struct state_pipe *s = (struct state_pipe *) state;
 
        if (flags == PUTF_DISCARD) {
                VIDEO_FRAME_DISPOSE(frame);
                return true;
        }
 
        struct audio_frame *af = display_pipe_get_audio(s);
        s->delegate->frame_arrived(frame, af);
 
        return true;
}

References state_pipe::delegate, display_pipe_get_audio(), flags, frame, frame_recv_delegate::frame_arrived(), PUTF_DISCARD, state, and VIDEO_FRAME_DISPOSE.

Here is the call graph for this function:

display_pipe_reconfigure()

static bool display_pipe_reconfigure ( void * state, struct video_desc desc )

static

Definition at line 265 of file pipe.cpp.

{
        struct state_pipe *s = (struct state_pipe *) state;
 
        s->desc = desc;
 
        return true;
}

References desc, and state.

display_pipe_reconfigure_audio()

static bool display_pipe_reconfigure_audio ( void * state, int quant_samples, int channels, int sample_rate )

static

Definition at line 281 of file pipe.cpp.

{
        UNUSED(state);
        UNUSED(quant_samples);
        UNUSED(channels);
        UNUSED(sample_rate);
 
        return true;
}

References channels, quant_samples, sample_rate, state, and UNUSED.

display_pipe_usage()

static void display_pipe_usage ( )

static

Definition at line 68 of file pipe.cpp.

                                 {
        cout << "Usage:\n"
                "\t-d pipe:<ptr>[:codec=<c>]\n";
}

Referenced by display_pipe_init().

get_codecs()

static bool get_codecs ( struct state_pipe * s, void * val, size_t * len )

static

Definition at line 191 of file pipe.cpp.

{
        if (s->decode_to != VIDEO_CODEC_NONE) {
                if (sizeof(codec_t) > *len) {
                        MSG(ERROR, "Insufficient prop length %zu B!\n", *len);
                        return false;
                }
                memcpy(val, &s->decode_to, sizeof(s->decode_to));
                *len = sizeof s->decode_to;
                return true;
        }
        auto       *out = (codec_t *) val;
        const void *end = (char *) val + *len;
        for (int i = VC_FIRST; i < VIDEO_CODEC_COUNT; ++i) {
                const auto c = (codec_t) i;
                if (is_codec_opaque(c)) {
                        continue;
                }
                if (out + 1 > end) {
                        MSG(ERROR, "Insufficient prop length %zu B!\n", *len);
                        return false;
                }
                memcpy(out++, &c, sizeof c);
        }
        *len = (char *) out - (char *) val;
        return true;
}

References state_pipe::decode_to, is_codec_opaque(), len, MSG, val, VC_FIRST, VIDEO_CODEC_COUNT, and VIDEO_CODEC_NONE.

Referenced by display_pipe_get_property().

Here is the call graph for this function:

REGISTER_HIDDEN_MODULE()

REGISTER_HIDDEN_MODULE	(	pipe	,
		&	display_pipe_info,
		LIBRARY_CLASS_VIDEO_DISPLAY	,
		VIDEO_DISPLAY_ABI_VERSION	)

Variable Documentation

display_pipe_info

const struct video_display_info display_pipe_info

static

Initial value:

= {
        display_pipe_probe,
        display_pipe_init,
        NULL, 
        display_pipe_done,
        display_pipe_getf,
        display_pipe_putf,
        display_pipe_reconfigure,
        display_pipe_get_property,
        display_pipe_put_audio_frame,
        display_pipe_reconfigure_audio,
        DISPLAY_NO_GENERIC_FPS_INDICATOR,
}

Definition at line 298 of file pipe.cpp.

                                                           {
        display_pipe_probe,
        display_pipe_init,
        NULL, // _run
        display_pipe_done,
        display_pipe_getf,
        display_pipe_putf,
        display_pipe_reconfigure,
        display_pipe_get_property,
        display_pipe_put_audio_frame,
        display_pipe_reconfigure_audio,
        DISPLAY_NO_GENERIC_FPS_INDICATOR,
};