deltacast.cpp File Reference

#include "host.h"
#include "debug.h"
#include "deltacast_common.hpp"
#include "lib_common.h"
#include "tv.h"
#include "video.h"
#include "video_display.h"
#include "audio/types.h"
#include "audio/utils.h"
#include "utils/ring_buffer.h"
#include <algorithm>

Include dependency graph for deltacast.cpp:

Go to the source code of this file.

Classes
struct	state_deltacast

Macros
#define	DELTACAST_MAGIC   0x01005e02

Functions
static void	display_deltacast_done (void *state)
static bool	display_deltacast_get_property (void *state, int property, void *val, size_t *len)
static struct video_frame *	display_deltacast_getf (void *state)
static void *	display_deltacast_init (struct module *parent, const char *fmt, unsigned int flags)
static void	display_deltacast_probe (struct device_info **available_cards, int *count, void(**deleter)(void *))
static void	display_deltacast_put_audio_frame (void *state, const struct audio_frame *frame)
static bool	display_deltacast_putf (void *state, struct video_frame *frame, long long nonblock)
static bool	display_deltacast_reconfigure (void *state, struct video_desc desc)
static bool	display_deltacast_reconfigure_audio (void *state, int quant_samples, int channels, int sample_rate)
	REGISTER_MODULE (deltacast, &display_deltacast_info, LIBRARY_CLASS_VIDEO_DISPLAY, VIDEO_DISPLAY_ABI_VERSION)
static void	show_help (void)

Variables
static const struct video_display_info	display_deltacast_info

Detailed Description

Author

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

Definition in file deltacast.cpp.

Macro Definition Documentation

DELTACAST_MAGIC

#define DELTACAST_MAGIC   0x01005e02

Definition at line 57 of file deltacast.cpp.

Referenced by display_deltacast_getf(), display_deltacast_init(), and display_deltacast_putf().

Function Documentation

display_deltacast_done()

static void display_deltacast_done ( void * state )

static

Definition at line 413 of file deltacast.cpp.

{
        struct state_deltacast *s = (struct state_deltacast *)state;
 
        if(s->initialized) {
                if(s->SlotHandle)
                        VHD_UnlockSlotHandle(s->SlotHandle);
                VHD_StopStream(s->StreamHandle);
                VHD_CloseStreamHandle(s->StreamHandle);
                VHD_SetBoardProperty(s->BoardHandle,VHD_CORE_BP_BYPASS_RELAY_0,TRUE);
                VHD_CloseBoardHandle(s->BoardHandle);
        }
 
        vf_free(s->frame);
        free(s);
}

References state_deltacast::BoardHandle, state_deltacast::frame, state_deltacast::initialized, state_deltacast::SlotHandle, state, state_deltacast::StreamHandle, TRUE, and vf_free().

Here is the call graph for this function:

display_deltacast_get_property()

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

static

Definition at line 431 of file deltacast.cpp.

{
        UNUSED(state);
        codec_t codecs[] = {v210, UYVY, RAW};
        interlacing_t supported_il_modes[] = {PROGRESSIVE, UPPER_FIELD_FIRST, SEGMENTED_FRAME};
        int rgb_shift[] = {0, 8, 16};
        
        switch (property) {
                case DISPLAY_PROPERTY_CODECS:
                        if(sizeof(codecs) <= *len) {
                                memcpy(val, codecs, sizeof(codecs));
                        } else {
                                return false;
                        }
                        
                        *len = sizeof(codecs);
                        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_AUDIO_FORMAT:
                        {
                                assert(*len == sizeof(struct audio_desc));
                                struct audio_desc *desc = (struct audio_desc *) val;
                                desc->sample_rate = 48000;
                                desc->ch_count = std::max(desc->ch_count, 16);
                                desc->codec = AC_PCM;
                                desc->bps = desc->bps < 3 ? 2 : 3;
                        }
                        break;
                default:
                        return false;
        }
        return true;
}

References AC_PCM, codecs, desc, DISPLAY_PROPERTY_AUDIO_FORMAT, DISPLAY_PROPERTY_BUF_PITCH, DISPLAY_PROPERTY_CODECS, DISPLAY_PROPERTY_RGB_SHIFT, DISPLAY_PROPERTY_SUPPORTED_IL_MODES, len, PITCH_DEFAULT, PROGRESSIVE, property, RAW, SEGMENTED_FRAME, state, UNUSED, UPPER_FIELD_FIRST, UYVY, v210, and val.

display_deltacast_getf()

static struct video_frame * display_deltacast_getf ( void * state )

static

Definition at line 97 of file deltacast.cpp.

{
        struct state_deltacast *s = (struct state_deltacast *)state;
        BYTE *pBuffer;
        ULONG BufferSize;
        ULONG Result;
 
        assert(s->magic == DELTACAST_MAGIC);
        
        if(!s->initialized)
                return s->frame;
        
        Result = VHD_LockSlotHandle(s->StreamHandle, &s->SlotHandle);
        if (Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Unable to lock slot.\n");
                return NULL;
        }
        Result = VHD_GetSlotBuffer(s->SlotHandle,VHD_SDI_BT_VIDEO,&pBuffer,&BufferSize);
        if (Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Unable to get buffer.\n");
                return NULL;
        }
        
        s->tile->data = (char *) pBuffer;
        s->tile->data_len = BufferSize;
 
        return s->frame;
}

References tile::data, tile::data_len, DELTACAST_MAGIC, state_deltacast::frame, state_deltacast::initialized, LOG_LEVEL_ERROR, log_msg(), state_deltacast::magic, state_deltacast::SlotHandle, state, state_deltacast::StreamHandle, and state_deltacast::tile.

Here is the call graph for this function:

display_deltacast_init()

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

static

Definition at line 302 of file deltacast.cpp.

{
        UNUSED(parent);
        struct state_deltacast *s;
        ULONG             Result,DllVersion,NbBoards,ChnType;
        ULONG             BrdId = 0;
 
        s = (struct state_deltacast *)calloc(1, sizeof(struct state_deltacast));
        s->magic = DELTACAST_MAGIC;
        
        s->frame = vf_alloc(1);
        s->tile = vf_get_tile(s->frame, 0);
        s->frames = 0;
        
        gettimeofday(&s->tv, NULL);
        
        s->initialized = FALSE;
        if(flags & DISPLAY_FLAG_AUDIO_EMBEDDED) {
                s->play_audio = TRUE;
        } else {
                s->play_audio = FALSE;
        }
        
        s->BoardHandle = s->StreamHandle = s->SlotHandle = NULL;
        s->audio_configured = FALSE;
 
        if(fmt && strcmp(fmt, "help") == 0) {
                show_help();
                vf_free(s->frame);
                free(s);
                return INIT_NOERR;
        }
        
        if(fmt)
        {
                char *tmp = strdup(fmt);
                char *save_ptr = NULL;
                char *tok;
                
                tok = strtok_r(tmp, ":", &save_ptr);
                if(!tok)
                {
                        free(tmp);
                        show_help();
                        goto error;
                }
                if (strncasecmp(tok, "device=", strlen("device=")) == 0) {
                        BrdId = atoi(tok + strlen("device="));
                } else {
                        log_msg(LOG_LEVEL_ERROR, "Unknown option: %s\n\n", tok);
                        free(tmp);
                        show_help();
                        goto error;
                }
                free(tmp);
        }
 
        /* Query VideoMasterHD information */
        Result = VHD_GetApiInfo(&DllVersion,&NbBoards);
        if (Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] ERROR : Cannot query VideoMasterHD"
                                " information. Result = 0x%08" PRIX_ULONG "\n",
                                Result);
                goto error;
        }
        if (NbBoards == 0) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] No DELTA board detected, exiting...\n");
                goto error;
        }
        
        if(BrdId >= NbBoards) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Wrong index %" PRIu_ULONG ". Found %" PRIu_ULONG " cards.\n", BrdId, NbBoards);
                goto error;
        }
 
        /* Open a handle on first DELTA-hd/sdi/codec board */
        Result = VHD_OpenBoardHandle(BrdId,&s->BoardHandle,NULL,0);
        if (Result != VHDERR_NOERROR)
        {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] ERROR : Cannot open DELTA board %" PRIu_ULONG " handle. Result = 0x%08" PRIX_ULONG "\n", BrdId, Result);
                goto error;
        }
 
        if (!delta_set_nb_channels(BrdId, s->BoardHandle, 0, 1)) {
                goto error;
        }
 
        VHD_GetBoardProperty(s->BoardHandle, VHD_CORE_BP_TX0_TYPE, &ChnType);
        if((ChnType!=VHD_CHNTYPE_SDSDI)&&(ChnType!=VHD_CHNTYPE_HDSDI)&&(ChnType!=VHD_CHNTYPE_3GSDI)) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] ERROR : The selected channel is not an SDI one\n");
                goto bad_channel;
        }
        
        /* Disable RX0-TX0 by-pass relay loopthrough */
        VHD_SetBoardProperty(s->BoardHandle,VHD_CORE_BP_BYPASS_RELAY_0,FALSE);
        
        /* Select a 1/1 clock system */
        VHD_SetBoardProperty(s->BoardHandle,VHD_SDI_BP_CLOCK_SYSTEM,VHD_CLOCKDIV_1);
 
        pthread_mutex_init(&s->lock, NULL);
                  
        return s;
 
bad_channel:
        VHD_CloseBoardHandle(s->BoardHandle);
error:
        vf_free(s->frame);
        free(s);
        return NULL;
}

References state_deltacast::audio_configured, state_deltacast::BoardHandle, delta_set_nb_channels(), DELTACAST_MAGIC, DISPLAY_FLAG_AUDIO_EMBEDDED, FALSE, flags, fmt, state_deltacast::frame, state_deltacast::frames, INIT_NOERR, state_deltacast::initialized, state_deltacast::lock, LOG_LEVEL_ERROR, log_msg(), state_deltacast::magic, parent, state_deltacast::play_audio, PRIu_ULONG, PRIX_ULONG, show_help(), state_deltacast::SlotHandle, state_deltacast::StreamHandle, state_deltacast::tile, TRUE, state_deltacast::tv, UNUSED, vf_alloc(), vf_free(), and vf_get_tile().

Here is the call graph for this function:

display_deltacast_probe()

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

static

Definition at line 255 of file deltacast.cpp.

{
        UNUSED(deleter);
        *count = 0;
        *available_cards = nullptr;
 
        ULONG             Result,DllVersion,NbBoards;
        Result = VHD_GetApiInfo(&DllVersion,&NbBoards);
        if (Result != VHDERR_NOERROR) {
                return;
        }
        if (NbBoards == 0) {
                return;
        }
 
        /* Query DELTA boards information */
        for (ULONG i = 0; i < NbBoards; i++)
        {
                ULONG BoardType;
                HANDLE            BoardHandle = NULL;
                ULONG Result = VHD_OpenBoardHandle(i,&BoardHandle,NULL,0);
                VHD_GetBoardProperty(BoardHandle, VHD_CORE_BP_BOARD_TYPE, &BoardType);
 
                *count += 1;
                *available_cards = (struct device_info *)
                        realloc(*available_cards, *count * sizeof(struct device_info));
                memset(*available_cards + *count - 1, 0, sizeof(struct device_info));
                snprintf((*available_cards)[*count - 1].dev, sizeof (*available_cards)[*count - 1].dev, ":device=%d", *count - 1);
                snprintf((*available_cards)[*count - 1].extra, sizeof (*available_cards)[*count - 1].extra, R"("embeddedAudioAvailable":"t")");
                (*available_cards)[*count - 1].repeatable = false;
 
                if (Result == VHDERR_NOERROR)
                {
                        std::string board{"Unknown DELTACAST type"};
                        auto it = board_type_map.find(BoardType);
                        if (it != board_type_map.end()) {
                                board = it->second;
                        }
                        snprintf((*available_cards)[*count - 1].name,
                                        sizeof (*available_cards)[*count - 1].name - 1,
                                        "DELTACAST %s", board.c_str());
                        VHD_CloseBoardHandle(BoardHandle);
                }
        }
 
}

References board_type_map, state_deltacast::BoardHandle, count, deleter, device_info::dev, device_info::extra, name, and UNUSED.

display_deltacast_put_audio_frame()

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

static

Definition at line 540 of file deltacast.cpp.

{
        struct state_deltacast *s = (struct state_deltacast *)state;
        int i;
        int channel_len = frame->data_len / frame->ch_count;
 
        pthread_mutex_lock(&s->lock);
        for(i = 0; i < frame->ch_count; ++i) {
                 demux_channel(s->audio_tmp, frame->data, frame->bps, frame->data_len, frame->ch_count, i);
                 ring_buffer_write(s->audio_channels[i], s->audio_tmp, channel_len);
        }
        pthread_mutex_unlock(&s->lock);
}

References state_deltacast::audio_channels, state_deltacast::audio_tmp, demux_channel(), frame, state_deltacast::lock, ring_buffer_write(), and state.

Here is the call graph for this function:

display_deltacast_putf()

static bool display_deltacast_putf ( void * state, struct video_frame * frame, long long nonblock )

static

Definition at line 126 of file deltacast.cpp.

{
        struct state_deltacast *s = (struct state_deltacast *)state;
        struct timeval tv;
        int i;
        ULONG Result;
 
        UNUSED(frame);
        UNUSED(nonblock);
 
        assert(s->magic == DELTACAST_MAGIC);
        
        pthread_mutex_lock(&s->lock);
        if(s->play_audio && s->audio_configured) {
                /* Retrieve the number of needed samples */
                for(i = 0; i < s->audio_desc.ch_count; ++i) {
                        s->AudioInfo.pAudioGroups[i / 4].pAudioChannels[i % 4].DataSize = 0;
                }
                Result = VHD_SlotEmbedAudio(s->SlotHandle,&s->AudioInfo);
                if (Result != VHDERR_BUFFERTOOSMALL)
                {
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] ERROR : Cannot embed audio on TX0 stream. Result = 0x%08" PRIX_ULONG "\n", Result);
                } else {
                        for(i = 0; i < s->audio_desc.ch_count; ++i) {
                                int ret;
                                ret = ring_buffer_read(s->audio_channels[i], (char *) s->AudioInfo.pAudioGroups[i / 4].pAudioChannels[i % 4].pData, s->AudioInfo.pAudioGroups[i / 4].pAudioChannels[i % 4].DataSize);
                                if(!ret) {
                                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Buffer underflow for channel %d.\n", i);
                                }
                                s->AudioInfo.pAudioGroups[0].pAudioChannels[0].DataSize = ret;
                        }
                }
                /* Embed audio */
                Result = VHD_SlotEmbedAudio(s->SlotHandle,&s->AudioInfo);
                if (Result != VHDERR_NOERROR)
                {
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] ERROR : Cannot embed audio on TX0 stream. Result = 0x%08" PRIX_ULONG "\n",Result);
                }
        }
        pthread_mutex_unlock(&s->lock);
 
        VHD_UnlockSlotHandle(s->SlotHandle);
        s->SlotHandle = NULL;
        
        gettimeofday(&tv, NULL);
        double seconds = tv_diff(tv, s->tv);
        if (seconds > 5) {
                double fps = s->frames / seconds;
                log_msg(LOG_LEVEL_INFO, "[DELTACAST display] %lu frames in %g seconds = %g FPS\n",
                        s->frames, seconds, fps);
                s->tv = tv;
                s->frames = 0;
        }
        s->frames++;
 
        return true;
}

References state_deltacast::audio_channels, state_deltacast::audio_configured, state_deltacast::audio_desc, state_deltacast::AudioInfo, audio_desc::ch_count, DELTACAST_MAGIC, frame, state_deltacast::frames, state_deltacast::lock, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, log_msg(), state_deltacast::magic, nonblock, state_deltacast::play_audio, PRIX_ULONG, ring_buffer_read(), state_deltacast::SlotHandle, state, state_deltacast::tv, tv_diff(), and UNUSED.

Here is the call graph for this function:

display_deltacast_reconfigure()

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

static

Definition at line 185 of file deltacast.cpp.

{
        struct state_deltacast            *s = (struct state_deltacast *)state;
        int VideoStandard = 0;
        int i;
        ULONG Result;
        
        if(s->initialized) {
                if(s->SlotHandle)
                        VHD_UnlockSlotHandle(s->SlotHandle);
                VHD_StopStream(s->StreamHandle);
                VHD_CloseStreamHandle(s->StreamHandle);
        }
 
        assert(desc.tile_count == 1);
 
        s->tile->width = desc.width;
        s->tile->height = desc.height;
        s->frame->color_spec = desc.color_spec;
        s->frame->interlacing = desc.interlacing;
        s->frame->fps = desc.fps;
        
        for (i = 0; i < deltacast_frame_modes_count; ++i)
        {
                if(fabs(desc.fps - deltacast_frame_modes[i].fps) < 0.01 &&
                                desc.interlacing == deltacast_frame_modes[i].interlacing &&
                                desc.width == deltacast_frame_modes[i].width &&
                                desc.height == deltacast_frame_modes[i].height) {
                        VideoStandard = deltacast_frame_modes[i].mode;
                        log_msg(LOG_LEVEL_NOTICE, "[DELTACAST] %s mode selected.\n", deltacast_frame_modes[i].name);
                        break;
                }
        }
        if(i == deltacast_frame_modes_count) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Failed to obtain video format for incoming video: %dx%d @ %2.2f %s\n", desc.width, desc.height,
                                                                        (double) desc.fps, get_interlacing_description(desc.interlacing));
 
                goto error;
        }
        
        if(desc.color_spec == RAW) {
                Result = VHD_OpenStreamHandle(s->BoardHandle,VHD_ST_TX0,VHD_SDI_STPROC_RAW,NULL,&s->StreamHandle,NULL);
        } else if (s->play_audio == TRUE) {
                Result = VHD_OpenStreamHandle(s->BoardHandle,VHD_ST_TX0,VHD_SDI_STPROC_JOINED,NULL,&s->StreamHandle,NULL);
        } else {
                Result = VHD_OpenStreamHandle(s->BoardHandle,VHD_ST_TX0,VHD_SDI_STPROC_DISJOINED_VIDEO,NULL,&s->StreamHandle,NULL);
        }
        
        if (Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Failed to open stream handle.\n");
                goto error;
        }
        
        VHD_SetStreamProperty(s->StreamHandle,VHD_SDI_SP_VIDEO_STANDARD,VideoStandard);
        VHD_SetStreamProperty(s->StreamHandle,VHD_CORE_SP_BUFFERQUEUE_DEPTH,2);
        VHD_SetStreamProperty(s->StreamHandle,VHD_CORE_SP_BUFFERQUEUE_PRELOAD,0);
 
        Result = VHD_StartStream(s->StreamHandle);
        if (Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Unable to start stream.\n");  
                goto error;
        }
        
        s->initialized = TRUE;
        return true;
 
error:
        return false;
}

References state_deltacast::BoardHandle, video_desc::color_spec, video_frame::color_spec, deltacast_frame_modes, deltacast_frame_modes_count, desc, deltacast_frame_mode_t::fps, video_desc::fps, video_frame::fps, state_deltacast::frame, get_interlacing_description(), deltacast_frame_mode_t::height, tile::height, video_desc::height, state_deltacast::initialized, deltacast_frame_mode_t::interlacing, video_desc::interlacing, video_frame::interlacing, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, log_msg(), deltacast_frame_mode_t::mode, name, state_deltacast::play_audio, RAW, state_deltacast::SlotHandle, state, state_deltacast::StreamHandle, state_deltacast::tile, video_desc::tile_count, TRUE, deltacast_frame_mode_t::width, tile::width, and video_desc::width.

Here is the call graph for this function:

display_deltacast_reconfigure_audio()

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

static

Definition at line 485 of file deltacast.cpp.

{
        struct state_deltacast *s = (struct state_deltacast *)state;
        int i;
 
        assert(channels <= 16);
 
        pthread_mutex_lock(&s->lock);
        s->audio_configured = FALSE;
        for(i = 0; i < 16; ++i) {
                ring_buffer_destroy(s->audio_channels[i]);
                s->audio_channels[i] = NULL;
        }
        free(s->audio_tmp);
 
        s->audio_desc.bps = quant_samples / 8;
        s->audio_desc.ch_count = channels;
        s->audio_desc.sample_rate = sample_rate;
 
        for(i = 0; i < channels; ++i) {
                s->audio_channels[i] = ring_buffer_init(s->audio_desc.bps * s->audio_desc.sample_rate);
        }
        s->audio_tmp = (char *) malloc(s->audio_desc.bps * s->audio_desc.sample_rate);
 
        /* Configure audio info */
        memset(&s->AudioInfo, 0, sizeof(VHD_AUDIOINFO));
        for(i = 0; i < channels; ++i) {
                VHD_AUDIOCHANNEL *pAudioChn=NULL;
                pAudioChn = &s->AudioInfo.pAudioGroups[i / 4].pAudioChannels[i % 4];
                pAudioChn->Mode = VHD_AM_MONO;
                switch(quant_samples) {
                        case 16:
                                pAudioChn->BufferFormat = VHD_AF_16; 
                                break;
                        case 20:
                                pAudioChn->BufferFormat = VHD_AF_20; 
                                break;
                        case 24:
                                pAudioChn->BufferFormat = VHD_AF_24; 
                                break;
                        default:
                                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Unsupported PCM audio: %d bits.\n", quant_samples);
                                pthread_mutex_unlock(&s->lock);
                                return false;
                }
                pAudioChn->pData = new BYTE[s->audio_desc.bps * s->audio_desc.sample_rate];
        }
 
        s->audio_configured = TRUE;
        pthread_mutex_unlock(&s->lock);
 
        return true;
}

References state_deltacast::audio_channels, state_deltacast::audio_configured, state_deltacast::audio_desc, state_deltacast::audio_tmp, state_deltacast::AudioInfo, audio_desc::bps, audio_desc::ch_count, channels, FALSE, state_deltacast::lock, LOG_LEVEL_ERROR, log_msg(), quant_samples, ring_buffer_destroy(), ring_buffer_init(), audio_desc::sample_rate, sample_rate, state, and TRUE.

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	deltacast	,
		&	display_deltacast_info,
		LIBRARY_CLASS_VIDEO_DISPLAY	,
		VIDEO_DISPLAY_ABI_VERSION	)

show_help()

static void show_help ( void )

static

Definition at line 85 of file deltacast.cpp.

{
        printf("deltacast (output) options:\n");
        printf("\t-d deltacast[:device=<index>]\n");
 
        print_available_delta_boards();
 
        printf("\nDefault board is 0.\n");
 
}

References print_available_delta_boards().

Referenced by display_deltacast_init().

Here is the call graph for this function:

Variable Documentation

display_deltacast_info

const struct video_display_info display_deltacast_info

static

Initial value:

= {
        display_deltacast_probe,
        display_deltacast_init,
        NULL, 
        display_deltacast_done,
        display_deltacast_getf,
        display_deltacast_putf,
        display_deltacast_reconfigure,
        display_deltacast_get_property,
        display_deltacast_put_audio_frame,
        display_deltacast_reconfigure_audio,
        DISPLAY_NO_GENERIC_FPS_INDICATOR,
}

Definition at line 554 of file deltacast.cpp.

                                                                {
        display_deltacast_probe,
        display_deltacast_init,
        NULL, // _run
        display_deltacast_done,
        display_deltacast_getf,
        display_deltacast_putf,
        display_deltacast_reconfigure,
        display_deltacast_get_property,
        display_deltacast_put_audio_frame,
        display_deltacast_reconfigure_audio,
        DISPLAY_NO_GENERIC_FPS_INDICATOR,
};