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
33 #include "libavutil/avstring.h"
34 #include "libavutil/eval.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/dict.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/samplefmt.h"
41 #include "libavutil/avassert.h"
42 #include "libavutil/time.h"
43 #include "libavformat/avformat.h"
44 #include "libavdevice/avdevice.h"
45 #include "libswscale/swscale.h"
46 #include "libavutil/opt.h"
47 #include "libavcodec/avfft.h"
48 #include "libswresample/swresample.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/buffersink.h"
53 # include "libavfilter/buffersrc.h"
57 #include <SDL_thread.h>
63 const char program_name[] = "ffplay";
64 const int program_birth_year = 2003;
66 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
68 #define EXTERNAL_CLOCK_MIN_FRAMES 2
69 #define EXTERNAL_CLOCK_MAX_FRAMES 10
71 /* Minimum SDL audio buffer size, in samples. */
72 #define SDL_AUDIO_MIN_BUFFER_SIZE 512
73 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
74 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
76 /* no AV sync correction is done if below the minimum AV sync threshold */
77 #define AV_SYNC_THRESHOLD_MIN 0.04
78 /* AV sync correction is done if above the maximum AV sync threshold */
79 #define AV_SYNC_THRESHOLD_MAX 0.1
80 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
81 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
82 /* no AV correction is done if too big error */
83 #define AV_NOSYNC_THRESHOLD 10.0
85 /* maximum audio speed change to get correct sync */
86 #define SAMPLE_CORRECTION_PERCENT_MAX 10
88 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
89 #define EXTERNAL_CLOCK_SPEED_MIN 0.900
90 #define EXTERNAL_CLOCK_SPEED_MAX 1.010
91 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
93 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
94 #define AUDIO_DIFF_AVG_NB 20
96 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
97 #define REFRESH_RATE 0.01
99 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
100 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
101 #define SAMPLE_ARRAY_SIZE (8 * 65536)
103 #define CURSOR_HIDE_DELAY 1000000
105 static unsigned sws_flags = SWS_BICUBIC;
107 typedef struct MyAVPacketList {
109 struct MyAVPacketList *next;
113 typedef struct PacketQueue {
114 MyAVPacketList *first_pkt, *last_pkt;
123 #define VIDEO_PICTURE_QUEUE_SIZE 3
124 #define SUBPICTURE_QUEUE_SIZE 16
125 #define SAMPLE_QUEUE_SIZE 9
126 #define FRAME_QUEUE_SIZE FFMAX(SAMPLE_QUEUE_SIZE, FFMAX(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE))
128 typedef struct AudioParams {
131 int64_t channel_layout;
132 enum AVSampleFormat fmt;
137 typedef struct Clock {
138 double pts; /* clock base */
139 double pts_drift; /* clock base minus time at which we updated the clock */
142 int serial; /* clock is based on a packet with this serial */
144 int *queue_serial; /* pointer to the current packet queue serial, used for obsolete clock detection */
147 /* Common struct for handling all types of decoded data and allocated render buffers. */
148 typedef struct Frame {
152 double pts; /* presentation timestamp for the frame */
153 double duration; /* estimated duration of the frame */
154 int64_t pos; /* byte position of the frame in the input file */
163 typedef struct FrameQueue {
164 Frame queue[FRAME_QUEUE_SIZE];
177 AV_SYNC_AUDIO_MASTER, /* default choice */
178 AV_SYNC_VIDEO_MASTER,
179 AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
182 typedef struct Decoder {
186 AVCodecContext *avctx;
190 SDL_cond *empty_queue_cond;
192 AVRational start_pts_tb;
194 AVRational next_pts_tb;
195 SDL_Thread *decoder_tid;
198 typedef struct VideoState {
199 SDL_Thread *read_tid;
200 AVInputFormat *iformat;
205 int queue_attachments_req;
210 int read_pause_return;
234 int audio_clock_serial;
235 double audio_diff_cum; /* used for AV difference average computation */
236 double audio_diff_avg_coef;
237 double audio_diff_threshold;
238 int audio_diff_avg_count;
241 int audio_hw_buf_size;
242 uint8_t silence_buf[SDL_AUDIO_MIN_BUFFER_SIZE];
245 unsigned int audio_buf_size; /* in bytes */
246 unsigned int audio_buf1_size;
247 int audio_buf_index; /* in bytes */
248 int audio_write_buf_size;
249 struct AudioParams audio_src;
251 struct AudioParams audio_filter_src;
253 struct AudioParams audio_tgt;
254 struct SwrContext *swr_ctx;
255 int frame_drops_early;
256 int frame_drops_late;
259 SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
261 int16_t sample_array[SAMPLE_ARRAY_SIZE];
262 int sample_array_index;
266 FFTSample *rdft_data;
268 double last_vis_time;
271 AVStream *subtitle_st;
272 PacketQueue subtitleq;
275 double frame_last_returned_time;
276 double frame_last_filter_delay;
280 double max_frame_duration; // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
282 struct SwsContext *img_convert_ctx;
284 struct SwsContext *sub_convert_ctx;
285 SDL_Rect last_display_rect;
289 int width, height, xleft, ytop;
294 AVFilterContext *in_video_filter; // the first filter in the video chain
295 AVFilterContext *out_video_filter; // the last filter in the video chain
296 AVFilterContext *in_audio_filter; // the first filter in the audio chain
297 AVFilterContext *out_audio_filter; // the last filter in the audio chain
298 AVFilterGraph *agraph; // audio filter graph
301 int last_video_stream, last_audio_stream, last_subtitle_stream;
303 SDL_cond *continue_read_thread;
306 /* options specified by the user */
307 static AVInputFormat *file_iformat;
308 static const char *input_filename;
309 static const char *window_title;
310 static int fs_screen_width;
311 static int fs_screen_height;
312 static int default_width = 640;
313 static int default_height = 480;
314 static int screen_width = 0;
315 static int screen_height = 0;
316 static int audio_disable;
317 static int video_disable;
318 static int subtitle_disable;
319 static const char* wanted_stream_spec[AVMEDIA_TYPE_NB] = {0};
320 static int seek_by_bytes = -1;
321 static int display_disable;
322 static int show_status = 1;
323 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
324 static int64_t start_time = AV_NOPTS_VALUE;
325 static int64_t duration = AV_NOPTS_VALUE;
327 static int genpts = 0;
328 static int lowres = 0;
329 static int decoder_reorder_pts = -1;
331 static int exit_on_keydown;
332 static int exit_on_mousedown;
334 static int framedrop = -1;
335 static int infinite_buffer = -1;
336 static enum ShowMode show_mode = SHOW_MODE_NONE;
337 static const char *audio_codec_name;
338 static const char *subtitle_codec_name;
339 static const char *video_codec_name;
340 double rdftspeed = 0.02;
341 static int64_t cursor_last_shown;
342 static int cursor_hidden = 0;
344 static const char **vfilters_list = NULL;
345 static int nb_vfilters = 0;
346 static char *afilters = NULL;
348 static int autorotate = 1;
350 /* current context */
351 static int is_full_screen;
352 static int64_t audio_callback_time;
354 static AVPacket flush_pkt;
356 #define FF_ALLOC_EVENT (SDL_USEREVENT)
357 #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
359 static SDL_Surface *screen;
362 static int opt_add_vfilter(void *optctx, const char *opt, const char *arg)
364 GROW_ARRAY(vfilters_list, nb_vfilters);
365 vfilters_list[nb_vfilters - 1] = arg;
371 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
372 enum AVSampleFormat fmt2, int64_t channel_count2)
374 /* If channel count == 1, planar and non-planar formats are the same */
375 if (channel_count1 == 1 && channel_count2 == 1)
376 return av_get_packed_sample_fmt(fmt1) != av_get_packed_sample_fmt(fmt2);
378 return channel_count1 != channel_count2 || fmt1 != fmt2;
382 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
384 if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
385 return channel_layout;
390 static void free_picture(Frame *vp);
392 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
394 MyAVPacketList *pkt1;
396 if (q->abort_request)
399 pkt1 = av_malloc(sizeof(MyAVPacketList));
404 if (pkt == &flush_pkt)
406 pkt1->serial = q->serial;
411 q->last_pkt->next = pkt1;
414 q->size += pkt1->pkt.size + sizeof(*pkt1);
415 /* XXX: should duplicate packet data in DV case */
416 SDL_CondSignal(q->cond);
420 static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
424 /* duplicate the packet */
425 if (pkt != &flush_pkt && av_dup_packet(pkt) < 0)
428 SDL_LockMutex(q->mutex);
429 ret = packet_queue_put_private(q, pkt);
430 SDL_UnlockMutex(q->mutex);
432 if (pkt != &flush_pkt && ret < 0)
438 static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
440 AVPacket pkt1, *pkt = &pkt1;
444 pkt->stream_index = stream_index;
445 return packet_queue_put(q, pkt);
448 /* packet queue handling */
449 static void packet_queue_init(PacketQueue *q)
451 memset(q, 0, sizeof(PacketQueue));
452 q->mutex = SDL_CreateMutex();
453 q->cond = SDL_CreateCond();
454 q->abort_request = 1;
457 static void packet_queue_flush(PacketQueue *q)
459 MyAVPacketList *pkt, *pkt1;
461 SDL_LockMutex(q->mutex);
462 for (pkt = q->first_pkt; pkt; pkt = pkt1) {
464 av_free_packet(&pkt->pkt);
471 SDL_UnlockMutex(q->mutex);
474 static void packet_queue_destroy(PacketQueue *q)
476 packet_queue_flush(q);
477 SDL_DestroyMutex(q->mutex);
478 SDL_DestroyCond(q->cond);
481 static void packet_queue_abort(PacketQueue *q)
483 SDL_LockMutex(q->mutex);
485 q->abort_request = 1;
487 SDL_CondSignal(q->cond);
489 SDL_UnlockMutex(q->mutex);
492 static void packet_queue_start(PacketQueue *q)
494 SDL_LockMutex(q->mutex);
495 q->abort_request = 0;
496 packet_queue_put_private(q, &flush_pkt);
497 SDL_UnlockMutex(q->mutex);
500 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
501 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
503 MyAVPacketList *pkt1;
506 SDL_LockMutex(q->mutex);
509 if (q->abort_request) {
516 q->first_pkt = pkt1->next;
520 q->size -= pkt1->pkt.size + sizeof(*pkt1);
523 *serial = pkt1->serial;
531 SDL_CondWait(q->cond, q->mutex);
534 SDL_UnlockMutex(q->mutex);
538 static void decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
539 memset(d, 0, sizeof(Decoder));
542 d->empty_queue_cond = empty_queue_cond;
543 d->start_pts = AV_NOPTS_VALUE;
546 static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
552 if (d->queue->abort_request)
555 if (!d->packet_pending || d->queue->serial != d->pkt_serial) {
558 if (d->queue->nb_packets == 0)
559 SDL_CondSignal(d->empty_queue_cond);
560 if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
562 if (pkt.data == flush_pkt.data) {
563 avcodec_flush_buffers(d->avctx);
565 d->next_pts = d->start_pts;
566 d->next_pts_tb = d->start_pts_tb;
568 } while (pkt.data == flush_pkt.data || d->queue->serial != d->pkt_serial);
569 av_free_packet(&d->pkt);
570 d->pkt_temp = d->pkt = pkt;
571 d->packet_pending = 1;
574 switch (d->avctx->codec_type) {
575 case AVMEDIA_TYPE_VIDEO:
576 ret = avcodec_decode_video2(d->avctx, frame, &got_frame, &d->pkt_temp);
578 if (decoder_reorder_pts == -1) {
579 frame->pts = av_frame_get_best_effort_timestamp(frame);
580 } else if (decoder_reorder_pts) {
581 frame->pts = frame->pkt_pts;
583 frame->pts = frame->pkt_dts;
587 case AVMEDIA_TYPE_AUDIO:
588 ret = avcodec_decode_audio4(d->avctx, frame, &got_frame, &d->pkt_temp);
590 AVRational tb = (AVRational){1, frame->sample_rate};
591 if (frame->pts != AV_NOPTS_VALUE)
592 frame->pts = av_rescale_q(frame->pts, d->avctx->time_base, tb);
593 else if (frame->pkt_pts != AV_NOPTS_VALUE)
594 frame->pts = av_rescale_q(frame->pkt_pts, av_codec_get_pkt_timebase(d->avctx), tb);
595 else if (d->next_pts != AV_NOPTS_VALUE)
596 frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
597 if (frame->pts != AV_NOPTS_VALUE) {
598 d->next_pts = frame->pts + frame->nb_samples;
603 case AVMEDIA_TYPE_SUBTITLE:
604 ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &d->pkt_temp);
609 d->packet_pending = 0;
612 d->pkt_temp.pts = AV_NOPTS_VALUE;
613 if (d->pkt_temp.data) {
614 if (d->avctx->codec_type != AVMEDIA_TYPE_AUDIO)
615 ret = d->pkt_temp.size;
616 d->pkt_temp.data += ret;
617 d->pkt_temp.size -= ret;
618 if (d->pkt_temp.size <= 0)
619 d->packet_pending = 0;
622 d->packet_pending = 0;
623 d->finished = d->pkt_serial;
627 } while (!got_frame && !d->finished);
632 static void decoder_destroy(Decoder *d) {
633 av_free_packet(&d->pkt);
636 static void frame_queue_unref_item(Frame *vp)
638 av_frame_unref(vp->frame);
639 avsubtitle_free(&vp->sub);
642 static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last)
645 memset(f, 0, sizeof(FrameQueue));
646 if (!(f->mutex = SDL_CreateMutex()))
647 return AVERROR(ENOMEM);
648 if (!(f->cond = SDL_CreateCond()))
649 return AVERROR(ENOMEM);
651 f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
652 f->keep_last = !!keep_last;
653 for (i = 0; i < f->max_size; i++)
654 if (!(f->queue[i].frame = av_frame_alloc()))
655 return AVERROR(ENOMEM);
659 static void frame_queue_destory(FrameQueue *f)
662 for (i = 0; i < f->max_size; i++) {
663 Frame *vp = &f->queue[i];
664 frame_queue_unref_item(vp);
665 av_frame_free(&vp->frame);
668 SDL_DestroyMutex(f->mutex);
669 SDL_DestroyCond(f->cond);
672 static void frame_queue_signal(FrameQueue *f)
674 SDL_LockMutex(f->mutex);
675 SDL_CondSignal(f->cond);
676 SDL_UnlockMutex(f->mutex);
679 static Frame *frame_queue_peek(FrameQueue *f)
681 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
684 static Frame *frame_queue_peek_next(FrameQueue *f)
686 return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];
689 static Frame *frame_queue_peek_last(FrameQueue *f)
691 return &f->queue[f->rindex];
694 static Frame *frame_queue_peek_writable(FrameQueue *f)
696 /* wait until we have space to put a new frame */
697 SDL_LockMutex(f->mutex);
698 while (f->size >= f->max_size &&
699 !f->pktq->abort_request) {
700 SDL_CondWait(f->cond, f->mutex);
702 SDL_UnlockMutex(f->mutex);
704 if (f->pktq->abort_request)
707 return &f->queue[f->windex];
710 static Frame *frame_queue_peek_readable(FrameQueue *f)
712 /* wait until we have a readable a new frame */
713 SDL_LockMutex(f->mutex);
714 while (f->size - f->rindex_shown <= 0 &&
715 !f->pktq->abort_request) {
716 SDL_CondWait(f->cond, f->mutex);
718 SDL_UnlockMutex(f->mutex);
720 if (f->pktq->abort_request)
723 return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
726 static void frame_queue_push(FrameQueue *f)
728 if (++f->windex == f->max_size)
730 SDL_LockMutex(f->mutex);
732 SDL_CondSignal(f->cond);
733 SDL_UnlockMutex(f->mutex);
736 static void frame_queue_next(FrameQueue *f)
738 if (f->keep_last && !f->rindex_shown) {
742 frame_queue_unref_item(&f->queue[f->rindex]);
743 if (++f->rindex == f->max_size)
745 SDL_LockMutex(f->mutex);
747 SDL_CondSignal(f->cond);
748 SDL_UnlockMutex(f->mutex);
751 /* jump back to the previous frame if available by resetting rindex_shown */
752 static int frame_queue_prev(FrameQueue *f)
754 int ret = f->rindex_shown;
759 /* return the number of undisplayed frames in the queue */
760 static int frame_queue_nb_remaining(FrameQueue *f)
762 return f->size - f->rindex_shown;
765 /* return last shown position */
766 static int64_t frame_queue_last_pos(FrameQueue *f)
768 Frame *fp = &f->queue[f->rindex];
769 if (f->rindex_shown && fp->serial == f->pktq->serial)
775 static void decoder_abort(Decoder *d, FrameQueue *fq)
777 packet_queue_abort(d->queue);
778 frame_queue_signal(fq);
779 SDL_WaitThread(d->decoder_tid, NULL);
780 d->decoder_tid = NULL;
781 packet_queue_flush(d->queue);
784 static inline void fill_rectangle(SDL_Surface *screen,
785 int x, int y, int w, int h, int color, int update)
792 SDL_FillRect(screen, &rect, color);
793 if (update && w > 0 && h > 0)
794 SDL_UpdateRect(screen, x, y, w, h);
797 /* draw only the border of a rectangle */
798 static void fill_border(int xleft, int ytop, int width, int height, int x, int y, int w, int h, int color, int update)
802 /* fill the background */
806 w2 = width - (x + w);
812 h2 = height - (y + h);
815 fill_rectangle(screen,
819 fill_rectangle(screen,
820 xleft + width - w2, ytop,
823 fill_rectangle(screen,
827 fill_rectangle(screen,
828 xleft + w1, ytop + height - h2,
833 #define ALPHA_BLEND(a, oldp, newp, s)\
834 ((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
840 static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh)
842 int x, y, Y, U, V, A;
843 uint8_t *lum, *cb, *cr;
844 int dstx, dsty, dstw, dsth;
845 const AVPicture *src = &rect->pict;
847 dstw = av_clip(rect->w, 0, imgw);
848 dsth = av_clip(rect->h, 0, imgh);
849 dstx = av_clip(rect->x, 0, imgw - dstw);
850 dsty = av_clip(rect->y, 0, imgh - dsth);
851 lum = dst->data[0] + dstx + dsty * dst->linesize[0];
852 cb = dst->data[1] + dstx/2 + (dsty >> 1) * dst->linesize[1];
853 cr = dst->data[2] + dstx/2 + (dsty >> 1) * dst->linesize[2];
855 for (y = 0; y<dsth; y++) {
856 for (x = 0; x<dstw; x++) {
857 Y = src->data[0][x + y*src->linesize[0]];
858 A = src->data[3][x + y*src->linesize[3]];
859 lum[0] = ALPHA_BLEND(A, lum[0], Y, 0);
862 lum += dst->linesize[0] - dstw;
865 for (y = 0; y<dsth/2; y++) {
866 for (x = 0; x<dstw/2; x++) {
867 U = src->data[1][x + y*src->linesize[1]];
868 V = src->data[2][x + y*src->linesize[2]];
869 A = src->data[3][2*x + 2*y *src->linesize[3]]
870 + src->data[3][2*x + 1 + 2*y *src->linesize[3]]
871 + src->data[3][2*x + 1 + (2*y+1)*src->linesize[3]]
872 + src->data[3][2*x + (2*y+1)*src->linesize[3]];
873 cb[0] = ALPHA_BLEND(A>>2, cb[0], U, 0);
874 cr[0] = ALPHA_BLEND(A>>2, cr[0], V, 0);
878 cb += dst->linesize[1] - dstw/2;
879 cr += dst->linesize[2] - dstw/2;
883 static void free_picture(Frame *vp)
886 SDL_FreeYUVOverlay(vp->bmp);
891 static void calculate_display_rect(SDL_Rect *rect,
892 int scr_xleft, int scr_ytop, int scr_width, int scr_height,
893 int pic_width, int pic_height, AVRational pic_sar)
896 int width, height, x, y;
898 if (pic_sar.num == 0)
901 aspect_ratio = av_q2d(pic_sar);
903 if (aspect_ratio <= 0.0)
905 aspect_ratio *= (float)pic_width / (float)pic_height;
907 /* XXX: we suppose the screen has a 1.0 pixel ratio */
909 width = ((int)rint(height * aspect_ratio)) & ~1;
910 if (width > scr_width) {
912 height = ((int)rint(width / aspect_ratio)) & ~1;
914 x = (scr_width - width) / 2;
915 y = (scr_height - height) / 2;
916 rect->x = scr_xleft + x;
917 rect->y = scr_ytop + y;
918 rect->w = FFMAX(width, 1);
919 rect->h = FFMAX(height, 1);
922 static void video_image_display(VideoState *is)
930 vp = frame_queue_peek(&is->pictq);
932 if (is->subtitle_st) {
933 if (frame_queue_nb_remaining(&is->subpq) > 0) {
934 sp = frame_queue_peek(&is->subpq);
936 if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
937 SDL_LockYUVOverlay (vp->bmp);
939 pict.data[0] = vp->bmp->pixels[0];
940 pict.data[1] = vp->bmp->pixels[2];
941 pict.data[2] = vp->bmp->pixels[1];
943 pict.linesize[0] = vp->bmp->pitches[0];
944 pict.linesize[1] = vp->bmp->pitches[2];
945 pict.linesize[2] = vp->bmp->pitches[1];
947 for (i = 0; i < sp->sub.num_rects; i++)
948 blend_subrect(&pict, sp->sub.rects[i],
949 vp->bmp->w, vp->bmp->h);
951 SDL_UnlockYUVOverlay (vp->bmp);
956 calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
958 SDL_DisplayYUVOverlay(vp->bmp, &rect);
960 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) {
961 int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
962 fill_border(is->xleft, is->ytop, is->width, is->height, rect.x, rect.y, rect.w, rect.h, bgcolor, 1);
963 is->last_display_rect = rect;
968 static inline int compute_mod(int a, int b)
970 return a < 0 ? a%b + b : a%b;
973 static void video_audio_display(VideoState *s)
975 int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
976 int ch, channels, h, h2, bgcolor, fgcolor;
978 int rdft_bits, nb_freq;
980 for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
982 nb_freq = 1 << (rdft_bits - 1);
984 /* compute display index : center on currently output samples */
985 channels = s->audio_tgt.channels;
986 nb_display_channels = channels;
988 int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
990 delay = s->audio_write_buf_size;
993 /* to be more precise, we take into account the time spent since
994 the last buffer computation */
995 if (audio_callback_time) {
996 time_diff = av_gettime_relative() - audio_callback_time;
997 delay -= (time_diff * s->audio_tgt.freq) / 1000000;
1000 delay += 2 * data_used;
1001 if (delay < data_used)
1004 i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
1005 if (s->show_mode == SHOW_MODE_WAVES) {
1007 for (i = 0; i < 1000; i += channels) {
1008 int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
1009 int a = s->sample_array[idx];
1010 int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
1011 int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
1012 int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
1014 if (h < score && (b ^ c) < 0) {
1021 s->last_i_start = i_start;
1023 i_start = s->last_i_start;
1026 bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
1027 if (s->show_mode == SHOW_MODE_WAVES) {
1028 fill_rectangle(screen,
1029 s->xleft, s->ytop, s->width, s->height,
1032 fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
1034 /* total height for one channel */
1035 h = s->height / nb_display_channels;
1036 /* graph height / 2 */
1038 for (ch = 0; ch < nb_display_channels; ch++) {
1040 y1 = s->ytop + ch * h + (h / 2); /* position of center line */
1041 for (x = 0; x < s->width; x++) {
1042 y = (s->sample_array[i] * h2) >> 15;
1049 fill_rectangle(screen,
1050 s->xleft + x, ys, 1, y,
1053 if (i >= SAMPLE_ARRAY_SIZE)
1054 i -= SAMPLE_ARRAY_SIZE;
1058 fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
1060 for (ch = 1; ch < nb_display_channels; ch++) {
1061 y = s->ytop + ch * h;
1062 fill_rectangle(screen,
1063 s->xleft, y, s->width, 1,
1066 SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
1068 nb_display_channels= FFMIN(nb_display_channels, 2);
1069 if (rdft_bits != s->rdft_bits) {
1070 av_rdft_end(s->rdft);
1071 av_free(s->rdft_data);
1072 s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
1073 s->rdft_bits = rdft_bits;
1074 s->rdft_data = av_malloc_array(nb_freq, 4 *sizeof(*s->rdft_data));
1076 if (!s->rdft || !s->rdft_data){
1077 av_log(NULL, AV_LOG_ERROR, "Failed to allocate buffers for RDFT, switching to waves display\n");
1078 s->show_mode = SHOW_MODE_WAVES;
1081 for (ch = 0; ch < nb_display_channels; ch++) {
1082 data[ch] = s->rdft_data + 2 * nb_freq * ch;
1084 for (x = 0; x < 2 * nb_freq; x++) {
1085 double w = (x-nb_freq) * (1.0 / nb_freq);
1086 data[ch][x] = s->sample_array[i] * (1.0 - w * w);
1088 if (i >= SAMPLE_ARRAY_SIZE)
1089 i -= SAMPLE_ARRAY_SIZE;
1091 av_rdft_calc(s->rdft, data[ch]);
1093 /* Least efficient way to do this, we should of course
1094 * directly access it but it is more than fast enough. */
1095 for (y = 0; y < s->height; y++) {
1096 double w = 1 / sqrt(nb_freq);
1097 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]));
1098 int b = (nb_display_channels == 2 ) ? sqrt(w * sqrt(data[1][2 * y + 0] * data[1][2 * y + 0]
1099 + data[1][2 * y + 1] * data[1][2 * y + 1])) : a;
1102 fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);
1104 fill_rectangle(screen,
1105 s->xpos, s->height-y, 1, 1,
1109 SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
1112 if (s->xpos >= s->width)
1117 static void stream_close(VideoState *is)
1119 /* XXX: use a special url_shutdown call to abort parse cleanly */
1120 is->abort_request = 1;
1121 SDL_WaitThread(is->read_tid, NULL);
1122 packet_queue_destroy(&is->videoq);
1123 packet_queue_destroy(&is->audioq);
1124 packet_queue_destroy(&is->subtitleq);
1126 /* free all pictures */
1127 frame_queue_destory(&is->pictq);
1128 frame_queue_destory(&is->sampq);
1129 frame_queue_destory(&is->subpq);
1130 SDL_DestroyCond(is->continue_read_thread);
1131 #if !CONFIG_AVFILTER
1132 sws_freeContext(is->img_convert_ctx);
1134 sws_freeContext(is->sub_convert_ctx);
1138 static void do_exit(VideoState *is)
1143 av_lockmgr_register(NULL);
1146 av_freep(&vfilters_list);
1148 avformat_network_deinit();
1152 av_log(NULL, AV_LOG_QUIET, "%s", "");
1156 static void sigterm_handler(int sig)
1161 static void set_default_window_size(int width, int height, AVRational sar)
1164 calculate_display_rect(&rect, 0, 0, INT_MAX, height, width, height, sar);
1165 default_width = rect.w;
1166 default_height = rect.h;
1169 static int video_open(VideoState *is, int force_set_video_mode, Frame *vp)
1171 int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
1174 if (is_full_screen) flags |= SDL_FULLSCREEN;
1175 else flags |= SDL_RESIZABLE;
1177 if (vp && vp->width)
1178 set_default_window_size(vp->width, vp->height, vp->sar);
1180 if (is_full_screen && fs_screen_width) {
1181 w = fs_screen_width;
1182 h = fs_screen_height;
1183 } else if (!is_full_screen && screen_width) {
1190 w = FFMIN(16383, w);
1191 if (screen && is->width == screen->w && screen->w == w
1192 && is->height== screen->h && screen->h == h && !force_set_video_mode)
1194 screen = SDL_SetVideoMode(w, h, 0, flags);
1196 av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");
1200 window_title = input_filename;
1201 SDL_WM_SetCaption(window_title, window_title);
1203 is->width = screen->w;
1204 is->height = screen->h;
1209 /* display the current picture, if any */
1210 static void video_display(VideoState *is)
1213 video_open(is, 0, NULL);
1214 if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1215 video_audio_display(is);
1216 else if (is->video_st)
1217 video_image_display(is);
1220 static double get_clock(Clock *c)
1222 if (*c->queue_serial != c->serial)
1227 double time = av_gettime_relative() / 1000000.0;
1228 return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1232 static void set_clock_at(Clock *c, double pts, int serial, double time)
1235 c->last_updated = time;
1236 c->pts_drift = c->pts - time;
1240 static void set_clock(Clock *c, double pts, int serial)
1242 double time = av_gettime_relative() / 1000000.0;
1243 set_clock_at(c, pts, serial, time);
1246 static void set_clock_speed(Clock *c, double speed)
1248 set_clock(c, get_clock(c), c->serial);
1252 static void init_clock(Clock *c, int *queue_serial)
1256 c->queue_serial = queue_serial;
1257 set_clock(c, NAN, -1);
1260 static void sync_clock_to_slave(Clock *c, Clock *slave)
1262 double clock = get_clock(c);
1263 double slave_clock = get_clock(slave);
1264 if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1265 set_clock(c, slave_clock, slave->serial);
1268 static int get_master_sync_type(VideoState *is) {
1269 if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1271 return AV_SYNC_VIDEO_MASTER;
1273 return AV_SYNC_AUDIO_MASTER;
1274 } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1276 return AV_SYNC_AUDIO_MASTER;
1278 return AV_SYNC_EXTERNAL_CLOCK;
1280 return AV_SYNC_EXTERNAL_CLOCK;
1284 /* get the current master clock value */
1285 static double get_master_clock(VideoState *is)
1289 switch (get_master_sync_type(is)) {
1290 case AV_SYNC_VIDEO_MASTER:
1291 val = get_clock(&is->vidclk);
1293 case AV_SYNC_AUDIO_MASTER:
1294 val = get_clock(&is->audclk);
1297 val = get_clock(&is->extclk);
1303 static void check_external_clock_speed(VideoState *is) {
1304 if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1305 is->audio_stream >= 0 && is->audioq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES) {
1306 set_clock_speed(&is->extclk, FFMAX(EXTERNAL_CLOCK_SPEED_MIN, is->extclk.speed - EXTERNAL_CLOCK_SPEED_STEP));
1307 } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1308 (is->audio_stream < 0 || is->audioq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES)) {
1309 set_clock_speed(&is->extclk, FFMIN(EXTERNAL_CLOCK_SPEED_MAX, is->extclk.speed + EXTERNAL_CLOCK_SPEED_STEP));
1311 double speed = is->extclk.speed;
1313 set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1317 /* seek in the stream */
1318 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1320 if (!is->seek_req) {
1323 is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1325 is->seek_flags |= AVSEEK_FLAG_BYTE;
1327 SDL_CondSignal(is->continue_read_thread);
1331 /* pause or resume the video */
1332 static void stream_toggle_pause(VideoState *is)
1335 is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1336 if (is->read_pause_return != AVERROR(ENOSYS)) {
1337 is->vidclk.paused = 0;
1339 set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1341 set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1342 is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1345 static void toggle_pause(VideoState *is)
1347 stream_toggle_pause(is);
1351 static void step_to_next_frame(VideoState *is)
1353 /* if the stream is paused unpause it, then step */
1355 stream_toggle_pause(is);
1359 static double compute_target_delay(double delay, VideoState *is)
1361 double sync_threshold, diff = 0;
1363 /* update delay to follow master synchronisation source */
1364 if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
1365 /* if video is slave, we try to correct big delays by
1366 duplicating or deleting a frame */
1367 diff = get_clock(&is->vidclk) - get_master_clock(is);
1369 /* skip or repeat frame. We take into account the
1370 delay to compute the threshold. I still don't know
1371 if it is the best guess */
1372 sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1373 if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1374 if (diff <= -sync_threshold)
1375 delay = FFMAX(0, delay + diff);
1376 else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1377 delay = delay + diff;
1378 else if (diff >= sync_threshold)
1383 av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1389 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1390 if (vp->serial == nextvp->serial) {
1391 double duration = nextvp->pts - vp->pts;
1392 if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1393 return vp->duration;
1401 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1402 /* update current video pts */
1403 set_clock(&is->vidclk, pts, serial);
1404 sync_clock_to_slave(&is->extclk, &is->vidclk);
1407 /* called to display each frame */
1408 static void video_refresh(void *opaque, double *remaining_time)
1410 VideoState *is = opaque;
1415 if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1416 check_external_clock_speed(is);
1418 if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1419 time = av_gettime_relative() / 1000000.0;
1420 if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1422 is->last_vis_time = time;
1424 *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1429 if (is->force_refresh)
1430 redisplay = frame_queue_prev(&is->pictq);
1432 if (frame_queue_nb_remaining(&is->pictq) == 0) {
1433 // nothing to do, no picture to display in the queue
1435 double last_duration, duration, delay;
1438 /* dequeue the picture */
1439 lastvp = frame_queue_peek_last(&is->pictq);
1440 vp = frame_queue_peek(&is->pictq);
1442 if (vp->serial != is->videoq.serial) {
1443 frame_queue_next(&is->pictq);
1448 if (lastvp->serial != vp->serial && !redisplay)
1449 is->frame_timer = av_gettime_relative() / 1000000.0;
1454 /* compute nominal last_duration */
1455 last_duration = vp_duration(is, lastvp, vp);
1459 delay = compute_target_delay(last_duration, is);
1461 time= av_gettime_relative()/1000000.0;
1462 if (time < is->frame_timer + delay && !redisplay) {
1463 *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1467 is->frame_timer += delay;
1468 if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1469 is->frame_timer = time;
1471 SDL_LockMutex(is->pictq.mutex);
1472 if (!redisplay && !isnan(vp->pts))
1473 update_video_pts(is, vp->pts, vp->pos, vp->serial);
1474 SDL_UnlockMutex(is->pictq.mutex);
1476 if (frame_queue_nb_remaining(&is->pictq) > 1) {
1477 Frame *nextvp = frame_queue_peek_next(&is->pictq);
1478 duration = vp_duration(is, vp, nextvp);
1479 if(!is->step && (redisplay || framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1481 is->frame_drops_late++;
1482 frame_queue_next(&is->pictq);
1488 if (is->subtitle_st) {
1489 while (frame_queue_nb_remaining(&is->subpq) > 0) {
1490 sp = frame_queue_peek(&is->subpq);
1492 if (frame_queue_nb_remaining(&is->subpq) > 1)
1493 sp2 = frame_queue_peek_next(&is->subpq);
1497 if (sp->serial != is->subtitleq.serial
1498 || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1499 || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1501 frame_queue_next(&is->subpq);
1509 /* display picture */
1510 if (!display_disable && is->show_mode == SHOW_MODE_VIDEO)
1513 frame_queue_next(&is->pictq);
1515 if (is->step && !is->paused)
1516 stream_toggle_pause(is);
1519 is->force_refresh = 0;
1521 static int64_t last_time;
1523 int aqsize, vqsize, sqsize;
1526 cur_time = av_gettime_relative();
1527 if (!last_time || (cur_time - last_time) >= 30000) {
1532 aqsize = is->audioq.size;
1534 vqsize = is->videoq.size;
1535 if (is->subtitle_st)
1536 sqsize = is->subtitleq.size;
1538 if (is->audio_st && is->video_st)
1539 av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1540 else if (is->video_st)
1541 av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1542 else if (is->audio_st)
1543 av_diff = get_master_clock(is) - get_clock(&is->audclk);
1544 av_log(NULL, AV_LOG_INFO,
1545 "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1546 get_master_clock(is),
1547 (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
1549 is->frame_drops_early + is->frame_drops_late,
1553 is->video_st ? is->video_st->codec->pts_correction_num_faulty_dts : 0,
1554 is->video_st ? is->video_st->codec->pts_correction_num_faulty_pts : 0);
1556 last_time = cur_time;
1561 /* allocate a picture (needs to do that in main thread to avoid
1562 potential locking problems */
1563 static void alloc_picture(VideoState *is)
1568 vp = &is->pictq.queue[is->pictq.windex];
1572 video_open(is, 0, vp);
1574 vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
1577 bufferdiff = vp->bmp ? FFMAX(vp->bmp->pixels[0], vp->bmp->pixels[1]) - FFMIN(vp->bmp->pixels[0], vp->bmp->pixels[1]) : 0;
1578 if (!vp->bmp || vp->bmp->pitches[0] < vp->width || bufferdiff < (int64_t)vp->height * vp->bmp->pitches[0]) {
1579 /* SDL allocates a buffer smaller than requested if the video
1580 * overlay hardware is unable to support the requested size. */
1581 av_log(NULL, AV_LOG_FATAL,
1582 "Error: the video system does not support an image\n"
1583 "size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
1584 "to reduce the image size.\n", vp->width, vp->height );
1588 SDL_LockMutex(is->pictq.mutex);
1590 SDL_CondSignal(is->pictq.cond);
1591 SDL_UnlockMutex(is->pictq.mutex);
1594 static void duplicate_right_border_pixels(SDL_Overlay *bmp) {
1595 int i, width, height;
1597 for (i = 0; i < 3; i++) {
1604 if (bmp->pitches[i] > width) {
1605 maxp = bmp->pixels[i] + bmp->pitches[i] * height - 1;
1606 for (p = bmp->pixels[i] + width - 1; p < maxp; p += bmp->pitches[i])
1612 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1616 #if defined(DEBUG_SYNC) && 0
1617 printf("frame_type=%c pts=%0.3f\n",
1618 av_get_picture_type_char(src_frame->pict_type), pts);
1621 if (!(vp = frame_queue_peek_writable(&is->pictq)))
1624 vp->sar = src_frame->sample_aspect_ratio;
1626 /* alloc or resize hardware picture buffer */
1627 if (!vp->bmp || vp->reallocate || !vp->allocated ||
1628 vp->width != src_frame->width ||
1629 vp->height != src_frame->height) {
1634 vp->width = src_frame->width;
1635 vp->height = src_frame->height;
1637 /* the allocation must be done in the main thread to avoid
1638 locking problems. */
1639 event.type = FF_ALLOC_EVENT;
1640 event.user.data1 = is;
1641 SDL_PushEvent(&event);
1643 /* wait until the picture is allocated */
1644 SDL_LockMutex(is->pictq.mutex);
1645 while (!vp->allocated && !is->videoq.abort_request) {
1646 SDL_CondWait(is->pictq.cond, is->pictq.mutex);
1648 /* if the queue is aborted, we have to pop the pending ALLOC event or wait for the allocation to complete */
1649 if (is->videoq.abort_request && SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_EVENTMASK(FF_ALLOC_EVENT)) != 1) {
1650 while (!vp->allocated && !is->abort_request) {
1651 SDL_CondWait(is->pictq.cond, is->pictq.mutex);
1654 SDL_UnlockMutex(is->pictq.mutex);
1656 if (is->videoq.abort_request)
1660 /* if the frame is not skipped, then display it */
1662 AVPicture pict = { { 0 } };
1664 /* get a pointer on the bitmap */
1665 SDL_LockYUVOverlay (vp->bmp);
1667 pict.data[0] = vp->bmp->pixels[0];
1668 pict.data[1] = vp->bmp->pixels[2];
1669 pict.data[2] = vp->bmp->pixels[1];
1671 pict.linesize[0] = vp->bmp->pitches[0];
1672 pict.linesize[1] = vp->bmp->pitches[2];
1673 pict.linesize[2] = vp->bmp->pitches[1];
1676 // FIXME use direct rendering
1677 av_picture_copy(&pict, (AVPicture *)src_frame,
1678 src_frame->format, vp->width, vp->height);
1681 AVDictionaryEntry *e = av_dict_get(sws_dict, "sws_flags", NULL, 0);
1683 const AVClass *class = sws_get_class();
1684 const AVOption *o = av_opt_find(&class, "sws_flags", NULL, 0,
1685 AV_OPT_SEARCH_FAKE_OBJ);
1686 int ret = av_opt_eval_flags(&class, o, e->value, &sws_flags);
1692 is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
1693 vp->width, vp->height, src_frame->format, vp->width, vp->height,
1694 AV_PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
1695 if (!is->img_convert_ctx) {
1696 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1699 sws_scale(is->img_convert_ctx, src_frame->data, src_frame->linesize,
1700 0, vp->height, pict.data, pict.linesize);
1702 /* workaround SDL PITCH_WORKAROUND */
1703 duplicate_right_border_pixels(vp->bmp);
1704 /* update the bitmap content */
1705 SDL_UnlockYUVOverlay(vp->bmp);
1708 vp->duration = duration;
1710 vp->serial = serial;
1712 /* now we can update the picture count */
1713 frame_queue_push(&is->pictq);
1718 static int get_video_frame(VideoState *is, AVFrame *frame)
1722 if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1728 if (frame->pts != AV_NOPTS_VALUE)
1729 dpts = av_q2d(is->video_st->time_base) * frame->pts;
1731 frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1733 is->viddec_width = frame->width;
1734 is->viddec_height = frame->height;
1736 if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
1737 if (frame->pts != AV_NOPTS_VALUE) {
1738 double diff = dpts - get_master_clock(is);
1739 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1740 diff - is->frame_last_filter_delay < 0 &&
1741 is->viddec.pkt_serial == is->vidclk.serial &&
1742 is->videoq.nb_packets) {
1743 is->frame_drops_early++;
1744 av_frame_unref(frame);
1755 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1756 AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1759 int nb_filters = graph->nb_filters;
1760 AVFilterInOut *outputs = NULL, *inputs = NULL;
1763 outputs = avfilter_inout_alloc();
1764 inputs = avfilter_inout_alloc();
1765 if (!outputs || !inputs) {
1766 ret = AVERROR(ENOMEM);
1770 outputs->name = av_strdup("in");
1771 outputs->filter_ctx = source_ctx;
1772 outputs->pad_idx = 0;
1773 outputs->next = NULL;
1775 inputs->name = av_strdup("out");
1776 inputs->filter_ctx = sink_ctx;
1777 inputs->pad_idx = 0;
1778 inputs->next = NULL;
1780 if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1783 if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1787 /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1788 for (i = 0; i < graph->nb_filters - nb_filters; i++)
1789 FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1791 ret = avfilter_graph_config(graph, NULL);
1793 avfilter_inout_free(&outputs);
1794 avfilter_inout_free(&inputs);
1798 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1800 static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
1801 char sws_flags_str[512] = "";
1802 char buffersrc_args[256];
1804 AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1805 AVCodecContext *codec = is->video_st->codec;
1806 AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1807 AVDictionaryEntry *e = NULL;
1809 while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1810 if (!strcmp(e->key, "sws_flags")) {
1811 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1813 av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1815 if (strlen(sws_flags_str))
1816 sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1818 graph->scale_sws_opts = av_strdup(sws_flags_str);
1820 snprintf(buffersrc_args, sizeof(buffersrc_args),
1821 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1822 frame->width, frame->height, frame->format,
1823 is->video_st->time_base.num, is->video_st->time_base.den,
1824 codec->sample_aspect_ratio.num, FFMAX(codec->sample_aspect_ratio.den, 1));
1825 if (fr.num && fr.den)
1826 av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1828 if ((ret = avfilter_graph_create_filter(&filt_src,
1829 avfilter_get_by_name("buffer"),
1830 "ffplay_buffer", buffersrc_args, NULL,
1834 ret = avfilter_graph_create_filter(&filt_out,
1835 avfilter_get_by_name("buffersink"),
1836 "ffplay_buffersink", NULL, NULL, graph);
1840 if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1843 last_filter = filt_out;
1845 /* Note: this macro adds a filter before the lastly added filter, so the
1846 * processing order of the filters is in reverse */
1847 #define INSERT_FILT(name, arg) do { \
1848 AVFilterContext *filt_ctx; \
1850 ret = avfilter_graph_create_filter(&filt_ctx, \
1851 avfilter_get_by_name(name), \
1852 "ffplay_" name, arg, NULL, graph); \
1856 ret = avfilter_link(filt_ctx, 0, last_filter, 0); \
1860 last_filter = filt_ctx; \
1863 /* SDL YUV code is not handling odd width/height for some driver
1864 * combinations, therefore we crop the picture to an even width/height. */
1865 INSERT_FILT("crop", "floor(in_w/2)*2:floor(in_h/2)*2");
1868 double theta = get_rotation(is->video_st);
1870 if (fabs(theta - 90) < 1.0) {
1871 INSERT_FILT("transpose", "clock");
1872 } else if (fabs(theta - 180) < 1.0) {
1873 INSERT_FILT("hflip", NULL);
1874 INSERT_FILT("vflip", NULL);
1875 } else if (fabs(theta - 270) < 1.0) {
1876 INSERT_FILT("transpose", "cclock");
1877 } else if (fabs(theta) > 1.0) {
1878 char rotate_buf[64];
1879 snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1880 INSERT_FILT("rotate", rotate_buf);
1884 if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1887 is->in_video_filter = filt_src;
1888 is->out_video_filter = filt_out;
1894 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1896 static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE };
1897 int sample_rates[2] = { 0, -1 };
1898 int64_t channel_layouts[2] = { 0, -1 };
1899 int channels[2] = { 0, -1 };
1900 AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1901 char aresample_swr_opts[512] = "";
1902 AVDictionaryEntry *e = NULL;
1903 char asrc_args[256];
1906 avfilter_graph_free(&is->agraph);
1907 if (!(is->agraph = avfilter_graph_alloc()))
1908 return AVERROR(ENOMEM);
1910 while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1911 av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1912 if (strlen(aresample_swr_opts))
1913 aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1914 av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1916 ret = snprintf(asrc_args, sizeof(asrc_args),
1917 "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1918 is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1919 is->audio_filter_src.channels,
1920 1, is->audio_filter_src.freq);
1921 if (is->audio_filter_src.channel_layout)
1922 snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1923 ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1925 ret = avfilter_graph_create_filter(&filt_asrc,
1926 avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1927 asrc_args, NULL, is->agraph);
1932 ret = avfilter_graph_create_filter(&filt_asink,
1933 avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1934 NULL, NULL, is->agraph);
1938 if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1940 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
1943 if (force_output_format) {
1944 channel_layouts[0] = is->audio_tgt.channel_layout;
1945 channels [0] = is->audio_tgt.channels;
1946 sample_rates [0] = is->audio_tgt.freq;
1947 if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
1949 if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1951 if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1953 if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
1958 if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
1961 is->in_audio_filter = filt_asrc;
1962 is->out_audio_filter = filt_asink;
1966 avfilter_graph_free(&is->agraph);
1969 #endif /* CONFIG_AVFILTER */
1971 static int audio_thread(void *arg)
1973 VideoState *is = arg;
1974 AVFrame *frame = av_frame_alloc();
1977 int last_serial = -1;
1978 int64_t dec_channel_layout;
1986 return AVERROR(ENOMEM);
1989 if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
1993 tb = (AVRational){1, frame->sample_rate};
1996 dec_channel_layout = get_valid_channel_layout(frame->channel_layout, av_frame_get_channels(frame));
1999 cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2000 frame->format, av_frame_get_channels(frame)) ||
2001 is->audio_filter_src.channel_layout != dec_channel_layout ||
2002 is->audio_filter_src.freq != frame->sample_rate ||
2003 is->auddec.pkt_serial != last_serial;
2006 char buf1[1024], buf2[1024];
2007 av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2008 av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2009 av_log(NULL, AV_LOG_DEBUG,
2010 "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",
2011 is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2012 frame->sample_rate, av_frame_get_channels(frame), av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2014 is->audio_filter_src.fmt = frame->format;
2015 is->audio_filter_src.channels = av_frame_get_channels(frame);
2016 is->audio_filter_src.channel_layout = dec_channel_layout;
2017 is->audio_filter_src.freq = frame->sample_rate;
2018 last_serial = is->auddec.pkt_serial;
2020 if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2024 if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2027 while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2028 tb = is->out_audio_filter->inputs[0]->time_base;
2030 if (!(af = frame_queue_peek_writable(&is->sampq)))
2033 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2034 af->pos = av_frame_get_pkt_pos(frame);
2035 af->serial = is->auddec.pkt_serial;
2036 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2038 av_frame_move_ref(af->frame, frame);
2039 frame_queue_push(&is->sampq);
2042 if (is->audioq.serial != is->auddec.pkt_serial)
2045 if (ret == AVERROR_EOF)
2046 is->auddec.finished = is->auddec.pkt_serial;
2049 } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2052 avfilter_graph_free(&is->agraph);
2054 av_frame_free(&frame);
2058 static void decoder_start(Decoder *d, int (*fn)(void *), void *arg)
2060 packet_queue_start(d->queue);
2061 d->decoder_tid = SDL_CreateThread(fn, arg);
2064 static int video_thread(void *arg)
2066 VideoState *is = arg;
2067 AVFrame *frame = av_frame_alloc();
2071 AVRational tb = is->video_st->time_base;
2072 AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2075 AVFilterGraph *graph = avfilter_graph_alloc();
2076 AVFilterContext *filt_out = NULL, *filt_in = NULL;
2079 enum AVPixelFormat last_format = -2;
2080 int last_serial = -1;
2081 int last_vfilter_idx = 0;
2083 av_frame_free(&frame);
2084 return AVERROR(ENOMEM);
2091 avfilter_graph_free(&graph);
2093 return AVERROR(ENOMEM);
2097 ret = get_video_frame(is, frame);
2104 if ( last_w != frame->width
2105 || last_h != frame->height
2106 || last_format != frame->format
2107 || last_serial != is->viddec.pkt_serial
2108 || last_vfilter_idx != is->vfilter_idx) {
2109 av_log(NULL, AV_LOG_DEBUG,
2110 "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2112 (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2113 frame->width, frame->height,
2114 (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2115 avfilter_graph_free(&graph);
2116 graph = avfilter_graph_alloc();
2117 if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2119 event.type = FF_QUIT_EVENT;
2120 event.user.data1 = is;
2121 SDL_PushEvent(&event);
2124 filt_in = is->in_video_filter;
2125 filt_out = is->out_video_filter;
2126 last_w = frame->width;
2127 last_h = frame->height;
2128 last_format = frame->format;
2129 last_serial = is->viddec.pkt_serial;
2130 last_vfilter_idx = is->vfilter_idx;
2131 frame_rate = filt_out->inputs[0]->frame_rate;
2134 ret = av_buffersrc_add_frame(filt_in, frame);
2139 is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2141 ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2143 if (ret == AVERROR_EOF)
2144 is->viddec.finished = is->viddec.pkt_serial;
2149 is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
2150 if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
2151 is->frame_last_filter_delay = 0;
2152 tb = filt_out->inputs[0]->time_base;
2154 duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2155 pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2156 ret = queue_picture(is, frame, pts, duration, av_frame_get_pkt_pos(frame), is->viddec.pkt_serial);
2157 av_frame_unref(frame);
2167 avfilter_graph_free(&graph);
2169 av_frame_free(&frame);
2173 static int subtitle_thread(void *arg)
2175 VideoState *is = arg;
2182 if (!(sp = frame_queue_peek_writable(&is->subpq)))
2185 if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2190 if (got_subtitle && sp->sub.format == 0) {
2191 if (sp->sub.pts != AV_NOPTS_VALUE)
2192 pts = sp->sub.pts / (double)AV_TIME_BASE;
2194 sp->serial = is->subdec.pkt_serial;
2196 for (i = 0; i < sp->sub.num_rects; i++)
2198 int in_w = sp->sub.rects[i]->w;
2199 int in_h = sp->sub.rects[i]->h;
2200 int subw = is->subdec.avctx->width ? is->subdec.avctx->width : is->viddec_width;
2201 int subh = is->subdec.avctx->height ? is->subdec.avctx->height : is->viddec_height;
2202 int out_w = is->viddec_width ? in_w * is->viddec_width / subw : in_w;
2203 int out_h = is->viddec_height ? in_h * is->viddec_height / subh : in_h;
2206 //can not use avpicture_alloc as it is not compatible with avsubtitle_free()
2207 av_image_fill_linesizes(newpic.linesize, AV_PIX_FMT_YUVA420P, out_w);
2208 newpic.data[0] = av_malloc(newpic.linesize[0] * out_h);
2209 newpic.data[3] = av_malloc(newpic.linesize[3] * out_h);
2210 newpic.data[1] = av_malloc(newpic.linesize[1] * ((out_h+1)/2));
2211 newpic.data[2] = av_malloc(newpic.linesize[2] * ((out_h+1)/2));
2213 is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
2214 in_w, in_h, AV_PIX_FMT_PAL8, out_w, out_h,
2215 AV_PIX_FMT_YUVA420P, sws_flags, NULL, NULL, NULL);
2216 if (!is->sub_convert_ctx || !newpic.data[0] || !newpic.data[3] ||
2217 !newpic.data[1] || !newpic.data[2]
2219 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the sub conversion context\n");
2222 sws_scale(is->sub_convert_ctx,
2223 (void*)sp->sub.rects[i]->pict.data, sp->sub.rects[i]->pict.linesize,
2224 0, in_h, newpic.data, newpic.linesize);
2226 av_free(sp->sub.rects[i]->pict.data[0]);
2227 av_free(sp->sub.rects[i]->pict.data[1]);
2228 sp->sub.rects[i]->pict = newpic;
2229 sp->sub.rects[i]->w = out_w;
2230 sp->sub.rects[i]->h = out_h;
2231 sp->sub.rects[i]->x = sp->sub.rects[i]->x * out_w / in_w;
2232 sp->sub.rects[i]->y = sp->sub.rects[i]->y * out_h / in_h;
2235 /* now we can update the picture count */
2236 frame_queue_push(&is->subpq);
2237 } else if (got_subtitle) {
2238 avsubtitle_free(&sp->sub);
2244 /* copy samples for viewing in editor window */
2245 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2249 size = samples_size / sizeof(short);
2251 len = SAMPLE_ARRAY_SIZE - is->sample_array_index;
2254 memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2256 is->sample_array_index += len;
2257 if (is->sample_array_index >= SAMPLE_ARRAY_SIZE)
2258 is->sample_array_index = 0;
2263 /* return the wanted number of samples to get better sync if sync_type is video
2264 * or external master clock */
2265 static int synchronize_audio(VideoState *is, int nb_samples)
2267 int wanted_nb_samples = nb_samples;
2269 /* if not master, then we try to remove or add samples to correct the clock */
2270 if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
2271 double diff, avg_diff;
2272 int min_nb_samples, max_nb_samples;
2274 diff = get_clock(&is->audclk) - get_master_clock(is);
2276 if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2277 is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2278 if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
2279 /* not enough measures to have a correct estimate */
2280 is->audio_diff_avg_count++;
2282 /* estimate the A-V difference */
2283 avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2285 if (fabs(avg_diff) >= is->audio_diff_threshold) {
2286 wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2287 min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2288 max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2289 wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2291 av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2292 diff, avg_diff, wanted_nb_samples - nb_samples,
2293 is->audio_clock, is->audio_diff_threshold);
2296 /* too big difference : may be initial PTS errors, so
2298 is->audio_diff_avg_count = 0;
2299 is->audio_diff_cum = 0;
2303 return wanted_nb_samples;
2307 * Decode one audio frame and return its uncompressed size.
2309 * The processed audio frame is decoded, converted if required, and
2310 * stored in is->audio_buf, with size in bytes given by the return
2313 static int audio_decode_frame(VideoState *is)
2315 int data_size, resampled_data_size;
2316 int64_t dec_channel_layout;
2317 av_unused double audio_clock0;
2318 int wanted_nb_samples;
2326 while (frame_queue_nb_remaining(&is->sampq) == 0) {
2327 if ((av_gettime_relative() - audio_callback_time) > 1000000LL * is->audio_hw_buf_size / is->audio_tgt.bytes_per_sec / 2)
2332 if (!(af = frame_queue_peek_readable(&is->sampq)))
2334 frame_queue_next(&is->sampq);
2335 } while (af->serial != is->audioq.serial);
2337 data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(af->frame),
2338 af->frame->nb_samples,
2339 af->frame->format, 1);
2341 dec_channel_layout =
2342 (af->frame->channel_layout && av_frame_get_channels(af->frame) == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
2343 af->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(af->frame));
2344 wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2346 if (af->frame->format != is->audio_src.fmt ||
2347 dec_channel_layout != is->audio_src.channel_layout ||
2348 af->frame->sample_rate != is->audio_src.freq ||
2349 (wanted_nb_samples != af->frame->nb_samples && !is->swr_ctx)) {
2350 swr_free(&is->swr_ctx);
2351 is->swr_ctx = swr_alloc_set_opts(NULL,
2352 is->audio_tgt.channel_layout, is->audio_tgt.fmt, is->audio_tgt.freq,
2353 dec_channel_layout, af->frame->format, af->frame->sample_rate,
2355 if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2356 av_log(NULL, AV_LOG_ERROR,
2357 "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2358 af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), av_frame_get_channels(af->frame),
2359 is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
2360 swr_free(&is->swr_ctx);
2363 is->audio_src.channel_layout = dec_channel_layout;
2364 is->audio_src.channels = av_frame_get_channels(af->frame);
2365 is->audio_src.freq = af->frame->sample_rate;
2366 is->audio_src.fmt = af->frame->format;
2370 const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2371 uint8_t **out = &is->audio_buf1;
2372 int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2373 int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2376 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2379 if (wanted_nb_samples != af->frame->nb_samples) {
2380 if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2381 wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2382 av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2386 av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2387 if (!is->audio_buf1)
2388 return AVERROR(ENOMEM);
2389 len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2391 av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2394 if (len2 == out_count) {
2395 av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2396 if (swr_init(is->swr_ctx) < 0)
2397 swr_free(&is->swr_ctx);
2399 is->audio_buf = is->audio_buf1;
2400 resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2402 is->audio_buf = af->frame->data[0];
2403 resampled_data_size = data_size;
2406 audio_clock0 = is->audio_clock;
2407 /* update the audio clock with the pts */
2408 if (!isnan(af->pts))
2409 is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2411 is->audio_clock = NAN;
2412 is->audio_clock_serial = af->serial;
2415 static double last_clock;
2416 printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2417 is->audio_clock - last_clock,
2418 is->audio_clock, audio_clock0);
2419 last_clock = is->audio_clock;
2422 return resampled_data_size;
2425 /* prepare a new audio buffer */
2426 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2428 VideoState *is = opaque;
2429 int audio_size, len1;
2431 audio_callback_time = av_gettime_relative();
2434 if (is->audio_buf_index >= is->audio_buf_size) {
2435 audio_size = audio_decode_frame(is);
2436 if (audio_size < 0) {
2437 /* if error, just output silence */
2438 is->audio_buf = is->silence_buf;
2439 is->audio_buf_size = sizeof(is->silence_buf) / is->audio_tgt.frame_size * is->audio_tgt.frame_size;
2441 if (is->show_mode != SHOW_MODE_VIDEO)
2442 update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2443 is->audio_buf_size = audio_size;
2445 is->audio_buf_index = 0;
2447 len1 = is->audio_buf_size - is->audio_buf_index;
2450 memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2453 is->audio_buf_index += len1;
2455 is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
2456 /* Let's assume the audio driver that is used by SDL has two periods. */
2457 if (!isnan(is->audio_clock)) {
2458 set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / is->audio_tgt.bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
2459 sync_clock_to_slave(&is->extclk, &is->audclk);
2463 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2465 SDL_AudioSpec wanted_spec, spec;
2467 static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2468 static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2469 int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2471 env = SDL_getenv("SDL_AUDIO_CHANNELS");
2473 wanted_nb_channels = atoi(env);
2474 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2476 if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2477 wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2478 wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2480 wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2481 wanted_spec.channels = wanted_nb_channels;
2482 wanted_spec.freq = wanted_sample_rate;
2483 if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2484 av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2487 while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2488 next_sample_rate_idx--;
2489 wanted_spec.format = AUDIO_S16SYS;
2490 wanted_spec.silence = 0;
2491 wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2492 wanted_spec.callback = sdl_audio_callback;
2493 wanted_spec.userdata = opaque;
2494 while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
2495 av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2496 wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2497 wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2498 if (!wanted_spec.channels) {
2499 wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2500 wanted_spec.channels = wanted_nb_channels;
2501 if (!wanted_spec.freq) {
2502 av_log(NULL, AV_LOG_ERROR,
2503 "No more combinations to try, audio open failed\n");
2507 wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2509 if (spec.format != AUDIO_S16SYS) {
2510 av_log(NULL, AV_LOG_ERROR,
2511 "SDL advised audio format %d is not supported!\n", spec.format);
2514 if (spec.channels != wanted_spec.channels) {
2515 wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2516 if (!wanted_channel_layout) {
2517 av_log(NULL, AV_LOG_ERROR,
2518 "SDL advised channel count %d is not supported!\n", spec.channels);
2523 audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2524 audio_hw_params->freq = spec.freq;
2525 audio_hw_params->channel_layout = wanted_channel_layout;
2526 audio_hw_params->channels = spec.channels;
2527 audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2528 audio_hw_params->bytes_per_sec = av_samples_get_buffer_size(NULL, audio_hw_params->channels, audio_hw_params->freq, audio_hw_params->fmt, 1);
2529 if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2530 av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2536 /* open a given stream. Return 0 if OK */
2537 static int stream_component_open(VideoState *is, int stream_index)
2539 AVFormatContext *ic = is->ic;
2540 AVCodecContext *avctx;
2542 const char *forced_codec_name = NULL;
2544 AVDictionaryEntry *t = NULL;
2545 int sample_rate, nb_channels;
2546 int64_t channel_layout;
2548 int stream_lowres = lowres;
2550 if (stream_index < 0 || stream_index >= ic->nb_streams)
2552 avctx = ic->streams[stream_index]->codec;
2554 codec = avcodec_find_decoder(avctx->codec_id);
2556 switch(avctx->codec_type){
2557 case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
2558 case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2559 case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
2561 if (forced_codec_name)
2562 codec = avcodec_find_decoder_by_name(forced_codec_name);
2564 if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2565 "No codec could be found with name '%s'\n", forced_codec_name);
2566 else av_log(NULL, AV_LOG_WARNING,
2567 "No codec could be found with id %d\n", avctx->codec_id);
2571 avctx->codec_id = codec->id;
2572 if(stream_lowres > av_codec_get_max_lowres(codec)){
2573 av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2574 av_codec_get_max_lowres(codec));
2575 stream_lowres = av_codec_get_max_lowres(codec);
2577 av_codec_set_lowres(avctx, stream_lowres);
2580 if(stream_lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
2583 avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2585 if(codec->capabilities & AV_CODEC_CAP_DR1)
2586 avctx->flags |= CODEC_FLAG_EMU_EDGE;
2589 opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2590 if (!av_dict_get(opts, "threads", NULL, 0))
2591 av_dict_set(&opts, "threads", "auto", 0);
2593 av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2594 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2595 av_dict_set(&opts, "refcounted_frames", "1", 0);
2596 if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2599 if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2600 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2601 ret = AVERROR_OPTION_NOT_FOUND;
2606 ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2607 switch (avctx->codec_type) {
2608 case AVMEDIA_TYPE_AUDIO:
2613 is->audio_filter_src.freq = avctx->sample_rate;
2614 is->audio_filter_src.channels = avctx->channels;
2615 is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2616 is->audio_filter_src.fmt = avctx->sample_fmt;
2617 if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2619 link = is->out_audio_filter->inputs[0];
2620 sample_rate = link->sample_rate;
2621 nb_channels = link->channels;
2622 channel_layout = link->channel_layout;
2625 sample_rate = avctx->sample_rate;
2626 nb_channels = avctx->channels;
2627 channel_layout = avctx->channel_layout;
2630 /* prepare audio output */
2631 if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2633 is->audio_hw_buf_size = ret;
2634 is->audio_src = is->audio_tgt;
2635 is->audio_buf_size = 0;
2636 is->audio_buf_index = 0;
2638 /* init averaging filter */
2639 is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2640 is->audio_diff_avg_count = 0;
2641 /* since we do not have a precise anough audio fifo fullness,
2642 we correct audio sync only if larger than this threshold */
2643 is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
2645 is->audio_stream = stream_index;
2646 is->audio_st = ic->streams[stream_index];
2648 decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread);
2649 if ((is->ic->iformat->flags & (AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK)) && !is->ic->iformat->read_seek) {
2650 is->auddec.start_pts = is->audio_st->start_time;
2651 is->auddec.start_pts_tb = is->audio_st->time_base;
2653 decoder_start(&is->auddec, audio_thread, is);
2656 case AVMEDIA_TYPE_VIDEO:
2657 is->video_stream = stream_index;
2658 is->video_st = ic->streams[stream_index];
2660 is->viddec_width = avctx->width;
2661 is->viddec_height = avctx->height;
2663 decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread);
2664 decoder_start(&is->viddec, video_thread, is);
2665 is->queue_attachments_req = 1;
2667 case AVMEDIA_TYPE_SUBTITLE:
2668 is->subtitle_stream = stream_index;
2669 is->subtitle_st = ic->streams[stream_index];
2671 decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread);
2672 decoder_start(&is->subdec, subtitle_thread, is);
2679 av_dict_free(&opts);
2684 static void stream_component_close(VideoState *is, int stream_index)
2686 AVFormatContext *ic = is->ic;
2687 AVCodecContext *avctx;
2689 if (stream_index < 0 || stream_index >= ic->nb_streams)
2691 avctx = ic->streams[stream_index]->codec;
2693 switch (avctx->codec_type) {
2694 case AVMEDIA_TYPE_AUDIO:
2695 decoder_abort(&is->auddec, &is->sampq);
2697 decoder_destroy(&is->auddec);
2698 swr_free(&is->swr_ctx);
2699 av_freep(&is->audio_buf1);
2700 is->audio_buf1_size = 0;
2701 is->audio_buf = NULL;
2704 av_rdft_end(is->rdft);
2705 av_freep(&is->rdft_data);
2710 case AVMEDIA_TYPE_VIDEO:
2711 decoder_abort(&is->viddec, &is->pictq);
2712 decoder_destroy(&is->viddec);
2714 case AVMEDIA_TYPE_SUBTITLE:
2715 decoder_abort(&is->subdec, &is->subpq);
2716 decoder_destroy(&is->subdec);
2722 ic->streams[stream_index]->discard = AVDISCARD_ALL;
2723 avcodec_close(avctx);
2724 switch (avctx->codec_type) {
2725 case AVMEDIA_TYPE_AUDIO:
2726 is->audio_st = NULL;
2727 is->audio_stream = -1;
2729 case AVMEDIA_TYPE_VIDEO:
2730 is->video_st = NULL;
2731 is->video_stream = -1;
2733 case AVMEDIA_TYPE_SUBTITLE:
2734 is->subtitle_st = NULL;
2735 is->subtitle_stream = -1;
2742 static int decode_interrupt_cb(void *ctx)
2744 VideoState *is = ctx;
2745 return is->abort_request;
2748 static int is_realtime(AVFormatContext *s)
2750 if( !strcmp(s->iformat->name, "rtp")
2751 || !strcmp(s->iformat->name, "rtsp")
2752 || !strcmp(s->iformat->name, "sdp")
2756 if(s->pb && ( !strncmp(s->filename, "rtp:", 4)
2757 || !strncmp(s->filename, "udp:", 4)
2764 /* this thread gets the stream from the disk or the network */
2765 static int read_thread(void *arg)
2767 VideoState *is = arg;
2768 AVFormatContext *ic = NULL;
2770 int st_index[AVMEDIA_TYPE_NB];
2771 AVPacket pkt1, *pkt = &pkt1;
2772 int64_t stream_start_time;
2773 int pkt_in_play_range = 0;
2774 AVDictionaryEntry *t;
2775 AVDictionary **opts;
2776 int orig_nb_streams;
2777 SDL_mutex *wait_mutex = SDL_CreateMutex();
2778 int scan_all_pmts_set = 0;
2781 memset(st_index, -1, sizeof(st_index));
2782 is->last_video_stream = is->video_stream = -1;
2783 is->last_audio_stream = is->audio_stream = -1;
2784 is->last_subtitle_stream = is->subtitle_stream = -1;
2787 ic = avformat_alloc_context();
2789 av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2790 ret = AVERROR(ENOMEM);
2793 ic->interrupt_callback.callback = decode_interrupt_cb;
2794 ic->interrupt_callback.opaque = is;
2795 if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2796 av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2797 scan_all_pmts_set = 1;
2799 err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2801 print_error(is->filename, err);
2805 if (scan_all_pmts_set)
2806 av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2808 if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2809 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2810 ret = AVERROR_OPTION_NOT_FOUND;
2816 ic->flags |= AVFMT_FLAG_GENPTS;
2818 av_format_inject_global_side_data(ic);
2820 opts = setup_find_stream_info_opts(ic, codec_opts);
2821 orig_nb_streams = ic->nb_streams;
2823 err = avformat_find_stream_info(ic, opts);
2825 for (i = 0; i < orig_nb_streams; i++)
2826 av_dict_free(&opts[i]);
2830 av_log(NULL, AV_LOG_WARNING,
2831 "%s: could not find codec parameters\n", is->filename);
2837 ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2839 if (seek_by_bytes < 0)
2840 seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2842 is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2844 if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2845 window_title = av_asprintf("%s - %s", t->value, input_filename);
2847 /* if seeking requested, we execute it */
2848 if (start_time != AV_NOPTS_VALUE) {
2851 timestamp = start_time;
2852 /* add the stream start time */
2853 if (ic->start_time != AV_NOPTS_VALUE)
2854 timestamp += ic->start_time;
2855 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2857 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2858 is->filename, (double)timestamp / AV_TIME_BASE);
2862 is->realtime = is_realtime(ic);
2865 av_dump_format(ic, 0, is->filename, 0);
2867 for (i = 0; i < ic->nb_streams; i++) {
2868 AVStream *st = ic->streams[i];
2869 enum AVMediaType type = st->codec->codec_type;
2870 st->discard = AVDISCARD_ALL;
2871 if (wanted_stream_spec[type] && st_index[type] == -1)
2872 if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2875 for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2876 if (wanted_stream_spec[i] && st_index[i] == -1) {
2877 av_log(NULL, AV_LOG_ERROR, "Stream specifier %s does not match any %s stream\n", wanted_stream_spec[i], av_get_media_type_string(i));
2878 st_index[i] = INT_MAX;
2883 st_index[AVMEDIA_TYPE_VIDEO] =
2884 av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO,
2885 st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2887 st_index[AVMEDIA_TYPE_AUDIO] =
2888 av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO,
2889 st_index[AVMEDIA_TYPE_AUDIO],
2890 st_index[AVMEDIA_TYPE_VIDEO],
2892 if (!video_disable && !subtitle_disable)
2893 st_index[AVMEDIA_TYPE_SUBTITLE] =
2894 av_find_best_stream(ic, AVMEDIA_TYPE_SUBTITLE,
2895 st_index[AVMEDIA_TYPE_SUBTITLE],
2896 (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2897 st_index[AVMEDIA_TYPE_AUDIO] :
2898 st_index[AVMEDIA_TYPE_VIDEO]),
2901 is->show_mode = show_mode;
2902 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2903 AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2904 AVCodecContext *avctx = st->codec;
2905 AVRational sar = av_guess_sample_aspect_ratio(ic, st, NULL);
2907 set_default_window_size(avctx->width, avctx->height, sar);
2910 /* open the streams */
2911 if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2912 stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2916 if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2917 ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2919 if (is->show_mode == SHOW_MODE_NONE)
2920 is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2922 if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2923 stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2926 if (is->video_stream < 0 && is->audio_stream < 0) {
2927 av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2933 if (infinite_buffer < 0 && is->realtime)
2934 infinite_buffer = 1;
2937 if (is->abort_request)
2939 if (is->paused != is->last_paused) {
2940 is->last_paused = is->paused;
2942 is->read_pause_return = av_read_pause(ic);
2946 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2948 (!strcmp(ic->iformat->name, "rtsp") ||
2949 (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2950 /* wait 10 ms to avoid trying to get another packet */
2957 int64_t seek_target = is->seek_pos;
2958 int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2959 int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2960 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2961 // of the seek_pos/seek_rel variables
2963 ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2965 av_log(NULL, AV_LOG_ERROR,
2966 "%s: error while seeking\n", is->ic->filename);
2968 if (is->audio_stream >= 0) {
2969 packet_queue_flush(&is->audioq);
2970 packet_queue_put(&is->audioq, &flush_pkt);
2972 if (is->subtitle_stream >= 0) {
2973 packet_queue_flush(&is->subtitleq);
2974 packet_queue_put(&is->subtitleq, &flush_pkt);
2976 if (is->video_stream >= 0) {
2977 packet_queue_flush(&is->videoq);
2978 packet_queue_put(&is->videoq, &flush_pkt);
2980 if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2981 set_clock(&is->extclk, NAN, 0);
2983 set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2987 is->queue_attachments_req = 1;
2990 step_to_next_frame(is);
2992 if (is->queue_attachments_req) {
2993 if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
2995 if ((ret = av_copy_packet(©, &is->video_st->attached_pic)) < 0)
2997 packet_queue_put(&is->videoq, ©);
2998 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
3000 is->queue_attachments_req = 0;
3003 /* if the queue are full, no need to read more */
3004 if (infinite_buffer<1 &&
3005 (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
3006 || ( (is->audioq .nb_packets > MIN_FRAMES || is->audio_stream < 0 || is->audioq.abort_request)
3007 && (is->videoq .nb_packets > MIN_FRAMES || is->video_stream < 0 || is->videoq.abort_request
3008 || (is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3009 && (is->subtitleq.nb_packets > MIN_FRAMES || is->subtitle_stream < 0 || is->subtitleq.abort_request)))) {
3011 SDL_LockMutex(wait_mutex);
3012 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3013 SDL_UnlockMutex(wait_mutex);
3017 (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3018 (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3019 if (loop != 1 && (!loop || --loop)) {
3020 stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3021 } else if (autoexit) {
3026 ret = av_read_frame(ic, pkt);
3028 if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3029 if (is->video_stream >= 0)
3030 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
3031 if (is->audio_stream >= 0)
3032 packet_queue_put_nullpacket(&is->audioq, is->audio_stream);
3033 if (is->subtitle_stream >= 0)
3034 packet_queue_put_nullpacket(&is->subtitleq, is->subtitle_stream);
3037 if (ic->pb && ic->pb->error)
3039 SDL_LockMutex(wait_mutex);
3040 SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3041 SDL_UnlockMutex(wait_mutex);
3046 /* check if packet is in play range specified by user, then queue, otherwise discard */
3047 stream_start_time = ic->streams[pkt->stream_index]->start_time;
3048 pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3049 pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3050 (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3051 av_q2d(ic->streams[pkt->stream_index]->time_base) -
3052 (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3053 <= ((double)duration / 1000000);
3054 if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3055 packet_queue_put(&is->audioq, pkt);
3056 } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3057 && !(is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
3058 packet_queue_put(&is->videoq, pkt);
3059 } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3060 packet_queue_put(&is->subtitleq, pkt);
3062 av_free_packet(pkt);
3065 /* wait until the end */
3066 while (!is->abort_request) {
3072 /* close each stream */
3073 if (is->audio_stream >= 0)
3074 stream_component_close(is, is->audio_stream);
3075 if (is->video_stream >= 0)
3076 stream_component_close(is, is->video_stream);
3077 if (is->subtitle_stream >= 0)
3078 stream_component_close(is, is->subtitle_stream);
3080 avformat_close_input(&ic);
3087 event.type = FF_QUIT_EVENT;
3088 event.user.data1 = is;
3089 SDL_PushEvent(&event);
3091 SDL_DestroyMutex(wait_mutex);
3095 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3099 is = av_mallocz(sizeof(VideoState));
3102 av_strlcpy(is->filename, filename, sizeof(is->filename));
3103 is->iformat = iformat;
3107 /* start video display */
3108 if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3110 if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3112 if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3115 packet_queue_init(&is->videoq);
3116 packet_queue_init(&is->audioq);
3117 packet_queue_init(&is->subtitleq);
3119 is->continue_read_thread = SDL_CreateCond();
3121 init_clock(&is->vidclk, &is->videoq.serial);
3122 init_clock(&is->audclk, &is->audioq.serial);
3123 init_clock(&is->extclk, &is->extclk.serial);
3124 is->audio_clock_serial = -1;
3125 is->av_sync_type = av_sync_type;
3126 is->read_tid = SDL_CreateThread(read_thread, is);
3127 if (!is->read_tid) {
3135 static void stream_cycle_channel(VideoState *is, int codec_type)
3137 AVFormatContext *ic = is->ic;
3138 int start_index, stream_index;
3141 AVProgram *p = NULL;
3142 int nb_streams = is->ic->nb_streams;
3144 if (codec_type == AVMEDIA_TYPE_VIDEO) {
3145 start_index = is->last_video_stream;
3146 old_index = is->video_stream;
3147 } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3148 start_index = is->last_audio_stream;
3149 old_index = is->audio_stream;
3151 start_index = is->last_subtitle_stream;
3152 old_index = is->subtitle_stream;
3154 stream_index = start_index;
3156 if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3157 p = av_find_program_from_stream(ic, NULL, is->video_stream);
3159 nb_streams = p->nb_stream_indexes;
3160 for (start_index = 0; start_index < nb_streams; start_index++)
3161 if (p->stream_index[start_index] == stream_index)
3163 if (start_index == nb_streams)
3165 stream_index = start_index;
3170 if (++stream_index >= nb_streams)
3172 if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3175 is->last_subtitle_stream = -1;
3178 if (start_index == -1)
3182 if (stream_index == start_index)
3184 st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3185 if (st->codec->codec_type == codec_type) {
3186 /* check that parameters are OK */
3187 switch (codec_type) {
3188 case AVMEDIA_TYPE_AUDIO:
3189 if (st->codec->sample_rate != 0 &&
3190 st->codec->channels != 0)
3193 case AVMEDIA_TYPE_VIDEO:
3194 case AVMEDIA_TYPE_SUBTITLE:
3202 if (p && stream_index != -1)
3203 stream_index = p->stream_index[stream_index];
3204 av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3205 av_get_media_type_string(codec_type),
3209 stream_component_close(is, old_index);
3210 stream_component_open(is, stream_index);
3214 static void toggle_full_screen(VideoState *is)
3216 #if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
3217 /* OS X needs to reallocate the SDL overlays */
3219 for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
3220 is->pictq.queue[i].reallocate = 1;
3222 is_full_screen = !is_full_screen;
3223 video_open(is, 1, NULL);
3226 static void toggle_audio_display(VideoState *is)
3228 int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
3229 int next = is->show_mode;
3231 next = (next + 1) % SHOW_MODE_NB;
3232 } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3233 if (is->show_mode != next) {
3234 fill_rectangle(screen,
3235 is->xleft, is->ytop, is->width, is->height,
3237 is->force_refresh = 1;
3238 is->show_mode = next;
3242 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3243 double remaining_time = 0.0;
3245 while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
3246 if (!cursor_hidden && av_gettime_relative() - cursor_last_shown > CURSOR_HIDE_DELAY) {
3250 if (remaining_time > 0.0)
3251 av_usleep((int64_t)(remaining_time * 1000000.0));
3252 remaining_time = REFRESH_RATE;
3253 if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3254 video_refresh(is, &remaining_time);
3259 static void seek_chapter(VideoState *is, int incr)
3261 int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3264 if (!is->ic->nb_chapters)
3267 /* find the current chapter */
3268 for (i = 0; i < is->ic->nb_chapters; i++) {
3269 AVChapter *ch = is->ic->chapters[i];
3270 if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3278 if (i >= is->ic->nb_chapters)
3281 av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3282 stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3283 AV_TIME_BASE_Q), 0, 0);
3286 /* handle an event sent by the GUI */
3287 static void event_loop(VideoState *cur_stream)
3290 double incr, pos, frac;
3294 refresh_loop_wait_event(cur_stream, &event);
3295 switch (event.type) {
3297 if (exit_on_keydown) {
3298 do_exit(cur_stream);
3301 switch (event.key.keysym.sym) {
3304 do_exit(cur_stream);
3307 toggle_full_screen(cur_stream);
3308 cur_stream->force_refresh = 1;
3312 toggle_pause(cur_stream);
3314 case SDLK_s: // S: Step to next frame
3315 step_to_next_frame(cur_stream);
3318 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3321 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3324 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_VIDEO);
3325 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_AUDIO);
3326 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3329 stream_cycle_channel(cur_stream, AVMEDIA_TYPE_SUBTITLE);
3333 if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3334 if (++cur_stream->vfilter_idx >= nb_vfilters)
3335 cur_stream->vfilter_idx = 0;
3337 cur_stream->vfilter_idx = 0;
3338 toggle_audio_display(cur_stream);
3341 toggle_audio_display(cur_stream);
3345 if (cur_stream->ic->nb_chapters <= 1) {
3349 seek_chapter(cur_stream, 1);
3352 if (cur_stream->ic->nb_chapters <= 1) {
3356 seek_chapter(cur_stream, -1);
3370 if (seek_by_bytes) {
3372 if (pos < 0 && cur_stream->video_stream >= 0)
3373 pos = frame_queue_last_pos(&cur_stream->pictq);
3374 if (pos < 0 && cur_stream->audio_stream >= 0)
3375 pos = frame_queue_last_pos(&cur_stream->sampq);
3377 pos = avio_tell(cur_stream->ic->pb);
3378 if (cur_stream->ic->bit_rate)
3379 incr *= cur_stream->ic->bit_rate / 8.0;
3383 stream_seek(cur_stream, pos, incr, 1);
3385 pos = get_master_clock(cur_stream);
3387 pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3389 if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3390 pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3391 stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3398 case SDL_VIDEOEXPOSE:
3399 cur_stream->force_refresh = 1;
3401 case SDL_MOUSEBUTTONDOWN:
3402 if (exit_on_mousedown) {
3403 do_exit(cur_stream);
3406 case SDL_MOUSEMOTION:
3407 if (cursor_hidden) {
3411 cursor_last_shown = av_gettime_relative();
3412 if (event.type == SDL_MOUSEBUTTONDOWN) {
3415 if (event.motion.state != SDL_PRESSED)
3419 if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3420 uint64_t size = avio_size(cur_stream->ic->pb);
3421 stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3425 int tns, thh, tmm, tss;
3426 tns = cur_stream->ic->duration / 1000000LL;
3428 tmm = (tns % 3600) / 60;
3430 frac = x / cur_stream->width;
3433 mm = (ns % 3600) / 60;
3435 av_log(NULL, AV_LOG_INFO,
3436 "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3437 hh, mm, ss, thh, tmm, tss);
3438 ts = frac * cur_stream->ic->duration;
3439 if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3440 ts += cur_stream->ic->start_time;
3441 stream_seek(cur_stream, ts, 0, 0);
3444 case SDL_VIDEORESIZE:
3445 screen = SDL_SetVideoMode(FFMIN(16383, event.resize.w), event.resize.h, 0,
3446 SDL_HWSURFACE|(is_full_screen?SDL_FULLSCREEN:SDL_RESIZABLE)|SDL_ASYNCBLIT|SDL_HWACCEL);
3448 av_log(NULL, AV_LOG_FATAL, "Failed to set video mode\n");
3449 do_exit(cur_stream);
3451 screen_width = cur_stream->width = screen->w;
3452 screen_height = cur_stream->height = screen->h;
3453 cur_stream->force_refresh = 1;
3457 do_exit(cur_stream);
3459 case FF_ALLOC_EVENT:
3460 alloc_picture(event.user.data1);
3468 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3470 av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3471 return opt_default(NULL, "video_size", arg);
3474 static int opt_width(void *optctx, const char *opt, const char *arg)
3476 screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3480 static int opt_height(void *optctx, const char *opt, const char *arg)
3482 screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3486 static int opt_format(void *optctx, const char *opt, const char *arg)
3488 file_iformat = av_find_input_format(arg);
3489 if (!file_iformat) {
3490 av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3491 return AVERROR(EINVAL);
3496 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3498 av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3499 return opt_default(NULL, "pixel_format", arg);
3502 static int opt_sync(void *optctx, const char *opt, const char *arg)
3504 if (!strcmp(arg, "audio"))
3505 av_sync_type = AV_SYNC_AUDIO_MASTER;
3506 else if (!strcmp(arg, "video"))
3507 av_sync_type = AV_SYNC_VIDEO_MASTER;
3508 else if (!strcmp(arg, "ext"))
3509 av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
3511 av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3517 static int opt_seek(void *optctx, const char *opt, const char *arg)
3519 start_time = parse_time_or_die(opt, arg, 1);
3523 static int opt_duration(void *optctx, const char *opt, const char *arg)
3525 duration = parse_time_or_die(opt, arg, 1);
3529 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3531 show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3532 !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3533 !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
3534 parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3538 static void opt_input_file(void *optctx, const char *filename)
3540 if (input_filename) {
3541 av_log(NULL, AV_LOG_FATAL,
3542 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3543 filename, input_filename);
3546 if (!strcmp(filename, "-"))
3548 input_filename = filename;
3551 static int opt_codec(void *optctx, const char *opt, const char *arg)
3553 const char *spec = strchr(opt, ':');
3555 av_log(NULL, AV_LOG_ERROR,
3556 "No media specifier was specified in '%s' in option '%s'\n",
3558 return AVERROR(EINVAL);
3562 case 'a' : audio_codec_name = arg; break;
3563 case 's' : subtitle_codec_name = arg; break;
3564 case 'v' : video_codec_name = arg; break;
3566 av_log(NULL, AV_LOG_ERROR,
3567 "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3568 return AVERROR(EINVAL);
3575 static const OptionDef options[] = {
3576 #include "cmdutils_common_opts.h"
3577 { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3578 { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3579 { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3580 { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3581 { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3582 { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3583 { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3584 { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3585 { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3586 { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3587 { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3588 { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
3589 { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3590 { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3591 { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3592 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3593 { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3594 { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3595 { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3596 { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3597 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3598 { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3599 { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3600 { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3601 { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3602 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3603 { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3604 { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3605 { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3607 { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3608 { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3610 { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3611 { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3612 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3613 { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3614 { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3615 { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
3616 { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3617 { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
3618 { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3622 static void show_usage(void)
3624 av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3625 av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3626 av_log(NULL, AV_LOG_INFO, "\n");
3629 void show_help_default(const char *opt, const char *arg)
3631 av_log_set_callback(log_callback_help);
3633 show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3634 show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3636 show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3637 show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
3638 #if !CONFIG_AVFILTER
3639 show_help_children(sws_get_class(), AV_OPT_FLAG_ENCODING_PARAM);
3641 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
3643 printf("\nWhile playing:\n"
3645 "f toggle full screen\n"
3647 "a cycle audio channel in the current program\n"
3648 "v cycle video channel\n"
3649 "t cycle subtitle channel in the current program\n"
3651 "w cycle video filters or show modes\n"
3652 "s activate frame-step mode\n"
3653 "left/right seek backward/forward 10 seconds\n"
3654 "down/up seek backward/forward 1 minute\n"
3655 "page down/page up seek backward/forward 10 minutes\n"
3656 "mouse click seek to percentage in file corresponding to fraction of width\n"
3660 static int lockmgr(void **mtx, enum AVLockOp op)
3663 case AV_LOCK_CREATE:
3664 *mtx = SDL_CreateMutex();
3668 case AV_LOCK_OBTAIN:
3669 return !!SDL_LockMutex(*mtx);
3670 case AV_LOCK_RELEASE:
3671 return !!SDL_UnlockMutex(*mtx);
3672 case AV_LOCK_DESTROY:
3673 SDL_DestroyMutex(*mtx);
3679 /* Called from the main */
3680 int main(int argc, char **argv)
3684 char dummy_videodriver[] = "SDL_VIDEODRIVER=dummy";
3686 av_log_set_flags(AV_LOG_SKIP_REPEATED);
3687 parse_loglevel(argc, argv, options);
3689 /* register all codecs, demux and protocols */
3691 avdevice_register_all();
3694 avfilter_register_all();
3697 avformat_network_init();
3701 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
3702 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
3704 show_banner(argc, argv, options);
3706 parse_options(NULL, argc, argv, options, opt_input_file);
3708 if (!input_filename) {
3710 av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3711 av_log(NULL, AV_LOG_FATAL,
3712 "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3716 if (display_disable) {
3719 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3721 flags &= ~SDL_INIT_AUDIO;
3722 if (display_disable)
3723 SDL_putenv(dummy_videodriver); /* For the event queue, we always need a video driver. */
3724 #if !defined(_WIN32) && !defined(__APPLE__)
3725 flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
3727 if (SDL_Init (flags)) {
3728 av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3729 av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3733 if (!display_disable) {
3734 const SDL_VideoInfo *vi = SDL_GetVideoInfo();
3735 fs_screen_width = vi->current_w;
3736 fs_screen_height = vi->current_h;
3739 SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
3740 SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3741 SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3743 if (av_lockmgr_register(lockmgr)) {
3744 av_log(NULL, AV_LOG_FATAL, "Could not initialize lock manager!\n");
3748 av_init_packet(&flush_pkt);
3749 flush_pkt.data = (uint8_t *)&flush_pkt;
3751 is = stream_open(input_filename, file_iformat);
3753 av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");