GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavdevice/xv.c Lines: 0 176 0.0 %
Date: 2020-10-23 17:01:47 Branches: 0 78 0.0 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2013 Jeff Moguillansky
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
/**
22
 * @file
23
 * XVideo output device
24
 *
25
 * TODO:
26
 * - add support to more formats
27
 */
28
29
#include <X11/Xlib.h>
30
#include <X11/extensions/Xv.h>
31
#include <X11/extensions/XShm.h>
32
#include <X11/extensions/Xvlib.h>
33
#include <sys/shm.h>
34
35
#include "libavutil/opt.h"
36
#include "libavutil/pixdesc.h"
37
#include "libavutil/imgutils.h"
38
#include "libavformat/internal.h"
39
#include "avdevice.h"
40
41
typedef struct {
42
    AVClass *class;
43
    GC gc;
44
45
    Window window;
46
    int64_t window_id;
47
    char *window_title;
48
    int window_width, window_height;
49
    int window_x, window_y;
50
    int dest_x, dest_y;          /**< display area position */
51
    unsigned int dest_w, dest_h; /**< display area dimensions */
52
53
    Display* display;
54
    char *display_name;
55
56
    XvImage* yuv_image;
57
    enum AVPixelFormat image_format;
58
    int image_width, image_height;
59
    XShmSegmentInfo yuv_shminfo;
60
    int xv_port;
61
    Atom wm_delete_message;
62
} XVContext;
63
64
typedef struct XVTagFormatMap
65
{
66
    int tag;
67
    enum AVPixelFormat format;
68
} XVTagFormatMap;
69
70
static const XVTagFormatMap tag_codec_map[] = {
71
    { MKTAG('I','4','2','0'), AV_PIX_FMT_YUV420P },
72
    { MKTAG('U','Y','V','Y'), AV_PIX_FMT_UYVY422 },
73
    { MKTAG('Y','U','Y','2'), AV_PIX_FMT_YUYV422 },
74
    { 0,                      AV_PIX_FMT_NONE }
75
};
76
77
static int xv_get_tag_from_format(enum AVPixelFormat format)
78
{
79
    const XVTagFormatMap *m = tag_codec_map;
80
    int i;
81
    for (i = 0; m->tag; m = &tag_codec_map[++i]) {
82
        if (m->format == format)
83
            return m->tag;
84
    }
85
    return 0;
86
}
87
88
static int xv_write_trailer(AVFormatContext *s)
89
{
90
    XVContext *xv = s->priv_data;
91
    if (xv->display) {
92
        XShmDetach(xv->display, &xv->yuv_shminfo);
93
        if (xv->yuv_image)
94
            shmdt(xv->yuv_image->data);
95
        XFree(xv->yuv_image);
96
        if (xv->gc)
97
            XFreeGC(xv->display, xv->gc);
98
        XCloseDisplay(xv->display);
99
    }
100
    return 0;
101
}
102
103
static int xv_write_header(AVFormatContext *s)
104
{
105
    XVContext *xv = s->priv_data;
106
    unsigned int num_adaptors;
107
    XvAdaptorInfo *ai;
108
    XvImageFormatValues *fv;
109
    XColor fgcolor;
110
    XWindowAttributes window_attrs;
111
    int num_formats = 0, j, tag, ret;
112
    AVCodecParameters *par = s->streams[0]->codecpar;
113
114
    if (   s->nb_streams > 1
115
        || par->codec_type != AVMEDIA_TYPE_VIDEO
116
        || (par->codec_id != AV_CODEC_ID_WRAPPED_AVFRAME && par->codec_id != AV_CODEC_ID_RAWVIDEO)) {
117
        av_log(s, AV_LOG_ERROR, "Only a single raw or wrapped avframe video stream is supported.\n");
118
        return AVERROR(EINVAL);
119
    }
120
121
    if (!(tag = xv_get_tag_from_format(par->format))) {
122
        av_log(s, AV_LOG_ERROR,
123
               "Unsupported pixel format '%s', only yuv420p, uyvy422, yuyv422 are currently supported\n",
124
               av_get_pix_fmt_name(par->format));
125
        return AVERROR_PATCHWELCOME;
126
    }
127
    xv->image_format = par->format;
128
129
    xv->display = XOpenDisplay(xv->display_name);
130
    if (!xv->display) {
131
        av_log(s, AV_LOG_ERROR, "Could not open the X11 display '%s'\n", xv->display_name);
132
        return AVERROR(EINVAL);
133
    }
134
135
    xv->image_width  = par->width;
136
    xv->image_height = par->height;
137
    if (!xv->window_width && !xv->window_height) {
138
        AVRational sar = par->sample_aspect_ratio;
139
        xv->window_width  = par->width;
140
        xv->window_height = par->height;
141
        if (sar.num) {
142
            if (sar.num > sar.den)
143
                xv->window_width = av_rescale(xv->window_width, sar.num, sar.den);
144
            if (sar.num < sar.den)
145
                xv->window_height = av_rescale(xv->window_height, sar.den, sar.num);
146
        }
147
    }
148
    if (!xv->window_id) {
149
        xv->window = XCreateSimpleWindow(xv->display, DefaultRootWindow(xv->display),
150
                                         xv->window_x, xv->window_y,
151
                                         xv->window_width, xv->window_height,
152
                                         0, 0, 0);
153
        if (!xv->window_title) {
154
            if (!(xv->window_title = av_strdup(s->url))) {
155
                ret = AVERROR(ENOMEM);
156
                goto fail;
157
            }
158
        }
159
        XStoreName(xv->display, xv->window, xv->window_title);
160
        xv->wm_delete_message = XInternAtom(xv->display, "WM_DELETE_WINDOW", False);
161
        XSetWMProtocols(xv->display, xv->window, &xv->wm_delete_message, 1);
162
        XMapWindow(xv->display, xv->window);
163
    } else
164
        xv->window = xv->window_id;
165
166
    if (XvQueryAdaptors(xv->display, DefaultRootWindow(xv->display), &num_adaptors, &ai) != Success) {
167
        ret = AVERROR_EXTERNAL;
168
        goto fail;
169
    }
170
    if (!num_adaptors) {
171
        av_log(s, AV_LOG_ERROR, "No X-Video adaptors present\n");
172
        return AVERROR(ENODEV);
173
    }
174
    xv->xv_port = ai[0].base_id;
175
    XvFreeAdaptorInfo(ai);
176
177
    fv = XvListImageFormats(xv->display, xv->xv_port, &num_formats);
178
    if (!fv) {
179
        ret = AVERROR_EXTERNAL;
180
        goto fail;
181
    }
182
    for (j = 0; j < num_formats; j++) {
183
        if (fv[j].id == tag) {
184
            break;
185
        }
186
    }
187
    XFree(fv);
188
189
    if (j >= num_formats) {
190
        av_log(s, AV_LOG_ERROR,
191
               "Device does not support pixel format %s, aborting\n",
192
               av_get_pix_fmt_name(par->format));
193
        ret = AVERROR(EINVAL);
194
        goto fail;
195
    }
196
197
    xv->gc = XCreateGC(xv->display, xv->window, 0, 0);
198
    xv->image_width  = par->width;
199
    xv->image_height = par->height;
200
    xv->yuv_image = XvShmCreateImage(xv->display, xv->xv_port, tag, 0,
201
                                     xv->image_width, xv->image_height, &xv->yuv_shminfo);
202
    xv->yuv_shminfo.shmid = shmget(IPC_PRIVATE, xv->yuv_image->data_size,
203
                                   IPC_CREAT | 0777);
204
    xv->yuv_shminfo.shmaddr = (char *)shmat(xv->yuv_shminfo.shmid, 0, 0);
205
    xv->yuv_image->data = xv->yuv_shminfo.shmaddr;
206
    xv->yuv_shminfo.readOnly = False;
207
208
    XShmAttach(xv->display, &xv->yuv_shminfo);
209
    XSync(xv->display, False);
210
    shmctl(xv->yuv_shminfo.shmid, IPC_RMID, 0);
211
212
    XGetWindowAttributes(xv->display, xv->window, &window_attrs);
213
    fgcolor.red = fgcolor.green = fgcolor.blue = 0;
214
    fgcolor.flags = DoRed | DoGreen | DoBlue;
215
    XAllocColor(xv->display, window_attrs.colormap, &fgcolor);
216
    XSetForeground(xv->display, xv->gc, fgcolor.pixel);
217
    //force display area recalculation at first frame
218
    xv->window_width = xv->window_height = 0;
219
220
    return 0;
221
  fail:
222
    xv_write_trailer(s);
223
    return ret;
224
}
225
226
static void compute_display_area(AVFormatContext *s)
227
{
228
    XVContext *xv = s->priv_data;
229
    AVRational sar, dar; /* sample and display aspect ratios */
230
    AVStream *st = s->streams[0];
231
    AVCodecParameters *par = st->codecpar;
232
233
    /* compute overlay width and height from the codec context information */
234
    sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
235
    dar = av_mul_q(sar, (AVRational){ par->width, par->height });
236
237
    /* we suppose the screen has a 1/1 sample aspect ratio */
238
    /* fit in the window */
239
    if (av_cmp_q(dar, (AVRational){ xv->dest_w, xv->dest_h }) > 0) {
240
        /* fit in width */
241
        xv->dest_y = xv->dest_h;
242
        xv->dest_x = 0;
243
        xv->dest_h = av_rescale(xv->dest_w, dar.den, dar.num);
244
        xv->dest_y -= xv->dest_h;
245
        xv->dest_y /= 2;
246
    } else {
247
        /* fit in height */
248
        xv->dest_x = xv->dest_w;
249
        xv->dest_y = 0;
250
        xv->dest_w = av_rescale(xv->dest_h, dar.num, dar.den);
251
        xv->dest_x -= xv->dest_w;
252
        xv->dest_x /= 2;
253
    }
254
}
255
256
static int xv_repaint(AVFormatContext *s)
257
{
258
    XVContext *xv = s->priv_data;
259
    XWindowAttributes window_attrs;
260
261
    XGetWindowAttributes(xv->display, xv->window, &window_attrs);
262
    if (window_attrs.width != xv->window_width || window_attrs.height != xv->window_height) {
263
        XRectangle rect[2];
264
        xv->dest_w = window_attrs.width;
265
        xv->dest_h = window_attrs.height;
266
        compute_display_area(s);
267
        if (xv->dest_x) {
268
            rect[0].width  = rect[1].width  = xv->dest_x;
269
            rect[0].height = rect[1].height = window_attrs.height;
270
            rect[0].y      = rect[1].y      = 0;
271
            rect[0].x = 0;
272
            rect[1].x = xv->dest_w + xv->dest_x;
273
            XFillRectangles(xv->display, xv->window, xv->gc, rect, 2);
274
        }
275
        if (xv->dest_y) {
276
            rect[0].width  = rect[1].width  = window_attrs.width;
277
            rect[0].height = rect[1].height = xv->dest_y;
278
            rect[0].x      = rect[1].x      = 0;
279
            rect[0].y = 0;
280
            rect[1].y = xv->dest_h + xv->dest_y;
281
            XFillRectangles(xv->display, xv->window, xv->gc, rect, 2);
282
        }
283
    }
284
285
    if (XvShmPutImage(xv->display, xv->xv_port, xv->window, xv->gc,
286
                      xv->yuv_image, 0, 0, xv->image_width, xv->image_height,
287
                      xv->dest_x, xv->dest_y, xv->dest_w, xv->dest_h, True) != Success) {
288
        av_log(s, AV_LOG_ERROR, "Could not copy image to XV shared memory buffer\n");
289
        return AVERROR_EXTERNAL;
290
    }
291
    return 0;
292
}
293
294
static int write_picture(AVFormatContext *s, uint8_t *input_data[4],
295
                         int linesize[4])
296
{
297
    XVContext *xv = s->priv_data;
298
    XvImage *img = xv->yuv_image;
299
    uint8_t *data[3] = {
300
        img->data + img->offsets[0],
301
        img->data + img->offsets[1],
302
        img->data + img->offsets[2]
303
    };
304
305
    /* Check messages. Window might get closed. */
306
    if (!xv->window_id) {
307
        XEvent event;
308
        while (XPending(xv->display)) {
309
            XNextEvent(xv->display, &event);
310
            if (event.type == ClientMessage && event.xclient.data.l[0] == xv->wm_delete_message) {
311
                av_log(xv, AV_LOG_DEBUG, "Window close event.\n");
312
                return AVERROR(EPIPE);
313
            }
314
        }
315
    }
316
317
    av_image_copy(data, img->pitches, (const uint8_t **)input_data, linesize,
318
                  xv->image_format, img->width, img->height);
319
    return xv_repaint(s);
320
}
321
322
static int xv_write_packet(AVFormatContext *s, AVPacket *pkt)
323
{
324
    AVCodecParameters *par = s->streams[0]->codecpar;
325
326
    if (par->codec_id == AV_CODEC_ID_WRAPPED_AVFRAME) {
327
        AVFrame *frame = (AVFrame *)pkt->data;
328
        return write_picture(s, frame->data, frame->linesize);
329
    } else {
330
        uint8_t *data[4];
331
        int linesize[4];
332
333
        av_image_fill_arrays(data, linesize, pkt->data, par->format,
334
                             par->width, par->height, 1);
335
        return write_picture(s, data, linesize);
336
    }
337
}
338
339
static int xv_write_frame(AVFormatContext *s, int stream_index, AVFrame **frame,
340
                          unsigned flags)
341
{
342
    /* xv_write_header() should have accepted only supported formats */
343
    if ((flags & AV_WRITE_UNCODED_FRAME_QUERY))
344
        return 0;
345
    return write_picture(s, (*frame)->data, (*frame)->linesize);
346
}
347
348
static int xv_control_message(AVFormatContext *s, int type, void *data, size_t data_size)
349
{
350
    switch(type) {
351
    case AV_APP_TO_DEV_WINDOW_REPAINT:
352
        return xv_repaint(s);
353
    default:
354
        break;
355
    }
356
    return AVERROR(ENOSYS);
357
}
358
359
#define OFFSET(x) offsetof(XVContext, x)
360
static const AVOption options[] = {
361
    { "display_name", "set display name",       OFFSET(display_name), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
362
    { "window_id",    "set existing window id", OFFSET(window_id),    AV_OPT_TYPE_INT64,  {.i64 = 0 }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
363
    { "window_size",  "set window forced size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
364
    { "window_title", "set window title",       OFFSET(window_title), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
365
    { "window_x",     "set window x offset",    OFFSET(window_x),     AV_OPT_TYPE_INT,    {.i64 = 0 }, -INT_MAX, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
366
    { "window_y",     "set window y offset",    OFFSET(window_y),     AV_OPT_TYPE_INT,    {.i64 = 0 }, -INT_MAX, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
367
    { NULL }
368
369
};
370
371
static const AVClass xv_class = {
372
    .class_name = "xvideo outdev",
373
    .item_name  = av_default_item_name,
374
    .option     = options,
375
    .version    = LIBAVUTIL_VERSION_INT,
376
    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT,
377
};
378
379
AVOutputFormat ff_xv_muxer = {
380
    .name           = "xv",
381
    .long_name      = NULL_IF_CONFIG_SMALL("XV (XVideo) output device"),
382
    .priv_data_size = sizeof(XVContext),
383
    .audio_codec    = AV_CODEC_ID_NONE,
384
    .video_codec    = AV_CODEC_ID_WRAPPED_AVFRAME,
385
    .write_header   = xv_write_header,
386
    .write_packet   = xv_write_packet,
387
    .write_uncoded_frame = xv_write_frame,
388
    .write_trailer  = xv_write_trailer,
389
    .control_message = xv_control_message,
390
    .flags          = AVFMT_NOFILE | AVFMT_VARIABLE_FPS | AVFMT_NOTIMESTAMPS,
391
    .priv_class     = &xv_class,
392
};