mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-02-19 20:46:22 +00:00
Code Issues 1 Projects Releases Wiki Activity

sys/v4l2/: add norm, channel and frequency properties.

Browse source 
Original commit message from CVS:
2004-01-12  Benjamin Otte  <in7y118@public.uni-hamburg.de>

* sys/v4l2/gstv4l2element.c: (gst_v4l2element_class_init),
(gst_v4l2element_dispose), (gst_v4l2element_set_property),
(gst_v4l2element_get_property):
* sys/v4l2/v4l2_calls.c: (gst_v4l2_set_defaults), (gst_v4l2_open):
add norm, channel and frequency properties.
* sys/v4l2/gstv4l2tuner.c:
fixes for tuner interface changes
* sys/v4l2/gstv4l2element.h:
* sys/v4l2/gstv4l2src.c:
* sys/v4l2/gstv4l2src.h:
* sys/v4l2/v4l2src_calls.c:
* sys/v4l2/v4l2src_calls.h:
rework v4l2src to work with saa1734 cards and allow mmaped buffers.
This commit is contained in:
Benjamin Otte 2004-01-12 02:19:57 +00:00
parent efeab14a4e
commit 409384e0d8
9 changed files with 1077 additions and 1060 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
ChangeLog
View file

@ -1,3 +1,19 @@
2004-01-12 Benjamin Otte <in7y118@public.uni-hamburg.de>
* sys/v4l2/gstv4l2element.c: (gst_v4l2element_class_init),
(gst_v4l2element_dispose), (gst_v4l2element_set_property),
(gst_v4l2element_get_property):
* sys/v4l2/v4l2_calls.c: (gst_v4l2_set_defaults), (gst_v4l2_open):
add norm, channel and frequency properties.
* sys/v4l2/gstv4l2tuner.c:
fixes for tuner interface changes
* sys/v4l2/gstv4l2element.h:
* sys/v4l2/gstv4l2src.c:
* sys/v4l2/gstv4l2src.h:
* sys/v4l2/v4l2src_calls.c:
* sys/v4l2/v4l2src_calls.h:
rework v4l2src to work with saa1734 cards and allow mmaped buffers.
2004-01-12 Benjamin Otte <in7y118@public.uni-hamburg.de> 2004-01-12 Benjamin Otte <in7y118@public.uni-hamburg.de>
* gst-libs/gst/tuner/tuner.c: (gst_tuner_class_init), * gst-libs/gst/tuner/tuner.c: (gst_tuner_class_init),

178
sys/v4l2/gstv4l2element.c
View file

@ -43,17 +43,20 @@ static GstElementDetails gst_v4l2element_details = {
/* V4l2Element signals and args */ /* V4l2Element signals and args */
enum { enum {
/* FILL ME */ /* FILL ME */
SIGNAL_OPEN, SIGNAL_OPEN,
SIGNAL_CLOSE, SIGNAL_CLOSE,
LAST_SIGNAL LAST_SIGNAL
}; };
enum { enum {
ARG_0, ARG_0,
ARG_DEVICE, ARG_DEVICE,
ARG_DEVICE_NAME, ARG_DEVICE_NAME,
ARG_FLAGS ARG_NORM,
ARG_CHANNEL,
ARG_FREQUENCY,
ARG_FLAGS
}; };
@ -378,41 +381,47 @@ gst_v4l2element_base_init (GstV4l2ElementClass *klass)
static void static void
gst_v4l2element_class_init (GstV4l2ElementClass *klass) gst_v4l2element_class_init (GstV4l2ElementClass *klass)
{ {
GObjectClass *gobject_class; GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_class; GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
gobject_class = (GObjectClass*)klass; parent_class = g_type_class_peek_parent (klass);
gstelement_class = (GstElementClass*)klass;
parent_class = g_type_class_ref(GST_TYPE_ELEMENT); g_object_class_install_property(gobject_class, ARG_DEVICE,
g_param_spec_string("device", "Device", "Device location",
NULL, G_PARAM_READWRITE));
g_object_class_install_property(gobject_class, ARG_DEVICE_NAME,
g_param_spec_string("device_name", "Device name",
"Name of the device", NULL, G_PARAM_READABLE));
g_object_class_install_property(gobject_class, ARG_FLAGS,
g_param_spec_flags("flags", "Flags", "Device type flags",
GST_TYPE_V4L2_DEVICE_FLAGS, 0, G_PARAM_READABLE));
g_object_class_install_property(gobject_class, ARG_NORM,
g_param_spec_string("norm", "norm",
"Norm to use", NULL, G_PARAM_READWRITE));
g_object_class_install_property(gobject_class, ARG_CHANNEL,
g_param_spec_string("channel", "channel",
"input/output to switch to", NULL, G_PARAM_READWRITE));
g_object_class_install_property(gobject_class, ARG_FREQUENCY,
g_param_spec_ulong ("frequency", "frequency",
"frequency to tune to", 0, G_MAXULONG, 0, G_PARAM_READWRITE));
g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DEVICE, /* signals */
g_param_spec_string("device", "Device", "Device location", gst_v4l2element_signals[SIGNAL_OPEN] =
NULL, G_PARAM_READWRITE)); g_signal_new("open", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DEVICE_NAME, G_STRUCT_OFFSET(GstV4l2ElementClass, open),
g_param_spec_string("device_name", "Device name", NULL, NULL, g_cclosure_marshal_VOID__STRING,
"Name of the device", NULL, G_PARAM_READABLE)); G_TYPE_NONE, 1, G_TYPE_STRING);
g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FLAGS, gst_v4l2element_signals[SIGNAL_CLOSE] =
g_param_spec_flags("flags", "Flags", "Device type flags", g_signal_new("close", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
GST_TYPE_V4L2_DEVICE_FLAGS, 0, G_PARAM_READABLE)); G_STRUCT_OFFSET(GstV4l2ElementClass, close),
NULL, NULL, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
/* signals */ gobject_class->set_property = gst_v4l2element_set_property;
gst_v4l2element_signals[SIGNAL_OPEN] = gobject_class->get_property = gst_v4l2element_get_property;
g_signal_new("open", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST, gobject_class->dispose = gst_v4l2element_dispose;
G_STRUCT_OFFSET(GstV4l2ElementClass, open),
NULL, NULL, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
gst_v4l2element_signals[SIGNAL_CLOSE] =
g_signal_new("close", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GstV4l2ElementClass, close),
NULL, NULL, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
gobject_class->set_property = gst_v4l2element_set_property; gstelement_class->change_state = gst_v4l2element_change_state;
gobject_class->get_property = gst_v4l2element_get_property;
gobject_class->dispose = gst_v4l2element_dispose;
gstelement_class->change_state = gst_v4l2element_change_state;
} }
@ -446,10 +455,13 @@ gst_v4l2element_dispose (GObject *object)
g_free (v4l2element->display); g_free (v4l2element->display);
} }
if (v4l2element->device) { g_free (v4l2element->device);
g_free (v4l2element->device); v4l2element->device = NULL;
} g_free (v4l2element->norm);
v4l2element->norm = NULL;
g_free (v4l2element->channel);
v4l2element->channel = NULL;
if (((GObjectClass *) parent_class)->dispose) if (((GObjectClass *) parent_class)->dispose)
((GObjectClass *) parent_class)->dispose(object); ((GObjectClass *) parent_class)->dispose(object);
} }
@ -460,24 +472,63 @@ gst_v4l2element_set_property (GObject *object,
const GValue *value, const GValue *value,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GstV4l2Element *v4l2element; GstV4l2Element *v4l2element;
GstTuner *tuner;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail(GST_IS_V4L2ELEMENT(object)); /* it's not null if we got it, but it might not be ours */
v4l2element = GST_V4L2ELEMENT(object); g_return_if_fail (GST_IS_V4L2ELEMENT (object));
v4l2element = GST_V4L2ELEMENT (object);
switch (prop_id) { /* stupid GstInterface */
case ARG_DEVICE: tuner = (GstTuner *) object;
if (!GST_V4L2_IS_OPEN(v4l2element)) {
if (v4l2element->device) switch (prop_id) {
g_free(v4l2element->device); case ARG_DEVICE:
v4l2element->device = g_strdup(g_value_get_string(value)); if (!GST_V4L2_IS_OPEN(v4l2element)) {
} if (v4l2element->device)
break; g_free(v4l2element->device);
default: v4l2element->device = g_value_dup_string(value);
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); }
break; break;
case ARG_NORM:
if (GST_V4L2_IS_OPEN(v4l2element)) {
GstTunerNorm *norm = gst_tuner_get_norm (tuner);
if (norm) {
gst_tuner_set_norm (tuner, norm);
} }
} else {
g_free (v4l2element->norm);
v4l2element->norm = g_value_dup_string (value);
g_object_notify (object, "norm");
}
break;
case ARG_CHANNEL:
if (GST_V4L2_IS_OPEN(v4l2element)) {
GstTunerChannel *channel = gst_tuner_get_channel (tuner);
if (channel) {
gst_tuner_set_channel (tuner, channel);
}
} else {
g_free (v4l2element->channel);
v4l2element->channel = g_value_dup_string (value);
g_object_notify (object, "channel");
}
break;
case ARG_FREQUENCY:
if (GST_V4L2_IS_OPEN(v4l2element)) {
GstTunerChannel *channel;
if (!v4l2element->channel) return;
channel = gst_tuner_get_channel (tuner);
g_assert (channel);
gst_tuner_set_frequency (tuner, channel, g_value_get_ulong (value));
} else {
v4l2element->frequency = g_value_get_ulong (value);
g_object_notify (object, "frequency");
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
} }
@ -513,6 +564,15 @@ gst_v4l2element_get_property (GObject *object,
g_value_set_flags(value, flags); g_value_set_flags(value, flags);
break; break;
} }
case ARG_NORM:
g_value_set_string (value, v4l2element->norm);
break;
case ARG_CHANNEL:
g_value_set_string (value, v4l2element->channel);
break;
case ARG_FREQUENCY:
g_value_set_ulong (value, v4l2element->frequency);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break; break;

5
sys/v4l2/gstv4l2element.h
View file

@ -82,6 +82,11 @@ struct _GstV4l2Element {
GstXWindowListener *overlay; GstXWindowListener *overlay;
XID xwindow_id; XID xwindow_id;
/* properties */
gchar *norm;
gchar *channel;
gulong frequency;
/* caching values */ /* caching values */
gchar *display; gchar *display;
}; };

1218
sys/v4l2/gstv4l2src.c
View file

File diff suppressed because it is too large Load diff

45
sys/v4l2/gstv4l2src.h
View file

@ -22,6 +22,10 @@
#include <gstv4l2element.h> #include <gstv4l2element.h>
GST_DEBUG_CATEGORY_EXTERN (v4l2src_debug);
#define GST_V4L2_MAX_BUFFERS 16
#define GST_V4L2_MIN_BUFFERS 2
#define GST_TYPE_V4L2SRC \ #define GST_TYPE_V4L2SRC \
(gst_v4l2src_get_type()) (gst_v4l2src_get_type())
@ -34,9 +38,26 @@
#define GST_IS_V4L2SRC_CLASS(obj) \ #define GST_IS_V4L2SRC_CLASS(obj) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_V4L2SRC)) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_V4L2SRC))
typedef struct _GstV4l2BufferPool GstV4l2BufferPool;
typedef struct _GstV4l2Buffer GstV4l2Buffer;
typedef struct _GstV4l2Src GstV4l2Src;
typedef struct _GstV4l2SrcClass GstV4l2SrcClass;
typedef struct _GstV4l2Src GstV4l2Src; /* global info */
typedef struct _GstV4l2SrcClass GstV4l2SrcClass; struct _GstV4l2BufferPool {
GstAtomicInt refcount; /* number of users: 1 for every buffer, 1 for element */
gint video_fd;
guint buffer_count;
GstV4l2Buffer * buffers;
};
struct _GstV4l2Buffer {
struct v4l2_buffer buffer;
guint8 * start;
guint length;
GstAtomicInt refcount; /* add 1 if in use by element, add 1 if in use by GstBuffer */
GstV4l2BufferPool * pool;
};
struct _GstV4l2Src { struct _GstV4l2Src {
GstV4l2Element v4l2element; GstV4l2Element v4l2element;
@ -45,28 +66,21 @@ struct _GstV4l2Src {
GstPad *srcpad; GstPad *srcpad;
/* internal lists */ /* internal lists */
GList /*v4l2_fmtdesc*/ *formats, *format_list; /* list of available capture formats */ GSList *formats; /* list of available capture formats */
/* buffers */
GstV4l2BufferPool *pool;
/* buffer properties */
struct v4l2_buffer bufsettings;
struct v4l2_requestbuffers breq; struct v4l2_requestbuffers breq;
struct v4l2_format format; struct v4l2_format format;
/* num of queued frames and some GThread stuff
* to wait if there's not enough */
gint8 *frame_queue_state;
GMutex *mutex_queue_state;
GCond *cond_queue_state;
gint num_queued;
gint queue_frame;
/* True if we want to stop */ /* True if we want to stop */
gboolean quit; gboolean quit;
/* A/V sync... frame counter and internal cache */ /* A/V sync... frame counter and internal cache */
gulong handled; gulong handled;
gint last_frame;
gint need_writes; gint need_writes;
GstBuffer *cached_buffer;
gulong last_seq; gulong last_seq;
/* clock */ /* clock */
@ -75,9 +89,6 @@ struct _GstV4l2Src {
/* time to substract from clock time to get back to timestamp */ /* time to substract from clock time to get back to timestamp */
GstClockTime substract_time; GstClockTime substract_time;
/* how often are we going to use each frame? */
gint *use_num_times;
/* how are we going to push buffers? */ /* how are we going to push buffers? */
gboolean use_fixed_fps; gboolean use_fixed_fps;
}; };

32
sys/v4l2/gstv4l2tuner.c
View file

@ -40,14 +40,14 @@ static const GList *
gst_v4l2_tuner_list_channels (GstTuner *mixer); gst_v4l2_tuner_list_channels (GstTuner *mixer);
static void gst_v4l2_tuner_set_channel (GstTuner *mixer, static void gst_v4l2_tuner_set_channel (GstTuner *mixer,
GstTunerChannel *channel); GstTunerChannel *channel);
static const GstTunerChannel * static GstTunerChannel *
gst_v4l2_tuner_get_channel (GstTuner *mixer); gst_v4l2_tuner_get_channel (GstTuner *mixer);
static const GList * static const GList *
gst_v4l2_tuner_list_norms (GstTuner *mixer); gst_v4l2_tuner_list_norms (GstTuner *mixer);
static void gst_v4l2_tuner_set_norm (GstTuner *mixer, static void gst_v4l2_tuner_set_norm (GstTuner *mixer,
GstTunerNorm *norm); GstTunerNorm *norm);
static const GstTunerNorm * static GstTunerNorm *
gst_v4l2_tuner_get_norm (GstTuner *mixer); gst_v4l2_tuner_get_norm (GstTuner *mixer);
static void gst_v4l2_tuner_set_frequency (GstTuner *mixer, static void gst_v4l2_tuner_set_frequency (GstTuner *mixer,
@ -205,13 +205,15 @@ gst_v4l2_tuner_set_channel (GstTuner *mixer,
g_return_if_fail (gst_v4l2_tuner_contains_channel (v4l2element, v4l2channel)); g_return_if_fail (gst_v4l2_tuner_contains_channel (v4l2element, v4l2channel));
/* ... or output, if we're a sink... */ /* ... or output, if we're a sink... */
if (gst_v4l2_tuner_is_sink (v4l2element)) if (gst_v4l2_tuner_is_sink (v4l2element) ?
gst_v4l2_set_output (v4l2element, v4l2channel->index); gst_v4l2_set_output (v4l2element, v4l2channel->index) :
else gst_v4l2_set_input (v4l2element, v4l2channel->index)) {
gst_v4l2_set_input (v4l2element, v4l2channel->index); gst_tuner_channel_changed (mixer, channel);
g_object_notify (G_OBJECT (v4l2element), "channel");
}
} }
static const GstTunerChannel * static GstTunerChannel *
gst_v4l2_tuner_get_channel (GstTuner *mixer) gst_v4l2_tuner_get_channel (GstTuner *mixer)
{ {
GstV4l2Element *v4l2element = GST_V4L2ELEMENT (mixer); GstV4l2Element *v4l2element = GST_V4L2ELEMENT (mixer);
@ -229,7 +231,7 @@ gst_v4l2_tuner_get_channel (GstTuner *mixer)
for (item = v4l2element->channels; item != NULL; item = item->next) { for (item = v4l2element->channels; item != NULL; item = item->next) {
if (channel == GST_V4L2_TUNER_CHANNEL (item->data)->index) if (channel == GST_V4L2_TUNER_CHANNEL (item->data)->index)
return (const GstTunerChannel *) item->data; return (GstTunerChannel *) item->data;
} }
return NULL; return NULL;
@ -265,10 +267,13 @@ gst_v4l2_tuner_set_norm (GstTuner *mixer,
g_return_if_fail (GST_V4L2_IS_OPEN (v4l2element)); g_return_if_fail (GST_V4L2_IS_OPEN (v4l2element));
g_return_if_fail (gst_v4l2_tuner_contains_norm (v4l2element, v4l2norm)); g_return_if_fail (gst_v4l2_tuner_contains_norm (v4l2element, v4l2norm));
gst_v4l2_set_norm (v4l2element, v4l2norm->index); if (gst_v4l2_set_norm (v4l2element, v4l2norm->index)) {
gst_tuner_norm_changed (mixer, norm);
g_object_notify (G_OBJECT (v4l2element), "norm");
}
} }
static const GstTunerNorm * static GstTunerNorm *
gst_v4l2_tuner_get_norm (GstTuner *mixer) gst_v4l2_tuner_get_norm (GstTuner *mixer)
{ {
GstV4l2Element *v4l2element = GST_V4L2ELEMENT (mixer); GstV4l2Element *v4l2element = GST_V4L2ELEMENT (mixer);
@ -282,7 +287,7 @@ gst_v4l2_tuner_get_norm (GstTuner *mixer)
for (item = v4l2element->norms; item != NULL; item = item->next) { for (item = v4l2element->norms; item != NULL; item = item->next) {
if (norm == GST_V4L2_TUNER_NORM (item->data)->index) if (norm == GST_V4L2_TUNER_NORM (item->data)->index)
return (const GstTunerNorm *) item->data; return (GstTunerNorm *) item->data;
} }
return NULL; return NULL;
@ -306,7 +311,10 @@ gst_v4l2_tuner_set_frequency (GstTuner *mixer,
gst_v4l2_get_input (v4l2element, &chan); gst_v4l2_get_input (v4l2element, &chan);
if (chan == GST_V4L2_TUNER_CHANNEL (channel)->index && if (chan == GST_V4L2_TUNER_CHANNEL (channel)->index &&
GST_TUNER_CHANNEL_HAS_FLAG (channel, GST_TUNER_CHANNEL_FREQUENCY)) { GST_TUNER_CHANNEL_HAS_FLAG (channel, GST_TUNER_CHANNEL_FREQUENCY)) {
gst_v4l2_set_frequency (v4l2element, v4l2channel->tuner, frequency); if (gst_v4l2_set_frequency (v4l2element, v4l2channel->tuner, frequency)) {
gst_tuner_frequency_changed (mixer, channel, frequency);
g_object_notify (G_OBJECT (v4l2element), "frequency");
}
} }
} }

48
sys/v4l2/v4l2_calls.c
View file

@ -342,6 +342,49 @@ gst_v4l2_empty_lists (GstV4l2Element *v4l2element)
v4l2element->colors = NULL; v4l2element->colors = NULL;
} }
/* FIXME: move this stuff to gstv4l2tuner.c? */
static void
gst_v4l2_set_defaults (GstV4l2Element *v4l2element)
{
GstTunerNorm *norm = NULL;
GstTunerChannel *channel = NULL;
GstTuner *tuner = GST_TUNER (v4l2element);
if (v4l2element->norm)
norm = gst_tuner_find_norm_by_name (tuner, v4l2element->norm);
if (norm) {
gst_tuner_set_norm (tuner, norm);
} else {
norm = GST_TUNER_NORM (gst_tuner_get_norm (GST_TUNER (v4l2element)));
v4l2element->norm = g_strdup (norm->label);
gst_tuner_norm_changed (tuner, norm);
g_object_notify (G_OBJECT (v4l2element), "norm");
}
if (v4l2element->channel)
channel = gst_tuner_find_channel_by_name (tuner, v4l2element->channel);
if (channel) {
gst_tuner_set_channel (tuner, channel);
} else {
channel = GST_TUNER_CHANNEL (gst_tuner_get_channel (GST_TUNER (v4l2element)));
v4l2element->channel = g_strdup (channel->label);
gst_tuner_channel_changed (tuner, channel);
g_object_notify (G_OBJECT (v4l2element), "channel");
}
if (v4l2element->frequency != 0) {
gst_tuner_set_frequency (tuner, channel, v4l2element->frequency);
} else {
v4l2element->frequency = gst_tuner_get_frequency (tuner, channel);
if (v4l2element->frequency == 0) {
/* guess */
gst_tuner_set_frequency (tuner, channel, 1000);
} else {
g_object_notify (G_OBJECT (v4l2element), "frequency");
}
}
}
/****************************************************** /******************************************************
* gst_v4l2_open(): * gst_v4l2_open():
@ -387,7 +430,10 @@ gst_v4l2_open (GstV4l2Element *v4l2element)
if (!gst_v4l2_fill_lists(v4l2element)) if (!gst_v4l2_fill_lists(v4l2element))
goto error; goto error;
gst_info("Opened device '%s' (%s) successfully\n", /* set defaults */
gst_v4l2_set_defaults (v4l2element);
GST_INFO_OBJECT (v4l2element, "Opened device '%s' (%s) successfully\n",
v4l2element->vcap.card, v4l2element->device); v4l2element->vcap.card, v4l2element->device);
return TRUE; return TRUE;

578
sys/v4l2/v4l2src_calls.c
View file

@ -31,26 +31,24 @@
#include <errno.h> #include <errno.h>
#include "v4l2src_calls.h" #include "v4l2src_calls.h"
#include <sys/time.h> #include <sys/time.h>
#include <unistd.h>
#define GST_CAT_DEFAULT v4l2src_debug
/* lalala... */
#define GST_V4L2_SET_ACTIVE(element) (element)->buffer = GINT_TO_POINTER (-1)
#define GST_V4L2_SET_INACTIVE(element) (element)->buffer = NULL
#define DEBUG(format, args...) \ #define DEBUG(format, args...) \
GST_DEBUG_OBJECT (\ GST_CAT_DEBUG_OBJECT (\
GST_ELEMENT(v4l2src), \ v4l2src_debug, v4l2src, \
"V4L2SRC: " format, ##args) "V4L2SRC: " format, ##args)
#define MIN_BUFFERS_QUEUED 2
/* On some systems MAP_FAILED seems to be missing */ /* On some systems MAP_FAILED seems to be missing */
#ifndef MAP_FAILED #ifndef MAP_FAILED
#define MAP_FAILED ( (caddr_t) -1 ) #define MAP_FAILED ( (caddr_t) -1 )
#endif #endif
enum {
QUEUE_STATE_ERROR = -1,
QUEUE_STATE_READY_FOR_QUEUE,
QUEUE_STATE_QUEUED,
QUEUE_STATE_SYNCED,
};
/****************************************************** /******************************************************
* gst_v4l2src_fill_format_list(): * gst_v4l2src_fill_format_list():
* create list of supported capture formats * create list of supported capture formats
@ -60,54 +58,49 @@ enum {
gboolean gboolean
gst_v4l2src_fill_format_list (GstV4l2Src *v4l2src) gst_v4l2src_fill_format_list (GstV4l2Src *v4l2src)
{ {
gint n; gint n;
struct v4l2_fmtdesc *format;
DEBUG("getting src format enumerations"); GST_DEBUG_OBJECT (v4l2src, "getting src format enumerations");
/* format enumeration */ /* format enumeration */
for (n=0;;n++) { for (n=0;;n++) {
struct v4l2_fmtdesc format, *fmtptr; format = g_new (struct v4l2_fmtdesc, 1);
format.index = n; format->index = n;
format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_ENUM_FMT, &format) < 0) { if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_ENUM_FMT, format) < 0) {
if (errno == EINVAL) if (errno == EINVAL) {
break; /* end of enumeration */ break; /* end of enumeration */
else { } else {
gst_element_error(GST_ELEMENT(v4l2src), gst_element_error(GST_ELEMENT(v4l2src),
"Failed to get no. %d in pixelformat enumeration for %s: %s", "Failed to get no. %d in pixelformat enumeration for %s: %s",
n, GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno)); n, GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE; g_free (format);
} return FALSE;
} }
fmtptr = g_malloc(sizeof(format)); }
memcpy(fmtptr, &format, sizeof(format)); GST_LOG_OBJECT (v4l2src, "got format"GST_FOURCC_FORMAT,
v4l2src->formats = g_list_append(v4l2src->formats, fmtptr); GST_FOURCC_ARGS (format->pixelformat));
v4l2src->formats = g_slist_prepend (v4l2src->formats, format);
}
v4l2src->format_list = g_list_append(v4l2src->format_list, fmtptr->description); return TRUE;
}
return TRUE;
} }
/****************************************************** /******************************************************
* gst_v4l2src_empty_format_list(): * gst_v4l2src_clear_format_list():
* free list of supported capture formats * free list of supported capture formats
* return value: TRUE on success, FALSE on error * return value: TRUE on success, FALSE on error
******************************************************/ ******************************************************/
gboolean gboolean
gst_v4l2src_empty_format_list (GstV4l2Src *v4l2src) gst_v4l2src_clear_format_list (GstV4l2Src *v4l2src)
{ {
while (g_list_length(v4l2src->formats) > 0) { g_slist_foreach (v4l2src->formats, (GFunc) g_free, NULL);
gpointer data = g_list_nth_data(v4l2src->formats, 0); g_slist_free (v4l2src->formats);
v4l2src->formats = g_list_remove(v4l2src->formats, data);
g_free(data);
}
g_list_free(v4l2src->format_list);
v4l2src->format_list = NULL;
return TRUE; return TRUE;
} }
@ -117,65 +110,47 @@ gst_v4l2src_empty_format_list (GstV4l2Src *v4l2src)
* return value: TRUE on success, FALSE on error * return value: TRUE on success, FALSE on error
******************************************************/ ******************************************************/
static gboolean gboolean
gst_v4l2src_queue_frame (GstV4l2Src *v4l2src, gst_v4l2src_queue_frame (GstV4l2Src *v4l2src,
gint num) guint i)
{ {
DEBUG("queueing frame %d", num); GST_LOG_OBJECT (v4l2src, "queueing frame %u", i);
if (v4l2src->frame_queue_state[num] != QUEUE_STATE_READY_FOR_QUEUE) { if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_QBUF, &v4l2src->pool->buffers[i].buffer) < 0) {
return FALSE; gst_element_error(GST_ELEMENT(v4l2src), "Error queueing buffer %u on device %s: %s",
} i, GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE;
}
v4l2src->bufsettings.index = num; return TRUE;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd,
VIDIOC_QBUF, &v4l2src->bufsettings) < 0) {
gst_element_error(GST_ELEMENT(v4l2src),
"Error queueing buffer %d on device %s: %s",
num, GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE;
}
v4l2src->frame_queue_state[num] = QUEUE_STATE_QUEUED;
v4l2src->num_queued++;
return TRUE;
} }
/****************************************************** /******************************************************
* gst_v4l2src_sync_next_frame(): * gst_v4l2src_grab_frame ():
* sync on a frame for capturing * grab a frame for capturing
* return value: TRUE on success, FALSE on error * return value: TRUE on success, FALSE on error
******************************************************/ ******************************************************/
static gboolean gint
gst_v4l2src_sync_next_frame (GstV4l2Src *v4l2src, gst_v4l2src_grab_frame (GstV4l2Src *v4l2src)
gint *num)
{ {
if (v4l2src->num_queued <= 0) { struct v4l2_buffer buffer;
return FALSE;
} buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
while (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_DQBUF, &buffer) < 0) {
/* if the sync() got interrupted, we can retry */
if (errno != EINTR) {
gst_element_error(GST_ELEMENT(v4l2src), "Error syncing on a buffer on device %s: %s",
GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return -1;
}
GST_DEBUG_OBJECT (v4l2src, "grab got interrupted");
}
while (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, GST_LOG_OBJECT (v4l2src, "grabbed frame %d", buffer.index);
VIDIOC_DQBUF, &v4l2src->bufsettings) < 0) {
/* if the sync() got interrupted, we can retry */
if (errno != EINTR) {
gst_element_error(GST_ELEMENT(v4l2src),
"Error syncing on a buffer on device %s: %s",
GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE;
}
DEBUG("Sync got interrupted");
}
DEBUG("synced on frame %d", v4l2src->bufsettings.index); return buffer.index;
*num = v4l2src->bufsettings.index;
v4l2src->frame_queue_state[*num] = QUEUE_STATE_SYNCED;
v4l2src->num_queued--;
return TRUE;
} }
@ -226,6 +201,7 @@ gst_v4l2src_set_capture (GstV4l2Src *v4l2src,
v4l2src->format.fmt.pix.width = width; v4l2src->format.fmt.pix.width = width;
v4l2src->format.fmt.pix.height = height; v4l2src->format.fmt.pix.height = height;
v4l2src->format.fmt.pix.pixelformat = fmt->pixelformat; v4l2src->format.fmt.pix.pixelformat = fmt->pixelformat;
v4l2src->format.fmt.pix.field = V4L2_FIELD_INTERLACED;
v4l2src->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; v4l2src->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_S_FMT, &v4l2src->format) < 0) { if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_S_FMT, &v4l2src->format) < 0) {
@ -250,88 +226,81 @@ gst_v4l2src_set_capture (GstV4l2Src *v4l2src,
gboolean gboolean
gst_v4l2src_capture_init (GstV4l2Src *v4l2src) gst_v4l2src_capture_init (GstV4l2Src *v4l2src)
{ {
gint n; gint n;
gchar *desc = NULL; guint buffers;
struct v4l2_buffer buf;
DEBUG("initting the capture system"); GST_DEBUG_OBJECT (v4l2src, "initting the capture system");
GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src)); GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
GST_V4L2_CHECK_NOT_ACTIVE(GST_V4L2ELEMENT(v4l2src)); GST_V4L2_CHECK_NOT_ACTIVE(GST_V4L2ELEMENT(v4l2src));
/* request buffer info */ /* request buffer info */
if (v4l2src->breq.count < MIN_BUFFERS_QUEUED) { buffers = v4l2src->breq.count;
v4l2src->breq.count = MIN_BUFFERS_QUEUED; if (v4l2src->breq.count > GST_V4L2_MAX_BUFFERS) {
} v4l2src->breq.count = GST_V4L2_MAX_BUFFERS;
v4l2src->breq.type = v4l2src->format.type; }
v4l2src->breq.memory = V4L2_MEMORY_MMAP; if (v4l2src->breq.count < GST_V4L2_MIN_BUFFERS) {
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, v4l2src->breq.count = GST_V4L2_MIN_BUFFERS;
VIDIOC_REQBUFS, &v4l2src->breq) < 0) { }
gst_element_error(GST_ELEMENT(v4l2src), v4l2src->breq.type = v4l2src->format.type;
"Error requesting buffers (%d) for %s: %s", v4l2src->breq.memory = V4L2_MEMORY_MMAP;
v4l2src->breq.count, GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno)); if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_REQBUFS, &v4l2src->breq) < 0) {
return FALSE; gst_element_error(GST_ELEMENT(v4l2src), "Error requesting buffers (%d) for %s: %s",
} v4l2src->breq.count, GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE;
}
if (v4l2src->breq.count < MIN_BUFFERS_QUEUED) { if (v4l2src->breq.count < GST_V4L2_MIN_BUFFERS) {
gst_element_error(GST_ELEMENT(v4l2src), gst_element_error(GST_ELEMENT(v4l2src), "Too little buffers. We got %d, we want at least %d",
"Too little buffers. We got %d, we want at least %d", v4l2src->breq.count, GST_V4L2_MIN_BUFFERS);
v4l2src->breq.count, MIN_BUFFERS_QUEUED); v4l2src->breq.count = buffers;
return FALSE; return FALSE;
} }
v4l2src->bufsettings.type = v4l2src->format.type; if (v4l2src->breq.count != buffers)
g_object_notify (G_OBJECT (v4l2src), "num_buffers");
for (n=0;n<g_list_length(v4l2src->formats);n++) { GST_INFO_OBJECT (v4l2src, "Got %d buffers ("GST_FOURCC_FORMAT") of size %d KB\n",
struct v4l2_fmtdesc *fmt = (struct v4l2_fmtdesc *) g_list_nth_data(v4l2src->formats, n); v4l2src->breq.count, GST_FOURCC_ARGS (v4l2src->format.fmt.pix.pixelformat),
if (v4l2src->format.fmt.pix.pixelformat == fmt->pixelformat) { v4l2src->format.fmt.pix.sizeimage / 1024);
desc = fmt->description;
break;
}
}
gst_info("Got %d buffers (%s) of size %d KB\n",
v4l2src->breq.count, desc, v4l2src->format.fmt.pix.sizeimage/1024);
/* keep track of queued buffers */ /* Map the buffers */
v4l2src->frame_queue_state = (gint8 *) v4l2src->pool = g_new (GstV4l2BufferPool, 1);
g_malloc(sizeof(gint8) * v4l2src->breq.count); gst_atomic_int_init (&v4l2src->pool->refcount, 1);
v4l2src->pool->video_fd = GST_V4L2ELEMENT (v4l2src)->video_fd;
v4l2src->pool->buffer_count = v4l2src->breq.count;
v4l2src->pool->buffers = g_new0 (GstV4l2Buffer, v4l2src->breq.count);
/* track how often to use each frame */ for (n = 0; n < v4l2src->breq.count; n++) {
v4l2src->use_num_times = (gint *) GstV4l2Buffer *buffer = &v4l2src->pool->buffers[n];
g_malloc(sizeof(gint) * v4l2src->breq.count);
/* lock for the frame_state */ gst_atomic_int_init (&buffer->refcount, 1);
v4l2src->mutex_queue_state = g_mutex_new(); buffer->pool = v4l2src->pool;
v4l2src->cond_queue_state = g_cond_new(); buffer->buffer.index = n;
buffer->buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_QUERYBUF, &buffer->buffer) < 0) {
gst_element_error(GST_ELEMENT(v4l2src), "Failed to get buffer (%d) properties: %s",
n, g_strerror(errno));
gst_v4l2src_capture_deinit(v4l2src);
return FALSE;
}
buffer->start = mmap (0, buffer->buffer.length, PROT_READ|PROT_WRITE, MAP_SHARED,
GST_V4L2ELEMENT(v4l2src)->video_fd, buffer->buffer.m.offset);
if (buffer->start == MAP_FAILED) {
gst_element_error(GST_ELEMENT(v4l2src), "Error mapping video buffer (%d) on device %s: %s",
n, GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
buffer->start = 0;
gst_v4l2src_capture_deinit (v4l2src);
return FALSE;
}
buffer->length = buffer->buffer.length;
if (!gst_v4l2src_queue_frame(v4l2src, n)) {
gst_v4l2src_capture_deinit (v4l2src);
return FALSE;
}
}
/* Map the buffers */ GST_V4L2_SET_ACTIVE(GST_V4L2ELEMENT (v4l2src));
GST_V4L2ELEMENT(v4l2src)->buffer = (guint8 **) return TRUE;
g_malloc(sizeof(guint8 *) * v4l2src->breq.count);
for (n=0;n<v4l2src->breq.count;n++) {
buf.index = n;
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd,
VIDIOC_QUERYBUF, &buf) < 0) {
gst_element_error(GST_ELEMENT(v4l2src),
"Failed to get buffer (%d) properties: %s",
n, g_strerror(errno));
gst_v4l2src_capture_deinit(v4l2src);
return FALSE;
}
GST_V4L2ELEMENT(v4l2src)->buffer[n] = mmap(0,
buf.length, PROT_READ|PROT_WRITE, MAP_SHARED,
GST_V4L2ELEMENT(v4l2src)->video_fd, buf.m.offset);
if (GST_V4L2ELEMENT(v4l2src)->buffer[n] == MAP_FAILED) {
gst_element_error(GST_ELEMENT(v4l2src),
"Error mapping video buffer (%d) on device %s: %s",
n, GST_V4L2ELEMENT(v4l2src)->device,
g_strerror(errno));
GST_V4L2ELEMENT(v4l2src)->buffer[n] = NULL;
gst_v4l2src_capture_deinit(v4l2src);
return FALSE;
}
}
return TRUE;
} }
@ -344,147 +313,25 @@ gst_v4l2src_capture_init (GstV4l2Src *v4l2src)
gboolean gboolean
gst_v4l2src_capture_start (GstV4l2Src *v4l2src) gst_v4l2src_capture_start (GstV4l2Src *v4l2src)
{ {
gint n; gint type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
DEBUG("starting the capturing"); GST_DEBUG_OBJECT (v4l2src, "starting the capturing");
GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src)); GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
if (!GST_V4L2_IS_ACTIVE (GST_V4L2ELEMENT(v4l2src))) {
gst_pad_renegotiate (v4l2src->srcpad);
}
GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src));
g_mutex_lock(v4l2src->mutex_queue_state); v4l2src->quit = FALSE;
v4l2src->quit = FALSE; if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_STREAMON, &type) < 0) {
v4l2src->num_queued = 0; gst_element_error(GST_ELEMENT(v4l2src), "Error starting streaming capture for %s: %s",
v4l2src->queue_frame = 0; GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE;
}
/* set all buffers ready to queue , this starts streaming capture */ return TRUE;
for (n=0;n<v4l2src->breq.count;n++) {
v4l2src->frame_queue_state[n] = QUEUE_STATE_READY_FOR_QUEUE;
if (!gst_v4l2src_queue_frame(v4l2src, n)) {
g_mutex_unlock(v4l2src->mutex_queue_state);
gst_v4l2src_capture_stop(v4l2src);
return FALSE;
}
}
n = 1;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_STREAMON, &n) < 0) {
gst_element_error(GST_ELEMENT(v4l2src),
"Error starting streaming capture for %s: %s",
GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE;
}
g_mutex_unlock(v4l2src->mutex_queue_state);
return TRUE;
}
/******************************************************
* gst_v4l2src_grab_frame():
* capture one frame during streaming capture
* return value: TRUE on success, FALSE on error
******************************************************/
gboolean
gst_v4l2src_grab_frame (GstV4l2Src *v4l2src,
gint *num)
{
DEBUG("syncing on the next frame");
GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src));
g_mutex_lock(v4l2src->mutex_queue_state);
/* do we have enough frames? */
while (v4l2src->num_queued < MIN_BUFFERS_QUEUED ||
v4l2src->frame_queue_state[v4l2src->queue_frame] ==
QUEUE_STATE_READY_FOR_QUEUE) {
while (v4l2src->frame_queue_state[v4l2src->queue_frame] !=
QUEUE_STATE_READY_FOR_QUEUE &&
!v4l2src->quit) {
GST_DEBUG (
"Waiting for frames to become available (%d < %d)",
v4l2src->num_queued, MIN_BUFFERS_QUEUED);
g_cond_wait(v4l2src->cond_queue_state,
v4l2src->mutex_queue_state);
}
if (v4l2src->quit) {
g_mutex_unlock(v4l2src->mutex_queue_state);
return TRUE; /* it won't get through anyway */
}
if (!gst_v4l2src_queue_frame(v4l2src, v4l2src->queue_frame)) {
g_mutex_unlock(v4l2src->mutex_queue_state);
return FALSE;
}
v4l2src->queue_frame = (v4l2src->queue_frame + 1) % v4l2src->breq.count;
}
/* syncing on the buffer grabs it */
if (!gst_v4l2src_sync_next_frame(v4l2src, num)) {
g_mutex_unlock(v4l2src->mutex_queue_state);
return FALSE;
}
g_mutex_unlock(v4l2src->mutex_queue_state);
return TRUE;
}
/******************************************************
*
******************************************************/
guint8 *
gst_v4l2src_get_buffer (GstV4l2Src *v4l2src,
gint num)
{
if (!GST_V4L2_IS_ACTIVE(GST_V4L2ELEMENT(v4l2src)) ||
!GST_V4L2_IS_OPEN(GST_V4L2ELEMENT(v4l2src)))
return NULL;
if (num < 0 || num >= v4l2src->breq.count)
return NULL;
return GST_V4L2ELEMENT(v4l2src)->buffer[num];
}
/******************************************************
* gst_v4l2src_requeue_frame():
* re-queue a frame after we're done with the buffer
* return value: TRUE on success, FALSE on error
******************************************************/
gboolean
gst_v4l2src_requeue_frame (GstV4l2Src *v4l2src,
gint num)
{
DEBUG("requeueing frame %d", num);
GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src));
/* mark frame as 'ready to requeue' */
g_mutex_lock(v4l2src->mutex_queue_state);
if (v4l2src->frame_queue_state[num] != QUEUE_STATE_SYNCED) {
gst_element_error(GST_ELEMENT(v4l2src),
"Invalid state %d (expected %d), can't requeue",
v4l2src->frame_queue_state[num],
QUEUE_STATE_SYNCED);
return FALSE;
}
v4l2src->frame_queue_state[num] = QUEUE_STATE_READY_FOR_QUEUE;
/* let an optional wait know */
g_cond_broadcast(v4l2src->cond_queue_state);
g_mutex_unlock(v4l2src->mutex_queue_state);
return TRUE;
} }
@ -497,37 +344,60 @@ gst_v4l2src_requeue_frame (GstV4l2Src *v4l2src,
gboolean gboolean
gst_v4l2src_capture_stop (GstV4l2Src *v4l2src) gst_v4l2src_capture_stop (GstV4l2Src *v4l2src)
{ {
gint n = 0; gint type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
DEBUG("stopping capturing"); GST_DEBUG_OBJECT (v4l2src, "stopping capturing");
GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src)); GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src)); GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src));
g_mutex_lock(v4l2src->mutex_queue_state); /* we actually need to sync on all queued buffers but not
* on the non-queued ones */
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_STREAMOFF, &type) < 0) {
gst_element_error (GST_ELEMENT(v4l2src), "Error stopping streaming capture for %s: %s",
GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE;
}
/* we actually need to sync on all queued buffers but not /* make an optional pending wait stop */
* on the non-queued ones */ v4l2src->quit = TRUE;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_STREAMOFF, &n) < 0) {
gst_element_error(GST_ELEMENT(v4l2src),
"Error stopping streaming capture for %s: %s",
GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno));
return FALSE;
}
/* make an optional pending wait stop */
v4l2src->quit = TRUE;
g_cond_broadcast(v4l2src->cond_queue_state);
/* sync on remaining frames */ return TRUE;
while (v4l2src->num_queued > 0) {
gst_v4l2src_sync_next_frame(v4l2src, &n);
}
g_mutex_unlock(v4l2src->mutex_queue_state);
return TRUE;
} }
static void
gst_v4l2src_buffer_pool_free (GstV4l2BufferPool *pool, gboolean do_close)
{
guint i;
for (i = 0; i < pool->buffer_count; i++) {
gst_atomic_int_destroy (&pool->buffers[i].refcount);
munmap (pool->buffers[i].start, pool->buffers[i].length);
}
g_free (pool->buffers);
gst_atomic_int_destroy (&pool->refcount);
if (do_close)
close (pool->video_fd);
g_free (pool);
}
void
gst_v4l2src_free_buffer (GstBuffer *buffer)
{
GstV4l2Buffer *buf = (GstV4l2Buffer *) GST_BUFFER_PRIVATE (buffer);
GST_LOG ("freeing buffer %p (nr. %d)", buffer, buf->buffer.index);
if (!gst_atomic_int_dec_and_test (&buf->refcount)) {
/* we're still in use, add to queue again
note: this might fail because the device is already stopped (race) */
if (ioctl(buf->pool->video_fd, VIDIOC_QBUF, &buf->buffer) < 0)
GST_INFO ("readding to queue failed, assuming video device is stopped");
}
if (gst_atomic_int_dec_and_test (&buf->pool->refcount)) {
/* we're last thing that used all this */
gst_v4l2src_buffer_pool_free (buf->pool, TRUE);
}
}
/****************************************************** /******************************************************
* gst_v4l2src_capture_deinit(): * gst_v4l2src_capture_deinit():
@ -538,31 +408,32 @@ gst_v4l2src_capture_stop (GstV4l2Src *v4l2src)
gboolean gboolean
gst_v4l2src_capture_deinit (GstV4l2Src *v4l2src) gst_v4l2src_capture_deinit (GstV4l2Src *v4l2src)
{ {
int n; gint i, dequeue = 0;
DEBUG("deinitting capture system"); GST_DEBUG_OBJECT (v4l2src, "deinitting capture system");
GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src)); GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src));
/* unmap the buffer */ /* free the buffers */
for (n=0;n<v4l2src->breq.count;n++) { for (i = 0; i < v4l2src->breq.count; i++) {
if (!GST_V4L2ELEMENT(v4l2src)->buffer[n]) { if (gst_atomic_int_dec_and_test (&v4l2src->pool->buffers[i].refcount))
break; dequeue++;
} }
munmap(GST_V4L2ELEMENT(v4l2src)->buffer[n], for (i = 0; i < dequeue; i++) {
v4l2src->format.fmt.pix.sizeimage); struct v4l2_buffer buffer;
GST_V4L2ELEMENT(v4l2src)->buffer[n] = NULL; buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_DQBUF, &buffer) < 0)
GST_WARNING_OBJECT (v4l2src, "Could not dequeue buffer on uninitialization");
/* free buffer tracker */ }
g_free(GST_V4L2ELEMENT(v4l2src)->buffer); if (gst_atomic_int_dec_and_test (&v4l2src->pool->refcount)) {
GST_V4L2ELEMENT(v4l2src)->buffer = NULL; /* we're last thing that used all this */
g_mutex_free(v4l2src->mutex_queue_state); gst_v4l2src_buffer_pool_free (v4l2src->pool, FALSE);
g_cond_free(v4l2src->cond_queue_state); }
g_free(v4l2src->frame_queue_state); v4l2src->pool = NULL;
g_free(v4l2src->use_num_times);
GST_V4L2_SET_INACTIVE (GST_V4L2ELEMENT (v4l2src));
return TRUE; return TRUE;
} }
@ -578,13 +449,16 @@ gst_v4l2src_get_size_limits (GstV4l2Src *v4l2src,
{ {
struct v4l2_format fmt; struct v4l2_format fmt;
GST_LOG_OBJECT (v4l2src, "getting size limits with format " GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (format->pixelformat));
/* get size delimiters */ /* get size delimiters */
memset(&fmt, 0, sizeof(fmt)); memset(&fmt, 0, sizeof(fmt));
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = 0; fmt.fmt.pix.width = 0;
fmt.fmt.pix.height = 0; fmt.fmt.pix.height = 0;
fmt.fmt.pix.pixelformat = format->pixelformat; fmt.fmt.pix.pixelformat = format->pixelformat;
fmt.fmt.pix.field = V4L2_FIELD_ANY; fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd,
VIDIOC_TRY_FMT, &fmt) < 0) { VIDIOC_TRY_FMT, &fmt) < 0) {
return FALSE; return FALSE;
@ -594,9 +468,10 @@ gst_v4l2src_get_size_limits (GstV4l2Src *v4l2src,
*min_w = fmt.fmt.pix.width; *min_w = fmt.fmt.pix.width;
if (min_h) if (min_h)
*min_h = fmt.fmt.pix.height; *min_h = fmt.fmt.pix.height;
GST_LOG_OBJECT (v4l2src, "got min size %dx%d", fmt.fmt.pix.width, fmt.fmt.pix.height);
fmt.fmt.pix.width = G_MAXINT; fmt.fmt.pix.width = G_MAXINT;
fmt.fmt.pix.height = G_MAXINT; fmt.fmt.pix.height = 576;
if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd,
VIDIOC_TRY_FMT, &fmt) < 0) { VIDIOC_TRY_FMT, &fmt) < 0) {
return FALSE; return FALSE;
@ -606,6 +481,7 @@ gst_v4l2src_get_size_limits (GstV4l2Src *v4l2src,
*max_w = fmt.fmt.pix.width; *max_w = fmt.fmt.pix.width;
if (max_h) if (max_h)
*max_h = fmt.fmt.pix.height; *max_h = fmt.fmt.pix.height;
GST_LOG_OBJECT (v4l2src, "got max size %dx%d", fmt.fmt.pix.width, fmt.fmt.pix.height);
return TRUE; return TRUE;
} }

17
sys/v4l2/v4l2src_calls.h
View file

@ -17,8 +17,8 @@
* Boston, MA 02111-1307, USA. * Boston, MA 02111-1307, USA.
*/ */
#ifndef __V4L2_SRC_CALLS_H__ #ifndef __V4L2SRC_CALLS_H__
#define __V4L2_SRC_CALLS_H__ #define __V4L2SRC_CALLS_H__
#include "gstv4l2src.h" #include "gstv4l2src.h"
#include "v4l2_calls.h" #include "v4l2_calls.h"
@ -31,17 +31,16 @@ gboolean gst_v4l2src_set_capture (GstV4l2Src *v4l2src,
gint height); gint height);
gboolean gst_v4l2src_capture_init (GstV4l2Src *v4l2src); gboolean gst_v4l2src_capture_init (GstV4l2Src *v4l2src);
gboolean gst_v4l2src_capture_start (GstV4l2Src *v4l2src); gboolean gst_v4l2src_capture_start (GstV4l2Src *v4l2src);
gboolean gst_v4l2src_grab_frame (GstV4l2Src *v4l2src, gint gst_v4l2src_grab_frame (GstV4l2Src *v4l2src);
gint *num);
guint8 * gst_v4l2src_get_buffer (GstV4l2Src *v4l2src, guint8 * gst_v4l2src_get_buffer (GstV4l2Src *v4l2src,
gint num); gint num);
gboolean gst_v4l2src_requeue_frame (GstV4l2Src *v4l2src, gboolean gst_v4l2src_queue_frame (GstV4l2Src *v4l2src,
gint num); guint i);
gboolean gst_v4l2src_capture_stop (GstV4l2Src *v4l2src); gboolean gst_v4l2src_capture_stop (GstV4l2Src *v4l2src);
gboolean gst_v4l2src_capture_deinit (GstV4l2Src *v4l2src); gboolean gst_v4l2src_capture_deinit (GstV4l2Src *v4l2src);
gboolean gst_v4l2src_fill_format_list (GstV4l2Src *v4l2src); gboolean gst_v4l2src_fill_format_list (GstV4l2Src *v4l2src);
gboolean gst_v4l2src_empty_format_list (GstV4l2Src *v4l2src); gboolean gst_v4l2src_clear_format_list (GstV4l2Src *v4l2src);
/* hacky */ /* hacky */
gboolean gst_v4l2src_get_size_limits (GstV4l2Src *v4l2src, gboolean gst_v4l2src_get_size_limits (GstV4l2Src *v4l2src,
@ -49,4 +48,6 @@ gboolean gst_v4l2src_get_size_limits (GstV4l2Src *v4l2src,
gint *min_w, gint *max_w, gint *min_w, gint *max_w,
gint *min_h, gint *max_h); gint *min_h, gint *max_h);
#endif /* __V4L2_SRC_CALLS_H__ */ void gst_v4l2src_free_buffer (GstBuffer *buffer);
#endif /* __V4L2SRC_CALLS_H__ */