2 * avplay : Simple Media Player based on the Libav libraries
3 * Copyright (c) 2003 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 #include "libavutil/avstring.h"
29 #include "libavutil/colorspace.h"
30 #include "libavutil/display.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/dict.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/samplefmt.h"
37 #include "libavutil/time.h"
38 #include "libavformat/avformat.h"
39 #include "libavdevice/avdevice.h"
40 #include "libavresample/avresample.h"
41 #include "libavutil/opt.h"
42 #include "libavcodec/avfft.h"
44 #include "libavfilter/avfilter.h"
45 #include "libavfilter/buffersink.h"
46 #include "libavfilter/buffersrc.h"
51 #include <SDL_thread.h>
54 #undef main /* We don't want SDL to override our main() */
59 const char program_name
[] = "avplay";
60 const int program_birth_year
= 2003;
62 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
63 #define MIN_AUDIOQ_SIZE (20 * 16 * 1024)
66 /* SDL audio buffer size, in samples. Should be small to have precise
67 A/V sync as SDL does not have hardware buffer fullness info. */
68 #define SDL_AUDIO_BUFFER_SIZE 1024
70 /* no AV sync correction is done if below the AV sync threshold */
71 #define AV_SYNC_THRESHOLD 0.01
72 /* no AV correction is done if too big error */
73 #define AV_NOSYNC_THRESHOLD 10.0
75 #define FRAME_SKIP_FACTOR 0.05
77 /* maximum audio speed change to get correct sync */
78 #define SAMPLE_CORRECTION_PERCENT_MAX 10
80 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
81 #define AUDIO_DIFF_AVG_NB 20
83 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
84 #define SAMPLE_ARRAY_SIZE (2 * 65536)
86 static int64_t sws_flags
= SWS_BICUBIC
;
88 typedef struct PacketQueue
{
89 AVPacketList
*first_pkt
, *last_pkt
;
97 #define VIDEO_PICTURE_QUEUE_SIZE 2
98 #define SUBPICTURE_QUEUE_SIZE 4
100 typedef struct VideoPicture
{
101 double pts
; // presentation timestamp for this picture
102 double target_clock
; // av_gettime_relative() time at which this should be displayed ideally
103 int64_t pos
; // byte position in file
105 int width
, height
; /* source height & width */
108 enum AVPixelFormat pix_fmt
;
113 typedef struct SubPicture
{
114 double pts
; /* presentation time stamp for this picture */
119 AV_SYNC_AUDIO_MASTER
, /* default choice */
120 AV_SYNC_VIDEO_MASTER
,
121 AV_SYNC_EXTERNAL_CLOCK
, /* synchronize to an external clock */
124 typedef struct PlayerState
{
125 SDL_Thread
*parse_tid
;
126 SDL_Thread
*video_tid
;
127 SDL_Thread
*refresh_tid
;
128 AVInputFormat
*iformat
;
137 int read_pause_return
;
143 double external_clock
; /* external clock base */
144 int64_t external_clock_time
;
147 double audio_diff_cum
; /* used for AV difference average computation */
148 double audio_diff_avg_coef
;
149 double audio_diff_threshold
;
150 int audio_diff_avg_count
;
152 AVCodecContext
*audio_dec
;
154 int audio_hw_buf_size
;
155 uint8_t silence_buf
[SDL_AUDIO_BUFFER_SIZE
];
158 unsigned int audio_buf_size
; /* in bytes */
159 int audio_buf_index
; /* in bytes */
160 AVPacket audio_pkt_temp
;
162 enum AVSampleFormat sdl_sample_fmt
;
163 uint64_t sdl_channel_layout
;
166 enum AVSampleFormat resample_sample_fmt
;
167 uint64_t resample_channel_layout
;
168 int resample_sample_rate
;
169 AVAudioResampleContext
*avr
;
172 int show_audio
; /* if true, display audio samples */
173 int16_t sample_array
[SAMPLE_ARRAY_SIZE
];
174 int sample_array_index
;
178 FFTSample
*rdft_data
;
181 SDL_Thread
*subtitle_tid
;
183 int subtitle_stream_changed
;
184 AVStream
*subtitle_st
;
185 AVCodecContext
*subtitle_dec
;
186 PacketQueue subtitleq
;
187 SubPicture subpq
[SUBPICTURE_QUEUE_SIZE
];
188 int subpq_size
, subpq_rindex
, subpq_windex
;
189 SDL_mutex
*subpq_mutex
;
190 SDL_cond
*subpq_cond
;
193 double frame_last_pts
;
194 double frame_last_delay
;
195 double video_clock
; // pts of last decoded frame / predicted pts of next decoded frame
198 AVCodecContext
*video_dec
;
200 double video_current_pts
; // current displayed pts (different from video_clock if frame fifos are used)
201 double video_current_pts_drift
; // video_current_pts - time (av_gettime_relative) at which we updated video_current_pts - used to have running video pts
202 int64_t video_current_pos
; // current displayed file pos
203 VideoPicture pictq
[VIDEO_PICTURE_QUEUE_SIZE
];
204 int pictq_size
, pictq_rindex
, pictq_windex
;
205 SDL_mutex
*pictq_mutex
;
206 SDL_cond
*pictq_cond
;
208 // QETimer *video_timer;
210 int width
, height
, xleft
, ytop
;
212 PtsCorrectionContext pts_ctx
;
214 AVFilterContext
*in_video_filter
; // the first filter in the video chain
215 AVFilterContext
*out_video_filter
; // the last filter in the video chain
218 float skip_frames_index
;
221 SpecifierOpt
*codec_names
;
225 /* options specified by the user */
226 static AVInputFormat
*file_iformat
;
227 static const char *input_filename
;
228 static const char *window_title
;
229 static int fs_screen_width
;
230 static int fs_screen_height
;
231 static int screen_width
= 0;
232 static int screen_height
= 0;
233 static int audio_disable
;
234 static int video_disable
;
235 static int wanted_stream
[AVMEDIA_TYPE_NB
] = {
236 [AVMEDIA_TYPE_AUDIO
] = -1,
237 [AVMEDIA_TYPE_VIDEO
] = -1,
238 [AVMEDIA_TYPE_SUBTITLE
] = -1,
240 static int seek_by_bytes
= -1;
241 static int display_disable
;
242 static int show_status
= 1;
243 static int av_sync_type
= AV_SYNC_AUDIO_MASTER
;
244 static int64_t start_time
= AV_NOPTS_VALUE
;
245 static int64_t duration
= AV_NOPTS_VALUE
;
247 static int workaround_bugs
= 1;
249 static int genpts
= 0;
250 static int idct
= FF_IDCT_AUTO
;
251 static enum AVDiscard skip_frame
= AVDISCARD_DEFAULT
;
252 static enum AVDiscard skip_idct
= AVDISCARD_DEFAULT
;
253 static enum AVDiscard skip_loop_filter
= AVDISCARD_DEFAULT
;
254 static int error_concealment
= 3;
255 static int decoder_reorder_pts
= -1;
256 static int noautoexit
;
257 static int exit_on_keydown
;
258 static int exit_on_mousedown
;
260 static int framedrop
= 1;
261 static int infinite_buffer
= 0;
263 static int rdftspeed
= 20;
264 static char *vfilters
= NULL
;
265 static int autorotate
= 1;
267 /* current context */
268 static int is_full_screen
;
269 static PlayerState player_state
;
270 static PlayerState
*player
= &player_state
;
271 static int64_t audio_callback_time
;
273 static AVPacket flush_pkt
;
275 #define FF_ALLOC_EVENT (SDL_USEREVENT)
276 #define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
277 #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
279 static SDL_Surface
*screen
;
281 static int packet_queue_put(PacketQueue
*q
, AVPacket
*pkt
);
283 /* packet queue handling */
284 static void packet_queue_init(PacketQueue
*q
)
286 memset(q
, 0, sizeof(PacketQueue
));
287 q
->mutex
= SDL_CreateMutex();
288 q
->cond
= SDL_CreateCond();
289 packet_queue_put(q
, &flush_pkt
);
292 static void packet_queue_flush(PacketQueue
*q
)
294 AVPacketList
*pkt
, *pkt1
;
296 SDL_LockMutex(q
->mutex
);
297 for (pkt
= q
->first_pkt
; pkt
!= NULL
; pkt
= pkt1
) {
299 av_packet_unref(&pkt
->pkt
);
306 SDL_UnlockMutex(q
->mutex
);
309 static void packet_queue_end(PacketQueue
*q
)
311 packet_queue_flush(q
);
312 SDL_DestroyMutex(q
->mutex
);
313 SDL_DestroyCond(q
->cond
);
316 static int packet_queue_put(PacketQueue
*q
, AVPacket
*pkt
)
320 pkt1
= av_malloc(sizeof(AVPacketList
));
327 SDL_LockMutex(q
->mutex
);
333 q
->last_pkt
->next
= pkt1
;
336 q
->size
+= pkt1
->pkt
.size
+ sizeof(*pkt1
);
337 /* XXX: should duplicate packet data in DV case */
338 SDL_CondSignal(q
->cond
);
340 SDL_UnlockMutex(q
->mutex
);
344 static void packet_queue_abort(PacketQueue
*q
)
346 SDL_LockMutex(q
->mutex
);
348 q
->abort_request
= 1;
350 SDL_CondSignal(q
->cond
);
352 SDL_UnlockMutex(q
->mutex
);
355 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
356 static int packet_queue_get(PacketQueue
*q
, AVPacket
*pkt
, int block
)
361 SDL_LockMutex(q
->mutex
);
364 if (q
->abort_request
) {
371 q
->first_pkt
= pkt1
->next
;
375 q
->size
-= pkt1
->pkt
.size
+ sizeof(*pkt1
);
384 SDL_CondWait(q
->cond
, q
->mutex
);
387 SDL_UnlockMutex(q
->mutex
);
391 static inline void fill_rectangle(SDL_Surface
*screen
,
392 int x
, int y
, int w
, int h
, int color
)
399 SDL_FillRect(screen
, &rect
, color
);
402 #define ALPHA_BLEND(a, oldp, newp, s)\
403 ((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
405 #define RGBA_IN(r, g, b, a, s)\
407 unsigned int v = ((const uint32_t *)(s))[0];\
408 a = (v >> 24) & 0xff;\
409 r = (v >> 16) & 0xff;\
410 g = (v >> 8) & 0xff;\
414 #define YUVA_IN(y, u, v, a, s, pal)\
416 unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
417 a = (val >> 24) & 0xff;\
418 y = (val >> 16) & 0xff;\
419 u = (val >> 8) & 0xff;\
423 #define YUVA_OUT(d, y, u, v, a)\
425 ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
431 static void blend_subrect(uint8_t *dst
[4], uint16_t dst_linesize
[4],
432 const AVSubtitleRect
*rect
, int imgw
, int imgh
)
434 int wrap
, wrap3
, width2
, skip2
;
435 int y
, u
, v
, a
, u1
, v1
, a1
, w
, h
;
436 uint8_t *lum
, *cb
, *cr
;
439 int dstx
, dsty
, dstw
, dsth
;
441 dstw
= av_clip(rect
->w
, 0, imgw
);
442 dsth
= av_clip(rect
->h
, 0, imgh
);
443 dstx
= av_clip(rect
->x
, 0, imgw
- dstw
);
444 dsty
= av_clip(rect
->y
, 0, imgh
- dsth
);
445 /* sdl has U and V inverted */
446 lum
= dst
[0] + dsty
* dst_linesize
[0];
447 cb
= dst
[2] + (dsty
>> 1) * dst_linesize
[2];
448 cr
= dst
[1] + (dsty
>> 1) * dst_linesize
[1];
450 width2
= ((dstw
+ 1) >> 1) + (dstx
& ~dstw
& 1);
452 wrap
= dst_linesize
[0];
453 wrap3
= rect
->linesize
[0];
455 pal
= (const uint32_t *)rect
->data
[1]; /* Now in YCrCb! */
463 YUVA_IN(y
, u
, v
, a
, p
, pal
);
464 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
465 cb
[0] = ALPHA_BLEND(a
>> 2, cb
[0], u
, 0);
466 cr
[0] = ALPHA_BLEND(a
>> 2, cr
[0], v
, 0);
472 for (w
= dstw
- (dstx
& 1); w
>= 2; w
-= 2) {
473 YUVA_IN(y
, u
, v
, a
, p
, pal
);
477 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
479 YUVA_IN(y
, u
, v
, a
, p
+ BPP
, pal
);
483 lum
[1] = ALPHA_BLEND(a
, lum
[1], y
, 0);
484 cb
[0] = ALPHA_BLEND(a1
>> 2, cb
[0], u1
, 1);
485 cr
[0] = ALPHA_BLEND(a1
>> 2, cr
[0], v1
, 1);
492 YUVA_IN(y
, u
, v
, a
, p
, pal
);
493 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
494 cb
[0] = ALPHA_BLEND(a
>> 2, cb
[0], u
, 0);
495 cr
[0] = ALPHA_BLEND(a
>> 2, cr
[0], v
, 0);
499 p
+= wrap3
- dstw
* BPP
;
500 lum
+= wrap
- dstw
- dstx
;
501 cb
+= dst_linesize
[2] - width2
- skip2
;
502 cr
+= dst_linesize
[1] - width2
- skip2
;
504 for (h
= dsth
- (dsty
& 1); h
>= 2; h
-= 2) {
510 YUVA_IN(y
, u
, v
, a
, p
, pal
);
514 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
517 YUVA_IN(y
, u
, v
, a
, p
, pal
);
521 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
522 cb
[0] = ALPHA_BLEND(a1
>> 2, cb
[0], u1
, 1);
523 cr
[0] = ALPHA_BLEND(a1
>> 2, cr
[0], v1
, 1);
529 for (w
= dstw
- (dstx
& 1); w
>= 2; w
-= 2) {
530 YUVA_IN(y
, u
, v
, a
, p
, pal
);
534 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
536 YUVA_IN(y
, u
, v
, a
, p
+ BPP
, pal
);
540 lum
[1] = ALPHA_BLEND(a
, lum
[1], y
, 0);
544 YUVA_IN(y
, u
, v
, a
, p
, pal
);
548 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
550 YUVA_IN(y
, u
, v
, a
, p
+ BPP
, pal
);
554 lum
[1] = ALPHA_BLEND(a
, lum
[1], y
, 0);
556 cb
[0] = ALPHA_BLEND(a1
>> 2, cb
[0], u1
, 2);
557 cr
[0] = ALPHA_BLEND(a1
>> 2, cr
[0], v1
, 2);
561 p
+= -wrap3
+ 2 * BPP
;
565 YUVA_IN(y
, u
, v
, a
, p
, pal
);
569 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
572 YUVA_IN(y
, u
, v
, a
, p
, pal
);
576 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
577 cb
[0] = ALPHA_BLEND(a1
>> 2, cb
[0], u1
, 1);
578 cr
[0] = ALPHA_BLEND(a1
>> 2, cr
[0], v1
, 1);
584 p
+= wrap3
+ (wrap3
- dstw
* BPP
);
585 lum
+= wrap
+ (wrap
- dstw
- dstx
);
586 cb
+= dst_linesize
[2] - width2
- skip2
;
587 cr
+= dst_linesize
[1] - width2
- skip2
;
589 /* handle odd height */
596 YUVA_IN(y
, u
, v
, a
, p
, pal
);
597 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
598 cb
[0] = ALPHA_BLEND(a
>> 2, cb
[0], u
, 0);
599 cr
[0] = ALPHA_BLEND(a
>> 2, cr
[0], v
, 0);
605 for (w
= dstw
- (dstx
& 1); w
>= 2; w
-= 2) {
606 YUVA_IN(y
, u
, v
, a
, p
, pal
);
610 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
612 YUVA_IN(y
, u
, v
, a
, p
+ BPP
, pal
);
616 lum
[1] = ALPHA_BLEND(a
, lum
[1], y
, 0);
617 cb
[0] = ALPHA_BLEND(a1
>> 2, cb
[0], u
, 1);
618 cr
[0] = ALPHA_BLEND(a1
>> 2, cr
[0], v
, 1);
625 YUVA_IN(y
, u
, v
, a
, p
, pal
);
626 lum
[0] = ALPHA_BLEND(a
, lum
[0], y
, 0);
627 cb
[0] = ALPHA_BLEND(a
>> 2, cb
[0], u
, 0);
628 cr
[0] = ALPHA_BLEND(a
>> 2, cr
[0], v
, 0);
633 static void free_subpicture(SubPicture
*sp
)
635 avsubtitle_free(&sp
->sub
);
638 static void video_image_display(PlayerState
*is
)
643 int width
, height
, x
, y
;
647 vp
= &is
->pictq
[is
->pictq_rindex
];
652 aspect_ratio
= av_q2d(vp
->sar
);
653 if (aspect_ratio
<= 0.0)
655 aspect_ratio
*= (float)vp
->width
/ (float)vp
->height
;
659 if (is
->subpq_size
> 0)
661 sp
= &is
->subpq
[is
->subpq_rindex
];
663 if (vp
->pts
>= sp
->pts
+ ((float) sp
->sub
.start_display_time
/ 1000))
665 SDL_LockYUVOverlay (vp
->bmp
);
667 for (i
= 0; i
< sp
->sub
.num_rects
; i
++)
668 blend_subrect(vp
->bmp
->pixels
, vp
->bmp
->pitches
,
669 sp
->sub
.rects
[i
], vp
->bmp
->w
, vp
->bmp
->h
);
671 SDL_UnlockYUVOverlay (vp
->bmp
);
677 /* XXX: we suppose the screen has a 1.0 pixel ratio */
679 width
= ((int)rint(height
* aspect_ratio
)) & ~1;
680 if (width
> is
->width
) {
682 height
= ((int)rint(width
/ aspect_ratio
)) & ~1;
684 x
= (is
->width
- width
) / 2;
685 y
= (is
->height
- height
) / 2;
686 is
->no_background
= 0;
687 rect
.x
= is
->xleft
+ x
;
688 rect
.y
= is
->ytop
+ y
;
691 SDL_DisplayYUVOverlay(vp
->bmp
, &rect
);
695 /* get the current audio output buffer size, in samples. With SDL, we
696 cannot have a precise information */
697 static int audio_write_get_buf_size(PlayerState
*is
)
699 return is
->audio_buf_size
- is
->audio_buf_index
;
702 static inline int compute_mod(int a
, int b
)
711 static void video_audio_display(PlayerState
*s
)
713 int i
, i_start
, x
, y1
, y
, ys
, delay
, n
, nb_display_channels
;
714 int ch
, channels
, h
, h2
, bgcolor
, fgcolor
;
716 int rdft_bits
, nb_freq
;
718 for (rdft_bits
= 1; (1 << rdft_bits
) < 2 * s
->height
; rdft_bits
++)
720 nb_freq
= 1 << (rdft_bits
- 1);
722 /* compute display index : center on currently output samples */
723 channels
= s
->sdl_channels
;
724 nb_display_channels
= channels
;
726 int data_used
= s
->show_audio
== 1 ? s
->width
: (2 * nb_freq
);
728 delay
= audio_write_get_buf_size(s
);
731 /* to be more precise, we take into account the time spent since
732 the last buffer computation */
733 if (audio_callback_time
) {
734 time_diff
= av_gettime_relative() - audio_callback_time
;
735 delay
-= (time_diff
* s
->sdl_sample_rate
) / 1000000;
738 delay
+= 2 * data_used
;
739 if (delay
< data_used
)
742 i_start
= x
= compute_mod(s
->sample_array_index
- delay
* channels
, SAMPLE_ARRAY_SIZE
);
743 if (s
->show_audio
== 1) {
745 for (i
= 0; i
< 1000; i
+= channels
) {
746 int idx
= (SAMPLE_ARRAY_SIZE
+ x
- i
) % SAMPLE_ARRAY_SIZE
;
747 int a
= s
->sample_array
[idx
];
748 int b
= s
->sample_array
[(idx
+ 4 * channels
) % SAMPLE_ARRAY_SIZE
];
749 int c
= s
->sample_array
[(idx
+ 5 * channels
) % SAMPLE_ARRAY_SIZE
];
750 int d
= s
->sample_array
[(idx
+ 9 * channels
) % SAMPLE_ARRAY_SIZE
];
752 if (h
< score
&& (b
^ c
) < 0) {
759 s
->last_i_start
= i_start
;
761 i_start
= s
->last_i_start
;
764 bgcolor
= SDL_MapRGB(screen
->format
, 0x00, 0x00, 0x00);
765 if (s
->show_audio
== 1) {
766 fill_rectangle(screen
,
767 s
->xleft
, s
->ytop
, s
->width
, s
->height
,
770 fgcolor
= SDL_MapRGB(screen
->format
, 0xff, 0xff, 0xff);
772 /* total height for one channel */
773 h
= s
->height
/ nb_display_channels
;
774 /* graph height / 2 */
776 for (ch
= 0; ch
< nb_display_channels
; ch
++) {
778 y1
= s
->ytop
+ ch
* h
+ (h
/ 2); /* position of center line */
779 for (x
= 0; x
< s
->width
; x
++) {
780 y
= (s
->sample_array
[i
] * h2
) >> 15;
787 fill_rectangle(screen
,
788 s
->xleft
+ x
, ys
, 1, y
,
791 if (i
>= SAMPLE_ARRAY_SIZE
)
792 i
-= SAMPLE_ARRAY_SIZE
;
796 fgcolor
= SDL_MapRGB(screen
->format
, 0x00, 0x00, 0xff);
798 for (ch
= 1; ch
< nb_display_channels
; ch
++) {
799 y
= s
->ytop
+ ch
* h
;
800 fill_rectangle(screen
,
801 s
->xleft
, y
, s
->width
, 1,
804 SDL_UpdateRect(screen
, s
->xleft
, s
->ytop
, s
->width
, s
->height
);
806 nb_display_channels
= FFMIN(nb_display_channels
, 2);
807 if (rdft_bits
!= s
->rdft_bits
) {
808 av_rdft_end(s
->rdft
);
809 av_free(s
->rdft_data
);
810 s
->rdft
= av_rdft_init(rdft_bits
, DFT_R2C
);
811 s
->rdft_bits
= rdft_bits
;
812 s
->rdft_data
= av_malloc(4 * nb_freq
* sizeof(*s
->rdft_data
));
816 for (ch
= 0; ch
< nb_display_channels
; ch
++) {
817 data
[ch
] = s
->rdft_data
+ 2 * nb_freq
* ch
;
819 for (x
= 0; x
< 2 * nb_freq
; x
++) {
820 double w
= (x
-nb_freq
) * (1.0 / nb_freq
);
821 data
[ch
][x
] = s
->sample_array
[i
] * (1.0 - w
* w
);
823 if (i
>= SAMPLE_ARRAY_SIZE
)
824 i
-= SAMPLE_ARRAY_SIZE
;
826 av_rdft_calc(s
->rdft
, data
[ch
]);
828 /* Least efficient way to do this, we should of course
829 * directly access it but it is more than fast enough. */
830 for (y
= 0; y
< s
->height
; y
++) {
831 double w
= 1 / sqrt(nb_freq
);
832 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]));
833 int b
= (nb_display_channels
== 2 ) ?
sqrt(w
* sqrt(data
[1][2 * y
+ 0] * data
[1][2 * y
+ 0]
834 + data
[1][2 * y
+ 1] * data
[1][2 * y
+ 1])) : a
;
837 fgcolor
= SDL_MapRGB(screen
->format
, a
, b
, (a
+ b
) / 2);
839 fill_rectangle(screen
,
840 s
->xpos
, s
->height
-y
, 1, 1,
844 SDL_UpdateRect(screen
, s
->xpos
, s
->ytop
, 1, s
->height
);
846 if (s
->xpos
>= s
->width
)
851 static int video_open(PlayerState
*is
)
853 int flags
= SDL_HWSURFACE
| SDL_ASYNCBLIT
| SDL_HWACCEL
;
856 if (is_full_screen
) flags
|= SDL_FULLSCREEN
;
857 else flags
|= SDL_RESIZABLE
;
859 if (is_full_screen
&& fs_screen_width
) {
861 h
= fs_screen_height
;
862 } else if (!is_full_screen
&& screen_width
) {
865 } else if (is
->out_video_filter
&& is
->out_video_filter
->inputs
[0]) {
866 w
= is
->out_video_filter
->inputs
[0]->w
;
867 h
= is
->out_video_filter
->inputs
[0]->h
;
872 if (screen
&& is
->width
== screen
->w
&& screen
->w
== w
873 && is
->height
== screen
->h
&& screen
->h
== h
)
876 #if defined(__APPLE__) && !SDL_VERSION_ATLEAST(1, 2, 14)
877 /* setting bits_per_pixel = 0 or 32 causes blank video on OS X and older SDL */
878 screen
= SDL_SetVideoMode(w
, h
, 24, flags
);
880 screen
= SDL_SetVideoMode(w
, h
, 0, flags
);
883 fprintf(stderr
, "SDL: could not set video mode - exiting\n");
887 window_title
= input_filename
;
888 SDL_WM_SetCaption(window_title
, window_title
);
890 is
->width
= screen
->w
;
891 is
->height
= screen
->h
;
896 /* display the current picture, if any */
897 static void video_display(PlayerState
*is
)
901 if (is
->audio_st
&& is
->show_audio
)
902 video_audio_display(is
);
903 else if (is
->video_st
)
904 video_image_display(is
);
907 static int refresh_thread(void *opaque
)
909 PlayerState
*is
= opaque
;
910 while (!is
->abort_request
) {
912 event
.type
= FF_REFRESH_EVENT
;
913 event
.user
.data1
= opaque
;
916 SDL_PushEvent(&event
);
918 av_usleep(is
->audio_st
&& is
->show_audio ? rdftspeed
* 1000 : 5000); // FIXME ideally we should wait the correct time but SDLs event passing is so slow it would be silly
923 /* get the current audio clock value */
924 static double get_audio_clock(PlayerState
*is
)
927 int hw_buf_size
, bytes_per_sec
;
928 pts
= is
->audio_clock
;
929 hw_buf_size
= audio_write_get_buf_size(is
);
932 bytes_per_sec
= is
->sdl_sample_rate
* is
->sdl_channels
*
933 av_get_bytes_per_sample(is
->sdl_sample_fmt
);
936 pts
-= (double)hw_buf_size
/ bytes_per_sec
;
940 /* get the current video clock value */
941 static double get_video_clock(PlayerState
*is
)
944 return is
->video_current_pts
;
946 return is
->video_current_pts_drift
+ av_gettime_relative() / 1000000.0;
950 /* get the current external clock value */
951 static double get_external_clock(PlayerState
*is
)
954 ti
= av_gettime_relative();
955 return is
->external_clock
+ ((ti
- is
->external_clock_time
) * 1e-6);
958 /* get the current master clock value */
959 static double get_master_clock(PlayerState
*is
)
963 if (is
->av_sync_type
== AV_SYNC_VIDEO_MASTER
) {
965 val
= get_video_clock(is
);
967 val
= get_audio_clock(is
);
968 } else if (is
->av_sync_type
== AV_SYNC_AUDIO_MASTER
) {
970 val
= get_audio_clock(is
);
972 val
= get_video_clock(is
);
974 val
= get_external_clock(is
);
979 /* seek in the stream */
980 static void stream_seek(PlayerState
*is
, int64_t pos
, int64_t rel
, int seek_by_bytes
)
985 is
->seek_flags
&= ~AVSEEK_FLAG_BYTE
;
987 is
->seek_flags
|= AVSEEK_FLAG_BYTE
;
992 /* pause or resume the video */
993 static void stream_pause(PlayerState
*is
)
996 is
->frame_timer
+= av_gettime_relative() / 1000000.0 + is
->video_current_pts_drift
- is
->video_current_pts
;
997 if (is
->read_pause_return
!= AVERROR(ENOSYS
)) {
998 is
->video_current_pts
= is
->video_current_pts_drift
+ av_gettime_relative() / 1000000.0;
1000 is
->video_current_pts_drift
= is
->video_current_pts
- av_gettime_relative() / 1000000.0;
1002 is
->paused
= !is
->paused
;
1005 static double compute_target_time(double frame_current_pts
, PlayerState
*is
)
1007 double delay
, sync_threshold
, diff
= 0;
1009 /* compute nominal delay */
1010 delay
= frame_current_pts
- is
->frame_last_pts
;
1011 if (delay
<= 0 || delay
>= 10.0) {
1012 /* if incorrect delay, use previous one */
1013 delay
= is
->frame_last_delay
;
1015 is
->frame_last_delay
= delay
;
1017 is
->frame_last_pts
= frame_current_pts
;
1019 /* update delay to follow master synchronisation source */
1020 if (((is
->av_sync_type
== AV_SYNC_AUDIO_MASTER
&& is
->audio_st
) ||
1021 is
->av_sync_type
== AV_SYNC_EXTERNAL_CLOCK
)) {
1022 /* if video is slave, we try to correct big delays by
1023 duplicating or deleting a frame */
1024 diff
= get_video_clock(is
) - get_master_clock(is
);
1026 /* skip or repeat frame. We take into account the
1027 delay to compute the threshold. I still don't know
1028 if it is the best guess */
1029 sync_threshold
= FFMAX(AV_SYNC_THRESHOLD
, delay
);
1030 if (fabs(diff
) < AV_NOSYNC_THRESHOLD
) {
1031 if (diff
<= -sync_threshold
)
1033 else if (diff
>= sync_threshold
)
1037 is
->frame_timer
+= delay
;
1039 av_log(NULL
, AV_LOG_TRACE
, "video: delay=%0.3f pts=%0.3f A-V=%f\n",
1040 delay
, frame_current_pts
, -diff
);
1042 return is
->frame_timer
;
1045 /* called to display each frame */
1046 static void video_refresh_timer(void *opaque
)
1048 PlayerState
*is
= opaque
;
1051 SubPicture
*sp
, *sp2
;
1055 if (is
->pictq_size
== 0) {
1056 // nothing to do, no picture to display in the que
1058 double time
= av_gettime_relative() / 1000000.0;
1060 /* dequeue the picture */
1061 vp
= &is
->pictq
[is
->pictq_rindex
];
1063 if (time
< vp
->target_clock
)
1065 /* update current video pts */
1066 is
->video_current_pts
= vp
->pts
;
1067 is
->video_current_pts_drift
= is
->video_current_pts
- time
;
1068 is
->video_current_pos
= vp
->pos
;
1069 if (is
->pictq_size
> 1) {
1070 VideoPicture
*nextvp
= &is
->pictq
[(is
->pictq_rindex
+ 1) % VIDEO_PICTURE_QUEUE_SIZE
];
1071 assert(nextvp
->target_clock
>= vp
->target_clock
);
1072 next_target
= nextvp
->target_clock
;
1074 next_target
= vp
->target_clock
+ is
->video_clock
- vp
->pts
; // FIXME pass durations cleanly
1076 if (framedrop
&& time
> next_target
) {
1077 is
->skip_frames
*= 1.0 + FRAME_SKIP_FACTOR
;
1078 if (is
->pictq_size
> 1 || time
> next_target
+ 0.5) {
1079 /* update queue size and signal for next picture */
1080 if (++is
->pictq_rindex
== VIDEO_PICTURE_QUEUE_SIZE
)
1081 is
->pictq_rindex
= 0;
1083 SDL_LockMutex(is
->pictq_mutex
);
1085 SDL_CondSignal(is
->pictq_cond
);
1086 SDL_UnlockMutex(is
->pictq_mutex
);
1091 if (is
->subtitle_st
) {
1092 if (is
->subtitle_stream_changed
) {
1093 SDL_LockMutex(is
->subpq_mutex
);
1095 while (is
->subpq_size
) {
1096 free_subpicture(&is
->subpq
[is
->subpq_rindex
]);
1098 /* update queue size and signal for next picture */
1099 if (++is
->subpq_rindex
== SUBPICTURE_QUEUE_SIZE
)
1100 is
->subpq_rindex
= 0;
1104 is
->subtitle_stream_changed
= 0;
1106 SDL_CondSignal(is
->subpq_cond
);
1107 SDL_UnlockMutex(is
->subpq_mutex
);
1109 if (is
->subpq_size
> 0) {
1110 sp
= &is
->subpq
[is
->subpq_rindex
];
1112 if (is
->subpq_size
> 1)
1113 sp2
= &is
->subpq
[(is
->subpq_rindex
+ 1) % SUBPICTURE_QUEUE_SIZE
];
1117 if ((is
->video_current_pts
> (sp
->pts
+ ((float) sp
->sub
.end_display_time
/ 1000)))
1118 || (sp2
&& is
->video_current_pts
> (sp2
->pts
+ ((float) sp2
->sub
.start_display_time
/ 1000))))
1120 free_subpicture(sp
);
1122 /* update queue size and signal for next picture */
1123 if (++is
->subpq_rindex
== SUBPICTURE_QUEUE_SIZE
)
1124 is
->subpq_rindex
= 0;
1126 SDL_LockMutex(is
->subpq_mutex
);
1128 SDL_CondSignal(is
->subpq_cond
);
1129 SDL_UnlockMutex(is
->subpq_mutex
);
1135 /* display picture */
1136 if (!display_disable
)
1139 /* update queue size and signal for next picture */
1140 if (++is
->pictq_rindex
== VIDEO_PICTURE_QUEUE_SIZE
)
1141 is
->pictq_rindex
= 0;
1143 SDL_LockMutex(is
->pictq_mutex
);
1145 SDL_CondSignal(is
->pictq_cond
);
1146 SDL_UnlockMutex(is
->pictq_mutex
);
1148 } else if (is
->audio_st
) {
1149 /* draw the next audio frame */
1151 /* if only audio stream, then display the audio bars (better
1152 than nothing, just to test the implementation */
1154 /* display picture */
1155 if (!display_disable
)
1159 static int64_t last_time
;
1161 int aqsize
, vqsize
, sqsize
;
1164 cur_time
= av_gettime_relative();
1165 if (!last_time
|| (cur_time
- last_time
) >= 30000) {
1170 aqsize
= is
->audioq
.size
;
1172 vqsize
= is
->videoq
.size
;
1173 if (is
->subtitle_st
)
1174 sqsize
= is
->subtitleq
.size
;
1176 if (is
->audio_st
&& is
->video_st
)
1177 av_diff
= get_audio_clock(is
) - get_video_clock(is
);
1178 printf("%7.2f A-V:%7.3f s:%3.1f aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64
"/%"PRId64
" \r",
1179 get_master_clock(is
), av_diff
, FFMAX(is
->skip_frames
- 1, 0), aqsize
/ 1024,
1180 vqsize
/ 1024, sqsize
, is
->pts_ctx
.num_faulty_dts
, is
->pts_ctx
.num_faulty_pts
);
1182 last_time
= cur_time
;
1187 static void player_close(PlayerState
*is
)
1191 /* XXX: use a special url_shutdown call to abort parse cleanly */
1192 is
->abort_request
= 1;
1193 SDL_WaitThread(is
->parse_tid
, NULL
);
1194 SDL_WaitThread(is
->refresh_tid
, NULL
);
1196 /* free all pictures */
1197 for (i
= 0; i
< VIDEO_PICTURE_QUEUE_SIZE
; i
++) {
1200 SDL_FreeYUVOverlay(vp
->bmp
);
1204 SDL_DestroyMutex(is
->pictq_mutex
);
1205 SDL_DestroyCond(is
->pictq_cond
);
1206 SDL_DestroyMutex(is
->subpq_mutex
);
1207 SDL_DestroyCond(is
->subpq_cond
);
1210 static void do_exit(void)
1213 player_close(player
);
1217 avformat_network_deinit();
1221 av_log(NULL
, AV_LOG_QUIET
, "");
1225 /* allocate a picture (needs to do that in main thread to avoid
1226 potential locking problems */
1227 static void alloc_picture(void *opaque
)
1229 PlayerState
*is
= opaque
;
1232 vp
= &is
->pictq
[is
->pictq_windex
];
1235 SDL_FreeYUVOverlay(vp
->bmp
);
1237 vp
->width
= is
->out_video_filter
->inputs
[0]->w
;
1238 vp
->height
= is
->out_video_filter
->inputs
[0]->h
;
1239 vp
->pix_fmt
= is
->out_video_filter
->inputs
[0]->format
;
1241 vp
->bmp
= SDL_CreateYUVOverlay(vp
->width
, vp
->height
,
1244 if (!vp
->bmp
|| vp
->bmp
->pitches
[0] < vp
->width
) {
1245 /* SDL allocates a buffer smaller than requested if the video
1246 * overlay hardware is unable to support the requested size. */
1247 fprintf(stderr
, "Error: the video system does not support an image\n"
1248 "size of %dx%d pixels. Try using -vf \"scale=w:h\"\n"
1249 "to reduce the image size.\n", vp
->width
, vp
->height
);
1253 SDL_LockMutex(is
->pictq_mutex
);
1255 SDL_CondSignal(is
->pictq_cond
);
1256 SDL_UnlockMutex(is
->pictq_mutex
);
1259 /* The 'pts' parameter is the dts of the packet / pts of the frame and
1260 * guessed if not known. */
1261 static int queue_picture(PlayerState
*is
, AVFrame
*src_frame
, double pts
, int64_t pos
)
1265 /* wait until we have space to put a new picture */
1266 SDL_LockMutex(is
->pictq_mutex
);
1268 if (is
->pictq_size
>= VIDEO_PICTURE_QUEUE_SIZE
&& !is
->refresh
)
1269 is
->skip_frames
= FFMAX(1.0 - FRAME_SKIP_FACTOR
, is
->skip_frames
* (1.0 - FRAME_SKIP_FACTOR
));
1271 while (is
->pictq_size
>= VIDEO_PICTURE_QUEUE_SIZE
&&
1272 !is
->videoq
.abort_request
) {
1273 SDL_CondWait(is
->pictq_cond
, is
->pictq_mutex
);
1275 SDL_UnlockMutex(is
->pictq_mutex
);
1277 if (is
->videoq
.abort_request
)
1280 vp
= &is
->pictq
[is
->pictq_windex
];
1282 vp
->sar
= src_frame
->sample_aspect_ratio
;
1284 /* alloc or resize hardware picture buffer */
1285 if (!vp
->bmp
|| vp
->reallocate
||
1286 vp
->width
!= is
->out_video_filter
->inputs
[0]->w
||
1287 vp
->height
!= is
->out_video_filter
->inputs
[0]->h
) {
1293 /* the allocation must be done in the main thread to avoid
1295 event
.type
= FF_ALLOC_EVENT
;
1296 event
.user
.data1
= is
;
1297 SDL_PushEvent(&event
);
1299 /* wait until the picture is allocated */
1300 SDL_LockMutex(is
->pictq_mutex
);
1301 while (!vp
->allocated
&& !is
->videoq
.abort_request
) {
1302 SDL_CondWait(is
->pictq_cond
, is
->pictq_mutex
);
1304 SDL_UnlockMutex(is
->pictq_mutex
);
1306 if (is
->videoq
.abort_request
)
1310 /* if the frame is not skipped, then display it */
1315 /* get a pointer on the bitmap */
1316 SDL_LockYUVOverlay (vp
->bmp
);
1318 data
[0] = vp
->bmp
->pixels
[0];
1319 data
[1] = vp
->bmp
->pixels
[2];
1320 data
[2] = vp
->bmp
->pixels
[1];
1322 linesize
[0] = vp
->bmp
->pitches
[0];
1323 linesize
[1] = vp
->bmp
->pitches
[2];
1324 linesize
[2] = vp
->bmp
->pitches
[1];
1326 // FIXME use direct rendering
1327 av_image_copy(data
, linesize
, src_frame
->data
, src_frame
->linesize
,
1328 vp
->pix_fmt
, vp
->width
, vp
->height
);
1330 /* update the bitmap content */
1331 SDL_UnlockYUVOverlay(vp
->bmp
);
1336 /* now we can update the picture count */
1337 if (++is
->pictq_windex
== VIDEO_PICTURE_QUEUE_SIZE
)
1338 is
->pictq_windex
= 0;
1339 SDL_LockMutex(is
->pictq_mutex
);
1340 vp
->target_clock
= compute_target_time(vp
->pts
, is
);
1343 SDL_UnlockMutex(is
->pictq_mutex
);
1348 /* Compute the exact PTS for the picture if it is omitted in the stream.
1349 * The 'pts1' parameter is the dts of the packet / pts of the frame. */
1350 static int output_picture2(PlayerState
*is
, AVFrame
*src_frame
, double pts1
, int64_t pos
)
1352 double frame_delay
, pts
;
1358 /* update video clock with pts, if present */
1359 is
->video_clock
= pts
;
1361 pts
= is
->video_clock
;
1363 /* update video clock for next frame */
1364 frame_delay
= av_q2d(is
->video_dec
->time_base
);
1365 /* For MPEG-2, the frame can be repeated, so we update the
1366 clock accordingly */
1367 frame_delay
+= src_frame
->repeat_pict
* (frame_delay
* 0.5);
1368 is
->video_clock
+= frame_delay
;
1370 ret
= queue_picture(is
, src_frame
, pts
, pos
);
1371 av_frame_unref(src_frame
);
1375 static int get_video_frame(PlayerState
*is
, AVFrame
*frame
, int64_t *pts
, AVPacket
*pkt
)
1379 if (packet_queue_get(&is
->videoq
, pkt
, 1) < 0)
1382 if (pkt
->data
== flush_pkt
.data
) {
1383 avcodec_flush_buffers(is
->video_dec
);
1385 SDL_LockMutex(is
->pictq_mutex
);
1386 // Make sure there are no long delay timers (ideally we should just flush the que but thats harder)
1387 for (i
= 0; i
< VIDEO_PICTURE_QUEUE_SIZE
; i
++) {
1388 is
->pictq
[i
].target_clock
= 0;
1390 while (is
->pictq_size
&& !is
->videoq
.abort_request
) {
1391 SDL_CondWait(is
->pictq_cond
, is
->pictq_mutex
);
1393 is
->video_current_pos
= -1;
1394 SDL_UnlockMutex(is
->pictq_mutex
);
1396 init_pts_correction(&is
->pts_ctx
);
1397 is
->frame_last_pts
= AV_NOPTS_VALUE
;
1398 is
->frame_last_delay
= 0;
1399 is
->frame_timer
= (double)av_gettime_relative() / 1000000.0;
1400 is
->skip_frames
= 1;
1401 is
->skip_frames_index
= 0;
1405 avcodec_decode_video2(is
->video_dec
, frame
, &got_picture
, pkt
);
1408 if (decoder_reorder_pts
== -1) {
1409 *pts
= guess_correct_pts(&is
->pts_ctx
, frame
->pts
, frame
->pkt_dts
);
1410 } else if (decoder_reorder_pts
) {
1413 *pts
= frame
->pkt_dts
;
1416 if (*pts
== AV_NOPTS_VALUE
) {
1419 if (is
->video_st
->sample_aspect_ratio
.num
) {
1420 frame
->sample_aspect_ratio
= is
->video_st
->sample_aspect_ratio
;
1423 is
->skip_frames_index
+= 1;
1424 if (is
->skip_frames_index
>= is
->skip_frames
) {
1425 is
->skip_frames_index
-= FFMAX(is
->skip_frames
, 1.0);
1428 av_frame_unref(frame
);
1433 static int configure_video_filters(AVFilterGraph
*graph
, PlayerState
*is
, const char *vfilters
)
1435 char sws_flags_str
[128];
1436 char buffersrc_args
[256];
1438 AVFilterContext
*filt_src
= NULL
, *filt_out
= NULL
, *last_filter
;
1439 AVCodecContext
*codec
= is
->video_dec
;
1441 snprintf(sws_flags_str
, sizeof(sws_flags_str
), "flags=%"PRId64
, sws_flags
);
1442 graph
->scale_sws_opts
= av_strdup(sws_flags_str
);
1444 snprintf(buffersrc_args
, sizeof(buffersrc_args
), "%d:%d:%d:%d:%d:%d:%d",
1445 codec
->width
, codec
->height
, codec
->pix_fmt
,
1446 is
->video_st
->time_base
.num
, is
->video_st
->time_base
.den
,
1447 codec
->sample_aspect_ratio
.num
, codec
->sample_aspect_ratio
.den
);
1450 if ((ret
= avfilter_graph_create_filter(&filt_src
,
1451 avfilter_get_by_name("buffer"),
1452 "src", buffersrc_args
, NULL
,
1455 if ((ret
= avfilter_graph_create_filter(&filt_out
,
1456 avfilter_get_by_name("buffersink"),
1457 "out", NULL
, NULL
, graph
)) < 0)
1460 last_filter
= filt_out
;
1462 /* Note: this macro adds a filter before the lastly added filter, so the
1463 * processing order of the filters is in reverse */
1464 #define INSERT_FILT(name, arg) do { \
1465 AVFilterContext *filt_ctx; \
1467 ret = avfilter_graph_create_filter(&filt_ctx, \
1468 avfilter_get_by_name(name), \
1469 "avplay_" name, arg, NULL, graph); \
1473 ret = avfilter_link(filt_ctx, 0, last_filter, 0); \
1477 last_filter = filt_ctx; \
1480 INSERT_FILT("format", "yuv420p");
1483 uint8_t* displaymatrix
= av_stream_get_side_data(is
->video_st
,
1484 AV_PKT_DATA_DISPLAYMATRIX
, NULL
);
1485 if (displaymatrix
) {
1486 double rot
= av_display_rotation_get((int32_t*) displaymatrix
);
1487 if (rot
< -135 || rot
> 135) {
1488 INSERT_FILT("vflip", NULL
);
1489 INSERT_FILT("hflip", NULL
);
1490 } else if (rot
< -45) {
1491 INSERT_FILT("transpose", "dir=clock");
1492 } else if (rot
> 45) {
1493 INSERT_FILT("transpose", "dir=cclock");
1499 AVFilterInOut
*outputs
= avfilter_inout_alloc();
1500 AVFilterInOut
*inputs
= avfilter_inout_alloc();
1502 outputs
->name
= av_strdup("in");
1503 outputs
->filter_ctx
= filt_src
;
1504 outputs
->pad_idx
= 0;
1505 outputs
->next
= NULL
;
1507 inputs
->name
= av_strdup("out");
1508 inputs
->filter_ctx
= last_filter
;
1509 inputs
->pad_idx
= 0;
1510 inputs
->next
= NULL
;
1512 if ((ret
= avfilter_graph_parse(graph
, vfilters
, inputs
, outputs
, NULL
)) < 0)
1515 if ((ret
= avfilter_link(filt_src
, 0, last_filter
, 0)) < 0)
1519 if ((ret
= avfilter_graph_config(graph
, NULL
)) < 0)
1522 is
->in_video_filter
= filt_src
;
1523 is
->out_video_filter
= filt_out
;
1528 static int video_thread(void *arg
)
1530 AVPacket pkt
= { 0 };
1531 PlayerState
*is
= arg
;
1532 AVFrame
*frame
= av_frame_alloc();
1537 AVFilterGraph
*graph
= avfilter_graph_alloc();
1538 AVFilterContext
*filt_out
= NULL
, *filt_in
= NULL
;
1539 int last_w
= is
->video_dec
->width
;
1540 int last_h
= is
->video_dec
->height
;
1542 av_frame_free(&frame
);
1543 return AVERROR(ENOMEM
);
1546 if ((ret
= configure_video_filters(graph
, is
, vfilters
)) < 0)
1548 filt_in
= is
->in_video_filter
;
1549 filt_out
= is
->out_video_filter
;
1552 avfilter_graph_free(&graph
);
1553 return AVERROR(ENOMEM
);
1558 while (is
->paused
&& !is
->videoq
.abort_request
)
1561 av_packet_unref(&pkt
);
1563 ret
= get_video_frame(is
, frame
, &pts_int
, &pkt
);
1570 if ( last_w
!= is
->video_dec
->width
1571 || last_h
!= is
->video_dec
->height
) {
1572 av_log(NULL
, AV_LOG_TRACE
, "Changing size %dx%d -> %dx%d\n", last_w
, last_h
,
1573 is
->video_dec
->width
, is
->video_dec
->height
);
1574 avfilter_graph_free(&graph
);
1575 graph
= avfilter_graph_alloc();
1576 if ((ret
= configure_video_filters(graph
, is
, vfilters
)) < 0)
1578 filt_in
= is
->in_video_filter
;
1579 filt_out
= is
->out_video_filter
;
1580 last_w
= is
->video_dec
->width
;
1581 last_h
= is
->video_dec
->height
;
1584 frame
->pts
= pts_int
;
1585 ret
= av_buffersrc_add_frame(filt_in
, frame
);
1590 ret
= av_buffersink_get_frame(filt_out
, frame
);
1596 pts_int
= frame
->pts
;
1597 tb
= filt_out
->inputs
[0]->time_base
;
1598 if (av_cmp_q(tb
, is
->video_st
->time_base
)) {
1599 av_unused
int64_t pts1
= pts_int
;
1600 pts_int
= av_rescale_q(pts_int
, tb
, is
->video_st
->time_base
);
1601 av_log(NULL
, AV_LOG_TRACE
, "video_thread(): "
1602 "tb:%d/%d pts:%"PRId64
" -> tb:%d/%d pts:%"PRId64
"\n",
1603 tb
.num
, tb
.den
, pts1
,
1604 is
->video_st
->time_base
.num
, is
->video_st
->time_base
.den
, pts_int
);
1606 pts
= pts_int
* av_q2d(is
->video_st
->time_base
);
1607 ret
= output_picture2(is
, frame
, pts
, 0);
1616 stream_pause(player
);
1619 av_freep(&vfilters
);
1620 avfilter_graph_free(&graph
);
1621 av_packet_unref(&pkt
);
1622 av_frame_free(&frame
);
1626 static int subtitle_thread(void *arg
)
1628 PlayerState
*is
= arg
;
1630 AVPacket pkt1
, *pkt
= &pkt1
;
1634 int r
, g
, b
, y
, u
, v
, a
;
1637 while (is
->paused
&& !is
->subtitleq
.abort_request
) {
1640 if (packet_queue_get(&is
->subtitleq
, pkt
, 1) < 0)
1643 if (pkt
->data
== flush_pkt
.data
) {
1644 avcodec_flush_buffers(is
->subtitle_dec
);
1647 SDL_LockMutex(is
->subpq_mutex
);
1648 while (is
->subpq_size
>= SUBPICTURE_QUEUE_SIZE
&&
1649 !is
->subtitleq
.abort_request
) {
1650 SDL_CondWait(is
->subpq_cond
, is
->subpq_mutex
);
1652 SDL_UnlockMutex(is
->subpq_mutex
);
1654 if (is
->subtitleq
.abort_request
)
1657 sp
= &is
->subpq
[is
->subpq_windex
];
1659 /* NOTE: ipts is the PTS of the _first_ picture beginning in
1660 this packet, if any */
1662 if (pkt
->pts
!= AV_NOPTS_VALUE
)
1663 pts
= av_q2d(is
->subtitle_dec
->time_base
) * pkt
->pts
;
1665 avcodec_decode_subtitle2(is
->subtitle_dec
, &sp
->sub
,
1666 &got_subtitle
, pkt
);
1668 if (got_subtitle
&& sp
->sub
.format
== 0) {
1671 for (i
= 0; i
< sp
->sub
.num_rects
; i
++)
1673 for (j
= 0; j
< sp
->sub
.rects
[i
]->nb_colors
; j
++)
1675 RGBA_IN(r
, g
, b
, a
, (uint32_t *)sp
->sub
.rects
[i
]->data
[1] + j
);
1676 y
= RGB_TO_Y_CCIR(r
, g
, b
);
1677 u
= RGB_TO_U_CCIR(r
, g
, b
, 0);
1678 v
= RGB_TO_V_CCIR(r
, g
, b
, 0);
1679 YUVA_OUT((uint32_t *)sp
->sub
.rects
[i
]->data
[1] + j
, y
, u
, v
, a
);
1683 /* now we can update the picture count */
1684 if (++is
->subpq_windex
== SUBPICTURE_QUEUE_SIZE
)
1685 is
->subpq_windex
= 0;
1686 SDL_LockMutex(is
->subpq_mutex
);
1688 SDL_UnlockMutex(is
->subpq_mutex
);
1690 av_packet_unref(pkt
);
1695 /* copy samples for viewing in editor window */
1696 static void update_sample_display(PlayerState
*is
, short *samples
, int samples_size
)
1700 size
= samples_size
/ sizeof(short);
1702 len
= SAMPLE_ARRAY_SIZE
- is
->sample_array_index
;
1705 memcpy(is
->sample_array
+ is
->sample_array_index
, samples
, len
* sizeof(short));
1707 is
->sample_array_index
+= len
;
1708 if (is
->sample_array_index
>= SAMPLE_ARRAY_SIZE
)
1709 is
->sample_array_index
= 0;
1714 /* return the new audio buffer size (samples can be added or deleted
1715 to get better sync if video or external master clock) */
1716 static int synchronize_audio(PlayerState
*is
, short *samples
,
1717 int samples_size1
, double pts
)
1719 int n
, samples_size
;
1722 n
= is
->sdl_channels
* av_get_bytes_per_sample(is
->sdl_sample_fmt
);
1723 samples_size
= samples_size1
;
1725 /* if not master, then we try to remove or add samples to correct the clock */
1726 if (((is
->av_sync_type
== AV_SYNC_VIDEO_MASTER
&& is
->video_st
) ||
1727 is
->av_sync_type
== AV_SYNC_EXTERNAL_CLOCK
)) {
1728 double diff
, avg_diff
;
1729 int wanted_size
, min_size
, max_size
, nb_samples
;
1731 ref_clock
= get_master_clock(is
);
1732 diff
= get_audio_clock(is
) - ref_clock
;
1734 if (diff
< AV_NOSYNC_THRESHOLD
) {
1735 is
->audio_diff_cum
= diff
+ is
->audio_diff_avg_coef
* is
->audio_diff_cum
;
1736 if (is
->audio_diff_avg_count
< AUDIO_DIFF_AVG_NB
) {
1737 /* not enough measures to have a correct estimate */
1738 is
->audio_diff_avg_count
++;
1740 /* estimate the A-V difference */
1741 avg_diff
= is
->audio_diff_cum
* (1.0 - is
->audio_diff_avg_coef
);
1743 if (fabs(avg_diff
) >= is
->audio_diff_threshold
) {
1744 wanted_size
= samples_size
+ ((int)(diff
* is
->sdl_sample_rate
) * n
);
1745 nb_samples
= samples_size
/ n
;
1747 min_size
= ((nb_samples
* (100 - SAMPLE_CORRECTION_PERCENT_MAX
)) / 100) * n
;
1748 max_size
= ((nb_samples
* (100 + SAMPLE_CORRECTION_PERCENT_MAX
)) / 100) * n
;
1749 if (wanted_size
< min_size
)
1750 wanted_size
= min_size
;
1751 else if (wanted_size
> max_size
)
1752 wanted_size
= max_size
;
1754 /* add or remove samples to correction the synchro */
1755 if (wanted_size
< samples_size
) {
1756 /* remove samples */
1757 samples_size
= wanted_size
;
1758 } else if (wanted_size
> samples_size
) {
1759 uint8_t *samples_end
, *q
;
1763 nb
= (samples_size
- wanted_size
);
1764 samples_end
= (uint8_t *)samples
+ samples_size
- n
;
1765 q
= samples_end
+ n
;
1767 memcpy(q
, samples_end
, n
);
1771 samples_size
= wanted_size
;
1774 av_log(NULL
, AV_LOG_TRACE
, "diff=%f adiff=%f sample_diff=%d apts=%0.3f vpts=%0.3f %f\n",
1775 diff
, avg_diff
, samples_size
- samples_size1
,
1776 is
->audio_clock
, is
->video_clock
, is
->audio_diff_threshold
);
1779 /* too big difference : may be initial PTS errors, so
1781 is
->audio_diff_avg_count
= 0;
1782 is
->audio_diff_cum
= 0;
1786 return samples_size
;
1789 /* decode one audio frame and returns its uncompressed size */
1790 static int audio_decode_frame(PlayerState
*is
, double *pts_ptr
)
1792 AVPacket
*pkt_temp
= &is
->audio_pkt_temp
;
1793 AVPacket
*pkt
= &is
->audio_pkt
;
1794 AVCodecContext
*dec
= is
->audio_dec
;
1795 int n
, len1
, data_size
, got_frame
;
1798 int flush_complete
= 0;
1801 /* NOTE: the audio packet can contain several frames */
1802 while (pkt_temp
->size
> 0 || (!pkt_temp
->data
&& new_packet
)) {
1803 int resample_changed
, audio_resample
;
1806 if (!(is
->frame
= av_frame_alloc()))
1807 return AVERROR(ENOMEM
);
1813 len1
= avcodec_decode_audio4(dec
, is
->frame
, &got_frame
, pkt_temp
);
1815 /* if error, we skip the frame */
1820 pkt_temp
->data
+= len1
;
1821 pkt_temp
->size
-= len1
;
1824 /* stop sending empty packets if the decoder is finished */
1825 if (!pkt_temp
->data
&& (dec
->codec
->capabilities
& AV_CODEC_CAP_DELAY
))
1829 data_size
= av_samples_get_buffer_size(NULL
, dec
->channels
,
1830 is
->frame
->nb_samples
,
1831 is
->frame
->format
, 1);
1833 audio_resample
= is
->frame
->format
!= is
->sdl_sample_fmt
||
1834 is
->frame
->channel_layout
!= is
->sdl_channel_layout
||
1835 is
->frame
->sample_rate
!= is
->sdl_sample_rate
;
1837 resample_changed
= is
->frame
->format
!= is
->resample_sample_fmt
||
1838 is
->frame
->channel_layout
!= is
->resample_channel_layout
||
1839 is
->frame
->sample_rate
!= is
->resample_sample_rate
;
1841 if ((!is
->avr
&& audio_resample
) || resample_changed
) {
1844 avresample_close(is
->avr
);
1845 else if (audio_resample
) {
1846 is
->avr
= avresample_alloc_context();
1848 fprintf(stderr
, "error allocating AVAudioResampleContext\n");
1852 if (audio_resample
) {
1853 av_opt_set_int(is
->avr
, "in_channel_layout", is
->frame
->channel_layout
, 0);
1854 av_opt_set_int(is
->avr
, "in_sample_fmt", is
->frame
->format
, 0);
1855 av_opt_set_int(is
->avr
, "in_sample_rate", is
->frame
->sample_rate
, 0);
1856 av_opt_set_int(is
->avr
, "out_channel_layout", is
->sdl_channel_layout
, 0);
1857 av_opt_set_int(is
->avr
, "out_sample_fmt", is
->sdl_sample_fmt
, 0);
1858 av_opt_set_int(is
->avr
, "out_sample_rate", is
->sdl_sample_rate
, 0);
1860 if ((ret
= avresample_open(is
->avr
)) < 0) {
1861 fprintf(stderr
, "error initializing libavresample\n");
1865 is
->resample_sample_fmt
= is
->frame
->format
;
1866 is
->resample_channel_layout
= is
->frame
->channel_layout
;
1867 is
->resample_sample_rate
= is
->frame
->sample_rate
;
1870 if (audio_resample
) {
1872 int out_samples
, out_size
, out_linesize
;
1873 int osize
= av_get_bytes_per_sample(is
->sdl_sample_fmt
);
1874 int nb_samples
= is
->frame
->nb_samples
;
1876 out_size
= av_samples_get_buffer_size(&out_linesize
,
1879 is
->sdl_sample_fmt
, 0);
1880 tmp_out
= av_realloc(is
->audio_buf1
, out_size
);
1882 return AVERROR(ENOMEM
);
1883 is
->audio_buf1
= tmp_out
;
1885 out_samples
= avresample_convert(is
->avr
,
1887 out_linesize
, nb_samples
,
1889 is
->frame
->linesize
[0],
1890 is
->frame
->nb_samples
);
1891 if (out_samples
< 0) {
1892 fprintf(stderr
, "avresample_convert() failed\n");
1895 is
->audio_buf
= is
->audio_buf1
;
1896 data_size
= out_samples
* osize
* is
->sdl_channels
;
1898 is
->audio_buf
= is
->frame
->data
[0];
1901 /* if no pts, then compute it */
1902 pts
= is
->audio_clock
;
1904 n
= is
->sdl_channels
* av_get_bytes_per_sample(is
->sdl_sample_fmt
);
1905 is
->audio_clock
+= (double)data_size
/
1906 (double)(n
* is
->sdl_sample_rate
);
1909 static double last_clock
;
1910 printf("audio: delay=%0.3f clock=%0.3f pts=%0.3f\n",
1911 is
->audio_clock
- last_clock
,
1912 is
->audio_clock
, pts
);
1913 last_clock
= is
->audio_clock
;
1919 /* free the current packet */
1921 av_packet_unref(pkt
);
1922 memset(pkt_temp
, 0, sizeof(*pkt_temp
));
1924 if (is
->paused
|| is
->audioq
.abort_request
) {
1928 /* read next packet */
1929 if ((new_packet
= packet_queue_get(&is
->audioq
, pkt
, 1)) < 0)
1932 if (pkt
->data
== flush_pkt
.data
) {
1933 avcodec_flush_buffers(dec
);
1939 /* if update the audio clock with the pts */
1940 if (pkt
->pts
!= AV_NOPTS_VALUE
) {
1941 is
->audio_clock
= av_q2d(is
->audio_st
->time_base
)*pkt
->pts
;
1946 /* prepare a new audio buffer */
1947 static void sdl_audio_callback(void *opaque
, Uint8
*stream
, int len
)
1949 PlayerState
*is
= opaque
;
1950 int audio_size
, len1
;
1953 audio_callback_time
= av_gettime_relative();
1956 if (is
->audio_buf_index
>= is
->audio_buf_size
) {
1957 audio_size
= audio_decode_frame(is
, &pts
);
1958 if (audio_size
< 0) {
1959 /* if error, just output silence */
1960 is
->audio_buf
= is
->silence_buf
;
1961 is
->audio_buf_size
= sizeof(is
->silence_buf
);
1964 update_sample_display(is
, (int16_t *)is
->audio_buf
, audio_size
);
1965 audio_size
= synchronize_audio(is
, (int16_t *)is
->audio_buf
, audio_size
,
1967 is
->audio_buf_size
= audio_size
;
1969 is
->audio_buf_index
= 0;
1971 len1
= is
->audio_buf_size
- is
->audio_buf_index
;
1974 memcpy(stream
, (uint8_t *)is
->audio_buf
+ is
->audio_buf_index
, len1
);
1977 is
->audio_buf_index
+= len1
;
1981 static AVCodec
*find_codec_or_die(const char *name
, enum AVMediaType type
)
1983 const AVCodecDescriptor
*desc
;
1984 AVCodec
*codec
= avcodec_find_decoder_by_name(name
);
1986 if (!codec
&& (desc
= avcodec_descriptor_get_by_name(name
))) {
1987 codec
= avcodec_find_decoder(desc
->id
);
1989 av_log(NULL
, AV_LOG_VERBOSE
, "Matched decoder '%s' for codec '%s'.\n",
1990 codec
->name
, desc
->name
);
1994 av_log(NULL
, AV_LOG_FATAL
, "Unknown decoder '%s'\n", name
);
1998 if (codec
->type
!= type
) {
1999 av_log(NULL
, AV_LOG_FATAL
, "Invalid decoder type '%s'\n", name
);
2006 static AVCodec
*choose_decoder(PlayerState
*is
, AVFormatContext
*ic
, AVStream
*st
)
2008 char *codec_name
= NULL
;
2011 for (i
= 0; i
< is
->nb_codec_names
; i
++) {
2012 char *spec
= is
->codec_names
[i
].specifier
;
2013 if ((ret
= check_stream_specifier(ic
, st
, spec
)) > 0)
2014 codec_name
= is
->codec_names
[i
].u
.str
;
2020 AVCodec
*codec
= find_codec_or_die(codec_name
, st
->codecpar
->codec_type
);
2021 st
->codecpar
->codec_id
= codec
->id
;
2024 return avcodec_find_decoder(st
->codecpar
->codec_id
);
2027 /* open a given stream. Return 0 if OK */
2028 static int stream_component_open(PlayerState
*is
, int stream_index
)
2030 AVFormatContext
*ic
= is
->ic
;
2031 AVCodecContext
*avctx
;
2033 SDL_AudioSpec wanted_spec
, spec
;
2035 AVDictionaryEntry
*t
= NULL
;
2038 if (stream_index
< 0 || stream_index
>= ic
->nb_streams
)
2041 avctx
= avcodec_alloc_context3(NULL
);
2043 return AVERROR(ENOMEM
);
2045 ret
= avcodec_parameters_to_context(avctx
, ic
->streams
[stream_index
]->codecpar
);
2047 avcodec_free_context(&avctx
);
2051 opts
= filter_codec_opts(codec_opts
, avctx
->codec_id
, ic
, ic
->streams
[stream_index
], NULL
);
2053 codec
= choose_decoder(is
, ic
, ic
->streams
[stream_index
]);
2054 avctx
->workaround_bugs
= workaround_bugs
;
2055 avctx
->idct_algo
= idct
;
2056 avctx
->skip_frame
= skip_frame
;
2057 avctx
->skip_idct
= skip_idct
;
2058 avctx
->skip_loop_filter
= skip_loop_filter
;
2059 avctx
->error_concealment
= error_concealment
;
2062 avctx
->flags2
|= AV_CODEC_FLAG2_FAST
;
2064 if (!av_dict_get(opts
, "threads", NULL
, 0))
2065 av_dict_set(&opts
, "threads", "auto", 0);
2066 if (avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
)
2067 av_dict_set(&opts
, "refcounted_frames", "1", 0);
2069 (ret
= avcodec_open2(avctx
, codec
, &opts
)) < 0) {
2072 if ((t
= av_dict_get(opts
, "", NULL
, AV_DICT_IGNORE_SUFFIX
))) {
2073 av_log(NULL
, AV_LOG_ERROR
, "Option %s not found.\n", t
->key
);
2074 ret
= AVERROR_OPTION_NOT_FOUND
;
2078 /* prepare audio output */
2079 if (avctx
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
2080 is
->sdl_sample_rate
= avctx
->sample_rate
;
2082 if (!avctx
->channel_layout
)
2083 avctx
->channel_layout
= av_get_default_channel_layout(avctx
->channels
);
2084 if (!avctx
->channel_layout
) {
2085 fprintf(stderr
, "unable to guess channel layout\n");
2086 ret
= AVERROR_INVALIDDATA
;
2089 if (avctx
->channels
== 1)
2090 is
->sdl_channel_layout
= AV_CH_LAYOUT_MONO
;
2092 is
->sdl_channel_layout
= AV_CH_LAYOUT_STEREO
;
2093 is
->sdl_channels
= av_get_channel_layout_nb_channels(is
->sdl_channel_layout
);
2095 wanted_spec
.format
= AUDIO_S16SYS
;
2096 wanted_spec
.freq
= is
->sdl_sample_rate
;
2097 wanted_spec
.channels
= is
->sdl_channels
;
2098 wanted_spec
.silence
= 0;
2099 wanted_spec
.samples
= SDL_AUDIO_BUFFER_SIZE
;
2100 wanted_spec
.callback
= sdl_audio_callback
;
2101 wanted_spec
.userdata
= is
;
2102 if (SDL_OpenAudio(&wanted_spec
, &spec
) < 0) {
2103 fprintf(stderr
, "SDL_OpenAudio: %s\n", SDL_GetError());
2104 ret
= AVERROR_UNKNOWN
;
2107 is
->audio_hw_buf_size
= spec
.size
;
2108 is
->sdl_sample_fmt
= AV_SAMPLE_FMT_S16
;
2109 is
->resample_sample_fmt
= is
->sdl_sample_fmt
;
2110 is
->resample_channel_layout
= avctx
->channel_layout
;
2111 is
->resample_sample_rate
= avctx
->sample_rate
;
2114 ic
->streams
[stream_index
]->discard
= AVDISCARD_DEFAULT
;
2115 switch (avctx
->codec_type
) {
2116 case AVMEDIA_TYPE_AUDIO
:
2117 is
->audio_stream
= stream_index
;
2118 is
->audio_st
= ic
->streams
[stream_index
];
2119 is
->audio_dec
= avctx
;
2120 is
->audio_buf_size
= 0;
2121 is
->audio_buf_index
= 0;
2123 /* init averaging filter */
2124 is
->audio_diff_avg_coef
= exp(log(0.01) / AUDIO_DIFF_AVG_NB
);
2125 is
->audio_diff_avg_count
= 0;
2126 /* since we do not have a precise enough audio FIFO fullness,
2127 we correct audio sync only if larger than this threshold */
2128 is
->audio_diff_threshold
= 2.0 * SDL_AUDIO_BUFFER_SIZE
/ avctx
->sample_rate
;
2130 memset(&is
->audio_pkt
, 0, sizeof(is
->audio_pkt
));
2131 packet_queue_init(&is
->audioq
);
2134 case AVMEDIA_TYPE_VIDEO
:
2135 is
->video_stream
= stream_index
;
2136 is
->video_st
= ic
->streams
[stream_index
];
2137 is
->video_dec
= avctx
;
2139 packet_queue_init(&is
->videoq
);
2140 is
->video_tid
= SDL_CreateThread(video_thread
, is
);
2142 case AVMEDIA_TYPE_SUBTITLE
:
2143 is
->subtitle_stream
= stream_index
;
2144 is
->subtitle_st
= ic
->streams
[stream_index
];
2145 is
->subtitle_dec
= avctx
;
2146 packet_queue_init(&is
->subtitleq
);
2148 is
->subtitle_tid
= SDL_CreateThread(subtitle_thread
, is
);
2155 av_dict_free(&opts
);
2160 static void stream_component_close(PlayerState
*is
, int stream_index
)
2162 AVFormatContext
*ic
= is
->ic
;
2163 AVCodecParameters
*par
;
2165 if (stream_index
< 0 || stream_index
>= ic
->nb_streams
)
2167 par
= ic
->streams
[stream_index
]->codecpar
;
2169 switch (par
->codec_type
) {
2170 case AVMEDIA_TYPE_AUDIO
:
2171 packet_queue_abort(&is
->audioq
);
2175 packet_queue_end(&is
->audioq
);
2176 av_packet_unref(&is
->audio_pkt
);
2178 avresample_free(&is
->avr
);
2179 av_freep(&is
->audio_buf1
);
2180 is
->audio_buf
= NULL
;
2181 av_frame_free(&is
->frame
);
2184 av_rdft_end(is
->rdft
);
2185 av_freep(&is
->rdft_data
);
2190 case AVMEDIA_TYPE_VIDEO
:
2191 packet_queue_abort(&is
->videoq
);
2193 /* note: we also signal this mutex to make sure we deblock the
2194 video thread in all cases */
2195 SDL_LockMutex(is
->pictq_mutex
);
2196 SDL_CondSignal(is
->pictq_cond
);
2197 SDL_UnlockMutex(is
->pictq_mutex
);
2199 SDL_WaitThread(is
->video_tid
, NULL
);
2201 packet_queue_end(&is
->videoq
);
2203 case AVMEDIA_TYPE_SUBTITLE
:
2204 packet_queue_abort(&is
->subtitleq
);
2206 /* note: we also signal this mutex to make sure we deblock the
2207 video thread in all cases */
2208 SDL_LockMutex(is
->subpq_mutex
);
2209 is
->subtitle_stream_changed
= 1;
2211 SDL_CondSignal(is
->subpq_cond
);
2212 SDL_UnlockMutex(is
->subpq_mutex
);
2214 SDL_WaitThread(is
->subtitle_tid
, NULL
);
2216 packet_queue_end(&is
->subtitleq
);
2222 ic
->streams
[stream_index
]->discard
= AVDISCARD_ALL
;
2223 switch (par
->codec_type
) {
2224 case AVMEDIA_TYPE_AUDIO
:
2225 avcodec_free_context(&is
->audio_dec
);
2226 is
->audio_st
= NULL
;
2227 is
->audio_stream
= -1;
2229 case AVMEDIA_TYPE_VIDEO
:
2230 avcodec_free_context(&is
->video_dec
);
2231 is
->video_st
= NULL
;
2232 is
->video_stream
= -1;
2234 case AVMEDIA_TYPE_SUBTITLE
:
2235 avcodec_free_context(&is
->subtitle_dec
);
2236 is
->subtitle_st
= NULL
;
2237 is
->subtitle_stream
= -1;
2244 /* since we have only one decoding thread, we can use a global
2245 variable instead of a thread local variable */
2246 static PlayerState
*global_video_state
;
2248 static int decode_interrupt_cb(void *ctx
)
2250 return global_video_state
&& global_video_state
->abort_request
;
2253 static void stream_close(PlayerState
*is
)
2255 /* disable interrupting */
2256 global_video_state
= NULL
;
2258 /* close each stream */
2259 if (is
->audio_stream
>= 0)
2260 stream_component_close(is
, is
->audio_stream
);
2261 if (is
->video_stream
>= 0)
2262 stream_component_close(is
, is
->video_stream
);
2263 if (is
->subtitle_stream
>= 0)
2264 stream_component_close(is
, is
->subtitle_stream
);
2266 avformat_close_input(&is
->ic
);
2270 static int stream_setup(PlayerState
*is
)
2272 AVFormatContext
*ic
= NULL
;
2274 int st_index
[AVMEDIA_TYPE_NB
];
2275 AVDictionaryEntry
*t
;
2276 AVDictionary
**opts
;
2277 int orig_nb_streams
;
2279 memset(st_index
, -1, sizeof(st_index
));
2280 is
->video_stream
= -1;
2281 is
->audio_stream
= -1;
2282 is
->subtitle_stream
= -1;
2284 global_video_state
= is
;
2286 ic
= avformat_alloc_context();
2288 av_log(NULL
, AV_LOG_FATAL
, "Could not allocate context.\n");
2289 ret
= AVERROR(ENOMEM
);
2292 ic
->interrupt_callback
.callback
= decode_interrupt_cb
;
2293 err
= avformat_open_input(&ic
, is
->filename
, is
->iformat
, &format_opts
);
2295 print_error(is
->filename
, err
);
2300 if ((t
= av_dict_get(format_opts
, "", NULL
, AV_DICT_IGNORE_SUFFIX
))) {
2301 av_log(NULL
, AV_LOG_ERROR
, "Option %s not found.\n", t
->key
);
2302 ret
= AVERROR_OPTION_NOT_FOUND
;
2308 ic
->flags
|= AVFMT_FLAG_GENPTS
;
2310 opts
= setup_find_stream_info_opts(ic
, codec_opts
);
2311 orig_nb_streams
= ic
->nb_streams
;
2313 for (i
= 0; i
< ic
->nb_streams
; i
++)
2314 choose_decoder(is
, ic
, ic
->streams
[i
]);
2316 err
= avformat_find_stream_info(ic
, opts
);
2318 for (i
= 0; i
< orig_nb_streams
; i
++)
2319 av_dict_free(&opts
[i
]);
2323 fprintf(stderr
, "%s: could not find codec parameters\n", is
->filename
);
2329 ic
->pb
->eof_reached
= 0; // FIXME hack, avplay maybe should not use url_feof() to test for the end
2331 if (seek_by_bytes
< 0)
2332 seek_by_bytes
= !!(ic
->iformat
->flags
& AVFMT_TS_DISCONT
);
2334 /* if seeking requested, we execute it */
2335 if (start_time
!= AV_NOPTS_VALUE
) {
2338 timestamp
= start_time
;
2339 /* add the stream start time */
2340 if (ic
->start_time
!= AV_NOPTS_VALUE
)
2341 timestamp
+= ic
->start_time
;
2342 ret
= avformat_seek_file(ic
, -1, INT64_MIN
, timestamp
, INT64_MAX
, 0);
2344 fprintf(stderr
, "%s: could not seek to position %0.3f\n",
2345 is
->filename
, (double)timestamp
/ AV_TIME_BASE
);
2349 for (i
= 0; i
< ic
->nb_streams
; i
++)
2350 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2352 st_index
[AVMEDIA_TYPE_VIDEO
] =
2353 av_find_best_stream(ic
, AVMEDIA_TYPE_VIDEO
,
2354 wanted_stream
[AVMEDIA_TYPE_VIDEO
], -1, NULL
, 0);
2356 st_index
[AVMEDIA_TYPE_AUDIO
] =
2357 av_find_best_stream(ic
, AVMEDIA_TYPE_AUDIO
,
2358 wanted_stream
[AVMEDIA_TYPE_AUDIO
],
2359 st_index
[AVMEDIA_TYPE_VIDEO
],
2362 st_index
[AVMEDIA_TYPE_SUBTITLE
] =
2363 av_find_best_stream(ic
, AVMEDIA_TYPE_SUBTITLE
,
2364 wanted_stream
[AVMEDIA_TYPE_SUBTITLE
],
2365 (st_index
[AVMEDIA_TYPE_AUDIO
] >= 0 ?
2366 st_index
[AVMEDIA_TYPE_AUDIO
] :
2367 st_index
[AVMEDIA_TYPE_VIDEO
]),
2370 av_dump_format(ic
, 0, is
->filename
, 0);
2373 /* open the streams */
2374 if (st_index
[AVMEDIA_TYPE_AUDIO
] >= 0) {
2375 stream_component_open(is
, st_index
[AVMEDIA_TYPE_AUDIO
]);
2379 if (st_index
[AVMEDIA_TYPE_VIDEO
] >= 0) {
2380 ret
= stream_component_open(is
, st_index
[AVMEDIA_TYPE_VIDEO
]);
2383 if (!display_disable
)
2387 if (st_index
[AVMEDIA_TYPE_SUBTITLE
] >= 0) {
2388 stream_component_open(is
, st_index
[AVMEDIA_TYPE_SUBTITLE
]);
2391 if (is
->video_stream
< 0 && is
->audio_stream
< 0) {
2392 fprintf(stderr
, "%s: could not open codecs\n", is
->filename
);
2403 /* this thread gets the stream from the disk or the network */
2404 static int decode_thread(void *arg
)
2406 PlayerState
*is
= arg
;
2407 AVPacket pkt1
, *pkt
= &pkt1
;
2408 AVFormatContext
*ic
= is
->ic
;
2409 int pkt_in_play_range
= 0;
2413 if (is
->abort_request
)
2415 if (is
->paused
!= is
->last_paused
) {
2416 is
->last_paused
= is
->paused
;
2418 is
->read_pause_return
= av_read_pause(ic
);
2422 #if CONFIG_RTSP_DEMUXER
2423 if (is
->paused
&& !strcmp(ic
->iformat
->name
, "rtsp")) {
2424 /* wait 10 ms to avoid trying to get another packet */
2431 int64_t seek_target
= is
->seek_pos
;
2432 int64_t seek_min
= is
->seek_rel
> 0 ? seek_target
- is
->seek_rel
+ 2: INT64_MIN
;
2433 int64_t seek_max
= is
->seek_rel
< 0 ? seek_target
- is
->seek_rel
- 2: INT64_MAX
;
2434 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2435 // of the seek_pos/seek_rel variables
2437 ret
= avformat_seek_file(is
->ic
, -1, seek_min
, seek_target
, seek_max
, is
->seek_flags
);
2439 fprintf(stderr
, "%s: error while seeking\n", is
->ic
->filename
);
2441 if (is
->audio_stream
>= 0) {
2442 packet_queue_flush(&is
->audioq
);
2443 packet_queue_put(&is
->audioq
, &flush_pkt
);
2445 if (is
->subtitle_stream
>= 0) {
2446 packet_queue_flush(&is
->subtitleq
);
2447 packet_queue_put(&is
->subtitleq
, &flush_pkt
);
2449 if (is
->video_stream
>= 0) {
2450 packet_queue_flush(&is
->videoq
);
2451 packet_queue_put(&is
->videoq
, &flush_pkt
);
2458 /* if the queue are full, no need to read more */
2459 if (!infinite_buffer
&&
2460 (is
->audioq
.size
+ is
->videoq
.size
+ is
->subtitleq
.size
> MAX_QUEUE_SIZE
2461 || ( (is
->audioq
.size
> MIN_AUDIOQ_SIZE
|| is
->audio_stream
< 0)
2462 && (is
->videoq
.nb_packets
> MIN_FRAMES
|| is
->video_stream
< 0)
2463 && (is
->subtitleq
.nb_packets
> MIN_FRAMES
|| is
->subtitle_stream
< 0)))) {
2469 if (is
->video_stream
>= 0) {
2470 av_init_packet(pkt
);
2473 pkt
->stream_index
= is
->video_stream
;
2474 packet_queue_put(&is
->videoq
, pkt
);
2476 if (is
->audio_stream
>= 0 &&
2477 (is
->audio_dec
->codec
->capabilities
& AV_CODEC_CAP_DELAY
)) {
2478 av_init_packet(pkt
);
2481 pkt
->stream_index
= is
->audio_stream
;
2482 packet_queue_put(&is
->audioq
, pkt
);
2485 if (is
->audioq
.size
+ is
->videoq
.size
+ is
->subtitleq
.size
== 0) {
2486 if (loop
!= 1 && (!loop
|| --loop
)) {
2487 stream_seek(player
, start_time
!= AV_NOPTS_VALUE ? start_time
: 0, 0, 0);
2488 } else if (!noautoexit
) {
2495 ret
= av_read_frame(ic
, pkt
);
2497 if (ret
== AVERROR_EOF
|| (ic
->pb
&& ic
->pb
->eof_reached
))
2499 if (ic
->pb
&& ic
->pb
->error
)
2501 SDL_Delay(100); /* wait for user event */
2504 /* check if packet is in play range specified by user, then queue, otherwise discard */
2505 pkt_in_play_range
= duration
== AV_NOPTS_VALUE
||
2506 (pkt
->pts
- ic
->streams
[pkt
->stream_index
]->start_time
) *
2507 av_q2d(ic
->streams
[pkt
->stream_index
]->time_base
) -
2508 (double)(start_time
!= AV_NOPTS_VALUE ? start_time
: 0) / 1000000
2509 <= ((double)duration
/ 1000000);
2510 if (pkt
->stream_index
== is
->audio_stream
&& pkt_in_play_range
) {
2511 packet_queue_put(&is
->audioq
, pkt
);
2512 } else if (pkt
->stream_index
== is
->video_stream
&& pkt_in_play_range
) {
2513 packet_queue_put(&is
->videoq
, pkt
);
2514 } else if (pkt
->stream_index
== is
->subtitle_stream
&& pkt_in_play_range
) {
2515 packet_queue_put(&is
->subtitleq
, pkt
);
2517 av_packet_unref(pkt
);
2520 /* wait until the end */
2521 while (!is
->abort_request
) {
2533 event
.type
= FF_QUIT_EVENT
;
2534 event
.user
.data1
= is
;
2535 SDL_PushEvent(&event
);
2540 static int stream_open(PlayerState
*is
,
2541 const char *filename
, AVInputFormat
*iformat
)
2545 av_strlcpy(is
->filename
, filename
, sizeof(is
->filename
));
2546 is
->iformat
= iformat
;
2550 if ((ret
= stream_setup(is
)) < 0) {
2554 /* start video display */
2555 is
->pictq_mutex
= SDL_CreateMutex();
2556 is
->pictq_cond
= SDL_CreateCond();
2558 is
->subpq_mutex
= SDL_CreateMutex();
2559 is
->subpq_cond
= SDL_CreateCond();
2561 is
->av_sync_type
= av_sync_type
;
2562 is
->refresh_tid
= SDL_CreateThread(refresh_thread
, is
);
2563 if (!is
->refresh_tid
)
2565 is
->parse_tid
= SDL_CreateThread(decode_thread
, is
);
2571 static void stream_cycle_channel(PlayerState
*is
, int codec_type
)
2573 AVFormatContext
*ic
= is
->ic
;
2574 int start_index
, stream_index
;
2577 if (codec_type
== AVMEDIA_TYPE_VIDEO
)
2578 start_index
= is
->video_stream
;
2579 else if (codec_type
== AVMEDIA_TYPE_AUDIO
)
2580 start_index
= is
->audio_stream
;
2582 start_index
= is
->subtitle_stream
;
2583 if (start_index
< (codec_type
== AVMEDIA_TYPE_SUBTITLE ?
-1 : 0))
2585 stream_index
= start_index
;
2587 if (++stream_index
>= is
->ic
->nb_streams
)
2589 if (codec_type
== AVMEDIA_TYPE_SUBTITLE
)
2596 if (stream_index
== start_index
)
2598 st
= ic
->streams
[stream_index
];
2599 if (st
->codecpar
->codec_type
== codec_type
) {
2600 /* check that parameters are OK */
2601 switch (codec_type
) {
2602 case AVMEDIA_TYPE_AUDIO
:
2603 if (st
->codecpar
->sample_rate
!= 0 &&
2604 st
->codecpar
->channels
!= 0)
2607 case AVMEDIA_TYPE_VIDEO
:
2608 case AVMEDIA_TYPE_SUBTITLE
:
2616 stream_component_close(is
, start_index
);
2617 stream_component_open(is
, stream_index
);
2621 static void toggle_full_screen(void)
2623 #if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
2624 /* OS X needs to empty the picture_queue */
2626 for (i
= 0; i
< VIDEO_PICTURE_QUEUE_SIZE
; i
++)
2627 player
->pictq
[i
].reallocate
= 1;
2629 is_full_screen
= !is_full_screen
;
2633 static void toggle_pause(void)
2636 stream_pause(player
);
2640 static void step_to_next_frame(void)
2643 /* if the stream is paused unpause it, then step */
2645 stream_pause(player
);
2650 static void toggle_audio_display(void)
2653 int bgcolor
= SDL_MapRGB(screen
->format
, 0x00, 0x00, 0x00);
2654 player
->show_audio
= (player
->show_audio
+ 1) % 3;
2655 fill_rectangle(screen
,
2656 player
->xleft
, player
->ytop
, player
->width
, player
->height
,
2658 SDL_UpdateRect(screen
, player
->xleft
, player
->ytop
, player
->width
, player
->height
);
2662 static void seek_chapter(PlayerState
*is
, int incr
)
2664 int64_t pos
= get_master_clock(is
) * AV_TIME_BASE
;
2667 if (!is
->ic
->nb_chapters
)
2670 /* find the current chapter */
2671 for (i
= 0; i
< is
->ic
->nb_chapters
; i
++) {
2672 AVChapter
*ch
= is
->ic
->chapters
[i
];
2673 if (av_compare_ts(pos
, AV_TIME_BASE_Q
, ch
->start
, ch
->time_base
) < 0) {
2681 if (i
>= is
->ic
->nb_chapters
)
2684 av_log(NULL
, AV_LOG_VERBOSE
, "Seeking to chapter %d.\n", i
);
2685 stream_seek(is
, av_rescale_q(is
->ic
->chapters
[i
]->start
, is
->ic
->chapters
[i
]->time_base
,
2686 AV_TIME_BASE_Q
), 0, 0);
2689 /* handle an event sent by the GUI */
2690 static void event_loop(void)
2693 double incr
, pos
, frac
;
2697 SDL_WaitEvent(&event
);
2698 switch (event
.type
) {
2700 if (exit_on_keydown
) {
2704 switch (event
.key
.keysym
.sym
) {
2710 toggle_full_screen();
2716 case SDLK_s
: // S: Step to next frame
2717 step_to_next_frame();
2721 stream_cycle_channel(player
, AVMEDIA_TYPE_AUDIO
);
2725 stream_cycle_channel(player
, AVMEDIA_TYPE_VIDEO
);
2729 stream_cycle_channel(player
, AVMEDIA_TYPE_SUBTITLE
);
2732 toggle_audio_display();
2735 seek_chapter(player
, 1);
2738 seek_chapter(player
, -1);
2753 if (seek_by_bytes
) {
2754 if (player
->video_stream
>= 0 && player
->video_current_pos
>= 0) {
2755 pos
= player
->video_current_pos
;
2756 } else if (player
->audio_stream
>= 0 && player
->audio_pkt
.pos
>= 0) {
2757 pos
= player
->audio_pkt
.pos
;
2759 pos
= avio_tell(player
->ic
->pb
);
2760 if (player
->ic
->bit_rate
)
2761 incr
*= player
->ic
->bit_rate
/ 8.0;
2765 stream_seek(player
, pos
, incr
, 1);
2767 pos
= get_master_clock(player
);
2769 stream_seek(player
, (int64_t)(pos
* AV_TIME_BASE
), (int64_t)(incr
* AV_TIME_BASE
), 0);
2777 case SDL_MOUSEBUTTONDOWN
:
2778 if (exit_on_mousedown
) {
2782 case SDL_MOUSEMOTION
:
2783 if (event
.type
== SDL_MOUSEBUTTONDOWN
) {
2786 if (event
.motion
.state
!= SDL_PRESSED
)
2791 if (seek_by_bytes
|| player
->ic
->duration
<= 0) {
2792 uint64_t size
= avio_size(player
->ic
->pb
);
2793 stream_seek(player
, size
*x
/player
->width
, 0, 1);
2797 int tns
, thh
, tmm
, tss
;
2798 tns
= player
->ic
->duration
/ 1000000LL;
2800 tmm
= (tns
% 3600) / 60;
2802 frac
= x
/ player
->width
;
2805 mm
= (ns
% 3600) / 60;
2807 fprintf(stderr
, "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac
*100,
2808 hh
, mm
, ss
, thh
, tmm
, tss
);
2809 ts
= frac
* player
->ic
->duration
;
2810 if (player
->ic
->start_time
!= AV_NOPTS_VALUE
)
2811 ts
+= player
->ic
->start_time
;
2812 stream_seek(player
, ts
, 0, 0);
2816 case SDL_VIDEORESIZE
:
2818 screen
= SDL_SetVideoMode(event
.resize
.w
, event
.resize
.h
, 0,
2819 SDL_HWSURFACE
|SDL_RESIZABLE
|SDL_ASYNCBLIT
|SDL_HWACCEL
);
2820 screen_width
= player
->width
= event
.resize
.w
;
2821 screen_height
= player
->height
= event
.resize
.h
;
2828 case FF_ALLOC_EVENT
:
2829 video_open(event
.user
.data1
);
2830 alloc_picture(event
.user
.data1
);
2832 case FF_REFRESH_EVENT
:
2833 video_refresh_timer(event
.user
.data1
);
2834 player
->refresh
= 0;
2842 static int opt_frame_size(void *optctx
, const char *opt
, const char *arg
)
2844 av_log(NULL
, AV_LOG_ERROR
,
2845 "Option '%s' has been removed, use private format options instead\n", opt
);
2846 return AVERROR(EINVAL
);
2849 static int opt_width(void *optctx
, const char *opt
, const char *arg
)
2851 screen_width
= parse_number_or_die(opt
, arg
, OPT_INT64
, 1, INT_MAX
);
2855 static int opt_height(void *optctx
, const char *opt
, const char *arg
)
2857 screen_height
= parse_number_or_die(opt
, arg
, OPT_INT64
, 1, INT_MAX
);
2861 static int opt_format(void *optctx
, const char *opt
, const char *arg
)
2863 file_iformat
= av_find_input_format(arg
);
2864 if (!file_iformat
) {
2865 fprintf(stderr
, "Unknown input format: %s\n", arg
);
2866 return AVERROR(EINVAL
);
2871 static int opt_frame_pix_fmt(void *optctx
, const char *opt
, const char *arg
)
2873 av_log(NULL
, AV_LOG_ERROR
,
2874 "Option '%s' has been removed, use private format options instead\n", opt
);
2875 return AVERROR(EINVAL
);
2878 static int opt_sync(void *optctx
, const char *opt
, const char *arg
)
2880 if (!strcmp(arg
, "audio"))
2881 av_sync_type
= AV_SYNC_AUDIO_MASTER
;
2882 else if (!strcmp(arg
, "video"))
2883 av_sync_type
= AV_SYNC_VIDEO_MASTER
;
2884 else if (!strcmp(arg
, "ext"))
2885 av_sync_type
= AV_SYNC_EXTERNAL_CLOCK
;
2887 fprintf(stderr
, "Unknown value for %s: %s\n", opt
, arg
);
2893 static int opt_seek(void *optctx
, const char *opt
, const char *arg
)
2895 start_time
= parse_time_or_die(opt
, arg
, 1);
2899 static int opt_duration(void *optctx
, const char *opt
, const char *arg
)
2901 duration
= parse_time_or_die(opt
, arg
, 1);
2905 #define OFF(x) offsetof(PlayerState, x)
2906 static const OptionDef options
[] = {
2907 #include "cmdutils_common_opts.h"
2908 { "x", HAS_ARG
, { .func_arg
= opt_width
}, "force displayed width", "width" },
2909 { "y", HAS_ARG
, { .func_arg
= opt_height
}, "force displayed height", "height" },
2910 { "s", HAS_ARG
| OPT_VIDEO
, { .func_arg
= opt_frame_size
}, "set frame size (WxH or abbreviation)", "size" },
2911 { "fs", OPT_BOOL
, { &is_full_screen
}, "force full screen" },
2912 { "an", OPT_BOOL
, { &audio_disable
}, "disable audio" },
2913 { "vn", OPT_BOOL
, { &video_disable
}, "disable video" },
2914 { "ast", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &wanted_stream
[AVMEDIA_TYPE_AUDIO
] }, "select desired audio stream", "stream_number" },
2915 { "vst", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &wanted_stream
[AVMEDIA_TYPE_VIDEO
] }, "select desired video stream", "stream_number" },
2916 { "sst", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &wanted_stream
[AVMEDIA_TYPE_SUBTITLE
] }, "select desired subtitle stream", "stream_number" },
2917 { "ss", HAS_ARG
, { .func_arg
= opt_seek
}, "seek to a given position in seconds", "pos" },
2918 { "t", HAS_ARG
, { .func_arg
= opt_duration
}, "play \"duration\" seconds of audio/video", "duration" },
2919 { "bytes", OPT_INT
| HAS_ARG
, { &seek_by_bytes
}, "seek by bytes 0=off 1=on -1=auto", "val" },
2920 { "nodisp", OPT_BOOL
, { &display_disable
}, "disable graphical display" },
2921 { "f", HAS_ARG
, { .func_arg
= opt_format
}, "force format", "fmt" },
2922 { "pix_fmt", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, { .func_arg
= opt_frame_pix_fmt
}, "set pixel format", "format" },
2923 { "stats", OPT_BOOL
| OPT_EXPERT
, { &show_status
}, "show status", "" },
2924 { "bug", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &workaround_bugs
}, "workaround bugs", "" },
2925 { "fast", OPT_BOOL
| OPT_EXPERT
, { &fast
}, "non spec compliant optimizations", "" },
2926 { "genpts", OPT_BOOL
| OPT_EXPERT
, { &genpts
}, "generate pts", "" },
2927 { "drp", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &decoder_reorder_pts
}, "let decoder reorder pts 0=off 1=on -1=auto", ""},
2928 { "skiploop", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &skip_loop_filter
}, "", "" },
2929 { "skipframe", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &skip_frame
}, "", "" },
2930 { "skipidct", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &skip_idct
}, "", "" },
2931 { "idct", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &idct
}, "set idct algo", "algo" },
2932 { "ec", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &error_concealment
}, "set error concealment options", "bit_mask" },
2933 { "sync", HAS_ARG
| OPT_EXPERT
, { .func_arg
= opt_sync
}, "set audio-video sync. type (type=audio/video/ext)", "type" },
2934 { "noautoexit", OPT_BOOL
| OPT_EXPERT
, { &noautoexit
}, "Do not exit at the end of playback", "" },
2935 { "exitonkeydown", OPT_BOOL
| OPT_EXPERT
, { &exit_on_keydown
}, "exit on key down", "" },
2936 { "exitonmousedown", OPT_BOOL
| OPT_EXPERT
, { &exit_on_mousedown
}, "exit on mouse down", "" },
2937 { "loop", OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &loop
}, "set number of times the playback shall be looped", "loop count" },
2938 { "framedrop", OPT_BOOL
| OPT_EXPERT
, { &framedrop
}, "drop frames when cpu is too slow", "" },
2939 { "infbuf", OPT_BOOL
| OPT_EXPERT
, { &infinite_buffer
}, "don't limit the input buffer size (useful with realtime streams)", "" },
2940 { "window_title", OPT_STRING
| HAS_ARG
, { &window_title
}, "set window title", "window title" },
2941 { "vf", OPT_STRING
| HAS_ARG
, { &vfilters
}, "video filters", "filter list" },
2942 { "rdftspeed", OPT_INT
| HAS_ARG
| OPT_AUDIO
| OPT_EXPERT
, { &rdftspeed
}, "rdft speed", "msecs" },
2943 { "default", HAS_ARG
| OPT_AUDIO
| OPT_VIDEO
| OPT_EXPERT
, { .func_arg
= opt_default
}, "generic catchall option", "" },
2944 { "i", 0, { NULL
}, "avconv compatibility dummy option", ""},
2945 { "autorotate", OPT_BOOL
, { &autorotate
}, "automatically rotate video", "" },
2946 { "c", HAS_ARG
| OPT_STRING
| OPT_SPEC
| OPT_INPUT
, { .off
= OFF(codec_names
) }, "codec name", "codec" },
2947 { "codec", HAS_ARG
| OPT_STRING
| OPT_SPEC
| OPT_INPUT
, { .off
= OFF(codec_names
) }, "codec name", "codec" },
2952 static void show_usage(void)
2954 printf("Simple media player\n");
2955 printf("usage: %s [options] input_file\n", program_name
);
2959 void show_help_default(const char *opt
, const char *arg
)
2961 av_log_set_callback(log_callback_help
);
2963 show_help_options(options
, "Main options:", 0, OPT_EXPERT
, 0);
2964 show_help_options(options
, "Advanced options:", OPT_EXPERT
, 0, 0);
2966 show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM
);
2967 show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM
);
2968 printf("\nWhile playing:\n"
2970 "f toggle full screen\n"
2972 "a cycle audio channel\n"
2973 "v cycle video channel\n"
2974 "t cycle subtitle channel\n"
2975 "w show audio waves\n"
2976 "s activate frame-step mode\n"
2977 "left/right seek backward/forward 10 seconds\n"
2978 "down/up seek backward/forward 1 minute\n"
2979 "mouse click seek to percentage in file corresponding to fraction of width\n"
2983 static void opt_input_file(void *optctx
, const char *filename
)
2985 if (input_filename
) {
2986 fprintf(stderr
, "Argument '%s' provided as input filename, but '%s' was already specified.\n",
2987 filename
, input_filename
);
2990 if (!strcmp(filename
, "-"))
2992 input_filename
= filename
;
2995 /* Called from the main */
2996 int main(int argc
, char **argv
)
3000 av_log_set_flags(AV_LOG_SKIP_REPEATED
);
3001 parse_loglevel(argc
, argv
, options
);
3003 /* register all codecs, demux and protocols */
3004 avcodec_register_all();
3006 avdevice_register_all();
3008 avfilter_register_all();
3010 avformat_network_init();
3016 parse_options(player
, argc
, argv
, options
, opt_input_file
);
3018 if (!input_filename
) {
3020 fprintf(stderr
, "An input file must be specified\n");
3021 fprintf(stderr
, "Use -h to get full help or, even better, run 'man %s'\n", program_name
);
3025 if (display_disable
) {
3028 flags
= SDL_INIT_VIDEO
| SDL_INIT_AUDIO
| SDL_INIT_TIMER
;
3029 #if !defined(__MINGW32__) && !defined(__APPLE__)
3030 flags
|= SDL_INIT_EVENTTHREAD
; /* Not supported on Windows or Mac OS X */
3032 if (SDL_Init (flags
)) {
3033 fprintf(stderr
, "Could not initialize SDL - %s\n", SDL_GetError());
3037 if (!display_disable
) {
3038 const SDL_VideoInfo
*vi
= SDL_GetVideoInfo();
3039 fs_screen_width
= vi
->current_w
;
3040 fs_screen_height
= vi
->current_h
;
3043 SDL_EventState(SDL_ACTIVEEVENT
, SDL_IGNORE
);
3044 SDL_EventState(SDL_SYSWMEVENT
, SDL_IGNORE
);
3045 SDL_EventState(SDL_USEREVENT
, SDL_IGNORE
);
3047 av_init_packet(&flush_pkt
);
3048 flush_pkt
.data
= (uint8_t *)&flush_pkt
;
3050 if (stream_open(player
, input_filename
, file_iformat
) < 0) {
3051 fprintf(stderr
, "Could not setup the player\n");
3052 stream_close(player
);