deltacast.cpp File Reference

#include "config.h"
#include "config_unix.h"
#include "config_win32.h"
#include <algorithm>
#include <fcntl.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include "audio/types.h"
#include "audio/utils.h"
#include "debug.h"
#include "deltacast_common.hpp"
#include "host.h"
#include "lib_common.h"
#include "tv.h"
#include "video.h"
#include "video_capture.h"
#include "video_capture_params.h"

Include dependency graph for deltacast.cpp:

Go to the source code of this file.

Classes
class	delta_init_exception
struct	vidcap_deltacast_state

Macros
#define	DELTA_TRY_CMD(cmd, msg)

Functions
	REGISTER_MODULE (deltacast, &vidcap_deltacast_info, LIBRARY_CLASS_VIDEO_CAPTURE, VIDEO_CAPTURE_ABI_VERSION)
static void	usage (void)
static void	vidcap_deltacast_done (void *state)
static struct video_frame *	vidcap_deltacast_grab (void *state, struct audio_frame **audio)
static int	vidcap_deltacast_init (struct vidcap_params *params, void **state)
static void	vidcap_deltacast_probe (device_info **available_cards, int *count, void(**deleter)(void *))
static bool	wait_for_channel (struct vidcap_deltacast_state *s)

Variables
static const struct video_capture_info	vidcap_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

DELTA_TRY_CMD

#define DELTA_TRY_CMD	(		cmd,
			msg )

Value:

        do {\
                Result = cmd;\
                if (Result != VHDERR_NOERROR) {\
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] " msg " Result = 0x%08" PRIX_ULONG "\n", Result);\
                        throw delta_init_exception();\
                }\
        } while(0)

Definition at line 139 of file deltacast.cpp.

#define DELTA_TRY_CMD(cmd, msg) \
        do {\
                Result = cmd;\
                if (Result != VHDERR_NOERROR) {\
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] " msg " Result = 0x%08" PRIX_ULONG "\n", Result);\
                        throw delta_init_exception();\
                }\
        } while(0)

Referenced by wait_for_channel().

Function Documentation

REGISTER_MODULE()

REGISTER_MODULE	(	deltacast	,
		&	vidcap_deltacast_info,
		LIBRARY_CLASS_VIDEO_CAPTURE	,
		VIDEO_CAPTURE_ABI_VERSION	)

usage()

static void usage ( void )

static

Definition at line 93 of file deltacast.cpp.

{
        printf("\t-t deltacast[:device=<index>][:mode=<mode>][:codec=<codec>]\n");
 
        print_available_delta_boards();
 
        printf("\nAvailable modes:\n");
        for (int i = 0; i < deltacast_frame_modes_count; ++i)
        {
                printf("\t%d: %s", deltacast_frame_modes[i].mode,
                                deltacast_frame_modes[i].name);
                if (deltacast_frame_modes[i].iface != VHD_INTERFACE_AUTO)
                        printf("\t\t(no autodetection)");
                printf("\n");
        }
        
        printf("\nAvailable codecs:\n");
        printf("\tUYVY\n");
        printf("\tv210\n");
        printf("\traw\n");
 
        printf("\nDefault board is 0. If mode is omitted, it will be autodetected "
                        "(except of UHD modes). Default codec is UYVY.\n");
}

References deltacast_frame_modes, deltacast_frame_modes_count, mode, name, and print_available_delta_boards().

Referenced by vidcap_deltacast_init().

Here is the call graph for this function:

vidcap_deltacast_done()

static void vidcap_deltacast_done ( void * state )

static

Definition at line 467 of file deltacast.cpp.

{
        struct vidcap_deltacast_state *s = (struct vidcap_deltacast_state *) state;
 
        assert(s != NULL);
        
        if(s->SlotHandle)
                VHD_UnlockSlotHandle(s->SlotHandle);
        VHD_StopStream(s->StreamHandle);
        VHD_CloseStreamHandle(s->StreamHandle);
        /* Re-establish RX0-TX0 by-pass relay loopthrough */
        VHD_SetBoardProperty(s->BoardHandle,VHD_CORE_BP_BYPASS_RELAY_0,TRUE);
        VHD_CloseBoardHandle(s->BoardHandle);
        
        vf_free(s->frame);
        free(s->audio_frame.data);
        free(s);
}

References vidcap_deltacast_state::audio_frame, vidcap_deltacast_state::BoardHandle, audio_frame::data, vidcap_deltacast_state::frame, vidcap_deltacast_state::SlotHandle, state, vidcap_deltacast_state::StreamHandle, TRUE, and vf_free().

Here is the call graph for this function:

vidcap_deltacast_grab()

static struct video_frame * vidcap_deltacast_grab ( void * state, struct audio_frame ** audio )

static

Definition at line 487 of file deltacast.cpp.

{
        struct vidcap_deltacast_state   *s = (struct vidcap_deltacast_state *) state;
        
        ULONG             /*SlotsCount, SlotsDropped,*/BufferSize;
        ULONG             Result;
        BYTE             *pBuffer=NULL;
 
        if (!s->initialized) {
                try {
                        if(wait_for_channel(s)) {
                                s->initialized = true;
                        } else {
                                return NULL;
                        }
                } catch(delta_init_exception &e) {
                }
        }
 
        *audio = NULL;
        /* Unlock slot */
        if(s->SlotHandle)
                VHD_UnlockSlotHandle(s->SlotHandle);
        Result = VHD_LockSlotHandle(s->StreamHandle,&s->SlotHandle);
        if (Result != VHDERR_NOERROR) {
                if (Result != VHDERR_TIMEOUT) {
                        log_msg(LOG_LEVEL_ERROR, "ERROR : Cannot lock slot on RX0 stream. Result = 0x%08" PRIX_ULONG "\n", Result);
                }
                else {
                        log_msg(LOG_LEVEL_ERROR, "Timeout \n");
                }
                return NULL;
        }
 
        if(s->grab_audio) {
                /* Set the audio buffer size */
                s->AudioBufferSize = VHD_GetBlockSize(s->pAudioChn->BufferFormat, s->pAudioChn->Mode) *
                        VHD_GetNbSamples((VHD_VIDEOSTANDARD) s->VideoStandard, (VHD_CLOCKDIVISOR) s->ClockSystem, VHD_ASR_48000, 0);
                s->pAudioChn->DataSize = s->AudioBufferSize;
 
                /* Extract audio */
                Result = VHD_SlotExtractAudio(s->SlotHandle, &s->AudioInfo);
                if(Result==VHDERR_NOERROR) {
                        s->audio_frame.data_len = s->pAudioChn->DataSize;
                        /* Do audio processing here */
                        *audio = &s->audio_frame;
                } else {
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Audio grabbing error. Result = 0x%08" PRIX_ULONG "\n",Result);
                }
        }
 
        
         Result = VHD_GetSlotBuffer(s->SlotHandle, VHD_SDI_BT_VIDEO, &pBuffer, &BufferSize);
         
         if (Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "\nERROR : Cannot get slot buffer. Result = 0x%08" PRIX_ULONG "\n",Result);
                return NULL;
         }
         
         s->tile->data = (char*) pBuffer;
         s->tile->data_len = BufferSize;
 
         /* Print some statistics */
         /*VHD_GetStreamProperty(s->StreamHandle,VHD_CORE_SP_SLOTS_COUNT,&SlotsCount);
         VHD_GetStreamProperty(s->StreamHandle,VHD_CORE_SP_SLOTS_DROPPED,&SlotsDropped);
         printf("%u frames received (%u dropped)            \r",SlotsCount,SlotsDropped);*/
        gettimeofday(&s->t, NULL);
        double seconds = tv_diff(s->t, s->t0);    
        if (seconds >= 5) {
            float fps  = s->frames / seconds;
            log_msg(LOG_LEVEL_INFO, "[DELTACAST cap.] %d frames in %g seconds = %g FPS\n", s->frames, seconds, fps);
            s->t0 = s->t;
            s->frames = 0;
        }
        s->frames++;
        
        return s->frame;
}

References audio, vidcap_deltacast_state::audio_frame, vidcap_deltacast_state::AudioBufferSize, vidcap_deltacast_state::AudioInfo, vidcap_deltacast_state::ClockSystem, tile::data, audio_frame::data_len, tile::data_len, vidcap_deltacast_state::frame, vidcap_deltacast_state::frames, vidcap_deltacast_state::grab_audio, vidcap_deltacast_state::initialized, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, log_msg(), vidcap_deltacast_state::pAudioChn, PRIX_ULONG, vidcap_deltacast_state::SlotHandle, state, vidcap_deltacast_state::StreamHandle, vidcap_deltacast_state::t0, vidcap_deltacast_state::tile, tv_diff(), vidcap_deltacast_state::VideoStandard, and wait_for_channel().

Here is the call graph for this function:

vidcap_deltacast_init()

static int vidcap_deltacast_init ( struct vidcap_params * params, void ** state )

static

Definition at line 311 of file deltacast.cpp.

{
        struct vidcap_deltacast_state *s = nullptr;
        ULONG             Result,DllVersion,NbBoards,ChnType;
        ULONG             BrdId = 0;
 
        printf("vidcap_deltacast_init\n");
 
        char *init_fmt = strdup(vidcap_params_get_fmt(params));
        if (init_fmt && strcmp(init_fmt, "help") == 0) {
                free(init_fmt);
                usage();
                return VIDCAP_INIT_NOERR;
        }
 
        s = (struct vidcap_deltacast_state *) calloc(1, sizeof(struct vidcap_deltacast_state));
 
        if(s == NULL) {
                printf("Unable to allocate DELTACAST state\n");
                free(init_fmt);
                free(s);
                return VIDCAP_INIT_FAIL;
        }
 
        gettimeofday(&s->t0, NULL);
 
        s->frame = vf_alloc(1);
        s->tile = vf_get_tile(s->frame, 0);
        s->frames = 0;
        s->grab_audio = FALSE;
        s->autodetect_format = TRUE;
        s->frame->color_spec = UYVY;
        s->audio_frame.data = NULL;
 
        s->BoardHandle = s->StreamHandle = s->SlotHandle = NULL;
 
        if (init_fmt) {
                char *save_ptr = NULL;
                char *tok;
                char *tmp = init_fmt;
 
                while ((tok = strtok_r(tmp, ":", &save_ptr)) != NULL) {
                        if (strncasecmp(tok, "device=", strlen("device=")) == 0) {
                                BrdId = atoi(tok + strlen("device="));
                        } else if (strncasecmp(tok, "board=", strlen("board=")) == 0) {
                                // compat, should be device= instead
                                BrdId = atoi(tok + strlen("board="));
                        } else if (strncasecmp(tok, "mode=", strlen("mode=")) == 0) {
                                s->VideoStandard = atoi(tok + strlen("mode="));
                                s->autodetect_format = FALSE;
                        } else if (strncasecmp(tok, "codec=", strlen("codec=")) == 0) {
                                tok = tok + strlen("codec=");
                                if(strcasecmp(tok, "raw") == 0)
                                        s->frame->color_spec = RAW;
                                else if(strcmp(tok, "UYVY") == 0)
                                        s->frame->color_spec = UYVY;
                                else if(strcmp(tok, "v210") == 0)
                                        s->frame->color_spec = v210;
                                else {
                                        log_msg(LOG_LEVEL_ERROR, "Wrong "
                                        "codec entered.\n");
                                        usage();
                                        goto error;
                                }
                        } else {
                                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Wrong config option '%s'!\n", tok);
                                goto error;
                        }
                        tmp = NULL;
                }
        }
        free(init_fmt);
        init_fmt = NULL;
 
        printf("[DELTACAST] Selected device %" PRIu_ULONG "\n", BrdId);
 
        if(s->autodetect_format) {
                printf("DELTACAST] We will try to autodetect incoming video format.\n");
        }
 
        /* 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, 1, 0)) {
                goto error;
        }
 
        VHD_GetBoardProperty(s->BoardHandle, VHD_CORE_BP_RX0_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 error;
        }
 
        /* Disable RX0-TX0 by-pass relay loopthrough */
        VHD_SetBoardProperty(s->BoardHandle,VHD_CORE_BP_BYPASS_RELAY_0,FALSE);
        VHD_SetBoardProperty(s->BoardHandle,VHD_CORE_BP_BYPASS_RELAY_1,FALSE);
        VHD_SetBoardProperty(s->BoardHandle,VHD_CORE_BP_BYPASS_RELAY_2,FALSE);
        VHD_SetBoardProperty(s->BoardHandle,VHD_CORE_BP_BYPASS_RELAY_3,FALSE);
 
        s->initialize_flags = vidcap_params_get_flags(params);
        printf("\nWaiting for channel locked...\n");
        try {
                if(wait_for_channel(s)) {
                        s->initialized = true;
                }
        } catch(delta_init_exception &e) {
                goto error;
        }
 
        *state = s;
        return VIDCAP_INIT_OK;
 
error:
        free(init_fmt);
 
        if (s) {
                if(s->StreamHandle) {
                        /* Close stream handle */
                        VHD_CloseStreamHandle(s->StreamHandle);
                }
                if(s->BoardHandle) {
                        /* Re-establish RX0-TX0 by-pass relay loopthrough */
                        VHD_SetBoardProperty(s->BoardHandle,VHD_CORE_BP_BYPASS_RELAY_0,TRUE);
                        VHD_CloseBoardHandle(s->BoardHandle);
                }
                vf_free(s->frame);
        }
 
        free(s);
        return VIDCAP_INIT_FAIL;
}

References vidcap_deltacast_state::audio_frame, vidcap_deltacast_state::autodetect_format, vidcap_deltacast_state::BoardHandle, video_frame::color_spec, audio_frame::data, delta_set_nb_channels(), FALSE, vidcap_deltacast_state::frame, vidcap_deltacast_state::frames, vidcap_deltacast_state::grab_audio, vidcap_deltacast_state::initialize_flags, vidcap_deltacast_state::initialized, LOG_LEVEL_ERROR, log_msg(), PRIu_ULONG, PRIX_ULONG, RAW, vidcap_deltacast_state::SlotHandle, state, vidcap_deltacast_state::StreamHandle, vidcap_deltacast_state::t0, vidcap_deltacast_state::tile, TRUE, usage(), UYVY, v210, vf_alloc(), vf_free(), vf_get_tile(), VIDCAP_INIT_FAIL, VIDCAP_INIT_NOERR, VIDCAP_INIT_OK, vidcap_params_get_flags(), vidcap_params_get_fmt(), vidcap_deltacast_state::VideoStandard, and wait_for_channel().

Here is the call graph for this function:

vidcap_deltacast_probe()

static void vidcap_deltacast_probe ( device_info ** available_cards, int * count, void(** deleter )(void *) )

static

Definition at line 118 of file deltacast.cpp.

{
        *deleter = free;
 
        ULONG             Result,DllVersion,NbBoards;
        Result = VHD_GetApiInfo(&DllVersion,&NbBoards);
        if (Result == VHDERR_NOERROR) {
                *available_cards = (struct device_info *) calloc(NbBoards, sizeof(struct device_info));
                *count = NbBoards;
                for (ULONG i = 0; i < NbBoards; ++i) {
                        auto& card = (*available_cards)[i];
                        snprintf(card.dev, sizeof(card.dev), ":device=%" PRIu_ULONG, i);
                        snprintf(card.name, sizeof(card.name), "DELTACAST SDI board %" PRIu_ULONG, i);
                        snprintf(card.extra, sizeof(card.extra), "\"embeddedAudioAvailable\":\"t\"");
                }
        }
}

References count, deleter, and PRIu_ULONG.

wait_for_channel()

static bool wait_for_channel ( struct vidcap_deltacast_state * s )

static

Function initialize is intended to be called repeatedly if no signal detected in vidcap_deltacast_init(). This will be tried everytime grab is called and until initialized.

Definition at line 153 of file deltacast.cpp.

{
        ULONG             Result;
        ULONG             Packing;
        ULONG             Status = 0;
        int               i;
        ULONG             Interface = 0;
 
        /* Wait for channel locked */
        Result = VHD_GetBoardProperty(s->BoardHandle, VHD_CORE_BP_RX0_STATUS, &Status);
 
        if (Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] ERROR : Cannot get channel status. Result = 0x%08" PRIX_ULONG "\n",Result);
                throw delta_init_exception();
        }
 
        // no signal was detected on the wire
        if(Status & VHD_CORE_RXSTS_UNLOCKED) {
                return false;
        }
 
        /* Auto-detect clock system */
        Result = VHD_GetBoardProperty(s->BoardHandle,VHD_SDI_BP_RX0_CLOCK_DIV,&s->ClockSystem);
 
        if(Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] ERROR : Cannot detect incoming clock system from RX0. Result = 0x%08" PRIX_ULONG "\n",Result);
                throw delta_init_exception();
        } else {
                printf("\nIncoming clock system : %s\n",(s->ClockSystem==VHD_CLOCKDIV_1)?"European":"American");
        }
 
         /* Select the detected clock system */
        VHD_SetBoardProperty(s->BoardHandle,VHD_SDI_BP_CLOCK_SYSTEM,s->ClockSystem);
 
        /* Create a logical stream to receive from RX0 connector */
        if(!s->autodetect_format && s->frame->color_spec == RAW)
                Result = VHD_OpenStreamHandle(s->BoardHandle,VHD_ST_RX0,VHD_SDI_STPROC_RAW,NULL,&s->StreamHandle,NULL);
        else if(s->initialize_flags & VIDCAP_FLAG_AUDIO_EMBEDDED) {
                Result = VHD_OpenStreamHandle(s->BoardHandle,VHD_ST_RX0,VHD_SDI_STPROC_JOINED,NULL,&s->StreamHandle,NULL);
        } else {
                Result = VHD_OpenStreamHandle(s->BoardHandle,VHD_ST_RX0,VHD_SDI_STPROC_DISJOINED_VIDEO,NULL,&s->StreamHandle,NULL);
        }
 
 
        if (Result != VHDERR_NOERROR)
        {
                log_msg(LOG_LEVEL_ERROR, "ERROR : Cannot open RX0 stream on DELTA-hd/sdi/codec board handle. Result = 0x%08" PRIX_ULONG "\n",Result);
                throw delta_init_exception();
        }
 
        if(s->autodetect_format) {
                /* Get auto-detected video standard */
                Result = VHD_GetStreamProperty(s->StreamHandle,VHD_SDI_SP_VIDEO_STANDARD,&s->VideoStandard);
 
                if ((Result == VHDERR_NOERROR) && (s->VideoStandard != NB_VHD_VIDEOSTANDARDS)) {
                } else {
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Cannot detect incoming video standard from RX0. Result = 0x%08" PRIX_ULONG "\n",Result);
                        throw delta_init_exception();
                }
        }
 
        for (i = 0; i < deltacast_frame_modes_count; ++i)
        {
                if(s->VideoStandard == (ULONG) deltacast_frame_modes[i].mode) {
                        s->frame->fps = deltacast_frame_modes[i].fps;
                        s->frame->interlacing = deltacast_frame_modes[i].interlacing;
                        s->tile->width = deltacast_frame_modes[i].width;
                        s->tile->height = deltacast_frame_modes[i].height;
                        Interface = deltacast_frame_modes[i].iface;
                        printf("[DELTACAST] %s mode selected. %dx%d @ %2.2f %s\n", deltacast_frame_modes[i].name, s->tile->width, s->tile->height,
                                        (double) s->frame->fps, get_interlacing_description(s->frame->interlacing));
                        break;
                }
        }
        if(i == deltacast_frame_modes_count) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Failed to obtain information about video format %" PRIu_ULONG ".\n", s->VideoStandard);
                throw delta_init_exception();
        }
 
        /* Configure stream */
        DELTA_TRY_CMD(VHD_SetStreamProperty(s->StreamHandle, VHD_SDI_SP_INTERFACE, Interface),
                        "Unable to set interface.");
        DELTA_TRY_CMD(VHD_SetStreamProperty(s->StreamHandle, VHD_SDI_SP_VIDEO_STANDARD, s->VideoStandard),
                        "Unable to set video standard.");
        DELTA_TRY_CMD(VHD_SetStreamProperty(s->StreamHandle, VHD_CORE_SP_TRANSFER_SCHEME,
                                VHD_TRANSFER_SLAVED),
                        "Unable to set transfer scheme.");
 
        if(s->autodetect_format) {
                Result = VHD_GetStreamProperty(s->StreamHandle, VHD_CORE_SP_BUFFER_PACKING, &Packing);
                if (Result != VHDERR_NOERROR) {
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Unable to get pixel format\n");
                        throw delta_init_exception();
                }
                if(Packing == VHD_BUFPACK_VIDEO_YUV422_10) {
                        s->frame->color_spec = v210;
                } else if(Packing == VHD_BUFPACK_VIDEO_YUV422_8) {
                        s->frame->color_spec = UYVY;
                } else {
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Detected unknown pixel format!\n");
                        throw delta_init_exception();
                }
        }
        if(s->frame->color_spec == v210 || s->frame->color_spec == RAW) {
                Packing = VHD_BUFPACK_VIDEO_YUV422_10;
        } else if(s->frame->color_spec == UYVY) {
                Packing = VHD_BUFPACK_VIDEO_YUV422_8;
        } else {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Unsupported pixel format\n");
                throw delta_init_exception();
        }
        printf("[DELTACAST] Pixel format '%s' selected.\n", get_codec_name(s->frame->color_spec));
        Result = VHD_SetStreamProperty(s->StreamHandle, VHD_CORE_SP_BUFFER_PACKING, Packing);
        if (Result != VHDERR_NOERROR) {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] Unable to set pixel format\n");
                throw delta_init_exception();
        }
 
        if ((s->initialize_flags & VIDCAP_FLAG_AUDIO_EMBEDDED) == 0u) {
                s->audio_frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : max(DEFAULT_AUDIO_CAPTURE_CHANNELS, 2);
                if (s->audio_frame.ch_count != 1 &&
                                s->audio_frame.ch_count != 2) {
                        log_msg(LOG_LEVEL_ERROR, "[DELTACAST capture] Unable to handle channel count other than 1 or 2.\n");
                        throw delta_init_exception();
                }
                s->audio_frame.bps = 3;
                s->audio_frame.sample_rate = 48000;
                memset(&s->AudioInfo, 0, sizeof(VHD_AUDIOINFO));
                s->pAudioChn = &s->AudioInfo.pAudioGroups[0].pAudioChannels[0];
                s->pAudioChn->Mode = s->AudioInfo.pAudioGroups[0].pAudioChannels[1].Mode= s->audio_frame.ch_count == 1 ? VHD_AM_MONO : VHD_AM_STEREO;
                s->pAudioChn->BufferFormat = s->AudioInfo.pAudioGroups[0].pAudioChannels[1].BufferFormat=VHD_AF_24;
 
                /* Get the biggest audio frame size */
                s->AudioBufferSize = VHD_GetBlockSize(s->pAudioChn->BufferFormat, s->pAudioChn->Mode) *
                        VHD_GetNbSamples((VHD_VIDEOSTANDARD) s->VideoStandard, (VHD_CLOCKDIVISOR) s->ClockSystem, VHD_ASR_48000, 0);
                s->audio_frame.max_size = s->AudioBufferSize;
                /* Create audio buffer */
                s->audio_frame.data = (char *) calloc(1, s->audio_frame.max_size);
                s->pAudioChn->pData = (BYTE *)
                        s->audio_frame.data;
 
                LOG(LOG_LEVEL_NOTICE) << "[DELTACAST] Grabbing audio enabled: " << audio_desc_from_frame(&s->audio_frame) << "\n";
                s->grab_audio = TRUE;
        }
 
        /* Start stream */
        Result = VHD_StartStream(s->StreamHandle);
        if (Result == VHDERR_NOERROR){
                printf("[DELTACAST] Stream started.\n");
        } else {
                log_msg(LOG_LEVEL_ERROR, "[DELTACAST] ERROR : Cannot start RX0 stream on DELTA-hd/sdi/codec board handle. Result = 0x%08" PRIX_ULONG "\n",Result);
                throw delta_init_exception();
        }
 
        return true;
}

References audio_capture_channels, audio_desc_from_frame(), vidcap_deltacast_state::audio_frame, vidcap_deltacast_state::AudioBufferSize, vidcap_deltacast_state::AudioInfo, vidcap_deltacast_state::autodetect_format, vidcap_deltacast_state::BoardHandle, audio_frame::bps, audio_frame::ch_count, vidcap_deltacast_state::ClockSystem, video_frame::color_spec, audio_frame::data, DEFAULT_AUDIO_CAPTURE_CHANNELS, DELTA_TRY_CMD, deltacast_frame_modes, deltacast_frame_modes_count, deltacast_frame_mode_t::fps, video_frame::fps, vidcap_deltacast_state::frame, get_codec_name(), get_interlacing_description(), vidcap_deltacast_state::grab_audio, deltacast_frame_mode_t::height, tile::height, deltacast_frame_mode_t::iface, vidcap_deltacast_state::initialize_flags, deltacast_frame_mode_t::interlacing, video_frame::interlacing, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, log_msg(), max, audio_frame::max_size, deltacast_frame_mode_t::mode, name, vidcap_deltacast_state::pAudioChn, PRIu_ULONG, PRIX_ULONG, RAW, audio_frame::sample_rate, vidcap_deltacast_state::StreamHandle, vidcap_deltacast_state::tile, TRUE, UYVY, v210, VIDCAP_FLAG_AUDIO_EMBEDDED, vidcap_deltacast_state::VideoStandard, deltacast_frame_mode_t::width, and tile::width.

Referenced by vidcap_deltacast_grab(), and vidcap_deltacast_init().

Here is the call graph for this function:

Variable Documentation

vidcap_deltacast_info

const struct video_capture_info vidcap_deltacast_info

static

Initial value:

= {
        vidcap_deltacast_probe,
        vidcap_deltacast_init,
        vidcap_deltacast_done,
        vidcap_deltacast_grab,
        VIDCAP_NO_GENERIC_FPS_INDICATOR,
}

Definition at line 566 of file deltacast.cpp.

                                                               {
        vidcap_deltacast_probe,
        vidcap_deltacast_init,
        vidcap_deltacast_done,
        vidcap_deltacast_grab,
        VIDCAP_NO_GENERIC_FPS_INDICATOR,
};