display_bluefish444_state Struct Reference

Collaboration diagram for display_bluefish444_state:

Public Member Functions
	display_bluefish444_state (unsigned int flags, int deviceId=1) noexcept(false)
virtual	~display_bluefish444_state () noexcept
void	cleanup () noexcept
struct video_frame *	getf () noexcept
void *	playback_loop () noexcept
void	putf (struct video_frame *) noexcept(false)
void	reconfigure (struct video_desc) noexcept(false)

Static Public Member Functions
static void *	playback_thread (void *arg) noexcept

Private Attributes
int	m_AttachedDevicesCount
pthread_cond_t	m_BossCv
int	m_CardFirmware
BLUE_S32	m_CardType
ULONG	m_CurrentVideoMode
int	m_deviceId
struct video_frame *	m_frame
queue< struct av_buffer * >	m_FreeFrameQueue
BLUE_U32	m_GoldenSize
ULONG	m_InvalidVideoModeFlag
unsigned long int	m_LastFieldCount
pthread_mutex_t	m_lock
uint32_t	m_magic
int	m_Offset [MAX_BLUE_OUT_CHANNELS]
bool	m_PlayAudio
struct av_buffer *	m_pPlayingBuffer
BLUEVELVETC_HANDLE	m_pSDK [MAX_BLUE_OUT_CHANNELS]
av_buffer *	m_pTmpFrame
queue< struct av_buffer * >	m_ReadyFrameQueue
pthread_t	m_thread
int	m_TileCount
pthread_cond_t	m_WorkerCv
bool	m_WorkerWaiting

Detailed Description

Definition at line 102 of file bluefish444.cpp.

Constructor & Destructor Documentation

display_bluefish444_state()

display_bluefish444_state::display_bluefish444_state	(	unsigned int	flags,
		int	deviceId = 1 )

Definition at line 158 of file bluefish444.cpp.

                                              :
        m_magic(BLUEFISH444_MAGIC),
        m_frame(NULL),
        m_deviceId(deviceId),
        m_AttachedDevicesCount(0),
        m_GoldenSize(0),
        m_LastFieldCount(0),
        m_pPlayingBuffer(NULL),
#ifdef HAVE_BLUE_AUDIO
        m_AudioRingBuffer(ring_buffer_init(48000*4*16*8)),
#endif
        m_PlayAudio(false)
{
        BLUE_S32 iDevices = 0;
        BLUE_U32 val32;
 
        if(flags) {
#ifdef HAVE_BLUE_AUDIO
                m_PlayAudio = true;
#else
                throw runtime_error("Audio support missing in this build");
#endif
        }
        pthread_mutex_init(&m_lock, NULL);
        pthread_cond_init(&m_WorkerCv, NULL);
        pthread_cond_init(&m_BossCv, NULL);
 
        BLUEVELVETC_HANDLE pSDK = bfcFactory();
        bfcEnumerate(pSDK, &iDevices);
        if(iDevices < 1) {
                bfcDestroy(pSDK);
                throw runtime_error("No Bluefish card detected");
        }
 
        bfcQueryCardType(pSDK, &m_CardType, m_deviceId);
        bfcQueryCardProperty32(pSDK, INVALID_VIDEO_MODE_FLAG, &val32);
        m_InvalidVideoModeFlag = val32;
                
        if(BLUE_FAIL(bfcAttach(pSDK, m_deviceId))) {
                bfcDestroy(pSDK);
                throw runtime_error("Unable to attach card");
        }
 
        bfcQueryCardProperty32(pSDK, EPOCH_GET_PRODUCT_ID, &val32);
 
        m_CardFirmware = val32;
        m_deviceId = deviceId;
 
        bfcDetach(pSDK);
        bfcDestroy(pSDK);
 
#ifdef HAVE_BLUE_AUDIO
        memset(&m_AudioDesc, 0, sizeof(m_AudioDesc));
        memset(&m_HancInfo, 0, sizeof(m_HancInfo));
        for(int i = 0; i < 4; ++i) {
                m_HancInfo.AudioDBNArray[i] = -1;
        }
        m_HancInfo.hanc_data_ptr = (unsigned int *) bfAlloc(MAX_HANC_SIZE);
        pthread_spin_init(&m_AudioSpinLock, 0);
#endif
 
        pthread_create(&m_thread, NULL, playback_thread, this);
}

References flags, and MAX_HANC_SIZE.

~display_bluefish444_state()

display_bluefish444_state::~display_bluefish444_state ( )

virtualnoexcept

Definition at line 223 of file bluefish444.cpp.

{
        assert(m_magic == BLUEFISH444_MAGIC);
        // Kill thread
        pthread_mutex_lock(&m_lock);
        m_ReadyFrameQueue.push(NULL);
        pthread_cond_signal(&m_WorkerCv);
        pthread_mutex_unlock(&m_lock);
        unsigned long int FieldCount;
        //cards must be genlocked; only then all for output channels are completely in synch
        bfcWaitVideoOutputSync(m_pSDK[0], UPD_FMT_FRAME, &FieldCount);
 
        pthread_join(m_thread, NULL);
 
        cleanup();
 
        pthread_mutex_destroy(&m_lock);
        pthread_cond_destroy(&m_WorkerCv);
        pthread_cond_destroy(&m_BossCv);
 
#ifdef HAVE_BLUE_AUDIO
        ring_buffer_destroy(m_AudioRingBuffer);
        bfFree(MAX_HANC_SIZE, m_HancInfo.hanc_data_ptr);
        pthread_spin_destroy(&m_AudioSpinLock);
#endif
}

References BLUEFISH444_MAGIC, cleanup(), m_BossCv, m_lock, m_magic, m_pSDK, m_ReadyFrameQueue, m_thread, m_WorkerCv, MAX_HANC_SIZE, and ring_buffer_destroy().

Here is the call graph for this function:

Member Function Documentation

cleanup()

void display_bluefish444_state::cleanup ( )

noexcept

Definition at line 453 of file bluefish444.cpp.

{
        //turn on black generator (unless we want to keep displaying the last rendered frame)
        for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                uint32_t value;
 
                value = ENUM_BLACKGENERATOR_ON;
                bfcSetCardProperty32(m_pSDK[i], VIDEO_BLACKGENERATOR, value);
 
                bfcVideoPlaybackStop(m_pSDK[i], 1, 1);
        }
 
        while(!m_FreeFrameQueue.empty()) {
                struct av_buffer *frame = m_FreeFrameQueue.front();
                m_FreeFrameQueue.pop();
                delete frame;
        }
 
        if(m_pPlayingBuffer) {
                delete m_pPlayingBuffer;
                m_pPlayingBuffer = NULL;
        }
 
        vf_free(m_frame);
        m_frame = NULL;
 
        for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                bfcDetach(m_pSDK[i]);
                bfcDestroy(m_pSDK[i]);
        }
 
        m_AttachedDevicesCount = 0;
}

References frame, m_AttachedDevicesCount, m_frame, m_FreeFrameQueue, m_pPlayingBuffer, m_pSDK, and vf_free().

Referenced by ~display_bluefish444_state().

Here is the call graph for this function:

getf()

struct video_frame * display_bluefish444_state::getf ( )

noexcept

Definition at line 702 of file bluefish444.cpp.

{
        pthread_mutex_lock(&m_lock);
        while(m_FreeFrameQueue.empty()) {
                pthread_cond_wait(&m_BossCv, &m_lock);
        }
        m_pTmpFrame = m_FreeFrameQueue.front();
        m_FreeFrameQueue.pop();
        for(int i = 0; i < m_TileCount; ++i) {
                m_frame->tiles[i].data = (char *) m_pTmpFrame->pVideoBuffer[i];
        }
        pthread_mutex_unlock(&m_lock);
 
        return m_frame;
}

References tile::data, m_BossCv, m_frame, m_FreeFrameQueue, m_lock, m_pTmpFrame, m_TileCount, av_buffer::pVideoBuffer, and video_frame::tiles.

Referenced by display_bluefish444_getf().

playback_loop()

void * display_bluefish444_state::playback_loop ( )

noexcept

Definition at line 257 of file bluefish444.cpp.

{
        uint32_t FrameCount = 0;
        struct timeval t0;
#ifdef HAVE_BLUE_AUDIO
        uint32_t EmbAudioFlag = blue_enable_hanc_timestamp_pkt | blue_emb_audio_enable; // enable timecode
#endif
 
        gettimeofday(&t0, NULL);
 
#ifdef _WIN32
        OVERLAPPED Overlapped[MAX_BLUE_OUT_CHANNELS];
        for (int i = 0;i < MAX_BLUE_OUT_CHANNELS; ++ i) {
                Overlapped[i].hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        }
#endif
 
        while(1) {
                struct av_buffer *frame;
                pthread_mutex_lock(&m_lock);
                while(m_ReadyFrameQueue.empty()) {
                        m_WorkerWaiting = true;
                        pthread_cond_wait(&m_WorkerCv, &m_lock);
                        m_WorkerWaiting = false;
                }
 
                frame = m_ReadyFrameQueue.front();
                m_ReadyFrameQueue.pop();
                pthread_mutex_unlock(&m_lock);
 
                if(frame == NULL) {
                        return NULL;
                }
 
                unsigned long int FieldCount = 0;
 
                // for more than one input, cards must be genlocked
                bfcWaitVideoOutputSync(m_pSDK[0], UPD_FMT_FRAME, &FieldCount);
                if(m_pPlayingBuffer) {
                        pthread_mutex_lock(&m_lock);
                        m_FreeFrameQueue.push(m_pPlayingBuffer);
                        pthread_cond_signal(&m_BossCv);
                        pthread_mutex_unlock(&m_lock);
                }
 
                bool WaitResult = true;
 
                for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                        unsigned char *videoBuffer;
#ifdef _WIN32
                        OVERLAPPED *OverlapCh = &Overlapped[i];
#endif
                        if(m_TileCount == m_AttachedDevicesCount) {
                                videoBuffer = (unsigned char *) frame->pVideoBuffer[i];
                        } else { // untiled 4K
                                videoBuffer = (unsigned char *) frame->pVideoBuffer[0];
                        }
#ifdef _WIN32
                        int err = bfcSystemBufferWriteAsync(
#else
                        int err = bfcSystemBufferWrite(
#endif
                                        m_pSDK[i], videoBuffer + m_Offset[i], m_GoldenSize,
#ifdef _WIN32
                                        OverlapCh,
#endif
                                        (m_PlayAudio && i == 0 ?
                                         BlueImage_HANC_DMABuffer(frame->BufferId, BLUE_DATA_IMAGE) :
                                         BlueImage_DMABuffer(frame->BufferId, BLUE_DATA_IMAGE)), 0
                                        );
                        if(!BLUE_OK(err)) {
                                cerr << "Write failed (Channel " << (char) ('A' + i) << ")" << endl;
                                WaitResult = false;
                        }
                }
#ifdef _WIN32
                if(WaitResult) {
                        for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                                DWORD BytesReturned = 0;
                                GetOverlappedResult(bfcGetHandle(m_pSDK[i]), &Overlapped[i], &BytesReturned, TRUE);
                                ResetEvent(Overlapped[i].hEvent);
                        }
                }
#else
                UNUSED(WaitResult);
#endif
 
#ifdef HAVE_BLUE_AUDIO
                if(m_PlayAudio) {
                        m_HancInfo.time_code = 0LL;                       //RP188 VITC time code
                        m_HancInfo.rp188_ltc_time_code = 0LL;     //RP188 LTC time code
                        m_HancInfo.ltc_time_code = 0LL;           //external LTC time code
                        m_HancInfo.sd_vitc_time_code = 0LL;       //this field is only valid for SD video signal
                        m_HancInfo.video_mode = m_CurrentVideoMode;
 
                        uint32_t NrSamples = 0;
                        pthread_spin_lock(&m_AudioSpinLock);
                        uint32_t NumberAudioChannels = m_AudioDesc.ch_count;
                        char audio_data[2002*4*16];
                        unsigned int nSampleType;
                        ULONG EmbAudioProp = 0;
 
                        if(NumberAudioChannels > 0) {
                                NrSamples = GetNumberOfAudioSamplesPerFrame(m_CurrentVideoMode,
                                                FrameCount);
                                switch(m_AudioDesc.bps) {
                                        case 2:
                                                nSampleType = AUDIO_CHANNEL_16BIT; // AUDIO_CHANNEL_LITTLEENDIAN
                                                break;
                                        case 3:
                                                nSampleType = AUDIO_CHANNEL_24BIT;
                                                break;
                                        default:
                                                fprintf(stderr, "[Blue] Unhandled audio sample type!\n");
                                                abort();
                                }
 
                                if(NumberAudioChannels > 0)
                                        EmbAudioProp |= (blue_emb_audio_group1_enable);
                                if(NumberAudioChannels > 4)
                                        EmbAudioProp |= (blue_emb_audio_group2_enable);
                                if(NumberAudioChannels > 8)
                                        EmbAudioProp |= (blue_emb_audio_group3_enable);
                                if(NumberAudioChannels > 12)
                                        EmbAudioProp |= (blue_emb_audio_group4_enable);
 
                                int bytes = ring_buffer_read(m_AudioRingBuffer, audio_data, NrSamples *
                                                m_AudioDesc.bps *m_AudioDesc.ch_count);
                                NrSamples = bytes / m_AudioDesc.bps / m_AudioDesc.ch_count;
                        }
                        pthread_spin_unlock(&m_AudioSpinLock);
 
                        if(NrSamples > 0) {
                                bfcEncodeHancFrameEx(m_pSDK[0], m_CardType, &m_HancInfo, audio_data,
                                                m_AudioDesc.ch_count, NrSamples,
                                                nSampleType, EmbAudioProp | EmbAudioFlag);
 
                                //wait for both DMA transfers to be finished
                                //GetOverlappedResult(pSDK->m_hDevice, &OverlapChA, &BytesReturnedChA, TRUE);
                                //ResetEvent(OverlapChA.hEvent);
 
                                //now we can DMA the HANC frame
#ifdef _WIN32
                                bfcSystemBufferWriteAsync(m_pSDK[0], (unsigned char *) m_HancInfo.hanc_data_ptr,
                                                MAX_HANC_SIZE,
                                                NULL, BlueImage_HANC_DMABuffer(frame->BufferId, BLUE_DATA_HANC));
#else
                                bfcSystemBufferWrite(m_pSDK[0], (unsigned char *) m_HancInfo.hanc_data_ptr,
                                                MAX_HANC_SIZE,
                                                BlueImage_HANC_DMABuffer(frame->BufferId, BLUE_DATA_HANC), 0);
#endif
                        }
                }
#endif
                //tell the card to playback the frames on the next interrupt
                for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                        bfcRenderBufferUpdate(m_pSDK[i],
                                        (m_PlayAudio && i == 0 ?
                                         BlueBuffer_Image_HANC(frame->BufferId) :
                                         BlueBuffer_Image(frame->BufferId))
                                        );
                }
 
                if(FieldCount != m_LastFieldCount + 2) {
                        cerr << "[Blue444 disp] " << "Dropped " <<
                                ((FieldCount - m_LastFieldCount + 2)/2) <<
                                " frames." << endl;
                }
 
                m_LastFieldCount = FieldCount;
 
                FrameCount++;
 
                struct timeval t;
                gettimeofday(&t, NULL);
                double seconds = tv_diff(t, t0);
                if (seconds >= 5) {
                        float fps  = FrameCount / seconds;
                        log_msg(LOG_LEVEL_INFO, "[Blue disp] %d frames in %g seconds = %g FPS\n",
                                        FrameCount, seconds, fps);
                        t0 = t;
                        FrameCount = 0;
                }
 
                m_pPlayingBuffer = frame;
        }
 
#ifdef _WIN32
                for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                        CloseHandle(Overlapped[i].hEvent);
                }
#endif
 
        return NULL;
}

References FALSE, frame, GetNumberOfAudioSamplesPerFrame(), LOG_LEVEL_INFO, log_msg(), m_AttachedDevicesCount, m_BossCv, m_CardType, m_CurrentVideoMode, m_FreeFrameQueue, m_GoldenSize, m_LastFieldCount, m_lock, m_Offset, m_PlayAudio, m_pPlayingBuffer, m_pSDK, m_ReadyFrameQueue, m_TileCount, m_WorkerCv, m_WorkerWaiting, MAX_BLUE_OUT_CHANNELS, MAX_HANC_SIZE, ring_buffer_read(), TRUE, tv_diff(), and UNUSED.

Referenced by playback_thread().

Here is the call graph for this function:

playback_thread()

void * display_bluefish444_state::playback_thread ( void * arg )

staticnoexcept

Definition at line 250 of file bluefish444.cpp.

{
        display_bluefish444_state *s = 
                (display_bluefish444_state *) arg;
        return s->playback_loop();
}

References playback_loop().

Here is the call graph for this function:

putf()

void display_bluefish444_state::putf

(

struct video_frame *

frame

)

Definition at line 718 of file bluefish444.cpp.

{
        if (!frame)
                return;
 
        if (frame->tiles[0].data !=
                        (char *) m_pTmpFrame->pVideoBuffer[0]) {
                throw invalid_argument("Invalid frame supplied!");
        }
 
        pthread_mutex_lock(&m_lock);
        for(int i = 0; i < m_TileCount; ++i) {
                m_pTmpFrame->pVideoBuffer[i] = (unsigned int *)(void *) m_frame->tiles[i].data;
        }
        m_ReadyFrameQueue.push(m_pTmpFrame);
        pthread_cond_signal(&m_WorkerCv);
        pthread_mutex_unlock(&m_lock);
}

References tile::data, frame, and video_frame::tiles.

Referenced by display_bluefish444_putf().

reconfigure()

void display_bluefish444_state::reconfigure

(

struct video_desc

desc

)

Definition at line 487 of file bluefish444.cpp.

{
        ULONG VideoMode;
        BLUE_U32 val32;
        bool is4K;
        bool isTiled4K;
        int tile_width, tile_height;
 
        pthread_mutex_lock(&m_lock);
        while(!m_ReadyFrameQueue.empty() ||
                !m_WorkerWaiting)
                pthread_cond_wait(&m_BossCv, &m_lock);
        pthread_mutex_unlock(&m_lock);
 
        cleanup();
 
        tile_width = desc.width;
        tile_height = desc.height;
 
        // 4K
        if((desc.width == 4096 || desc.width == 3840) && desc.height == 2160) {
                is4K = true;
                isTiled4K = false;
                tile_width /= 2;
                tile_height /= 2;
        } else if(desc.tile_count == 4 &&
                        (desc.width == 2048 || desc.width == 1920) &&
                        desc.height == 1080) {
                // tiled 4K
                is4K = true;
                isTiled4K = true;
        } else {
                is4K = false;
                isTiled4K = false;
        }
 
        m_TileCount = desc.tile_count;
 
        if(is4K) {
                // we need a SuperNova QuadOut card
                if(m_CardType != CRD_BLUE_SUPER_NOVA) {
                        throw runtime_error("We need a SuperNova card for 4K mode! "
                                        "Let us know if you need a different combination "
                                        "(eg. 2x Bluefish card");
                }
 
                if(m_CardFirmware != ORAC_4SDIOUTPUT_FIRMWARE_PRODUCTID)
                {
                        throw runtime_error("Wrong firmware; need 4 output channels (QuadOut)");
                }
                
                m_AttachedDevicesCount = 4;
        } else {
                m_AttachedDevicesCount = 1;
        }
 
        for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                m_pSDK[i] = bfcFactory();
 
                //Attach the SDK object to a specific card, in this case card 1
                if(BLUE_FAIL(bfcAttach(m_pSDK[i], m_deviceId)))
                {
                        throw runtime_error("Error on device attach");
                }
        }
 
        VideoMode = m_InvalidVideoModeFlag;
 
        for(int i = 0; i < bluefish_frame_modes_count; ++i) {
                if((int) bluefish_frame_modes[i].width == tile_width &&
                                (int) bluefish_frame_modes[i].height == tile_height &&
                                fabs(bluefish_frame_modes[i].fps - desc.fps) < 0.01 &&
                                bluefish_frame_modes[i].interlacing == desc.interlacing)
                {
                        VideoMode = 
                                bluefish_frame_modes[i].mode;
                }
        }
 
        if(VideoMode == m_InvalidVideoModeFlag) {
                ostringstream msg_ss;
                msg_ss << "Unable to find appropriate video format for " <<
                        tile_width << "x" << tile_height <<
                        get_interlacing_suffix(desc.interlacing) <<
                        " @" << fixed << setprecision(2) << desc.fps;
                throw runtime_error(msg_ss.str());
        }
 
        m_CurrentVideoMode = VideoMode;
 
        ULONG UpdateFormat = UPD_FMT_FRAME;
        ULONG MemoryFormat;
        switch(desc.color_spec) {
                case UYVY:
                        MemoryFormat = MEM_FMT_2VUY;
                        break;
                case v210:
                        MemoryFormat = MEM_FMT_V210;
                        break;
                case RGBA:
                        MemoryFormat = MEM_FMT_RGBA;
                        break;
                // case DPX10:
                //         MemoryFormat = MEM_FMT_CINEON_LITTLE_ENDIAN;
                //         break;
                default:
                        throw logic_error("Unknown video format!!!");
        }
 
        ULONG VideoEngine = VIDEO_ENGINE_FRAMESTORE;
 
        ULONG OutputChannels[4] = {
                BLUE_VIDEO_OUTPUT_CHANNEL_A,
                BLUE_VIDEO_OUTPUT_CHANNEL_B,
                BLUE_VIDEO_OUTPUT_CHANNEL_C,
                BLUE_VIDEO_OUTPUT_CHANNEL_D
        };
        ULONG Sources[4] = { EPOCH_SRC_OUTPUT_MEM_INTERFACE_CHA,
                EPOCH_SRC_OUTPUT_MEM_INTERFACE_CHB,
                EPOCH_SRC_OUTPUT_MEM_INTERFACE_CHC,
                EPOCH_SRC_OUTPUT_MEM_INTERFACE_CHD
        };
        ULONG Destinations[4] = { EPOCH_DEST_SDI_OUTPUT_A,
                EPOCH_DEST_SDI_OUTPUT_B,
                EPOCH_DEST_SDI_OUTPUT_C,
                EPOCH_DEST_SDI_OUTPUT_D
        };
 
        for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                InitOutputChannel(m_pSDK[i], OutputChannels[i],
                                UpdateFormat, MemoryFormat, VideoEngine);
                RouteChannel(m_pSDK[i], Sources[i],
                                Destinations[i],
                                BLUE_CONNECTOR_PROP_SINGLE_LINK);
        }
 
        if(m_PlayAudio) {
                //route the same audio to AES as well (AES only supports 8 channels, though)
                val32 = EPOCH_SET_ROUTING(EPOCH_SRC_OUTPUT_MEM_INTERFACE_CHA,
                                EPOCH_DEST_AES_ANALOG_AUDIO_OUTPUT, BLUE_CONNECTOR_PROP_SINGLE_LINK);
                bfcSetCardProperty32(m_pSDK[0], MR2_ROUTING, val32);
 
                val32 = blue_emb_audio_group1_enable | blue_emb_audio_enable | blue_enable_hanc_timestamp_pkt;
                bfcSetCardProperty32(m_pSDK[0], EMBEDDED_AUDIO_OUTPUT, val32);
        }
 
        //Set the required video mode
        for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                val32 = VideoMode;
                bfcSetCardProperty32(m_pSDK[i], VIDEO_MODE, val32);
                bfcQueryCardProperty32(m_pSDK[i], VIDEO_MODE, &val32);
                if(val32 != VideoMode)
                {
                        throw logic_error("Can't set video mode; FIFO running already?");
                }
        }
 
        for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                val32 = vc_get_linesize(tile_width, desc.color_spec);
                bfcSetCardProperty32(m_pSDK[i], VIDEO_IMAGE_WIDTH, val32);
                val32 = tile_height;
                bfcSetCardProperty32(m_pSDK[i], VIDEO_IMAGE_HEIGHT, val32);
                val32 = vc_get_linesize(desc.width, desc.color_spec);
                bfcSetCardProperty32(m_pSDK[i], VIDEO_IMAGE_PITCH, val32);
        }
 
        BLUE_U32 Width, Height, BytesPerLine, BytesPerFrame, GoldenSize;
        bfcGetVideoInfo(VideoMode, UpdateFormat, MemoryFormat, &Width, &Height, &BytesPerLine, &BytesPerFrame, &GoldenSize);
 
        ULONG FrameSize = GoldenSize;
        if(is4K && !isTiled4K) {
                BytesPerFrame = vc_get_linesize(desc.width, desc.color_spec) *
                        desc.height;
                // 4 * GoldenSize should be AFAIK correct but it keeps failing during
                // DMA transfer of last segment of 4K video
                FrameSize = 5 * GoldenSize;
        }
 
        cout << "Video Golden:          " << GoldenSize << endl;
        cout << "Video Pixels per line: " << Width << endl;
        cout << "Video lines:           " << Height << endl;
        cout << "Video Bytes per frame: " << BytesPerFrame << endl;
        cout << "Video Bytes per line:  " << BytesPerLine << endl;
 
        for(int i = 0; i < BUFFER_COUNT; ++i) {
                av_buffer *new_buffer = new av_buffer(desc.tile_count, FrameSize);
                m_FreeFrameQueue.push(new_buffer);
        }
 
        m_frame = vf_alloc_desc(desc);
        for(unsigned int i = 0; i < desc.tile_count; ++i) {
                m_frame->tiles[i].data_len = BytesPerFrame;
        }
 
        if(!is4K || isTiled4K) {
                m_GoldenSize = GoldenSize;
                for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                        m_Offset[i] = 0;
                }
        } else {
                m_GoldenSize = vc_get_linesize(desc.width, desc.color_spec) * tile_height;
                for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                        int x = i % 2;
                        int y = i / 2;
                        m_Offset[i] = y * m_GoldenSize + x *
                                vc_get_linesize(tile_width, desc.color_spec);
                }
        }
 
        for(int i = 0; i < m_AttachedDevicesCount; ++i) {
                bfcVideoPlaybackStart(m_pSDK[i], 0, 0);
        }
}

References av_buffer::av_buffer(), bluefish_frame_modes, bluefish_frame_modes_count, BUFFER_COUNT, cleanup(), video_desc::color_spec, desc, video_desc::fps, get_interlacing_suffix(), video_desc::height, InitOutputChannel(), bluefish_frame_mode_t::interlacing, video_desc::interlacing, bluefish_frame_mode_t::mode, RGBA, RouteChannel(), video_desc::tile_count, UYVY, v210, vc_get_linesize(), vf_alloc_desc(), and video_desc::width.

Referenced by display_bluefish444_reconfigure().

Here is the call graph for this function:

Member Data Documentation

m_AttachedDevicesCount

int display_bluefish444_state::m_AttachedDevicesCount

private

Definition at line 127 of file bluefish444.cpp.

Referenced by cleanup(), and playback_loop().

m_BossCv

pthread_cond_t display_bluefish444_state::m_BossCv

private

Definition at line 140 of file bluefish444.cpp.

Referenced by ~display_bluefish444_state(), getf(), and playback_loop().

m_CardFirmware

int display_bluefish444_state::m_CardFirmware

private

Definition at line 129 of file bluefish444.cpp.

m_CardType

BLUE_S32 display_bluefish444_state::m_CardType

private

Definition at line 128 of file bluefish444.cpp.

Referenced by playback_loop().

m_CurrentVideoMode

ULONG display_bluefish444_state::m_CurrentVideoMode

private

Definition at line 134 of file bluefish444.cpp.

Referenced by playback_loop().

m_deviceId

int display_bluefish444_state::m_deviceId

private

Definition at line 125 of file bluefish444.cpp.

m_frame

struct video_frame* display_bluefish444_state::m_frame

private

Definition at line 123 of file bluefish444.cpp.

Referenced by cleanup(), and getf().

m_FreeFrameQueue

queue<struct av_buffer *> display_bluefish444_state::m_FreeFrameQueue

private

Definition at line 144 of file bluefish444.cpp.

Referenced by cleanup(), getf(), and playback_loop().

m_GoldenSize

BLUE_U32 display_bluefish444_state::m_GoldenSize

private

Definition at line 135 of file bluefish444.cpp.

Referenced by playback_loop().

m_InvalidVideoModeFlag

ULONG display_bluefish444_state::m_InvalidVideoModeFlag

private

Definition at line 133 of file bluefish444.cpp.

m_LastFieldCount

unsigned long int display_bluefish444_state::m_LastFieldCount

private

Definition at line 136 of file bluefish444.cpp.

Referenced by playback_loop().

m_lock

pthread_mutex_t display_bluefish444_state::m_lock

private

Definition at line 138 of file bluefish444.cpp.

Referenced by ~display_bluefish444_state(), getf(), and playback_loop().

m_magic

uint32_t display_bluefish444_state::m_magic

private

Definition at line 121 of file bluefish444.cpp.

Referenced by ~display_bluefish444_state().

m_Offset

int display_bluefish444_state::m_Offset[MAX_BLUE_OUT_CHANNELS]

private

Definition at line 131 of file bluefish444.cpp.

Referenced by playback_loop().

m_PlayAudio

bool display_bluefish444_state::m_PlayAudio

private

Definition at line 155 of file bluefish444.cpp.

Referenced by playback_loop().

m_pPlayingBuffer

struct av_buffer* display_bluefish444_state::m_pPlayingBuffer

private

Definition at line 145 of file bluefish444.cpp.

Referenced by cleanup(), and playback_loop().

m_pSDK

BLUEVELVETC_HANDLE display_bluefish444_state::m_pSDK[MAX_BLUE_OUT_CHANNELS]

private

Definition at line 126 of file bluefish444.cpp.

Referenced by ~display_bluefish444_state(), cleanup(), and playback_loop().

m_pTmpFrame

av_buffer* display_bluefish444_state::m_pTmpFrame

private

Definition at line 148 of file bluefish444.cpp.

Referenced by getf().

m_ReadyFrameQueue

queue<struct av_buffer *> display_bluefish444_state::m_ReadyFrameQueue

private

Definition at line 142 of file bluefish444.cpp.

Referenced by ~display_bluefish444_state(), and playback_loop().

m_thread

pthread_t display_bluefish444_state::m_thread

private

Definition at line 141 of file bluefish444.cpp.

Referenced by ~display_bluefish444_state().

m_TileCount

int display_bluefish444_state::m_TileCount

private

Definition at line 130 of file bluefish444.cpp.

Referenced by getf(), and playback_loop().

m_WorkerCv

pthread_cond_t display_bluefish444_state::m_WorkerCv

private

Definition at line 139 of file bluefish444.cpp.

Referenced by ~display_bluefish444_state(), and playback_loop().

m_WorkerWaiting

bool display_bluefish444_state::m_WorkerWaiting

private

Definition at line 143 of file bluefish444.cpp.

Referenced by playback_loop().

---

The documentation for this struct was generated from the following file:

• src/video_display/bluefish444.cpp