yair/gst-plugin-linescan
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

matroxsrc: add first working version of Matrox Imaging Library source

Browse Source
This commit is contained in:
Joshua M. Doe 2017-05-09 13:39:16 -04:00
parent 62d1b1f6fd
commit 376fbb5fd2
6 changed files with 885 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -52,6 +52,9 @@ macro_log_feature(IMPERX_FLEX_FOUND "Imperx FrameLink Express" "Required to buil
find_package(IOtechDaqX)
macro_log_feature(IOTECHDAQX_FOUND "IOtech DaqX" "Required to build IOtech DaqX source element" "http://www.euresys.com/" FALSE)
find_package(Matrox)
macro_log_feature(MATROX_FOUND "Matrox MIL" "Required to build Matrox MIL source element" "http://www.matrox.com/imaging/" FALSE)
find_package(Phoenix)
macro_log_feature(PHOENIX_FOUND "Active Silicon Phoenix" "Required to build Active Silicon Phoenix source element" "http://www.activesilicon.com/" FALSE)

33
cmake/modules/FindMatrox.cmake Normal file
View File

@ -0,0 +1,33 @@
# - Try to find Matrox MIL SDK
# Once done this will define
#
# MATROX_FOUND - system has Matrox MIL SDK
# MATROX_INCLUDE_DIR - the Matrox MIL SDK include directory
# MATROX_LIBRARIES - the libraries needed to use Matrox MIL SDK
# Copyright (c) 2006, Tim Beaulen <tbscope@gmail.com>
# Copyright (c) 2017 outside US, United States Government, Joshua M. Doe <oss@nvl.army.mil>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if (NOT MATROX_DIR)
set (MATROX_DIR "C:/Program Files/Matrox Imaging/Mil" CACHE PATH "Directory containing Matrox MIL SDK includes and libraries")
endif ()
find_path (MATROX_INCLUDE_DIR Mil.h
PATHS
"${MATROX_DIR}/Include"
DOC "Directory containing Matrox MIL include files")
find_library (_MATROX_LIB NAMES Mil.lib
PATHS
"${MATROX_DIR}/LIB")
set (MATROX_LIBRARIES ${_MATROX_LIB})
mark_as_advanced (_MATROX_LIB)
include (FindPackageHandleStandardArgs)
find_package_handle_standard_args (MATROX DEFAULT_MSG MATROX_INCLUDE_DIR MATROX_LIBRARIES)

4
sys/CMakeLists.txt
View File

@ -14,6 +14,10 @@ if (IDSUEYE_FOUND)
add_subdirectory (idsueye)
endif (IDSUEYE_FOUND)
if (MATROX_FOUND)
add_subdirectory (matrox)
endif (MATROX_FOUND)
if (NIIMAQ_FOUND)
add_subdirectory (niimaq)
endif (NIIMAQ_FOUND)

29
sys/matrox/CMakeLists.txt Normal file
View File

@ -0,0 +1,29 @@
add_definitions (-DHAVE_CONFIG_H)
set (SOURCES
gstmatroxsrc.c)
set (HEADERS
gstmatroxsrc.h)
include_directories (AFTER
${MATROX_INCLUDE_DIR})
set (libname libgstmatrox)
add_library (${libname} MODULE
${SOURCES}
${HEADERS})
target_link_libraries (${libname}
${GLIB2_LIBRARIES}
${GOBJECT_LIBRARIES}
${GSTREAMER_LIBRARY}
${GSTREAMER_BASE_LIBRARY}
${GSTREAMER_VIDEO_LIBRARY}
${MATROX_LIBRARIES})
set (pdbfile "${CMAKE_CURRENT_BINARY_DIR}/\${CMAKE_INSTALL_CONFIG_NAME}/${libname}.pdb")
install (FILES ${pdbfile} DESTINATION lib/gstreamer-1.0)
install(TARGETS ${libname}
LIBRARY DESTINATION lib/gstreamer-1.0)

733
sys/matrox/gstmatroxsrc.c Normal file
View File

@ -0,0 +1,733 @@
/* GStreamer
* Copyright (C) 2011 FIXME <fixme@example.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin Street, Suite 500,
* Boston, MA 02110-1335, USA.
*/
/**
* SECTION:element-gstimperxflexsrc
*
* The imperxflexsrc element is a source for IMPERX and FrameLink Express framegrabbers.
*
* <refsect2>
* <title>Example launch line</title>
* |[
* gst-launch -v imperxflexsrc ! videoconvert ! autovideosink
* ]|
* Shows video from the default IMPERX FrameLink Express framegrabber
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/gst.h>
#include <gst/base/gstpushsrc.h>
#include <gst/video/video.h>
#include "gstmatroxsrc.h"
GST_DEBUG_CATEGORY_STATIC (gst_matroxsrc_debug);
#define GST_CAT_DEFAULT gst_matroxsrc_debug
/* prototypes */
static void gst_matroxsrc_set_property (GObject * object,
guint property_id, const GValue * value, GParamSpec * pspec);
static void gst_matroxsrc_get_property (GObject * object,
guint property_id, GValue * value, GParamSpec * pspec);
static void gst_matroxsrc_dispose (GObject * object);
static void gst_matroxsrc_finalize (GObject * object);
static gboolean gst_matroxsrc_start (GstBaseSrc * src);
static gboolean gst_matroxsrc_stop (GstBaseSrc * src);
static GstCaps *gst_matroxsrc_get_caps (GstBaseSrc * src, GstCaps * filter);
static gboolean gst_matroxsrc_set_caps (GstBaseSrc * src, GstCaps * caps);
static gboolean gst_matroxsrc_unlock (GstBaseSrc * src);
static gboolean gst_matroxsrc_unlock_stop (GstBaseSrc * src);
static GstFlowReturn gst_matroxsrc_create (GstPushSrc * src, GstBuffer ** buf);
static GstCaps *gst_matroxsrc_create_caps (GstMatroxSrc * src);
static MIL_INT MFTYPE
gst_matroxsrc_callback (MIL_INT HookType, MIL_ID EventId, void *UserDataPtr);
enum
{
PROP_0,
PROP_DEVICE,
PROP_BOARD,
PROP_CHANNEL,
PROP_FORMAT,
PROP_NUM_CAPTURE_BUFFERS,
PROP_TIMEOUT
};
#define DEFAULT_PROP_DEVICE "M_SYSTEM_DEFAULT"
#define DEFAULT_PROP_BOARD -1
#define DEFAULT_PROP_CHANNEL -1
#define DEFAULT_PROP_FORMAT "M_DEFAULT"
#define DEFAULT_PROP_NUM_CAPTURE_BUFFERS 2
#define DEFAULT_PROP_TIMEOUT 1000
/* pad templates */
static GstStaticPadTemplate gst_matroxsrc_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE
("{ GRAY8, GRAY16_LE, GRAY16_BE, BGRA }"))
);
/* class initialization */
G_DEFINE_TYPE (GstMatroxSrc, gst_matroxsrc, GST_TYPE_PUSH_SRC);
static void
gst_matroxsrc_class_init (GstMatroxSrcClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
GstPushSrcClass *gstpushsrc_class = GST_PUSH_SRC_CLASS (klass);
gobject_class->set_property = gst_matroxsrc_set_property;
gobject_class->get_property = gst_matroxsrc_get_property;
gobject_class->dispose = gst_matroxsrc_dispose;
gobject_class->finalize = gst_matroxsrc_finalize;
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&gst_matroxsrc_src_template));
gst_element_class_set_static_metadata (gstelement_class,
"Matrox Imaging Library Video Source", "Source/Video",
"Matrox Imaging Library video source",
"Joshua M. Doe <oss@nvl.army.mil>");
gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_matroxsrc_start);
gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_matroxsrc_stop);
gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_matroxsrc_get_caps);
gstbasesrc_class->set_caps = GST_DEBUG_FUNCPTR (gst_matroxsrc_set_caps);
gstbasesrc_class->unlock = GST_DEBUG_FUNCPTR (gst_matroxsrc_unlock);
gstbasesrc_class->unlock_stop = GST_DEBUG_FUNCPTR (gst_matroxsrc_unlock_stop);
gstpushsrc_class->create = GST_DEBUG_FUNCPTR (gst_matroxsrc_create);
/* Install GObject properties */
g_object_class_install_property (gobject_class, PROP_DEVICE,
g_param_spec_string ("device", "Device",
"System descriptor, default is specified in MilConfig",
DEFAULT_PROP_DEVICE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_BOARD,
g_param_spec_int ("board", "Board",
"Board number, -1 uses default specified in MilConfig", -1, 15,
DEFAULT_PROP_BOARD,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_CHANNEL,
g_param_spec_int ("channel", "Channel",
"Channel number, -1 uses default specified in MilConfig", -1, 15,
DEFAULT_PROP_CHANNEL,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_FORMAT,
g_param_spec_string ("format", "Format or format file",
"Format, as predefined string or DCF file path, default is specified in MilConfig",
DEFAULT_PROP_FORMAT,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_NUM_CAPTURE_BUFFERS,
g_param_spec_uint ("num-capture-buffers", "Number of capture buffers",
"Number of capture buffers", 1, G_MAXUINT,
DEFAULT_PROP_NUM_CAPTURE_BUFFERS,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TIMEOUT,
g_param_spec_int ("timeout", "Timeout (ms)",
"Timeout in ms (0 to use default)", 0, G_MAXINT, DEFAULT_PROP_TIMEOUT,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
}
static void
gst_matroxsrc_reset (GstMatroxSrc * src)
{
gint i;
src->acq_started = FALSE;
if (src->caps) {
gst_caps_unref (src->caps);
src->caps = NULL;
}
if (src->buffer) {
gst_buffer_unref (src->buffer);
src->buffer = NULL;
}
if (src->MilGrabBufferList) {
for (i = 0; src->num_capture_buffers; ++i) {
if (src->MilGrabBufferList[i]) {
MbufFree (src->MilGrabBufferList[i]);
}
}
g_free (src->MilGrabBufferList);
src->MilGrabBufferList = NULL;
}
if (src->MilApplication) {
MappFree (src->MilApplication);
src->MilApplication = M_NULL;
}
if (src->MilSystem) {
MsysFree (src->MilSystem);
src->MilSystem = M_NULL;
}
if (src->MilDigitizer) {
MdigFree (src->MilDigitizer);
src->MilDigitizer = M_NULL;
}
}
static void
gst_matroxsrc_init (GstMatroxSrc * src)
{
/* set source as live (no preroll) */
gst_base_src_set_live (GST_BASE_SRC (src), TRUE);
/* override default of BYTES to operate in time mode */
gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);
/* initialize member variables */
src->device = g_strdup (DEFAULT_PROP_DEVICE);
src->board = DEFAULT_PROP_BOARD;
src->channel = DEFAULT_PROP_CHANNEL;
src->format = g_strdup (DEFAULT_PROP_FORMAT);
src->num_capture_buffers = DEFAULT_PROP_NUM_CAPTURE_BUFFERS;
src->timeout = DEFAULT_PROP_TIMEOUT;
g_mutex_init (&src->mutex);
g_cond_init (&src->cond);
src->stop_requested = FALSE;
src->caps = NULL;
src->buffer = NULL;
src->MilApplication = M_NULL;
src->MilSystem = M_NULL;
src->MilDigitizer = M_NULL;
src->MilGrabBufferList = NULL;
gst_matroxsrc_reset (src);
}
void
gst_matroxsrc_set_property (GObject * object, guint property_id,
const GValue * value, GParamSpec * pspec)
{
GstMatroxSrc *src;
src = GST_MATROX_SRC (object);
switch (property_id) {
case PROP_DEVICE:
g_free (src->device);
src->device = g_strdup (g_value_get_string (value));
break;
case PROP_NUM_CAPTURE_BUFFERS:
if (src->acq_started) {
GST_ELEMENT_WARNING (src, RESOURCE, SETTINGS,
("Number of capture buffers cannot be changed after acquisition has started."),
(NULL));
} else {
src->num_capture_buffers = g_value_get_uint (value);
}
break;
case PROP_BOARD:
src->board = g_value_get_int (value);
break;
case PROP_CHANNEL:
src->channel = g_value_get_int (value);
break;
case PROP_FORMAT:
g_free (src->format);
src->format = g_strdup (g_value_get_string (value));
break;
case PROP_TIMEOUT:
src->timeout = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void
gst_matroxsrc_get_property (GObject * object, guint property_id,
GValue * value, GParamSpec * pspec)
{
GstMatroxSrc *src;
g_return_if_fail (GST_IS_MATROX_SRC (object));
src = GST_MATROX_SRC (object);
switch (property_id) {
case PROP_DEVICE:
g_value_set_string (value, src->device);
break;
case PROP_NUM_CAPTURE_BUFFERS:
g_value_set_uint (value, src->num_capture_buffers);
break;
case PROP_BOARD:
g_value_set_int (value, src->board);
break;
case PROP_CHANNEL:
g_value_set_int (value, src->channel);
break;
case PROP_FORMAT:
g_value_set_string (value, src->format);
break;
case PROP_TIMEOUT:
g_value_set_int (value, src->timeout);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void
gst_matroxsrc_dispose (GObject * object)
{
GstMatroxSrc *src;
g_return_if_fail (GST_IS_MATROX_SRC (object));
src = GST_MATROX_SRC (object);
/* clean up as possible. may be called multiple times */
g_mutex_clear (&src->mutex);
g_cond_clear (&src->cond);
G_OBJECT_CLASS (gst_matroxsrc_parent_class)->dispose (object);
}
void
gst_matroxsrc_finalize (GObject * object)
{
GstMatroxSrc *src;
g_return_if_fail (GST_IS_MATROX_SRC (object));
src = GST_MATROX_SRC (object);
/* clean up object here */
g_free (src->device);
g_free (src->format);
gst_matroxsrc_reset (src);
G_OBJECT_CLASS (gst_matroxsrc_parent_class)->finalize (object);
}
static gboolean
gst_matroxsrc_start (GstBaseSrc * bsrc)
{
GstMatroxSrc *src = GST_MATROX_SRC (bsrc);
MIL_ID ret;
gint i;
gint width;
gint height;
gint bpp;
gint n_bands;
GstVideoInfo vinfo;
GST_DEBUG_OBJECT (src, "start");
/* create App */
ret = MappAlloc (M_NULL, M_DEFAULT, &src->MilApplication);
if (ret == M_NULL) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Failed to allocate a MIL application"), (NULL));
return FALSE;
}
/* create System */
if (src->board == -1) {
ret =
MsysAlloc (src->MilApplication, src->device, M_DEFAULT, M_DEFAULT,
&src->MilSystem);
} else {
ret =
MsysAlloc (src->MilApplication, src->device, src->board, M_DEFAULT,
&src->MilSystem);
}
if (ret == M_NULL) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Failed to allocate a MIL system"), (NULL));
return FALSE;
}
/* create Digitizer */
MdigAlloc (src->MilSystem, M_DEFAULT, src->format, M_DEFAULT,
&src->MilDigitizer);
if (ret == M_NULL) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Failed to allocate a MIL digitizer"), (NULL));
return FALSE;
}
/* get format info and create caps */
width = MdigInquire (src->MilDigitizer, M_SIZE_X, M_NULL);
height = MdigInquire (src->MilDigitizer, M_SIZE_Y, M_NULL);
bpp = MdigInquire (src->MilDigitizer, M_SIZE_BIT, M_NULL);
n_bands = MdigInquire (src->MilDigitizer, M_SIZE_BAND, M_NULL);
src->color_mode = MdigInquire (src->MilDigitizer, M_COLOR_MODE, M_NULL);
gst_video_info_init (&vinfo);
vinfo.width = width;
vinfo.height = height;
if (src->caps) {
gst_caps_unref (src->caps);
src->caps = NULL;
}
if (src->color_mode == M_MONOCHROME) {
g_assert (n_bands == 1);
if (bpp == 8) {
src->video_format = GST_VIDEO_FORMAT_GRAY8;
} else if (bpp > 8 && bpp <= 16) {
GValue val = G_VALUE_INIT;
GstStructure *s;
if (G_BYTE_ORDER == G_LITTLE_ENDIAN) {
src->video_format = GST_VIDEO_FORMAT_GRAY16_LE;
} else if (G_BYTE_ORDER == G_BIG_ENDIAN) {
src->video_format = GST_VIDEO_FORMAT_GRAY16_BE;
}
vinfo.finfo = gst_video_format_get_info (src->video_format);
src->caps = gst_video_info_to_caps (&vinfo);
/* set bpp, extra info for GRAY16 so elements can scale properly */
s = gst_caps_get_structure (src->caps, 0);
g_value_init (&val, G_TYPE_INT);
g_value_set_int (&val, bpp);
gst_structure_set_value (s, "bpp", &val);
g_value_unset (&val);
} else {
GST_ELEMENT_ERROR (src, STREAM, WRONG_TYPE,
("Unknown or unsupported bit depth (%d).", bpp), (NULL));
return FALSE;
}
} else if (src->color_mode == M_BGR24) {
g_assert (n_bands == 3);
src->video_format = GST_VIDEO_FORMAT_BGR;
} else if (src->color_mode == M_BGR32) {
g_assert (n_bands == 3);
src->video_format = GST_VIDEO_FORMAT_BGRx;
} else if (src->color_mode == M_RGB) {
g_assert (n_bands == 3);
src->video_format = GST_VIDEO_FORMAT_RGB;
} /*else if (color_mode == M_YUV) {
g_assert (n_bands == 3);
src = GST_VIDEO_FORMAT_YUY2;
} */
else {
GST_WARNING_OBJECT (src,
"Color mode %d not directly supported, will try converting to BGRx",
src->color_mode);
src->video_format = GST_VIDEO_FORMAT_BGRx;
src->color_mode = M_BGR32;
n_bands = 3;
bpp = 8;
}
if (!src->caps) {
vinfo.finfo = gst_video_format_get_info (src->video_format);
src->caps = gst_video_info_to_caps (&vinfo);
}
src->height = vinfo.height;
src->gst_stride = GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 0);
if (src->MilGrabBufferList) {
g_free (src->MilGrabBufferList);
}
src->MilGrabBufferList = g_new (MIL_ID, src->num_capture_buffers);
for (i = 0; i < src->num_capture_buffers; i++) {
MbufAllocColor (src->MilSystem,
n_bands,
width,
height,
bpp, M_IMAGE + M_GRAB + M_PROC + M_PACKED, &src->MilGrabBufferList[i]);
if (src->MilGrabBufferList[i]) {
MbufClear (src->MilGrabBufferList[i], 0xFF);
} else {
break;
}
}
return TRUE;
}
static gboolean
gst_matroxsrc_stop (GstBaseSrc * bsrc)
{
GstMatroxSrc *src = GST_MATROX_SRC (bsrc);
GST_DEBUG_OBJECT (src, "stop");
if (src->acq_started) {
MdigProcess (src->MilDigitizer, src->MilGrabBufferList,
src->num_capture_buffers, M_STOP, M_DEFAULT, gst_matroxsrc_callback,
src);
src->acq_started = FALSE;
}
gst_matroxsrc_reset (src);
return TRUE;
}
static GstCaps *
gst_matroxsrc_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
{
GstMatroxSrc *src = GST_MATROX_SRC (bsrc);
GstCaps *caps;
if (src->MilDigitizer == M_NULL) {
caps = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (src));
} else {
caps = gst_caps_copy (src->caps);
}
GST_DEBUG_OBJECT (src, "The caps before filtering are %" GST_PTR_FORMAT,
caps);
if (filter && caps) {
GstCaps *tmp = gst_caps_intersect (caps, filter);
gst_caps_unref (caps);
caps = tmp;
}
GST_DEBUG_OBJECT (src, "The caps after filtering are %" GST_PTR_FORMAT, caps);
return caps;
}
static gboolean
gst_matroxsrc_set_caps (GstBaseSrc * bsrc, GstCaps * caps)
{
GstMatroxSrc *src = GST_MATROX_SRC (bsrc);
GstVideoInfo vinfo;
GstStructure *s = gst_caps_get_structure (caps, 0);
GST_DEBUG_OBJECT (src, "The caps being set are %" GST_PTR_FORMAT, caps);
gst_video_info_from_caps (&vinfo, caps);
if (GST_VIDEO_INFO_FORMAT (&vinfo) != GST_VIDEO_FORMAT_UNKNOWN) {
src->gst_stride = GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 0);
} else {
goto unsupported_caps;
}
return TRUE;
unsupported_caps:
GST_ERROR_OBJECT (src, "Unsupported caps: %" GST_PTR_FORMAT, caps);
return FALSE;
}
static gboolean
gst_matroxsrc_unlock (GstBaseSrc * bsrc)
{
GstMatroxSrc *src = GST_MATROX_SRC (bsrc);
GST_LOG_OBJECT (src, "unlock");
g_mutex_lock (&src->mutex);
src->stop_requested = TRUE;
g_cond_signal (&src->cond);
g_mutex_unlock (&src->mutex);
return TRUE;
}
static gboolean
gst_matroxsrc_unlock_stop (GstBaseSrc * bsrc)
{
GstMatroxSrc *src = GST_MATROX_SRC (bsrc);
GST_LOG_OBJECT (src, "unlock_stop");
src->stop_requested = FALSE;
return TRUE;
}
static GstBuffer *
gst_matroxsrc_create_buffer_from_id (GstMatroxSrc * src, MIL_ID buffer_id)
{
GstMapInfo minfo;
GstBuffer *buf;
/* TODO: use allocator or use from pool */
buf = gst_buffer_new_and_alloc (src->height * src->gst_stride);
/* map buffer so we can copy to it */
gst_buffer_map (buf, &minfo, GST_MAP_WRITE);
GST_LOG_OBJECT (src,
"GstBuffer size=%d, gst_stride=%d", minfo.size, src->gst_stride);
/* copy MilBuffer to GstBuffer, possibly performing conversion in the process */
if (src->video_format == GST_VIDEO_FORMAT_GRAY8 ||
src->video_format == GST_VIDEO_FORMAT_GRAY16_LE ||
src->video_format == GST_VIDEO_FORMAT_GRAY16_BE) {
MbufGet (buffer_id, minfo.data);
} else {
/* TODO: add support for planar color and YUV */
MbufGetColor (buffer_id, M_PACKED | src->color_mode, M_ALL_BANDS,
minfo.data);
}
gst_buffer_unmap (buf, &minfo);
return buf;
}
static MIL_INT MFTYPE
gst_matroxsrc_callback (MIL_INT HookType, MIL_ID EventId, void *UserDataPtr)
{
GstMatroxSrc *src = GST_MATROX_SRC (UserDataPtr);
MIL_ID ModifiedBufferId;
gint dropped_frames;
static guint64 last_frame_number = 0;
static guint64 buffers_processed = 0;
static guint64 total_dropped_frames = 0;
GstClock *clock;
GstClockTime clock_time;
g_assert (src != NULL);
clock = gst_element_get_clock (GST_ELEMENT (src));
clock_time = gst_clock_get_time (clock);
gst_object_unref (clock);
/* Retrieve the MIL_ID of the grabbed buffer. */
MdigGetHookInfo (EventId, M_MODIFIED_BUFFER + M_BUFFER_ID, &ModifiedBufferId);
///* check for dropped frames and disrupted signal */
//dropped_frames = (pFrameInfo->number - last_frame_number) - 1;
//if (dropped_frames > 0) {
// total_dropped_frames += dropped_frames;
// GST_WARNING_OBJECT (src, "Dropped %d frames (%d total)", dropped_frames,
// total_dropped_frames);
//} else if (dropped_frames < 0) {
// GST_WARNING_OBJECT (src,
// "Signal disrupted, frames likely dropped and timestamps inaccurate");
// /* frame timestamps reset, so adjust start time, accuracy reduced */
// src->acq_start_time =
// gst_clock_get_time (gst_element_get_clock (GST_ELEMENT (src))) -
// pFrameInfo->timestamp * GST_USECOND;
//}
//last_frame_number = pFrameInfo->number;
g_mutex_lock (&src->mutex);
if (src->buffer) {
/* TODO: save this in dropped frame total? */
GST_WARNING_OBJECT (src,
"Got new buffer before old handled, dropping old.");
gst_buffer_unref (src->buffer);
src->buffer = NULL;
}
src->buffer = gst_matroxsrc_create_buffer_from_id (src, ModifiedBufferId);
GST_BUFFER_TIMESTAMP (src->buffer) =
GST_CLOCK_DIFF (gst_element_get_base_time (GST_ELEMENT (src)),
clock_time);
GST_BUFFER_OFFSET (src->buffer) = buffers_processed;
++buffers_processed;
g_cond_signal (&src->cond);
g_mutex_unlock (&src->mutex);
return M_NULL;
}
static GstFlowReturn
gst_matroxsrc_create (GstPushSrc * psrc, GstBuffer ** buf)
{
GstMatroxSrc *src = GST_MATROX_SRC (psrc);
gint64 end_time;
GST_LOG_OBJECT (src, "create");
/* Start acquisition if not already started */
if (G_UNLIKELY (!src->acq_started)) {
GST_LOG_OBJECT (src, "starting acquisition");
src->acq_start_time =
gst_clock_get_time (gst_element_get_clock (GST_ELEMENT (src)));
MdigProcess (src->MilDigitizer, src->MilGrabBufferList,
src->num_capture_buffers, M_START, M_DEFAULT, gst_matroxsrc_callback,
src);
src->acq_started = TRUE;
}
/* wait for a buffer to be ready */
g_mutex_lock (&src->mutex);
end_time = g_get_monotonic_time () + src->timeout * G_TIME_SPAN_MILLISECOND;
while (!src->buffer && !src->stop_requested) {
if (!g_cond_wait_until (&src->cond, &src->mutex, end_time)) {
g_mutex_unlock (&src->mutex);
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Timeout, no data received after %d ms", src->timeout), (NULL));
return GST_FLOW_ERROR;
}
}
*buf = src->buffer;
src->buffer = NULL;
g_mutex_unlock (&src->mutex);
if (src->stop_requested) {
if (*buf != NULL) {
gst_buffer_unref (*buf);
*buf = NULL;
}
return GST_FLOW_FLUSHING;
}
return GST_FLOW_OK;
}
static gboolean
plugin_init (GstPlugin * plugin)
{
GST_DEBUG_CATEGORY_INIT (gst_matroxsrc_debug, "matroxsrc", 0,
"debug category for matroxsrc element");
gst_element_register (plugin, "matroxsrc", GST_RANK_NONE,
gst_matroxsrc_get_type ());
return TRUE;
}
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
matrox,
"Matrox Imaging Library video source",
plugin_init, VERSION, "LGPL", PACKAGE_NAME, GST_PACKAGE_ORIGIN)

83
sys/matrox/gstmatroxsrc.h Normal file
View File

@ -0,0 +1,83 @@
/* GStreamer
* Copyright (C) 2017 FIXME <fixme@example.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef _GST_MATROX_SRC_H_
#define _GST_MATROX_SRC_H_
#include <gst/base/gstpushsrc.h>
#include <mil.h>
G_BEGIN_DECLS
#define GST_TYPE_MATROX_SRC (gst_matroxsrc_get_type())
#define GST_MATROX_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MATROX_SRC,GstMatroxSrc))
#define GST_MATROX_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MATROX_SRC,GstMatroxSrcClass))
#define GST_IS_MATROX_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MATROX_SRC))
#define GST_IS_MATROX_SRC_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MATROX_SRC))
typedef struct _GstMatroxSrc GstMatroxSrc;
typedef struct _GstMatroxSrcClass GstMatroxSrcClass;
struct _GstMatroxSrc
{
GstPushSrc base_matroxsrc;
gboolean acq_started;
/* MIL handles */
MIL_ID MilApplication;
MIL_ID MilSystem;
MIL_ID MilDigitizer;
MIL_ID *MilGrabBufferList;
/* properties */
gchar *device;
gint board;
gint channel;
gchar *format;
guint num_capture_buffers;
gint timeout;
GstBuffer *buffer;
GstClockTime acq_start_time;
GstCaps *caps;
gint width;
gint height;
gint bpp;
gint gst_stride;
MIL_INT color_mode;
GstVideoFormat video_format;
GMutex mutex;
GCond cond;
gboolean stop_requested;
};
struct _GstMatroxSrcClass
{
GstPushSrcClass base_matroxsrc_class;
};
GType gst_matroxsrc_get_type (void);
G_END_DECLS
#endif