git.sesse.net Git - ffmpeg/blob - libav/grab.c

   1 /*
   2  * Linux video grab interface
   3  * Copyright (c) 2000,2001 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include "avformat.h"
  20 #include <linux/videodev.h>
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23 #include <sys/ioctl.h>
  24 #include <sys/mman.h>
  25 #include <sys/time.h>
  26 #include <time.h>
  27
  28 typedef struct {
  29     int fd;
  30     int frame_format; /* see VIDEO_PALETTE_xxx */
  31     int use_mmap;
  32     int width, height;
  33     int frame_rate;
  34     INT64 time_frame;
  35     int frame_size;
  36 } VideoData;
  37
  38 const char *v4l_device = "/dev/video";
  39
  40 /* XXX: move all that to the context */
  41
  42 static struct video_capability  video_cap;
  43 static UINT8 *video_buf;
  44 static struct video_mbuf gb_buffers;
  45 static struct video_mmap gb_buf;
  46 static struct video_audio audio, audio_saved;
  47 static int gb_frame = 0;
  48
  49 static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
  50 {
  51     VideoData *s = s1->priv_data;
  52     AVStream *st;
  53     int width, height;
  54     int video_fd, frame_size;
  55     int ret, frame_rate;
  56     int desired_palette;
  57
  58     if (!ap || ap->width <= 0 || ap->height <= 0 || ap->frame_rate <= 0)
  59         return -1;
  60
  61     width = ap->width;
  62     height = ap->height;
  63     frame_rate = ap->frame_rate;
  64
  65     st = av_new_stream(s1, 0);
  66     if (!st)
  67         return -ENOMEM;
  68
  69     s->width = width;
  70     s->height = height;
  71     s->frame_rate = frame_rate;
  72
  73     video_fd = open(v4l_device, O_RDWR);
  74     if (video_fd < 0) {
  75         perror(v4l_device);
  76         goto fail;
  77     }
  78
  79     if (ioctl(video_fd,VIDIOCGCAP,&video_cap) < 0) {
  80         perror("VIDIOCGCAP");
  81         goto fail;
  82     }
  83
  84     if (!(video_cap.type & VID_TYPE_CAPTURE)) {
  85         fprintf(stderr, "Fatal: grab device does not handle capture\n");
  86         goto fail;
  87     }
  88
  89     desired_palette = -1;
  90     if (st->codec.pix_fmt == PIX_FMT_YUV420P) {
  91         desired_palette = VIDEO_PALETTE_YUV420P;
  92     } else if (st->codec.pix_fmt == PIX_FMT_YUV422) {
  93         desired_palette = VIDEO_PALETTE_YUV422;
  94     } else if (st->codec.pix_fmt == PIX_FMT_BGR24) {
  95         desired_palette = VIDEO_PALETTE_RGB24;
  96     }
  97
  98     /* unmute audio */
  99     ioctl(video_fd, VIDIOCGAUDIO, &audio);
 100     memcpy(&audio_saved, &audio, sizeof(audio));
 101     audio.flags &= ~VIDEO_AUDIO_MUTE;
 102     ioctl(video_fd, VIDIOCSAUDIO, &audio);
 103
 104     ret = ioctl(video_fd,VIDIOCGMBUF,&gb_buffers);
 105     if (ret < 0) {
 106         /* try to use read based access */
 107         struct video_window win;
 108         struct video_picture pict;
 109         int val;
 110
 111         win.x = 0;
 112         win.y = 0;
 113         win.width = width;
 114         win.height = height;
 115         win.chromakey = -1;
 116         win.flags = 0;
 117
 118         ioctl(video_fd, VIDIOCSWIN, &win);
 119
 120         ioctl(video_fd, VIDIOCGPICT, &pict);
 121 #if 0
 122         printf("v4l: colour=%d hue=%d brightness=%d constrast=%d whiteness=%d\n",
 123                pict.colour,
 124                pict.hue,
 125                pict.brightness,
 126                pict.contrast,
 127                pict.whiteness);
 128 #endif
 129         /* try to choose a suitable video format */
 130         pict.palette = desired_palette;
 131         if (desired_palette == -1 || (ret = ioctl(video_fd, VIDIOCSPICT, &pict)) < 0) {
 132             pict.palette=VIDEO_PALETTE_YUV420P;
 133             ret = ioctl(video_fd, VIDIOCSPICT, &pict);
 134             if (ret < 0) {
 135                 pict.palette=VIDEO_PALETTE_YUV422;
 136                 ret = ioctl(video_fd, VIDIOCSPICT, &pict);
 137                 if (ret < 0) {
 138                     pict.palette=VIDEO_PALETTE_RGB24;
 139                     ret = ioctl(video_fd, VIDIOCSPICT, &pict);
 140                     if (ret < 0)
 141                         goto fail1;
 142                 }
 143             }
 144         }
 145
 146         s->frame_format = pict.palette;
 147
 148         val = 1;
 149         ioctl(video_fd, VIDIOCCAPTURE, &val);
 150
 151         s->time_frame = gettime();
 152         s->use_mmap = 0;
 153     } else {
 154         video_buf = mmap(0,gb_buffers.size,PROT_READ|PROT_WRITE,MAP_SHARED,video_fd,0);
 155         if ((unsigned char*)-1 == video_buf) {
 156             perror("mmap");
 157             goto fail;
 158         }
 159         gb_frame = 0;
 160         s->time_frame = gettime();
 161
 162         /* start to grab the first frame */
 163         gb_buf.frame = gb_frame % gb_buffers.frames;
 164         gb_buf.height = height;
 165         gb_buf.width = width;
 166         gb_buf.format = desired_palette;
 167
 168         if (desired_palette == -1 || (ret = ioctl(video_fd, VIDIOCMCAPTURE, &gb_buf)) < 0) {
 169             gb_buf.format = VIDEO_PALETTE_YUV420P;
 170
 171             ret = ioctl(video_fd, VIDIOCMCAPTURE, &gb_buf);
 172             if (ret < 0 && errno != EAGAIN) {
 173                 /* try YUV422 */
 174                 gb_buf.format = VIDEO_PALETTE_YUV422;
 175
 176                 ret = ioctl(video_fd, VIDIOCMCAPTURE, &gb_buf);
 177                 if (ret < 0 && errno != EAGAIN) {
 178                     /* try RGB24 */
 179                     gb_buf.format = VIDEO_PALETTE_RGB24;
 180                     ret = ioctl(video_fd, VIDIOCMCAPTURE, &gb_buf);
 181                 }
 182             }
 183         }
 184         if (ret < 0) {
 185             if (errno != EAGAIN) {
 186             fail1:
 187                 fprintf(stderr, "Fatal: grab device does not support suitable format\n");
 188             } else {
 189                 fprintf(stderr,"Fatal: grab device does not receive any video signal\n");
 190             }
 191             goto fail;
 192         }
 193         s->frame_format = gb_buf.format;
 194         s->use_mmap = 1;
 195     }
 196
 197     switch(s->frame_format) {
 198     case VIDEO_PALETTE_YUV420P:
 199         frame_size = (width * height * 3) / 2;
 200         st->codec.pix_fmt = PIX_FMT_YUV420P;
 201         break;
 202     case VIDEO_PALETTE_YUV422:
 203         frame_size = width * height * 2;
 204         st->codec.pix_fmt = PIX_FMT_YUV422;
 205         break;
 206     case VIDEO_PALETTE_RGB24:
 207         frame_size = width * height * 3;
 208         st->codec.pix_fmt = PIX_FMT_BGR24; /* NOTE: v4l uses BGR24, not RGB24 ! */
 209         break;
 210     default:
 211         goto fail;
 212     }
 213     s->fd = video_fd;
 214     s->frame_size = frame_size;
 215
 216     st->codec.codec_type = CODEC_TYPE_VIDEO;
 217     st->codec.codec_id = CODEC_ID_RAWVIDEO;
 218     st->codec.width = width;
 219     st->codec.height = height;
 220     st->codec.frame_rate = frame_rate;
 221
 222     return 0;
 223  fail:
 224     if (video_fd >= 0)
 225         close(video_fd);
 226     av_free(st);
 227     return -EIO;
 228 }
 229
 230 static int v4l_mm_read_picture(VideoData *s, UINT8 *buf)
 231 {
 232     UINT8 *ptr;
 233     struct timeval tv_s;
 234     //struct timeval tv_e;
 235     //int delay;
 236
 237     /* Setup to capture the next frame */
 238     gb_buf.frame = (gb_frame + 1) % gb_buffers.frames;
 239     if (ioctl(s->fd, VIDIOCMCAPTURE, &gb_buf) < 0) {
 240         if (errno == EAGAIN)
 241             fprintf(stderr,"Cannot Sync\n");
 242         else
 243             perror("VIDIOCMCAPTURE");
 244         return -EIO;
 245     }
 246
 247     gettimeofday(&tv_s, 0);
 248
 249     while (ioctl(s->fd, VIDIOCSYNC, &gb_frame) < 0 &&
 250            (errno == EAGAIN || errno == EINTR));
 251
 252     /*
 253     gettimeofday(&tv_e, 0);
 254
 255     delay = (tv_e.tv_sec - tv_s.tv_sec) * 1000000 + tv_e.tv_usec - tv_s.tv_usec;
 256     if (delay > 10000)
 257         printf("VIDIOCSYNC took %d us\n", delay);
 258     */
 259
 260     ptr = video_buf + gb_buffers.offsets[gb_frame];
 261     memcpy(buf, ptr, s->frame_size);
 262
 263     /* This is now the grabbing frame */
 264     gb_frame = gb_buf.frame;
 265
 266     return s->frame_size;
 267 }
 268
 269 static int grab_read_packet(AVFormatContext *s1, AVPacket *pkt)
 270 {
 271     VideoData *s = s1->priv_data;
 272     INT64 curtime, delay;
 273     struct timespec ts;
 274     int first;
 275     INT64 per_frame = (INT64_C(1000000) * FRAME_RATE_BASE) / s->frame_rate;
 276     int dropped = 0;
 277
 278     /* Calculate the time of the next frame */
 279     s->time_frame += per_frame;
 280
 281     /* wait based on the frame rate */
 282     for(first = 1;; first = 0) {
 283         curtime = gettime();
 284         delay = s->time_frame - curtime;
 285         if (delay <= 0) {
 286             if (delay < -per_frame) {
 287                 /* printf("grabbing is %d frames late (dropping)\n", (int) -(delay / 16666)); */
 288                 dropped = 1;
 289                 s->time_frame += per_frame;
 290             }
 291             break;
 292         }
 293         ts.tv_sec = delay / 1000000;
 294         ts.tv_nsec = (delay % 1000000) * 1000;
 295         nanosleep(&ts, NULL);
 296     }
 297
 298     if (av_new_packet(pkt, s->frame_size) < 0)
 299         return -EIO;
 300
 301     if (dropped)
 302         pkt->flags |= PKT_FLAG_DROPPED_FRAME;
 303
 304     /* read one frame */
 305     if (s->use_mmap) {
 306         return v4l_mm_read_picture(s, pkt->data);
 307     } else {
 308         if (read(s->fd, pkt->data, pkt->size) != pkt->size)
 309             return -EIO;
 310         return s->frame_size;
 311     }
 312 }
 313
 314 static int grab_read_close(AVFormatContext *s1)
 315 {
 316     VideoData *s = s1->priv_data;
 317     /* restore audio settings */
 318     ioctl(s->fd, VIDIOCSAUDIO, &audio_saved);
 319
 320     close(s->fd);
 321     return 0;
 322 }
 323
 324 AVInputFormat video_grab_device_format = {
 325     "video_grab_device",
 326     "video grab",
 327     sizeof(VideoData),
 328     NULL,
 329     grab_read_header,
 330     grab_read_packet,
 331     grab_read_close,
 332     flags: AVFMT_NOFILE,
 333 };
 334
 335 int video_grab_init(void)
 336 {
 337     av_register_input_format(&video_grab_device_format);
 338     return 0;
 339 }