bitflow.cpp File Reference

#include "bitflow/BFciLib.h"
#include <inttypes.h>
#include "debug.h"
#include "lib_common.h"
#include "video.h"
#include "video_capture.h"

Include dependency graph for bitflow.cpp:

Go to the source code of this file.

Classes
struct	vidcap_state_bitflow

Functions
static void	debayer (char *out, char *in, int width, int height)
static float	get_fps (struct vidcap_state_bitflow *s)
static bool	map_frame_buffers (struct vidcap_state_bitflow *s)
	REGISTER_MODULE (bitflow, &vidcap_bitflow_info, LIBRARY_CLASS_VIDEO_CAPTURE, VIDEO_CAPTURE_ABI_VERSION)
static bool	reset_acquisition (struct vidcap_state_bitflow *s)
static void	restartAcquisition (struct vidcap_state_bitflow *s)
static bool	start_acquisition (struct vidcap_state_bitflow *s)
static void	vidcap_bitflow_done (void *state)
static struct video_frame *	vidcap_bitflow_grab (void *state, struct audio_frame **audio)
static int	vidcap_bitflow_init (struct vidcap_params *params, void **state)
static void	vidcap_bitflow_probe (device_info **available_cards, int *count, void(**deleter)(void *))

Variables
static const struct video_capture_info	vidcap_bitflow_info

Detailed Description

Author

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

Definition in file bitflow.cpp.

Function Documentation

debayer()

static void debayer ( char * out, char * in, int width, int height )

static

Definition at line 224 of file bitflow.cpp.

{
        for (int y = 0; y < height; y += 2) {
                for (int x = 0; x < width; ++x) {
                        *out++ = in[x + 1];
                        *out++ = in[x];
                        *out++ = in[x + width];
                }
                for (int x = 0; x < width; ++x) {
                        *out++ = in[x + 1];
                        *out++ = in[x + width + 1];
                        *out++ = in[x + width];
                }
 
                in += 2 * width;
        }
}

Referenced by vidcap_bitflow_grab().

get_fps()

static float get_fps ( struct vidcap_state_bitflow * s )

static

Definition at line 111 of file bitflow.cpp.

                                                     {
        tCIRC circ;
        tCITDP cfgFN, cfg, camFN, cam, firmFN, firm, serial, cxp, spare;
 
        if (kCIEnoErr != (circ = CiVFGinquire2(s->sCIp, &cfgFN, &cfg, &camFN,
                                        &cam, &firmFN, &firm, &serial, &cxp, &spare))) {
                log_msg(LOG_LEVEL_ERROR, "CiVFGinquire gave '%s'\n", CiErrStr(circ));
                return 0.0f;
        }
 
        int x = 0;
        while (cam[x].descriptor != NULL) {
                if (strcmp(cam[x].descriptor, "CAMREGAFTER") == 0) {
                        tCIU32  *ptr = (tCIU32 *)(cam[x].datap);
                        int y = *ptr++;
                        while (y-- > 0) {
                                if (ptr[0] == 0x000200C4) {
                                        return *(float *) (ptr + 1);
                                }
                                ptr += 2;
                        }
                }
                x += 1;
        }
 
        return 0;
}

References LOG_LEVEL_ERROR, log_msg(), and vidcap_state_bitflow::sCIp.

Referenced by vidcap_bitflow_init().

Here is the call graph for this function:

map_frame_buffers()

static bool map_frame_buffers ( struct vidcap_state_bitflow * s )

static

Definition at line 64 of file bitflow.cpp.

                                                              {
        tCIRC circ;
        if (kCIEnoErr != (circ = CiMapFrameBuffers(s->sCIp,
                                        0, // 0-read only, 1- read/write
                                        &s->nPtrs,
                                        &s->uPtrs)))
        {
                log_msg(LOG_LEVEL_ERROR, "CiMapFrameBuffers gave '%s'\n",CiErrStr(circ));
                if ((NULL != s->uPtrs) && (kCIEnoErr != (circ = CiUnmapFrameBuffers(s->sCIp)))){
                        log_msg(LOG_LEVEL_ERROR, "CiUnmapFrameBuffers gave '%s'\n",CiErrStr(circ));
                }
                return false;
        }
        if (s->nPtrs != s->nFrames) {
                log_msg(LOG_LEVEL_ERROR, "Error requested - %" PRIu32 ", mapped :%p\n", s->nFrames, s->nPtrs);
        }
 
        return true;
}

References LOG_LEVEL_ERROR, log_msg(), vidcap_state_bitflow::nFrames, vidcap_state_bitflow::nPtrs, vidcap_state_bitflow::sCIp, and vidcap_state_bitflow::uPtrs.

Referenced by restartAcquisition(), and vidcap_bitflow_init().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	bitflow	,
		&	vidcap_bitflow_info,
		LIBRARY_CLASS_VIDEO_CAPTURE	,
		VIDEO_CAPTURE_ABI_VERSION	)

reset_acquisition()

static bool reset_acquisition ( struct vidcap_state_bitflow * s )

static

Definition at line 84 of file bitflow.cpp.

                                                              {
        tCIRC circ;
        if (kCIEnoErr != (circ = CiAqSWreset(s->sCIp))) {
                log_msg(LOG_LEVEL_ERROR, "CiAqSWreset gave '%s'\n", CiErrStr(circ));
                if ((NULL != s->uPtrs) && (kCIEnoErr != (circ = CiUnmapFrameBuffers(s->sCIp)))){
                        log_msg(LOG_LEVEL_ERROR, "CiUnmapFrameBuffers gave '%s'\n",CiErrStr(circ));
                }
                return false;
        }
 
        return true;
}

References LOG_LEVEL_ERROR, log_msg(), vidcap_state_bitflow::sCIp, and vidcap_state_bitflow::uPtrs.

Referenced by restartAcquisition(), and vidcap_bitflow_init().

Here is the call graph for this function:

restartAcquisition()

static void restartAcquisition ( struct vidcap_state_bitflow * s )

static

Definition at line 242 of file bitflow.cpp.

{
        if (!map_frame_buffers(s)) {
                goto fail;
        }
 
        if (!reset_acquisition(s)) {
                goto fail;
        }
 
        if (!start_acquisition(s)) {
                goto fail;
        }
 
        return;
fail:
        log_msg(LOG_LEVEL_FATAL, "[bitflow] Unable to restart acquisition!\n");
        exit_uv(1);
}

References exit_uv(), LOG_LEVEL_FATAL, log_msg(), map_frame_buffers(), reset_acquisition(), and start_acquisition().

Referenced by vidcap_bitflow_grab().

Here is the call graph for this function:

start_acquisition()

static bool start_acquisition ( struct vidcap_state_bitflow * s )

static

Definition at line 97 of file bitflow.cpp.

                                                              {
        tCIRC circ;
        int numberOfFrames = 0;
        if (kCIEnoErr != (circ = CiAqStart(s->sCIp, numberOfFrames))) // 0-continous, n-frame number
        {
                log_msg(LOG_LEVEL_ERROR, "CiAqStart gave '%s'\n",CiErrStr(circ));
                if ((NULL != s->uPtrs) && (kCIEnoErr != (circ = CiUnmapFrameBuffers(s->sCIp)))){
                        log_msg(LOG_LEVEL_ERROR, "CiUnmapFrameBuffers gave '%s'\n",CiErrStr(circ));
                }
                return false;
        }
        return true;
}

References LOG_LEVEL_ERROR, log_msg(), vidcap_state_bitflow::sCIp, and vidcap_state_bitflow::uPtrs.

Referenced by restartAcquisition(), and vidcap_bitflow_init().

Here is the call graph for this function:

vidcap_bitflow_done()

static void vidcap_bitflow_done ( void * state )

static

Definition at line 203 of file bitflow.cpp.

{
        struct vidcap_state_bitflow *s = (struct vidcap_state_bitflow *) state;
        tCIRC circ;
 
        /*
         **  Unmap the frame buffers.
         */
        if ((NULL != s->uPtrs) && (kCIEnoErr != (circ = CiUnmapFrameBuffers(s->sCIp)))){
                log_msg(LOG_LEVEL_ERROR, "CiUnmapFrameBuffers gave '%s'\n",CiErrStr(circ));
        }
        /*
         **  Close the access.
         */
        if ((NULL != s->sCIp) && (kCIEnoErr != (circ = CiVFGclose(s->sCIp)))) {
                log_msg(LOG_LEVEL_ERROR, "CiVFGclose gave '%s'\n",CiErrStr(circ));
        }
 
        free(s);
}

References LOG_LEVEL_ERROR, log_msg(), vidcap_state_bitflow::sCIp, state, and vidcap_state_bitflow::uPtrs.

Referenced by vidcap_bitflow_init().

Here is the call graph for this function:

vidcap_bitflow_grab()

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

static

Definition at line 262 of file bitflow.cpp.

{
        struct vidcap_state_bitflow *s = (struct vidcap_state_bitflow *) state;
 
        tCIU32                      frameID;
        tCIU8                       *frameP;
        tCIRC                       circ;
 
        //Check to see if a frame is already available before waiting.
        circ = CiGetOldestNotDeliveredFrame(s->sCIp, &frameID, &frameP);
 
        switch (circ) {
                case kCIEnoErr:
                        // we have the frame
                        break;
                case kCIEnoNewData:
                        if (kCIEnoErr != (circ = CiWaitNextUndeliveredFrame(s->sCIp,-1))) // negative - infinite wait
                        {
                                switch (circ) {
                                        case kCIEaqAbortedErr:
                                                log_msg(LOG_LEVEL_ERROR, "CiWaitNextUndeliveredFrame gave '%s'\n",CiErrStr(circ));
                                                break;
                                        case kCIEdataHWerr:
                                                log_msg(LOG_LEVEL_ERROR, "CiWaitNextUndeliveredFrame gave '%s'\n",CiErrStr(circ));
                                                restartAcquisition(s);
 
                                                break;
                                        default:
                                                log_msg(LOG_LEVEL_ERROR, "CiWaitNextUndeliveredFrame gave '%s'\n",CiErrStr(circ));
                                }
                                return NULL;
                        }
                        circ = CiGetOldestNotDeliveredFrame(s->sCIp, &frameID, &frameP);
                        if (circ == kCIEnoErr) {
                                break;
                        } else {
                                return NULL;
                        }
                case kCIEaqAbortedErr:
                        log_msg(LOG_LEVEL_ERROR, "CiGetOldestNotDeliveredFrame: acquistion aborted\n");
                        return NULL;
                case kCIEdataHWerr:
                        log_msg(LOG_LEVEL_ERROR, "CiWaitNextUndeliveredFrame gave '%s'\n",CiErrStr(circ));
                        restartAcquisition(s);
                        return NULL;
                default:
                        log_msg(LOG_LEVEL_ERROR, "CiGetOldestNotDeliveredFrame gave '%s'\n",CiErrStr(circ));
                        return NULL;
        }
 
        tCIU32 count;
        switch (circ = CiGetUndeliveredCount(s->sCIp,&count)) {
                case kCIEnoErr:
                        /*
                         **    We have the frame.
                         */
                        break;
                case kCIEnoNewData:
                        /*
                         **    We need to wait for another frame.
                         */
                        log_msg(LOG_LEVEL_ERROR, "CiGetUndeliveredCount error\n");
                        return NULL;
                case kCIEaqAbortedErr:
                        log_msg(LOG_LEVEL_ERROR, "CiGetOldestNotDeliveredFrame: acquistion aborted\n");
                        return NULL;
                default:
                        log_msg(LOG_LEVEL_ERROR, "CiGetOldestNotDeliveredFrame gave '%s'\n",CiErrStr(circ));
                        return NULL;
        }
 
        if (count > 0) {
                log_msg(LOG_LEVEL_WARNING, "Undelivered count: %" PRIu32 "\n");
        }
 
        video_frame *out = vf_alloc_desc_data(s->desc);
        debayer((char *) out->tiles[0].data, (char *) frameP, s->desc.width, s->desc.height);
        out->callbacks.dispose = vf_free;
 
        *audio = NULL;
        return out;
}

References audio, video_frame::callbacks, count, tile::data, debayer(), vidcap_state_bitflow::desc, video_frame_callbacks::dispose, video_desc::height, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), restartAcquisition(), vidcap_state_bitflow::sCIp, state, video_frame::tiles, vf_alloc_desc_data(), vf_free(), and video_desc::width.

Here is the call graph for this function:

vidcap_bitflow_init()

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

static

< from CiSysBrdInfo()

< access mode flags

< access token

Definition at line 139 of file bitflow.cpp.

{
        if (vidcap_params_get_flags(params) & VIDCAP_FLAG_AUDIO_ANY) {
                return VIDCAP_INIT_AUDIO_NOT_SUPPORTED;
        }
        struct vidcap_state_bitflow *s = (struct vidcap_state_bitflow *) calloc(1, sizeof(struct vidcap_state_bitflow));
 
        s->sNdx = 0;
 
        tCIRC circ;
        //Open the ndx'th frame grabber with write permission.
        if (kCIEnoErr != (circ = CiVFGopen(s->sNdx,                
                                        kCIBO_writeAccess,   
                                        &s->sCIp)))             
        {
                log_msg(LOG_LEVEL_ERROR, "CiVFGopen gave '%s'\n",CiErrStr(circ));
                goto error;
        }
 
        if (kCIEnoErr != (circ = CiVFGinitialize(s->sCIp,NULL)))
        {
                log_msg(LOG_LEVEL_ERROR, "CiVFGinitialize gave '%s'\n",CiErrStr(circ));
                goto error;
        }
 
        if (kCIEnoErr != (circ = CiDrvrBuffConfigure(s->sCIp, 20, 0, 0, 0, 0))) {
                log_msg(LOG_LEVEL_ERROR, "CiDrvrBuffConfigure gave '%s'\n",CiErrStr(circ));
                goto error;
        }
 
        tCIU32 bitsPerPix, hROIsize, vROIsize, hROIoffset, vROIoffset, stride;
        if (kCIEnoErr != (circ = CiBufferInterrogate(s->sCIp, &s->nFrames, &bitsPerPix, &hROIoffset, &hROIsize, &vROIoffset, &vROIsize, &stride)))
        {
                log_msg(LOG_LEVEL_ERROR, "CiBufferInterrogate gave '%s'\n",CiErrStr(circ));
                goto error;
        }
 
        s->desc = {hROIsize, vROIsize, RGB, get_fps(s), PROGRESSIVE, 1};
 
        if (s->desc.fps == 0) {
                log_msg(LOG_LEVEL_ERROR, "Unable to get FPS!");
                goto error;
        }
 
        if (!map_frame_buffers(s)) {
                goto error;
        }
 
        if (!reset_acquisition(s)) {
                goto error;
        }
 
        if (!start_acquisition(s)) {
                goto error;
        }
 
        *state = s;
        return VIDCAP_INIT_OK;
 
error:
        vidcap_bitflow_done(s);
        return -1;
}

References vidcap_state_bitflow::desc, video_desc::fps, get_fps(), LOG_LEVEL_ERROR, log_msg(), map_frame_buffers(), vidcap_state_bitflow::nFrames, PROGRESSIVE, reset_acquisition(), RGB, vidcap_state_bitflow::sCIp, vidcap_state_bitflow::sNdx, start_acquisition(), state, vidcap_bitflow_done(), VIDCAP_FLAG_AUDIO_ANY, VIDCAP_INIT_AUDIO_NOT_SUPPORTED, VIDCAP_INIT_OK, and vidcap_params_get_flags().

Here is the call graph for this function:

vidcap_bitflow_probe()

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

static

Definition at line 345 of file bitflow.cpp.

{
        *available_cards = nullptr;
        *count = 0;
        *deleter = free;
}

References count, and deleter.

Variable Documentation

vidcap_bitflow_info

const struct video_capture_info vidcap_bitflow_info

static

Initial value:

= {
        vidcap_bitflow_probe,
        vidcap_bitflow_init,
        vidcap_bitflow_done,
        vidcap_bitflow_grab,
        VIDCAP_NO_GENERIC_FPS_INDICATOR,
}

Definition at line 352 of file bitflow.cpp.

                                                             {
        vidcap_bitflow_probe,
        vidcap_bitflow_init,
        vidcap_bitflow_done,
        vidcap_bitflow_grab,
        VIDCAP_NO_GENERIC_FPS_INDICATOR,
};