FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sdl2.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 Josh de Kock
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  * libSDL2 output device
24  */
25 
26 #include <SDL.h>
27 #include <SDL_thread.h>
28 
29 #include "libavutil/avstring.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/parseutils.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/time.h"
35 #include "avdevice.h"
36 
37 typedef struct {
38  AVClass *class;
39  SDL_Window *window;
40  SDL_Renderer *renderer;
41  char *window_title;
42  int window_width, window_height; /**< size of the window */
45 
46  SDL_Texture *texture;
48  SDL_Rect texture_rect;
49 
50  int inited;
51 } SDLContext;
52 
53 static const struct sdl_texture_format_entry {
56  /*
57  * Not implemented in FFmpeg, but leaving here for completeness.
58  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_ARGB4444 },
59  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_RGBA4444 },
60  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_ABGR4444 },
61  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_BGRA4444 },
62  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_ARGB1555 },
63  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_RGBA5551 },
64  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_ABGR1555 },
65  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_BGRA5551 },
66  * { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_ARGB2101010 },
67  */
68  { AV_PIX_FMT_RGB8, SDL_PIXELFORMAT_RGB332 },
69  { AV_PIX_FMT_RGB444, SDL_PIXELFORMAT_RGB444 },
70  { AV_PIX_FMT_RGB555, SDL_PIXELFORMAT_RGB555 },
71  { AV_PIX_FMT_BGR555, SDL_PIXELFORMAT_BGR555 },
72  { AV_PIX_FMT_RGB565, SDL_PIXELFORMAT_RGB565 },
73  { AV_PIX_FMT_BGR565, SDL_PIXELFORMAT_BGR565 },
74  { AV_PIX_FMT_RGB24, SDL_PIXELFORMAT_RGB24 },
75  { AV_PIX_FMT_BGR24, SDL_PIXELFORMAT_BGR24 },
76  { AV_PIX_FMT_0RGB32, SDL_PIXELFORMAT_RGB888 },
77  { AV_PIX_FMT_0BGR32, SDL_PIXELFORMAT_BGR888 },
78 #if HAVE_BIGENDIAN
79  { AV_PIX_FMT_RGB0, SDL_PIXELFORMAT_RGBX8888 },
80  { AV_PIX_FMT_BGR0, SDL_PIXELFORMAT_BGRX8888 },
81 #else
82  { AV_PIX_FMT_0BGR, SDL_PIXELFORMAT_RGBX8888 },
83  { AV_PIX_FMT_0RGB, SDL_PIXELFORMAT_BGRX8888 },
84 #endif
85  { AV_PIX_FMT_RGB32, SDL_PIXELFORMAT_ARGB8888 },
86  { AV_PIX_FMT_RGB32_1, SDL_PIXELFORMAT_RGBA8888 },
87  { AV_PIX_FMT_BGR32, SDL_PIXELFORMAT_ABGR8888 },
88  { AV_PIX_FMT_BGR32_1, SDL_PIXELFORMAT_BGRA8888 },
89  { AV_PIX_FMT_YUV420P, SDL_PIXELFORMAT_IYUV },
90  { AV_PIX_FMT_YUYV422, SDL_PIXELFORMAT_YUY2 },
91  { AV_PIX_FMT_UYVY422, SDL_PIXELFORMAT_UYVY },
92  { AV_PIX_FMT_NONE, 0 },
93 };
94 
96 {
97  AVRational sar, dar; /* sample and display aspect ratios */
98  SDLContext *sdl = s->priv_data;
99  AVStream *st = s->streams[0];
100  AVCodecParameters *codecpar = st->codecpar;
101  SDL_Rect *texture_rect = &sdl->texture_rect;
102 
103  /* compute texture width and height from the codec context information */
104  sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
105  dar = av_mul_q(sar, (AVRational){ codecpar->width, codecpar->height });
106 
107  /* we suppose the screen has a 1/1 sample aspect ratio */
108  if (sdl->window_width && sdl->window_height) {
109  /* fit in the window */
110  if (av_cmp_q(dar, (AVRational){ sdl->window_width, sdl->window_height }) > 0) {
111  /* fit in width */
112  texture_rect->w = sdl->window_width;
113  texture_rect->h = av_rescale(texture_rect->w, dar.den, dar.num);
114  } else {
115  /* fit in height */
116  texture_rect->h = sdl->window_height;
117  texture_rect->w = av_rescale(texture_rect->h, dar.num, dar.den);
118  }
119  } else {
120  if (sar.num > sar.den) {
121  texture_rect->w = codecpar->width;
122  texture_rect->h = av_rescale(texture_rect->w, dar.den, dar.num);
123  } else {
124  texture_rect->h = codecpar->height;
125  texture_rect->w = av_rescale(texture_rect->h, dar.num, dar.den);
126  }
127  sdl->window_width = texture_rect->w;
128  sdl->window_height = texture_rect->h;
129  }
130 
131  texture_rect->x = (sdl->window_width - texture_rect->w) / 2;
132  texture_rect->y = (sdl->window_height - texture_rect->h) / 2;
133 }
134 
136 {
137  SDLContext *sdl = s->priv_data;
138 
139  if (sdl->texture)
140  SDL_DestroyTexture(sdl->texture);
141  sdl->texture = NULL;
142 
143  if (sdl->renderer)
144  SDL_DestroyRenderer(sdl->renderer);
145  sdl->renderer = NULL;
146 
147  if (sdl->window)
148  SDL_DestroyWindow(sdl->window);
149  sdl->window = NULL;
150 
151  if (!sdl->inited)
152  SDL_Quit();
153 
154  return 0;
155 }
156 
157 #define SDL_BASE_FLAGS (SDL_SWSURFACE|SDL_WINDOW_RESIZABLE)
158 
160 {
161  SDLContext *sdl = s->priv_data;
162  AVStream *st = s->streams[0];
163  AVCodecParameters *codecpar = st->codecpar;
164  int i, ret = 0;
165  int flags = 0;
166 
167  if (!sdl->window_title)
168  sdl->window_title = av_strdup(s->filename);
169 
170  if (SDL_WasInit(SDL_INIT_VIDEO)) {
172  "SDL video subsystem was already inited, you could have multiple SDL outputs. This may cause unknown behaviour.\n");
173  sdl->inited = 1;
174  }
175 
176  if ( s->nb_streams > 1
177  || codecpar->codec_type != AVMEDIA_TYPE_VIDEO
178  || codecpar->codec_id != AV_CODEC_ID_RAWVIDEO) {
179  av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
180  goto fail;
181  }
182 
183  for (i = 0; sdl_texture_format_map[i].format != AV_PIX_FMT_NONE; i++) {
184  if (sdl_texture_format_map[i].format == codecpar->format) {
186  break;
187  }
188  }
189 
190  if (!sdl->texture_fmt) {
191  av_log(s, AV_LOG_ERROR,
192  "Unsupported pixel format '%s'.\n",
193  av_get_pix_fmt_name(codecpar->format));
194  goto fail;
195  }
196 
197  /* resize texture to width and height from the codec context information */
198  flags = SDL_BASE_FLAGS | (sdl->window_fullscreen ? SDL_WINDOW_FULLSCREEN : 0) |
199  (sdl->window_borderless ? SDL_WINDOW_BORDERLESS : 0);
200 
201  /* initialization */
202  if (!sdl->inited){
203  if (SDL_Init(SDL_INIT_VIDEO) != 0) {
204  av_log(s, AV_LOG_ERROR, "Unable to initialize SDL: %s\n", SDL_GetError());
205  goto fail;
206  }
207  }
208 
209  sdl->window_width = sdl->texture_rect.w = codecpar->width;
210  sdl->window_height = sdl->texture_rect.h = codecpar->height;
211  sdl->texture_rect.x = sdl->texture_rect.y = 0;
212 
213  if (SDL_CreateWindowAndRenderer(sdl->window_width, sdl->window_height,
214  flags, &sdl->window, &sdl->renderer) != 0){
215  av_log(sdl, AV_LOG_ERROR, "Couldn't create window and renderer: %s\n", SDL_GetError());
216  goto fail;
217  }
218 
219  SDL_SetWindowTitle(sdl->window, sdl->window_title);
220 
221  sdl->texture = SDL_CreateTexture(sdl->renderer, sdl->texture_fmt, SDL_TEXTUREACCESS_STREAMING,
222  sdl->window_width, sdl->window_height);
223 
224  if (!sdl->texture) {
225  av_log(sdl, AV_LOG_ERROR, "Unable to set create mode: %s\n", SDL_GetError());
226  goto fail;
227  }
228 
229  av_log(s, AV_LOG_VERBOSE, "w:%d h:%d fmt:%s -> w:%d h:%d\n",
230  codecpar->width, codecpar->height, av_get_pix_fmt_name(codecpar->format),
231  sdl->window_width, sdl->window_height);
232 
233  sdl->inited = 1;
234 
235  return 0;
236 fail:
238  return ret;
239 }
240 
242 {
243  int ret, quit = 0;
244  SDLContext *sdl = s->priv_data;
245  AVCodecParameters *codecpar = s->streams[0]->codecpar;
246  uint8_t *data[4];
247  int linesize[4];
248 
249  SDL_Event event;
250  if (SDL_PollEvent(&event)){
251  switch (event.type) {
252  case SDL_KEYDOWN:
253  switch (event.key.keysym.sym) {
254  case SDLK_ESCAPE:
255  case SDLK_q:
256  quit = 1;
257  break;
258  default:
259  break;
260  }
261  break;
262  case SDL_QUIT:
263  quit = 1;
264  break;
265  case SDL_WINDOWEVENT:
266  switch(event.window.event){
267  case SDL_WINDOWEVENT_RESIZED:
268  case SDL_WINDOWEVENT_SIZE_CHANGED:
269  sdl->window_width = event.window.data1;
270  sdl->window_height = event.window.data2;
272  break;
273  default:
274  break;
275  }
276  break;
277  default:
278  break;
279  }
280  }
281 
282  if (quit) {
284  return AVERROR(EIO);
285  }
286 
287  av_image_fill_arrays(data, linesize, pkt->data, codecpar->format, codecpar->width, codecpar->height, 1);
288  switch (sdl->texture_fmt) {
289  /* case SDL_PIXELFORMAT_ARGB4444:
290  * case SDL_PIXELFORMAT_RGBA4444:
291  * case SDL_PIXELFORMAT_ABGR4444:
292  * case SDL_PIXELFORMAT_BGRA4444:
293  * case SDL_PIXELFORMAT_ARGB1555:
294  * case SDL_PIXELFORMAT_RGBA5551:
295  * case SDL_PIXELFORMAT_ABGR1555:
296  * case SDL_PIXELFORMAT_BGRA5551:
297  * case SDL_PIXELFORMAT_ARGB2101010:
298  */
299  case SDL_PIXELFORMAT_IYUV:
300  case SDL_PIXELFORMAT_YUY2:
301  case SDL_PIXELFORMAT_UYVY:
302  ret = SDL_UpdateYUVTexture(sdl->texture, NULL,
303  data[0], linesize[0],
304  data[1], linesize[1],
305  data[2], linesize[2]);
306  break;
307  case SDL_PIXELFORMAT_RGB332:
308  case SDL_PIXELFORMAT_RGB444:
309  case SDL_PIXELFORMAT_RGB555:
310  case SDL_PIXELFORMAT_BGR555:
311  case SDL_PIXELFORMAT_RGB565:
312  case SDL_PIXELFORMAT_BGR565:
313  case SDL_PIXELFORMAT_RGB24:
314  case SDL_PIXELFORMAT_BGR24:
315  case SDL_PIXELFORMAT_RGB888:
316  case SDL_PIXELFORMAT_RGBX8888:
317  case SDL_PIXELFORMAT_BGR888:
318  case SDL_PIXELFORMAT_BGRX8888:
319  case SDL_PIXELFORMAT_ARGB8888:
320  case SDL_PIXELFORMAT_RGBA8888:
321  case SDL_PIXELFORMAT_ABGR8888:
322  case SDL_PIXELFORMAT_BGRA8888:
323  ret = SDL_UpdateTexture(sdl->texture, NULL, data[0], linesize[0]);
324  break;
325  default:
326  av_log(NULL, AV_LOG_FATAL, "Unsupported pixel format\n");
327  ret = -1;
328  break;
329  }
330  SDL_RenderClear(sdl->renderer);
331  SDL_RenderCopy(sdl->renderer, sdl->texture, NULL, &sdl->texture_rect);
332  SDL_RenderPresent(sdl->renderer);
333  return ret;
334 }
335 
336 #define OFFSET(x) offsetof(SDLContext,x)
337 
338 static const AVOption options[] = {
339  { "window_title", "set SDL window title", OFFSET(window_title), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
340  { "window_size", "set SDL window forced size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
341  { "window_fullscreen", "set SDL window fullscreen", OFFSET(window_fullscreen), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
342  { "window_borderless", "set SDL window border off", OFFSET(window_borderless), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
343  { NULL },
344 };
345 
346 static const AVClass sdl2_class = {
347  .class_name = "sdl2 outdev",
348  .item_name = av_default_item_name,
349  .option = options,
350  .version = LIBAVUTIL_VERSION_INT,
352 };
353 
355  .name = "sdl,sdl2",
356  .long_name = NULL_IF_CONFIG_SMALL("SDL2 output device"),
357  .priv_data_size = sizeof(SDLContext),
358  .audio_codec = AV_CODEC_ID_NONE,
359  .video_codec = AV_CODEC_ID_RAWVIDEO,
364  .priv_class = &sdl2_class,
365 };
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:82
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:672
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
int texture_fmt
Definition: sdl2.c:54
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:64
static int sdl2_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: sdl2.c:241
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4066
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:959
int num
Numerator.
Definition: rational.h:59
static int sdl2_write_header(AVFormatContext *s)
Definition: sdl2.c:159
int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], const uint8_t *src, enum AVPixelFormat pix_fmt, int width, int height, int align)
Setup the data pointers and linesizes based on the specified image parameters and the provided array...
Definition: imgutils.c:409
#define SDL_BASE_FLAGS
Definition: sdl2.c:157
static int sdl2_write_trailer(AVFormatContext *s)
Definition: sdl2.c:135
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:253
static AVPacket pkt
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:340
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4058
Format I/O context.
Definition: avformat.h:1349
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
int window_fullscreen
Definition: sdl2.c:43
uint8_t
SDL_Renderer * renderer
Definition: sdl2.c:40
int width
Video only.
Definition: avcodec.h:4132
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:252
AVOptions.
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1417
uint8_t * data
Definition: avcodec.h:1657
static int flags
Definition: log.c:57
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
SDL_Window * window
Definition: sdl2.c:39
Main libavdevice API header.
static void compute_texture_rect(AVFormatContext *s)
Definition: sdl2.c:95
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:329
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
static const AVOption options[]
Definition: sdl2.c:338
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4062
#define AV_PIX_FMT_0BGR32
Definition: pixfmt.h:331
#define OFFSET(x)
Definition: sdl2.c:336
#define fail()
Definition: checkasm.h:89
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1405
SDL_Rect texture_rect
Definition: sdl2.c:48
enum AVPixelFormat format
Definition: sdl2.c:54
char filename[1024]
input or output filename
Definition: avformat.h:1425
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
const char * name
Definition: avformat.h:524
int window_height
size of the window
Definition: sdl2.c:42
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:65
static const AVClass sdl2_class
Definition: sdl2.c:346
Definition: sdl2.c:53
int inited
Definition: sdl2.c:50
SDL_Texture * texture
Definition: sdl2.c:46
Stream structure.
Definition: avformat.h:889
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:486
AVOutputFormat ff_sdl2_muxer
Definition: sdl2.c:354
int window_width
Definition: sdl2.c:42
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:344
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:328
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:237
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:326
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:63
static const char * window_title
Definition: ffplay.c:313
static const char * format
Definition: movenc.c:47
Describe the class of an AVClass context structure.
Definition: log.h:67
int window_borderless
Definition: sdl2.c:44
Rational number (pair of numerator and denominator).
Definition: rational.h:58
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:254
offset must point to two consecutive integers
Definition: opt.h:233
misc parsing utilities
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:343
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:478
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:87
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:339
int den
Denominator.
Definition: rational.h:60
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:489
char * window_title
Definition: sdl2.c:41
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:327
void * priv_data
Format private data.
Definition: avformat.h:1377
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:338
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
static const struct sdl_texture_format_entry sdl_texture_format_map[]
int texture_fmt
Definition: sdl2.c:47
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:170
AVCodecParameters * codecpar
Definition: avformat.h:1252
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:2249
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:251
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1634
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:330