3 * v4lmjpegsrc_calls.c: functions for hardware MJPEG video source
5 * Copyright (C) 2001-2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
27 #include <sys/types.h>
30 #include <sys/ioctl.h>
34 #include "v4lmjpegsrc_calls.h"
36 /* On some systems MAP_FAILED seems to be missing */
38 #define MAP_FAILED ( (caddr_t) -1 )
41 #define MIN_BUFFERS_QUEUED 2
43 GST_DEBUG_CATEGORY_EXTERN (v4lmjpegsrc_debug);
44 #define GST_CAT_DEFAULT v4lmjpegsrc_debug
48 QUEUE_STATE_ERROR = -1,
49 QUEUE_STATE_READY_FOR_QUEUE,
54 /******************************************************
55 * gst_v4lmjpegsrc_queue_frame():
56 * queue a frame for capturing
57 * return value: TRUE on success, FALSE on error
58 ******************************************************/
61 gst_v4lmjpegsrc_queue_frame (GstV4lMjpegSrc * v4lmjpegsrc, gint num)
63 GST_DEBUG_OBJECT (v4lmjpegsrc, "queueing frame %d", num);
65 if (v4lmjpegsrc->frame_queue_state[num] != QUEUE_STATE_READY_FOR_QUEUE) {
69 if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_QBUF_CAPT,
71 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, READ, (NULL),
72 ("Error queueing a buffer (%d): %s", num, g_strerror (errno)));
76 v4lmjpegsrc->frame_queue_state[num] = QUEUE_STATE_QUEUED;
77 v4lmjpegsrc->num_queued++;
83 /******************************************************
84 * gst_v4lmjpegsrc_sync_next_frame():
85 * sync on the next frame for capturing
86 * return value: TRUE on success, FALSE on error
87 ******************************************************/
90 gst_v4lmjpegsrc_sync_next_frame (GstV4lMjpegSrc * v4lmjpegsrc, gint * num)
92 GST_DEBUG_OBJECT (v4lmjpegsrc, "syncing on next frame");
94 if (v4lmjpegsrc->num_queued <= 0) {
98 while (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd,
99 MJPIOC_SYNC, &(v4lmjpegsrc->bsync)) < 0) {
100 if (errno != EINTR) {
101 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SYNC, (NULL), GST_ERROR_SYSTEM);
104 GST_DEBUG_OBJECT (v4lmjpegsrc, "Sync got interrupted");
107 *num = v4lmjpegsrc->bsync.frame;
109 v4lmjpegsrc->frame_queue_state[*num] = QUEUE_STATE_SYNCED;
110 v4lmjpegsrc->num_queued--;
116 /******************************************************
117 * gst_v4lmjpegsrc_set_buffer():
118 * set buffer parameters (size/count)
119 * return value: TRUE on success, FALSE on error
120 ******************************************************/
123 gst_v4lmjpegsrc_set_buffer (GstV4lMjpegSrc * v4lmjpegsrc,
124 gint numbufs, gint bufsize)
126 GST_DEBUG_OBJECT (v4lmjpegsrc,
127 "setting buffer info to numbufs = %d, bufsize = %d KB", numbufs, bufsize);
128 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
129 GST_V4L_CHECK_NOT_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
131 v4lmjpegsrc->breq.size = bufsize * 1024;
132 v4lmjpegsrc->breq.count = numbufs;
138 /******************************************************
139 * gst_v4lmjpegsrc_set_capture():
140 * set capture parameters (simple)
141 * return value: TRUE on success, FALSE on error
142 ******************************************************/
145 gst_v4lmjpegsrc_set_capture (GstV4lMjpegSrc * v4lmjpegsrc,
146 gint decimation, gint quality)
149 struct mjpeg_params bparm;
151 GST_DEBUG_OBJECT (v4lmjpegsrc, "setting decimation = %d, quality = %d",
152 decimation, quality);
153 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
154 GST_V4L_CHECK_NOT_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
156 gst_v4l_get_chan_norm (GST_V4LELEMENT (v4lmjpegsrc), &input, &norm);
158 /* Query params for capture */
159 if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_G_PARAMS,
161 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SETTINGS, (NULL),
166 bparm.decimation = decimation;
167 bparm.quality = quality;
170 bparm.APP_len = 0; /* no JPEG markers - TODO: this is definitely not right for decimation==1 */
172 mw = GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth;
173 if (mw != 768 && mw != 640) {
179 v4lmjpegsrc->end_width = mw / decimation;
180 v4lmjpegsrc->end_height = (norm == VIDEO_MODE_NTSC ? 480 : 576) / decimation;
182 /* TODO: interlacing */
184 /* Set params for capture */
185 if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_S_PARAMS,
187 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SETTINGS, (NULL),
196 /******************************************************
197 * gst_v4lmjpegsrc_set_capture_m():
198 * set capture parameters (advanced)
199 * return value: TRUE on success, FALSE on error
200 ******************************************************/
203 gst_v4lmjpegsrc_set_capture_m (GstV4lMjpegSrc * v4lmjpegsrc,
206 gint width, gint height, gint h_decimation, gint v_decimation, gint quality)
210 struct mjpeg_params bparm;
212 GST_DEBUG_OBJECT (v4lmjpegsrc, "setting x_offset = %d, y_offset = %d, "
213 "width = %d, height = %d, h_decimation = %d, v_decimation = %d, quality = %d\n",
214 x_offset, y_offset, width, height, h_decimation, v_decimation, quality);
215 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
216 GST_V4L_CHECK_NOT_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
218 gst_v4l_get_chan_norm (GST_V4LELEMENT (v4lmjpegsrc), &input, &norm);
220 if (GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth != 768 &&
221 GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth != 640)
224 maxwidth = GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth;
226 /* Query params for capture */
227 if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_G_PARAMS,
229 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SETTINGS, (NULL),
234 bparm.decimation = 0;
235 bparm.quality = quality;
238 bparm.APP_len = 0; /* no JPEG markers - TODO: this is definitely
239 * not right for decimation==1 */
244 width = (maxwidth == 720
245 && h_decimation != 1) ? 704 : maxwidth - 2 * x_offset;
248 x_offset = (maxwidth - width) / 2;
254 height = (norm == VIDEO_MODE_NTSC) ? 480 : 576 - 2 * y_offset;
257 y_offset = ((norm == VIDEO_MODE_NTSC) ? 480 : 576 - height) / 2;
260 if (width + x_offset > maxwidth) {
261 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
262 ("Image width+offset (%d) bigger than maximum (%d)",
263 width + x_offset, maxwidth));
266 if ((width % (bparm.HorDcm * 16)) != 0) {
267 GST_ELEMENT_ERROR (v4lmjpegsrc, STREAM, FORMAT, (NULL),
268 ("Image width (%d) not multiple of %d (required for JPEG)",
269 width, bparm.HorDcm * 16));
272 if (height + y_offset > (norm == VIDEO_MODE_NTSC ? 480 : 576)) {
273 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
274 ("Image height+offset (%d) bigger than maximum (%d)",
275 height + y_offset, (norm == VIDEO_MODE_NTSC ? 480 : 576)));
278 /* RJ: Image height must only be a multiple of 8, but geom_height
279 * is double the field height
281 if ((height % (bparm.VerDcm * 16)) != 0) {
282 GST_ELEMENT_ERROR (v4lmjpegsrc, STREAM, FORMAT, (NULL),
283 ("Image height (%d) not multiple of %d (required for JPEG)",
284 height, bparm.VerDcm * 16));
288 bparm.img_x = x_offset;
289 bparm.img_width = width;
290 bparm.img_y = y_offset;
291 bparm.img_height = height;
292 bparm.HorDcm = h_decimation;
293 bparm.VerDcm = (v_decimation == 4) ? 2 : 1;
294 bparm.TmpDcm = (v_decimation == 1) ? 1 : 2;
295 bparm.field_per_buff = (v_decimation == 1) ? 2 : 1;
297 v4lmjpegsrc->end_width = width / h_decimation;
298 v4lmjpegsrc->end_width = height / v_decimation;
300 /* TODO: interlacing */
302 /* Set params for capture */
303 if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd, MJPIOC_S_PARAMS,
305 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, SETTINGS, (NULL),
314 /******************************************************
315 * gst_v4lmjpegsrc_capture_init():
316 * initialize the capture system
317 * return value: TRUE on success, FALSE on error
318 ******************************************************/
321 gst_v4lmjpegsrc_capture_init (GstV4lMjpegSrc * v4lmjpegsrc)
323 GST_DEBUG_OBJECT (v4lmjpegsrc, "initting capture subsystem");
324 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
325 GST_V4L_CHECK_NOT_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
327 /* Request buffers */
328 if (ioctl (GST_V4LELEMENT (v4lmjpegsrc)->video_fd,
329 MJPIOC_REQBUFS, &(v4lmjpegsrc->breq)) < 0) {
330 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM);
334 if (v4lmjpegsrc->breq.count < MIN_BUFFERS_QUEUED) {
335 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, READ, (NULL),
336 ("Too little buffers. We got %ld, we want at least %d",
337 v4lmjpegsrc->breq.count, MIN_BUFFERS_QUEUED));
341 GST_INFO_OBJECT (v4lmjpegsrc, "Got %ld buffers of size %ld KB",
342 v4lmjpegsrc->breq.count, v4lmjpegsrc->breq.size / 1024);
344 /* keep track of queued buffers */
345 v4lmjpegsrc->frame_queue_state = (gint8 *)
346 g_malloc (sizeof (gint8) * v4lmjpegsrc->breq.count);
348 /* track how often to use each frame */
349 v4lmjpegsrc->use_num_times = (gint *)
350 g_malloc (sizeof (gint) * v4lmjpegsrc->breq.count);
352 /* lock for the frame_state */
353 v4lmjpegsrc->mutex_queue_state = g_mutex_new ();
354 v4lmjpegsrc->cond_queue_state = g_cond_new ();
356 /* Map the buffers */
357 GST_V4LELEMENT (v4lmjpegsrc)->buffer = mmap (0,
358 v4lmjpegsrc->breq.count * v4lmjpegsrc->breq.size,
359 PROT_READ | PROT_WRITE, MAP_SHARED,
360 GST_V4LELEMENT (v4lmjpegsrc)->video_fd, 0);
361 if (GST_V4LELEMENT (v4lmjpegsrc)->buffer == MAP_FAILED) {
362 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
363 ("Error mapping video buffers: %s", g_strerror (errno)));
364 GST_V4LELEMENT (v4lmjpegsrc)->buffer = NULL;
372 /******************************************************
373 * gst_v4lmjpegsrc_capture_start():
374 * start streaming capture
375 * return value: TRUE on success, FALSE on error
376 ******************************************************/
379 gst_v4lmjpegsrc_capture_start (GstV4lMjpegSrc * v4lmjpegsrc)
383 GST_DEBUG_OBJECT (v4lmjpegsrc, "starting capture");
384 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
385 GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
387 g_mutex_lock (v4lmjpegsrc->mutex_queue_state);
389 v4lmjpegsrc->quit = FALSE;
390 v4lmjpegsrc->num_queued = 0;
391 v4lmjpegsrc->queue_frame = 0;
393 /* set all buffers ready to queue , this starts streaming capture */
394 for (n = 0; n < v4lmjpegsrc->breq.count; n++) {
395 v4lmjpegsrc->frame_queue_state[n] = QUEUE_STATE_READY_FOR_QUEUE;
396 if (!gst_v4lmjpegsrc_queue_frame (v4lmjpegsrc, n)) {
397 g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
398 gst_v4lmjpegsrc_capture_stop (v4lmjpegsrc);
403 v4lmjpegsrc->is_capturing = TRUE;
404 g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
410 /******************************************************
411 * gst_v4lmjpegsrc_grab_frame():
412 * grab one frame during streaming capture
413 * return value: TRUE on success, FALSE on error
414 ******************************************************/
417 gst_v4lmjpegsrc_grab_frame (GstV4lMjpegSrc * v4lmjpegsrc,
418 gint * num, gint * size)
420 GST_DEBUG_OBJECT (v4lmjpegsrc, "grabbing frame");
421 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
422 GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
424 g_mutex_lock (v4lmjpegsrc->mutex_queue_state);
426 /* do we have enough frames? */
427 while (v4lmjpegsrc->num_queued < MIN_BUFFERS_QUEUED ||
428 v4lmjpegsrc->frame_queue_state[v4lmjpegsrc->queue_frame] ==
429 QUEUE_STATE_READY_FOR_QUEUE) {
430 while (v4lmjpegsrc->frame_queue_state[v4lmjpegsrc->queue_frame] !=
431 QUEUE_STATE_READY_FOR_QUEUE && !v4lmjpegsrc->quit) {
432 GST_DEBUG_OBJECT (v4lmjpegsrc,
433 "Waiting for frames to become available (%d < %d)",
434 v4lmjpegsrc->num_queued, MIN_BUFFERS_QUEUED);
435 g_cond_wait (v4lmjpegsrc->cond_queue_state,
436 v4lmjpegsrc->mutex_queue_state);
438 if (v4lmjpegsrc->quit) {
439 g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
440 return TRUE; /* it won't get through anyway */
442 if (!gst_v4lmjpegsrc_queue_frame (v4lmjpegsrc, v4lmjpegsrc->queue_frame)) {
443 g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
446 v4lmjpegsrc->queue_frame =
447 (v4lmjpegsrc->queue_frame + 1) % v4lmjpegsrc->breq.count;
450 /* syncing on the buffer grabs it */
451 if (!gst_v4lmjpegsrc_sync_next_frame (v4lmjpegsrc, num)) {
455 *size = v4lmjpegsrc->bsync.length;
457 g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
463 /******************************************************
464 * gst_v4lmjpegsrc_get_buffer():
465 * get the memory address of a single buffer
466 * return value: TRUE on success, FALSE on error
467 ******************************************************/
470 gst_v4lmjpegsrc_get_buffer (GstV4lMjpegSrc * v4lmjpegsrc, gint num)
472 /*DEBUG("gst_v4lmjpegsrc_get_buffer(), num = %d", num); */
474 if (!GST_V4L_IS_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc)) ||
475 !GST_V4L_IS_OPEN (GST_V4LELEMENT (v4lmjpegsrc)))
478 if (num < 0 || num >= v4lmjpegsrc->breq.count)
481 return GST_V4LELEMENT (v4lmjpegsrc)->buffer + (v4lmjpegsrc->breq.size * num);
485 /******************************************************
486 * gst_v4lmjpegsrc_requeue_frame():
487 * requeue a frame for capturing
488 * return value: TRUE on success, FALSE on error
489 ******************************************************/
492 gst_v4lmjpegsrc_requeue_frame (GstV4lMjpegSrc * v4lmjpegsrc, gint num)
494 GST_DEBUG_OBJECT (v4lmjpegsrc, "requeueing frame %d", num);
495 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
496 GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
498 /* mark frame as 'ready to requeue' */
499 g_mutex_lock (v4lmjpegsrc->mutex_queue_state);
501 if (v4lmjpegsrc->frame_queue_state[num] != QUEUE_STATE_SYNCED) {
502 GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
503 ("Invalid state %d (expected %d), can't requeue",
504 v4lmjpegsrc->frame_queue_state[num], QUEUE_STATE_SYNCED));
508 v4lmjpegsrc->frame_queue_state[num] = QUEUE_STATE_READY_FOR_QUEUE;
510 /* let an optional wait know */
511 g_cond_broadcast (v4lmjpegsrc->cond_queue_state);
513 g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
519 /******************************************************
520 * gst_v4lmjpegsrc_capture_stop():
521 * stop streaming capture
522 * return value: TRUE on success, FALSE on error
523 ******************************************************/
526 gst_v4lmjpegsrc_capture_stop (GstV4lMjpegSrc * v4lmjpegsrc)
530 GST_DEBUG_OBJECT (v4lmjpegsrc, "stopping capture");
531 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
532 GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
534 g_mutex_lock (v4lmjpegsrc->mutex_queue_state);
536 /* make an optional pending wait stop */
537 v4lmjpegsrc->quit = TRUE;
538 g_cond_broadcast (v4lmjpegsrc->cond_queue_state);
540 /* sync on remaining frames */
541 while (v4lmjpegsrc->num_queued > 0) {
542 gst_v4lmjpegsrc_sync_next_frame (v4lmjpegsrc, &n);
545 v4lmjpegsrc->is_capturing = FALSE;
546 g_mutex_unlock (v4lmjpegsrc->mutex_queue_state);
552 /******************************************************
553 * gst_v4lmjpegsrc_capture_deinit():
554 * deinitialize the capture system
555 * return value: TRUE on success, FALSE on error
556 ******************************************************/
559 gst_v4lmjpegsrc_capture_deinit (GstV4lMjpegSrc * v4lmjpegsrc)
561 GST_DEBUG_OBJECT (v4lmjpegsrc, "quitting capture subsystem");
562 GST_V4L_CHECK_OPEN (GST_V4LELEMENT (v4lmjpegsrc));
563 GST_V4L_CHECK_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc));
565 /* unmap the buffer */
566 munmap (GST_V4LELEMENT (v4lmjpegsrc)->buffer,
567 v4lmjpegsrc->breq.size * v4lmjpegsrc->breq.count);
568 GST_V4LELEMENT (v4lmjpegsrc)->buffer = NULL;
570 /* free buffer tracker */
571 g_mutex_free (v4lmjpegsrc->mutex_queue_state);
572 g_cond_free (v4lmjpegsrc->cond_queue_state);
573 g_free (v4lmjpegsrc->frame_queue_state);
574 g_free (v4lmjpegsrc->use_num_times);