bluefish444.cpp File Reference

#include <iomanip>
#include <iostream>
#include <queue>
#include "bluefish444_common.h"
#include "audio/types.h"
#include "audio/utils.h"
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "tv.h"
#include "video.h"
#include "video_capture.h"

Include dependency graph for bluefish444.cpp:

Go to the source code of this file.

Classes
struct	av_frame
struct	av_frame_base
struct	av_frame_nosignal
struct	vidcap_bluefish444_state

Macros
#define	BUFFERS   4
#define	MAX_BLUE_IN_CHANNELS   4
#define	UINT   uint32_t

Functions
static void	BailOut (BLUEVELVETC_HANDLE pSDK)
static void	InitInputChannel (BLUEVELVETC_HANDLE pSDK, uint32_t DefaultInputChannel, uint32_t UpdateFormat, uint32_t MemoryFormat, uint32_t VideoEngine)
static void	parse_fmt (struct vidcap_bluefish444_state *s, char *fmt)
	REGISTER_MODULE (bluefish444, &vidcap_bluefish444_info, LIBRARY_CLASS_VIDEO_CAPTURE, VIDEO_CAPTURE_ABI_VERSION)
void	RouteChannel (BLUEVELVETC_HANDLE pSDK, uint32_t Source, uint32_t Destination, uint32_t LinkType)
static bool	setup_audio (struct vidcap_bluefish444_state *s, unsigned int flags)
static void	show_help (void)
static void	signal_error (struct vidcap_bluefish444_state *s)
static void	SyncForSignal (struct vidcap_bluefish444_state *s)
bool	UpdateVideoMode (struct vidcap_bluefish444_state *s, uint32_t VideoMode)
static void	vidcap_bluefish444_done (void *state)
static struct video_frame *	vidcap_bluefish444_grab (void *state, struct audio_frame **audio)
static int	vidcap_bluefish444_init (struct vidcap_params *params, void **state)
static void	vidcap_bluefish444_probe (device_info **available_cards, int *count, void(**deleter)(void *))
static void	WaitForMajorInterrupt (struct vidcap_bluefish444_state *s)
static void *	worker (void *arg)

Variables
static bool	should_exit_worker = false
static const struct video_capture_info	vidcap_bluefish444_info

Detailed Description

Author

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

Definition in file bluefish444.cpp.

Macro Definition Documentation

BUFFERS

#define BUFFERS   4

Definition at line 63 of file bluefish444.cpp.

Referenced by SyncForSignal(), and worker().

MAX_BLUE_IN_CHANNELS

#define MAX_BLUE_IN_CHANNELS   4

Definition at line 65 of file bluefish444.cpp.

UINT

#define UINT   uint32_t

Definition at line 60 of file bluefish444.cpp.

Function Documentation

BailOut()

static void BailOut ( BLUEVELVETC_HANDLE pSDK )

static

Definition at line 205 of file bluefish444.cpp.

{
        bfcDetach(pSDK);
        bfcDestroy(pSDK);
}

Referenced by vidcap_bluefish444_done(), and vidcap_bluefish444_init().

InitInputChannel()

void InitInputChannel ( BLUEVELVETC_HANDLE pSDK, uint32_t DefaultInputChannel, uint32_t UpdateFormat, uint32_t MemoryFormat, uint32_t VideoEngine )

static

Definition at line 211 of file bluefish444.cpp.

{
        //MOST IMPORTANT: as the first step set the channel that we want to work with
        bfcSetCardProperty32(pSDK, DEFAULT_VIDEO_INPUT_CHANNEL, DefaultInputChannel);
 
        //make sure the FIFO hasn't been left running (e.g. application crash before), otherwise we can't change card properties
        bfcVideoCaptureStop(pSDK);
 
        bfcSetCardProperty32(pSDK, VIDEO_INPUT_UPDATE_TYPE, UpdateFormat);
 
        bfcSetCardProperty32(pSDK, VIDEO_INPUT_MEMORY_FORMAT, MemoryFormat);
 
        //Only set the Video Engine after setting up the required update type and memory format and make sure that there is a valid input signal
        bfcSetCardProperty32(pSDK, VIDEO_INPUT_ENGINE, VideoEngine);
}

Referenced by vidcap_bluefish444_init().

parse_fmt()

static void parse_fmt ( struct vidcap_bluefish444_state * s, char * fmt )

static

Definition at line 738 of file bluefish444.cpp.

                                                                     {
        char *item,
             *save_ptr = NULL;
        if(!fmt) {
                return;
        }
        while((item = strtok_r(fmt, ":", &save_ptr))) {
                if(strcasecmp(item, "framestore") == 0) {
                        s->VideoEngine = VIDEO_ENGINE_FRAMESTORE;
                } else if(strcasecmp(item, "duplex") == 0) {
                        s->VideoEngine = VIDEO_ENGINE_DUPLEX;
                } else if(strncasecmp(item, "depth=", strlen("depth=")) == 0) {
                        int depth = atoi(item + strlen("depth="));
                        if(depth == 8) {
                                s->MemoryFormat = MEM_FMT_2VUY;
                        } else if (depth == 10) {
                                s->MemoryFormat = MEM_FMT_V210;
                        } else {
                                cerr << "[Blue cap] Unsupported bit depth: " << depth << endl;
                        }
                } else if(strcasecmp(item, "subfield") == 0) {
                        s->SubField = true;
                } else if(strncasecmp(item, "device=", strlen("device=")) == 0) {
                        s->iDeviceId = atoi(item + strlen("device="));
                } else if(strcasecmp(item, "4K") == 0) {
                        s->is4K = true;
                } else {
                        cerr << "[Blue cap] Unrecognized option: " << item << endl;
                }
 
                fmt = NULL;
        }
}

References fmt, vidcap_bluefish444_state::iDeviceId, vidcap_bluefish444_state::is4K, vidcap_bluefish444_state::MemoryFormat, vidcap_bluefish444_state::SubField, and vidcap_bluefish444_state::VideoEngine.

Referenced by vidcap_bluefish444_init().

REGISTER_MODULE()

REGISTER_MODULE	(	bluefish444	,
		&	vidcap_bluefish444_info,
		LIBRARY_CLASS_VIDEO_CAPTURE	,
		VIDEO_CAPTURE_ABI_VERSION	)

RouteChannel()

void RouteChannel	(	BLUEVELVETC_HANDLE	pSDK,
		uint32_t	Source,
		uint32_t	Destination,
		uint32_t	LinkType )

Definition at line 227 of file bluefish444.cpp.

{
        uint32_t val = EPOCH_SET_ROUTING(Source, Destination, LinkType);
        bfcSetCardProperty32(pSDK, MR2_ROUTING, val);
}

References val.

Referenced by vidcap_bluefish444_init().

setup_audio()

static bool setup_audio ( struct vidcap_bluefish444_state * s, unsigned int flags )

static

Definition at line 366 of file bluefish444.cpp.

{
        memset(&s->objHancDecode, 0, sizeof(s->objHancDecode));
 
        s->audio.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
        s->objHancDecode.audio_ch_required_mask = 0;
        /* MONO_CHANNEL_9 and _10 are used for analog output */
        switch (s->audio.ch_count) {
                case 16:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_18;
                        // fall through
                case 15:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_17;
                        // fall through
                case 14:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_16;
                        // fall through
                case 13:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_15;
                        // fall through
                case 12:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_14;
                        // fall through
                case 11:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_13;
                        // fall through
                case 10:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_12;
                        // fall through
                case 9:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_11;
                        // fall through
                case 8:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_8;
                        // fall through
                case 7:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_7;
                        // fall through
                case 6:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_6;
                        // fall through
                case 5:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_5;
                        // fall through
                case 4:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_4;
                        // fall through
                case 3:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_3;
                        // fall through
                case 2:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_2;
                        // fall through
                case 1:
                        s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_1;
                        break;
                default:
                        cerr << "Too many output channels requested." << endl;
                        return false;
        }
        s->objHancDecode.type_of_sample_required = (AUDIO_CHANNEL_16BIT|AUDIO_CHANNEL_LITTLEENDIAN);
        s->objHancDecode.max_expected_audio_sample_count = 2002; // 1 frame time for 23.98 FPS
        if(flags & VIDCAP_FLAG_AUDIO_EMBEDDED) {
                s->objHancDecode.audio_input_source = AUDIO_INPUT_SOURCE_EMB;
        } else if(flags & VIDCAP_FLAG_AUDIO_AESEBU) {
                s->objHancDecode.audio_input_source = AUDIO_INPUT_SOURCE_AES;
        } else { // flags == VIDCAP_FLAG_AUDIO_ANALOG
                cerr << "[Blue cap] Analog audio not supported." << endl;
                return false;
        }
 
        s->audio.bps = 2;
        s->audio.sample_rate = 48000; // perhaps the driver does not support different
        s->audio.max_size = 4*4096*16;
 
        LOG(LOG_LEVEL_NOTICE) << "[Blue cap] audio initialized sucessfully: " << audio_desc_from_frame(&s->audio) << "\n";
        
        s->hanc_buffer = (unsigned int *) bfAlloc(MAX_HANC_SIZE);
 
        return true;
}

References vidcap_bluefish444_state::audio, audio_capture_channels, audio_desc_from_frame(), audio_frame::bps, audio_frame::ch_count, DEFAULT_AUDIO_CAPTURE_CHANNELS, flags, vidcap_bluefish444_state::hanc_buffer, LOG, LOG_LEVEL_NOTICE, MAX_HANC_SIZE, audio_frame::max_size, vidcap_bluefish444_state::objHancDecode, audio_frame::sample_rate, VIDCAP_FLAG_AUDIO_AESEBU, and VIDCAP_FLAG_AUDIO_EMBEDDED.

Referenced by vidcap_bluefish444_init().

Here is the call graph for this function:

show_help()

static void show_help ( void )

static

Definition at line 81 of file bluefish444.cpp.

{
        BLUE_S32 iDevices;
        BLUEVELVETC_HANDLE pSDK = bfcFactory();
        bfcEnumerate(pSDK, &iDevices);
        bfcDestroy(pSDK);
 
        printf("Bluefish444 capture\n");
        printf("Usage\n");
        printf("\t-t bluefish444[:framestore|:duplex][:depth={10|8}]"
                        "[:subfield][:4K][:device=<device_id>]\n");
 
        printf("\t\t4K - use 4 inputs of a SuperNova card\n");
 
        printf("\t\t<device_id> - ID of the Bluefish device (if more present)\n");
        cout << "\t\t" << iDevices << " Bluefish devices found in this system" << endl;
        if(iDevices == 1) {
                cout << " (default)" << endl;
        } else if(iDevices > 1) {
                cout << ", valid indices [1," << iDevices  << "]" << endl;
                cout << "default is 1" << endl;
        }
}

References vidcap_bluefish444_state::pSDK.

Referenced by vidcap_bluefish444_init().

signal_error()

static void signal_error ( struct vidcap_bluefish444_state * s )

static

Definition at line 449 of file bluefish444.cpp.

                                                             {
        pthread_mutex_lock(&s->lock);
        if(!s->CapturedFrame) {
                s->CapturedFrame = new av_frame_nosignal;
                pthread_cond_signal(&s->CapturedFrameReadyCV);
        }
        pthread_mutex_unlock(&s->lock);
}

References vidcap_bluefish444_state::CapturedFrame, vidcap_bluefish444_state::CapturedFrameReadyCV, and vidcap_bluefish444_state::lock.

Referenced by worker().

SyncForSignal()

static void SyncForSignal ( struct vidcap_bluefish444_state * s )

static

Definition at line 306 of file bluefish444.cpp.

{
        unsigned long int FieldCount = 0;
 
        if(s->VideoEngine == VIDEO_ENGINE_FRAMESTORE) {
                s->ScheduleID = s->CapturingID = s->DoneID = 0;
 
                if(s->SubField) {
                        WaitForMajorInterrupt(s);
                }
 
                //start the capture sequence
                // all input channels must be genlocked
                bfcWaitVideoInputSync(s->pSDK[0], s->UpdateFormat, &FieldCount);  //this call just synchronises us to the card
                for(int i = 0; i < s->attachedDevices; ++i) {
                        bfcRenderBufferCapture(s->pSDK[i], BlueBuffer_Image_HANC(s->ScheduleID));
                }
                s->CapturingID = s->ScheduleID;
                s->ScheduleID = (s->ScheduleID + 1) % BUFFERS;
                s->LastFieldCount = FieldCount;
 
                if(s->SubField) {
                        WaitForMajorInterrupt(s);
                }
 
                bfcWaitVideoInputSync(s->pSDK[0], s->UpdateFormat, &FieldCount);  //the first buffer starts to be captured now; this is it's field count
                for(int i = 0; i < s->attachedDevices; ++i) {
                        bfcRenderBufferCapture(s->pSDK[i], BlueBuffer_Image_HANC(s->ScheduleID));
                }
                s->DoneID = s->CapturingID;
                s->CapturingID = s->ScheduleID;
                s->ScheduleID = (s->ScheduleID + 1) % BUFFERS;
                s->LastFieldCount = FieldCount;
        } else {
                for(int i = 0; i < s->attachedDevices; ++i) {
                        bfcWaitVideoInputSync(s->pSDK[i], s->UpdateFormat, &FieldCount);
                }
                s->LastFieldCount = FieldCount;
        }
}

References vidcap_bluefish444_state::attachedDevices, BUFFERS, vidcap_bluefish444_state::CapturingID, vidcap_bluefish444_state::DoneID, vidcap_bluefish444_state::LastFieldCount, vidcap_bluefish444_state::pSDK, vidcap_bluefish444_state::ScheduleID, vidcap_bluefish444_state::SubField, vidcap_bluefish444_state::UpdateFormat, vidcap_bluefish444_state::VideoEngine, and WaitForMajorInterrupt().

Referenced by worker().

Here is the call graph for this function:

UpdateVideoMode()

bool UpdateVideoMode	(	struct vidcap_bluefish444_state *	s,
		uint32_t	VideoMode )

Definition at line 233 of file bluefish444.cpp.

{
        for (int i = 0; i < bluefish_frame_modes_count; ++i) {
                if(bluefish_frame_modes[i].mode == VideoMode) {
                        s->video_desc.interlacing =
                                bluefish_frame_modes[i].interlacing;
                        if(s->video_desc.interlacing == INTERLACED_MERGED) {
                                s->interlaced = true;
                        }  else {
                                s->interlaced = false;
                        }
 
                        s->video_desc.fps =
                                bluefish_frame_modes[i].fps;
                        s->video_desc.width =
                                bluefish_frame_modes[i].width;
                        s->video_desc.height =
                                bluefish_frame_modes[i].height;
 
                        streamsize ss = cout.precision();
                        cout << "[Blue cap] Format changed " <<
                                bluefish_frame_modes[i].width << "x" << 
                                bluefish_frame_modes[i].height <<
                                get_interlacing_suffix(bluefish_frame_modes[i].interlacing) <<
                                " @" << setprecision(2) << 
                                bluefish_frame_modes[i].fps << setprecision(ss) << endl;
                        return true;
                }
        }
        return false;
}

References bluefish_frame_modes, bluefish_frame_modes_count, bluefish_frame_mode_t::fps, video_desc::fps, get_interlacing_suffix(), bluefish_frame_mode_t::height, video_desc::height, vidcap_bluefish444_state::interlaced, INTERLACED_MERGED, bluefish_frame_mode_t::interlacing, video_desc::interlacing, mode, vidcap_bluefish444_state::video_desc, bluefish_frame_mode_t::width, and video_desc::width.

Referenced by worker().

Here is the call graph for this function:

vidcap_bluefish444_done()

static void vidcap_bluefish444_done ( void * state )

static

Definition at line 969 of file bluefish444.cpp.

{
        struct vidcap_bluefish444_state *s = (struct vidcap_bluefish444_state *) state;
 
        assert(s != NULL);
 
        pthread_mutex_lock(&s->lock);
        if(s->NetworkFrame) {
                if(s->NetworkFrame->valid) {
                        s->FreeFrameQueue.push(s->NetworkFrame);
                        pthread_cond_signal(&s->FreeFrameQueueNotEmptyCV);
                } else {
                        delete s->NetworkFrame;
                }
                s->NetworkFrame = NULL;
        }
        if(s->CapturedFrame) {
                delete s->CapturedFrame;
                s->CapturedFrame = NULL;
                pthread_cond_signal(&s->CapturedFrameDoneCV);
        }
        should_exit_worker = true;
        pthread_mutex_unlock(&s->lock);
        pthread_join(s->worker_id, NULL);
 
#ifdef _WIN32
        CloseHandle(s->OverlapChA.hEvent);
#endif
 
        delete s->CapturedFrame;
        delete s->NetworkFrame;
        while(!s->FreeFrameQueue.empty()) {
                delete s->FreeFrameQueue.front();
                s->FreeFrameQueue.pop();
        }
 
        bfFree(MAX_HANC_SIZE, s->hanc_buffer);
 
        for(int i = 0; i < s->attachedDevices; ++i) {
                bfcVideoCaptureStop(s->pSDK[i]);
                BailOut(s->pSDK[i]);
        }
 
        pthread_cond_destroy(&s->CapturedFrameReadyCV);
        pthread_cond_destroy(&s->CapturedFrameDoneCV);
        pthread_cond_destroy(&s->FreeFrameQueueNotEmptyCV);
 
        delete s;
}

References vidcap_bluefish444_state::attachedDevices, BailOut(), vidcap_bluefish444_state::CapturedFrame, vidcap_bluefish444_state::CapturedFrameDoneCV, vidcap_bluefish444_state::CapturedFrameReadyCV, vidcap_bluefish444_state::FreeFrameQueue, vidcap_bluefish444_state::FreeFrameQueueNotEmptyCV, vidcap_bluefish444_state::hanc_buffer, vidcap_bluefish444_state::lock, MAX_HANC_SIZE, vidcap_bluefish444_state::NetworkFrame, vidcap_bluefish444_state::pSDK, should_exit_worker, state, av_frame::valid, and vidcap_bluefish444_state::worker_id.

Here is the call graph for this function:

vidcap_bluefish444_grab()

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

static

Definition at line 1020 of file bluefish444.cpp.

{
        struct vidcap_bluefish444_state *s = (struct vidcap_bluefish444_state *) state;
 
        struct av_frame *frame;
        struct video_frame *res = NULL;
 
        *audio = NULL;
 
        pthread_mutex_lock(&s->lock);
        if(s->NetworkFrame) {
                if(s->NetworkFrame->valid) {
                        s->FreeFrameQueue.push(s->NetworkFrame);
                        pthread_cond_signal(&s->FreeFrameQueueNotEmptyCV);
                } else {
                        delete s->NetworkFrame;
                }
                s->NetworkFrame = NULL;
        }
 
        while(!s->CapturedFrame) {
                pthread_cond_wait(&s->CapturedFrameReadyCV, &s->lock);
        }
 
        if(dynamic_cast<av_frame_nosignal *>(s->CapturedFrame)) {
                delete s->CapturedFrame;
                s->CapturedFrame = NULL;
                pthread_cond_signal(&s->CapturedFrameDoneCV);
                pthread_mutex_unlock(&s->lock);
                return NULL;
        } else {
                frame = dynamic_cast<av_frame *>(s->CapturedFrame);
        }
 
        if(frame->audio_len) {
                s->audio.data = frame->audio_data;
                s->audio.data_len = frame->audio_len;
                *audio = &s->audio;
        }
 
        res = frame->video;
 
        s->NetworkFrame = frame;
        s->CapturedFrame = NULL;
        pthread_cond_signal(&s->CapturedFrameDoneCV);
 
        // Merge two fields together if needed (subfield, interlaced)
        if(res->fragment) {
                if(res->frame_fragment_id % 2 == 0) {
                        //upper field
                        res->last_fragment = FALSE;
                } else {
                        //bottom field
                        res->tiles[0].offset += res->tiles[0].data_len * 2;
                        res->frame_fragment_id &= 0xfffffffeu;
                }
                if(s->interlaced) {
                        res->interlacing = UPPER_FIELD_FIRST;
                }
        }
 
        pthread_mutex_unlock(&s->lock);
 
        return res;
}

References audio, vidcap_bluefish444_state::audio, vidcap_bluefish444_state::CapturedFrame, vidcap_bluefish444_state::CapturedFrameDoneCV, vidcap_bluefish444_state::CapturedFrameReadyCV, audio_frame::data, audio_frame::data_len, tile::data_len, FALSE, video_frame::fragment, frame, video_frame::frame_fragment_id, vidcap_bluefish444_state::FreeFrameQueue, vidcap_bluefish444_state::FreeFrameQueueNotEmptyCV, vidcap_bluefish444_state::interlaced, video_frame::interlacing, video_frame::last_fragment, vidcap_bluefish444_state::lock, vidcap_bluefish444_state::NetworkFrame, tile::offset, state, video_frame::tiles, UPPER_FIELD_FIRST, and av_frame::valid.

vidcap_bluefish444_init()

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

static

Definition at line 773 of file bluefish444.cpp.

{
        struct vidcap_bluefish444_state *s;
        ULONG InputChannels[4] = {
                BLUE_VIDEO_INPUT_CHANNEL_A,
                BLUE_VIDEO_INPUT_CHANNEL_B,
                BLUE_VIDEO_INPUT_CHANNEL_C,
                BLUE_VIDEO_INPUT_CHANNEL_D
        };
        ULONG Sources[4] = { EPOCH_SRC_SDI_INPUT_A,
                EPOCH_SRC_SDI_INPUT_B,
                EPOCH_SRC_SDI_INPUT_C,
                EPOCH_SRC_SDI_INPUT_D
        };
        ULONG Destinations[4] = { EPOCH_DEST_INPUT_MEM_INTERFACE_CHA,
                EPOCH_DEST_INPUT_MEM_INTERFACE_CHB,
                EPOCH_DEST_INPUT_MEM_INTERFACE_CHC,
                EPOCH_DEST_INPUT_MEM_INTERFACE_CHD
        };
 
        if(vidcap_params_get_fmt(params) && strcmp(vidcap_params_get_fmt(params), "help") == 0) {
                show_help();
                return VIDCAP_INIT_NOERR;
        }
 
        printf("vidcap_bluefish444_init\n");
 
        s = new vidcap_bluefish444_state;
 
        if(s == NULL) {
                printf("Unable to allocate bluefish444 capture state\n");
                return VIDCAP_INIT_FAIL;
        }
 
        s->MemoryFormat = MEM_FMT_2VUY;
        s->VideoEngine = VIDEO_ENGINE_DUPLEX;
        s->UpdateFormat = UPD_FMT_FRAME;
        s->SubField = false;
        s->iDeviceId = 1;
        s->is4K = false;
 
        char *tmp_fmt = strdup(vidcap_params_get_fmt(params));
        parse_fmt(s, tmp_fmt);
        free(tmp_fmt);
 
#ifdef _WIN32
        memset(&s->OverlapChA, 0, sizeof(s->OverlapChA));
        s->OverlapChA.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
#endif
 
        int iDevices = 0;
        s->SavedVideoMode = VID_FMT_INVALID;
 
        if(s->SubField) {
#ifdef _WIN32
                s->VideoEngine = VIDEO_ENGINE_FRAMESTORE;
                s->pIrqInfo = bfcNewVideoSyncStruct(s->pSDK);
#else
                cerr << "Subfields not supported under Linux." << endl;
                goto error;
#endif
        }
 
        if(s->is4K) {
                s->VideoEngine = VIDEO_ENGINE_FRAMESTORE;
                s->attachedDevices = 4;
                s->video_desc.tile_count = 4;
                if(s->VideoEngine == VIDEO_ENGINE_DUPLEX) {
                        cerr << "4K mode is not supported in duplex mode." << endl;
                        goto error;
                }
                if(s->SubField) {
                        cerr << "Subfields are not supported in 4K mode." << endl;
                        goto error;
                }
        } else {
                s->attachedDevices = 1;
        }
 
        for(int i = 0; i < s->attachedDevices; ++i) {
                s->pSDK[i] = bfcFactory();
        }
 
        bfcEnumerate(s->pSDK[0], &iDevices);
        if(iDevices < 1) {
                cout << "No Bluefish device detected." << endl;
                goto error;
        }
 
        for(int i = 0; i < s->attachedDevices; ++i) {
                if(BLUE_FAIL(bfcAttach(s->pSDK[i], s->iDeviceId))) {
                        cerr << "Error on device attach (channel " <<
                                (char)('A' + i) << ")"  << endl;
                        goto error;
                }
        }
 
        if(s->is4K) {
                BLUE_U32 firmware;
                int iCardType = CRD_INVALID;
                bfcQueryCardType(s->pSDK[0], &iCardType, s->iDeviceId);
                bfcQueryCardProperty32(s->pSDK[0], EPOCH_GET_PRODUCT_ID, &firmware);
 
                if (iCardType != CRD_BLUE_SUPER_NOVA) {
                        cerr << "4K supported only for a SuperNova card!" << endl;
                        goto error;
                }
                if(firmware != ORAC_4SDIINPUT_FIRMWARE_PRODUCTID) {
                         cerr << "Wrong firmware; need 4 input channels (QuadIn)";
                         goto error;
                }
        }
 
        for(int i = 0; i < s->attachedDevices; ++i) {
                InitInputChannel(s->pSDK[i], InputChannels[i], s->UpdateFormat, s->MemoryFormat, s->VideoEngine);
                RouteChannel(s->pSDK[i], Sources[i], Destinations[i], BLUE_CONNECTOR_PROP_SINGLE_LINK);
        }
 
        //Get VID_FMT_INVALID flag; this enum has changed over time and might be different depending on which driver this application runs on
        BLUE_U32 val32;
        bfcQueryCardProperty32(s->pSDK[0], INVALID_VIDEO_MODE_FLAG, &val32);
        s->InvalidVideoModeFlag = val32;
 
        s->LastFieldCount = 0;
 
        s->frames = 0;
        gettimeofday(&s->t0, NULL);
 
        s->video_desc.tile_count = s->attachedDevices;
        if(s->MemoryFormat == MEM_FMT_2VUY) {
                s->video_desc.color_spec = UYVY;
        } else { // MEM_FMT_V210
                s->video_desc.color_spec = v210;
        }
        
        // make sure that capture is stopped
        for(int i = 0; i < s->attachedDevices; ++i) {
                bfcVideoCaptureStop(s->pSDK[i]);
                if(BLUE_FAIL(bfcVideoCaptureStart(s->pSDK[i]))) {
                        /* is this really needed? Sometimes this command keeps failing but
                         * we can stil go on, so ignore this error */
                        //cerr << "Error video capture start failed on channel A" << endl;
                        //goto error;
                }
        }
 
        gettimeofday(&s->t0, NULL);
 
        s->grab_audio = false;
        s->audio.data = NULL;
        s->audio.max_size = 0;
        s->hanc_buffer = NULL;
#ifdef HAVE_BLUE_AUDIO
        if(vidcap_params_get_flags(params)) {
                if(s->SubField) {
                        cerr << "[Blue cap] Unable to grab audio in sub-field mode." << endl;
                        goto error;
                }
                bool ret = setup_audio(s, vidcap_params_get_flags(params));
                if(ret == false) {
                        cerr << "[Blue cap] Unable to setup audio." << endl;
                        goto error;
                } else {
                        s->grab_audio = true;
                }
        }
#else
        if(vidcap_params_get_flags(params)) {
                cerr << "[Blue cap] Unable to capture audio. Support isn't compiled in." << endl;
                goto error;
        }
#endif
 
        pthread_mutex_init(&s->lock, NULL);
        pthread_cond_init(&s->CapturedFrameReadyCV, NULL);
        pthread_cond_init(&s->CapturedFrameDoneCV, NULL);
        pthread_cond_init(&s->FreeFrameQueueNotEmptyCV, NULL);
        s->NetworkFrame = NULL;
        s->CapturedFrame = NULL;
 
        if(pthread_create(&s->worker_id, NULL, worker, (void *) s) != 0) {
                cerr << "[Blue cap] Error initializing thread." << endl;
                goto error;
        }
 
        *state = s;
        return VIDCAP_INIT_OK;
 
error:
        for(int i = 0; i < s->attachedDevices; ++i) {
                BailOut(s->pSDK[i]);
        }
        delete s;
        return VIDCAP_INIT_FAIL;
}

References vidcap_bluefish444_state::attachedDevices, vidcap_bluefish444_state::audio, BailOut(), vidcap_bluefish444_state::CapturedFrame, vidcap_bluefish444_state::CapturedFrameDoneCV, vidcap_bluefish444_state::CapturedFrameReadyCV, video_desc::color_spec, audio_frame::data, FALSE, vidcap_bluefish444_state::frames, vidcap_bluefish444_state::FreeFrameQueueNotEmptyCV, vidcap_bluefish444_state::grab_audio, vidcap_bluefish444_state::hanc_buffer, vidcap_bluefish444_state::iDeviceId, InitInputChannel(), vidcap_bluefish444_state::InvalidVideoModeFlag, vidcap_bluefish444_state::is4K, vidcap_bluefish444_state::LastFieldCount, vidcap_bluefish444_state::lock, audio_frame::max_size, vidcap_bluefish444_state::MemoryFormat, vidcap_bluefish444_state::NetworkFrame, parse_fmt(), vidcap_bluefish444_state::pSDK, RouteChannel(), vidcap_bluefish444_state::SavedVideoMode, setup_audio(), show_help(), state, vidcap_bluefish444_state::SubField, vidcap_bluefish444_state::t0, video_desc::tile_count, TRUE, vidcap_bluefish444_state::UpdateFormat, UYVY, v210, VIDCAP_INIT_FAIL, VIDCAP_INIT_NOERR, VIDCAP_INIT_OK, vidcap_params_get_flags(), vidcap_params_get_fmt(), vidcap_bluefish444_state::video_desc, vidcap_bluefish444_state::VideoEngine, worker(), and vidcap_bluefish444_state::worker_id.

Here is the call graph for this function:

vidcap_bluefish444_probe()

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

static

Definition at line 347 of file bluefish444.cpp.

{
        *deleter = free;
 
        BLUE_S32 iDevices;
        BLUEVELVETC_HANDLE pSDK = bfcFactory();
        bfcEnumerate(pSDK, &iDevices);
        bfcDestroy(pSDK);
 
        *count = iDevices;
        *available_cards = (struct device_info *) calloc(iDevices, sizeof(struct device_info));
        for (int i = 0; i < iDevices; ++i) {
                auto& card = (*available_cards)[i];
                snprintf(card.dev, sizeof(card.dev), ":device=%d", i + 1);
                snprintf(card.name, sizeof(card.name), "Bluefish444 card #%d", i);
        }
}

References count, and deleter.

WaitForMajorInterrupt()

static void WaitForMajorInterrupt ( struct vidcap_bluefish444_state * s )

static

Definition at line 276 of file bluefish444.cpp.

{
#ifdef _WIN32
        assert(s->attachedDevices == 1);
 
        BOOL bWaitForField = TRUE;
 
        //We need to wait for a major interrupt (sub field interrupt == 0) before we schedule a frame to be captured
        UINT SubFieldIrqs = 0;
        UINT VideoMsc = 0;
        DWORD IrqReturn = 0;
        do
        {
                bfcVideoSyncStructSet(s->pSDK[0], s->pIrqInfo, BLUE_VIDEO_INPUT_CHANNEL_A,
                                s->UpdateFormat,
                                IGNORE_SYNC_WAIT_TIMEOUT_VALUE);
                bfcWaitVideoSyncAsync(s->pSDK[0], &s->OverlapChA, s->pIrqInfo);
                IrqReturn = WaitForSingleObject(s->OverlapChA.hEvent, 1000);
                CompleteBlueAsyncReq(bfcGetHandle(s->pSDK[0]), &s->OverlapChA);
 
                bfcVideoSyncStructGet(s->pSDK[0], s->pIrqInfo, VideoMsc, SubFieldIrqs);
                if(s->video_desc.interlacing == PROGRESSIVE || (VideoMsc & 0x1))
                        bWaitForField = FALSE;
 
        }while(!((SubFieldIrqs == 0) && !bWaitForField));       //we need to schedule the field capture when SubFieldIrqs is 0
#else
        UNUSED(s);
#endif
}

References vidcap_bluefish444_state::attachedDevices, FALSE, video_desc::interlacing, PROGRESSIVE, vidcap_bluefish444_state::pSDK, TRUE, UNUSED, vidcap_bluefish444_state::UpdateFormat, and vidcap_bluefish444_state::video_desc.

Referenced by SyncForSignal().

worker()

static void * worker ( void * arg )

static

Definition at line 458 of file bluefish444.cpp.

{
        struct vidcap_bluefish444_state *s =
                (struct vidcap_bluefish444_state *) arg;
        uint32_t GoldenSize = 0;
        uint32_t ChunkSize = 0;
        uint32_t nChunks = 1;
        unsigned long int FieldCount = 0;
 
        while(!should_exit_worker) {
                BLUE_U32 val32;
                UINT SubFieldIrqs = 0;
                uint32_t VideoMode = VID_FMT_INVALID;
                int BufferId = -1;
                int     hanc_buffer_id=-1;         // flags required for starting audio capture
 
                blue_videoframe_info_ex FrameInfo;
 
                unsigned long int CurrentFieldCount = FieldCount;
                struct av_frame *current_frame = NULL;
                int nOffset = 0;
 
                // Synchronize
                if(!s->SubField || s->SavedVideoMode == VID_FMT_INVALID) {
                        //Check if we have a valid input signal, all cards should be in sync
                        bfcWaitVideoInputSync(s->pSDK[0], s->UpdateFormat, &FieldCount); //synchronise with the card before querying VIDEO_INPUT_SIGNAL_VIDEO_MODE
 
                        for(int i = 0; i < s->attachedDevices; ++i) {
                                bfcQueryCardProperty32(s->pSDK[i], VIDEO_INPUT_SIGNAL_VIDEO_MODE, &val32);
                                if(val32 >= VID_FMT_INVALID)
                                {
                                        cerr << "No valid input signal on channel " <<
                                               (char)('A' + i) << endl;
                                        signal_error(s);
                                        goto next_iteration;
                                }
                                if(i == 0) {
                                        VideoMode = val32;
                                } else {
                                        if(val32 != VideoMode) {
                                                cerr << "Different signal detected on channel " <<
                                                        (char)('A' + i) << " than on " <<
                                                       "channel A" << endl;
                                                signal_error(s);
                                                goto next_iteration;
                                        }
                                }
                        }
 
                } else {
#ifdef _WIN32
                        DWORD IrqReturn = 0;
                        UINT VideoMsc = 0;
                        // we do not allow mode change when in subfield mode
                        VideoMode = s->SavedVideoMode;
 
                        bfcVideoSyncStructSet(s->pSDK[0], s->pIrqInfo, BLUE_VIDEO_INPUT_CHANNEL_A,
                                        s->UpdateFormat,
                                        IGNORE_SYNC_WAIT_TIMEOUT_VALUE);
                        bfcWaitVideoSyncAsync(s->pSDK[0], &s->OverlapChA, s->pIrqInfo);
                        IrqReturn = WaitForSingleObject(s->OverlapChA.hEvent, 1000);
                        CompleteBlueAsyncReq(bfcGetHandle(s->pSDK[0]), &s->OverlapChA);
 
                        bfcVideoSyncStructGet(s->pSDK[0], s->pIrqInfo, VideoMsc, SubFieldIrqs);
                        //cerr <<FieldCount <<" " << SubFieldIrqs <<endl;
                        if(SubFieldIrqs == 0) {
                                FieldCount = VideoMsc;
                        }
#endif
                }
 
                if(s->LastFieldCount + 2 < FieldCount)
                {
                        cout << "Error: dropped " << ((FieldCount - s->LastFieldCount + 2)/2) << " frames" << endl;
                }
 
                // check for mode change
                if(s->SavedVideoMode != VideoMode) {
                        if(UpdateVideoMode(s, VideoMode)) {
                                // mode changed
                                pthread_mutex_lock(&s->lock);
                                if(s->NetworkFrame) {
                                        s->NetworkFrame->valid = false;
                                }
                                while(s->CapturedFrame) {
                                        pthread_cond_wait(&s->CapturedFrameDoneCV, &s->lock);
                                }
                                while(!s->FreeFrameQueue.empty()) {
                                        struct av_frame *frame = s->FreeFrameQueue.front();
                                        s->FreeFrameQueue.pop();
                                        delete frame;
                                }
 
                                s->SavedVideoMode = VideoMode;
 
                                uint32_t val32 = 0; // no subfield interrupts
                                if(s->SubField) {
                                        if(s->interlaced) {
                                                s->UpdateFormat = UPD_FMT_FIELD;
                                                val32 = 2;
                                        } else { // progressive
                                                if(s->video_desc.fps > 25) {
                                                        val32 = 2;
                                                } else {
                                                        val32 = 4;
                                                }
                                        }
                                }
 
                                BLUE_U32 Width, Height, BytesPerLine, BytesPerFrame;
                                bfcGetVideoInfo(VideoMode, s->UpdateFormat, s->MemoryFormat, &Width, &Height, &BytesPerLine, &BytesPerFrame, &GoldenSize);
                                ChunkSize = BytesPerFrame;
                                nChunks = 1;
 
                                for(int i = 0; i < 2; ++i) {
                                        s->FreeFrameQueue.push(new av_frame(s->video_desc, GoldenSize, BytesPerFrame,
                                                                s->audio.max_size));
                                }
                                pthread_mutex_unlock(&s->lock);
 
                                for(int i = 0; i < s->attachedDevices; ++i) {
                                        bfcSetCardProperty32(s->pSDK[i], VIDEO_INPUT_UPDATE_TYPE,
                                                        s->UpdateFormat);
                                        bfcSetCardProperty32(s->pSDK[i], EPOCH_SUBFIELD_INPUT_INTERRUPTS,
                                                        val32);
                                }
                                if(val32) {
                                        ChunkSize /= val32;
                                        nChunks = val32;
                                } else {
                                        ChunkSize = GoldenSize;
                                }
                                cout << "Golden       : " << GoldenSize << endl <<
                                        "BytesPerFrame: " << BytesPerFrame << endl <<
                                        "ChunkSize    : " << ChunkSize << endl;
 
                        } else {
                                cerr << "[Blue422 cap] Fatal: unknown video mode: " << VideoMode << endl;
                                signal_error(s);
                                goto next_iteration;
                        }
                        SyncForSignal(s);
                }
 
                pthread_mutex_lock(&s->lock);
                while(s->FreeFrameQueue.empty()) {
                        pthread_cond_wait(&s->FreeFrameQueueNotEmptyCV, &s->lock);
                }
                current_frame = s->FreeFrameQueue.front();
                s->FreeFrameQueue.pop();
                pthread_mutex_unlock(&s->lock);
 
                if(s->VideoEngine == VIDEO_ENGINE_DUPLEX) {
#ifdef _WIN32
                        unsigned int FifoSize = 0;
                        if(BLUE_FAIL(bfcGetCaptureVideoFrameInfoEx(s->pSDK[0], &s->OverlapChA, FrameInfo,
                                                        0, &FifoSize))) {
                                cerr << "Capture frame failed!" << endl;
                                signal_error(s);
                                goto next_iteration;
                        }
#else
                        if(BLUE_FAIL(bfcGetCaptureVideoFrameInfoEx(s->pSDK[0], &FrameInfo))) {
                                cerr << "Capture frame failed!" << endl;
                                signal_error(s);
                                goto next_iteration;
                        }
#endif
 
                        if(FrameInfo.nVideoSignalType >= s->InvalidVideoModeFlag) {
                                cerr << "Invalid video mode!" << endl;
                                signal_error(s);
                                goto next_iteration;
                        }
 
                        if(FrameInfo.BufferId == -1) {
                                cerr << "No buffer!" << endl;
                                signal_error(s);
                                goto next_iteration;
                        }
                        BufferId = FrameInfo.BufferId;
                } else {
                        BufferId = s->DoneID;
                }
 
                if(s->SubField) {
                        if(SubFieldIrqs == 0) {
                                nOffset = (nChunks - 1) * ChunkSize;
                                current_frame->video->last_fragment = TRUE;
                        } else {
                                nOffset = (SubFieldIrqs - 1) * ChunkSize;
                                current_frame->video->last_fragment = FALSE;
                        }
                        current_frame->video->tiles[0].data_len = ChunkSize;
                        current_frame->video->fragment = TRUE;
                        current_frame->video->tiles[0].offset = nOffset;
                        current_frame->video->frame_fragment_id = CurrentFieldCount & 0x3fff;
                }
 
                //DMA the frame from the card to our buffer
                for(int i = 0; i < s->attachedDevices; ++i) {
#ifdef _WIN32
                        bfcSystemBufferReadAsync(s->pSDK[i], (unsigned char *)
                                        current_frame->video->tiles[i].data,
                                        ChunkSize, NULL,
                                        BlueImage_HANC_DMABuffer(BufferId, BLUE_DATA_IMAGE), nOffset);
#else
                        bfcSystemBufferRead(s->pSDK[i], (unsigned char *)
                                        current_frame->video->tiles[i].data,
                                        ChunkSize,
                                        BlueImage_HANC_DMABuffer(BufferId, BLUE_DATA_IMAGE), nOffset);
#endif
                }
 
#ifdef HAVE_BLUE_AUDIO
                if(s->UpdateFormat == UPD_FMT_FRAME) {
                        hanc_buffer_id = BufferId;
                }
 
                if(s->grab_audio && hanc_buffer_id != -1) {
#ifdef _WIN32
                        bfcSystemBufferReadAsync(s->pSDK[0], (unsigned char *) s->hanc_buffer, MAX_HANC_SIZE, NULL, BlueImage_HANC_DMABuffer(BufferId, BLUE_DATA_HANC));
#else
                        bfcSystemBufferRead(s->pSDK[0], (unsigned char *) s->hanc_buffer, MAX_HANC_SIZE, BlueImage_HANC_DMABuffer(BufferId, BLUE_DATA_HANC), 0);
#endif
                        s->objHancDecode.audio_pcm_data_ptr = current_frame->audio_data;
                        int iCardType = CRD_INVALID;
                        bfcQueryCardType(s->pSDK[0], &iCardType, s->iDeviceId);
                        bfcDecodeHancFrameEx(s->pSDK[0], iCardType, (unsigned int *) s->hanc_buffer,
                                        &s->objHancDecode);
                        current_frame->audio_len = s->objHancDecode.no_audio_samples *
                                s->audio.bps;
                }
#endif
 
 
                if(s->VideoEngine == VIDEO_ENGINE_FRAMESTORE) {
                        if(!s->SubField || SubFieldIrqs == 0) {
                                //tell the card to capture another frame at the next interrupt
                                for(int i = 0; i < s->attachedDevices; ++i) {
                                        bfcRenderBufferCapture(s->pSDK[i],
                                                        BlueBuffer_Image_HANC(s->ScheduleID));
                                }
 
                                s->DoneID = s->CapturingID;
                                s->CapturingID = s->ScheduleID;
                                s->ScheduleID = (s->ScheduleID + 1) % BUFFERS;
                        }
                }
 
                s->LastFieldCount = FieldCount;
                if(!s->SubField || SubFieldIrqs == 0) {
                        s->frames++;
 
                        struct timeval t;
                        gettimeofday(&t, NULL);
                        double seconds = tv_diff(t, s->t0);
                        if (seconds >= 5) {
                                float fps  = s->frames / seconds;
                                log_msg(LOG_LEVEL_INFO, "[Blue cap] %d frames in %g seconds = %g FPS\n", s->frames, seconds, fps);
                                s->t0 = t;
                                s->frames = 0;
                        }
                }
 
                pthread_mutex_lock(&s->lock);
                while(s->CapturedFrame) {
                        pthread_cond_wait(&s->CapturedFrameDoneCV, &s->lock);
                }
                s->CapturedFrame = current_frame;
                pthread_cond_signal(&s->CapturedFrameReadyCV);
                pthread_mutex_unlock(&s->lock);
 
next_iteration:
                ;
        }
 
        return NULL;
}

References av_frame::av_frame(), vidcap_bluefish444_state::attachedDevices, vidcap_bluefish444_state::audio, av_frame::audio_data, av_frame::audio_len, audio_frame::bps, BUFFERS, vidcap_bluefish444_state::CapturedFrame, vidcap_bluefish444_state::CapturedFrameDoneCV, vidcap_bluefish444_state::CapturedFrameReadyCV, vidcap_bluefish444_state::CapturingID, tile::data, tile::data_len, vidcap_bluefish444_state::DoneID, FALSE, video_desc::fps, video_frame::fragment, frame, video_frame::frame_fragment_id, vidcap_bluefish444_state::frames, vidcap_bluefish444_state::FreeFrameQueue, vidcap_bluefish444_state::FreeFrameQueueNotEmptyCV, vidcap_bluefish444_state::grab_audio, vidcap_bluefish444_state::hanc_buffer, vidcap_bluefish444_state::iDeviceId, vidcap_bluefish444_state::interlaced, vidcap_bluefish444_state::InvalidVideoModeFlag, video_frame::last_fragment, vidcap_bluefish444_state::LastFieldCount, vidcap_bluefish444_state::lock, LOG_LEVEL_INFO, log_msg(), MAX_HANC_SIZE, audio_frame::max_size, vidcap_bluefish444_state::MemoryFormat, vidcap_bluefish444_state::NetworkFrame, vidcap_bluefish444_state::objHancDecode, tile::offset, vidcap_bluefish444_state::pSDK, vidcap_bluefish444_state::SavedVideoMode, vidcap_bluefish444_state::ScheduleID, should_exit_worker, signal_error(), vidcap_bluefish444_state::SubField, SyncForSignal(), vidcap_bluefish444_state::t0, video_frame::tiles, TRUE, tv_diff(), vidcap_bluefish444_state::UpdateFormat, UpdateVideoMode(), av_frame::valid, av_frame::video, vidcap_bluefish444_state::video_desc, and vidcap_bluefish444_state::VideoEngine.

Referenced by vidcap_bluefish444_init().

Here is the call graph for this function:

Variable Documentation

should_exit_worker

bool should_exit_worker = false

static

Definition at line 79 of file bluefish444.cpp.

Referenced by vidcap_bluefish444_done(), and worker().

vidcap_bluefish444_info

const struct video_capture_info vidcap_bluefish444_info

static

Initial value:

= {
        vidcap_bluefish444_probe,
        vidcap_bluefish444_init,
        vidcap_bluefish444_done,
        vidcap_bluefish444_grab,
        VIDCAP_NO_GENERIC_FPS_INDICATOR,
}

Definition at line 1086 of file bluefish444.cpp.

                                                                 {
        vidcap_bluefish444_probe,
        vidcap_bluefish444_init,
        vidcap_bluefish444_done,
        vidcap_bluefish444_grab,
        VIDCAP_NO_GENERIC_FPS_INDICATOR,
};