summaryrefslogtreecommitdiff
path: root/v4l2-apps/test
diff options
context:
space:
mode:
Diffstat (limited to 'v4l2-apps/test')
-rw-r--r--v4l2-apps/test/Makefile20
-rw-r--r--v4l2-apps/test/ioctl-test.c223
-rw-r--r--v4l2-apps/test/sliced-vbi-detect.c144
-rw-r--r--v4l2-apps/test/sliced-vbi-test.c469
-rw-r--r--v4l2-apps/test/v4lgrab.c194
-rw-r--r--v4l2-apps/test/vbi-test.c89
6 files changed, 1139 insertions, 0 deletions
diff --git a/v4l2-apps/test/Makefile b/v4l2-apps/test/Makefile
new file mode 100644
index 000000000..b6a83b2b3
--- /dev/null
+++ b/v4l2-apps/test/Makefile
@@ -0,0 +1,20 @@
+# Makefile for linuxtv.org v4l2-apps/test
+
+CPPFLAGS += -I../../linux/include
+
+binaries = ioctl-test \
+ sliced-vbi-test \
+ sliced-vbi-detect \
+ vbi-test \
+ v4lgrab
+
+.PHONY: all clean install
+
+all: $(binaries)
+
+clean::
+ rm -f $(binaries)
+
+install:
+
+include ../Make.rules
diff --git a/v4l2-apps/test/ioctl-test.c b/v4l2-apps/test/ioctl-test.c
new file mode 100644
index 000000000..61659dc78
--- /dev/null
+++ b/v4l2-apps/test/ioctl-test.c
@@ -0,0 +1,223 @@
+/*
+ v4l-ioctl-test - This small utility sends dumb v4l2 ioctl to a device.
+ It is meant to check ioctl debug messages generated and to check
+ if a function is implemented by that device.
+ flag INTERNAL will send v4l internal messages, defined at v4l2-common.h
+ and v4l_decoder.h. These messages shouldn't be handled by video
+ driver itself, but for internal video and/or audio decoders.
+
+ Copyright (C) 2005 Mauro Carvalho Chehab <mchehab@infradead.org>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * Internal ioctl doesn't work anymore, due to the changes at
+ * v4l2-dev.h.
+ */
+//#define INTERNAL 1 /* meant for testing ioctl debug msgs */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include "linux/videodev.h"
+
+#ifdef INTERNAL
+typedef __u8 u8;
+typedef __u32 u32;
+#include <linux/version.h>
+#include "../linux/include/media/v4l2-common.h"
+#include <linux/video_decoder.h>
+#else
+typedef u_int32_t u32;
+#endif
+
+/* All possible parameters used on v4l ioctls */
+union v4l_parms {
+ int i;
+ unsigned long l;
+ u32 u_32;
+
+ /* V4L1 structs */
+ struct vbi_format p_vbi_format;
+ struct video_audio p_video_audio;
+ struct video_buffer p_video_buffer;
+ struct video_capability p_video_capability;
+ struct video_capture p_video_capture;
+ struct video_channel p_video_channel;
+ struct video_code p_video_code;
+ struct video_info p_video_info;
+ struct video_key p_video_key;
+ struct video_mbuf p_video_mbuf;
+ struct video_mmap p_video_mmap;
+ struct video_picture p_video_picture;
+ struct video_play_mode p_video_play_mode;
+ struct video_tuner p_video_tuner;
+ struct video_unit p_video_unit;
+ struct video_window p_video_window;
+
+ /* V4L2 structs */
+ struct v4l2_audioout p_v4l2_audioout;
+ struct v4l2_audio p_v4l2_audio;
+ struct v4l2_buffer p_v4l2_buffer;
+ struct v4l2_control p_v4l2_control;
+ struct v4l2_cropcap p_v4l2_cropcap;
+ struct v4l2_crop p_v4l2_crop;
+ struct v4l2_fmtdesc p_v4l2_fmtdesc;
+ struct v4l2_format p_v4l2_format;
+ struct v4l2_frequency p_v4l2_frequency;
+ struct v4l2_input p_v4l2_input;
+ struct v4l2_modulator p_v4l2_modulator;
+ struct v4l2_output p_v4l2_output;
+ struct v4l2_queryctrl p_v4l2_queryctrl;
+ struct v4l2_querymenu p_v4l2_querymenu;
+ struct v4l2_requestbuffers p_v4l2_requestbuffers;
+ struct v4l2_standard p_v4l2_standard;
+ struct v4l2_streamparm p_v4l2_streamparm;
+ struct v4l2_tuner p_v4l2_tuner;
+
+#ifdef INTERNAL
+ /* Decoder structs */
+
+ struct video_decoder_capability p_video_decoder_capability;
+ struct video_decoder_init p_video_decoder_init;
+
+ /* Internal V4L2 structs */
+ struct v4l2_register p_v4l2_register;
+ struct v4l2_sliced_vbi_data p_v4l2_sliced_vbi_data;
+#endif
+};
+
+/* All defined ioctls */
+int ioctls[] = {
+ /* V4L ioctls */
+
+ VIDIOCCAPTURE,/* int */
+ VIDIOCGAUDIO,/* struct video_audio */
+ VIDIOCGCAP,/* struct video_capability */
+ VIDIOCGCAPTURE,/* struct video_capture */
+ VIDIOCGCHAN,/* struct video_channel */
+ VIDIOCGFBUF,/* struct video_buffer */
+ VIDIOCGFREQ,/* unsigned long */
+ VIDIOCGMBUF,/* struct video_mbuf */
+ VIDIOCGPICT,/* struct video_picture */
+ VIDIOCGPLAYINFO,/* struct video_info */
+ VIDIOCGTUNER,/* struct video_tuner */
+ VIDIOCGUNIT,/* struct video_unit */
+ VIDIOCGVBIFMT,/* struct vbi_format */
+ VIDIOCGWIN,/* struct video_window */
+ VIDIOCKEY,/* struct video_key */
+ VIDIOCMCAPTURE,/* struct video_mmap */
+ VIDIOCSAUDIO,/* struct video_audio */
+ VIDIOCSCAPTURE,/* struct video_capture */
+ VIDIOCSCHAN,/* struct video_channel */
+ VIDIOCSFBUF,/* struct video_buffer */
+ VIDIOCSFREQ,/* unsigned long */
+ VIDIOCSMICROCODE,/* struct video_code */
+ VIDIOCSPICT,/* struct video_picture */
+ VIDIOCSPLAYMODE,/* struct video_play_mode */
+ VIDIOCSTUNER,/* struct video_tuner */
+ VIDIOCSVBIFMT,/* struct vbi_format */
+ VIDIOCSWIN,/* struct video_window */
+ VIDIOCSWRITEMODE,/* int */
+ VIDIOCSYNC,/* int */
+
+ /* V4L2 ioctls */
+
+ VIDIOC_CROPCAP,/* struct v4l2_cropcap */
+ VIDIOC_DQBUF,/* struct v4l2_buffer */
+ VIDIOC_ENUMAUDIO,/* struct v4l2_audio */
+ VIDIOC_ENUMAUDOUT,/* struct v4l2_audioout */
+ VIDIOC_ENUM_FMT,/* struct v4l2_fmtdesc */
+ VIDIOC_ENUMINPUT,/* struct v4l2_input */
+ VIDIOC_ENUMOUTPUT,/* struct v4l2_output */
+ VIDIOC_ENUMSTD,/* struct v4l2_standard */
+// VIDIOC_G_AUDIO_OLD,/* struct v4l2_audio */
+// VIDIOC_G_AUDOUT_OLD,/* struct v4l2_audioout */
+ VIDIOC_G_CROP,/* struct v4l2_crop */
+ VIDIOC_G_CTRL,/* struct v4l2_control */
+ VIDIOC_G_FMT,/* struct v4l2_format */
+ VIDIOC_G_FREQUENCY,/* struct v4l2_frequency */
+ VIDIOC_G_MODULATOR,/* struct v4l2_modulator */
+ VIDIOC_G_PARM,/* struct v4l2_streamparm */
+ VIDIOC_G_TUNER,/* struct v4l2_tuner */
+// VIDIOC_OVERLAY_OLD,/* int */
+ VIDIOC_QBUF,/* struct v4l2_buffer */
+ VIDIOC_QUERYBUF,/* struct v4l2_buffer */
+ VIDIOC_QUERYCTRL,/* struct v4l2_queryctrl */
+ VIDIOC_QUERYMENU,/* struct v4l2_querymenu */
+ VIDIOC_REQBUFS,/* struct v4l2_requestbuffers */
+ VIDIOC_S_CTRL,/* struct v4l2_control */
+ VIDIOC_S_FMT,/* struct v4l2_format */
+ VIDIOC_S_INPUT,/* int */
+ VIDIOC_S_OUTPUT,/* int */
+ VIDIOC_S_PARM,/* struct v4l2_streamparm */
+ VIDIOC_TRY_FMT,/* struct v4l2_format */
+
+#ifdef INTERNAL
+ /* V4L2 internal ioctls */
+ AUDC_SET_RADIO,/* no args */
+ TDA9887_SET_CONFIG,/* int */
+ TUNER_SET_STANDBY,/* int */
+ TUNER_SET_TYPE_ADDR,/* int */
+
+ VIDIOC_INT_AUDIO_CLOCK_FREQ,/* u32 */
+ VIDIOC_INT_G_CHIP_IDENT,/* enum v4l2_chip_ident * */
+ VIDIOC_INT_I2S_CLOCK_FREQ,/* u32 */
+ VIDIOC_INT_S_REGISTER,/* struct v4l2_register */
+ VIDIOC_INT_S_VBI_DATA,/* struct v4l2_sliced_vbi_data */
+
+ /* Decoder ioctls */
+ DECODER_ENABLE_OUTPUT,/* int */
+ DECODER_GET_CAPABILITIES,/* struct video_decoder_capability */
+ DECODER_GET_STATUS,/* int */
+ DECODER_INIT,/* struct video_decoder_init */
+ DECODER_SET_GPIO,/* int */
+ DECODER_SET_INPUT,/* int */
+ DECODER_SET_NORM,/* int */
+ DECODER_SET_OUTPUT,/* int */
+ DECODER_SET_PICTURE,/* struct video_picture */
+ DECODER_SET_VBI_BYPASS,/* int */
+#endif
+};
+#define S_IOCTLS sizeof(ioctls)/sizeof(ioctls[0])
+
+/********************************************************************/
+int main (void)
+{
+ int fd=0, ret=0;
+ unsigned i;
+ char *device="/dev/video0";
+ union v4l_parms p;
+
+ if ((fd = open(device, O_RDONLY)) < 0) {
+ perror("Couldn't open video0");
+ return(-1);
+ }
+
+ for (i=0;i<S_IOCTLS;i++) {
+ memset(&p,0,sizeof(p));
+ ret=ioctl(fd,ioctls[i], (void *) &p);
+ printf("%i: ioctl=0x%08x, return=%d\n",i, ioctls[i], ret);
+ }
+
+ close (fd);
+
+ return (0);
+}
diff --git a/v4l2-apps/test/sliced-vbi-detect.c b/v4l2-apps/test/sliced-vbi-detect.c
new file mode 100644
index 000000000..f6d8da01f
--- /dev/null
+++ b/v4l2-apps/test/sliced-vbi-detect.c
@@ -0,0 +1,144 @@
+/*
+ Sliced vbi autodetection demonstration utility
+ Copyright (C) 2004 Hans Verkuil <hverkuil@xs4all.nl>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* This simple utility detects which VBI types are transmitted on
+ each field/line. It serves both as example source and as a tool to
+ test the sliced VBI implementation.
+
+ Usage: sliced-vbi-detect [device]
+ Without a device name as argument it will fallback to /dev/vbi0.
+ */
+
+#include <unistd.h>
+#include <features.h> /* Uses _GNU_SOURCE to define getsubopt in stdlib.h */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <math.h>
+
+#include <linux/videodev2.h>
+
+static void detect(int fh, struct v4l2_sliced_vbi_format *fmt)
+{
+ struct v4l2_sliced_vbi_data *buf = malloc(fmt->io_size);
+ int cnt;
+
+ for (cnt = 0; cnt < 5; cnt++) {
+ int size = read(fh, buf, fmt->io_size);
+ unsigned i;
+
+ if (size <= 0) {
+ printf("size = %d\n", size);
+ break;
+ }
+ if (cnt == 0)
+ continue;
+ for (i = 0; i < size / sizeof(*buf); i++) {
+ int field, line;
+
+ line = buf[i].line;
+ field = buf[i].field;
+ if (buf[i].id == 0)
+ continue;
+ if (line < 0 || line >= 24) {
+ printf("line %d out of range\n", line);
+ free(buf);
+ return;
+ }
+ fmt->service_lines[field][line] |= buf[i].id;
+ }
+ }
+ free(buf);
+}
+
+void v2s(int id)
+{
+ switch (id) {
+ case V4L2_SLICED_TELETEXT_B: printf(" TELETEXT"); break;
+ case V4L2_SLICED_CAPTION_525: printf(" CC"); break;
+ case V4L2_SLICED_WSS_625: printf(" WSS"); break;
+ case V4L2_SLICED_VPS: printf(" VPS"); break;
+ default: printf(" UNKNOWN %x", id); break;
+ }
+}
+
+int main(int argc, char **argv)
+{
+ char *device = "/dev/vbi0";
+ struct v4l2_format vbifmt;
+ struct v4l2_sliced_vbi_format vbiresult;
+ int fh;
+ int f, i, b;
+
+ if (argc == 2)
+ device = argv[1];
+ fh = open(device, O_RDONLY);
+
+ if (fh == -1) {
+ fprintf(stderr, "cannot open %s\n", device);
+ return 1;
+ }
+ memset(&vbiresult, 0, sizeof(vbiresult));
+ for (i = 0; i < 16; i++) {
+ int l;
+ int set = 0;
+
+ memset(&vbifmt, 0, sizeof(vbifmt));
+ vbifmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
+ for (l = 0; l < 24; l++) {
+ vbifmt.fmt.sliced.service_lines[0][l] = 1 << i;
+ vbifmt.fmt.sliced.service_lines[1][l] = 1 << i;
+ }
+ if (ioctl(fh, VIDIOC_S_FMT, &vbifmt) < 0) {
+ if (errno == EINVAL)
+ continue;
+ perror("IVTV_IOC_S_VBI_FMT");
+ exit(-1);
+ }
+ vbiresult.io_size = vbifmt.fmt.sliced.io_size;
+ for (l = 0; l < 24; l++) {
+ set |= vbifmt.fmt.sliced.service_lines[0][l] |
+ vbifmt.fmt.sliced.service_lines[1][l];
+ }
+ detect(fh, &vbiresult);
+ }
+ close(fh);
+ for (f = 0; f < 2; f++) {
+ printf("Field %d:\n", f);
+ for (i = 6; i < 24; i++) {
+ unsigned set = vbiresult.service_lines[f][i];
+
+ printf(" Line %2d:", i);
+ for (b = 0; b < 16; b++) {
+ if (set & (1 << b))
+ v2s(1 << b);
+ }
+ printf("\n");
+ }
+ }
+ return 0;
+}
diff --git a/v4l2-apps/test/sliced-vbi-test.c b/v4l2-apps/test/sliced-vbi-test.c
new file mode 100644
index 000000000..c8877de30
--- /dev/null
+++ b/v4l2-apps/test/sliced-vbi-test.c
@@ -0,0 +1,469 @@
+/*
+ Sliced vbi demonstration utility
+ Copyright (C) 2004 Hans Verkuil <hverkuil@xs4all.nl>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* This test tool is used to test the sliced VBI implementation. It reads
+ from /dev/vbi0 by default (or the device name that is specified as the
+ first argument) and shows which packets arrive and what the contents
+ is. It also serves as example code on how to use the sliced VBI API.
+ */
+
+#include <unistd.h>
+#include <features.h> /* Uses _GNU_SOURCE to define getsubopt in stdlib.h */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <math.h>
+
+#include <linux/videodev2.h>
+
+#define printable(c) ((((c) & 0x7F) < 0x20 || ((c) & 0x7F) > 0x7E) ? '.' : ((c) & 0x7F))
+
+int valid_char(char c);
+
+int valid_char(char c)
+{
+ /* Invalid Character */
+ if (((c) & 0x7F) < 0x20 || ((c) & 0x7F) > 0x7E)
+ return 0;
+ else /* Valid Character */
+ return 1;
+}
+
+int frames = 0;
+int lines = 0;
+int space_needed = 0;
+int text_off = 0;
+
+static const char *formats[] = {
+ "Full format 4:3, 576 lines",
+ "Letterbox 14:9 centre, 504 lines",
+ "Letterbox 14:9 top, 504 lines",
+ "Letterbox 16:9 centre, 430 lines",
+ "Letterbox 16:9 top, 430 lines",
+ "Letterbox > 16:9 centre",
+ "Full format 14:9 centre, 576 lines",
+ "Anamorphic 16:9, 576 lines"
+};
+static const char *subtitles[] = {
+ "none",
+ "in active image area",
+ "out of active image area",
+ "?"
+};
+
+void decode_wss(struct v4l2_sliced_vbi_data *s)
+{
+ unsigned char parity;
+ int wss;
+
+ wss = s->data[0] | (s->data[1] << 8);
+
+ parity = wss & 15;
+ parity ^= parity >> 2;
+ parity ^= parity >> 1;
+
+ if (!(parity & 1))
+ return;
+
+ printf("WSS: %s; %s mode; %s color coding;\n"
+ " %s helper; reserved b7=%d; %s\n"
+ " open subtitles: %s; %scopyright %s; copying %s\n",
+ formats[wss & 7],
+ (wss & 0x10) ? "film" : "camera",
+ (wss & 0x20) ? "MA/CP" : "standard",
+ (wss & 0x40) ? "modulated" : "no",
+ !!(wss & 0x80),
+ (wss & 0x0100) ? "have TTX subtitles; " : "",
+ subtitles[(wss >> 9) & 3],
+ (wss & 0x0800) ? "surround sound; " : "",
+ (wss & 0x1000) ? "asserted" : "unknown",
+ (wss & 0x2000) ? "restricted" : "not restricted");
+}
+
+static int odd_parity(uint8_t c)
+{
+ c ^= (c >> 4);
+ c ^= (c >> 2);
+ c ^= (c >> 1);
+
+ return c & 1;
+}
+
+static void decode_xds(struct v4l2_sliced_vbi_data *s)
+{
+ char c;
+
+ //printf("XDS: %02x %02x: ", s->data[0], s->data[1]);
+ c = odd_parity(s->data[0]) ? s->data[0] & 0x7F : '?';
+ c = printable(c);
+ //putchar(c);
+ c = odd_parity(s->data[1]) ? s->data[1] & 0x7F : '?';
+ c = printable(c);
+ //putchar(c);
+ //putchar('\n');
+}
+
+#define CC_SIZE 64
+
+static void decode_cc(struct v4l2_sliced_vbi_data *s)
+{
+ static int xds_transport = 0;
+ char c = s->data[0] & 0x7F;
+ static char cc[CC_SIZE + 1];
+ static char cc_last[2 + 1] = { 0, 0 };
+ char cc_disp[CC_SIZE + 1];
+ static int cc_idx;
+
+ if (s->field) { /* field 2 */
+ /* 0x01xx..0x0Exx ASCII_or_NUL[0..32] 0x0Fchks */
+ if (odd_parity(s->data[0]) && (c >= 0x01 && c <= 0x0F)) {
+ decode_xds(s);
+ xds_transport = (c != 0x0F);
+ } else if (xds_transport) {
+ decode_xds(s);
+ }
+ return;
+ }
+
+ if (s->data[0] == 0x10 ||
+ s->data[0] == 0x13 ||
+ s->data[0] == 0x15 ||
+ s->data[0] == 0x16 ||
+ s->data[0] == 0x91 ||
+ s->data[0] == 0x92 ||
+ s->data[0] == 0x94 || s->data[0] == 0x97 || s->data[0] == 0x1c) {
+ if (text_off) {
+ if (s->data[0] == 0x94 &&
+ (s->data[1] == 0xad || s->data[1] == 0x25)) {
+ text_off = 0;
+ }
+ } else {
+ if (s->data[0] == 0x1c &&
+ (s->data[1] == 0x2a || s->data[1] == 0xab)) {
+ text_off = 1;
+ }
+ }
+ }
+
+ if (text_off == 0) {
+ c = odd_parity(s->data[0]) ? s->data[0] & 0x7F : '?';
+
+ if (cc_idx >= CC_SIZE) {
+ cc_idx = CC_SIZE - 2;
+ memcpy(cc, cc + 2, cc_idx);
+ }
+ cc[cc_idx++] = c;
+
+ c = odd_parity(s->data[1]) ? s->data[1] & 0x7F : '?';
+
+ cc[cc_idx++] = c;
+
+ cc[cc_idx] = 0;
+ }
+
+ if (cc_idx == CC_SIZE) {
+ int x = 0, y = 0;
+ int debug = 0;
+
+ memset(cc_disp, 0, CC_SIZE);
+
+ if (debug)
+ fprintf(stderr, "\n");
+ for (y = 0, x = 0; y < cc_idx;) {
+
+ /* Control Code or Valid Character */
+ if (valid_char(cc[y]) == 0) {
+ if (debug) {
+ if (cc[y] == 0x00)
+ fprintf(stderr, "()");
+ else
+ fprintf(stderr, "(0x%02x)",
+ cc[y]);
+ }
+
+ /* skip over control code */
+ if (cc[y] >= 0x11 && cc[y] <= 0x1f) {
+ if (debug) {
+ if (cc[y + 1] == 0x00)
+ fprintf(stderr, "()");
+ else
+ fprintf(stderr,
+ "(0x%02x)",
+ cc[y + 1]);
+ }
+
+ if (space_needed == 1) {
+ space_needed = 0;
+ cc_disp[x++] = ' ';
+ lines++;
+ } else if (cc[y] == 0x14
+ && cc[y + 1] == 0x14) {
+ space_needed = 0;
+ cc_disp[x++] = ' ';
+ lines++;
+ }
+
+ cc_last[0] = cc[y];
+ cc_last[1] = cc[y + 1];
+ y += 2;
+ } else {
+ cc_last[0] = cc_last[1];
+ cc_last[1] = cc[y];
+ y++;
+ }
+ } else {
+ if (debug)
+ fprintf(stderr, "(%c)", cc[y] & 0x7F);
+
+ /* Record character */
+ if ((cc[y] & 0x7F) == '\n') {
+ cc_disp[x] = ' ';
+ lines++;
+ } else if (cc_last[1] == 0x2B
+ && cc_last[0] == 0x14
+ && (cc[y] & 0x7F) == '@') {
+ /* Do Nothing */
+ cc_last[0] = cc_last[1];
+ cc_last[1] = cc[y];
+ y++;
+ continue;
+ } else if ((cc[y] & 0x7F) != '\n') {
+ cc_disp[x] = cc[y] & 0x7F;
+ lines++;
+ } else {
+ printf("\nOdd Character (%c)\n",
+ cc[y] & 0x7F);
+ }
+
+ space_needed = 1;
+ x++;
+ cc_last[0] = cc_last[1];
+ cc_last[1] = cc[y];
+ y++;
+ }
+
+ /* Insert CC_SIZE char Line Break */
+ if (lines >= CC_SIZE && cc_disp[x - 1] == ' ') {
+ cc_disp[x++] = '\n';
+ lines = 0;
+ space_needed = 0;
+ }
+ }
+ if (debug)
+ fprintf(stderr, "\n");
+ printf("%s", cc_disp);
+ memset(cc_disp, 0, CC_SIZE);
+ //memset(cc, 0, CC_SIZE);
+
+ cc_idx = 0;
+ }
+}
+
+const uint8_t vbi_bit_reverse[256] = {
+ 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+ 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+ 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+ 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+ 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+ 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+ 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+ 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+ 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+ 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+ 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+ 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+ 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+ 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+ 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+ 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+ 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+ 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+ 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+ 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+ 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+ 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+ 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+ 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+ 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+ 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+ 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+ 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+ 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+ 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+ 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+ 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
+};
+
+#define printable(c) ((((c) & 0x7F) < 0x20 || ((c) & 0x7F) > 0x7E) ? '.' : ((c) & 0x7F))
+
+#define PIL(day, mon, hour, min) \
+ (((day) << 15) + ((mon) << 11) + ((hour) << 6) + ((min) << 0))
+
+static void dump_pil(int pil)
+{
+ int day, mon, hour, min;
+
+ day = pil >> 15;
+ mon = (pil >> 11) & 0xF;
+ hour = (pil >> 6) & 0x1F;
+ min = pil & 0x3F;
+
+ if (pil == PIL(0, 15, 31, 63))
+ printf(" PDC: Timer-control (no PDC)\n");
+ else if (pil == PIL(0, 15, 30, 63))
+ printf(" PDC: Recording inhibit/terminate\n");
+ else if (pil == PIL(0, 15, 29, 63))
+ printf(" PDC: Interruption\n");
+ else if (pil == PIL(0, 15, 28, 63))
+ printf(" PDC: Continue\n");
+ else if (pil == PIL(31, 15, 31, 63))
+ printf(" PDC: No time\n");
+ else
+ printf(" PDC: %05x, 200X-%02d-%02d %02d:%02d\n",
+ pil, mon, day, hour, min);
+}
+
+void decode_vps(struct v4l2_sliced_vbi_data *s)
+{
+ static char pr_label[20];
+ static char label[20];
+ static int l = 0;
+ int cni, pcs, pty, pil;
+ int c;
+ unsigned char *buf = s->data;
+
+ c = vbi_bit_reverse[buf[1]];
+
+ if ((int8_t) c < 0) {
+ label[l] = 0;
+ memcpy(pr_label, label, sizeof(pr_label));
+ l = 0;
+ }
+
+ c &= 0x7F;
+
+ label[l] = printable(c);
+
+ l = (l + 1) % 16;
+
+ printf("VPS: 3-10: %02x %02x %02x %02x %02x %02x %02x %02x (\"%s\")\n",
+ buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
+ pr_label);
+
+ pcs = buf[2] >> 6;
+
+ cni = +((buf[10] & 3) << 10)
+ + ((buf[11] & 0xC0) << 2)
+ + ((buf[8] & 0xC0) << 0)
+ + (buf[11] & 0x3F);
+
+ pil = ((buf[8] & 0x3F) << 14) + (buf[9] << 6) + (buf[10] >> 2);
+
+ pty = buf[12];
+
+ printf(" CNI: %04x PCS: %d PTY: %d ", cni, pcs, pty);
+
+ dump_pil(pil);
+}
+
+void process(struct v4l2_sliced_vbi_data *s)
+{
+ if (s->id == 0)
+ return;
+
+ //printf("%04d: line %02u field %d type %x\n", frames, s->line, s->field, s->id);
+ switch (s->id) {
+ case V4L2_SLICED_TELETEXT_B:
+ printf("teletext\n");
+ break;
+ case V4L2_SLICED_VPS:
+ if (s->line != 16 || s->field)
+ break;
+ decode_vps(s);
+ break;
+ case V4L2_SLICED_WSS_625:
+ if (s->line != 23 || s->field)
+ break;
+ decode_wss(s);
+ break;
+ case V4L2_SLICED_CAPTION_525:
+ if (s->line != 21)
+ break;
+ decode_cc(s);
+ break;
+ default:
+ printf("unknown\n");
+ break;
+ }
+}
+
+int main(int argc, char **argv)
+{
+ char *device = "/dev/vbi0";
+ struct v4l2_format fmt;
+ v4l2_std_id std;
+ struct v4l2_sliced_vbi_data *buf;
+ int fh;
+
+ if (argc == 2)
+ device = argv[1];
+ fh = open(device, O_RDONLY);
+
+ if (fh == -1) {
+ fprintf(stderr, "cannot open %s\n", device);
+ return 1;
+ }
+
+ setbuf(stdout, NULL);
+
+ ioctl(fh, VIDIOC_G_STD, &std);
+ fmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
+ fmt.fmt.sliced.service_set = (std & V4L2_STD_NTSC) ? V4L2_SLICED_VBI_525 : V4L2_SLICED_VBI_625;
+ fmt.fmt.sliced.reserved[0] = 0;
+ fmt.fmt.sliced.reserved[1] = 0;
+ if (ioctl(fh, VIDIOC_S_FMT, &fmt) < 0) {
+ perror("vbi");
+ close(fh);
+ return 1;
+ }
+
+ fprintf(stderr, "%08x, %d\n", fmt.fmt.sliced.service_set, fmt.fmt.sliced.io_size);
+ buf = malloc(fmt.fmt.sliced.io_size);
+ for (;;) {
+ int size = read(fh, buf, fmt.fmt.sliced.io_size);
+ unsigned i;
+
+ if (size <= 0)
+ break;
+ frames++;
+ for (i = 0; i < size / sizeof(struct v4l2_sliced_vbi_data); i++) {
+ process(&buf[i]);
+ }
+ }
+ close(fh);
+ return 0;
+}
diff --git a/v4l2-apps/test/v4lgrab.c b/v4l2-apps/test/v4lgrab.c
new file mode 100644
index 000000000..c8d433c1d
--- /dev/null
+++ b/v4l2-apps/test/v4lgrab.c
@@ -0,0 +1,194 @@
+/* Simple Video4Linux image grabber. */
+/*
+ * Video4Linux Driver Test/Example Framegrabbing Program
+ *
+ * Compile with:
+ * gcc -s -Wall -Wstrict-prototypes v4lgrab.c -o v4lgrab
+ * Use as:
+ * v4lgrab >image.ppm
+ *
+ * Copyright (C) 1998-05-03, Phil Blundell <philb@gnu.org>
+ * Copied from http://www.tazenda.demon.co.uk/phil/vgrabber.c
+ * with minor modifications (Dave Forrest, drf5n@virginia.edu).
+ *
+ */
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <stdlib.h>
+
+#include <linux/types.h>
+#include <linux/videodev.h>
+
+#define FILE "/dev/video0"
+
+/* Stole this from tvset.c */
+
+#define READ_VIDEO_PIXEL(buf, format, depth, r, g, b) \
+{ \
+ switch (format) \
+ { \
+ case VIDEO_PALETTE_GREY: \
+ switch (depth) \
+ { \
+ case 4: \
+ case 6: \
+ case 8: \
+ (r) = (g) = (b) = (*buf++ << 8);\
+ break; \
+ \
+ case 16: \
+ (r) = (g) = (b) = \
+ *((unsigned short *) buf); \
+ buf += 2; \
+ break; \
+ } \
+ break; \
+ \
+ \
+ case VIDEO_PALETTE_RGB565: \
+ { \
+ unsigned short tmp = *(unsigned short *)buf; \
+ (r) = tmp&0xF800; \
+ (g) = (tmp<<5)&0xFC00; \
+ (b) = (tmp<<11)&0xF800; \
+ buf += 2; \
+ } \
+ break; \
+ \
+ case VIDEO_PALETTE_RGB555: \
+ (r) = (buf[0]&0xF8)<<8; \
+ (g) = ((buf[0] << 5 | buf[1] >> 3)&0xF8)<<8; \
+ (b) = ((buf[1] << 2 ) & 0xF8)<<8; \
+ buf += 2; \
+ break; \
+ \
+ case VIDEO_PALETTE_RGB24: \
+ (r) = buf[0] << 8; (g) = buf[1] << 8; \
+ (b) = buf[2] << 8; \
+ buf += 3; \
+ break; \
+ \
+ default: \
+ fprintf(stderr, \
+ "Format %d not yet supported\n", \
+ format); \
+ } \
+}
+
+int get_brightness_adj(unsigned char *image, long size, int *brightness)
+{
+ long i, tot = 0;
+ for (i=0;i<size*3;i++)
+ tot += image[i];
+ *brightness = (128 - tot/(size*3))/3;
+ return !((tot/(size*3)) >= 126 && (tot/(size*3)) <= 130);
+}
+
+int main(int argc, char **argv)
+{
+ int fd = open(FILE, O_RDONLY), f;
+ struct video_capability cap;
+ struct video_window win;
+ struct video_picture vpic;
+
+ unsigned char *buffer, *src;
+ int bpp = 24, r, g, b;
+ unsigned int i, src_depth;
+
+ if (fd < 0) {
+ perror(FILE);
+ exit(1);
+ }
+
+ if (ioctl(fd, VIDIOCGCAP, &cap) < 0) {
+ perror("VIDIOGCAP");
+ fprintf(stderr, "(" FILE " not a video4linux device?)\n");
+ close(fd);
+ exit(1);
+ }
+
+ if (ioctl(fd, VIDIOCGWIN, &win) < 0) {
+ perror("VIDIOCGWIN");
+ close(fd);
+ exit(1);
+ }
+
+ if (ioctl(fd, VIDIOCGPICT, &vpic) < 0) {
+ perror("VIDIOCGPICT");
+ close(fd);
+ exit(1);
+ }
+
+ if (cap.type & VID_TYPE_MONOCHROME) {
+ vpic.depth=8;
+ vpic.palette=VIDEO_PALETTE_GREY; /* 8bit grey */
+ if(ioctl(fd, VIDIOCSPICT, &vpic) < 0) {
+ vpic.depth=6;
+ if(ioctl(fd, VIDIOCSPICT, &vpic) < 0) {
+ vpic.depth=4;
+ if(ioctl(fd, VIDIOCSPICT, &vpic) < 0) {
+ fprintf(stderr, "Unable to find a supported capture format.\n");
+ close(fd);
+ exit(1);
+ }
+ }
+ }
+ }
+ else {
+ vpic.depth=24;
+ vpic.palette=VIDEO_PALETTE_RGB24;
+
+ if(ioctl(fd, VIDIOCSPICT, &vpic) < 0) {
+ vpic.palette=VIDEO_PALETTE_RGB565;
+ vpic.depth=16;
+
+ if(ioctl(fd, VIDIOCSPICT, &vpic)==-1) {
+ vpic.palette=VIDEO_PALETTE_RGB555;
+ vpic.depth=15;
+
+ if(ioctl(fd, VIDIOCSPICT, &vpic)==-1) {
+ fprintf(stderr, "Unable to find a supported capture format.\n");
+ return -1;
+ }
+ }
+ }
+ }
+
+ buffer = malloc(win.width * win.height * bpp);
+ if (!buffer) {
+ fprintf(stderr, "Out of memory.\n");
+ exit(1);
+ }
+
+ do {
+ int newbright;
+ read(fd, buffer, win.width * win.height * bpp);
+ f = get_brightness_adj(buffer, win.width * win.height, &newbright);
+ if (f) {
+ vpic.brightness += (newbright << 8);
+ if(ioctl(fd, VIDIOCSPICT, &vpic)==-1) {
+ perror("VIDIOSPICT");
+ break;
+ }
+ }
+ } while (f);
+
+ fprintf(stdout, "P6\n%d %d 255\n", win.width, win.height);
+
+ src = buffer;
+
+ for (i = 0; i < win.width * win.height; i++) {
+ READ_VIDEO_PIXEL(src, vpic.palette, src_depth, r, g, b);
+ fputc(r>>8, stdout);
+ fputc(g>>8, stdout);
+ fputc(b>>8, stdout);
+ }
+
+ close(fd);
+ return 0;
+}
diff --git a/v4l2-apps/test/vbi-test.c b/v4l2-apps/test/vbi-test.c
new file mode 100644
index 000000000..c1a141bff
--- /dev/null
+++ b/v4l2-apps/test/vbi-test.c
@@ -0,0 +1,89 @@
+/*
+ v4l-ioctl-test - This small utility checks VBI format
+
+ Copyright (C) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <linux/videodev.h>
+
+/* All possible parameters used on v4l ioctls */
+union v4l_parms {
+ /* V4L1 structs */
+ struct vbi_format v1;
+
+ /* V4L2 structs */
+ struct v4l2_format v2;
+};
+
+/* All defined ioctls */
+int ioctls[] = {
+ /* V4L ioctls */
+
+ VIDIOCGVBIFMT,/* struct vbi_format */
+
+ /* V4L2 ioctls */
+
+ VIDIOC_G_FMT,/* struct v4l2_format */
+};
+#define S_IOCTLS sizeof(ioctls)/sizeof(ioctls[0])
+
+/********************************************************************/
+int main (void)
+{
+ int fd=0, ret=0;
+ char *device="/dev/video0";
+ union v4l_parms p;
+
+ if ((fd = open(device, O_RDONLY)) < 0) {
+ perror("Couldn't open video0");
+ return(-1);
+ }
+
+
+ /* V4L1 call */
+ memset(&p,0,sizeof(p));
+ ret=ioctl(fd,VIDIOCGVBIFMT, (void *) &p);
+
+ printf ("V4L1 call: ret=%i: sampling_rate=%d, samples_per_line=%d, "
+ "sample_format=%d, start=%d/%d, count=%d/%d, flags=%d\n", ret,
+ p.v1.sampling_rate,p.v1.samples_per_line, p.v1.sample_format,
+ p.v1.start[0],p.v1.start[1],p.v1.count[0],p.v1.count[1],p.v1.flags);
+
+
+ /* V4L2 call */
+ memset(&p,0,sizeof(p));
+ p.v2.type=V4L2_BUF_TYPE_VBI_CAPTURE;
+ ret=ioctl(fd,VIDIOC_G_FMT, (void *) &p);
+
+ printf ("V4L2 call: ret=%i: sampling_rate=%d, samples_per_line=%d, "
+ "sample_format=%d, offset=%d, start=%d/%d, count=%d/%d\n", ret,
+ p.v2.fmt.vbi.sampling_rate,p.v2.fmt.vbi.samples_per_line,
+ p.v2.fmt.vbi.sample_format,p.v2.fmt.vbi.offset,
+ p.v2.fmt.vbi.start[0],p.v2.fmt.vbi.start[1],
+ p.v2.fmt.vbi.count[0],p.v2.fmt.vbi.count[1]);
+
+ close (fd);
+
+ return (0);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-05 01:36:55 +0000