cebix/mintv/mintv.cpp

/*
 *  mintv.cpp - 50/60Hz noninterlaced video display using v4l and XVideo
 *
 *  Written in 2003-2004 by Christian Bauer
 */

#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <errno.h>

#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include <linux/videodev.h>

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/StringDefs.h>
#include <X11/Intrinsic.h>
#include <X11/Shell.h>
#include <X11/cursorfont.h>
#include <X11/Xaw/Simple.h>
#include <X11/extensions/XShm.h>
#include <X11/extensions/Xv.h>
#include <X11/extensions/Xvlib.h>

static bool ntsc = false;

const int PAL_WIDTH = 384;
const int PAL_HEIGHT = 288;
const int NTSC_WIDTH = 360;
const int NTSC_HEIGHT = 240;

static int grab_width = -1, grab_height;
static int image_width, image_height;
static int win_width, win_height;

const double PAL_FPS = 50.0;
const double NTSC_FPS = 59.94;

static double fps;

static int brightness = 50, contrast = 50, color = 50;

static int channel = 1;

#define XV_FORMAT 0x32595559
#define BYTES_PER_PIXEL 2

#define DOUBLE_FRAME 1
#define LOGGING 0

#if LOGGING
static FILE *log;
#endif

static int port = -1;
static Display *dpy;
static GC gc;
static Atom wm;
static Widget app_shell, video;
static XShmSegmentInfo shminfo;
static XvImage *image[2];
static int fd = -1;

static void quit(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        XShmDetach(dpy, &shminfo);
        shmdt(shminfo.shmaddr);

        if (fd >= 0) {
                video_audio au;
                au.audio = 1;
                ioctl(fd, VIDIOCGAUDIO, &au);
                au.flags |= VIDEO_AUDIO_MUTE;
                ioctl(fd, VIDIOCSAUDIO, &au);
                close(fd);
        }

        exit(0);
}

static void set_bcc(void)
{
        video_picture pict;
        if (ioctl(fd, VIDIOCGPICT, &pict) < 0) {
                fprintf(stderr, "ioctl VIDIOCGPICT: %s\n", strerror(errno));
                exit(1);
        }
        pict.brightness = brightness * 65536 / 100;
        pict.contrast = contrast * 65536 / 100;
        pict.colour = color * 65536 / 100;
        if (ioctl(fd, VIDIOCSPICT, &pict) < 0) {
                fprintf(stderr, "ioctl VIDIOCSPICT: %s\n", strerror(errno));
                exit(1);
        }
}

static void inc_brightness(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        if (brightness < 100)
                brightness++;
        set_bcc();
}

static void dec_brightness(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        if (brightness > 0)
                brightness--;
        set_bcc();
}

static void reset_brightness(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        brightness = 50;
        set_bcc();
}

static void inc_contrast(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        if (contrast < 100)
                contrast++;
        set_bcc();
}

static void dec_contrast(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        if (contrast > 0)
                contrast--;
        set_bcc();
}

static void reset_contrast(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        contrast = 50;
        set_bcc();
}

static void inc_color(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        if (color < 100)
                color++;
        set_bcc();
}

static void dec_color(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        if (color > 0)
                color--;
        set_bcc();
}

static void reset_color(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        color = 50;
        set_bcc();
}

static void set_channel(void)
{
        video_channel chan;
        chan.channel = channel;
        if (ioctl(fd, VIDIOCGCHAN, &chan) < 0) {
                fprintf(stderr, "ioctl VIDIOCGCHAN: %s\n", strerror(errno));
                exit(1);
        }
        if (ntsc)
                chan.norm = VIDEO_MODE_NTSC;
        else
                chan.norm = VIDEO_MODE_PAL;
        if (ioctl(fd, VIDIOCSCHAN, &chan) < 0) {
                fprintf(stderr, "ioctl VIDIOCSCHAN: %s\n", strerror(errno));
                exit(1);
        }
}

static void select_channel_1(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        channel = 1;
        set_channel();
}

static void select_channel_2(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
        channel = 2;
        set_channel();
}

static XtActionsRec actionTable[] = {
        {"quit", quit},
        {"inc_brightness", inc_brightness},
        {"dec_brightness", dec_brightness},
        {"reset_brightness", reset_brightness},
        {"inc_contrast", inc_contrast},
        {"dec_contrast", dec_contrast},
        {"reset_contrast", reset_contrast},
        {"inc_color", inc_color},
        {"dec_color", dec_color},
        {"reset_color", reset_color},
        {"select_channel_1", select_channel_1},
        {"select_channel_2", select_channel_2}
};

static void resize_event(Widget widget, XtPointer client_data, XEvent *event, Boolean *d)
{
        if (event->type == ConfigureNotify) {
                win_width = event->xconfigure.width;
                win_height = event->xconfigure.height;
    }
}

static video_mbuf mbuf;
static void *buf = NULL;
static video_mmap mm[2];
static int bufnum = 0;

typedef long long int64;
typedef unsigned long long uint64;

uint64 GetTicks_usec(void)
{
        struct timeval t;
        gettimeofday(&t, NULL);
        return (uint64)t.tv_sec * 1000000 + t.tv_usec;
}

void Delay_usec(unsigned usec)
{
        int was_error;
        struct timeval tv;

        /* Set the timeout interval - Linux only needs to do this once */
        tv.tv_sec = 0;
        tv.tv_usec = usec;
        do {
                errno = 0;
                was_error = select(0, NULL, NULL, NULL, &tv);
        } while (was_error && (errno == EINTR));
}

uint64 frame_time = 0;

static Boolean work_proc(XtPointer client_data)
{
        ioctl(fd, VIDIOCMCAPTURE, &(mm[bufnum ^ 1]));
        ioctl(fd, VIDIOCSYNC, &bufnum);

        uint64 now = GetTicks_usec();
#if LOGGING
        fprintf(log, "frame_time: %Ld\n", now - frame_time);
#endif
        frame_time = now;

#if DOUBLE_FRAME
        char *src = (char *)buf + mbuf.offsets[bufnum];
        char *dst = image[0]->data;
        for (unsigned y=0; y<grab_height; y+=2) {
                memcpy(dst, src, grab_width * BYTES_PER_PIXEL);
                src += grab_width * BYTES_PER_PIXEL * 2;
                dst += grab_width * BYTES_PER_PIXEL;
        }

        uint64 prev = GetTicks_usec();

        XvShmPutImage(
                dpy, port, XtWindow(video), gc, image[0],
                0, 0, image_width, image_height,
                0, 0, win_width, win_height,
                False
        );

        src = (char *)buf + mbuf.offsets[bufnum] + grab_width * BYTES_PER_PIXEL;
        dst = image[1]->data;
        for (unsigned y=0; y<grab_height; y+=2) {
                memcpy(dst, src, grab_width * BYTES_PER_PIXEL);
                src += grab_width * BYTES_PER_PIXEL * 2;
                dst += grab_width * BYTES_PER_PIXEL;
        }

        XSync(dpy, False);

        now = GetTicks_usec();
        uint64 elapsed = now - prev;
        int64 delay = int64(1000000.0 / fps) - (now - prev);
#if LOGGING
        fprintf(log, "elapsed %Ld usec, delay %Ld usec\n", elapsed, delay);
#endif
        if (delay > 0)
                Delay_usec(delay);

        XvShmPutImage(
                dpy, port, XtWindow(video), gc, image[1],
                0, 0, image_width, image_height,
                0, 0, win_width, win_height,
                False
        );
        XSync(dpy, False);
#else
        memcpy(image[0]->data, (char *)buf + mbuf.offsets[bufnum], image[0]->data_size);

        XvShmPutImage(
                dpy, port, XtWindow(video), gc, image[0],
                0, 0, image_width, image_height,
                0, 0, win_width, win_height,
                False
        );
        XSync(dpy, False);
#endif

        bufnum ^= 1;

        return False;
}

int main(int argc, char **argv)
{
        static struct option long_opts[] = {
                {"help", 0, 0, 'h'},
                {"ntsc", 0, 0, 'n'},
                {"port", 1, 0, 'p'},
                {"width", 1, 0, 'w'},
                {NULL, 0, 0, 0}
        };

#if LOGGING
        log = fopen("log", "w");
#endif

        // Parse options
        for (;;) {
                int c;
                if ((c = getopt_long(argc, argv, "hnp:w:", long_opts, NULL)) == -1)
                        break;

                switch (c) {
                        case 0: /* Long option */
                                break;
                        case 'n':
                                ntsc = true;
                                break;
                        case 'p':
                                port = atoi(optarg);
                                break;
                        case 'w':
                                grab_width = atoi(optarg);
                                break;
                        case 'h':
                        default:
                                fprintf(stderr,
                                        "50/60Hz video display application\n\n"
                                        "Options:\n"
                                        "  -h | --help     this text\n"
                                        "  -n | --ntsc     NTSC mode\n"
                                        "  -p | --port n   Xv output port\n"
                                        "  -w | --width n  image width\n\n"
                                        "Keyboard commands:\n"
                                        "  q         quit\n"
                                        "  1/2       select channel\n"
                                        "  KP 7/4/1  adjust brightness\n"
                                        "  KP 8/5/2  adjust contrast\n"
                                        "  KP 9/6/3  adjust color\n"
                                );
                                exit(1);
                                break;
                }
        }

        // Init X11
        XtAppContext app_context;
        app_shell = XtAppInitialize(&app_context, "mintv", NULL, 0, &argc, argv, NULL,  NULL, 0);
        dpy = XtDisplay(app_shell);
        XtAppAddActions(app_context,actionTable, sizeof(actionTable) / sizeof(XtActionsRec));
        XtOverrideTranslations(app_shell, XtParseTranslationTable(
                "<Message>WM_PROTOCOLS: quit()\n"
                "<Key>q: quit()\n"
                "<Key>Escape: quit()\n"
                "<Key>1: select_channel_1()\n"
                "<Key>2: select_channel_2()\n"
                "<Key>KP_7: inc_brightness()\n"
                "<Key>KP_4: reset_brightness()\n"
                "<Key>KP_1: dec_brightness()\n"
                "<Key>KP_8: inc_contrast()\n"
                "<Key>KP_5: reset_contrast()\n"
                "<Key>KP_2: dec_contrast()\n"
                "<Key>KP_9: inc_color()\n"
                "<Key>KP_6: reset_color()\n"
                "<Key>KP_3: dec_color()"
        ));
        XtAddEventHandler(app_shell, StructureNotifyMask, True, resize_event, NULL);
        wm = XInternAtom(XtDisplay(app_shell), "WM_DELETE_WINDOW", False);

        // Xvideo available?
        unsigned ver, rel, req, ev, err, val;
        if (XvQueryExtension(dpy, &ver, &rel, &req, &ev, &err) != Success) {
                fprintf(stderr, "Server doesn't support Xvideo\n");
                exit(1);
        }

        // Yes, query available adaptors
        unsigned num_adaptors;
        XvAdaptorInfo *ai;
        if (XvQueryAdaptors(dpy, DefaultRootWindow(dpy), &num_adaptors, &ai) != Success) {
                fprintf(stderr, "XvQueryAdaptors failed\n");
                exit(1);
        }

        // Find usable port
        if (port < 0) {
                for (unsigned i=0; i<num_adaptors; i++) {
                        if (ai[i].type & XvImageMask) {
                                for (unsigned p=ai[i].base_id; p<ai[i].base_id+ai[i].num_ports; p++) {
                                        int num_formats;
                                        XvImageFormatValues *fo = XvListImageFormats(dpy, p, &num_formats);
                                        if (fo) {
                                                for (unsigned j=0; j<num_formats; j++) {
                                                        if (fo[j].id == XV_FORMAT) {
                                                                port = p;
                                                                goto port_found;
                                                        }
                                                }
                                                XFree(fo);
                                        }
                                }
                        }
                }
port_found:
                ;
        }
        if (port < 0) {
                fprintf(stderr, "No suitable XVideo port found\n");
                exit(1);
        } else
                printf("Using XVideo port %d\n", port);

        // Set grab and window dimensions
        if (ntsc) {
                if (grab_width == -1)
                        grab_width = NTSC_WIDTH;
                grab_height = NTSC_HEIGHT;
                fps = NTSC_FPS;
        } else {
                if (grab_width == -1)
                        grab_width = PAL_WIDTH;
                grab_height = PAL_HEIGHT;
                fps = PAL_FPS;
        }
        image_width = grab_width;
        image_height = grab_height;
        win_width = DisplayWidth(dpy, DefaultScreen(dpy));
        win_height = DisplayHeight(dpy, DefaultScreen(dpy));
#if DOUBLE_FRAME
        grab_height *= 2;
#endif

        // Open window
        video = XtVaCreateManagedWidget("video", simpleWidgetClass, app_shell,
                XtNwidth, win_width,
                XtNheight, win_height,
                NULL
        );
        XtRealizeWidget(app_shell);
        XtVaSetValues(app_shell,
                XtNtitle, "mintv",
                XtNinput, True,
                NULL
        );
        XSetWMProtocols(dpy, XtWindow(app_shell), &wm, 1);
        gc = XCreateGC(dpy, XtWindow(video), 0, NULL);

        // Hide cursor
        Colormap cmap = DefaultColormap(dpy, DefaultScreen(dpy));
        XColor black;
        XParseColor(dpy, cmap, "#000000", &black);
        XAllocColor(dpy, cmap, &black);
        static char null_data[] = {0, 0, 0, 0, 0, 0, 0, 0};
        Pixmap null_pixmap = XCreateBitmapFromData(dpy, XtWindow(video), null_data, 8, 8);
        Cursor null_cursor = XCreatePixmapCursor(dpy, null_pixmap, null_pixmap, &black, &black, 0, 0);
        XDefineCursor(dpy, XtWindow(video), null_cursor);

        // Set image format
        unsigned format = XV_FORMAT;

        // Create image
        image[0] = XvShmCreateImage(dpy, port, format, NULL, image_width, image_height, &shminfo);
        image[1] = XvShmCreateImage(dpy, port, format, NULL, image_width, image_height, &shminfo);
        shminfo.shmid = shmget(IPC_PRIVATE, image[0]->data_size * 2, IPC_CREAT | 0777);
        shminfo.shmaddr = (char *)shmat(shminfo.shmid, NULL, 0);
        shminfo.readOnly = False;
        image[0]->data = shminfo.shmaddr;
        image[1]->data = shminfo.shmaddr + image[0]->data_size;
        XShmAttach(dpy, &shminfo);
        XSync(dpy, False);
        shmctl(shminfo.shmid, IPC_RMID, 0);
        memset(image[0]->data, 0x80, image[0]->data_size * 2);

        // Open frame grabber device
        fd = open("/dev/video0", O_RDWR);
        if (fd < 0) {
                fprintf(stderr, "Can't open /dev/video0: %s\n", strerror(errno));
                exit(1);
        }

        // Set channel
        set_channel();

        video_audio au;
        au.audio = 1;
        if (ioctl(fd, VIDIOCGAUDIO, &au) < 0) {
                fprintf(stderr, "ioctl VIDIOCGAUDIO: %s\n", strerror(errno));
                exit(1);
        }
        au.flags &= ~VIDEO_AUDIO_MUTE;
        if (ioctl(fd, VIDIOCSAUDIO, &au) < 0) {
                fprintf(stderr, "ioctl VIDIOCSAUDIO: %s\n", strerror(errno));
                exit(1);
        }

        // Configure frame grabber
        set_bcc();

        if (ioctl(fd, VIDIOCGMBUF, &mbuf) < 0) {
                fprintf(stderr, "ioctl VIDIOCGMBUF: %s\n", strerror(errno));
                exit(1);
        }

        buf = mmap(NULL, mbuf.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if (buf == NULL) {
                fprintf(stderr, "mmap failed: %s\n", strerror(errno));
                exit(1);
        }

        mm[0].frame = 0;
        mm[0].width = grab_width;
        mm[0].height = grab_height;
        mm[0].format = VIDEO_PALETTE_YUV422;
        mm[1].frame = 1;
        mm[1].width = grab_width;
        mm[1].height = grab_height;
        mm[1].format = VIDEO_PALETTE_YUV422;
        ioctl(fd, VIDIOCMCAPTURE, &(mm[bufnum]));

        // Disable screen saver
        XSetScreenSaver(dpy, 0, 0, DefaultBlanking, DefaultExposures);

        // Main loop
        XtAppAddWorkProc(app_context, work_proc, NULL);
        XtAppMainLoop(app_context);

        return 0;
}
Revision:	1.8
Committed:	2005-10-02T11:57:30Z (19 years, 1 month ago) by cebix
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.7:	+3 -3 lines
Log Message:	stylistic fixes
#	Content
1	/*
2	* mintv.cpp - 50/60Hz noninterlaced video display using v4l and XVideo
3	*
4	* Written in 2003-2004 by Christian Bauer
5	*/
6
7	#include <stdio.h>
8	#include <stdlib.h>
9	#include <getopt.h>
10	#include <errno.h>
11
12	#include <unistd.h>
13	#include <fcntl.h>
14	#include <sys/time.h>
15	#include <sys/ioctl.h>
16	#include <sys/mman.h>
17	#include <sys/shm.h>
18	#include <linux/videodev.h>
19
20	#include <X11/Xlib.h>
21	#include <X11/Xutil.h>
22	#include <X11/StringDefs.h>
23	#include <X11/Intrinsic.h>
24	#include <X11/Shell.h>
25	#include <X11/cursorfont.h>
26	#include <X11/Xaw/Simple.h>
27	#include <X11/extensions/XShm.h>
28	#include <X11/extensions/Xv.h>
29	#include <X11/extensions/Xvlib.h>
30
31	static bool ntsc = false;
32
33	const int PAL_WIDTH = 384;
34	const int PAL_HEIGHT = 288;
35	const int NTSC_WIDTH = 360;
36	const int NTSC_HEIGHT = 240;
37
38	static int grab_width = -1, grab_height;
39	static int image_width, image_height;
40	static int win_width, win_height;
41
42	const double PAL_FPS = 50.0;
43	const double NTSC_FPS = 59.94;
44
45	static double fps;
46
47	static int brightness = 50, contrast = 50, color = 50;
48
49	static int channel = 1;
50
51	#define XV_FORMAT 0x32595559
52	#define BYTES_PER_PIXEL 2
53
54	#define DOUBLE_FRAME 1
55	#define LOGGING 0
56
57	#if LOGGING
58	static FILE *log;
59	#endif
60
61	static int port = -1;
62	static Display *dpy;
63	static GC gc;
64	static Atom wm;
65	static Widget app_shell, video;
66	static XShmSegmentInfo shminfo;
67	static XvImage *image[2];
68	static int fd = -1;
69
70	static void quit(Widget widget, XEvent event, String params, Cardinal *num_params)
71	{
72	XShmDetach(dpy, &shminfo);
73	shmdt(shminfo.shmaddr);
74
75	if (fd >= 0) {
76	video_audio au;
77	au.audio = 1;
78	ioctl(fd, VIDIOCGAUDIO, &au);
79	au.flags \|= VIDEO_AUDIO_MUTE;
80	ioctl(fd, VIDIOCSAUDIO, &au);
81	close(fd);
82	}
83
84	exit(0);
85	}
86
87	static void set_bcc(void)
88	{
89	video_picture pict;
90	if (ioctl(fd, VIDIOCGPICT, &pict) < 0) {
91	fprintf(stderr, "ioctl VIDIOCGPICT: %s\n", strerror(errno));
92	exit(1);
93	}
94	pict.brightness = brightness * 65536 / 100;
95	pict.contrast = contrast * 65536 / 100;
96	pict.colour = color * 65536 / 100;
97	if (ioctl(fd, VIDIOCSPICT, &pict) < 0) {
98	fprintf(stderr, "ioctl VIDIOCSPICT: %s\n", strerror(errno));
99	exit(1);
100	}
101	}
102
103	static void inc_brightness(Widget widget, XEvent event, String params, Cardinal *num_params)
104	{
105	if (brightness < 100)
106	brightness++;
107	set_bcc();
108	}
109
110	static void dec_brightness(Widget widget, XEvent event, String params, Cardinal *num_params)
111	{
112	if (brightness > 0)
113	brightness--;
114	set_bcc();
115	}
116
117	static void reset_brightness(Widget widget, XEvent event, String params, Cardinal *num_params)
118	{
119	brightness = 50;
120	set_bcc();
121	}
122
123	static void inc_contrast(Widget widget, XEvent event, String params, Cardinal *num_params)
124	{
125	if (contrast < 100)
126	contrast++;
127	set_bcc();
128	}
129
130	static void dec_contrast(Widget widget, XEvent event, String params, Cardinal *num_params)
131	{
132	if (contrast > 0)
133	contrast--;
134	set_bcc();
135	}
136
137	static void reset_contrast(Widget widget, XEvent event, String params, Cardinal *num_params)
138	{
139	contrast = 50;
140	set_bcc();
141	}
142
143	static void inc_color(Widget widget, XEvent event, String params, Cardinal *num_params)
144	{
145	if (color < 100)
146	color++;
147	set_bcc();
148	}
149
150	static void dec_color(Widget widget, XEvent event, String params, Cardinal *num_params)
151	{
152	if (color > 0)
153	color--;
154	set_bcc();
155	}
156
157	static void reset_color(Widget widget, XEvent event, String params, Cardinal *num_params)
158	{
159	color = 50;
160	set_bcc();
161	}
162
163	static void set_channel(void)
164	{
165	video_channel chan;
166	chan.channel = channel;
167	if (ioctl(fd, VIDIOCGCHAN, &chan) < 0) {
168	fprintf(stderr, "ioctl VIDIOCGCHAN: %s\n", strerror(errno));
169	exit(1);
170	}
171	if (ntsc)
172	chan.norm = VIDEO_MODE_NTSC;
173	else
174	chan.norm = VIDEO_MODE_PAL;
175	if (ioctl(fd, VIDIOCSCHAN, &chan) < 0) {
176	fprintf(stderr, "ioctl VIDIOCSCHAN: %s\n", strerror(errno));
177	exit(1);
178	}
179	}
180
181	static void select_channel_1(Widget widget, XEvent event, String params, Cardinal *num_params)
182	{
183	channel = 1;
184	set_channel();
185	}
186
187	static void select_channel_2(Widget widget, XEvent event, String params, Cardinal *num_params)
188	{
189	channel = 2;
190	set_channel();
191	}
192
193	static XtActionsRec actionTable[] = {
194	{"quit", quit},
195	{"inc_brightness", inc_brightness},
196	{"dec_brightness", dec_brightness},
197	{"reset_brightness", reset_brightness},
198	{"inc_contrast", inc_contrast},
199	{"dec_contrast", dec_contrast},
200	{"reset_contrast", reset_contrast},
201	{"inc_color", inc_color},
202	{"dec_color", dec_color},
203	{"reset_color", reset_color},
204	{"select_channel_1", select_channel_1},
205	{"select_channel_2", select_channel_2}
206	};
207
208	static void resize_event(Widget widget, XtPointer client_data, XEvent event, Boolean d)
209	{
210	if (event->type == ConfigureNotify) {
211	win_width = event->xconfigure.width;
212	win_height = event->xconfigure.height;
213	}
214	}
215
216	static video_mbuf mbuf;
217	static void *buf = NULL;
218	static video_mmap mm[2];
219	static int bufnum = 0;
220
221	typedef long long int64;
222	typedef unsigned long long uint64;
223
224	uint64 GetTicks_usec(void)
225	{
226	struct timeval t;
227	gettimeofday(&t, NULL);
228	return (uint64)t.tv_sec * 1000000 + t.tv_usec;
229	}
230
231	void Delay_usec(unsigned usec)
232	{
233	int was_error;
234	struct timeval tv;
235
236	/* Set the timeout interval - Linux only needs to do this once */
237	tv.tv_sec = 0;
238	tv.tv_usec = usec;
239	do {
240	errno = 0;
241	was_error = select(0, NULL, NULL, NULL, &tv);
242	} while (was_error && (errno == EINTR));
243	}
244
245	uint64 frame_time = 0;
246
247	static Boolean work_proc(XtPointer client_data)
248	{
249	ioctl(fd, VIDIOCMCAPTURE, &(mm[bufnum ^ 1]));
250	ioctl(fd, VIDIOCSYNC, &bufnum);
251
252	uint64 now = GetTicks_usec();
253	#if LOGGING
254	fprintf(log, "frame_time: %Ld\n", now - frame_time);
255	#endif
256	frame_time = now;
257
258	#if DOUBLE_FRAME
259	char src = (char )buf + mbuf.offsets[bufnum];
260	char *dst = image[0]->data;
261	for (unsigned y=0; y<grab_height; y+=2) {
262	memcpy(dst, src, grab_width * BYTES_PER_PIXEL);
263	src += grab_width * BYTES_PER_PIXEL * 2;
264	dst += grab_width * BYTES_PER_PIXEL;
265	}
266
267	uint64 prev = GetTicks_usec();
268
269	XvShmPutImage(
270	dpy, port, XtWindow(video), gc, image[0],
271	0, 0, image_width, image_height,
272	0, 0, win_width, win_height,
273	False
274	);
275
276	src = (char )buf + mbuf.offsets[bufnum] + grab_width BYTES_PER_PIXEL;
277	dst = image[1]->data;
278	for (unsigned y=0; y<grab_height; y+=2) {
279	memcpy(dst, src, grab_width * BYTES_PER_PIXEL);
280	src += grab_width * BYTES_PER_PIXEL * 2;
281	dst += grab_width * BYTES_PER_PIXEL;
282	}
283
284	XSync(dpy, False);
285
286	now = GetTicks_usec();
287	uint64 elapsed = now - prev;
288	int64 delay = int64(1000000.0 / fps) - (now - prev);
289	#if LOGGING
290	fprintf(log, "elapsed %Ld usec, delay %Ld usec\n", elapsed, delay);
291	#endif
292	if (delay > 0)
293	Delay_usec(delay);
294
295	XvShmPutImage(
296	dpy, port, XtWindow(video), gc, image[1],
297	0, 0, image_width, image_height,
298	0, 0, win_width, win_height,
299	False
300	);
301	XSync(dpy, False);
302	#else
303	memcpy(image[0]->data, (char *)buf + mbuf.offsets[bufnum], image[0]->data_size);
304
305	XvShmPutImage(
306	dpy, port, XtWindow(video), gc, image[0],
307	0, 0, image_width, image_height,
308	0, 0, win_width, win_height,
309	False
310	);
311	XSync(dpy, False);
312	#endif
313
314	bufnum ^= 1;
315
316	return False;
317	}
318
319	int main(int argc, char **argv)
320	{
321	static struct option long_opts[] = {
322	{"help", 0, 0, 'h'},
323	{"ntsc", 0, 0, 'n'},
324	{"port", 1, 0, 'p'},
325	{"width", 1, 0, 'w'},
326	{NULL, 0, 0, 0}
327	};
328
329	#if LOGGING
330	log = fopen("log", "w");
331	#endif
332
333	// Parse options
334	for (;;) {
335	int c;
336	if ((c = getopt_long(argc, argv, "hnp:w:", long_opts, NULL)) == -1)
337	break;
338
339	switch (c) {
340	case 0: /* Long option */
341	break;
342	case 'n':
343	ntsc = true;
344	break;
345	case 'p':
346	port = atoi(optarg);
347	break;
348	case 'w':
349	grab_width = atoi(optarg);
350	break;
351	case 'h':
352	default:
353	fprintf(stderr,
354	"50/60Hz video display application\n\n"
355	"Options:\n"
356	" -h \| --help this text\n"
357	" -n \| --ntsc NTSC mode\n"
358	" -p \| --port n Xv output port\n"
359	" -w \| --width n image width\n\n"
360	"Keyboard commands:\n"
361	" q quit\n"
362	" 1/2 select channel\n"
363	" KP 7/4/1 adjust brightness\n"
364	" KP 8/5/2 adjust contrast\n"
365	" KP 9/6/3 adjust color\n"
366	);
367	exit(1);
368	break;
369	}
370	}
371
372	// Init X11
373	XtAppContext app_context;
374	app_shell = XtAppInitialize(&app_context, "mintv", NULL, 0, &argc, argv, NULL, NULL, 0);
375	dpy = XtDisplay(app_shell);
376	XtAppAddActions(app_context,actionTable, sizeof(actionTable) / sizeof(XtActionsRec));
377	XtOverrideTranslations(app_shell, XtParseTranslationTable(
378	"<Message>WM_PROTOCOLS: quit()\n"
379	"<Key>q: quit()\n"
380	"<Key>Escape: quit()\n"
381	"<Key>1: select_channel_1()\n"
382	"<Key>2: select_channel_2()\n"
383	"<Key>KP_7: inc_brightness()\n"
384	"<Key>KP_4: reset_brightness()\n"
385	"<Key>KP_1: dec_brightness()\n"
386	"<Key>KP_8: inc_contrast()\n"
387	"<Key>KP_5: reset_contrast()\n"
388	"<Key>KP_2: dec_contrast()\n"
389	"<Key>KP_9: inc_color()\n"
390	"<Key>KP_6: reset_color()\n"
391	"<Key>KP_3: dec_color()"
392	));
393	XtAddEventHandler(app_shell, StructureNotifyMask, True, resize_event, NULL);
394	wm = XInternAtom(XtDisplay(app_shell), "WM_DELETE_WINDOW", False);
395
396	// Xvideo available?
397	unsigned ver, rel, req, ev, err, val;
398	if (XvQueryExtension(dpy, &ver, &rel, &req, &ev, &err) != Success) {
399	fprintf(stderr, "Server doesn't support Xvideo\n");
400	exit(1);
401	}
402
403	// Yes, query available adaptors
404	unsigned num_adaptors;
405	XvAdaptorInfo *ai;
406	if (XvQueryAdaptors(dpy, DefaultRootWindow(dpy), &num_adaptors, &ai) != Success) {
407	fprintf(stderr, "XvQueryAdaptors failed\n");
408	exit(1);
409	}
410
411	// Find usable port
412	if (port < 0) {
413	for (unsigned i=0; i<num_adaptors; i++) {
414	if (ai[i].type & XvImageMask) {
415	for (unsigned p=ai[i].base_id; p<ai[i].base_id+ai[i].num_ports; p++) {
416	int num_formats;
417	XvImageFormatValues *fo = XvListImageFormats(dpy, p, &num_formats);
418	if (fo) {
419	for (unsigned j=0; j<num_formats; j++) {
420	if (fo[j].id == XV_FORMAT) {
421	port = p;
422	goto port_found;
423	}
424	}
425	XFree(fo);
426	}
427	}
428	}
429	}
430	port_found:
431	;
432	}
433	if (port < 0) {
434	fprintf(stderr, "No suitable XVideo port found\n");
435	exit(1);
436	} else
437	printf("Using XVideo port %d\n", port);
438
439	// Set grab and window dimensions
440	if (ntsc) {
441	if (grab_width == -1)
442	grab_width = NTSC_WIDTH;
443	grab_height = NTSC_HEIGHT;
444	fps = NTSC_FPS;
445	} else {
446	if (grab_width == -1)
447	grab_width = PAL_WIDTH;
448	grab_height = PAL_HEIGHT;
449	fps = PAL_FPS;
450	}
451	image_width = grab_width;
452	image_height = grab_height;
453	win_width = DisplayWidth(dpy, DefaultScreen(dpy));
454	win_height = DisplayHeight(dpy, DefaultScreen(dpy));
455	#if DOUBLE_FRAME
456	grab_height *= 2;
457	#endif
458
459	// Open window
460	video = XtVaCreateManagedWidget("video", simpleWidgetClass, app_shell,
461	XtNwidth, win_width,
462	XtNheight, win_height,
463	NULL
464	);
465	XtRealizeWidget(app_shell);
466	XtVaSetValues(app_shell,
467	XtNtitle, "mintv",
468	XtNinput, True,
469	NULL
470	);
471	XSetWMProtocols(dpy, XtWindow(app_shell), &wm, 1);
472	gc = XCreateGC(dpy, XtWindow(video), 0, NULL);
473
474	// Hide cursor
475	Colormap cmap = DefaultColormap(dpy, DefaultScreen(dpy));
476	XColor black;
477	XParseColor(dpy, cmap, "#000000", &black);
478	XAllocColor(dpy, cmap, &black);
479	static char null_data[] = {0, 0, 0, 0, 0, 0, 0, 0};
480	Pixmap null_pixmap = XCreateBitmapFromData(dpy, XtWindow(video), null_data, 8, 8);
481	Cursor null_cursor = XCreatePixmapCursor(dpy, null_pixmap, null_pixmap, &black, &black, 0, 0);
482	XDefineCursor(dpy, XtWindow(video), null_cursor);
483
484	// Set image format
485	unsigned format = XV_FORMAT;
486
487	// Create image
488	image[0] = XvShmCreateImage(dpy, port, format, NULL, image_width, image_height, &shminfo);
489	image[1] = XvShmCreateImage(dpy, port, format, NULL, image_width, image_height, &shminfo);
490	shminfo.shmid = shmget(IPC_PRIVATE, image[0]->data_size * 2, IPC_CREAT \| 0777);
491	shminfo.shmaddr = (char *)shmat(shminfo.shmid, NULL, 0);
492	shminfo.readOnly = False;
493	image[0]->data = shminfo.shmaddr;
494	image[1]->data = shminfo.shmaddr + image[0]->data_size;
495	XShmAttach(dpy, &shminfo);
496	XSync(dpy, False);
497	shmctl(shminfo.shmid, IPC_RMID, 0);
498	memset(image[0]->data, 0x80, image[0]->data_size * 2);
499
500	// Open frame grabber device
501	fd = open("/dev/video0", O_RDWR);
502	if (fd < 0) {
503	fprintf(stderr, "Can't open /dev/video0: %s\n", strerror(errno));
504	exit(1);
505	}
506
507	// Set channel
508	set_channel();
509
510	video_audio au;
511	au.audio = 1;
512	if (ioctl(fd, VIDIOCGAUDIO, &au) < 0) {
513	fprintf(stderr, "ioctl VIDIOCGAUDIO: %s\n", strerror(errno));
514	exit(1);
515	}
516	au.flags &= ~VIDEO_AUDIO_MUTE;
517	if (ioctl(fd, VIDIOCSAUDIO, &au) < 0) {
518	fprintf(stderr, "ioctl VIDIOCSAUDIO: %s\n", strerror(errno));
519	exit(1);
520	}
521
522	// Configure frame grabber
523	set_bcc();
524
525	if (ioctl(fd, VIDIOCGMBUF, &mbuf) < 0) {
526	fprintf(stderr, "ioctl VIDIOCGMBUF: %s\n", strerror(errno));
527	exit(1);
528	}
529
530	buf = mmap(NULL, mbuf.size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd, 0);
531	if (buf == NULL) {
532	fprintf(stderr, "mmap failed: %s\n", strerror(errno));
533	exit(1);
534	}
535
536	mm[0].frame = 0;
537	mm[0].width = grab_width;
538	mm[0].height = grab_height;
539	mm[0].format = VIDEO_PALETTE_YUV422;
540	mm[1].frame = 1;
541	mm[1].width = grab_width;
542	mm[1].height = grab_height;
543	mm[1].format = VIDEO_PALETTE_YUV422;
544	ioctl(fd, VIDIOCMCAPTURE, &(mm[bufnum]));
545
546	// Disable screen saver
547	XSetScreenSaver(dpy, 0, 0, DefaultBlanking, DefaultExposures);
548
549	// Main loop
550	XtAppAddWorkProc(app_context, work_proc, NULL);
551	XtAppMainLoop(app_context);
552
553	return 0;
554	}