--- /dev/null
+/* GStreamer
+ *
+ * v4lmjpegsrc_calls.c: functions for hardware MJPEG video source
+ *
+ * Copyright (C) 2001-2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <errno.h>
+#include "v4lmjpegsrc_calls.h"
+
+/* On some systems MAP_FAILED seems to be missing */
+#ifndef MAP_FAILED
+#define MAP_FAILED ( (caddr_t) -1 )
+#endif
+
+#define MIN_BUFFERS_QUEUED 2
+
+GST_DEBUG_CATEGORY_EXTERN (v4lmjpegsrc_debug);
+#define GST_CAT_DEFAULT v4lmjpegsrc_debug
+
+enum
+{
+ QUEUE_STATE_ERROR = -1,
+ QUEUE_STATE_READY_FOR_QUEUE,
+ QUEUE_STATE_QUEUED,
+ QUEUE_STATE_SYNCED,
+};
+
+/******************************************************
+ * gst_v4lmjpegsrc_queue_frame():
+ * queue a frame for capturing
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+static gboolean
+gst_v4lmjpegsrc_queue_frame (GstV4lMjpegSrc * v4lmjpegsrc, gint num)
+{
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "queueing frame %d", num);
+
+ if (v4lmjpegsrc->frame_queue_state[num] != QUEUE_STATE_READY_FOR_QUEUE) {
+ return FALSE;
+ }
+
+ if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_QBUF_CAPT,
+ &num) < 0) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, READ, (NULL),
+ ("Error queueing a buffer (%d): %s", num, g_strerror (errno)));
+ return FALSE;
+ }
+
+ v4lmjpegsrc->frame_queue_state[num] = QUEUE_STATE_QUEUED;
+ v4lmjpegsrc->num_queued++;
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_sync_next_frame():
+ * sync on the next frame for capturing
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+static gboolean
+gst_v4lmjpegsrc_sync_next_frame (GstV4lMjpegSrc * v4lmjpegsrc, gint * num)
+{
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "syncing on next frame");
+
+ if (v4lmjpegsrc->num_queued <= 0) {
+ return FALSE;
+ }
+
+ while (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd,
+ MJPIOC_SYNC, &(v4lmjpegsrc->bsync)) < 0) {
+ if (errno != EINTR) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SYNC, (NULL), GST_ERROR_SYSTEM);
+ return FALSE;
+ }
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "Sync got interrupted");
+ }
+
+ *num = v4lmjpegsrc->bsync.frame;
+
+ v4lmjpegsrc->frame_queue_state[*num] = QUEUE_STATE_SYNCED;
+ v4lmjpegsrc->num_queued--;
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_set_buffer():
+ * set buffer parameters (size/count)
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_set_buffer (GstV4lMjpegSrc * v4lmjpegsrc,
+ gint numbufs, gint bufsize)
+{
+ GST_DEBUG_OBJECT (v4lmjpegsrc,
+ "setting buffer info to numbufs = %d, bufsize = %d KB", numbufs, bufsize);
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_NOT_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ v4lmjpegsrc->breq.size = bufsize * 1024;
+ v4lmjpegsrc->breq.count = numbufs;
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_set_capture():
+ * set capture parameters (simple)
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_set_capture (GstV4lMjpegSrc * v4lmjpegsrc,
+ gint decimation, gint quality)
+{
+ int norm, input, mw;
+ struct mjpeg_params bparm;
+
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "setting decimation = %d, quality = %d",
+ decimation, quality);
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_NOT_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ gst_v4l_get_chan_norm (GST_V4LELEMENT (v4lmjpegsrc), &input, &norm);
+
+ /* Query params for capture */
+ if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_G_PARAMS,
+ &bparm) < 0) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SETTINGS, (NULL),
+ GST_ERROR_SYSTEM);
+ return FALSE;
+ }
+
+ bparm.decimation = decimation;
+ bparm.quality = quality;
+ bparm.norm = norm;
+ bparm.input = input;
+ bparm.APP_len = 0; /* no JPEG markers - TODO: this is definately not right for decimation==1 */
+
+ mw = GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth;
+ if (mw != 768 && mw != 640) {
+ if (decimation == 1)
+ mw = 720;
+ else
+ mw = 704;
+ }
+ v4lmjpegsrc->end_width = mw / decimation;
+ v4lmjpegsrc->end_height = (norm == VIDEO_MODE_NTSC ? 480 : 576) / decimation;
+
+ /* TODO: interlacing */
+
+ /* Set params for capture */
+ if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_S_PARAMS,
+ &bparm) < 0) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SETTINGS, (NULL),
+ GST_ERROR_SYSTEM);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_set_capture_m():
+ * set capture parameters (advanced)
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_set_capture_m (GstV4lMjpegSrc * v4lmjpegsrc,
+ gint x_offset,
+ gint y_offset,
+ gint width, gint height, gint h_decimation, gint v_decimation, gint quality)
+{
+ gint norm, input;
+ gint maxwidth;
+ struct mjpeg_params bparm;
+
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "setting x_offset = %d, y_offset = %d, "
+ "width = %d, height = %d, h_decimation = %d, v_decimation = %d, quality = %d\n",
+ x_offset, y_offset, width, height, h_decimation, v_decimation, quality);
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_NOT_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ gst_v4l_get_chan_norm (GST_V4LELEMENT (v4lmjpegsrc), &input, &norm);
+
+ if (GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth != 768 &&
+ GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth != 640)
+ maxwidth = 720;
+ else
+ maxwidth = GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth;
+
+ /* Query params for capture */
+ if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_G_PARAMS,
+ &bparm) < 0) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SETTINGS, (NULL),
+ GST_ERROR_SYSTEM);
+ return FALSE;
+ }
+
+ bparm.decimation = 0;
+ bparm.quality = quality;
+ bparm.norm = norm;
+ bparm.input = input;
+ bparm.APP_len = 0; /* no JPEG markers - TODO: this is definately
+ * not right for decimation==1 */
+
+ if (width <= 0) {
+ if (x_offset < 0)
+ x_offset = 0;
+ width = (maxwidth == 720
+ && h_decimation != 1) ? 704 : maxwidth - 2 * x_offset;
+ } else {
+ if (x_offset < 0)
+ x_offset = (maxwidth - width) / 2;
+ }
+
+ if (height <= 0) {
+ if (y_offset < 0)
+ y_offset = 0;
+ height = (norm == VIDEO_MODE_NTSC) ? 480 : 576 - 2 * y_offset;
+ } else {
+ if (y_offset < 0)
+ y_offset = ((norm == VIDEO_MODE_NTSC) ? 480 : 576 - height) / 2;
+ }
+
+ if (width + x_offset > maxwidth) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
+ ("Image width+offset (%d) bigger than maximum (%d)",
+ width + x_offset, maxwidth));
+ return FALSE;
+ }
+ if ((width % (bparm.HorDcm * 16)) != 0) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, STREAM, FORMAT, (NULL),
+ ("Image width (%d) not multiple of %d (required for JPEG)",
+ width, bparm.HorDcm * 16));
+ return FALSE;
+ }
+ if (height + y_offset > (norm == VIDEO_MODE_NTSC ? 480 : 576)) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
+ ("Image height+offset (%d) bigger than maximum (%d)",
+ height + y_offset, (norm == VIDEO_MODE_NTSC ? 480 : 576)));
+ return FALSE;
+ }
+ /* RJ: Image height must only be a multiple of 8, but geom_height
+ * is double the field height
+ */
+ if ((height % (bparm.VerDcm * 16)) != 0) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, STREAM, FORMAT, (NULL),
+ ("Image height (%d) not multiple of %d (required for JPEG)",
+ height, bparm.VerDcm * 16));
+ return FALSE;
+ }
+
+ bparm.img_x = x_offset;
+ bparm.img_width = width;
+ bparm.img_y = y_offset;
+ bparm.img_height = height;
+ bparm.HorDcm = h_decimation;
+ bparm.VerDcm = (v_decimation == 4) ? 2 : 1;
+ bparm.TmpDcm = (v_decimation == 1) ? 1 : 2;
+ bparm.field_per_buff = (v_decimation == 1) ? 2 : 1;
+
+ v4lmjpegsrc->end_width = width / h_decimation;
+ v4lmjpegsrc->end_width = height / v_decimation;
+
+ /* TODO: interlacing */
+
+ /* Set params for capture */
+ if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_S_PARAMS,
+ &bparm) < 0) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SETTINGS, (NULL),
+ GST_ERROR_SYSTEM);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_capture_init():
+ * initialize the capture system
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_capture_init (GstV4lMjpegSrc * v4lmjpegsrc)
+{
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "initting capture subsystem");
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_NOT_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ /* Request buffers */
+ if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd,
+ MJPIOC_REQBUFS, &(v4lmjpegsrc->breq)) < 0) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM);
+ return FALSE;
+ }
+
+ if (v4lmjpegsrc->breq.count < MIN_BUFFERS_QUEUED) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, READ, (NULL),
+ ("Too little buffers. We got %ld, we want at least %d",
+ v4lmjpegsrc->breq.count, MIN_BUFFERS_QUEUED));
+ return FALSE;
+ }
+
+ GST_INFO_OBJECT (v4lmjpegsrc, "Got %ld buffers of size %ld KB",
+ v4lmjpegsrc->breq.count, v4lmjpegsrc->breq.size / 1024);
+
+ /* keep track of queued buffers */
+ v4lmjpegsrc->frame_queue_state = (gint8 *)
+ g_malloc (sizeof (gint8) * v4lmjpegsrc->breq.count);
+
+ /* track how often to use each frame */
+ v4lmjpegsrc->use_num_times = (gint *)
+ g_malloc (sizeof (gint) * v4lmjpegsrc->breq.count);
+
+ /* lock for the frame_state */
+ v4lmjpegsrc->mutex_queue_state = g_mutex_new ();
+ v4lmjpegsrc->cond_queue_state = g_cond_new ();
+
+ /* Map the buffers */
+ GST_V4LELEMENT (v4lmjpegsrc)->buffer = mmap (0,
+ v4lmjpegsrc->breq.count * v4lmjpegsrc->breq.size,
+ PROT_READ | PROT_WRITE, MAP_SHARED,
+ GST_V4LELEMENT (v4lmjpegsrc)->video_fd, 0);
+ if (GST_V4LELEMENT (v4lmjpegsrc)->buffer == MAP_FAILED) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
+ ("Error mapping video buffers: %s", g_strerror (errno)));
+ GST_V4LELEMENT (v4lmjpegsrc)->buffer = NULL;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_capture_start():
+ * start streaming capture
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_capture_start (GstV4lMjpegSrc * v4lmjpegsrc)
+{
+ int n;
+
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "starting capture");
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ g_mutex_lock (v4lmjpegsrc->mutex_queue_state);
+
+ v4lmjpegsrc->quit = FALSE;
+ v4lmjpegsrc->num_queued = 0;
+ v4lmjpegsrc->queue_frame = 0;
+
+ /* set all buffers ready to queue , this starts streaming capture */
+ for (n = 0; n < v4lmjpegsrc->breq.count; n++) {
+ v4lmjpegsrc->frame_queue_state[n] = QUEUE_STATE_READY_FOR_QUEUE;
+ if (!gst_v4lmjpegsrc_queue_frame (v4lmjpegsrc, n)) {
+ g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
+ gst_v4lmjpegsrc_capture_stop (v4lmjpegsrc);
+ return FALSE;
+ }
+ }
+
+ v4lmjpegsrc->is_capturing = TRUE;
+ g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_grab_frame():
+ * grab one frame during streaming capture
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_grab_frame (GstV4lMjpegSrc * v4lmjpegsrc,
+ gint * num, gint * size)
+{
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "grabbing frame");
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ g_mutex_lock (v4lmjpegsrc->mutex_queue_state);
+
+ /* do we have enough frames? */
+ while (v4lmjpegsrc->num_queued < MIN_BUFFERS_QUEUED ||
+ v4lmjpegsrc->frame_queue_state[v4lmjpegsrc->queue_frame] ==
+ QUEUE_STATE_READY_FOR_QUEUE) {
+ while (v4lmjpegsrc->frame_queue_state[v4lmjpegsrc->queue_frame] !=
+ QUEUE_STATE_READY_FOR_QUEUE && !v4lmjpegsrc->quit) {
+ GST_DEBUG_OBJECT (v4lmjpegsrc,
+ "Waiting for frames to become available (%d < %d)",
+ v4lmjpegsrc->num_queued, MIN_BUFFERS_QUEUED);
+ g_cond_wait (v4lmjpegsrc->cond_queue_state,
+ v4lmjpegsrc->mutex_queue_state);
+ }
+ if (v4lmjpegsrc->quit) {
+ g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
+ return TRUE; /* it won't get through anyway */
+ }
+ if (!gst_v4lmjpegsrc_queue_frame (v4lmjpegsrc, v4lmjpegsrc->queue_frame)) {
+ g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
+ return FALSE;
+ }
+ v4lmjpegsrc->queue_frame =
+ (v4lmjpegsrc->queue_frame + 1) % v4lmjpegsrc->breq.count;
+ }
+
+ /* syncing on the buffer grabs it */
+ if (!gst_v4lmjpegsrc_sync_next_frame (v4lmjpegsrc, num)) {
+ return FALSE;
+ }
+
+ *size = v4lmjpegsrc->bsync.length;
+
+ g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_get_buffer():
+ * get the memory address of a single buffer
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+guint8 *
+gst_v4lmjpegsrc_get_buffer (GstV4lMjpegSrc * v4lmjpegsrc, gint num)
+{
+ /*DEBUG("gst_v4lmjpegsrc_get_buffer(), num = %d", num); */
+
+ if (!GST_V4L_IS_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc)) ||
+ !GST_V4L_IS_OPEN (GST_V4LELEMENT (v4lmjpegsrc)))
+ return NULL;
+
+ if (num < 0 || num >= v4lmjpegsrc->breq.count)
+ return NULL;
+
+ return GST_V4LELEMENT (v4lmjpegsrc)->buffer + (v4lmjpegsrc->breq.size * num);
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_requeue_frame():
+ * requeue a frame for capturing
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_requeue_frame (GstV4lMjpegSrc * v4lmjpegsrc, gint num)
+{
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "requeueing frame %d", num);
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ /* mark frame as 'ready to requeue' */
+ g_mutex_lock (v4lmjpegsrc->mutex_queue_state);
+
+ if (v4lmjpegsrc->frame_queue_state[num] != QUEUE_STATE_SYNCED) {
+ GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
+ ("Invalid state %d (expected %d), can't requeue",
+ v4lmjpegsrc->frame_queue_state[num], QUEUE_STATE_SYNCED));
+ return FALSE;
+ }
+
+ v4lmjpegsrc->frame_queue_state[num] = QUEUE_STATE_READY_FOR_QUEUE;
+
+ /* let an optional wait know */
+ g_cond_broadcast (v4lmjpegsrc->cond_queue_state);
+
+ g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_capture_stop():
+ * stop streaming capture
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_capture_stop (GstV4lMjpegSrc * v4lmjpegsrc)
+{
+ int n;
+
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "stopping capture");
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ g_mutex_lock (v4lmjpegsrc->mutex_queue_state);
+
+ /* make an optional pending wait stop */
+ v4lmjpegsrc->quit = TRUE;
+ g_cond_broadcast (v4lmjpegsrc->cond_queue_state);
+
+ /* sync on remaining frames */
+ while (v4lmjpegsrc->num_queued > 0) {
+ gst_v4lmjpegsrc_sync_next_frame (v4lmjpegsrc, &n);
+ }
+
+ v4lmjpegsrc->is_capturing = FALSE;
+ g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
+
+ return TRUE;
+}
+
+
+/******************************************************
+ * gst_v4lmjpegsrc_capture_deinit():
+ * deinitialize the capture system
+ * return value: TRUE on success, FALSE on error
+ ******************************************************/
+
+gboolean
+gst_v4lmjpegsrc_capture_deinit (GstV4lMjpegSrc * v4lmjpegsrc)
+{
+ GST_DEBUG_OBJECT (v4lmjpegsrc, "quitting capture subsystem");
+ GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
+ GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
+
+ /* unmap the buffer */
+ munmap (GST_V4LELEMENT (v4lmjpegsrc)->buffer,
+ v4lmjpegsrc->breq.size * v4lmjpegsrc->breq.count);
+ GST_V4LELEMENT (v4lmjpegsrc)->buffer = NULL;
+
+ /* free buffer tracker */
+ g_mutex_free (v4lmjpegsrc->mutex_queue_state);
+ g_cond_free (v4lmjpegsrc->cond_queue_state);
+ g_free (v4lmjpegsrc->frame_queue_state);
+ g_free (v4lmjpegsrc->use_num_times);
+
+ return TRUE;
+}
projects / mafwsubrenderer / blobdiff