← Back to branch summary

~ubuntu-branches/ubuntu/maverick/zapping/maverick

« back to all changes in this revision

Viewing changes to zapping_setup_fb/v4l2.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-03-08 23:19:08 UTC
  • mfrom: (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050308231908-oip7rfv6lcmo8c0e
Tags: 0.9.2-2ubuntu1
Rebuilt for Python transition (2.3 -> 2.4)

Show diffs side-by-side

added added

removed removed

Lines of Context:
zapping_setup_fb/v4l2.c
19
19
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
20
 */
21
21
 
22
 
/* $Id: v4l2.c,v 1.2 2003/01/25 23:39:58 mschimek Exp $ */
 
22
/* $Id: v4l2.c,v 1.9 2005/02/25 18:10:08 mschimek Exp $ */
23
23
 
24
24
#ifdef HAVE_CONFIG_H
25
 
#  include <config.h>
 
25
#  include "config.h"
26
26
#endif
27
27
 
28
28
#include <fcntl.h>
29
29
#include <unistd.h>
30
30
#include <sys/ioctl.h>
31
31
 
 
32
#include "zapping_setup_fb.h"
 
33
 
32
34
#ifdef ENABLE_V4L
33
35
 
34
 
#include <fcntl.h>
35
 
#include <sys/ioctl.h>
36
 
 
37
 
#include "zapping_setup_fb.h"
38
 
 
39
 
#include "../common/videodev2.h" /* V4L2 header file */
40
 
 
41
 
#define v4l2_ioctl(fd, cmd, arg) dev_ioctl (fd, cmd, arg, fprintf_v4l2_ioctl)
42
 
 
43
 
static void
44
 
fprintf_v4l2_ioctl              (FILE *                 fp,
45
 
                                 int                    cmd,
46
 
                                 void *                 arg)
47
 
{
48
 
  switch (cmd)
49
 
    {
50
 
      CASE (VIDIOC_G_FBUF)
51
 
      CASE (VIDIOC_S_FBUF)
52
 
        {
53
 
          struct v4l2_framebuffer *t = arg;
54
 
 
55
 
          fprintf (fp, "capability=");
56
 
 
57
 
          fprintf_symbolic (fp, 0, (unsigned long) t->capability,
58
 
                            "EXTERNOVERLAY", V4L2_FBUF_CAP_EXTERNOVERLAY,
59
 
                            "CHROMAKEY", V4L2_FBUF_CAP_CHROMAKEY,
60
 
                            "CLIPPING", V4L2_FBUF_CAP_CLIPPING,
61
 
                            "SCALEUP", V4L2_FBUF_CAP_SCALEUP,
62
 
                            "SCALEDOWN", V4L2_FBUF_CAP_SCALEDOWN,
63
 
                            "BITMAP_CLIPPING", V4L2_FBUF_CAP_BITMAP_CLIPPING,
64
 
                            0);
65
 
          
66
 
          fprintf (fp, " flags=");
67
 
          
68
 
          fprintf_symbolic (fp, 2, (unsigned long) t->flags,
69
 
                            "PRIMARY", V4L2_FBUF_FLAG_PRIMARY,
70
 
                            "OVERLAY", V4L2_FBUF_FLAG_OVERLAY,
71
 
                            "CHROMAKEY", V4L2_FBUF_FLAG_CHROMAKEY,
72
 
                          0);
73
 
          
74
 
          fprintf (fp, " base[]={%p,%p,%p} fmt.width=%lu "
75
 
                   "fmt.height=%lu fmt.depth=%lu "
76
 
                   "fmt.pixelformat=0x%lx fmt.flags=",
77
 
                   t->base[0], t->base[1],
78
 
                   t->base[2], (unsigned long) t->fmt.width,
79
 
                   (unsigned long) t->fmt.height, (unsigned long) t->fmt.depth,
80
 
                   (unsigned long) t->fmt.pixelformat);
81
 
          
82
 
          fprintf_symbolic (fp, 2, (unsigned long) t->fmt.flags,
83
 
                            "COMPRESSED", V4L2_FMT_FLAG_COMPRESSED,
84
 
                            "BYTESPERLINE", V4L2_FMT_FLAG_BYTESPERLINE,
85
 
                            "INTERLACED", V4L2_FMT_FLAG_INTERLACED,
86
 
                            "TOPFIELD", V4L2_FMT_FLAG_TOPFIELD,
87
 
                            "BOTFIELD", V4L2_FMT_FLAG_BOTFIELD,
88
 
                            0);
89
 
 
90
 
          fprintf (fp, " fmt.bytesperline=%lu fmt.sizeimage=%lu fmt.priv=%lu",
91
 
                   (unsigned long) t->fmt.bytesperline,
92
 
                   (unsigned long) t->fmt.sizeimage,
93
 
                   (unsigned long) t->fmt.priv);
94
 
          break;
95
 
        }
96
 
 
97
 
      CASE (VIDIOC_QUERYCAP)
98
 
        {
99
 
          struct v4l2_capability *t = arg;
100
 
 
101
 
          fprintf (fp, "name=\"%.*s\" type=",
102
 
                   32, t->name);
103
 
 
104
 
          fprintf_symbolic (fp, 1, (unsigned long) t->type,
105
 
                            "CAPTURE", V4L2_TYPE_CAPTURE,
106
 
                            "CODEC", V4L2_TYPE_CODEC,
107
 
                            "OUTPUT", V4L2_TYPE_OUTPUT,
108
 
                            "FX", V4L2_TYPE_FX,
109
 
                            "VBI", V4L2_TYPE_VBI,
110
 
                            "VTR", V4L2_TYPE_VTR,
111
 
                            "VTX", V4L2_TYPE_VTX,
112
 
                            "RADIO", V4L2_TYPE_RADIO,
113
 
                            "VBI_INPUT", V4L2_TYPE_VBI_INPUT,
114
 
                            "VBI_OUTPUT", V4L2_TYPE_VBI_OUTPUT,
115
 
                            "PRIVATE", V4L2_TYPE_PRIVATE,
116
 
                            0);
117
 
        
118
 
          fprintf (fp, " inputs=%ld outputs=%ld "
119
 
                   "audios=%ld maxwidth=%ld "
120
 
                   "maxheight=%ld minwidth=%ld "
121
 
                   "minheight=%ld maxframerate=%ld "
122
 
                   "flags=",
123
 
                   (long) t->inputs, (long) t->outputs, 
124
 
                   (long) t->audios, (long) t->maxwidth, 
125
 
                   (long) t->maxheight, (long) t->minwidth, 
126
 
                   (long) t->minheight, (long) t->maxframerate);
127
 
          
128
 
          fprintf_symbolic (fp, 2, (unsigned long) t->flags,
129
 
                            "READ", V4L2_FLAG_READ,
130
 
                            "WRITE", V4L2_FLAG_WRITE,
131
 
                            "STREAMING", V4L2_FLAG_STREAMING,
132
 
                            "PREVIEW", V4L2_FLAG_PREVIEW,
133
 
                            "SELECT", V4L2_FLAG_SELECT,
134
 
                            "TUNER", V4L2_FLAG_TUNER,
135
 
                            "MONOCHROME", V4L2_FLAG_MONOCHROME,
136
 
                            "DATA_SERVICE", V4L2_FLAG_DATA_SERVICE,
137
 
                            0);
138
 
          break;
139
 
        }
140
 
 
141
 
      default:
142
 
        fprintf (fp, "<unknown cmd 0x%x>", cmd);
143
 
    }
144
 
}
 
36
#include <assert.h>
 
37
 
 
38
#include "common/videodev2.h" /* V4L2 header file */
 
39
#include "common/_videodev2.h"
 
40
 
 
41
#define v4l2_ioctl(fd, cmd, arg)                                        \
 
42
  (IOCTL_ARG_TYPE_CHECK_ ## cmd (arg),                                  \
 
43
   device_ioctl (log_fp, fprint_v4l2_ioctl_arg, fd, cmd, arg))
145
44
 
146
45
int
147
 
setup_v4l2                      (const char *           device_name)
 
46
setup_v4l2                      (const char *           device_name,
 
47
                                 const tv_overlay_buffer *buffer)
148
48
{
149
49
  int fd;
150
50
  struct v4l2_capability cap;
151
 
  struct v4l2_framebuffer fb;
152
51
 
153
52
  message (2, "Opening video device.\n");
154
53
 
155
 
  if (-1 == (fd = dev_open (device_name, 81, O_RDWR)))
 
54
  if (-1 == (fd = device_open_safer (device_name, 81, O_RDWR)))
156
55
    return -1;
157
56
 
158
57
  message (2, "Querying device capabilities.\n");
159
58
 
160
 
  if (-1 == v4l2_ioctl (fd, VIDIOC_QUERYCAP, &cap))
 
59
  if (0 == v4l2_ioctl (fd, VIDIOC_QUERYCAP, &cap))
161
60
    {
162
61
      errmsg ("VIDIOC_QUERYCAP ioctl failed,\n  probably not a V4L2 device");
163
62
      close (fd);
164
63
      return -1;
165
64
    }
166
65
 
167
 
  message (1, "Using V4L2 interface.\n");
168
 
 
169
 
  message (2, "Checking overlay capability.\n");
170
 
 
171
 
  if (V4L2_TYPE_CAPTURE != cap.type
172
 
      || !(V4L2_FLAG_PREVIEW & cap.flags))
173
 
    {
174
 
      message (1, "Device '%s' does not support video overlay.\n", device_name);
175
 
      goto failure;
176
 
    }
177
 
 
178
 
  message (2, "Getting current frame buffer parameters.\n");
179
 
 
180
 
  if (-1 == v4l2_ioctl (fd, VIDIOC_G_FBUF, &fb))
181
 
    {
182
 
      errmsg ("VIDIOC_G_FBUF ioctl failed");
183
 
      goto failure;
184
 
    }
185
 
 
186
 
  if (fb.capability & V4L2_FBUF_CAP_EXTERNOVERLAY)
187
 
    {
188
 
      message (2, "Genlock device, mission accomplished.\n");
189
 
      close (fd);
190
 
      return 1;
191
 
    }
192
 
 
193
 
  fb.base[0]            = (void *) addr;
194
 
  fb.base[1]            = (void *) addr;
195
 
  fb.base[2]            = (void *) addr;
196
 
  fb.fmt.width          = width;
197
 
  fb.fmt.height         = height;
198
 
  fb.fmt.depth          = bpp;
199
 
 
200
 
  switch (depth)
201
 
    {
202
 
    case  8:
203
 
      fb.fmt.pixelformat = V4L2_PIX_FMT_HI240; /* XXX bttv only */
204
 
      break;
205
 
 
206
 
#if BYTE_ORDER == BIG_ENDIAN /* safe? */
207
 
    case 15: fb.fmt.pixelformat = V4L2_PIX_FMT_RGB555X; break;
208
 
    case 16: fb.fmt.pixelformat = V4L2_PIX_FMT_RGB565X; break;
209
 
    case 24: fb.fmt.pixelformat = V4L2_PIX_FMT_RGB24;   break;
210
 
    case 32: fb.fmt.pixelformat = V4L2_PIX_FMT_RGB32;   break;
211
 
#else
212
 
    case 15: fb.fmt.pixelformat = V4L2_PIX_FMT_RGB555;  break;
213
 
    case 16: fb.fmt.pixelformat = V4L2_PIX_FMT_RGB565;  break;
214
 
    case 24: fb.fmt.pixelformat = V4L2_PIX_FMT_BGR24;   break;
215
 
    case 32: fb.fmt.pixelformat = V4L2_PIX_FMT_BGR32;   break;
216
 
#endif
217
 
    }
218
 
 
219
 
  fb.fmt.flags          = V4L2_FMT_FLAG_BYTESPERLINE; 
220
 
  fb.fmt.bytesperline   = bpl;
221
 
  fb.fmt.sizeimage      = height * fb.fmt.bytesperline;
222
 
 
223
 
  message (2, "Setting new frame buffer parameters.\n");
224
 
 
225
 
  /*
226
 
   *  This ioctl is privileged because it sets up
227
 
   *  DMA to a random (video memory) address. 
228
 
   */
229
 
  {
230
 
    int success;
231
 
    int saved_errno;
232
 
 
233
 
    if (!restore_root_privileges (uid, euid))
234
 
      goto failure;
235
 
 
236
 
    success = v4l2_ioctl (fd, VIDIOC_S_FBUF, &fb);
237
 
    saved_errno = errno;
238
 
 
239
 
    if (!drop_root_privileges (uid, euid))
240
 
      ; /* ignore */
241
 
 
242
 
    if (success == -1)
243
 
      {
244
 
        errno = saved_errno;
245
 
 
246
 
        errmsg ("VIDIOC_S_FBUF ioctl failed");
247
 
 
248
 
        if (EPERM == saved_errno && ROOT_UID != euid)
249
 
          message (1, "%s must be run as root, or marked as SUID root.\n",
250
 
                   program_invocation_short_name);
251
 
      failure:
252
 
        close (fd);
253
 
        return 0;
254
 
      }
255
 
  }
 
66
  /* V4L2 0.20 is obsolete, superseded by V4L2 of Linux 2.6. */
 
67
 
 
68
  errmsg ("V4L2 0.20 API not supported");
256
69
 
257
70
  close (fd);
258
71
 
259
 
  return 1;
 
72
  return 0; /* failed */
260
73
}
261
74
 
262
75
#else /* !ENABLE_V4L */
263
76
 
264
77
int
265
 
setup_v4l2                      (const char *           device_name)
 
78
setup_v4l2                      (const char *           device_name,
 
79
                                 const tv_overlay_buffer *buffer)
266
80
{
267
 
  return -1;
 
81
  return -1; /* try other */
268
82
}
269
83
 
270
84
#endif /* !ENABLE_V4L */