FFmpeg
fbdev_dec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
3  * Copyright (c) 2009 Giliard B. de Freitas <giliarde@gmail.com>
4  * Copyright (C) 2002 Gunnar Monell <gmo@linux.nu>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Linux framebuffer input device,
26  * inspired by code from fbgrab.c by Gunnar Monell.
27  * @see http://linux-fbdev.sourceforge.net/
28  */
29 
30 #include <unistd.h>
31 #include <fcntl.h>
32 #include <sys/ioctl.h>
33 #include <sys/mman.h>
34 #include <time.h>
35 #include <linux/fb.h>
36 
37 #include "libavutil/internal.h"
38 #include "libavutil/log.h"
39 #include "libavutil/mem.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/time.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/pixdesc.h"
44 #include "libavformat/internal.h"
45 #include "avdevice.h"
46 #include "fbdev_common.h"
47 
48 typedef struct FBDevContext {
49  AVClass *class; ///< class for private options
50  int frame_size; ///< size in bytes of a grabbed frame
51  AVRational framerate_q; ///< framerate
52  int64_t time_frame; ///< time for the next frame to output (in 1/1000000 units)
53 
54  int fd; ///< framebuffer device file descriptor
55  int width, height; ///< assumed frame resolution
56  int frame_linesize; ///< linesize of the output frame, it is assumed to be constant
58 
59  struct fb_var_screeninfo varinfo; ///< variable info;
60  struct fb_fix_screeninfo fixinfo; ///< fixed info;
61 
62  uint8_t *data; ///< framebuffer data
63 } FBDevContext;
64 
66 {
67  FBDevContext *fbdev = avctx->priv_data;
68  AVStream *st = NULL;
70  int ret, flags = O_RDONLY;
71  const char* device;
72 
73  if (!(st = avformat_new_stream(avctx, NULL)))
74  return AVERROR(ENOMEM);
75  avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in microseconds */
76 
77  /* NONBLOCK is ignored by the fbdev driver, only set for consistency */
78  if (avctx->flags & AVFMT_FLAG_NONBLOCK)
79  flags |= O_NONBLOCK;
80 
81  if (avctx->url[0])
82  device = avctx->url;
83  else
84  device = ff_fbdev_default_device();
85 
86  if ((fbdev->fd = avpriv_open(device, flags)) == -1) {
87  ret = AVERROR(errno);
88  av_log(avctx, AV_LOG_ERROR,
89  "Could not open framebuffer device '%s': %s\n",
90  device, av_err2str(ret));
91  return ret;
92  }
93 
94  if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
95  ret = AVERROR(errno);
96  av_log(avctx, AV_LOG_ERROR,
97  "FBIOGET_VSCREENINFO: %s\n", av_err2str(ret));
98  goto fail;
99  }
100 
101  if (ioctl(fbdev->fd, FBIOGET_FSCREENINFO, &fbdev->fixinfo) < 0) {
102  ret = AVERROR(errno);
103  av_log(avctx, AV_LOG_ERROR,
104  "FBIOGET_FSCREENINFO: %s\n", av_err2str(ret));
105  goto fail;
106  }
107 
109  if (pix_fmt == AV_PIX_FMT_NONE) {
110  ret = AVERROR(EINVAL);
111  av_log(avctx, AV_LOG_ERROR,
112  "Framebuffer pixel format not supported.\n");
113  goto fail;
114  }
115 
116  fbdev->width = fbdev->varinfo.xres;
117  fbdev->height = fbdev->varinfo.yres;
118  fbdev->bytes_per_pixel = (fbdev->varinfo.bits_per_pixel + 7) >> 3;
119  fbdev->frame_linesize = fbdev->width * fbdev->bytes_per_pixel;
120  fbdev->frame_size = fbdev->frame_linesize * fbdev->height;
121  fbdev->time_frame = AV_NOPTS_VALUE;
122  fbdev->data = mmap(NULL, fbdev->fixinfo.smem_len, PROT_READ, MAP_SHARED, fbdev->fd, 0);
123  if (fbdev->data == MAP_FAILED) {
124  ret = AVERROR(errno);
125  av_log(avctx, AV_LOG_ERROR, "Error in mmap(): %s\n", av_err2str(ret));
126  goto fail;
127  }
128 
131  st->codecpar->width = fbdev->width;
132  st->codecpar->height = fbdev->height;
133  st->codecpar->format = pix_fmt;
134  st->avg_frame_rate = fbdev->framerate_q;
135  st->codecpar->bit_rate =
136  fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;
137 
138  av_log(avctx, AV_LOG_INFO,
139  "w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%"PRId64"\n",
140  fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel,
142  fbdev->framerate_q.num, fbdev->framerate_q.den,
143  st->codecpar->bit_rate);
144  return 0;
145 
146 fail:
147  close(fbdev->fd);
148  return ret;
149 }
150 
152 {
153  FBDevContext *fbdev = avctx->priv_data;
154  int64_t curtime, delay;
155  struct timespec ts;
156  int i, ret;
157  uint8_t *pin, *pout;
158 
159  if (fbdev->time_frame == AV_NOPTS_VALUE)
160  fbdev->time_frame = av_gettime();
161 
162  /* wait based on the frame rate */
163  while (1) {
164  curtime = av_gettime();
165  delay = fbdev->time_frame - curtime;
166  av_log(avctx, AV_LOG_TRACE,
167  "time_frame:%"PRId64" curtime:%"PRId64" delay:%"PRId64"\n",
168  fbdev->time_frame, curtime, delay);
169  if (delay <= 0) {
170  fbdev->time_frame += INT64_C(1000000) / av_q2d(fbdev->framerate_q);
171  break;
172  }
173  if (avctx->flags & AVFMT_FLAG_NONBLOCK)
174  return AVERROR(EAGAIN);
175  ts.tv_sec = delay / 1000000;
176  ts.tv_nsec = (delay % 1000000) * 1000;
177  while (nanosleep(&ts, &ts) < 0 && errno == EINTR);
178  }
179 
180  if ((ret = av_new_packet(pkt, fbdev->frame_size)) < 0)
181  return ret;
182 
183  /* refresh fbdev->varinfo, visible data position may change at each call */
184  if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
185  av_log(avctx, AV_LOG_WARNING,
186  "Error refreshing variable info: %s\n", av_err2str(AVERROR(errno)));
187  }
188 
189  pkt->pts = curtime;
190 
191  /* compute visible data offset */
192  pin = fbdev->data + fbdev->bytes_per_pixel * fbdev->varinfo.xoffset +
193  fbdev->varinfo.yoffset * fbdev->fixinfo.line_length;
194  pout = pkt->data;
195 
196  for (i = 0; i < fbdev->height; i++) {
197  memcpy(pout, pin, fbdev->frame_linesize);
198  pin += fbdev->fixinfo.line_length;
199  pout += fbdev->frame_linesize;
200  }
201 
202  return fbdev->frame_size;
203 }
204 
206 {
207  FBDevContext *fbdev = avctx->priv_data;
208 
209  munmap(fbdev->data, fbdev->fixinfo.smem_len);
210  close(fbdev->fd);
211 
212  return 0;
213 }
214 
216 {
217  return ff_fbdev_get_device_list(device_list);
218 }
219 
220 #define OFFSET(x) offsetof(FBDevContext, x)
221 #define DEC AV_OPT_FLAG_DECODING_PARAM
222 static const AVOption options[] = {
223  { "framerate","", OFFSET(framerate_q), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC },
224  { NULL },
225 };
226 
227 static const AVClass fbdev_class = {
228  .class_name = "fbdev indev",
229  .item_name = av_default_item_name,
230  .option = options,
231  .version = LIBAVUTIL_VERSION_INT,
233 };
234 
236  .name = "fbdev",
237  .long_name = NULL_IF_CONFIG_SMALL("Linux framebuffer"),
238  .priv_data_size = sizeof(FBDevContext),
242  .get_device_list = fbdev_get_device_list,
243  .flags = AVFMT_NOFILE,
244  .priv_class = &fbdev_class,
245 };
ff_fbdev_default_device
const char * ff_fbdev_default_device()
Definition: fbdev_common.c:64
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4480
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
FBDevContext::bytes_per_pixel
int bytes_per_pixel
Definition: fbdev_dec.c:57
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:236
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: avcodec.h:231
pixdesc.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
AVOption
AVOption.
Definition: opt.h:246
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:943
fbdev_class
static const AVClass fbdev_class
Definition: fbdev_dec.c:227
fail
#define fail()
Definition: checkasm.h:120
FBDevContext::fixinfo
struct fb_fix_screeninfo fixinfo
fixed info;
Definition: fbdev_dec.c:60
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_get_pixfmt_from_fb_varinfo
enum AVPixelFormat ff_get_pixfmt_from_fb_varinfo(struct fb_var_screeninfo *varinfo)
Definition: fbdev_common.c:48
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVInputFormat
Definition: avformat.h:640
av_cold
#define av_cold
Definition: attributes.h:84
ff_fbdev_get_device_list
int ff_fbdev_get_device_list(AVDeviceInfoList *device_list)
Definition: fbdev_common.c:72
s
#define s(width, name)
Definition: cbs_vp9.c:257
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
avpriv_open
int avpriv_open(const char *filename, int flags,...)
A wrapper for open() setting O_CLOEXEC.
Definition: file_open.c:66
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1473
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
AVCodecParameters::width
int width
Video only.
Definition: avcodec.h:4023
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
fbdev_get_device_list
static int fbdev_get_device_list(AVFormatContext *s, AVDeviceInfoList *device_list)
Definition: fbdev_dec.c:215
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
FBDevContext::fd
int fd
framebuffer device file descriptor
Definition: fbdev_dec.c:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
internal.h
FBDevContext::frame_size
int frame_size
size in bytes of a grabbed frame
Definition: fbdev_dec.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1017
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
fbdev_read_close
static av_cold int fbdev_read_close(AVFormatContext *avctx)
Definition: fbdev_dec.c:205
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
parseutils.h
FBDevContext::width
int width
Definition: fbdev_dec.c:55
time.h
AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
Definition: log.h:42
FBDevContext::time_frame
int64_t time_frame
time for the next frame to output (in 1/1000000 units)
Definition: fbdev_dec.c:52
OFFSET
#define OFFSET(x)
Definition: fbdev_dec.c:220
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
DEC
#define DEC
Definition: fbdev_dec.c:221
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4910
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1438
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
avdevice.h
fbdev_common.h
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
internal.h
AVCodecParameters::height
int height
Definition: avcodec.h:4024
FBDevContext
Definition: fbdev_dec.c:48
fbdev_read_packet
static int fbdev_read_packet(AVFormatContext *avctx, AVPacket *pkt)
Definition: fbdev_dec.c:151
uint8_t
uint8_t
Definition: audio_convert.c:194
AVFMT_FLAG_NONBLOCK
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1476
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:870
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
AVDeviceInfoList
List of devices.
Definition: avdevice.h:460
FBDevContext::frame_linesize
int frame_linesize
linesize of the output frame, it is assumed to be constant
Definition: fbdev_dec.c:56
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
FBDevContext::varinfo
struct fb_var_screeninfo varinfo
variable info;
Definition: fbdev_dec.c:59
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
fbdev_read_header
static av_cold int fbdev_read_header(AVFormatContext *avctx)
Definition: fbdev_dec.c:65
mem.h
AVCodecParameters::format
int format
Definition: avcodec.h:3981
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3986
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_fbdev_demuxer
AVInputFormat ff_fbdev_demuxer
Definition: fbdev_dec.c:235
FBDevContext::data
uint8_t * data
framebuffer data
Definition: fbdev_dec.c:62
options
static const AVOption options[]
Definition: fbdev_dec.c:222
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1370
FBDevContext::height
int height
assumed frame resolution
Definition: fbdev_dec.c:55
FBDevContext::framerate_q
AVRational framerate_q
framerate
Definition: fbdev_dec.c:51
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2438