fbdev.c 9.19 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 {
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 103
    int ret, flags = O_RDONLY;

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

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

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

118
    if ((fbdev->fd = avpriv_open(avctx->filename, flags)) == -1) {
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
        ret = AVERROR(errno);
        av_log(avctx, AV_LOG_ERROR,
               "Could not open framebuffer device '%s': %s\n",
               avctx->filename, strerror(ret));
        return ret;
    }

    if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
        ret = AVERROR(errno);
        av_log(avctx, AV_LOG_ERROR,
               "FBIOGET_VSCREENINFO: %s\n", strerror(errno));
        goto fail;
    }

    if (ioctl(fbdev->fd, FBIOGET_FSCREENINFO, &fbdev->fixinfo) < 0) {
        ret = AVERROR(errno);
        av_log(avctx, AV_LOG_ERROR,
               "FBIOGET_FSCREENINFO: %s\n", strerror(errno));
        goto fail;
    }

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

    fbdev->width           = fbdev->varinfo.xres;
149
    fbdev->height          = fbdev->varinfo.yres;
150 151
    fbdev->bytes_per_pixel = (fbdev->varinfo.bits_per_pixel + 7) >> 3;
    fbdev->frame_linesize  = fbdev->width * fbdev->bytes_per_pixel;
152
    fbdev->frame_size      = fbdev->frame_linesize * fbdev->height;
153 154 155 156 157 158 159 160 161
    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);
        av_log(avctx, AV_LOG_ERROR, "Error in mmap(): %s\n", strerror(errno));
        goto fail;
    }

    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
162
    st->codec->codec_id   = AV_CODEC_ID_RAWVIDEO;
163
    st->codec->width      = fbdev->width;
164
    st->codec->height     = fbdev->height;
165
    st->codec->pix_fmt    = pix_fmt;
166
    st->codec->time_base  = (AVRational){fbdev->framerate_q.den, fbdev->framerate_q.num};
167
    st->codec->bit_rate   =
168
        fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;
169 170

    av_log(avctx, AV_LOG_INFO,
171
           "w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\n",
172
           fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel,
173
           av_get_pix_fmt_name(pix_fmt),
174
           fbdev->framerate_q.num, fbdev->framerate_q.den,
175 176 177 178 179 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
           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 */
208
    fbdev->time_frame += INT64_C(1000000) / av_q2d(fbdev->framerate_q);
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225

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

    /* refresh fbdev->varinfo, visible data position may change at each call */
    if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0)
        av_log(avctx, AV_LOG_WARNING,
               "Error refreshing variable info: %s\n", strerror(errno));

    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
226
    for (i = 0; i < fbdev->height; i++) {
227 228 229 230 231 232 233 234
        memcpy(pout, pin, fbdev->frame_linesize);
        pin  += fbdev->fixinfo.line_length;
        pout += fbdev->frame_linesize;
    }

    return fbdev->frame_size;
}

235
static av_cold int fbdev_read_close(AVFormatContext *avctx)
236 237 238 239 240 241 242 243 244
{
    FBDevContext *fbdev = avctx->priv_data;

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

    return 0;
}

245 246 247
#define OFFSET(x) offsetof(FBDevContext, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
248
    { "framerate","", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC },
249 250 251 252 253 254 255 256 257 258
    { NULL },
};

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

259 260 261 262 263 264 265 266
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,
267
    .priv_class     = &fbdev_class,
268
};