blob: 4cccfe528a8f9de2ca3908f3c1952872cdfe14af [file] [log] [blame]
Nest DevInfra8e1cc552016-03-17 14:59:01 -07001/*
2 * Copyright (c) 2011 Stefano Sabatini
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 * libSDL 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
37typedef struct {
38 AVClass *class;
39 SDL_Surface *surface;
40 SDL_Overlay *overlay;
41 char *window_title;
42 char *icon_title;
43 int window_width, window_height; /**< size of the window */
44 int window_fullscreen;
45
46 SDL_Rect overlay_rect;
47 int overlay_fmt;
48
49 int sdl_was_already_inited;
50 SDL_Thread *event_thread;
51 SDL_mutex *mutex;
52 SDL_cond *init_cond;
53 int init_ret; /* return code used to signal initialization errors */
54 int inited;
55 int quit;
56} SDLContext;
57
58static const struct sdl_overlay_pix_fmt_entry {
59 enum AVPixelFormat pix_fmt; int overlay_fmt;
60} sdl_overlay_pix_fmt_map[] = {
61 { AV_PIX_FMT_YUV420P, SDL_IYUV_OVERLAY },
62 { AV_PIX_FMT_YUYV422, SDL_YUY2_OVERLAY },
63 { AV_PIX_FMT_UYVY422, SDL_UYVY_OVERLAY },
64 { AV_PIX_FMT_NONE, 0 },
65};
66
67static int sdl_write_trailer(AVFormatContext *s)
68{
69 SDLContext *sdl = s->priv_data;
70
71 sdl->quit = 1;
72
73 if (sdl->overlay)
74 SDL_FreeYUVOverlay(sdl->overlay);
75 sdl->overlay = NULL;
76 if (sdl->event_thread)
77 SDL_WaitThread(sdl->event_thread, NULL);
78 sdl->event_thread = NULL;
79 if (sdl->mutex)
80 SDL_DestroyMutex(sdl->mutex);
81 sdl->mutex = NULL;
82 if (sdl->init_cond)
83 SDL_DestroyCond(sdl->init_cond);
84 sdl->init_cond = NULL;
85
86 if (!sdl->sdl_was_already_inited)
87 SDL_Quit();
88
89 return 0;
90}
91
92static void compute_overlay_rect(AVFormatContext *s)
93{
94 AVRational sar, dar; /* sample and display aspect ratios */
95 SDLContext *sdl = s->priv_data;
96 AVStream *st = s->streams[0];
97 AVCodecContext *encctx = st->codec;
98 SDL_Rect *overlay_rect = &sdl->overlay_rect;
99
100 /* compute overlay width and height from the codec context information */
101 sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
102 dar = av_mul_q(sar, (AVRational){ encctx->width, encctx->height });
103
104 /* we suppose the screen has a 1/1 sample aspect ratio */
105 if (sdl->window_width && sdl->window_height) {
106 /* fit in the window */
107 if (av_cmp_q(dar, (AVRational){ sdl->window_width, sdl->window_height }) > 0) {
108 /* fit in width */
109 overlay_rect->w = sdl->window_width;
110 overlay_rect->h = av_rescale(overlay_rect->w, dar.den, dar.num);
111 } else {
112 /* fit in height */
113 overlay_rect->h = sdl->window_height;
114 overlay_rect->w = av_rescale(overlay_rect->h, dar.num, dar.den);
115 }
116 } else {
117 if (sar.num > sar.den) {
118 overlay_rect->w = encctx->width;
119 overlay_rect->h = av_rescale(overlay_rect->w, dar.den, dar.num);
120 } else {
121 overlay_rect->h = encctx->height;
122 overlay_rect->w = av_rescale(overlay_rect->h, dar.num, dar.den);
123 }
124 sdl->window_width = overlay_rect->w;
125 sdl->window_height = overlay_rect->h;
126 }
127
128 overlay_rect->x = (sdl->window_width - overlay_rect->w) / 2;
129 overlay_rect->y = (sdl->window_height - overlay_rect->h) / 2;
130}
131
132#define SDL_BASE_FLAGS (SDL_SWSURFACE|SDL_RESIZABLE)
133
134static int event_thread(void *arg)
135{
136 AVFormatContext *s = arg;
137 SDLContext *sdl = s->priv_data;
138 int flags = SDL_BASE_FLAGS | (sdl->window_fullscreen ? SDL_FULLSCREEN : 0);
139 AVStream *st = s->streams[0];
140 AVCodecContext *encctx = st->codec;
141
142 /* initialization */
143 if (SDL_Init(SDL_INIT_VIDEO) != 0) {
144 av_log(s, AV_LOG_ERROR, "Unable to initialize SDL: %s\n", SDL_GetError());
145 sdl->init_ret = AVERROR(EINVAL);
146 goto init_end;
147 }
148
149 SDL_WM_SetCaption(sdl->window_title, sdl->icon_title);
150 sdl->surface = SDL_SetVideoMode(sdl->window_width, sdl->window_height,
151 24, flags);
152 if (!sdl->surface) {
153 av_log(sdl, AV_LOG_ERROR, "Unable to set video mode: %s\n", SDL_GetError());
154 sdl->init_ret = AVERROR(EINVAL);
155 goto init_end;
156 }
157
158 sdl->overlay = SDL_CreateYUVOverlay(encctx->width, encctx->height,
159 sdl->overlay_fmt, sdl->surface);
160 if (!sdl->overlay || sdl->overlay->pitches[0] < encctx->width) {
161 av_log(s, AV_LOG_ERROR,
162 "SDL does not support an overlay with size of %dx%d pixels\n",
163 encctx->width, encctx->height);
164 sdl->init_ret = AVERROR(EINVAL);
165 goto init_end;
166 }
167
168 sdl->init_ret = 0;
169 av_log(s, AV_LOG_VERBOSE, "w:%d h:%d fmt:%s -> w:%d h:%d\n",
170 encctx->width, encctx->height, av_get_pix_fmt_name(encctx->pix_fmt),
171 sdl->overlay_rect.w, sdl->overlay_rect.h);
172
173init_end:
174 SDL_LockMutex(sdl->mutex);
175 sdl->inited = 1;
176 SDL_UnlockMutex(sdl->mutex);
177 SDL_CondSignal(sdl->init_cond);
178
179 if (sdl->init_ret < 0)
180 return sdl->init_ret;
181
182 /* event loop */
183 while (!sdl->quit) {
184 int ret;
185 SDL_Event event;
186 SDL_PumpEvents();
187 ret = SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_ALLEVENTS);
188 if (ret < 0) {
189 av_log(s, AV_LOG_ERROR, "Error when getting SDL event: %s\n", SDL_GetError());
190 continue;
191 }
192 if (ret == 0) {
193 SDL_Delay(10);
194 continue;
195 }
196
197 switch (event.type) {
198 case SDL_KEYDOWN:
199 switch (event.key.keysym.sym) {
200 case SDLK_ESCAPE:
201 case SDLK_q:
202 sdl->quit = 1;
203 break;
204 }
205 break;
206 case SDL_QUIT:
207 sdl->quit = 1;
208 break;
209
210 case SDL_VIDEORESIZE:
211 sdl->window_width = event.resize.w;
212 sdl->window_height = event.resize.h;
213
214 SDL_LockMutex(sdl->mutex);
215 sdl->surface = SDL_SetVideoMode(sdl->window_width, sdl->window_height, 24, SDL_BASE_FLAGS);
216 if (!sdl->surface) {
217 av_log(s, AV_LOG_ERROR, "Failed to set SDL video mode: %s\n", SDL_GetError());
218 sdl->quit = 1;
219 } else {
220 compute_overlay_rect(s);
221 }
222 SDL_UnlockMutex(sdl->mutex);
223 break;
224
225 default:
226 break;
227 }
228 }
229
230 return 0;
231}
232
233static int sdl_write_header(AVFormatContext *s)
234{
235 SDLContext *sdl = s->priv_data;
236 AVStream *st = s->streams[0];
237 AVCodecContext *encctx = st->codec;
238 int i, ret;
239
240 if (!sdl->window_title)
241 sdl->window_title = av_strdup(s->filename);
242 if (!sdl->icon_title)
243 sdl->icon_title = av_strdup(sdl->window_title);
244
245 if (SDL_WasInit(SDL_INIT_VIDEO)) {
246 av_log(s, AV_LOG_ERROR,
247 "SDL video subsystem was already inited, aborting\n");
248 sdl->sdl_was_already_inited = 1;
249 ret = AVERROR(EINVAL);
250 goto fail;
251 }
252
253 if ( s->nb_streams > 1
254 || encctx->codec_type != AVMEDIA_TYPE_VIDEO
255 || encctx->codec_id != AV_CODEC_ID_RAWVIDEO) {
256 av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
257 ret = AVERROR(EINVAL);
258 goto fail;
259 }
260
261 for (i = 0; sdl_overlay_pix_fmt_map[i].pix_fmt != AV_PIX_FMT_NONE; i++) {
262 if (sdl_overlay_pix_fmt_map[i].pix_fmt == encctx->pix_fmt) {
263 sdl->overlay_fmt = sdl_overlay_pix_fmt_map[i].overlay_fmt;
264 break;
265 }
266 }
267
268 if (!sdl->overlay_fmt) {
269 av_log(s, AV_LOG_ERROR,
270 "Unsupported pixel format '%s', choose one of yuv420p, yuyv422, or uyvy422\n",
271 av_get_pix_fmt_name(encctx->pix_fmt));
272 ret = AVERROR(EINVAL);
273 goto fail;
274 }
275
276 /* compute overlay width and height from the codec context information */
277 compute_overlay_rect(s);
278
279 sdl->init_cond = SDL_CreateCond();
280 if (!sdl->init_cond) {
281 av_log(s, AV_LOG_ERROR, "Could not create SDL condition variable: %s\n", SDL_GetError());
282 ret = AVERROR_EXTERNAL;
283 goto fail;
284 }
285 sdl->mutex = SDL_CreateMutex();
286 if (!sdl->mutex) {
287 av_log(s, AV_LOG_ERROR, "Could not create SDL mutex: %s\n", SDL_GetError());
288 ret = AVERROR_EXTERNAL;
289 goto fail;
290 }
291 sdl->event_thread = SDL_CreateThread(event_thread, s);
292 if (!sdl->event_thread) {
293 av_log(s, AV_LOG_ERROR, "Could not create SDL event thread: %s\n", SDL_GetError());
294 ret = AVERROR_EXTERNAL;
295 goto fail;
296 }
297
298 /* wait until the video system has been inited */
299 SDL_LockMutex(sdl->mutex);
300 while (!sdl->inited) {
301 SDL_CondWait(sdl->init_cond, sdl->mutex);
302 }
303 SDL_UnlockMutex(sdl->mutex);
304 if (sdl->init_ret < 0) {
305 ret = sdl->init_ret;
306 goto fail;
307 }
308 return 0;
309
310fail:
311 sdl_write_trailer(s);
312 return ret;
313}
314
315static int sdl_write_packet(AVFormatContext *s, AVPacket *pkt)
316{
317 SDLContext *sdl = s->priv_data;
318 AVCodecContext *encctx = s->streams[0]->codec;
319 uint8_t *data[4];
320 int linesize[4];
321 int i;
322
323 if (sdl->quit) {
324 sdl_write_trailer(s);
325 return AVERROR(EIO);
326 }
327 av_image_fill_arrays(data, linesize, pkt->data, encctx->pix_fmt, encctx->width, encctx->height, 1);
328
329 SDL_LockMutex(sdl->mutex);
330 SDL_FillRect(sdl->surface, &sdl->surface->clip_rect,
331 SDL_MapRGB(sdl->surface->format, 0, 0, 0));
332 SDL_LockYUVOverlay(sdl->overlay);
333 for (i = 0; i < 3; i++) {
334 sdl->overlay->pixels [i] = data [i];
335 sdl->overlay->pitches[i] = linesize[i];
336 }
337 SDL_DisplayYUVOverlay(sdl->overlay, &sdl->overlay_rect);
338 SDL_UnlockYUVOverlay(sdl->overlay);
339
340 SDL_UpdateRect(sdl->surface,
341 sdl->overlay_rect.x, sdl->overlay_rect.y,
342 sdl->overlay_rect.w, sdl->overlay_rect.h);
343 SDL_UnlockMutex(sdl->mutex);
344
345 return 0;
346}
347
348#define OFFSET(x) offsetof(SDLContext,x)
349
350static const AVOption options[] = {
351 { "window_title", "set SDL window title", OFFSET(window_title), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
352 { "icon_title", "set SDL iconified window title", OFFSET(icon_title) , AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
353 { "window_size", "set SDL window forced size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
354 { "window_fullscreen", "set SDL window fullscreen", OFFSET(window_fullscreen), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
355 { NULL },
356};
357
358static const AVClass sdl_class = {
359 .class_name = "sdl outdev",
360 .item_name = av_default_item_name,
361 .option = options,
362 .version = LIBAVUTIL_VERSION_INT,
363 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT,
364};
365
366AVOutputFormat ff_sdl_muxer = {
367 .name = "sdl",
368 .long_name = NULL_IF_CONFIG_SMALL("SDL output device"),
369 .priv_data_size = sizeof(SDLContext),
370 .audio_codec = AV_CODEC_ID_NONE,
371 .video_codec = AV_CODEC_ID_RAWVIDEO,
372 .write_header = sdl_write_header,
373 .write_packet = sdl_write_packet,
374 .write_trailer = sdl_write_trailer,
375 .flags = AVFMT_NOFILE | AVFMT_VARIABLE_FPS | AVFMT_NOTIMESTAMPS,
376 .priv_class = &sdl_class,
377};