2 * Copyright (c) 2003 Fabrice Bellard
4 * This file is part of FFmpeg.
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.
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.
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
23 * simple media player based on the FFmpeg libraries
31 #include "libavutil/avstring.h"
32 #include "libavutil/colorspace.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/imgutils.h"
36 #include "libavutil/dict.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/avassert.h"
40 #include "libavutil/time.h"
41 #include "libavformat/avformat.h"
42 #include "libavdevice/avdevice.h"
43 #include "libswscale/swscale.h"
44 #include "libavutil/opt.h"
45 #include "libavcodec/avfft.h"
46 #include "libswresample/swresample.h"
49 # include "libavfilter/avcodec.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/buffersink.h"
52 # include "libavfilter/buffersrc.h"
56 #include <SDL_thread.h>
62 const char program_name[] = "ffplay";
63 const int program_birth_year = 2003;
65 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
68 /* SDL audio buffer size, in samples. Should be small to have precise
69 A/V sync as SDL does not have hardware buffer fullness info. */
70 #define SDL_AUDIO_BUFFER_SIZE 1024
72 /* no AV sync correction is done if below the minimum AV sync threshold */
73 #define AV_SYNC_THRESHOLD_MIN 0.01
74 /* AV sync correction is done if above the maximum AV sync threshold */
75 #define AV_SYNC_THRESHOLD_MAX 0.1
76 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
77 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
78 /* no AV correction is done if too big error */
79 #define AV_NOSYNC_THRESHOLD 10.0
81 /* maximum audio speed change to get correct sync */
82 #define SAMPLE_CORRECTION_PERCENT_MAX 10
84 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
85 #define EXTERNAL_CLOCK_SPEED_MIN 0.900
86 #define EXTERNAL_CLOCK_SPEED_MAX 1.010
87 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
89 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
90 #define AUDIO_DIFF_AVG_NB 20
92 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
93 #define REFRESH_RATE 0.01
95 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
96 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
97 #define SAMPLE_ARRAY_SIZE (8 * 65536)
99 #define CURSOR_HIDE_DELAY 1000000
101 static int64_t sws_flags = SWS_BICUBIC;
103 typedef struct MyAVPacketList {
105 struct MyAVPacketList *next;
109 typedef struct PacketQueue {
110 MyAVPacketList *first_pkt, *last_pkt;
119 #define VIDEO_PICTURE_QUEUE_SIZE 3
120 #define SUBPICTURE_QUEUE_SIZE 4
122 typedef struct VideoPicture {
123 double pts; // presentation timestamp for this picture
124 int64_t pos; // byte position in file
126 int width, height; /* source height & width */
134 typedef struct SubPicture {
135 double pts; /* presentation time stamp for this picture */
140 typedef struct AudioParams {
143 int64_t channel_layout;
144 enum AVSampleFormat fmt;
147 typedef struct Clock {
148 double pts; /* clock base */
149 double pts_drift; /* clock base minus time at which we updated the clock */
152 int serial; /* clock is based on a packet with this serial */
154 int *queue_serial; /* pointer to the current packet queue serial, used for obsolete clock detection */
158 AV_SYNC_AUDIO_MASTER, /* default choice */
159 AV_SYNC_VIDEO_MASTER,
160 AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
163 typedef struct VideoState {
164 SDL_Thread *read_tid;
165 SDL_Thread *video_tid;
166 AVInputFormat *iformat;
172 int queue_attachments_req;
177 int read_pause_return;
192 int audio_clock_serial;
193 double audio_diff_cum; /* used for AV difference average computation */
194 double audio_diff_avg_coef;
195 double audio_diff_threshold;
196 int audio_diff_avg_count;
199 int audio_hw_buf_size;
200 uint8_t silence_buf[SDL_AUDIO_BUFFER_SIZE];
203 unsigned int audio_buf_size; /* in bytes */
204 unsigned int audio_buf1_size;
205 int audio_buf_index; /* in bytes */
206 int audio_write_buf_size;
207 int audio_buf_frames_pending;
208 AVPacket audio_pkt_temp;
210 int audio_pkt_temp_serial;
211 int audio_last_serial;
212 struct AudioParams audio_src;
214 struct AudioParams audio_filter_src;
216 struct AudioParams audio_tgt;
217 struct SwrContext *swr_ctx;
218 int frame_drops_early;
219 int frame_drops_late;
221 int64_t audio_frame_next_pts;
224 SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
226 int16_t sample_array[SAMPLE_ARRAY_SIZE];
227 int sample_array_index;
231 FFTSample *rdft_data;
233 double last_vis_time;
235 SDL_Thread *subtitle_tid;
237 AVStream *subtitle_st;
238 PacketQueue subtitleq;
239 SubPicture subpq[SUBPICTURE_QUEUE_SIZE];
240 int subpq_size, subpq_rindex, subpq_windex;
241 SDL_mutex *subpq_mutex;
242 SDL_cond *subpq_cond;
245 double frame_last_pts;
246 double frame_last_duration;
247 double frame_last_dropped_pts;
248 double frame_last_returned_time;
249 double frame_last_filter_delay;
250 int64_t frame_last_dropped_pos;
251 int frame_last_dropped_serial;
255 int64_t video_current_pos; // current displayed file pos
256 double max_frame_duration; // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
257 VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
258 int pictq_size, pictq_rindex, pictq_windex;
259 SDL_mutex *pictq_mutex;
260 SDL_cond *pictq_cond;
262 struct SwsContext *img_convert_ctx;
264 SDL_Rect last_display_rect;
267 int width, height, xleft, ytop;
271 AVFilterContext *in_video_filter; // the first filter in the video chain
272 AVFilterContext *out_video_filter; // the last filter in the video chain
273 AVFilterContext *in_audio_filter; // the first filter in the audio chain
274 AVFilterContext *out_audio_filter; // the last filter in the audio chain
275 AVFilterGraph *agraph; // audio filter graph
278 int last_video_stream, last_audio_stream, last_subtitle_stream;
280 SDL_cond *continue_read_thread;
283 /* options specified by the user */
284 static AVInputFormat *file_iformat;
285 static const char *input_filename;
286 static const char *window_title;
287 static int fs_screen_width;
288 static int fs_screen_height;
289 static int default_width = 640;
290 static int default_height = 480;
291 static int screen_width = 0;
292 static int screen_height = 0;
293 static int audio_disable;
294 static int video_disable;
295 static int subtitle_disable;
296 static int wanted_stream[AVMEDIA_TYPE_NB] = {
297 [AVMEDIA_TYPE_AUDIO] = -1,
298 [AVMEDIA_TYPE_VIDEO] = -1,
299 [AVMEDIA_TYPE_SUBTITLE] = -1,
301 static int seek_by_bytes = -1;
302 static int display_disable;
303 static int show_status = 1;
304 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
305 static int64_t start_time = AV_NOPTS_VALUE;
306 static int64_t duration = AV_NOPTS_VALUE;
307 static int workaround_bugs = 1;
309 static int genpts = 0;
310 static int lowres = 0;
311 static int error_concealment = 3;
312 static int decoder_reorder_pts = -1;
314 static int exit_on_keydown;
315 static int exit_on_mousedown;
317 static int framedrop = -1;
318 static int infinite_buffer = -1;
319 static enum ShowMode show_mode = SHOW_MODE_NONE;
320 static const char *audio_codec_name;
321 static const char *subtitle_codec_name;
322 static const char *video_codec_name;
323 double rdftspeed = 0.02;
324 static int64_t cursor_last_shown;
325 static int cursor_hidden = 0;
327 static char *vfilters = NULL;
328 static char *afilters = NULL;
331 /* current context */
332 static int is_full_screen;
333 static int64_t audio_callback_time;
335 static AVPacket flush_pkt;
337 #define FF_ALLOC_EVENT (SDL_USEREVENT)
338 #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
340 static SDL_Surface *screen;
343 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
344 enum AVSampleFormat fmt2, int64_t channel_count2)
346 /* If channel count == 1, planar and non-planar formats are the same */
347 if (channel_count1 == 1 && channel_count2 == 1)
348 return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
350 return channel_count1 != channel_count2 || fmt1 != fmt2;
354 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
356 if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
357 return channel_layout;
362 static int packet_queue_put(PacketQueue *q, AVPacket *pkt);
364 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
366 MyAVPacketList *pkt1;
368 if (q->abort_request)
371 pkt1 = av_malloc(sizeof(MyAVPacketList));
376 if (pkt == &flush_pkt)
378 pkt1->serial = q->serial;
383 q->last_pkt->next = pkt1;
386 q->size += pkt1->pkt.size + sizeof(*pkt1);
387 /* XXX: should duplicate packet data in DV case */
388 SDL_CondSignal(q->cond);
392 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
396 /* duplicate the packet */
397 if (pkt != &flush_pkt && av_dup_packet(pkt) < 0)
400 SDL_LockMutex(q->mutex);
401 ret = packet_queue_put_private(q, pkt);
402 SDL_UnlockMutex(q->mutex);
404 if (pkt != &flush_pkt && ret < 0)
410 static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
412 AVPacket pkt1, *pkt = &pkt1;
416 pkt->stream_index = stream_index;
417 return packet_queue_put(q, pkt);
420 /* packet queue handling */
421 static void packet_queue_init(PacketQueue *q)
423 memset(q, 0, sizeof(PacketQueue));
424 q->mutex = SDL_CreateMutex();
425 q->cond = SDL_CreateCond();
426 q->abort_request = 1;
429 static void packet_queue_flush(PacketQueue *q)
431 MyAVPacketList *pkt, *pkt1;
433 SDL_LockMutex(q->mutex);
434 for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
436 av_free_packet(&pkt->pkt);
443 SDL_UnlockMutex(q->mutex);
446 static void packet_queue_destroy(PacketQueue *q)
448 packet_queue_flush(q);
449 SDL_DestroyMutex(q->mutex);
450 SDL_DestroyCond(q->cond);
453 static void packet_queue_abort(PacketQueue *q)
455 SDL_LockMutex(q->mutex);
457 q->abort_request = 1;
459 SDL_CondSignal(q->cond);
461 SDL_UnlockMutex(q->mutex);
464 static void packet_queue_start(PacketQueue *q)
466 SDL_LockMutex(q->mutex);
467 q->abort_request = 0;
468 packet_queue_put_private(q, &flush_pkt);
469 SDL_UnlockMutex(q->mutex);
472 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
473 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
475 MyAVPacketList *pkt1;
478 SDL_LockMutex(q->mutex);
481 if (q->abort_request) {
488 q->first_pkt = pkt1->next;
492 q->size -= pkt1->pkt.size + sizeof(*pkt1);
495 *serial = pkt1->serial;
503 SDL_CondWait(q->cond, q->mutex);
506 SDL_UnlockMutex(q->mutex);
510 static inline void fill_rectangle(SDL_Surface *screen,
511 int x, int y, int w, int h, int color, int update)
518 SDL_FillRect(screen, &rect, color);
519 if (update && w > 0 && h > 0)
520 SDL_UpdateRect(screen, x, y, w, h);
523 /* draw only the border of a rectangle */
524 static void fill_border(int xleft, int ytop, int width, int height, int x, int y, int w, int h, int color, int update)
528 /* fill the background */
532 w2 = width - (x + w);
538 h2 = height - (y + h);
541 fill_rectangle(screen,
545 fill_rectangle(screen,
546 xleft + width - w2, ytop,
549 fill_rectangle(screen,
553 fill_rectangle(screen,
554 xleft + w1, ytop + height - h2,
559 #define ALPHA_BLEND(a, oldp, newp, s)\
560 ((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
562 #define RGBA_IN(r, g, b, a, s)\
564 unsigned int v = ((const uint32_t *)(s))[0];\
565 a = (v >> 24) & 0xff;\
566 r = (v >> 16) & 0xff;\
567 g = (v >> 8) & 0xff;\
571 #define YUVA_IN(y, u, v, a, s, pal)\
573 unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
574 a = (val >> 24) & 0xff;\
575 y = (val >> 16) & 0xff;\
576 u = (val >> 8) & 0xff;\
580 #define YUVA_OUT(d, y, u, v, a)\
582 ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
588 static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh)
590 int wrap, wrap3, width2, skip2;
591 int y, u, v, a, u1, v1, a1, w, h;
592 uint8_t *lum, *cb, *cr;
595 int dstx, dsty, dstw, dsth;
597 dstw = av_clip(rect->w, 0, imgw);
598 dsth = av_clip(rect->h, 0, imgh);
599 dstx = av_clip(rect->x, 0, imgw - dstw);
600 dsty = av_clip(rect->y, 0, imgh - dsth);
601 lum = dst->data[0] + dsty * dst->linesize[0];
602 cb = dst->data[1] + (dsty >> 1) * dst->linesize[1];
603 cr = dst->data[2] + (dsty >> 1) * dst->linesize[2];
605 width2 = ((dstw + 1) >> 1) + (dstx & ~dstw & 1);
607 wrap = dst->linesize[0];
608 wrap3 = rect->pict.linesize[0];
609 p = rect->pict.data[0];
610 pal = (const uint32_t *)rect->pict.data[1]; /* Now in YCrCb! */
618 YUVA_IN(y, u, v, a, p, pal);
619 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
620 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
621 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
627 for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
628 YUVA_IN(y, u, v, a, p, pal);
632 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
634 YUVA_IN(y, u, v, a, p + BPP, pal);
638 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
639 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
640 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
647 YUVA_IN(y, u, v, a, p, pal);
648 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
649 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
650 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
654 p += wrap3 - dstw * BPP;
655 lum += wrap - dstw - dstx;
656 cb += dst->linesize[1] - width2 - skip2;
657 cr += dst->linesize[2] - width2 - skip2;
659 for (h = dsth - (dsty & 1); h >= 2; h -= 2) {
665 YUVA_IN(y, u, v, a, p, pal);
669 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
672 YUVA_IN(y, u, v, a, p, pal);
676 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
677 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
678 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
684 for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
685 YUVA_IN(y, u, v, a, p, pal);
689 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
691 YUVA_IN(y, u, v, a, p + BPP, pal);
695 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
699 YUVA_IN(y, u, v, a, p, pal);
703 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
705 YUVA_IN(y, u, v, a, p + BPP, pal);
709 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
711 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
712 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);
716 p += -wrap3 + 2 * BPP;
720 YUVA_IN(y, u, v, a, p, pal);
724 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
727 YUVA_IN(y, u, v, a, p, pal);
731 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
732 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
733 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
739 p += wrap3 + (wrap3 - dstw * BPP);
740 lum += wrap + (wrap - dstw - dstx);
741 cb += dst->linesize[1] - width2 - skip2;
742 cr += dst->linesize[2] - width2 - skip2;
744 /* handle odd height */
751 YUVA_IN(y, u, v, a, p, pal);
752 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
753 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
754 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
760 for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
761 YUVA_IN(y, u, v, a, p, pal);
765 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
767 YUVA_IN(y, u, v, a, p + BPP, pal);
771 lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
772 cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
773 cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
780 YUVA_IN(y, u, v, a, p, pal);
781 lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
782 cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
783 cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
788 static void free_picture(VideoPicture *vp)
791 SDL_FreeYUVOverlay(vp->bmp);
796 static void free_subpicture(SubPicture *sp)
798 avsubtitle_free(&sp->sub);
801 static void calculate_display_rect(SDL_Rect *rect, int scr_xleft, int scr_ytop, int scr_width, int scr_height, VideoPicture *vp)
804 int width, height, x, y;
806 if (vp->sar.num == 0)
809 aspect_ratio = av_q2d(vp->sar);
811 if (aspect_ratio <= 0.0)
813 aspect_ratio *= (float)vp->width / (float)vp->height;
815 /* XXX: we suppose the screen has a 1.0 pixel ratio */
817 width = ((int)rint(height * aspect_ratio)) & ~1;
818 if (width > scr_width) {
820 height = ((int)rint(width / aspect_ratio)) & ~1;
822 x = (scr_width - width) / 2;
823 y = (scr_height - height) / 2;
824 rect->x = scr_xleft + x;
825 rect->y = scr_ytop + y;
826 rect->w = FFMAX(width, 1);
827 rect->h = FFMAX(height, 1);
830 static void video_image_display(VideoState *is)
838 vp = &is->pictq[is->pictq_rindex];
840 if (is->subtitle_st) {
841 if (is->subpq_size > 0) {
842 sp = &is->subpq[is->subpq_rindex];
844 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
845 SDL_LockYUVOverlay (vp->bmp);
847 pict.data[0] = vp->bmp->pixels[0];
848 pict.data[1] = vp->bmp->pixels[2];
849 pict.data[2] = vp->bmp->pixels[1];
851 pict.linesize[0] = vp->bmp->pitches[0];
852 pict.linesize[1] = vp->bmp->pitches[2];
853 pict.linesize[2] = vp->bmp->pitches[1];
855 for (i = 0; i < sp->sub.num_rects; i++)
856 blend_subrect(&pict, sp->sub.rects[i],
857 vp->bmp->w, vp->bmp->h);
859 SDL_UnlockYUVOverlay (vp->bmp);
864 calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp);
866 SDL_DisplayYUVOverlay(vp->bmp, &rect);
868 if (rect.x != is->last_display_rect.x || rect.y != is->last_display_rect.y || rect.w != is->last_display_rect.w || rect.h != is->last_display_rect.h || is->force_refresh) {
869 int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
870 fill_border(is->xleft, is->ytop, is->width, is->height, rect.x, rect.y, rect.w, rect.h, bgcolor, 1);
871 is->last_display_rect = rect;
876 static inline int compute_mod(int a, int b)
878 return a < 0 ? a%b + b : a%b;
881 static void video_audio_display(VideoState *s)
883 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
884 int ch, channels, h, h2, bgcolor, fgcolor;
886 int rdft_bits, nb_freq;
888 for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
890 nb_freq = 1 << (rdft_bits - 1);
892 /* compute display index : center on currently output samples */
893 channels = s->audio_tgt.channels;
894 nb_display_channels = channels;
896 int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
898 delay = s->audio_write_buf_size;
901 /* to be more precise, we take into account the time spent since
902 the last buffer computation */
903 if (audio_callback_time) {
904 time_diff = av_gettime() - audio_callback_time;
905 delay -= (time_diff * s->audio_tgt.freq) / 1000000;
908 delay += 2 * data_used;
909 if (delay < data_used)
912 i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
913 if (s->show_mode == SHOW_MODE_WAVES) {
915 for (i = 0; i < 1000; i += channels) {
916 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
917 int a = s->sample_array[idx];
918 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
919 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
920 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
922 if (h < score && (b ^ c) < 0) {
929 s->last_i_start = i_start;
931 i_start = s->last_i_start;
934 bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
935 if (s->show_mode == SHOW_MODE_WAVES) {
936 fill_rectangle(screen,
937 s->xleft, s->ytop, s->width, s->height,
940 fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
942 /* total height for one channel */
943 h = s->height / nb_display_channels;
944 /* graph height / 2 */
946 for (ch = 0; ch < nb_display_channels; ch++) {
948 y1 = s->ytop + ch * h + (h / 2); /* position of center line */
949 for (x = 0; x < s->width; x++) {
950 y = (s->sample_array[i] * h2) >> 15;
957 fill_rectangle(screen,
958 s->xleft + x, ys, 1, y,
961 if (i >= SAMPLE_ARRAY_SIZE)
962 i -= SAMPLE_ARRAY_SIZE;
966 fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
968 for (ch = 1; ch < nb_display_channels; ch++) {
969 y = s->ytop + ch * h;
970 fill_rectangle(screen,
971 s->xleft, y, s->width, 1,
974 SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
976 nb_display_channels= FFMIN(nb_display_channels, 2);
977 if (rdft_bits != s->rdft_bits) {
978 av_rdft_end(s->rdft);
979 av_free(s->rdft_data);
980 s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
981 s->rdft_bits = rdft_bits;
982 s->rdft_data = av_malloc(4 * nb_freq * sizeof(*s->rdft_data));
986 for (ch = 0; ch < nb_display_channels; ch++) {
987 data[ch] = s->rdft_data + 2 * nb_freq * ch;
989 for (x = 0; x < 2 * nb_freq; x++) {
990 double w = (x-nb_freq) * (1.0 / nb_freq);
991 data[ch][x] = s->sample_array[i] * (1.0 - w * w);
993 if (i >= SAMPLE_ARRAY_SIZE)
994 i -= SAMPLE_ARRAY_SIZE;
996 av_rdft_calc(s->rdft, data[ch]);
998 /* Least efficient way to do this, we should of course
999 * directly access it but it is more than fast enough. */
1000 for (y = 0; y < s->height; y++) {
1001 double w = 1 / sqrt(nb_freq);
1002 int a = sqrt(w * sqrt(data[0][2 * y + 0] * data[0][2 * y + 0] + data[0][2 * y + 1] * data[0][2 * y + 1]));
1003 int b = (nb_display_channels == 2 ) ? sqrt(w * sqrt(data[1][2 * y + 0] * data[1][2 * y + 0]
1004 + data[1][2 * y + 1] * data[1][2 * y + 1])) : a;
1007 fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);
1009 fill_rectangle(screen,
1010 s->xpos, s->height-y, 1, 1,
1014 SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
1017 if (s->xpos >= s->width)
1022 static void stream_close(VideoState *is)
1025 /* XXX: use a special url_shutdown call to abort parse cleanly */
1026 is->abort_request = 1;
1027 SDL_WaitThread(is->read_tid, NULL);
1028 packet_queue_destroy(&is->videoq);
1029 packet_queue_destroy(&is->audioq);
1030 packet_queue_destroy(&is->subtitleq);
1032 /* free all pictures */
1033 for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
1034 free_picture(&is->pictq[i]);
1035 for (i = 0; i < SUBPICTURE_QUEUE_SIZE; i++)
1036 free_subpicture(&is->subpq[i]);
1037 SDL_DestroyMutex(is->pictq_mutex);
1038 SDL_DestroyCond(is->pictq_cond);
1039 SDL_DestroyMutex(is->subpq_mutex);
1040 SDL_DestroyCond(is->subpq_cond);
1041 SDL_DestroyCond(is->continue_read_thread);
1042 #if !CONFIG_AVFILTER
1043 sws_freeContext(is->img_convert_ctx);
1048 static void do_exit(VideoState *is)
1053 av_lockmgr_register(NULL);
1056 av_freep(&vfilters);
1058 avformat_network_deinit();
1062 av_log(NULL, AV_LOG_QUIET, "%s", "");
1066 static void sigterm_handler(int sig)
1071 static int video_open(VideoState *is, int force_set_video_mode, VideoPicture *vp)
1073 int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
1077 if (is_full_screen) flags |= SDL_FULLSCREEN;
1078 else flags |= SDL_RESIZABLE;
1080 if (vp && vp->width) {
1081 calculate_display_rect(&rect, 0, 0, INT_MAX, vp->height, vp);
1082 default_width = rect.w;
1083 default_height = rect.h;
1086 if (is_full_screen && fs_screen_width) {
1087 w = fs_screen_width;
1088 h = fs_screen_height;
1089 } else if (!is_full_screen && screen_width) {
1096 w = FFMIN(16383, w);
1097 if (screen && is->width == screen->w && screen->w == w
1098 && is->height== screen->h && screen->h == h && !force_set_video_mode)
1100 screen = SDL_SetVideoMode(w, h, 0, flags);
1102 av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");
1106 window_title = input_filename;
1107 SDL_WM_SetCaption(window_title, window_title);
1109 is->width = screen->w;
1110 is->height = screen->h;
1115 /* display the current picture, if any */
1116 static void video_display(VideoState *is)
1119 video_open(is, 0, NULL);
1120 if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1121 video_audio_display(is);
1122 else if (is->video_st)
1123 video_image_display(is);
1126 static double get_clock(Clock *c)
1128 if (*c->queue_serial != c->serial)
1133 double time = av_gettime() / 1000000.0;
1134 return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1138 static void set_clock_at(Clock *c, double pts, int serial, double time)
1141 c->last_updated = time;
1142 c->pts_drift = c->pts - time;
1146 static void set_clock(Clock *c, double pts, int serial)
1148 double time = av_gettime() / 1000000.0;
1149 set_clock_at(c, pts, serial, time);
1152 static void set_clock_speed(Clock *c, double speed)
1154 set_clock(c, get_clock(c), c->serial);
1158 static void init_clock(Clock *c, int *queue_serial)
1162 c->queue_serial = queue_serial;
1163 set_clock(c, NAN, -1);
1166 static void sync_clock_to_slave(Clock *c, Clock *slave)
1168 double clock = get_clock(c);
1169 double slave_clock = get_clock(slave);
1170 if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1171 set_clock(c, slave_clock, slave->serial);
1174 static int get_master_sync_type(VideoState *is) {
1175 if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1177 return AV_SYNC_VIDEO_MASTER;
1179 return AV_SYNC_AUDIO_MASTER;
1180 } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1182 return AV_SYNC_AUDIO_MASTER;
1184 return AV_SYNC_EXTERNAL_CLOCK;
1186 return AV_SYNC_EXTERNAL_CLOCK;
1190 /* get the current master clock value */
1191 static double get_master_clock(VideoState *is)
1195 switch (get_master_sync_type(is)) {
1196 case AV_SYNC_VIDEO_MASTER:
1197 val = get_clock(&is->vidclk);
1199 case AV_SYNC_AUDIO_MASTER:
1200 val = get_clock(&is->audclk);
1203 val = get_clock(&is->extclk);
1209 static void check_external_clock_speed(VideoState *is) {
1210 if (is->video_stream >= 0 && is->videoq.nb_packets <= MIN_FRAMES / 2 ||
1211 is->audio_stream >= 0 && is->audioq.nb_packets <= MIN_FRAMES / 2) {
1212 set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1213 } else if ((is->video_stream < 0 || is->videoq.nb_packets > MIN_FRAMES * 2) &&
1214 (is->audio_stream < 0 || is->audioq.nb_packets > MIN_FRAMES * 2)) {
1215 set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1217 double speed = is->extclk.speed;
1219 set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1223 /* seek in the stream */
1224 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1226 if (!is->seek_req) {
1229 is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1231 is->seek_flags |= AVSEEK_FLAG_BYTE;
1233 SDL_CondSignal(is->continue_read_thread);
1237 /* pause or resume the video */
1238 static void stream_toggle_pause(VideoState *is)
1241 is->frame_timer += av_gettime() / 1000000.0 + is->vidclk.pts_drift - is->vidclk.pts;
1242 if (is->read_pause_return != AVERROR(ENOSYS)) {
1243 is->vidclk.paused = 0;
1245 set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1247 set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1248 is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1251 static void toggle_pause(VideoState *is)
1253 stream_toggle_pause(is);
1257 static void step_to_next_frame(VideoState *is)
1259 /* if the stream is paused unpause it, then step */
1261 stream_toggle_pause(is);
1265 static double compute_target_delay(double delay, VideoState *is)
1267 double sync_threshold, diff;
1269 /* update delay to follow master synchronisation source */
1270 if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1271 /* if video is slave, we try to correct big delays by
1272 duplicating or deleting a frame */
1273 diff = get_clock(&is->vidclk) - get_master_clock(is);
1275 /* skip or repeat frame. We take into account the
1276 delay to compute the threshold. I still don't know
1277 if it is the best guess */
1278 sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1279 if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1280 if (diff <= -sync_threshold)
1281 delay = FFMAX(0, delay + diff);
1282 else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1283 delay = delay + diff;
1284 else if (diff >= sync_threshold)
1289 av_dlog(NULL, "video: delay=%0.3f A-V=%f\n",
1295 static void pictq_next_picture(VideoState *is) {
1296 /* update queue size and signal for next picture */
1297 if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
1298 is->pictq_rindex = 0;
1300 SDL_LockMutex(is->pictq_mutex);
1302 SDL_CondSignal(is->pictq_cond);
1303 SDL_UnlockMutex(is->pictq_mutex);
1306 static int pictq_prev_picture(VideoState *is) {
1307 VideoPicture *prevvp;
1309 /* update queue size and signal for the previous picture */
1310 prevvp = &is->pictq[(is->pictq_rindex + VIDEO_PICTURE_QUEUE_SIZE - 1) % VIDEO_PICTURE_QUEUE_SIZE];
1311 if (prevvp->allocated && prevvp->serial == is->videoq.serial) {
1312 SDL_LockMutex(is->pictq_mutex);
1313 if (is->pictq_size < VIDEO_PICTURE_QUEUE_SIZE) {
1314 if (--is->pictq_rindex == -1)
1315 is->pictq_rindex = VIDEO_PICTURE_QUEUE_SIZE - 1;
1319 SDL_CondSignal(is->pictq_cond);
1320 SDL_UnlockMutex(is->pictq_mutex);
1325 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1326 /* update current video pts */
1327 set_clock(&is->vidclk, pts, serial);
1328 sync_clock_to_slave(&is->extclk, &is->vidclk);
1329 is->video_current_pos = pos;
1330 is->frame_last_pts = pts;
1333 /* called to display each frame */
1334 static void video_refresh(void *opaque, double *remaining_time)
1336 VideoState *is = opaque;
1340 SubPicture *sp, *sp2;
1342 if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1343 check_external_clock_speed(is);
1345 if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1346 time = av_gettime() / 1000000.0;
1347 if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1349 is->last_vis_time = time;
1351 *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1356 if (is->force_refresh)
1357 redisplay = pictq_prev_picture(is);
1359 if (is->pictq_size == 0) {
1360 SDL_LockMutex(is->pictq_mutex);
1361 if (is->frame_last_dropped_pts != AV_NOPTS_VALUE && is->frame_last_dropped_pts > is->frame_last_pts) {
1362 update_video_pts(is, is->frame_last_dropped_pts, is->frame_last_dropped_pos, is->frame_last_dropped_serial);
1363 is->frame_last_dropped_pts = AV_NOPTS_VALUE;
1365 SDL_UnlockMutex(is->pictq_mutex);
1366 // nothing to do, no picture to display in the queue
1368 double last_duration, duration, delay;
1369 /* dequeue the picture */
1370 vp = &is->pictq[is->pictq_rindex];
1372 if (vp->serial != is->videoq.serial) {
1373 pictq_next_picture(is);
1381 /* compute nominal last_duration */
1382 last_duration = vp->pts - is->frame_last_pts;
1383 if (!isnan(last_duration) && last_duration > 0 && last_duration < is->max_frame_duration) {
1384 /* if duration of the last frame was sane, update last_duration in video state */
1385 is->frame_last_duration = last_duration;
1390 delay = compute_target_delay(is->frame_last_duration, is);
1392 time= av_gettime()/1000000.0;
1393 if (time < is->frame_timer + delay && !redisplay) {
1394 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1398 is->frame_timer += delay;
1399 if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1400 is->frame_timer = time;
1402 SDL_LockMutex(is->pictq_mutex);
1403 if (!redisplay && !isnan(vp->pts))
1404 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1405 SDL_UnlockMutex(is->pictq_mutex);
1407 if (is->pictq_size > 1) {
1408 VideoPicture *nextvp = &is->pictq[(is->pictq_rindex + 1) % VIDEO_PICTURE_QUEUE_SIZE];
1409 duration = nextvp->pts - vp->pts;
1410 if(!is->step && (redisplay || framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1412 is->frame_drops_late++;
1413 pictq_next_picture(is);
1419 if (is->subtitle_st) {
1420 while (is->subpq_size > 0) {
1421 sp = &is->subpq[is->subpq_rindex];
1423 if (is->subpq_size > 1)
1424 sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
1428 if (sp->serial != is->subtitleq.serial
1429 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1430 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1432 free_subpicture(sp);
1434 /* update queue size and signal for next picture */
1435 if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1436 is->subpq_rindex = 0;
1438 SDL_LockMutex(is->subpq_mutex);
1440 SDL_CondSignal(is->subpq_cond);
1441 SDL_UnlockMutex(is->subpq_mutex);
1449 /* display picture */
1450 if (!display_disable && is->show_mode == SHOW_MODE_VIDEO)
1453 pictq_next_picture(is);
1455 if (is->step && !is->paused)
1456 stream_toggle_pause(is);
1459 is->force_refresh = 0;
1461 static int64_t last_time;
1463 int aqsize, vqsize, sqsize;
1466 cur_time = av_gettime();
1467 if (!last_time || (cur_time - last_time) >= 30000) {
1472 aqsize = is->audioq.size;
1474 vqsize = is->videoq.size;
1475 if (is->subtitle_st)
1476 sqsize = is->subtitleq.size;
1478 if (is->audio_st && is->video_st)
1479 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1480 else if (is->video_st)
1481 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1482 else if (is->audio_st)
1483 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1484 av_log(NULL, AV_LOG_INFO,
1485 "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1486 get_master_clock(is),
1487 (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
1489 is->frame_drops_early + is->frame_drops_late,
1493 is->video_st ? is->video_st->codec->pts_correction_num_faulty_dts : 0,
1494 is->video_st ? is->video_st->codec->pts_correction_num_faulty_pts : 0);
1496 last_time = cur_time;
1501 /* allocate a picture (needs to do that in main thread to avoid
1502 potential locking problems */
1503 static void alloc_picture(VideoState *is)
1508 vp = &is->pictq[is->pictq_windex];
1512 video_open(is, 0, vp);
1514 vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
1517 bufferdiff = vp->bmp ? FFMAX(vp->bmp->pixels[0], vp->bmp->pixels[1]) - FFMIN(vp->bmp->pixels[0], vp->bmp->pixels[1]) : 0;
1518 if (!vp->bmp || vp->bmp->pitches[0] < vp->width || bufferdiff < (int64_t)vp->height * vp->bmp->pitches[0]) {
1519 /* SDL allocates a buffer smaller than requested if the video
1520 * overlay hardware is unable to support the requested size. */
1521 av_log(NULL, AV_LOG_FATAL,
1522 "Error: the video system does not support an image\n"
1523 "size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
1524 "to reduce the image size.\n", vp->width, vp->height );
1528 SDL_LockMutex(is->pictq_mutex);
1530 SDL_CondSignal(is->pictq_cond);
1531 SDL_UnlockMutex(is->pictq_mutex);
1534 static void duplicate_right_border_pixels(SDL_Overlay *bmp) {
1535 int i, width, height;
1537 for (i = 0; i < 3; i++) {
1544 if (bmp->pitches[i] > width) {
1545 maxp = bmp->pixels[i] + bmp->pitches[i] * height - 1;
1546 for (p = bmp->pixels[i] + width - 1; p < maxp; p += bmp->pitches[i])
1552 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, int64_t pos, int serial)
1556 #if defined(DEBUG_SYNC) && 0
1557 printf("frame_type=%c pts=%0.3f\n",
1558 av_get_picture_type_char(src_frame->pict_type), pts);
1561 /* wait until we have space to put a new picture */
1562 SDL_LockMutex(is->pictq_mutex);
1564 /* keep the last already displayed picture in the queue */
1565 while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE - 1 &&
1566 !is->videoq.abort_request) {
1567 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1569 SDL_UnlockMutex(is->pictq_mutex);
1571 if (is->videoq.abort_request)
1574 vp = &is->pictq[is->pictq_windex];
1576 vp->sar = src_frame->sample_aspect_ratio;
1578 /* alloc or resize hardware picture buffer */
1579 if (!vp->bmp || vp->reallocate || !vp->allocated ||
1580 vp->width != src_frame->width ||
1581 vp->height != src_frame->height) {
1586 vp->width = src_frame->width;
1587 vp->height = src_frame->height;
1589 /* the allocation must be done in the main thread to avoid
1590 locking problems. */
1591 event.type = FF_ALLOC_EVENT;
1592 event.user.data1 = is;
1593 SDL_PushEvent(&event);
1595 /* wait until the picture is allocated */
1596 SDL_LockMutex(is->pictq_mutex);
1597 while (!vp->allocated && !is->videoq.abort_request) {
1598 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1600 /* if the queue is aborted, we have to pop the pending ALLOC event or wait for the allocation to complete */
1601 if (is->videoq.abort_request && SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_EVENTMASK(FF_ALLOC_EVENT)) != 1) {
1602 while (!vp->allocated) {
1603 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1606 SDL_UnlockMutex(is->pictq_mutex);
1608 if (is->videoq.abort_request)
1612 /* if the frame is not skipped, then display it */
1614 AVPicture pict = { { 0 } };
1616 /* get a pointer on the bitmap */
1617 SDL_LockYUVOverlay (vp->bmp);
1619 pict.data[0] = vp->bmp->pixels[0];
1620 pict.data[1] = vp->bmp->pixels[2];
1621 pict.data[2] = vp->bmp->pixels[1];
1623 pict.linesize[0] = vp->bmp->pitches[0];
1624 pict.linesize[1] = vp->bmp->pitches[2];
1625 pict.linesize[2] = vp->bmp->pitches[1];
1628 // FIXME use direct rendering
1629 av_picture_copy(&pict, (AVPicture *)src_frame,
1630 src_frame->format, vp->width, vp->height);
1632 av_opt_get_int(sws_opts, "sws_flags", 0, &sws_flags);
1633 is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
1634 vp->width, vp->height, src_frame->format, vp->width, vp->height,
1635 AV_PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
1636 if (is->img_convert_ctx == NULL) {
1637 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1640 sws_scale(is->img_convert_ctx, src_frame->data, src_frame->linesize,
1641 0, vp->height, pict.data, pict.linesize);
1643 /* workaround SDL PITCH_WORKAROUND */
1644 duplicate_right_border_pixels(vp->bmp);
1645 /* update the bitmap content */
1646 SDL_UnlockYUVOverlay(vp->bmp);
1650 vp->serial = serial;
1652 /* now we can update the picture count */
1653 if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE)
1654 is->pictq_windex = 0;
1655 SDL_LockMutex(is->pictq_mutex);
1657 SDL_UnlockMutex(is->pictq_mutex);
1662 static int get_video_frame(VideoState *is, AVFrame *frame, AVPacket *pkt, int *serial)
1666 if (packet_queue_get(&is->videoq, pkt, 1, serial) < 0)
1669 if (pkt->data == flush_pkt.data) {
1670 avcodec_flush_buffers(is->video_st->codec);
1672 SDL_LockMutex(is->pictq_mutex);
1673 // Make sure there are no long delay timers (ideally we should just flush the queue but that's harder)
1674 while (is->pictq_size && !is->videoq.abort_request) {
1675 SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1677 is->video_current_pos = -1;
1678 is->frame_last_pts = AV_NOPTS_VALUE;
1679 is->frame_last_duration = 0;
1680 is->frame_timer = (double)av_gettime() / 1000000.0;
1681 is->frame_last_dropped_pts = AV_NOPTS_VALUE;
1682 SDL_UnlockMutex(is->pictq_mutex);
1686 if(avcodec_decode_video2(is->video_st->codec, frame, &got_picture, pkt) < 0)
1689 if (!got_picture && !pkt->data)
1690 is->video_finished = *serial;
1696 if (decoder_reorder_pts == -1) {
1697 frame->pts = av_frame_get_best_effort_timestamp(frame);
1698 } else if (decoder_reorder_pts) {
1699 frame->pts = frame->pkt_pts;
1701 frame->pts = frame->pkt_dts;
1704 if (frame->pts != AV_NOPTS_VALUE)
1705 dpts = av_q2d(is->video_st->time_base) * frame->pts;
1707 frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1709 if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1710 SDL_LockMutex(is->pictq_mutex);
1711 if (is->frame_last_pts != AV_NOPTS_VALUE && frame->pts != AV_NOPTS_VALUE) {
1712 double clockdiff = get_clock(&is->vidclk) - get_master_clock(is);
1713 double ptsdiff = dpts - is->frame_last_pts;
1714 if (!isnan(clockdiff) && fabs(clockdiff) < AV_NOSYNC_THRESHOLD &&
1715 !isnan(ptsdiff) && ptsdiff > 0 && ptsdiff < AV_NOSYNC_THRESHOLD &&
1716 clockdiff + ptsdiff - is->frame_last_filter_delay < 0 &&
1717 is->videoq.nb_packets) {
1718 is->frame_last_dropped_pos = av_frame_get_pkt_pos(frame);
1719 is->frame_last_dropped_pts = dpts;
1720 is->frame_last_dropped_serial = *serial;
1721 is->frame_drops_early++;
1722 av_frame_unref(frame);
1726 SDL_UnlockMutex(is->pictq_mutex);
1735 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1736 AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1739 AVFilterInOut *outputs = NULL, *inputs = NULL;
1742 outputs = avfilter_inout_alloc();
1743 inputs = avfilter_inout_alloc();
1744 if (!outputs || !inputs) {
1745 ret = AVERROR(ENOMEM);
1749 outputs->name = av_strdup("in");
1750 outputs->filter_ctx = source_ctx;
1751 outputs->pad_idx = 0;
1752 outputs->next = NULL;
1754 inputs->name = av_strdup("out");
1755 inputs->filter_ctx = sink_ctx;
1756 inputs->pad_idx = 0;
1757 inputs->next = NULL;
1759 if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1762 if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1766 ret = avfilter_graph_config(graph, NULL);
1768 avfilter_inout_free(&outputs);
1769 avfilter_inout_free(&inputs);
1773 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1775 static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
1776 char sws_flags_str[128];
1777 char buffersrc_args[256];
1779 AVFilterContext *filt_src = NULL, *filt_out = NULL, *filt_crop;
1780 AVCodecContext *codec = is->video_st->codec;
1781 AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1783 av_opt_get_int(sws_opts, "sws_flags", 0, &sws_flags);
1784 snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%"PRId64, sws_flags);
1785 graph->scale_sws_opts = av_strdup(sws_flags_str);
1787 snprintf(buffersrc_args, sizeof(buffersrc_args),
1788 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1789 frame->width, frame->height, frame->format,
1790 is->video_st->time_base.num, is->video_st->time_base.den,
1791 codec->sample_aspect_ratio.num, FFMAX(codec->sample_aspect_ratio.den, 1));
1792 if (fr.num && fr.den)
1793 av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1795 if ((ret = avfilter_graph_create_filter(&filt_src,
1796 avfilter_get_by_name("buffer"),
1797 "ffplay_buffer", buffersrc_args, NULL,
1801 ret = avfilter_graph_create_filter(&filt_out,
1802 avfilter_get_by_name("buffersink"),
1803 "ffplay_buffersink", NULL, NULL, graph);
1807 if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1810 /* SDL YUV code is not handling odd width/height for some driver
1811 * combinations, therefore we crop the picture to an even width/height. */
1812 if ((ret = avfilter_graph_create_filter(&filt_crop,
1813 avfilter_get_by_name("crop"),
1814 "ffplay_crop", "floor(in_w/2)*2:floor(in_h/2)*2", NULL, graph)) < 0)
1816 if ((ret = avfilter_link(filt_crop, 0, filt_out, 0)) < 0)
1819 if ((ret = configure_filtergraph(graph, vfilters, filt_src, filt_crop)) < 0)
1822 is->in_video_filter = filt_src;
1823 is->out_video_filter = filt_out;
1829 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1831 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1832 int sample_rates[2] = { 0, -1 };
1833 int64_t channel_layouts[2] = { 0, -1 };
1834 int channels[2] = { 0, -1 };
1835 AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1836 char aresample_swr_opts[512] = "";
1837 AVDictionaryEntry *e = NULL;
1838 char asrc_args[256];
1841 avfilter_graph_free(&is->agraph);
1842 if (!(is->agraph = avfilter_graph_alloc()))
1843 return AVERROR(ENOMEM);
1845 while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1846 av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1847 if (strlen(aresample_swr_opts))
1848 aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1849 av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1851 ret = snprintf(asrc_args, sizeof(asrc_args),
1852 "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1853 is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1854 is->audio_filter_src.channels,
1855 1, is->audio_filter_src.freq);
1856 if (is->audio_filter_src.channel_layout)
1857 snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1858 ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1860 ret = avfilter_graph_create_filter(&filt_asrc,
1861 avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1862 asrc_args, NULL, is->agraph);
1867 ret = avfilter_graph_create_filter(&filt_asink,
1868 avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1869 NULL, NULL, is->agraph);
1873 if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1875 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
1878 if (force_output_format) {
1879 channel_layouts[0] = is->audio_tgt.channel_layout;
1880 channels [0] = is->audio_tgt.channels;
1881 sample_rates [0] = is->audio_tgt.freq;
1882 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
1884 if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1886 if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1888 if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1893 if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
1896 is->in_audio_filter = filt_asrc;
1897 is->out_audio_filter = filt_asink;
1901 avfilter_graph_free(&is->agraph);
1904 #endif /* CONFIG_AVFILTER */
1906 static int video_thread(void *arg)
1908 AVPacket pkt = { 0 };
1909 VideoState *is = arg;
1910 AVFrame *frame = av_frame_alloc();
1916 AVFilterGraph *graph = avfilter_graph_alloc();
1917 AVFilterContext *filt_out = NULL, *filt_in = NULL;
1920 enum AVPixelFormat last_format = -2;
1921 int last_serial = -1;
1925 while (is->paused && !is->videoq.abort_request)
1928 avcodec_get_frame_defaults(frame);
1929 av_free_packet(&pkt);
1931 ret = get_video_frame(is, frame, &pkt, &serial);
1938 if ( last_w != frame->width
1939 || last_h != frame->height
1940 || last_format != frame->format
1941 || last_serial != serial) {
1942 av_log(NULL, AV_LOG_DEBUG,
1943 "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
1945 (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
1946 frame->width, frame->height,
1947 (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), serial);
1948 avfilter_graph_free(&graph);
1949 graph = avfilter_graph_alloc();
1950 if ((ret = configure_video_filters(graph, is, vfilters, frame)) < 0) {
1952 event.type = FF_QUIT_EVENT;
1953 event.user.data1 = is;
1954 SDL_PushEvent(&event);
1955 av_free_packet(&pkt);
1958 filt_in = is->in_video_filter;
1959 filt_out = is->out_video_filter;
1960 last_w = frame->width;
1961 last_h = frame->height;
1962 last_format = frame->format;
1963 last_serial = serial;
1966 ret = av_buffersrc_add_frame(filt_in, frame);
1969 av_frame_unref(frame);
1970 avcodec_get_frame_defaults(frame);
1971 av_free_packet(&pkt);
1974 is->frame_last_returned_time = av_gettime() / 1000000.0;
1976 ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
1978 if (ret == AVERROR_EOF)
1979 is->video_finished = serial;
1984 is->frame_last_filter_delay = av_gettime() / 1000000.0 - is->frame_last_returned_time;
1985 if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
1986 is->frame_last_filter_delay = 0;
1988 pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(filt_out->inputs[0]->time_base);
1989 ret = queue_picture(is, frame, pts, av_frame_get_pkt_pos(frame), serial);
1990 av_frame_unref(frame);
1993 pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(is->video_st->time_base);
1994 ret = queue_picture(is, frame, pts, av_frame_get_pkt_pos(frame), serial);
1995 av_frame_unref(frame);
2002 avcodec_flush_buffers(is->video_st->codec);
2004 avfilter_graph_free(&graph);
2006 av_free_packet(&pkt);
2007 av_frame_free(&frame);
2011 static int subtitle_thread(void *arg)
2013 VideoState *is = arg;
2015 AVPacket pkt1, *pkt = &pkt1;
2020 int r, g, b, y, u, v, a;
2023 while (is->paused && !is->subtitleq.abort_request) {
2026 if (packet_queue_get(&is->subtitleq, pkt, 1, &serial) < 0)
2029 if (pkt->data == flush_pkt.data) {
2030 avcodec_flush_buffers(is->subtitle_st->codec);
2033 SDL_LockMutex(is->subpq_mutex);
2034 while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
2035 !is->subtitleq.abort_request) {
2036 SDL_CondWait(is->subpq_cond, is->subpq_mutex);
2038 SDL_UnlockMutex(is->subpq_mutex);
2040 if (is->subtitleq.abort_request)
2043 sp = &is->subpq[is->subpq_windex];
2045 /* NOTE: ipts is the PTS of the _first_ picture beginning in
2046 this packet, if any */
2048 if (pkt->pts != AV_NOPTS_VALUE)
2049 pts = av_q2d(is->subtitle_st->time_base) * pkt->pts;
2051 avcodec_decode_subtitle2(is->subtitle_st->codec, &sp->sub,
2052 &got_subtitle, pkt);
2053 if (got_subtitle && sp->sub.format == 0) {
2054 if (sp->sub.pts != AV_NOPTS_VALUE)
2055 pts = sp->sub.pts / (double)AV_TIME_BASE;
2057 sp->serial = serial;
2059 for (i = 0; i < sp->sub.num_rects; i++)
2061 for (j = 0; j < sp->sub.rects[i]->nb_colors; j++)
2063 RGBA_IN(r, g, b, a, (uint32_t*)sp->sub.rects[i]->pict.data[1] + j);
2064 y = RGB_TO_Y_CCIR(r, g, b);
2065 u = RGB_TO_U_CCIR(r, g, b, 0);
2066 v = RGB_TO_V_CCIR(r, g, b, 0);
2067 YUVA_OUT((uint32_t*)sp->sub.rects[i]->pict.data[1] + j, y, u, v, a);
2071 /* now we can update the picture count */
2072 if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
2073 is->subpq_windex = 0;
2074 SDL_LockMutex(is->subpq_mutex);
2076 SDL_UnlockMutex(is->subpq_mutex);
2077 } else if (got_subtitle) {
2078 avsubtitle_free(&sp->sub);
2080 av_free_packet(pkt);
2085 /* copy samples for viewing in editor window */
2086 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2090 size = samples_size / sizeof(short);
2092 len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2095 memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2097 is->sample_array_index += len;
2098 if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2099 is->sample_array_index = 0;
2104 /* return the wanted number of samples to get better sync if sync_type is video
2105 * or external master clock */
2106 static int synchronize_audio(VideoState *is, int nb_samples)
2108 int wanted_nb_samples = nb_samples;
2110 /* if not master, then we try to remove or add samples to correct the clock */
2111 if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2112 double diff, avg_diff;
2113 int min_nb_samples, max_nb_samples;
2115 diff = get_clock(&is->audclk) - get_master_clock(is);
2117 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2118 is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2119 if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2120 /* not enough measures to have a correct estimate */
2121 is->audio_diff_avg_count++;
2123 /* estimate the A-V difference */
2124 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2126 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2127 wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2128 min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2129 max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2130 wanted_nb_samples = FFMIN(FFMAX(wanted_nb_samples, min_nb_samples), max_nb_samples);
2132 av_dlog(NULL, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2133 diff, avg_diff, wanted_nb_samples - nb_samples,
2134 is->audio_clock, is->audio_diff_threshold);
2137 /* too big difference : may be initial PTS errors, so
2139 is->audio_diff_avg_count = 0;
2140 is->audio_diff_cum = 0;
2144 return wanted_nb_samples;
2148 * Decode one audio frame and return its uncompressed size.
2150 * The processed audio frame is decoded, converted if required, and
2151 * stored in is->audio_buf, with size in bytes given by the return
2154 static int audio_decode_frame(VideoState *is)
2156 AVPacket *pkt_temp = &is->audio_pkt_temp;
2157 AVPacket *pkt = &is->audio_pkt;
2158 AVCodecContext *dec = is->audio_st->codec;
2159 int len1, data_size, resampled_data_size;
2160 int64_t dec_channel_layout;
2162 av_unused double audio_clock0;
2163 int wanted_nb_samples;
2169 /* NOTE: the audio packet can contain several frames */
2170 while (pkt_temp->stream_index != -1 || is->audio_buf_frames_pending) {
2172 if (!(is->frame = avcodec_alloc_frame()))
2173 return AVERROR(ENOMEM);
2175 av_frame_unref(is->frame);
2176 avcodec_get_frame_defaults(is->frame);
2179 if (is->audioq.serial != is->audio_pkt_temp_serial)
2185 if (!is->audio_buf_frames_pending) {
2186 len1 = avcodec_decode_audio4(dec, is->frame, &got_frame, pkt_temp);
2188 /* if error, we skip the frame */
2194 pkt_temp->pts = AV_NOPTS_VALUE;
2195 pkt_temp->data += len1;
2196 pkt_temp->size -= len1;
2197 if (pkt_temp->data && pkt_temp->size <= 0 || !pkt_temp->data && !got_frame)
2198 pkt_temp->stream_index = -1;
2199 if (!pkt_temp->data && !got_frame)
2200 is->audio_finished = is->audio_pkt_temp_serial;
2205 tb = (AVRational){1, is->frame->sample_rate};
2206 if (is->frame->pts != AV_NOPTS_VALUE)
2207 is->frame->pts = av_rescale_q(is->frame->pts, dec->time_base, tb);
2208 else if (is->frame->pkt_pts != AV_NOPTS_VALUE)
2209 is->frame->pts = av_rescale_q(is->frame->pkt_pts, is->audio_st->time_base, tb);
2210 else if (is->audio_frame_next_pts != AV_NOPTS_VALUE)
2212 is->frame->pts = av_rescale_q(is->audio_frame_next_pts, (AVRational){1, is->audio_filter_src.freq}, tb);
2214 is->frame->pts = av_rescale_q(is->audio_frame_next_pts, (AVRational){1, is->audio_src.freq}, tb);
2217 if (is->frame->pts != AV_NOPTS_VALUE)
2218 is->audio_frame_next_pts = is->frame->pts + is->frame->nb_samples;
2221 dec_channel_layout = get_valid_channel_layout(is->frame->channel_layout, av_frame_get_channels(is->frame));
2224 cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2225 is->frame->format, av_frame_get_channels(is->frame)) ||
2226 is->audio_filter_src.channel_layout != dec_channel_layout ||
2227 is->audio_filter_src.freq != is->frame->sample_rate ||
2228 is->audio_pkt_temp_serial != is->audio_last_serial;
2231 char buf1[1024], buf2[1024];
2232 av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2233 av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2234 av_log(NULL, AV_LOG_DEBUG,
2235 "Audio frame changed from rate:%d ch:%d fmt:%s layout:%s serial:%d to rate:%d ch:%d fmt:%s layout:%s serial:%d\n",
2236 is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, is->audio_last_serial,
2237 is->frame->sample_rate, av_frame_get_channels(is->frame), av_get_sample_fmt_name(is->frame->format), buf2, is->audio_pkt_temp_serial);
2239 is->audio_filter_src.fmt = is->frame->format;
2240 is->audio_filter_src.channels = av_frame_get_channels(is->frame);
2241 is->audio_filter_src.channel_layout = dec_channel_layout;
2242 is->audio_filter_src.freq = is->frame->sample_rate;
2243 is->audio_last_serial = is->audio_pkt_temp_serial;
2245 if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2249 if ((ret = av_buffersrc_add_frame(is->in_audio_filter, is->frame)) < 0)
2251 av_frame_unref(is->frame);
2255 if ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, is->frame, 0)) < 0) {
2256 if (ret == AVERROR(EAGAIN)) {
2257 is->audio_buf_frames_pending = 0;
2260 if (ret == AVERROR_EOF)
2261 is->audio_finished = is->audio_pkt_temp_serial;
2264 is->audio_buf_frames_pending = 1;
2265 tb = is->out_audio_filter->inputs[0]->time_base;
2268 data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(is->frame),
2269 is->frame->nb_samples,
2270 is->frame->format, 1);
2272 dec_channel_layout =
2273 (is->frame->channel_layout && av_frame_get_channels(is->frame) == av_get_channel_layout_nb_channels(is->frame->channel_layout)) ?
2274 is->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(is->frame));
2275 wanted_nb_samples = synchronize_audio(is, is->frame->nb_samples);
2277 if (is->frame->format != is->audio_src.fmt ||
2278 dec_channel_layout != is->audio_src.channel_layout ||
2279 is->frame->sample_rate != is->audio_src.freq ||
2280 (wanted_nb_samples != is->frame->nb_samples && !is->swr_ctx)) {
2281 swr_free(&is->swr_ctx);
2282 is->swr_ctx = swr_alloc_set_opts(NULL,
2283 is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2284 dec_channel_layout, is->frame->format, is->frame->sample_rate,
2286 if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2287 av_log(NULL, AV_LOG_ERROR,
2288 "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2289 is->frame->sample_rate, av_get_sample_fmt_name(is->frame->format), av_frame_get_channels(is->frame),
2290 is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2293 is->audio_src.channel_layout = dec_channel_layout;
2294 is->audio_src.channels = av_frame_get_channels(is->frame);
2295 is->audio_src.freq = is->frame->sample_rate;
2296 is->audio_src.fmt = is->frame->format;
2300 const uint8_t **in = (const uint8_t **)is->frame->extended_data;
2301 uint8_t **out = &is->audio_buf1;
2302 int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate + 256;
2303 int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2306 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2309 if (wanted_nb_samples != is->frame->nb_samples) {
2310 if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - is->frame->nb_samples) * is->audio_tgt.freq / is->frame->sample_rate,
2311 wanted_nb_samples * is->audio_tgt.freq / is->frame->sample_rate) < 0) {
2312 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2316 av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2317 if (!is->audio_buf1)
2318 return AVERROR(ENOMEM);
2319 len2 = swr_convert(is->swr_ctx, out, out_count, in, is->frame->nb_samples);
2321 av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2324 if (len2 == out_count) {
2325 av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2326 swr_init(is->swr_ctx);
2328 is->audio_buf = is->audio_buf1;
2329 resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2331 is->audio_buf = is->frame->data[0];
2332 resampled_data_size = data_size;
2335 audio_clock0 = is->audio_clock;
2336 /* update the audio clock with the pts */
2337 if (is->frame->pts != AV_NOPTS_VALUE)
2338 is->audio_clock = is->frame->pts * av_q2d(tb) + (double) is->frame->nb_samples / is->frame->sample_rate;
2340 is->audio_clock = NAN;
2341 is->audio_clock_serial = is->audio_pkt_temp_serial;
2344 static double last_clock;
2345 printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2346 is->audio_clock - last_clock,
2347 is->audio_clock, audio_clock0);
2348 last_clock = is->audio_clock;
2351 return resampled_data_size;
2354 /* free the current packet */
2356 av_free_packet(pkt);
2357 memset(pkt_temp, 0, sizeof(*pkt_temp));
2358 pkt_temp->stream_index = -1;
2360 if (is->audioq.abort_request) {
2364 if (is->audioq.nb_packets == 0)
2365 SDL_CondSignal(is->continue_read_thread);
2367 /* read next packet */
2368 if ((packet_queue_get(&is->audioq, pkt, 1, &is->audio_pkt_temp_serial)) < 0)
2371 if (pkt->data == flush_pkt.data) {
2372 avcodec_flush_buffers(dec);
2373 is->audio_buf_frames_pending = 0;
2374 is->audio_frame_next_pts = AV_NOPTS_VALUE;
2375 if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek)
2376 is->audio_frame_next_pts = is->audio_st->start_time;
2383 /* prepare a new audio buffer */
2384 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2386 VideoState *is = opaque;
2387 int audio_size, len1;
2389 int frame_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, 1, is->audio_tgt.fmt, 1);
2391 audio_callback_time = av_gettime();
2394 if (is->audio_buf_index >= is->audio_buf_size) {
2395 audio_size = audio_decode_frame(is);
2396 if (audio_size < 0) {
2397 /* if error, just output silence */
2398 is->audio_buf = is->silence_buf;
2399 is->audio_buf_size = sizeof(is->silence_buf) / frame_size * frame_size;
2401 if (is->show_mode != SHOW_MODE_VIDEO)
2402 update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2403 is->audio_buf_size = audio_size;
2405 is->audio_buf_index = 0;
2407 len1 = is->audio_buf_size - is->audio_buf_index;
2410 memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2413 is->audio_buf_index += len1;
2415 bytes_per_sec = is->audio_tgt.freq * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2416 is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2417 /* Let's assume the audio driver that is used by SDL has two periods. */
2418 if (!isnan(is->audio_clock)) {
2419 set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
2420 sync_clock_to_slave(&is->extclk, &is->audclk);
2424 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2426 SDL_AudioSpec wanted_spec, spec;
2428 static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2430 env = SDL_getenv("SDL_AUDIO_CHANNELS");
2432 wanted_nb_channels = atoi(env);
2433 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2435 if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2436 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2437 wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2439 wanted_spec.channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2440 wanted_spec.freq = wanted_sample_rate;
2441 if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2442 av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2445 wanted_spec.format = AUDIO_S16SYS;
2446 wanted_spec.silence = 0;
2447 wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
2448 wanted_spec.callback = sdl_audio_callback;
2449 wanted_spec.userdata = opaque;
2450 while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
2451 av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels): %s\n", wanted_spec.channels, SDL_GetError());
2452 wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2453 if (!wanted_spec.channels) {
2454 av_log(NULL, AV_LOG_ERROR,
2455 "No more channel combinations to try, audio open failed\n");
2458 wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2460 if (spec.format != AUDIO_S16SYS) {
2461 av_log(NULL, AV_LOG_ERROR,
2462 "SDL advised audio format %d is not supported!\n", spec.format);
2465 if (spec.channels != wanted_spec.channels) {
2466 wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2467 if (!wanted_channel_layout) {
2468 av_log(NULL, AV_LOG_ERROR,
2469 "SDL advised channel count %d is not supported!\n", spec.channels);
2474 audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2475 audio_hw_params->freq = spec.freq;
2476 audio_hw_params->channel_layout = wanted_channel_layout;
2477 audio_hw_params->channels = spec.channels;
2481 /* open a given stream. Return 0 if OK */
2482 static int stream_component_open(VideoState *is, int stream_index)
2484 AVFormatContext *ic = is->ic;
2485 AVCodecContext *avctx;
2487 const char *forced_codec_name = NULL;
2489 AVDictionaryEntry *t = NULL;
2490 int sample_rate, nb_channels;
2491 int64_t channel_layout;
2493 int stream_lowres = lowres;
2495 if (stream_index < 0 || stream_index >= ic->nb_streams)
2497 avctx = ic->streams[stream_index]->codec;
2499 codec = avcodec_find_decoder(avctx->codec_id);
2501 switch(avctx->codec_type){
2502 case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
2503 case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2504 case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
2506 if (forced_codec_name)
2507 codec = avcodec_find_decoder_by_name(forced_codec_name);
2509 if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2510 "No codec could be found with name '%s'\n", forced_codec_name);
2511 else av_log(NULL, AV_LOG_WARNING,
2512 "No codec could be found with id %d\n", avctx->codec_id);
2516 avctx->codec_id = codec->id;
2517 avctx->workaround_bugs = workaround_bugs;
2518 if(stream_lowres > av_codec_get_max_lowres(codec)){
2519 av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2520 av_codec_get_max_lowres(codec));
2521 stream_lowres = av_codec_get_max_lowres(codec);
2523 av_codec_set_lowres(avctx, stream_lowres);
2524 avctx->error_concealment = error_concealment;
2526 if(stream_lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
2527 if (fast) avctx->flags2 |= CODEC_FLAG2_FAST;
2528 if(codec->capabilities & CODEC_CAP_DR1)
2529 avctx->flags |= CODEC_FLAG_EMU_EDGE;
2531 opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2532 if (!av_dict_get(opts, "threads", NULL, 0))
2533 av_dict_set(&opts, "threads", "auto", 0);
2535 av_dict_set(&opts, "lowres", av_asprintf("%d", stream_lowres), AV_DICT_DONT_STRDUP_VAL);
2536 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2537 av_dict_set(&opts, "refcounted_frames", "1", 0);
2538 if (avcodec_open2(avctx, codec, &opts) < 0)
2540 if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2541 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2542 return AVERROR_OPTION_NOT_FOUND;
2545 ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2546 switch (avctx->codec_type) {
2547 case AVMEDIA_TYPE_AUDIO:
2552 is->audio_filter_src.freq = avctx->sample_rate;
2553 is->audio_filter_src.channels = avctx->channels;
2554 is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2555 is->audio_filter_src.fmt = avctx->sample_fmt;
2556 if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2558 link = is->out_audio_filter->inputs[0];
2559 sample_rate = link->sample_rate;
2560 nb_channels = link->channels;
2561 channel_layout = link->channel_layout;
2564 sample_rate = avctx->sample_rate;
2565 nb_channels = avctx->channels;
2566 channel_layout = avctx->channel_layout;
2569 /* prepare audio output */
2570 if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2572 is->audio_hw_buf_size = ret;
2573 is->audio_src = is->audio_tgt;
2574 is->audio_buf_size = 0;
2575 is->audio_buf_index = 0;
2577 /* init averaging filter */
2578 is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2579 is->audio_diff_avg_count = 0;
2580 /* since we do not have a precise anough audio fifo fullness,
2581 we correct audio sync only if larger than this threshold */
2582 is->audio_diff_threshold = 2.0 * is->audio_hw_buf_size / av_samples_get_buffer_size(NULL, is->audio_tgt.channels, is->audio_tgt.freq, is->audio_tgt.fmt, 1);
2584 memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
2585 memset(&is->audio_pkt_temp, 0, sizeof(is->audio_pkt_temp));
2586 is->audio_pkt_temp.stream_index = -1;
2588 is->audio_stream = stream_index;
2589 is->audio_st = ic->streams[stream_index];
2591 packet_queue_start(&is->audioq);
2594 case AVMEDIA_TYPE_VIDEO:
2595 is->video_stream = stream_index;
2596 is->video_st = ic->streams[stream_index];
2598 packet_queue_start(&is->videoq);
2599 is->video_tid = SDL_CreateThread(video_thread, is);
2600 is->queue_attachments_req = 1;
2602 case AVMEDIA_TYPE_SUBTITLE:
2603 is->subtitle_stream = stream_index;
2604 is->subtitle_st = ic->streams[stream_index];
2605 packet_queue_start(&is->subtitleq);
2607 is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
2615 static void stream_component_close(VideoState *is, int stream_index)
2617 AVFormatContext *ic = is->ic;
2618 AVCodecContext *avctx;
2620 if (stream_index < 0 || stream_index >= ic->nb_streams)
2622 avctx = ic->streams[stream_index]->codec;
2624 switch (avctx->codec_type) {
2625 case AVMEDIA_TYPE_AUDIO:
2626 packet_queue_abort(&is->audioq);
2630 packet_queue_flush(&is->audioq);
2631 av_free_packet(&is->audio_pkt);
2632 swr_free(&is->swr_ctx);
2633 av_freep(&is->audio_buf1);
2634 is->audio_buf1_size = 0;
2635 is->audio_buf = NULL;
2636 av_frame_free(&is->frame);
2639 av_rdft_end(is->rdft);
2640 av_freep(&is->rdft_data);
2645 avfilter_graph_free(&is->agraph);
2648 case AVMEDIA_TYPE_VIDEO:
2649 packet_queue_abort(&is->videoq);
2651 /* note: we also signal this mutex to make sure we deblock the
2652 video thread in all cases */
2653 SDL_LockMutex(is->pictq_mutex);
2654 SDL_CondSignal(is->pictq_cond);
2655 SDL_UnlockMutex(is->pictq_mutex);
2657 SDL_WaitThread(is->video_tid, NULL);
2659 packet_queue_flush(&is->videoq);
2661 case AVMEDIA_TYPE_SUBTITLE:
2662 packet_queue_abort(&is->subtitleq);
2664 /* note: we also signal this mutex to make sure we deblock the
2665 video thread in all cases */
2666 SDL_LockMutex(is->subpq_mutex);
2667 SDL_CondSignal(is->subpq_cond);
2668 SDL_UnlockMutex(is->subpq_mutex);
2670 SDL_WaitThread(is->subtitle_tid, NULL);
2672 packet_queue_flush(&is->subtitleq);
2678 ic->streams[stream_index]->discard = AVDISCARD_ALL;
2679 avcodec_close(avctx);
2680 switch (avctx->codec_type) {
2681 case AVMEDIA_TYPE_AUDIO:
2682 is->audio_st = NULL;
2683 is->audio_stream = -1;
2685 case AVMEDIA_TYPE_VIDEO:
2686 is->video_st = NULL;
2687 is->video_stream = -1;
2689 case AVMEDIA_TYPE_SUBTITLE:
2690 is->subtitle_st = NULL;
2691 is->subtitle_stream = -1;
2698 static int decode_interrupt_cb(void *ctx)
2700 VideoState *is = ctx;
2701 return is->abort_request;
2704 static int is_realtime(AVFormatContext *s)
2706 if( !strcmp(s->iformat->name, "rtp")
2707 || !strcmp(s->iformat->name, "rtsp")
2708 || !strcmp(s->iformat->name, "sdp")
2712 if(s->pb && ( !strncmp(s->filename, "rtp:", 4)
2713 || !strncmp(s->filename, "udp:", 4)
2720 /* this thread gets the stream from the disk or the network */
2721 static int read_thread(void *arg)
2723 VideoState *is = arg;
2724 AVFormatContext *ic = NULL;
2726 int st_index[AVMEDIA_TYPE_NB];
2727 AVPacket pkt1, *pkt = &pkt1;
2729 int64_t stream_start_time;
2730 int pkt_in_play_range = 0;
2731 AVDictionaryEntry *t;
2732 AVDictionary **opts;
2733 int orig_nb_streams;
2734 SDL_mutex *wait_mutex = SDL_CreateMutex();
2736 memset(st_index, -1, sizeof(st_index));
2737 is->last_video_stream = is->video_stream = -1;
2738 is->last_audio_stream = is->audio_stream = -1;
2739 is->last_subtitle_stream = is->subtitle_stream = -1;
2741 ic = avformat_alloc_context();
2742 ic->interrupt_callback.callback = decode_interrupt_cb;
2743 ic->interrupt_callback.opaque = is;
2744 err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2746 print_error(is->filename, err);
2750 if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2751 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2752 ret = AVERROR_OPTION_NOT_FOUND;
2758 ic->flags |= AVFMT_FLAG_GENPTS;
2760 opts = setup_find_stream_info_opts(ic, codec_opts);
2761 orig_nb_streams = ic->nb_streams;
2763 err = avformat_find_stream_info(ic, opts);
2765 av_log(NULL, AV_LOG_WARNING,
2766 "%s: could not find codec parameters\n", is->filename);
2770 for (i = 0; i < orig_nb_streams; i++)
2771 av_dict_free(&opts[i]);
2775 ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use url_feof() to test for the end
2777 if (seek_by_bytes < 0)
2778 seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2780 is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2782 if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2783 window_title = av_asprintf("%s - %s", t->value, input_filename);
2785 /* if seeking requested, we execute it */
2786 if (start_time != AV_NOPTS_VALUE) {
2789 timestamp = start_time;
2790 /* add the stream start time */
2791 if (ic->start_time != AV_NOPTS_VALUE)
2792 timestamp += ic->start_time;
2793 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2795 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2796 is->filename, (double)timestamp / AV_TIME_BASE);
2800 is->realtime = is_realtime(ic);
2802 for (i = 0; i < ic->nb_streams; i++)
2803 ic->streams[i]->discard = AVDISCARD_ALL;
2805 st_index[AVMEDIA_TYPE_VIDEO] =
2806 av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2807 wanted_stream[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2809 st_index[AVMEDIA_TYPE_AUDIO] =
2810 av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2811 wanted_stream[AVMEDIA_TYPE_AUDIO],
2812 st_index[AVMEDIA_TYPE_VIDEO],
2814 if (!video_disable && !subtitle_disable)
2815 st_index[AVMEDIA_TYPE_SUBTITLE] =
2816 av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2817 wanted_stream[AVMEDIA_TYPE_SUBTITLE],
2818 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2819 st_index[AVMEDIA_TYPE_AUDIO] :
2820 st_index[AVMEDIA_TYPE_VIDEO]),
2823 av_dump_format(ic, 0, is->filename, 0);
2826 is->show_mode = show_mode;
2828 /* open the streams */
2829 if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2830 stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2834 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2835 ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2837 if (is->show_mode == SHOW_MODE_NONE)
2838 is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2840 if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2841 stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2844 if (is->video_stream < 0 && is->audio_stream < 0) {
2845 av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2851 if (infinite_buffer < 0 && is->realtime)
2852 infinite_buffer = 1;
2855 if (is->abort_request)
2857 if (is->paused != is->last_paused) {
2858 is->last_paused = is->paused;
2860 is->read_pause_return = av_read_pause(ic);
2864 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2866 (!strcmp(ic->iformat->name, "rtsp") ||
2867 (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2868 /* wait 10 ms to avoid trying to get another packet */
2875 int64_t seek_target = is->seek_pos;
2876 int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2877 int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2878 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2879 // of the seek_pos/seek_rel variables
2881 ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2883 av_log(NULL, AV_LOG_ERROR,
2884 "%s: error while seeking\n", is->ic->filename);
2886 if (is->audio_stream >= 0) {
2887 packet_queue_flush(&is->audioq);
2888 packet_queue_put(&is->audioq, &flush_pkt);
2890 if (is->subtitle_stream >= 0) {
2891 packet_queue_flush(&is->subtitleq);
2892 packet_queue_put(&is->subtitleq, &flush_pkt);
2894 if (is->video_stream >= 0) {
2895 packet_queue_flush(&is->videoq);
2896 packet_queue_put(&is->videoq, &flush_pkt);
2898 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2899 set_clock(&is->extclk, NAN, 0);
2901 set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2905 is->queue_attachments_req = 1;
2908 step_to_next_frame(is);
2910 if (is->queue_attachments_req) {
2911 if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2913 if ((ret = av_copy_packet(©, &is->video_st->attached_pic)) < 0)
2915 packet_queue_put(&is->videoq, ©);
2916 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
2918 is->queue_attachments_req = 0;
2921 /* if the queue are full, no need to read more */
2922 if (infinite_buffer<1 &&
2923 (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
2924 || ( (is->audioq .nb_packets > MIN_FRAMES || is->audio_stream < 0 || is->audioq.abort_request)
2925 && (is->videoq .nb_packets > MIN_FRAMES || is->video_stream < 0 || is->videoq.abort_request
2926 || (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2927 && (is->subtitleq.nb_packets > MIN_FRAMES || is->subtitle_stream < 0 || is->subtitleq.abort_request)))) {
2929 SDL_LockMutex(wait_mutex);
2930 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
2931 SDL_UnlockMutex(wait_mutex);
2935 (!is->audio_st || is->audio_finished == is->audioq.serial) &&
2936 (!is->video_st || (is->video_finished == is->videoq.serial && is->pictq_size == 0))) {
2937 if (loop != 1 && (!loop || --loop)) {
2938 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
2939 } else if (autoexit) {
2945 if (is->video_stream >= 0)
2946 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
2947 if (is->audio_stream >= 0)
2948 packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
2953 ret = av_read_frame(ic, pkt);
2955 if (ret == AVERROR_EOF || url_feof(ic->pb))
2957 if (ic->pb && ic->pb->error)
2959 SDL_LockMutex(wait_mutex);
2960 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
2961 SDL_UnlockMutex(wait_mutex);
2964 /* check if packet is in play range specified by user, then queue, otherwise discard */
2965 stream_start_time = ic->streams[pkt->stream_index]->start_time;
2966 pkt_in_play_range = duration == AV_NOPTS_VALUE ||
2967 (pkt->pts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
2968 av_q2d(ic->streams[pkt->stream_index]->time_base) -
2969 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
2970 <= ((double)duration / 1000000);
2971 if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
2972 packet_queue_put(&is->audioq, pkt);
2973 } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
2974 && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
2975 packet_queue_put(&is->videoq, pkt);
2976 } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
2977 packet_queue_put(&is->subtitleq, pkt);
2979 av_free_packet(pkt);
2982 /* wait until the end */
2983 while (!is->abort_request) {
2989 /* close each stream */
2990 if (is->audio_stream >= 0)
2991 stream_component_close(is, is->audio_stream);
2992 if (is->video_stream >= 0)
2993 stream_component_close(is, is->video_stream);
2994 if (is->subtitle_stream >= 0)
2995 stream_component_close(is, is->subtitle_stream);
2997 avformat_close_input(&is->ic);
3003 event.type = FF_QUIT_EVENT;
3004 event.user.data1 = is;
3005 SDL_PushEvent(&event);
3007 SDL_DestroyMutex(wait_mutex);
3011 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3015 is = av_mallocz(sizeof(VideoState));
3018 av_strlcpy(is->filename, filename, sizeof(is->filename));
3019 is->iformat = iformat;
3023 /* start video display */
3024 is->pictq_mutex = SDL_CreateMutex();
3025 is->pictq_cond = SDL_CreateCond();
3027 is->subpq_mutex = SDL_CreateMutex();
3028 is->subpq_cond = SDL_CreateCond();
3030 packet_queue_init(&is->videoq);
3031 packet_queue_init(&is->audioq);
3032 packet_queue_init(&is->subtitleq);
3034 is->continue_read_thread = SDL_CreateCond();
3036 init_clock(&is->vidclk, &is->videoq.serial);
3037 init_clock(&is->audclk, &is->audioq.serial);
3038 init_clock(&is->extclk, &is->extclk.serial);
3039 is->audio_clock_serial = -1;
3040 is->audio_last_serial = -1;
3041 is->av_sync_type = av_sync_type;
3042 is->read_tid = SDL_CreateThread(read_thread, is);
3043 if (!is->read_tid) {
3050 static void stream_cycle_channel(VideoState *is, int codec_type)
3052 AVFormatContext *ic = is->ic;
3053 int start_index, stream_index;
3056 AVProgram *p = NULL;
3057 int nb_streams = is->ic->nb_streams;
3059 if (codec_type == AVMEDIA_TYPE_VIDEO) {
3060 start_index = is->last_video_stream;
3061 old_index = is->video_stream;
3062 } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3063 start_index = is->last_audio_stream;
3064 old_index = is->audio_stream;
3066 start_index = is->last_subtitle_stream;
3067 old_index = is->subtitle_stream;
3069 stream_index = start_index;
3071 if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3072 p = av_find_program_from_stream(ic, NULL, is->video_stream);
3074 nb_streams = p->nb_stream_indexes;
3075 for (start_index = 0; start_index < nb_streams; start_index++)
3076 if (p->stream_index[start_index] == stream_index)
3078 if (start_index == nb_streams)
3080 stream_index = start_index;
3085 if (++stream_index >= nb_streams)
3087 if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3090 is->last_subtitle_stream = -1;
3093 if (start_index == -1)
3097 if (stream_index == start_index)
3099 st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3100 if (st->codec->codec_type == codec_type) {
3101 /* check that parameters are OK */
3102 switch (codec_type) {
3103 case AVMEDIA_TYPE_AUDIO:
3104 if (st->codec->sample_rate != 0 &&
3105 st->codec->channels != 0)
3108 case AVMEDIA_TYPE_VIDEO:
3109 case AVMEDIA_TYPE_SUBTITLE:
3117 if (p && stream_index != -1)
3118 stream_index = p->stream_index[stream_index];
3119 stream_component_close(is, old_index);
3120 stream_component_open(is, stream_index);
3124 static void toggle_full_screen(VideoState *is)
3126 #if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
3127 /* OS X needs to reallocate the SDL overlays */
3129 for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
3130 is->pictq[i].reallocate = 1;
3132 is_full_screen = !is_full_screen;
3133 video_open(is, 1, NULL);
3136 static void toggle_audio_display(VideoState *is)
3138 int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
3139 int next = is->show_mode;
3141 next = (next + 1) % SHOW_MODE_NB;
3142 } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3143 if (is->show_mode != next) {
3144 fill_rectangle(screen,
3145 is->xleft, is->ytop, is->width, is->height,
3147 is->force_refresh = 1;
3148 is->show_mode = next;
3152 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3153 double remaining_time = 0.0;
3155 while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
3156 if (!cursor_hidden && av_gettime() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3160 if (remaining_time > 0.0)
3161 av_usleep((int64_t)(remaining_time * 1000000.0));
3162 remaining_time = REFRESH_RATE;
3163 if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3164 video_refresh(is, &remaining_time);
3169 /* handle an event sent by the GUI */
3170 static void event_loop(VideoState *cur_stream)
3173 double incr, pos, frac;
3177 refresh_loop_wait_event(cur_stream, &event);
3178 switch (event.type) {
3180 if (exit_on_keydown) {
3181 do_exit(cur_stream);
3184 switch (event.key.keysym.sym) {
3187 do_exit(cur_stream);
3190 toggle_full_screen(cur_stream);
3191 cur_stream->force_refresh = 1;
3195 toggle_pause(cur_stream);
3197 case SDLK_s: // S: Step to next frame
3198 step_to_next_frame(cur_stream);
3201 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3204 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3207 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3208 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3209 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3212 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3215 toggle_audio_display(cur_stream);
3235 if (seek_by_bytes) {
3236 if (cur_stream->video_stream >= 0 && cur_stream->video_current_pos >= 0) {
3237 pos = cur_stream->video_current_pos;
3238 } else if (cur_stream->audio_stream >= 0 && cur_stream->audio_pkt.pos >= 0) {
3239 pos = cur_stream->audio_pkt.pos;
3241 pos = avio_tell(cur_stream->ic->pb);
3242 if (cur_stream->ic->bit_rate)
3243 incr *= cur_stream->ic->bit_rate / 8.0;
3247 stream_seek(cur_stream, pos, incr, 1);
3249 pos = get_master_clock(cur_stream);
3251 pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3253 if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3254 pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3255 stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3262 case SDL_VIDEOEXPOSE:
3263 cur_stream->force_refresh = 1;
3265 case SDL_MOUSEBUTTONDOWN:
3266 if (exit_on_mousedown) {
3267 do_exit(cur_stream);
3270 case SDL_MOUSEMOTION:
3271 if (cursor_hidden) {
3275 cursor_last_shown = av_gettime();
3276 if (event.type == SDL_MOUSEBUTTONDOWN) {
3279 if (event.motion.state != SDL_PRESSED)
3283 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3284 uint64_t size = avio_size(cur_stream->ic->pb);
3285 stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3289 int tns, thh, tmm, tss;
3290 tns = cur_stream->ic->duration / 1000000LL;
3292 tmm = (tns % 3600) / 60;
3294 frac = x / cur_stream->width;
3297 mm = (ns % 3600) / 60;
3299 av_log(NULL, AV_LOG_INFO,
3300 "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3301 hh, mm, ss, thh, tmm, tss);
3302 ts = frac * cur_stream->ic->duration;
3303 if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3304 ts += cur_stream->ic->start_time;
3305 stream_seek(cur_stream, ts, 0, 0);
3308 case SDL_VIDEORESIZE:
3309 screen = SDL_SetVideoMode(FFMIN(16383, event.resize.w), event.resize.h, 0,
3310 SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
3312 av_log(NULL, AV_LOG_FATAL, "Failed to set video mode\n");
3313 do_exit(cur_stream);
3315 screen_width = cur_stream->width = screen->w;
3316 screen_height = cur_stream->height = screen->h;
3317 cur_stream->force_refresh = 1;
3321 do_exit(cur_stream);
3323 case FF_ALLOC_EVENT:
3324 alloc_picture(event.user.data1);
3332 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3334 av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3335 return opt_default(NULL, "video_size", arg);
3338 static int opt_width(void *optctx, const char *opt, const char *arg)
3340 screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3344 static int opt_height(void *optctx, const char *opt, const char *arg)
3346 screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3350 static int opt_format(void *optctx, const char *opt, const char *arg)
3352 file_iformat = av_find_input_format(arg);
3353 if (!file_iformat) {
3354 av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3355 return AVERROR(EINVAL);
3360 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3362 av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3363 return opt_default(NULL, "pixel_format", arg);
3366 static int opt_sync(void *optctx, const char *opt, const char *arg)
3368 if (!strcmp(arg, "audio"))
3369 av_sync_type = AV_SYNC_AUDIO_MASTER;
3370 else if (!strcmp(arg, "video"))
3371 av_sync_type = AV_SYNC_VIDEO_MASTER;
3372 else if (!strcmp(arg, "ext"))
3373 av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3375 av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3381 static int opt_seek(void *optctx, const char *opt, const char *arg)
3383 start_time = parse_time_or_die(opt, arg, 1);
3387 static int opt_duration(void *optctx, const char *opt, const char *arg)
3389 duration = parse_time_or_die(opt, arg, 1);
3393 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3395 show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3396 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3397 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
3398 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3402 static void opt_input_file(void *optctx, const char *filename)
3404 if (input_filename) {
3405 av_log(NULL, AV_LOG_FATAL,
3406 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3407 filename, input_filename);
3410 if (!strcmp(filename, "-"))
3412 input_filename = filename;
3415 static int opt_codec(void *optctx, const char *opt, const char *arg)
3417 const char *spec = strchr(opt, ':');
3419 av_log(NULL, AV_LOG_ERROR,
3420 "No media specifier was specified in '%s' in option '%s'\n",
3422 return AVERROR(EINVAL);
3426 case 'a' : audio_codec_name = arg; break;
3427 case 's' : subtitle_codec_name = arg; break;
3428 case 'v' : video_codec_name = arg; break;
3430 av_log(NULL, AV_LOG_ERROR,
3431 "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3432 return AVERROR(EINVAL);
3439 static const OptionDef options[] = {
3440 #include "cmdutils_common_opts.h"
3441 { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3442 { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3443 { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3444 { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3445 { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3446 { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3447 { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3448 { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_number" },
3449 { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_number" },
3450 { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_number" },
3451 { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3452 { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
3453 { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3454 { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3455 { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3456 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3457 { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3458 { "bug", OPT_INT | HAS_ARG | OPT_EXPERT, { &workaround_bugs }, "workaround bugs", "" },
3459 { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3460 { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3461 { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3462 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3463 { "ec", OPT_INT | HAS_ARG | OPT_EXPERT, { &error_concealment }, "set error concealment options", "bit_mask" },
3464 { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3465 { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3466 { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3467 { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3468 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3469 { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3470 { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3471 { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3473 { "vf", OPT_STRING | HAS_ARG, { &vfilters }, "set video filters", "filter_graph" },
3474 { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3476 { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3477 { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3478 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3479 { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3480 { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3481 { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
3482 { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3483 { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
3487 static void show_usage(void)
3489 av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3490 av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3491 av_log(NULL, AV_LOG_INFO, "\n");
3494 void show_help_default(const char *opt, const char *arg)
3496 av_log_set_callback(log_callback_help);
3498 show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3499 show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3501 show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3502 show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3503 #if !CONFIG_AVFILTER
3504 show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3506 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3508 printf("\nWhile playing:\n"
3510 "f toggle full screen\n"
3512 "a cycle audio channel in the current program\n"
3513 "v cycle video channel\n"
3514 "t cycle subtitle channel in the current program\n"
3516 "w show audio waves\n"
3517 "s activate frame-step mode\n"
3518 "left/right seek backward/forward 10 seconds\n"
3519 "down/up seek backward/forward 1 minute\n"
3520 "page down/page up seek backward/forward 10 minutes\n"
3521 "mouse click seek to percentage in file corresponding to fraction of width\n"
3525 static int lockmgr(void **mtx, enum AVLockOp op)
3528 case AV_LOCK_CREATE:
3529 *mtx = SDL_CreateMutex();
3533 case AV_LOCK_OBTAIN:
3534 return !!SDL_LockMutex(*mtx);
3535 case AV_LOCK_RELEASE:
3536 return !!SDL_UnlockMutex(*mtx);
3537 case AV_LOCK_DESTROY:
3538 SDL_DestroyMutex(*mtx);
3544 /* Called from the main */
3545 int main(int argc, char **argv)
3549 char dummy_videodriver[] = "SDL_VIDEODRIVER=dummy";
3551 av_log_set_flags(AV_LOG_SKIP_REPEATED);
3552 parse_loglevel(argc, argv, options);
3554 /* register all codecs, demux and protocols */
3555 avcodec_register_all();
3557 avdevice_register_all();
3560 avfilter_register_all();
3563 avformat_network_init();
3567 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
3568 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
3570 show_banner(argc, argv, options);
3572 parse_options(NULL, argc, argv, options, opt_input_file);
3574 if (!input_filename) {
3576 av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3577 av_log(NULL, AV_LOG_FATAL,
3578 "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3582 if (display_disable) {
3585 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3587 flags &= ~SDL_INIT_AUDIO;
3588 if (display_disable)
3589 SDL_putenv(dummy_videodriver); /* For the event queue, we always need a video driver. */
3590 #if !defined(__MINGW32__) && !defined(__APPLE__)
3591 flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
3593 if (SDL_Init (flags)) {
3594 av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3595 av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3599 if (!display_disable) {
3600 const SDL_VideoInfo *vi = SDL_GetVideoInfo();
3601 fs_screen_width = vi->current_w;
3602 fs_screen_height = vi->current_h;
3605 SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
3606 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3607 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3609 if (av_lockmgr_register(lockmgr)) {
3610 av_log(NULL, AV_LOG_FATAL, "Could not initialize lock manager!\n");
3614 av_init_packet(&flush_pkt);
3615 flush_pkt.data = (uint8_t *)&flush_pkt;
3617 is = stream_open(input_filename, file_iformat);
3619 av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");