fbdev.c 9.47 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * Copyright (c) 2011 Stefano Sabatini
 * Copyright (c) 2009 Giliard B. de Freitas <giliarde@gmail.com>
 * Copyright (C) 2002 Gunnar Monell <gmo@linux.nu>
 *
 * This file is part of Libav.
 *
 * Libav is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * Libav 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with Libav; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * Linux framebuffer input device,
 * inspired by code from fbgrab.c by Gunnar Monell.
27
 * @see http://linux-fbdev.sourceforge.net/
28 29 30 31 32 33 34 35 36
 */

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

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 44
#include "libavutil/pixdesc.h"
#include "libavformat/avformat.h"
45
#include "libavformat/internal.h"
46 47 48 49

struct rgb_pixfmt_map_entry {
    int bits_per_pixel;
    int red_offset, green_offset, blue_offset, alpha_offset;
50
    enum AVPixelFormat pixfmt;
51 52 53 54
};

static struct rgb_pixfmt_map_entry rgb_pixfmt_map[] = {
    // bpp, red_offset,  green_offset, blue_offset, alpha_offset, pixfmt
55 56 57 58 59 60
    {  32,       0,           8,          16,           24,   AV_PIX_FMT_RGBA  },
    {  32,      16,           8,           0,           24,   AV_PIX_FMT_BGRA  },
    {  32,       8,          16,          24,            0,   AV_PIX_FMT_ARGB  },
    {  32,       3,           2,           8,            0,   AV_PIX_FMT_ABGR  },
    {  24,       0,           8,          16,            0,   AV_PIX_FMT_RGB24 },
    {  24,      16,           8,           0,            0,   AV_PIX_FMT_BGR24 },
61 62
};

63
static enum AVPixelFormat get_pixfmt_from_fb_varinfo(struct fb_var_screeninfo *varinfo)
64 65 66 67 68 69 70 71 72 73 74 75
{
    int i;

    for (i = 0; i < FF_ARRAY_ELEMS(rgb_pixfmt_map); i++) {
        struct rgb_pixfmt_map_entry *entry = &rgb_pixfmt_map[i];
        if (entry->bits_per_pixel == varinfo->bits_per_pixel &&
            entry->red_offset     == varinfo->red.offset     &&
            entry->green_offset   == varinfo->green.offset   &&
            entry->blue_offset    == varinfo->blue.offset)
            return entry->pixfmt;
    }

76
    return AV_PIX_FMT_NONE;
77 78
}

79
typedef struct FBDevContext {
80
    AVClass *class;          ///< class for private options
81
    int frame_size;          ///< size in bytes of a grabbed frame
82
    AVRational framerate_q;  ///< framerate
83
    char *framerate;         ///< framerate string set by a private option
84 85 86
    int64_t time_frame;      ///< time for the next frame to output (in 1/1000000 units)

    int fd;                  ///< framebuffer device file descriptor
87
    int width, height;       ///< assumed frame resolution
88 89 90 91 92 93 94 95 96
    int frame_linesize;      ///< linesize of the output frame, it is assumed to be constant
    int bytes_per_pixel;

    struct fb_var_screeninfo varinfo; ///< variable info;
    struct fb_fix_screeninfo fixinfo; ///< fixed    info;

    uint8_t *data;           ///< framebuffer data
} FBDevContext;

97
static av_cold int fbdev_read_header(AVFormatContext *avctx)
98 99 100
{
    FBDevContext *fbdev = avctx->priv_data;
    AVStream *st = NULL;
101
    enum AVPixelFormat pix_fmt;
102
    int ret, flags = O_RDONLY;
Luca Barbato's avatar
Luca Barbato committed
103
    char errbuf[128];
104

105
    ret = av_parse_video_rate(&fbdev->framerate_q, fbdev->framerate);
106
    if (ret < 0) {
107
        av_log(avctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n", fbdev->framerate);
108 109 110
        return ret;
    }

111
    if (!(st = avformat_new_stream(avctx, NULL)))
112
        return AVERROR(ENOMEM);
113
    avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in microseconds */
114 115 116 117 118

    /* NONBLOCK is ignored by the fbdev driver, only set for consistency */
    if (avctx->flags & AVFMT_FLAG_NONBLOCK)
        flags |= O_NONBLOCK;

119
    if ((fbdev->fd = avpriv_open(avctx->filename, flags)) == -1) {
120
        ret = AVERROR(errno);
Luca Barbato's avatar
Luca Barbato committed
121
        av_strerror(ret, errbuf, sizeof(errbuf));
122 123
        av_log(avctx, AV_LOG_ERROR,
               "Could not open framebuffer device '%s': %s\n",
Luca Barbato's avatar
Luca Barbato committed
124
               avctx->filename, errbuf);
125 126 127 128 129
        return ret;
    }

    if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
        ret = AVERROR(errno);
Luca Barbato's avatar
Luca Barbato committed
130
        av_strerror(ret, errbuf, sizeof(errbuf));
131
        av_log(avctx, AV_LOG_ERROR,
Luca Barbato's avatar
Luca Barbato committed
132
               "FBIOGET_VSCREENINFO: %s\n", errbuf);
133 134 135 136 137
        goto fail;
    }

    if (ioctl(fbdev->fd, FBIOGET_FSCREENINFO, &fbdev->fixinfo) < 0) {
        ret = AVERROR(errno);
Luca Barbato's avatar
Luca Barbato committed
138
        av_strerror(ret, errbuf, sizeof(errbuf));
139
        av_log(avctx, AV_LOG_ERROR,
Luca Barbato's avatar
Luca Barbato committed
140
               "FBIOGET_FSCREENINFO: %s\n", errbuf);
141 142 143 144
        goto fail;
    }

    pix_fmt = get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
145
    if (pix_fmt == AV_PIX_FMT_NONE) {
146 147 148 149 150 151 152
        ret = AVERROR(EINVAL);
        av_log(avctx, AV_LOG_ERROR,
               "Framebuffer pixel format not supported.\n");
        goto fail;
    }

    fbdev->width           = fbdev->varinfo.xres;
153
    fbdev->height          = fbdev->varinfo.yres;
154 155
    fbdev->bytes_per_pixel = (fbdev->varinfo.bits_per_pixel + 7) >> 3;
    fbdev->frame_linesize  = fbdev->width * fbdev->bytes_per_pixel;
156
    fbdev->frame_size      = fbdev->frame_linesize * fbdev->height;
157 158 159 160
    fbdev->time_frame      = AV_NOPTS_VALUE;
    fbdev->data = mmap(NULL, fbdev->fixinfo.smem_len, PROT_READ, MAP_SHARED, fbdev->fd, 0);
    if (fbdev->data == MAP_FAILED) {
        ret = AVERROR(errno);
Luca Barbato's avatar
Luca Barbato committed
161 162
        av_strerror(ret, errbuf, sizeof(errbuf));
        av_log(avctx, AV_LOG_ERROR, "Error in mmap(): %s\n", errbuf);
163 164 165 166
        goto fail;
    }

    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
167
    st->codec->codec_id   = AV_CODEC_ID_RAWVIDEO;
168
    st->codec->width      = fbdev->width;
169
    st->codec->height     = fbdev->height;
170
    st->codec->pix_fmt    = pix_fmt;
171
    st->codec->time_base  = (AVRational){fbdev->framerate_q.den, fbdev->framerate_q.num};
172
    st->codec->bit_rate   =
173
        fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;
174 175

    av_log(avctx, AV_LOG_INFO,
176
           "w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\n",
177
           fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel,
178
           av_get_pix_fmt_name(pix_fmt),
179
           fbdev->framerate_q.num, fbdev->framerate_q.den,
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
           st->codec->bit_rate);
    return 0;

fail:
    close(fbdev->fd);
    return ret;
}

static int fbdev_read_packet(AVFormatContext *avctx, AVPacket *pkt)
{
    FBDevContext *fbdev = avctx->priv_data;
    int64_t curtime, delay;
    struct timespec ts;
    int i, ret;
    uint8_t *pin, *pout;

    if (fbdev->time_frame == AV_NOPTS_VALUE)
        fbdev->time_frame = av_gettime();

    /* wait based on the frame rate */
    curtime = av_gettime();
    delay = fbdev->time_frame - curtime;
    av_dlog(avctx,
            "time_frame:%"PRId64" curtime:%"PRId64" delay:%"PRId64"\n",
            fbdev->time_frame, curtime, delay);
    if (delay > 0) {
        if (avctx->flags & AVFMT_FLAG_NONBLOCK)
            return AVERROR(EAGAIN);
        ts.tv_sec  =  delay / 1000000;
        ts.tv_nsec = (delay % 1000000) * 1000;
        while (nanosleep(&ts, &ts) < 0 && errno == EINTR);
    }
    /* compute the time of the next frame */
213
    fbdev->time_frame += INT64_C(1000000) / av_q2d(fbdev->framerate_q);
214 215 216 217 218

    if ((ret = av_new_packet(pkt, fbdev->frame_size)) < 0)
        return ret;

    /* refresh fbdev->varinfo, visible data position may change at each call */
Luca Barbato's avatar
Luca Barbato committed
219 220 221
    if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
        char errbuf[128];
        av_strerror(AVERROR(errno), errbuf, sizeof(errbuf));
222
        av_log(avctx, AV_LOG_WARNING,
Luca Barbato's avatar
Luca Barbato committed
223 224
               "Error refreshing variable info: %s\n", errbuf);
    }
225 226 227 228 229 230 231 232 233

    pkt->pts = curtime;

    /* compute visible data offset */
    pin = fbdev->data + fbdev->bytes_per_pixel * fbdev->varinfo.xoffset +
                        fbdev->varinfo.yoffset * fbdev->fixinfo.line_length;
    pout = pkt->data;

    // TODO it'd be nice if the lines were aligned
234
    for (i = 0; i < fbdev->height; i++) {
235 236 237 238 239 240 241 242
        memcpy(pout, pin, fbdev->frame_linesize);
        pin  += fbdev->fixinfo.line_length;
        pout += fbdev->frame_linesize;
    }

    return fbdev->frame_size;
}

243
static av_cold int fbdev_read_close(AVFormatContext *avctx)
244 245 246 247 248 249 250 251 252
{
    FBDevContext *fbdev = avctx->priv_data;

    munmap(fbdev->data, fbdev->frame_size);
    close(fbdev->fd);

    return 0;
}

253 254 255
#define OFFSET(x) offsetof(FBDevContext, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
256
    { "framerate","", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC },
257 258 259 260 261 262 263 264 265 266
    { NULL },
};

static const AVClass fbdev_class = {
    .class_name = "fbdev indev",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

267 268 269 270 271 272 273 274
AVInputFormat ff_fbdev_demuxer = {
    .name           = "fbdev",
    .long_name      = NULL_IF_CONFIG_SMALL("Linux framebuffer"),
    .priv_data_size = sizeof(FBDevContext),
    .read_header    = fbdev_read_header,
    .read_packet    = fbdev_read_packet,
    .read_close     = fbdev_read_close,
    .flags          = AVFMT_NOFILE,
275
    .priv_class     = &fbdev_class,
276
};