FFmpeg
ffplay.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 Fabrice Bellard
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * simple media player based on the FFmpeg libraries
24  */
25 
26 #include "config.h"
27 #include <inttypes.h>
28 #include <math.h>
29 #include <limits.h>
30 #include <signal.h>
31 #include <stdint.h>
32 
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/fifo.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/avassert.h"
43 #include "libavutil/time.h"
44 #include "libavutil/bprint.h"
45 #include "libavformat/avformat.h"
46 #include "libavdevice/avdevice.h"
47 #include "libswscale/swscale.h"
48 #include "libavutil/opt.h"
49 #include "libavcodec/avfft.h"
51 
52 #if CONFIG_AVFILTER
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/buffersink.h"
55 # include "libavfilter/buffersrc.h"
56 #endif
57 
58 #include <SDL.h>
59 #include <SDL_thread.h>
60 
61 #include "cmdutils.h"
62 
63 #include <assert.h>
64 
65 const char program_name[] = "ffplay";
66 const int program_birth_year = 2003;
67 
68 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
69 #define MIN_FRAMES 25
70 #define EXTERNAL_CLOCK_MIN_FRAMES 2
71 #define EXTERNAL_CLOCK_MAX_FRAMES 10
72 
73 /* Minimum SDL audio buffer size, in samples. */
74 #define SDL_AUDIO_MIN_BUFFER_SIZE 512
75 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
76 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
77 
78 /* Step size for volume control in dB */
79 #define SDL_VOLUME_STEP (0.75)
80 
81 /* no AV sync correction is done if below the minimum AV sync threshold */
82 #define AV_SYNC_THRESHOLD_MIN 0.04
83 /* AV sync correction is done if above the maximum AV sync threshold */
84 #define AV_SYNC_THRESHOLD_MAX 0.1
85 /* If a frame duration is longer than this, it will not be duplicated to compensate AV sync */
86 #define AV_SYNC_FRAMEDUP_THRESHOLD 0.1
87 /* no AV correction is done if too big error */
88 #define AV_NOSYNC_THRESHOLD 10.0
89 
90 /* maximum audio speed change to get correct sync */
91 #define SAMPLE_CORRECTION_PERCENT_MAX 10
92 
93 /* external clock speed adjustment constants for realtime sources based on buffer fullness */
94 #define EXTERNAL_CLOCK_SPEED_MIN 0.900
95 #define EXTERNAL_CLOCK_SPEED_MAX 1.010
96 #define EXTERNAL_CLOCK_SPEED_STEP 0.001
97 
98 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
99 #define AUDIO_DIFF_AVG_NB 20
100 
101 /* polls for possible required screen refresh at least this often, should be less than 1/fps */
102 #define REFRESH_RATE 0.01
103 
104 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
105 /* TODO: We assume that a decoded and resampled frame fits into this buffer */
106 #define SAMPLE_ARRAY_SIZE (8 * 65536)
107 
108 #define CURSOR_HIDE_DELAY 1000000
109 
110 #define USE_ONEPASS_SUBTITLE_RENDER 1
111 
112 static unsigned sws_flags = SWS_BICUBIC;
113 
114 typedef struct MyAVPacketList {
116  int serial;
118 
119 typedef struct PacketQueue {
122  int size;
123  int64_t duration;
125  int serial;
126  SDL_mutex *mutex;
127  SDL_cond *cond;
128 } PacketQueue;
129 
130 #define VIDEO_PICTURE_QUEUE_SIZE 3
131 #define SUBPICTURE_QUEUE_SIZE 16
132 #define SAMPLE_QUEUE_SIZE 9
133 #define FRAME_QUEUE_SIZE FFMAX(SAMPLE_QUEUE_SIZE, FFMAX(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE))
134 
135 typedef struct AudioParams {
136  int freq;
137  int channels;
138  int64_t channel_layout;
139  enum AVSampleFormat fmt;
142 } AudioParams;
143 
144 typedef struct Clock {
145  double pts; /* clock base */
146  double pts_drift; /* clock base minus time at which we updated the clock */
147  double last_updated;
148  double speed;
149  int serial; /* clock is based on a packet with this serial */
150  int paused;
151  int *queue_serial; /* pointer to the current packet queue serial, used for obsolete clock detection */
152 } Clock;
153 
154 /* Common struct for handling all types of decoded data and allocated render buffers. */
155 typedef struct Frame {
158  int serial;
159  double pts; /* presentation timestamp for the frame */
160  double duration; /* estimated duration of the frame */
161  int64_t pos; /* byte position of the frame in the input file */
162  int width;
163  int height;
164  int format;
166  int uploaded;
167  int flip_v;
168 } Frame;
169 
170 typedef struct FrameQueue {
172  int rindex;
173  int windex;
174  int size;
175  int max_size;
178  SDL_mutex *mutex;
179  SDL_cond *cond;
181 } FrameQueue;
182 
183 enum {
184  AV_SYNC_AUDIO_MASTER, /* default choice */
186  AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
187 };
188 
189 typedef struct Decoder {
194  int finished;
196  SDL_cond *empty_queue_cond;
197  int64_t start_pts;
199  int64_t next_pts;
201  SDL_Thread *decoder_tid;
202 } Decoder;
203 
204 typedef struct VideoState {
205  SDL_Thread *read_tid;
209  int paused;
212  int seek_req;
214  int64_t seek_pos;
215  int64_t seek_rel;
218  int realtime;
219 
223 
227 
231 
233 
235 
236  double audio_clock;
238  double audio_diff_cum; /* used for AV difference average computation */
247  unsigned int audio_buf_size; /* in bytes */
248  unsigned int audio_buf1_size;
249  int audio_buf_index; /* in bytes */
252  int muted;
253  struct AudioParams audio_src;
254 #if CONFIG_AVFILTER
255  struct AudioParams audio_filter_src;
256 #endif
257  struct AudioParams audio_tgt;
261 
262  enum ShowMode {
263  SHOW_MODE_NONE = -1, SHOW_MODE_VIDEO = 0, SHOW_MODE_WAVES, SHOW_MODE_RDFT, SHOW_MODE_NB
264  } show_mode;
265  int16_t sample_array[SAMPLE_ARRAY_SIZE];
271  int xpos;
273  SDL_Texture *vis_texture;
274  SDL_Texture *sub_texture;
275  SDL_Texture *vid_texture;
276 
280 
281  double frame_timer;
287  double max_frame_duration; // maximum duration of a frame - above this, we consider the jump a timestamp discontinuity
290  int eof;
291 
292  char *filename;
293  int width, height, xleft, ytop;
294  int step;
295 
296 #if CONFIG_AVFILTER
297  int vfilter_idx;
298  AVFilterContext *in_video_filter; // the first filter in the video chain
299  AVFilterContext *out_video_filter; // the last filter in the video chain
300  AVFilterContext *in_audio_filter; // the first filter in the audio chain
301  AVFilterContext *out_audio_filter; // the last filter in the audio chain
302  AVFilterGraph *agraph; // audio filter graph
303 #endif
304 
305  int last_video_stream, last_audio_stream, last_subtitle_stream;
306 
308 } VideoState;
309 
310 /* options specified by the user */
312 static const char *input_filename;
313 static const char *window_title;
314 static int default_width = 640;
315 static int default_height = 480;
316 static int screen_width = 0;
317 static int screen_height = 0;
318 static int screen_left = SDL_WINDOWPOS_CENTERED;
319 static int screen_top = SDL_WINDOWPOS_CENTERED;
320 static int audio_disable;
321 static int video_disable;
322 static int subtitle_disable;
323 static const char* wanted_stream_spec[AVMEDIA_TYPE_NB] = {0};
324 static int seek_by_bytes = -1;
325 static float seek_interval = 10;
326 static int display_disable;
327 static int borderless;
328 static int alwaysontop;
329 static int startup_volume = 100;
330 static int show_status = -1;
332 static int64_t start_time = AV_NOPTS_VALUE;
333 static int64_t duration = AV_NOPTS_VALUE;
334 static int fast = 0;
335 static int genpts = 0;
336 static int lowres = 0;
337 static int decoder_reorder_pts = -1;
338 static int autoexit;
339 static int exit_on_keydown;
340 static int exit_on_mousedown;
341 static int loop = 1;
342 static int framedrop = -1;
343 static int infinite_buffer = -1;
344 static enum ShowMode show_mode = SHOW_MODE_NONE;
345 static const char *audio_codec_name;
346 static const char *subtitle_codec_name;
347 static const char *video_codec_name;
348 double rdftspeed = 0.02;
349 static int64_t cursor_last_shown;
350 static int cursor_hidden = 0;
351 #if CONFIG_AVFILTER
352 static const char **vfilters_list = NULL;
353 static int nb_vfilters = 0;
354 static char *afilters = NULL;
355 #endif
356 static int autorotate = 1;
357 static int find_stream_info = 1;
358 static int filter_nbthreads = 0;
359 
360 /* current context */
361 static int is_full_screen;
362 static int64_t audio_callback_time;
363 
364 #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
365 
366 static SDL_Window *window;
367 static SDL_Renderer *renderer;
368 static SDL_RendererInfo renderer_info = {0};
369 static SDL_AudioDeviceID audio_dev;
370 
371 static const struct TextureFormatEntry {
375  { AV_PIX_FMT_RGB8, SDL_PIXELFORMAT_RGB332 },
376  { AV_PIX_FMT_RGB444, SDL_PIXELFORMAT_RGB444 },
377  { AV_PIX_FMT_RGB555, SDL_PIXELFORMAT_RGB555 },
378  { AV_PIX_FMT_BGR555, SDL_PIXELFORMAT_BGR555 },
379  { AV_PIX_FMT_RGB565, SDL_PIXELFORMAT_RGB565 },
380  { AV_PIX_FMT_BGR565, SDL_PIXELFORMAT_BGR565 },
381  { AV_PIX_FMT_RGB24, SDL_PIXELFORMAT_RGB24 },
382  { AV_PIX_FMT_BGR24, SDL_PIXELFORMAT_BGR24 },
383  { AV_PIX_FMT_0RGB32, SDL_PIXELFORMAT_RGB888 },
384  { AV_PIX_FMT_0BGR32, SDL_PIXELFORMAT_BGR888 },
385  { AV_PIX_FMT_NE(RGB0, 0BGR), SDL_PIXELFORMAT_RGBX8888 },
386  { AV_PIX_FMT_NE(BGR0, 0RGB), SDL_PIXELFORMAT_BGRX8888 },
387  { AV_PIX_FMT_RGB32, SDL_PIXELFORMAT_ARGB8888 },
388  { AV_PIX_FMT_RGB32_1, SDL_PIXELFORMAT_RGBA8888 },
389  { AV_PIX_FMT_BGR32, SDL_PIXELFORMAT_ABGR8888 },
390  { AV_PIX_FMT_BGR32_1, SDL_PIXELFORMAT_BGRA8888 },
391  { AV_PIX_FMT_YUV420P, SDL_PIXELFORMAT_IYUV },
392  { AV_PIX_FMT_YUYV422, SDL_PIXELFORMAT_YUY2 },
393  { AV_PIX_FMT_UYVY422, SDL_PIXELFORMAT_UYVY },
394  { AV_PIX_FMT_NONE, SDL_PIXELFORMAT_UNKNOWN },
395 };
396 
397 #if CONFIG_AVFILTER
398 static int opt_add_vfilter(void *optctx, const char *opt, const char *arg)
399 {
400  GROW_ARRAY(vfilters_list, nb_vfilters);
401  vfilters_list[nb_vfilters - 1] = arg;
402  return 0;
403 }
404 #endif
405 
406 static inline
407 int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1,
408  enum AVSampleFormat fmt2, int64_t channel_count2)
409 {
410  /* If channel count == 1, planar and non-planar formats are the same */
411  if (channel_count1 == 1 && channel_count2 == 1)
413  else
414  return channel_count1 != channel_count2 || fmt1 != fmt2;
415 }
416 
417 static inline
418 int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
419 {
420  if (channel_layout && av_get_channel_layout_nb_channels(channel_layout) == channels)
421  return channel_layout;
422  else
423  return 0;
424 }
425 
427 {
428  MyAVPacketList pkt1;
429 
430  if (q->abort_request)
431  return -1;
432 
433  if (av_fifo_space(q->pkt_list) < sizeof(pkt1)) {
434  if (av_fifo_grow(q->pkt_list, sizeof(pkt1)) < 0)
435  return -1;
436  }
437 
438  pkt1.pkt = pkt;
439  pkt1.serial = q->serial;
440 
441  av_fifo_generic_write(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
442  q->nb_packets++;
443  q->size += pkt1.pkt->size + sizeof(pkt1);
444  q->duration += pkt1.pkt->duration;
445  /* XXX: should duplicate packet data in DV case */
446  SDL_CondSignal(q->cond);
447  return 0;
448 }
449 
451 {
452  AVPacket *pkt1;
453  int ret;
454 
455  pkt1 = av_packet_alloc();
456  if (!pkt1) {
457  av_packet_unref(pkt);
458  return -1;
459  }
460  av_packet_move_ref(pkt1, pkt);
461 
462  SDL_LockMutex(q->mutex);
463  ret = packet_queue_put_private(q, pkt1);
464  SDL_UnlockMutex(q->mutex);
465 
466  if (ret < 0)
467  av_packet_free(&pkt1);
468 
469  return ret;
470 }
471 
472 static int packet_queue_put_nullpacket(PacketQueue *q, AVPacket *pkt, int stream_index)
473 {
474  pkt->stream_index = stream_index;
475  return packet_queue_put(q, pkt);
476 }
477 
478 /* packet queue handling */
480 {
481  memset(q, 0, sizeof(PacketQueue));
482  q->pkt_list = av_fifo_alloc(sizeof(MyAVPacketList));
483  if (!q->pkt_list)
484  return AVERROR(ENOMEM);
485  q->mutex = SDL_CreateMutex();
486  if (!q->mutex) {
487  av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
488  return AVERROR(ENOMEM);
489  }
490  q->cond = SDL_CreateCond();
491  if (!q->cond) {
492  av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
493  return AVERROR(ENOMEM);
494  }
495  q->abort_request = 1;
496  return 0;
497 }
498 
500 {
501  MyAVPacketList pkt1;
502 
503  SDL_LockMutex(q->mutex);
504  while (av_fifo_size(q->pkt_list) >= sizeof(pkt1)) {
505  av_fifo_generic_read(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
506  av_packet_free(&pkt1.pkt);
507  }
508  q->nb_packets = 0;
509  q->size = 0;
510  q->duration = 0;
511  q->serial++;
512  SDL_UnlockMutex(q->mutex);
513 }
514 
516 {
518  av_fifo_freep(&q->pkt_list);
519  SDL_DestroyMutex(q->mutex);
520  SDL_DestroyCond(q->cond);
521 }
522 
524 {
525  SDL_LockMutex(q->mutex);
526 
527  q->abort_request = 1;
528 
529  SDL_CondSignal(q->cond);
530 
531  SDL_UnlockMutex(q->mutex);
532 }
533 
535 {
536  SDL_LockMutex(q->mutex);
537  q->abort_request = 0;
538  q->serial++;
539  SDL_UnlockMutex(q->mutex);
540 }
541 
542 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
544 {
545  MyAVPacketList pkt1;
546  int ret;
547 
548  SDL_LockMutex(q->mutex);
549 
550  for (;;) {
551  if (q->abort_request) {
552  ret = -1;
553  break;
554  }
555 
556  if (av_fifo_size(q->pkt_list) >= sizeof(pkt1)) {
557  av_fifo_generic_read(q->pkt_list, &pkt1, sizeof(pkt1), NULL);
558  q->nb_packets--;
559  q->size -= pkt1.pkt->size + sizeof(pkt1);
560  q->duration -= pkt1.pkt->duration;
561  av_packet_move_ref(pkt, pkt1.pkt);
562  if (serial)
563  *serial = pkt1.serial;
564  av_packet_free(&pkt1.pkt);
565  ret = 1;
566  break;
567  } else if (!block) {
568  ret = 0;
569  break;
570  } else {
571  SDL_CondWait(q->cond, q->mutex);
572  }
573  }
574  SDL_UnlockMutex(q->mutex);
575  return ret;
576 }
577 
578 static int decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
579  memset(d, 0, sizeof(Decoder));
580  d->pkt = av_packet_alloc();
581  if (!d->pkt)
582  return AVERROR(ENOMEM);
583  d->avctx = avctx;
584  d->queue = queue;
585  d->empty_queue_cond = empty_queue_cond;
587  d->pkt_serial = -1;
588  return 0;
589 }
590 
592  int ret = AVERROR(EAGAIN);
593 
594  for (;;) {
595  if (d->queue->serial == d->pkt_serial) {
596  do {
597  if (d->queue->abort_request)
598  return -1;
599 
600  switch (d->avctx->codec_type) {
601  case AVMEDIA_TYPE_VIDEO:
602  ret = avcodec_receive_frame(d->avctx, frame);
603  if (ret >= 0) {
604  if (decoder_reorder_pts == -1) {
605  frame->pts = frame->best_effort_timestamp;
606  } else if (!decoder_reorder_pts) {
607  frame->pts = frame->pkt_dts;
608  }
609  }
610  break;
611  case AVMEDIA_TYPE_AUDIO:
612  ret = avcodec_receive_frame(d->avctx, frame);
613  if (ret >= 0) {
614  AVRational tb = (AVRational){1, frame->sample_rate};
615  if (frame->pts != AV_NOPTS_VALUE)
616  frame->pts = av_rescale_q(frame->pts, d->avctx->pkt_timebase, tb);
617  else if (d->next_pts != AV_NOPTS_VALUE)
618  frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
619  if (frame->pts != AV_NOPTS_VALUE) {
620  d->next_pts = frame->pts + frame->nb_samples;
621  d->next_pts_tb = tb;
622  }
623  }
624  break;
625  }
626  if (ret == AVERROR_EOF) {
627  d->finished = d->pkt_serial;
629  return 0;
630  }
631  if (ret >= 0)
632  return 1;
633  } while (ret != AVERROR(EAGAIN));
634  }
635 
636  do {
637  if (d->queue->nb_packets == 0)
638  SDL_CondSignal(d->empty_queue_cond);
639  if (d->packet_pending) {
640  d->packet_pending = 0;
641  } else {
642  int old_serial = d->pkt_serial;
643  if (packet_queue_get(d->queue, d->pkt, 1, &d->pkt_serial) < 0)
644  return -1;
645  if (old_serial != d->pkt_serial) {
647  d->finished = 0;
648  d->next_pts = d->start_pts;
649  d->next_pts_tb = d->start_pts_tb;
650  }
651  }
652  if (d->queue->serial == d->pkt_serial)
653  break;
654  av_packet_unref(d->pkt);
655  } while (1);
656 
658  int got_frame = 0;
659  ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, d->pkt);
660  if (ret < 0) {
661  ret = AVERROR(EAGAIN);
662  } else {
663  if (got_frame && !d->pkt->data) {
664  d->packet_pending = 1;
665  }
666  ret = got_frame ? 0 : (d->pkt->data ? AVERROR(EAGAIN) : AVERROR_EOF);
667  }
668  av_packet_unref(d->pkt);
669  } else {
670  if (avcodec_send_packet(d->avctx, d->pkt) == AVERROR(EAGAIN)) {
671  av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
672  d->packet_pending = 1;
673  } else {
674  av_packet_unref(d->pkt);
675  }
676  }
677  }
678 }
679 
680 static void decoder_destroy(Decoder *d) {
681  av_packet_free(&d->pkt);
683 }
684 
686 {
687  av_frame_unref(vp->frame);
688  avsubtitle_free(&vp->sub);
689 }
690 
691 static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last)
692 {
693  int i;
694  memset(f, 0, sizeof(FrameQueue));
695  if (!(f->mutex = SDL_CreateMutex())) {
696  av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
697  return AVERROR(ENOMEM);
698  }
699  if (!(f->cond = SDL_CreateCond())) {
700  av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
701  return AVERROR(ENOMEM);
702  }
703  f->pktq = pktq;
704  f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
705  f->keep_last = !!keep_last;
706  for (i = 0; i < f->max_size; i++)
707  if (!(f->queue[i].frame = av_frame_alloc()))
708  return AVERROR(ENOMEM);
709  return 0;
710 }
711 
713 {
714  int i;
715  for (i = 0; i < f->max_size; i++) {
716  Frame *vp = &f->queue[i];
718  av_frame_free(&vp->frame);
719  }
720  SDL_DestroyMutex(f->mutex);
721  SDL_DestroyCond(f->cond);
722 }
723 
725 {
726  SDL_LockMutex(f->mutex);
727  SDL_CondSignal(f->cond);
728  SDL_UnlockMutex(f->mutex);
729 }
730 
732 {
733  return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
734 }
735 
737 {
738  return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];
739 }
740 
742 {
743  return &f->queue[f->rindex];
744 }
745 
747 {
748  /* wait until we have space to put a new frame */
749  SDL_LockMutex(f->mutex);
750  while (f->size >= f->max_size &&
751  !f->pktq->abort_request) {
752  SDL_CondWait(f->cond, f->mutex);
753  }
754  SDL_UnlockMutex(f->mutex);
755 
756  if (f->pktq->abort_request)
757  return NULL;
758 
759  return &f->queue[f->windex];
760 }
761 
763 {
764  /* wait until we have a readable a new frame */
765  SDL_LockMutex(f->mutex);
766  while (f->size - f->rindex_shown <= 0 &&
767  !f->pktq->abort_request) {
768  SDL_CondWait(f->cond, f->mutex);
769  }
770  SDL_UnlockMutex(f->mutex);
771 
772  if (f->pktq->abort_request)
773  return NULL;
774 
775  return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];
776 }
777 
779 {
780  if (++f->windex == f->max_size)
781  f->windex = 0;
782  SDL_LockMutex(f->mutex);
783  f->size++;
784  SDL_CondSignal(f->cond);
785  SDL_UnlockMutex(f->mutex);
786 }
787 
789 {
790  if (f->keep_last && !f->rindex_shown) {
791  f->rindex_shown = 1;
792  return;
793  }
795  if (++f->rindex == f->max_size)
796  f->rindex = 0;
797  SDL_LockMutex(f->mutex);
798  f->size--;
799  SDL_CondSignal(f->cond);
800  SDL_UnlockMutex(f->mutex);
801 }
802 
803 /* return the number of undisplayed frames in the queue */
805 {
806  return f->size - f->rindex_shown;
807 }
808 
809 /* return last shown position */
811 {
812  Frame *fp = &f->queue[f->rindex];
813  if (f->rindex_shown && fp->serial == f->pktq->serial)
814  return fp->pos;
815  else
816  return -1;
817 }
818 
819 static void decoder_abort(Decoder *d, FrameQueue *fq)
820 {
822  frame_queue_signal(fq);
823  SDL_WaitThread(d->decoder_tid, NULL);
824  d->decoder_tid = NULL;
826 }
827 
828 static inline void fill_rectangle(int x, int y, int w, int h)
829 {
830  SDL_Rect rect;
831  rect.x = x;
832  rect.y = y;
833  rect.w = w;
834  rect.h = h;
835  if (w && h)
836  SDL_RenderFillRect(renderer, &rect);
837 }
838 
839 static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
840 {
841  Uint32 format;
842  int access, w, h;
843  if (!*texture || SDL_QueryTexture(*texture, &format, &access, &w, &h) < 0 || new_width != w || new_height != h || new_format != format) {
844  void *pixels;
845  int pitch;
846  if (*texture)
847  SDL_DestroyTexture(*texture);
848  if (!(*texture = SDL_CreateTexture(renderer, new_format, SDL_TEXTUREACCESS_STREAMING, new_width, new_height)))
849  return -1;
850  if (SDL_SetTextureBlendMode(*texture, blendmode) < 0)
851  return -1;
852  if (init_texture) {
853  if (SDL_LockTexture(*texture, NULL, &pixels, &pitch) < 0)
854  return -1;
855  memset(pixels, 0, pitch * new_height);
856  SDL_UnlockTexture(*texture);
857  }
858  av_log(NULL, AV_LOG_VERBOSE, "Created %dx%d texture with %s.\n", new_width, new_height, SDL_GetPixelFormatName(new_format));
859  }
860  return 0;
861 }
862 
863 static void calculate_display_rect(SDL_Rect *rect,
864  int scr_xleft, int scr_ytop, int scr_width, int scr_height,
865  int pic_width, int pic_height, AVRational pic_sar)
866 {
867  AVRational aspect_ratio = pic_sar;
868  int64_t width, height, x, y;
869 
870  if (av_cmp_q(aspect_ratio, av_make_q(0, 1)) <= 0)
871  aspect_ratio = av_make_q(1, 1);
872 
873  aspect_ratio = av_mul_q(aspect_ratio, av_make_q(pic_width, pic_height));
874 
875  /* XXX: we suppose the screen has a 1.0 pixel ratio */
876  height = scr_height;
877  width = av_rescale(height, aspect_ratio.num, aspect_ratio.den) & ~1;
878  if (width > scr_width) {
879  width = scr_width;
880  height = av_rescale(width, aspect_ratio.den, aspect_ratio.num) & ~1;
881  }
882  x = (scr_width - width) / 2;
883  y = (scr_height - height) / 2;
884  rect->x = scr_xleft + x;
885  rect->y = scr_ytop + y;
886  rect->w = FFMAX((int)width, 1);
887  rect->h = FFMAX((int)height, 1);
888 }
889 
890 static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pix_fmt, SDL_BlendMode *sdl_blendmode)
891 {
892  int i;
893  *sdl_blendmode = SDL_BLENDMODE_NONE;
894  *sdl_pix_fmt = SDL_PIXELFORMAT_UNKNOWN;
895  if (format == AV_PIX_FMT_RGB32 ||
896  format == AV_PIX_FMT_RGB32_1 ||
897  format == AV_PIX_FMT_BGR32 ||
898  format == AV_PIX_FMT_BGR32_1)
899  *sdl_blendmode = SDL_BLENDMODE_BLEND;
900  for (i = 0; i < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; i++) {
901  if (format == sdl_texture_format_map[i].format) {
902  *sdl_pix_fmt = sdl_texture_format_map[i].texture_fmt;
903  return;
904  }
905  }
906 }
907 
908 static int upload_texture(SDL_Texture **tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
909  int ret = 0;
910  Uint32 sdl_pix_fmt;
911  SDL_BlendMode sdl_blendmode;
912  get_sdl_pix_fmt_and_blendmode(frame->format, &sdl_pix_fmt, &sdl_blendmode);
913  if (realloc_texture(tex, sdl_pix_fmt == SDL_PIXELFORMAT_UNKNOWN ? SDL_PIXELFORMAT_ARGB8888 : sdl_pix_fmt, frame->width, frame->height, sdl_blendmode, 0) < 0)
914  return -1;
915  switch (sdl_pix_fmt) {
916  case SDL_PIXELFORMAT_UNKNOWN:
917  /* This should only happen if we are not using avfilter... */
918  *img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
919  frame->width, frame->height, frame->format, frame->width, frame->height,
921  if (*img_convert_ctx != NULL) {
922  uint8_t *pixels[4];
923  int pitch[4];
924  if (!SDL_LockTexture(*tex, NULL, (void **)pixels, pitch)) {
925  sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
926  0, frame->height, pixels, pitch);
927  SDL_UnlockTexture(*tex);
928  }
929  } else {
930  av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
931  ret = -1;
932  }
933  break;
934  case SDL_PIXELFORMAT_IYUV:
935  if (frame->linesize[0] > 0 && frame->linesize[1] > 0 && frame->linesize[2] > 0) {
936  ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0], frame->linesize[0],
937  frame->data[1], frame->linesize[1],
938  frame->data[2], frame->linesize[2]);
939  } else if (frame->linesize[0] < 0 && frame->linesize[1] < 0 && frame->linesize[2] < 0) {
940  ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0],
941  frame->data[1] + frame->linesize[1] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[1],
942  frame->data[2] + frame->linesize[2] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[2]);
943  } else {
944  av_log(NULL, AV_LOG_ERROR, "Mixed negative and positive linesizes are not supported.\n");
945  return -1;
946  }
947  break;
948  default:
949  if (frame->linesize[0] < 0) {
950  ret = SDL_UpdateTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
951  } else {
952  ret = SDL_UpdateTexture(*tex, NULL, frame->data[0], frame->linesize[0]);
953  }
954  break;
955  }
956  return ret;
957 }
958 
960 {
961 #if SDL_VERSION_ATLEAST(2,0,8)
962  SDL_YUV_CONVERSION_MODE mode = SDL_YUV_CONVERSION_AUTOMATIC;
963  if (frame && (frame->format == AV_PIX_FMT_YUV420P || frame->format == AV_PIX_FMT_YUYV422 || frame->format == AV_PIX_FMT_UYVY422)) {
964  if (frame->color_range == AVCOL_RANGE_JPEG)
965  mode = SDL_YUV_CONVERSION_JPEG;
966  else if (frame->colorspace == AVCOL_SPC_BT709)
967  mode = SDL_YUV_CONVERSION_BT709;
968  else if (frame->colorspace == AVCOL_SPC_BT470BG || frame->colorspace == AVCOL_SPC_SMPTE170M || frame->colorspace == AVCOL_SPC_SMPTE240M)
969  mode = SDL_YUV_CONVERSION_BT601;
970  }
971  SDL_SetYUVConversionMode(mode);
972 #endif
973 }
974 
976 {
977  Frame *vp;
978  Frame *sp = NULL;
979  SDL_Rect rect;
980 
981  vp = frame_queue_peek_last(&is->pictq);
982  if (is->subtitle_st) {
983  if (frame_queue_nb_remaining(&is->subpq) > 0) {
984  sp = frame_queue_peek(&is->subpq);
985 
986  if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
987  if (!sp->uploaded) {
988  uint8_t* pixels[4];
989  int pitch[4];
990  int i;
991  if (!sp->width || !sp->height) {
992  sp->width = vp->width;
993  sp->height = vp->height;
994  }
995  if (realloc_texture(&is->sub_texture, SDL_PIXELFORMAT_ARGB8888, sp->width, sp->height, SDL_BLENDMODE_BLEND, 1) < 0)
996  return;
997 
998  for (i = 0; i < sp->sub.num_rects; i++) {
999  AVSubtitleRect *sub_rect = sp->sub.rects[i];
1000 
1001  sub_rect->x = av_clip(sub_rect->x, 0, sp->width );
1002  sub_rect->y = av_clip(sub_rect->y, 0, sp->height);
1003  sub_rect->w = av_clip(sub_rect->w, 0, sp->width - sub_rect->x);
1004  sub_rect->h = av_clip(sub_rect->h, 0, sp->height - sub_rect->y);
1005 
1007  sub_rect->w, sub_rect->h, AV_PIX_FMT_PAL8,
1008  sub_rect->w, sub_rect->h, AV_PIX_FMT_BGRA,
1009  0, NULL, NULL, NULL);
1010  if (!is->sub_convert_ctx) {
1011  av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
1012  return;
1013  }
1014  if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)pixels, pitch)) {
1015  sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
1016  0, sub_rect->h, pixels, pitch);
1017  SDL_UnlockTexture(is->sub_texture);
1018  }
1019  }
1020  sp->uploaded = 1;
1021  }
1022  } else
1023  sp = NULL;
1024  }
1025  }
1026 
1027  calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
1028 
1029  if (!vp->uploaded) {
1030  if (upload_texture(&is->vid_texture, vp->frame, &is->img_convert_ctx) < 0)
1031  return;
1032  vp->uploaded = 1;
1033  vp->flip_v = vp->frame->linesize[0] < 0;
1034  }
1035 
1037  SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0);
1039  if (sp) {
1040 #if USE_ONEPASS_SUBTITLE_RENDER
1041  SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
1042 #else
1043  int i;
1044  double xratio = (double)rect.w / (double)sp->width;
1045  double yratio = (double)rect.h / (double)sp->height;
1046  for (i = 0; i < sp->sub.num_rects; i++) {
1047  SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
1048  SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
1049  .y = rect.y + sub_rect->y * yratio,
1050  .w = sub_rect->w * xratio,
1051  .h = sub_rect->h * yratio};
1052  SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
1053  }
1054 #endif
1055  }
1056 }
1057 
1058 static inline int compute_mod(int a, int b)
1059 {
1060  return a < 0 ? a%b + b : a%b;
1061 }
1062 
1064 {
1065  int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
1066  int ch, channels, h, h2;
1067  int64_t time_diff;
1068  int rdft_bits, nb_freq;
1069 
1070  for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
1071  ;
1072  nb_freq = 1 << (rdft_bits - 1);
1073 
1074  /* compute display index : center on currently output samples */
1075  channels = s->audio_tgt.channels;
1076  nb_display_channels = channels;
1077  if (!s->paused) {
1078  int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
1079  n = 2 * channels;
1080  delay = s->audio_write_buf_size;
1081  delay /= n;
1082 
1083  /* to be more precise, we take into account the time spent since
1084  the last buffer computation */
1085  if (audio_callback_time) {
1086  time_diff = av_gettime_relative() - audio_callback_time;
1087  delay -= (time_diff * s->audio_tgt.freq) / 1000000;
1088  }
1089 
1090  delay += 2 * data_used;
1091  if (delay < data_used)
1092  delay = data_used;
1093 
1094  i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
1095  if (s->show_mode == SHOW_MODE_WAVES) {
1096  h = INT_MIN;
1097  for (i = 0; i < 1000; i += channels) {
1098  int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
1099  int a = s->sample_array[idx];
1100  int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
1101  int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
1102  int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
1103  int score = a - d;
1104  if (h < score && (b ^ c) < 0) {
1105  h = score;
1106  i_start = idx;
1107  }
1108  }
1109  }
1110 
1111  s->last_i_start = i_start;
1112  } else {
1113  i_start = s->last_i_start;
1114  }
1115 
1116  if (s->show_mode == SHOW_MODE_WAVES) {
1117  SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
1118 
1119  /* total height for one channel */
1120  h = s->height / nb_display_channels;
1121  /* graph height / 2 */
1122  h2 = (h * 9) / 20;
1123  for (ch = 0; ch < nb_display_channels; ch++) {
1124  i = i_start + ch;
1125  y1 = s->ytop + ch * h + (h / 2); /* position of center line */
1126  for (x = 0; x < s->width; x++) {
1127  y = (s->sample_array[i] * h2) >> 15;
1128  if (y < 0) {
1129  y = -y;
1130  ys = y1 - y;
1131  } else {
1132  ys = y1;
1133  }
1134  fill_rectangle(s->xleft + x, ys, 1, y);
1135  i += channels;
1136  if (i >= SAMPLE_ARRAY_SIZE)
1137  i -= SAMPLE_ARRAY_SIZE;
1138  }
1139  }
1140 
1141  SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
1142 
1143  for (ch = 1; ch < nb_display_channels; ch++) {
1144  y = s->ytop + ch * h;
1145  fill_rectangle(s->xleft, y, s->width, 1);
1146  }
1147  } else {
1148  if (realloc_texture(&s->vis_texture, SDL_PIXELFORMAT_ARGB8888, s->width, s->height, SDL_BLENDMODE_NONE, 1) < 0)
1149  return;
1150 
1151  nb_display_channels= FFMIN(nb_display_channels, 2);
1152  if (rdft_bits != s->rdft_bits) {
1153  av_rdft_end(s->rdft);
1154  av_free(s->rdft_data);
1155  s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
1156  s->rdft_bits = rdft_bits;
1157  s->rdft_data = av_malloc_array(nb_freq, 4 *sizeof(*s->rdft_data));
1158  }
1159  if (!s->rdft || !s->rdft_data){
1160  av_log(NULL, AV_LOG_ERROR, "Failed to allocate buffers for RDFT, switching to waves display\n");
1161  s->show_mode = SHOW_MODE_WAVES;
1162  } else {
1163  FFTSample *data[2];
1164  SDL_Rect rect = {.x = s->xpos, .y = 0, .w = 1, .h = s->height};
1165  uint32_t *pixels;
1166  int pitch;
1167  for (ch = 0; ch < nb_display_channels; ch++) {
1168  data[ch] = s->rdft_data + 2 * nb_freq * ch;
1169  i = i_start + ch;
1170  for (x = 0; x < 2 * nb_freq; x++) {
1171  double w = (x-nb_freq) * (1.0 / nb_freq);
1172  data[ch][x] = s->sample_array[i] * (1.0 - w * w);
1173  i += channels;
1174  if (i >= SAMPLE_ARRAY_SIZE)
1175  i -= SAMPLE_ARRAY_SIZE;
1176  }
1177  av_rdft_calc(s->rdft, data[ch]);
1178  }
1179  /* Least efficient way to do this, we should of course
1180  * directly access it but it is more than fast enough. */
1181  if (!SDL_LockTexture(s->vis_texture, &rect, (void **)&pixels, &pitch)) {
1182  pitch >>= 2;
1183  pixels += pitch * s->height;
1184  for (y = 0; y < s->height; y++) {
1185  double w = 1 / sqrt(nb_freq);
1186  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]));
1187  int b = (nb_display_channels == 2 ) ? sqrt(w * hypot(data[1][2 * y + 0], data[1][2 * y + 1]))
1188  : a;
1189  a = FFMIN(a, 255);
1190  b = FFMIN(b, 255);
1191  pixels -= pitch;
1192  *pixels = (a << 16) + (b << 8) + ((a+b) >> 1);
1193  }
1194  SDL_UnlockTexture(s->vis_texture);
1195  }
1196  SDL_RenderCopy(renderer, s->vis_texture, NULL, NULL);
1197  }
1198  if (!s->paused)
1199  s->xpos++;
1200  if (s->xpos >= s->width)
1201  s->xpos= s->xleft;
1202  }
1203 }
1204 
1205 static void stream_component_close(VideoState *is, int stream_index)
1206 {
1207  AVFormatContext *ic = is->ic;
1208  AVCodecParameters *codecpar;
1209 
1210  if (stream_index < 0 || stream_index >= ic->nb_streams)
1211  return;
1212  codecpar = ic->streams[stream_index]->codecpar;
1213 
1214  switch (codecpar->codec_type) {
1215  case AVMEDIA_TYPE_AUDIO:
1216  decoder_abort(&is->auddec, &is->sampq);
1217  SDL_CloseAudioDevice(audio_dev);
1218  decoder_destroy(&is->auddec);
1219  swr_free(&is->swr_ctx);
1220  av_freep(&is->audio_buf1);
1221  is->audio_buf1_size = 0;
1222  is->audio_buf = NULL;
1223 
1224  if (is->rdft) {
1225  av_rdft_end(is->rdft);
1226  av_freep(&is->rdft_data);
1227  is->rdft = NULL;
1228  is->rdft_bits = 0;
1229  }
1230  break;
1231  case AVMEDIA_TYPE_VIDEO:
1232  decoder_abort(&is->viddec, &is->pictq);
1233  decoder_destroy(&is->viddec);
1234  break;
1235  case AVMEDIA_TYPE_SUBTITLE:
1236  decoder_abort(&is->subdec, &is->subpq);
1237  decoder_destroy(&is->subdec);
1238  break;
1239  default:
1240  break;
1241  }
1242 
1243  ic->streams[stream_index]->discard = AVDISCARD_ALL;
1244  switch (codecpar->codec_type) {
1245  case AVMEDIA_TYPE_AUDIO:
1246  is->audio_st = NULL;
1247  is->audio_stream = -1;
1248  break;
1249  case AVMEDIA_TYPE_VIDEO:
1250  is->video_st = NULL;
1251  is->video_stream = -1;
1252  break;
1253  case AVMEDIA_TYPE_SUBTITLE:
1254  is->subtitle_st = NULL;
1255  is->subtitle_stream = -1;
1256  break;
1257  default:
1258  break;
1259  }
1260 }
1261 
1263 {
1264  /* XXX: use a special url_shutdown call to abort parse cleanly */
1265  is->abort_request = 1;
1266  SDL_WaitThread(is->read_tid, NULL);
1267 
1268  /* close each stream */
1269  if (is->audio_stream >= 0)
1271  if (is->video_stream >= 0)
1273  if (is->subtitle_stream >= 0)
1275 
1276  avformat_close_input(&is->ic);
1277 
1281 
1282  /* free all pictures */
1283  frame_queue_destory(&is->pictq);
1284  frame_queue_destory(&is->sampq);
1285  frame_queue_destory(&is->subpq);
1286  SDL_DestroyCond(is->continue_read_thread);
1289  av_free(is->filename);
1290  if (is->vis_texture)
1291  SDL_DestroyTexture(is->vis_texture);
1292  if (is->vid_texture)
1293  SDL_DestroyTexture(is->vid_texture);
1294  if (is->sub_texture)
1295  SDL_DestroyTexture(is->sub_texture);
1296  av_free(is);
1297 }
1298 
1299 static void do_exit(VideoState *is)
1300 {
1301  if (is) {
1302  stream_close(is);
1303  }
1304  if (renderer)
1305  SDL_DestroyRenderer(renderer);
1306  if (window)
1307  SDL_DestroyWindow(window);
1308  uninit_opts();
1309 #if CONFIG_AVFILTER
1310  av_freep(&vfilters_list);
1311 #endif
1313  if (show_status)
1314  printf("\n");
1315  SDL_Quit();
1316  av_log(NULL, AV_LOG_QUIET, "%s", "");
1317  exit(0);
1318 }
1319 
1320 static void sigterm_handler(int sig)
1321 {
1322  exit(123);
1323 }
1324 
1326 {
1327  SDL_Rect rect;
1328  int max_width = screen_width ? screen_width : INT_MAX;
1329  int max_height = screen_height ? screen_height : INT_MAX;
1330  if (max_width == INT_MAX && max_height == INT_MAX)
1331  max_height = height;
1332  calculate_display_rect(&rect, 0, 0, max_width, max_height, width, height, sar);
1333  default_width = rect.w;
1334  default_height = rect.h;
1335 }
1336 
1338 {
1339  int w,h;
1340 
1343 
1344  if (!window_title)
1346  SDL_SetWindowTitle(window, window_title);
1347 
1348  SDL_SetWindowSize(window, w, h);
1349  SDL_SetWindowPosition(window, screen_left, screen_top);
1350  if (is_full_screen)
1351  SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1352  SDL_ShowWindow(window);
1353 
1354  is->width = w;
1355  is->height = h;
1356 
1357  return 0;
1358 }
1359 
1360 /* display the current picture, if any */
1362 {
1363  if (!is->width)
1364  video_open(is);
1365 
1366  SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
1367  SDL_RenderClear(renderer);
1368  if (is->audio_st && is->show_mode != SHOW_MODE_VIDEO)
1369  video_audio_display(is);
1370  else if (is->video_st)
1371  video_image_display(is);
1372  SDL_RenderPresent(renderer);
1373 }
1374 
1375 static double get_clock(Clock *c)
1376 {
1377  if (*c->queue_serial != c->serial)
1378  return NAN;
1379  if (c->paused) {
1380  return c->pts;
1381  } else {
1382  double time = av_gettime_relative() / 1000000.0;
1383  return c->pts_drift + time - (time - c->last_updated) * (1.0 - c->speed);
1384  }
1385 }
1386 
1387 static void set_clock_at(Clock *c, double pts, int serial, double time)
1388 {
1389  c->pts = pts;
1390  c->last_updated = time;
1391  c->pts_drift = c->pts - time;
1392  c->serial = serial;
1393 }
1394 
1395 static void set_clock(Clock *c, double pts, int serial)
1396 {
1397  double time = av_gettime_relative() / 1000000.0;
1398  set_clock_at(c, pts, serial, time);
1399 }
1400 
1401 static void set_clock_speed(Clock *c, double speed)
1402 {
1403  set_clock(c, get_clock(c), c->serial);
1404  c->speed = speed;
1405 }
1406 
1407 static void init_clock(Clock *c, int *queue_serial)
1408 {
1409  c->speed = 1.0;
1410  c->paused = 0;
1411  c->queue_serial = queue_serial;
1412  set_clock(c, NAN, -1);
1413 }
1414 
1415 static void sync_clock_to_slave(Clock *c, Clock *slave)
1416 {
1417  double clock = get_clock(c);
1418  double slave_clock = get_clock(slave);
1419  if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
1420  set_clock(c, slave_clock, slave->serial);
1421 }
1422 
1424  if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
1425  if (is->video_st)
1426  return AV_SYNC_VIDEO_MASTER;
1427  else
1428  return AV_SYNC_AUDIO_MASTER;
1429  } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
1430  if (is->audio_st)
1431  return AV_SYNC_AUDIO_MASTER;
1432  else
1433  return AV_SYNC_EXTERNAL_CLOCK;
1434  } else {
1435  return AV_SYNC_EXTERNAL_CLOCK;
1436  }
1437 }
1438 
1439 /* get the current master clock value */
1441 {
1442  double val;
1443 
1444  switch (get_master_sync_type(is)) {
1445  case AV_SYNC_VIDEO_MASTER:
1446  val = get_clock(&is->vidclk);
1447  break;
1448  case AV_SYNC_AUDIO_MASTER:
1449  val = get_clock(&is->audclk);
1450  break;
1451  default:
1452  val = get_clock(&is->extclk);
1453  break;
1454  }
1455  return val;
1456 }
1457 
1459  if (is->video_stream >= 0 && is->videoq.nb_packets <= EXTERNAL_CLOCK_MIN_FRAMES ||
1462  } else if ((is->video_stream < 0 || is->videoq.nb_packets > EXTERNAL_CLOCK_MAX_FRAMES) &&
1465  } else {
1466  double speed = is->extclk.speed;
1467  if (speed != 1.0)
1468  set_clock_speed(&is->extclk, speed + EXTERNAL_CLOCK_SPEED_STEP * (1.0 - speed) / fabs(1.0 - speed));
1469  }
1470 }
1471 
1472 /* seek in the stream */
1473 static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
1474 {
1475  if (!is->seek_req) {
1476  is->seek_pos = pos;
1477  is->seek_rel = rel;
1478  is->seek_flags &= ~AVSEEK_FLAG_BYTE;
1479  if (seek_by_bytes)
1481  is->seek_req = 1;
1482  SDL_CondSignal(is->continue_read_thread);
1483  }
1484 }
1485 
1486 /* pause or resume the video */
1488 {
1489  if (is->paused) {
1490  is->frame_timer += av_gettime_relative() / 1000000.0 - is->vidclk.last_updated;
1491  if (is->read_pause_return != AVERROR(ENOSYS)) {
1492  is->vidclk.paused = 0;
1493  }
1494  set_clock(&is->vidclk, get_clock(&is->vidclk), is->vidclk.serial);
1495  }
1496  set_clock(&is->extclk, get_clock(&is->extclk), is->extclk.serial);
1497  is->paused = is->audclk.paused = is->vidclk.paused = is->extclk.paused = !is->paused;
1498 }
1499 
1501 {
1502  stream_toggle_pause(is);
1503  is->step = 0;
1504 }
1505 
1507 {
1508  is->muted = !is->muted;
1509 }
1510 
1511 static void update_volume(VideoState *is, int sign, double step)
1512 {
1513  double volume_level = is->audio_volume ? (20 * log(is->audio_volume / (double)SDL_MIX_MAXVOLUME) / log(10)) : -1000.0;
1514  int new_volume = lrint(SDL_MIX_MAXVOLUME * pow(10.0, (volume_level + sign * step) / 20.0));
1515  is->audio_volume = av_clip(is->audio_volume == new_volume ? (is->audio_volume + sign) : new_volume, 0, SDL_MIX_MAXVOLUME);
1516 }
1517 
1519 {
1520  /* if the stream is paused unpause it, then step */
1521  if (is->paused)
1522  stream_toggle_pause(is);
1523  is->step = 1;
1524 }
1525 
1526 static double compute_target_delay(double delay, VideoState *is)
1527 {
1528  double sync_threshold, diff = 0;
1529 
1530  /* update delay to follow master synchronisation source */
1532  /* if video is slave, we try to correct big delays by
1533  duplicating or deleting a frame */
1534  diff = get_clock(&is->vidclk) - get_master_clock(is);
1535 
1536  /* skip or repeat frame. We take into account the
1537  delay to compute the threshold. I still don't know
1538  if it is the best guess */
1539  sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
1540  if (!isnan(diff) && fabs(diff) < is->max_frame_duration) {
1541  if (diff <= -sync_threshold)
1542  delay = FFMAX(0, delay + diff);
1543  else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
1544  delay = delay + diff;
1545  else if (diff >= sync_threshold)
1546  delay = 2 * delay;
1547  }
1548  }
1549 
1550  av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
1551  delay, -diff);
1552 
1553  return delay;
1554 }
1555 
1556 static double vp_duration(VideoState *is, Frame *vp, Frame *nextvp) {
1557  if (vp->serial == nextvp->serial) {
1558  double duration = nextvp->pts - vp->pts;
1559  if (isnan(duration) || duration <= 0 || duration > is->max_frame_duration)
1560  return vp->duration;
1561  else
1562  return duration;
1563  } else {
1564  return 0.0;
1565  }
1566 }
1567 
1568 static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
1569  /* update current video pts */
1570  set_clock(&is->vidclk, pts, serial);
1571  sync_clock_to_slave(&is->extclk, &is->vidclk);
1572 }
1573 
1574 /* called to display each frame */
1575 static void video_refresh(void *opaque, double *remaining_time)
1576 {
1577  VideoState *is = opaque;
1578  double time;
1579 
1580  Frame *sp, *sp2;
1581 
1582  if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
1584 
1585  if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
1586  time = av_gettime_relative() / 1000000.0;
1587  if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
1588  video_display(is);
1589  is->last_vis_time = time;
1590  }
1591  *remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
1592  }
1593 
1594  if (is->video_st) {
1595 retry:
1596  if (frame_queue_nb_remaining(&is->pictq) == 0) {
1597  // nothing to do, no picture to display in the queue
1598  } else {
1599  double last_duration, duration, delay;
1600  Frame *vp, *lastvp;
1601 
1602  /* dequeue the picture */
1603  lastvp = frame_queue_peek_last(&is->pictq);
1604  vp = frame_queue_peek(&is->pictq);
1605 
1606  if (vp->serial != is->videoq.serial) {
1607  frame_queue_next(&is->pictq);
1608  goto retry;
1609  }
1610 
1611  if (lastvp->serial != vp->serial)
1612  is->frame_timer = av_gettime_relative() / 1000000.0;
1613 
1614  if (is->paused)
1615  goto display;
1616 
1617  /* compute nominal last_duration */
1618  last_duration = vp_duration(is, lastvp, vp);
1619  delay = compute_target_delay(last_duration, is);
1620 
1621  time= av_gettime_relative()/1000000.0;
1622  if (time < is->frame_timer + delay) {
1623  *remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
1624  goto display;
1625  }
1626 
1627  is->frame_timer += delay;
1628  if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX)
1629  is->frame_timer = time;
1630 
1631  SDL_LockMutex(is->pictq.mutex);
1632  if (!isnan(vp->pts))
1633  update_video_pts(is, vp->pts, vp->pos, vp->serial);
1634  SDL_UnlockMutex(is->pictq.mutex);
1635 
1636  if (frame_queue_nb_remaining(&is->pictq) > 1) {
1637  Frame *nextvp = frame_queue_peek_next(&is->pictq);
1638  duration = vp_duration(is, vp, nextvp);
1639  if(!is->step && (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) && time > is->frame_timer + duration){
1640  is->frame_drops_late++;
1641  frame_queue_next(&is->pictq);
1642  goto retry;
1643  }
1644  }
1645 
1646  if (is->subtitle_st) {
1647  while (frame_queue_nb_remaining(&is->subpq) > 0) {
1648  sp = frame_queue_peek(&is->subpq);
1649 
1650  if (frame_queue_nb_remaining(&is->subpq) > 1)
1651  sp2 = frame_queue_peek_next(&is->subpq);
1652  else
1653  sp2 = NULL;
1654 
1655  if (sp->serial != is->subtitleq.serial
1656  || (is->vidclk.pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1657  || (sp2 && is->vidclk.pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1658  {
1659  if (sp->uploaded) {
1660  int i;
1661  for (i = 0; i < sp->sub.num_rects; i++) {
1662  AVSubtitleRect *sub_rect = sp->sub.rects[i];
1663  uint8_t *pixels;
1664  int pitch, j;
1665 
1666  if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
1667  for (j = 0; j < sub_rect->h; j++, pixels += pitch)
1668  memset(pixels, 0, sub_rect->w << 2);
1669  SDL_UnlockTexture(is->sub_texture);
1670  }
1671  }
1672  }
1673  frame_queue_next(&is->subpq);
1674  } else {
1675  break;
1676  }
1677  }
1678  }
1679 
1680  frame_queue_next(&is->pictq);
1681  is->force_refresh = 1;
1682 
1683  if (is->step && !is->paused)
1684  stream_toggle_pause(is);
1685  }
1686 display:
1687  /* display picture */
1688  if (!display_disable && is->force_refresh && is->show_mode == SHOW_MODE_VIDEO && is->pictq.rindex_shown)
1689  video_display(is);
1690  }
1691  is->force_refresh = 0;
1692  if (show_status) {
1693  AVBPrint buf;
1694  static int64_t last_time;
1695  int64_t cur_time;
1696  int aqsize, vqsize, sqsize;
1697  double av_diff;
1698 
1699  cur_time = av_gettime_relative();
1700  if (!last_time || (cur_time - last_time) >= 30000) {
1701  aqsize = 0;
1702  vqsize = 0;
1703  sqsize = 0;
1704  if (is->audio_st)
1705  aqsize = is->audioq.size;
1706  if (is->video_st)
1707  vqsize = is->videoq.size;
1708  if (is->subtitle_st)
1709  sqsize = is->subtitleq.size;
1710  av_diff = 0;
1711  if (is->audio_st && is->video_st)
1712  av_diff = get_clock(&is->audclk) - get_clock(&is->vidclk);
1713  else if (is->video_st)
1714  av_diff = get_master_clock(is) - get_clock(&is->vidclk);
1715  else if (is->audio_st)
1716  av_diff = get_master_clock(is) - get_clock(&is->audclk);
1717 
1719  av_bprintf(&buf,
1720  "%7.2f %s:%7.3f fd=%4d aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1721  get_master_clock(is),
1722  (is->audio_st && is->video_st) ? "A-V" : (is->video_st ? "M-V" : (is->audio_st ? "M-A" : " ")),
1723  av_diff,
1725  aqsize / 1024,
1726  vqsize / 1024,
1727  sqsize,
1730 
1731  if (show_status == 1 && AV_LOG_INFO > av_log_get_level())
1732  fprintf(stderr, "%s", buf.str);
1733  else
1734  av_log(NULL, AV_LOG_INFO, "%s", buf.str);
1735 
1736  fflush(stderr);
1737  av_bprint_finalize(&buf, NULL);
1738 
1739  last_time = cur_time;
1740  }
1741  }
1742 }
1743 
1744 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
1745 {
1746  Frame *vp;
1747 
1748 #if defined(DEBUG_SYNC)
1749  printf("frame_type=%c pts=%0.3f\n",
1750  av_get_picture_type_char(src_frame->pict_type), pts);
1751 #endif
1752 
1753  if (!(vp = frame_queue_peek_writable(&is->pictq)))
1754  return -1;
1755 
1756  vp->sar = src_frame->sample_aspect_ratio;
1757  vp->uploaded = 0;
1758 
1759  vp->width = src_frame->width;
1760  vp->height = src_frame->height;
1761  vp->format = src_frame->format;
1762 
1763  vp->pts = pts;
1764  vp->duration = duration;
1765  vp->pos = pos;
1766  vp->serial = serial;
1767 
1768  set_default_window_size(vp->width, vp->height, vp->sar);
1769 
1770  av_frame_move_ref(vp->frame, src_frame);
1771  frame_queue_push(&is->pictq);
1772  return 0;
1773 }
1774 
1776 {
1777  int got_picture;
1778 
1779  if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
1780  return -1;
1781 
1782  if (got_picture) {
1783  double dpts = NAN;
1784 
1785  if (frame->pts != AV_NOPTS_VALUE)
1786  dpts = av_q2d(is->video_st->time_base) * frame->pts;
1787 
1788  frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
1789 
1791  if (frame->pts != AV_NOPTS_VALUE) {
1792  double diff = dpts - get_master_clock(is);
1793  if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
1794  diff - is->frame_last_filter_delay < 0 &&
1795  is->viddec.pkt_serial == is->vidclk.serial &&
1796  is->videoq.nb_packets) {
1797  is->frame_drops_early++;
1798  av_frame_unref(frame);
1799  got_picture = 0;
1800  }
1801  }
1802  }
1803  }
1804 
1805  return got_picture;
1806 }
1807 
1808 #if CONFIG_AVFILTER
1809 static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
1810  AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
1811 {
1812  int ret, i;
1813  int nb_filters = graph->nb_filters;
1815 
1816  if (filtergraph) {
1817  outputs = avfilter_inout_alloc();
1818  inputs = avfilter_inout_alloc();
1819  if (!outputs || !inputs) {
1820  ret = AVERROR(ENOMEM);
1821  goto fail;
1822  }
1823 
1824  outputs->name = av_strdup("in");
1825  outputs->filter_ctx = source_ctx;
1826  outputs->pad_idx = 0;
1827  outputs->next = NULL;
1828 
1829  inputs->name = av_strdup("out");
1830  inputs->filter_ctx = sink_ctx;
1831  inputs->pad_idx = 0;
1832  inputs->next = NULL;
1833 
1834  if ((ret = avfilter_graph_parse_ptr(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
1835  goto fail;
1836  } else {
1837  if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
1838  goto fail;
1839  }
1840 
1841  /* Reorder the filters to ensure that inputs of the custom filters are merged first */
1842  for (i = 0; i < graph->nb_filters - nb_filters; i++)
1843  FFSWAP(AVFilterContext*, graph->filters[i], graph->filters[i + nb_filters]);
1844 
1845  ret = avfilter_graph_config(graph, NULL);
1846 fail:
1847  avfilter_inout_free(&outputs);
1848  avfilter_inout_free(&inputs);
1849  return ret;
1850 }
1851 
1852 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
1853 {
1855  char sws_flags_str[512] = "";
1856  char buffersrc_args[256];
1857  int ret;
1858  AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter = NULL;
1859  AVCodecParameters *codecpar = is->video_st->codecpar;
1860  AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
1861  AVDictionaryEntry *e = NULL;
1862  int nb_pix_fmts = 0;
1863  int i, j;
1864 
1865  for (i = 0; i < renderer_info.num_texture_formats; i++) {
1866  for (j = 0; j < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; j++) {
1867  if (renderer_info.texture_formats[i] == sdl_texture_format_map[j].texture_fmt) {
1868  pix_fmts[nb_pix_fmts++] = sdl_texture_format_map[j].format;
1869  break;
1870  }
1871  }
1872  }
1873  pix_fmts[nb_pix_fmts] = AV_PIX_FMT_NONE;
1874 
1875  while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
1876  if (!strcmp(e->key, "sws_flags")) {
1877  av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", "flags", e->value);
1878  } else
1879  av_strlcatf(sws_flags_str, sizeof(sws_flags_str), "%s=%s:", e->key, e->value);
1880  }
1881  if (strlen(sws_flags_str))
1882  sws_flags_str[strlen(sws_flags_str)-1] = '\0';
1883 
1884  graph->scale_sws_opts = av_strdup(sws_flags_str);
1885 
1886  snprintf(buffersrc_args, sizeof(buffersrc_args),
1887  "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
1888  frame->width, frame->height, frame->format,
1890  codecpar->sample_aspect_ratio.num, FFMAX(codecpar->sample_aspect_ratio.den, 1));
1891  if (fr.num && fr.den)
1892  av_strlcatf(buffersrc_args, sizeof(buffersrc_args), ":frame_rate=%d/%d", fr.num, fr.den);
1893 
1894  if ((ret = avfilter_graph_create_filter(&filt_src,
1895  avfilter_get_by_name("buffer"),
1896  "ffplay_buffer", buffersrc_args, NULL,
1897  graph)) < 0)
1898  goto fail;
1899 
1900  ret = avfilter_graph_create_filter(&filt_out,
1901  avfilter_get_by_name("buffersink"),
1902  "ffplay_buffersink", NULL, NULL, graph);
1903  if (ret < 0)
1904  goto fail;
1905 
1906  if ((ret = av_opt_set_int_list(filt_out, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
1907  goto fail;
1908 
1909  last_filter = filt_out;
1910 
1911 /* Note: this macro adds a filter before the lastly added filter, so the
1912  * processing order of the filters is in reverse */
1913 #define INSERT_FILT(name, arg) do { \
1914  AVFilterContext *filt_ctx; \
1915  \
1916  ret = avfilter_graph_create_filter(&filt_ctx, \
1917  avfilter_get_by_name(name), \
1918  "ffplay_" name, arg, NULL, graph); \
1919  if (ret < 0) \
1920  goto fail; \
1921  \
1922  ret = avfilter_link(filt_ctx, 0, last_filter, 0); \
1923  if (ret < 0) \
1924  goto fail; \
1925  \
1926  last_filter = filt_ctx; \
1927 } while (0)
1928 
1929  if (autorotate) {
1930  double theta = get_rotation(is->video_st);
1931 
1932  if (fabs(theta - 90) < 1.0) {
1933  INSERT_FILT("transpose", "clock");
1934  } else if (fabs(theta - 180) < 1.0) {
1935  INSERT_FILT("hflip", NULL);
1936  INSERT_FILT("vflip", NULL);
1937  } else if (fabs(theta - 270) < 1.0) {
1938  INSERT_FILT("transpose", "cclock");
1939  } else if (fabs(theta) > 1.0) {
1940  char rotate_buf[64];
1941  snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
1942  INSERT_FILT("rotate", rotate_buf);
1943  }
1944  }
1945 
1946  if ((ret = configure_filtergraph(graph, vfilters, filt_src, last_filter)) < 0)
1947  goto fail;
1948 
1949  is->in_video_filter = filt_src;
1950  is->out_video_filter = filt_out;
1951 
1952 fail:
1953  return ret;
1954 }
1955 
1956 static int configure_audio_filters(VideoState *is, const char *afilters, int force_output_format)
1957 {
1959  int sample_rates[2] = { 0, -1 };
1960  int64_t channel_layouts[2] = { 0, -1 };
1961  int channels[2] = { 0, -1 };
1962  AVFilterContext *filt_asrc = NULL, *filt_asink = NULL;
1963  char aresample_swr_opts[512] = "";
1964  AVDictionaryEntry *e = NULL;
1965  char asrc_args[256];
1966  int ret;
1967 
1968  avfilter_graph_free(&is->agraph);
1969  if (!(is->agraph = avfilter_graph_alloc()))
1970  return AVERROR(ENOMEM);
1971  is->agraph->nb_threads = filter_nbthreads;
1972 
1973  while ((e = av_dict_get(swr_opts, "", e, AV_DICT_IGNORE_SUFFIX)))
1974  av_strlcatf(aresample_swr_opts, sizeof(aresample_swr_opts), "%s=%s:", e->key, e->value);
1975  if (strlen(aresample_swr_opts))
1976  aresample_swr_opts[strlen(aresample_swr_opts)-1] = '\0';
1977  av_opt_set(is->agraph, "aresample_swr_opts", aresample_swr_opts, 0);
1978 
1979  ret = snprintf(asrc_args, sizeof(asrc_args),
1980  "sample_rate=%d:sample_fmt=%s:channels=%d:time_base=%d/%d",
1981  is->audio_filter_src.freq, av_get_sample_fmt_name(is->audio_filter_src.fmt),
1982  is->audio_filter_src.channels,
1983  1, is->audio_filter_src.freq);
1984  if (is->audio_filter_src.channel_layout)
1985  snprintf(asrc_args + ret, sizeof(asrc_args) - ret,
1986  ":channel_layout=0x%"PRIx64, is->audio_filter_src.channel_layout);
1987 
1988  ret = avfilter_graph_create_filter(&filt_asrc,
1989  avfilter_get_by_name("abuffer"), "ffplay_abuffer",
1990  asrc_args, NULL, is->agraph);
1991  if (ret < 0)
1992  goto end;
1993 
1994 
1995  ret = avfilter_graph_create_filter(&filt_asink,
1996  avfilter_get_by_name("abuffersink"), "ffplay_abuffersink",
1997  NULL, NULL, is->agraph);
1998  if (ret < 0)
1999  goto end;
2000 
2001  if ((ret = av_opt_set_int_list(filt_asink, "sample_fmts", sample_fmts, AV_SAMPLE_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
2002  goto end;
2003  if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
2004  goto end;
2005 
2006  if (force_output_format) {
2007  channel_layouts[0] = is->audio_tgt.channel_layout;
2008  channels [0] = is->audio_tgt.channel_layout ? -1 : is->audio_tgt.channels;
2009  sample_rates [0] = is->audio_tgt.freq;
2010  if ((ret = av_opt_set_int(filt_asink, "all_channel_counts", 0, AV_OPT_SEARCH_CHILDREN)) < 0)
2011  goto end;
2012  if ((ret = av_opt_set_int_list(filt_asink, "channel_layouts", channel_layouts, -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2013  goto end;
2014  if ((ret = av_opt_set_int_list(filt_asink, "channel_counts" , channels , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2015  goto end;
2016  if ((ret = av_opt_set_int_list(filt_asink, "sample_rates" , sample_rates , -1, AV_OPT_SEARCH_CHILDREN)) < 0)
2017  goto end;
2018  }
2019 
2020 
2021  if ((ret = configure_filtergraph(is->agraph, afilters, filt_asrc, filt_asink)) < 0)
2022  goto end;
2023 
2024  is->in_audio_filter = filt_asrc;
2025  is->out_audio_filter = filt_asink;
2026 
2027 end:
2028  if (ret < 0)
2029  avfilter_graph_free(&is->agraph);
2030  return ret;
2031 }
2032 #endif /* CONFIG_AVFILTER */
2033 
2034 static int audio_thread(void *arg)
2035 {
2036  VideoState *is = arg;
2037  AVFrame *frame = av_frame_alloc();
2038  Frame *af;
2039 #if CONFIG_AVFILTER
2040  int last_serial = -1;
2041  int64_t dec_channel_layout;
2042  int reconfigure;
2043 #endif
2044  int got_frame = 0;
2045  AVRational tb;
2046  int ret = 0;
2047 
2048  if (!frame)
2049  return AVERROR(ENOMEM);
2050 
2051  do {
2052  if ((got_frame = decoder_decode_frame(&is->auddec, frame, NULL)) < 0)
2053  goto the_end;
2054 
2055  if (got_frame) {
2056  tb = (AVRational){1, frame->sample_rate};
2057 
2058 #if CONFIG_AVFILTER
2059  dec_channel_layout = get_valid_channel_layout(frame->channel_layout, frame->channels);
2060 
2061  reconfigure =
2062  cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
2063  frame->format, frame->channels) ||
2064  is->audio_filter_src.channel_layout != dec_channel_layout ||
2065  is->audio_filter_src.freq != frame->sample_rate ||
2066  is->auddec.pkt_serial != last_serial;
2067 
2068  if (reconfigure) {
2069  char buf1[1024], buf2[1024];
2070  av_get_channel_layout_string(buf1, sizeof(buf1), -1, is->audio_filter_src.channel_layout);
2071  av_get_channel_layout_string(buf2, sizeof(buf2), -1, dec_channel_layout);
2073  "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",
2074  is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
2075  frame->sample_rate, frame->channels, av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
2076 
2077  is->audio_filter_src.fmt = frame->format;
2078  is->audio_filter_src.channels = frame->channels;
2079  is->audio_filter_src.channel_layout = dec_channel_layout;
2080  is->audio_filter_src.freq = frame->sample_rate;
2081  last_serial = is->auddec.pkt_serial;
2082 
2083  if ((ret = configure_audio_filters(is, afilters, 1)) < 0)
2084  goto the_end;
2085  }
2086 
2087  if ((ret = av_buffersrc_add_frame(is->in_audio_filter, frame)) < 0)
2088  goto the_end;
2089 
2090  while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
2091  tb = av_buffersink_get_time_base(is->out_audio_filter);
2092 #endif
2093  if (!(af = frame_queue_peek_writable(&is->sampq)))
2094  goto the_end;
2095 
2096  af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2097  af->pos = frame->pkt_pos;
2098  af->serial = is->auddec.pkt_serial;
2099  af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
2100 
2101  av_frame_move_ref(af->frame, frame);
2102  frame_queue_push(&is->sampq);
2103 
2104 #if CONFIG_AVFILTER
2105  if (is->audioq.serial != is->auddec.pkt_serial)
2106  break;
2107  }
2108  if (ret == AVERROR_EOF)
2109  is->auddec.finished = is->auddec.pkt_serial;
2110 #endif
2111  }
2112  } while (ret >= 0 || ret == AVERROR(EAGAIN) || ret == AVERROR_EOF);
2113  the_end:
2114 #if CONFIG_AVFILTER
2115  avfilter_graph_free(&is->agraph);
2116 #endif
2117  av_frame_free(&frame);
2118  return ret;
2119 }
2120 
2121 static int decoder_start(Decoder *d, int (*fn)(void *), const char *thread_name, void* arg)
2122 {
2124  d->decoder_tid = SDL_CreateThread(fn, thread_name, arg);
2125  if (!d->decoder_tid) {
2126  av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
2127  return AVERROR(ENOMEM);
2128  }
2129  return 0;
2130 }
2131 
2132 static int video_thread(void *arg)
2133 {
2134  VideoState *is = arg;
2135  AVFrame *frame = av_frame_alloc();
2136  double pts;
2137  double duration;
2138  int ret;
2140  AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
2141 
2142 #if CONFIG_AVFILTER
2143  AVFilterGraph *graph = NULL;
2144  AVFilterContext *filt_out = NULL, *filt_in = NULL;
2145  int last_w = 0;
2146  int last_h = 0;
2147  enum AVPixelFormat last_format = -2;
2148  int last_serial = -1;
2149  int last_vfilter_idx = 0;
2150 #endif
2151 
2152  if (!frame)
2153  return AVERROR(ENOMEM);
2154 
2155  for (;;) {
2156  ret = get_video_frame(is, frame);
2157  if (ret < 0)
2158  goto the_end;
2159  if (!ret)
2160  continue;
2161 
2162 #if CONFIG_AVFILTER
2163  if ( last_w != frame->width
2164  || last_h != frame->height
2165  || last_format != frame->format
2166  || last_serial != is->viddec.pkt_serial
2167  || last_vfilter_idx != is->vfilter_idx) {
2169  "Video frame changed from size:%dx%d format:%s serial:%d to size:%dx%d format:%s serial:%d\n",
2170  last_w, last_h,
2171  (const char *)av_x_if_null(av_get_pix_fmt_name(last_format), "none"), last_serial,
2172  frame->width, frame->height,
2173  (const char *)av_x_if_null(av_get_pix_fmt_name(frame->format), "none"), is->viddec.pkt_serial);
2174  avfilter_graph_free(&graph);
2175  graph = avfilter_graph_alloc();
2176  if (!graph) {
2177  ret = AVERROR(ENOMEM);
2178  goto the_end;
2179  }
2180  graph->nb_threads = filter_nbthreads;
2181  if ((ret = configure_video_filters(graph, is, vfilters_list ? vfilters_list[is->vfilter_idx] : NULL, frame)) < 0) {
2182  SDL_Event event;
2183  event.type = FF_QUIT_EVENT;
2184  event.user.data1 = is;
2185  SDL_PushEvent(&event);
2186  goto the_end;
2187  }
2188  filt_in = is->in_video_filter;
2189  filt_out = is->out_video_filter;
2190  last_w = frame->width;
2191  last_h = frame->height;
2192  last_format = frame->format;
2193  last_serial = is->viddec.pkt_serial;
2194  last_vfilter_idx = is->vfilter_idx;
2195  frame_rate = av_buffersink_get_frame_rate(filt_out);
2196  }
2197 
2198  ret = av_buffersrc_add_frame(filt_in, frame);
2199  if (ret < 0)
2200  goto the_end;
2201 
2202  while (ret >= 0) {
2203  is->frame_last_returned_time = av_gettime_relative() / 1000000.0;
2204 
2205  ret = av_buffersink_get_frame_flags(filt_out, frame, 0);
2206  if (ret < 0) {
2207  if (ret == AVERROR_EOF)
2208  is->viddec.finished = is->viddec.pkt_serial;
2209  ret = 0;
2210  break;
2211  }
2212 
2215  is->frame_last_filter_delay = 0;
2216  tb = av_buffersink_get_time_base(filt_out);
2217 #endif
2218  duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
2219  pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
2220  ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
2221  av_frame_unref(frame);
2222 #if CONFIG_AVFILTER
2223  if (is->videoq.serial != is->viddec.pkt_serial)
2224  break;
2225  }
2226 #endif
2227 
2228  if (ret < 0)
2229  goto the_end;
2230  }
2231  the_end:
2232 #if CONFIG_AVFILTER
2233  avfilter_graph_free(&graph);
2234 #endif
2235  av_frame_free(&frame);
2236  return 0;
2237 }
2238 
2239 static int subtitle_thread(void *arg)
2240 {
2241  VideoState *is = arg;
2242  Frame *sp;
2243  int got_subtitle;
2244  double pts;
2245 
2246  for (;;) {
2247  if (!(sp = frame_queue_peek_writable(&is->subpq)))
2248  return 0;
2249 
2250  if ((got_subtitle = decoder_decode_frame(&is->subdec, NULL, &sp->sub)) < 0)
2251  break;
2252 
2253  pts = 0;
2254 
2255  if (got_subtitle && sp->sub.format == 0) {
2256  if (sp->sub.pts != AV_NOPTS_VALUE)
2257  pts = sp->sub.pts / (double)AV_TIME_BASE;
2258  sp->pts = pts;
2259  sp->serial = is->subdec.pkt_serial;
2260  sp->width = is->subdec.avctx->width;
2261  sp->height = is->subdec.avctx->height;
2262  sp->uploaded = 0;
2263 
2264  /* now we can update the picture count */
2265  frame_queue_push(&is->subpq);
2266  } else if (got_subtitle) {
2267  avsubtitle_free(&sp->sub);
2268  }
2269  }
2270  return 0;
2271 }
2272 
2273 /* copy samples for viewing in editor window */
2274 static void update_sample_display(VideoState *is, short *samples, int samples_size)
2275 {
2276  int size, len;
2277 
2278  size = samples_size / sizeof(short);
2279  while (size > 0) {
2281  if (len > size)
2282  len = size;
2283  memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
2284  samples += len;
2285  is->sample_array_index += len;
2287  is->sample_array_index = 0;
2288  size -= len;
2289  }
2290 }
2291 
2292 /* return the wanted number of samples to get better sync if sync_type is video
2293  * or external master clock */
2294 static int synchronize_audio(VideoState *is, int nb_samples)
2295 {
2296  int wanted_nb_samples = nb_samples;
2297 
2298  /* if not master, then we try to remove or add samples to correct the clock */
2300  double diff, avg_diff;
2301  int min_nb_samples, max_nb_samples;
2302 
2303  diff = get_clock(&is->audclk) - get_master_clock(is);
2304 
2305  if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {
2306  is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
2308  /* not enough measures to have a correct estimate */
2309  is->audio_diff_avg_count++;
2310  } else {
2311  /* estimate the A-V difference */
2312  avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
2313 
2314  if (fabs(avg_diff) >= is->audio_diff_threshold) {
2315  wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
2316  min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2317  max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
2318  wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
2319  }
2320  av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
2321  diff, avg_diff, wanted_nb_samples - nb_samples,
2323  }
2324  } else {
2325  /* too big difference : may be initial PTS errors, so
2326  reset A-V filter */
2327  is->audio_diff_avg_count = 0;
2328  is->audio_diff_cum = 0;
2329  }
2330  }
2331 
2332  return wanted_nb_samples;
2333 }
2334 
2335 /**
2336  * Decode one audio frame and return its uncompressed size.
2337  *
2338  * The processed audio frame is decoded, converted if required, and
2339  * stored in is->audio_buf, with size in bytes given by the return
2340  * value.
2341  */
2343 {
2344  int data_size, resampled_data_size;
2345  int64_t dec_channel_layout;
2346  av_unused double audio_clock0;
2347  int wanted_nb_samples;
2348  Frame *af;
2349 
2350  if (is->paused)
2351  return -1;
2352 
2353  do {
2354 #if defined(_WIN32)
2355  while (frame_queue_nb_remaining(&is->sampq) == 0) {
2357  return -1;
2358  av_usleep (1000);
2359  }
2360 #endif
2361  if (!(af = frame_queue_peek_readable(&is->sampq)))
2362  return -1;
2363  frame_queue_next(&is->sampq);
2364  } while (af->serial != is->audioq.serial);
2365 
2366  data_size = av_samples_get_buffer_size(NULL, af->frame->channels,
2367  af->frame->nb_samples,
2368  af->frame->format, 1);
2369 
2370  dec_channel_layout =
2373  wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
2374 
2375  if (af->frame->format != is->audio_src.fmt ||
2376  dec_channel_layout != is->audio_src.channel_layout ||
2377  af->frame->sample_rate != is->audio_src.freq ||
2378  (wanted_nb_samples != af->frame->nb_samples && !is->swr_ctx)) {
2379  swr_free(&is->swr_ctx);
2382  dec_channel_layout, af->frame->format, af->frame->sample_rate,
2383  0, NULL);
2384  if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
2386  "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
2389  swr_free(&is->swr_ctx);
2390  return -1;
2391  }
2392  is->audio_src.channel_layout = dec_channel_layout;
2393  is->audio_src.channels = af->frame->channels;
2394  is->audio_src.freq = af->frame->sample_rate;
2395  is->audio_src.fmt = af->frame->format;
2396  }
2397 
2398  if (is->swr_ctx) {
2399  const uint8_t **in = (const uint8_t **)af->frame->extended_data;
2400  uint8_t **out = &is->audio_buf1;
2401  int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate + 256;
2402  int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels, out_count, is->audio_tgt.fmt, 0);
2403  int len2;
2404  if (out_size < 0) {
2405  av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
2406  return -1;
2407  }
2408  if (wanted_nb_samples != af->frame->nb_samples) {
2409  if (swr_set_compensation(is->swr_ctx, (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq / af->frame->sample_rate,
2410  wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate) < 0) {
2411  av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
2412  return -1;
2413  }
2414  }
2415  av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
2416  if (!is->audio_buf1)
2417  return AVERROR(ENOMEM);
2418  len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
2419  if (len2 < 0) {
2420  av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
2421  return -1;
2422  }
2423  if (len2 == out_count) {
2424  av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
2425  if (swr_init(is->swr_ctx) < 0)
2426  swr_free(&is->swr_ctx);
2427  }
2428  is->audio_buf = is->audio_buf1;
2429  resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
2430  } else {
2431  is->audio_buf = af->frame->data[0];
2432  resampled_data_size = data_size;
2433  }
2434 
2435  audio_clock0 = is->audio_clock;
2436  /* update the audio clock with the pts */
2437  if (!isnan(af->pts))
2438  is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
2439  else
2440  is->audio_clock = NAN;
2441  is->audio_clock_serial = af->serial;
2442 #ifdef DEBUG
2443  {
2444  static double last_clock;
2445  printf("audio: delay=%0.3f clock=%0.3f clock0=%0.3f\n",
2446  is->audio_clock - last_clock,
2447  is->audio_clock, audio_clock0);
2448  last_clock = is->audio_clock;
2449  }
2450 #endif
2451  return resampled_data_size;
2452 }
2453 
2454 /* prepare a new audio buffer */
2455 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
2456 {
2457  VideoState *is = opaque;
2458  int audio_size, len1;
2459 
2461 
2462  while (len > 0) {
2463  if (is->audio_buf_index >= is->audio_buf_size) {
2464  audio_size = audio_decode_frame(is);
2465  if (audio_size < 0) {
2466  /* if error, just output silence */
2467  is->audio_buf = NULL;
2469  } else {
2470  if (is->show_mode != SHOW_MODE_VIDEO)
2471  update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
2472  is->audio_buf_size = audio_size;
2473  }
2474  is->audio_buf_index = 0;
2475  }
2476  len1 = is->audio_buf_size - is->audio_buf_index;
2477  if (len1 > len)
2478  len1 = len;
2479  if (!is->muted && is->audio_buf && is->audio_volume == SDL_MIX_MAXVOLUME)
2480  memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
2481  else {
2482  memset(stream, 0, len1);
2483  if (!is->muted && is->audio_buf)
2484  SDL_MixAudioFormat(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, is->audio_volume);
2485  }
2486  len -= len1;
2487  stream += len1;
2488  is->audio_buf_index += len1;
2489  }
2491  /* Let's assume the audio driver that is used by SDL has two periods. */
2492  if (!isnan(is->audio_clock)) {
2494  sync_clock_to_slave(&is->extclk, &is->audclk);
2495  }
2496 }
2497 
2498 static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
2499 {
2500  SDL_AudioSpec wanted_spec, spec;
2501  const char *env;
2502  static const int next_nb_channels[] = {0, 0, 1, 6, 2, 6, 4, 6};
2503  static const int next_sample_rates[] = {0, 44100, 48000, 96000, 192000};
2504  int next_sample_rate_idx = FF_ARRAY_ELEMS(next_sample_rates) - 1;
2505 
2506  env = SDL_getenv("SDL_AUDIO_CHANNELS");
2507  if (env) {
2508  wanted_nb_channels = atoi(env);
2509  wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2510  }
2511  if (!wanted_channel_layout || wanted_nb_channels != av_get_channel_layout_nb_channels(wanted_channel_layout)) {
2512  wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);
2513  wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
2514  }
2515  wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);
2516  wanted_spec.channels = wanted_nb_channels;
2517  wanted_spec.freq = wanted_sample_rate;
2518  if (wanted_spec.freq <= 0 || wanted_spec.channels <= 0) {
2519  av_log(NULL, AV_LOG_ERROR, "Invalid sample rate or channel count!\n");
2520  return -1;
2521  }
2522  while (next_sample_rate_idx && next_sample_rates[next_sample_rate_idx] >= wanted_spec.freq)
2523  next_sample_rate_idx--;
2524  wanted_spec.format = AUDIO_S16SYS;
2525  wanted_spec.silence = 0;
2526  wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
2527  wanted_spec.callback = sdl_audio_callback;
2528  wanted_spec.userdata = opaque;
2529  while (!(audio_dev = SDL_OpenAudioDevice(NULL, 0, &wanted_spec, &spec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE))) {
2530  av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
2531  wanted_spec.channels, wanted_spec.freq, SDL_GetError());
2532  wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
2533  if (!wanted_spec.channels) {
2534  wanted_spec.freq = next_sample_rates[next_sample_rate_idx--];
2535  wanted_spec.channels = wanted_nb_channels;
2536  if (!wanted_spec.freq) {
2538  "No more combinations to try, audio open failed\n");
2539  return -1;
2540  }
2541  }
2542  wanted_channel_layout = av_get_default_channel_layout(wanted_spec.channels);
2543  }
2544  if (spec.format != AUDIO_S16SYS) {
2546  "SDL advised audio format %d is not supported!\n", spec.format);
2547  return -1;
2548  }
2549  if (spec.channels != wanted_spec.channels) {
2550  wanted_channel_layout = av_get_default_channel_layout(spec.channels);
2551  if (!wanted_channel_layout) {
2553  "SDL advised channel count %d is not supported!\n", spec.channels);
2554  return -1;
2555  }
2556  }
2557 
2558  audio_hw_params->fmt = AV_SAMPLE_FMT_S16;
2559  audio_hw_params->freq = spec.freq;
2560  audio_hw_params->channel_layout = wanted_channel_layout;
2561  audio_hw_params->channels = spec.channels;
2562  audio_hw_params->frame_size = av_samples_get_buffer_size(NULL, audio_hw_params->channels, 1, audio_hw_params->fmt, 1);
2563  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);
2564  if (audio_hw_params->bytes_per_sec <= 0 || audio_hw_params->frame_size <= 0) {
2565  av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size failed\n");
2566  return -1;
2567  }
2568  return spec.size;
2569 }
2570 
2571 /* open a given stream. Return 0 if OK */
2572 static int stream_component_open(VideoState *is, int stream_index)
2573 {
2574  AVFormatContext *ic = is->ic;
2575  AVCodecContext *avctx;
2576  AVCodec *codec;
2577  const char *forced_codec_name = NULL;
2578  AVDictionary *opts = NULL;
2579  AVDictionaryEntry *t = NULL;
2580  int sample_rate, nb_channels;
2581  int64_t channel_layout;
2582  int ret = 0;
2583  int stream_lowres = lowres;
2584 
2585  if (stream_index < 0 || stream_index >= ic->nb_streams)
2586  return -1;
2587 
2588  avctx = avcodec_alloc_context3(NULL);
2589  if (!avctx)
2590  return AVERROR(ENOMEM);
2591 
2592  ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
2593  if (ret < 0)
2594  goto fail;
2595  avctx->pkt_timebase = ic->streams[stream_index]->time_base;
2596 
2597  codec = avcodec_find_decoder(avctx->codec_id);
2598 
2599  switch(avctx->codec_type){
2600  case AVMEDIA_TYPE_AUDIO : is->last_audio_stream = stream_index; forced_codec_name = audio_codec_name; break;
2601  case AVMEDIA_TYPE_SUBTITLE: is->last_subtitle_stream = stream_index; forced_codec_name = subtitle_codec_name; break;
2602  case AVMEDIA_TYPE_VIDEO : is->last_video_stream = stream_index; forced_codec_name = video_codec_name; break;
2603  }
2604  if (forced_codec_name)
2605  codec = avcodec_find_decoder_by_name(forced_codec_name);
2606  if (!codec) {
2607  if (forced_codec_name) av_log(NULL, AV_LOG_WARNING,
2608  "No codec could be found with name '%s'\n", forced_codec_name);
2609  else av_log(NULL, AV_LOG_WARNING,
2610  "No decoder could be found for codec %s\n", avcodec_get_name(avctx->codec_id));
2611  ret = AVERROR(EINVAL);
2612  goto fail;
2613  }
2614 
2615  avctx->codec_id = codec->id;
2616  if (stream_lowres > codec->max_lowres) {
2617  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2618  codec->max_lowres);
2619  stream_lowres = codec->max_lowres;
2620  }
2621  avctx->lowres = stream_lowres;
2622 
2623  if (fast)
2624  avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2625 
2626  opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], codec);
2627  if (!av_dict_get(opts, "threads", NULL, 0))
2628  av_dict_set(&opts, "threads", "auto", 0);
2629  if (stream_lowres)
2630  av_dict_set_int(&opts, "lowres", stream_lowres, 0);
2631  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
2632  av_dict_set(&opts, "refcounted_frames", "1", 0);
2633  if ((ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2634  goto fail;
2635  }
2636  if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2637  av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2639  goto fail;
2640  }
2641 
2642  is->eof = 0;
2643  ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2644  switch (avctx->codec_type) {
2645  case AVMEDIA_TYPE_AUDIO:
2646 #if CONFIG_AVFILTER
2647  {
2648  AVFilterContext *sink;
2649 
2650  is->audio_filter_src.freq = avctx->sample_rate;
2651  is->audio_filter_src.channels = avctx->channels;
2652  is->audio_filter_src.channel_layout = get_valid_channel_layout(avctx->channel_layout, avctx->channels);
2653  is->audio_filter_src.fmt = avctx->sample_fmt;
2654  if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
2655  goto fail;
2656  sink = is->out_audio_filter;
2657  sample_rate = av_buffersink_get_sample_rate(sink);
2658  nb_channels = av_buffersink_get_channels(sink);
2659  channel_layout = av_buffersink_get_channel_layout(sink);
2660  }
2661 #else
2662  sample_rate = avctx->sample_rate;
2663  nb_channels = avctx->channels;
2664  channel_layout = avctx->channel_layout;
2665 #endif
2666 
2667  /* prepare audio output */
2668  if ((ret = audio_open(is, channel_layout, nb_channels, sample_rate, &is->audio_tgt)) < 0)
2669  goto fail;
2670  is->audio_hw_buf_size = ret;
2671  is->audio_src = is->audio_tgt;
2672  is->audio_buf_size = 0;
2673  is->audio_buf_index = 0;
2674 
2675  /* init averaging filter */
2676  is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2677  is->audio_diff_avg_count = 0;
2678  /* since we do not have a precise anough audio FIFO fullness,
2679  we correct audio sync only if larger than this threshold */
2681 
2682  is->audio_stream = stream_index;
2683  is->audio_st = ic->streams[stream_index];
2684 
2685  if ((ret = decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread)) < 0)
2686  goto fail;
2688  is->auddec.start_pts = is->audio_st->start_time;
2690  }
2691  if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
2692  goto out;
2693  SDL_PauseAudioDevice(audio_dev, 0);
2694  break;
2695  case AVMEDIA_TYPE_VIDEO:
2696  is->video_stream = stream_index;
2697  is->video_st = ic->streams[stream_index];
2698 
2699  if ((ret = decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread)) < 0)
2700  goto fail;
2701  if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
2702  goto out;
2703  is->queue_attachments_req = 1;
2704  break;
2705  case AVMEDIA_TYPE_SUBTITLE:
2706  is->subtitle_stream = stream_index;
2707  is->subtitle_st = ic->streams[stream_index];
2708 
2709  if ((ret = decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread)) < 0)
2710  goto fail;
2711  if ((ret = decoder_start(&is->subdec, subtitle_thread, "subtitle_decoder", is)) < 0)
2712  goto out;
2713  break;
2714  default:
2715  break;
2716  }
2717  goto out;
2718 
2719 fail:
2720  avcodec_free_context(&avctx);
2721 out:
2722  av_dict_free(&opts);
2723 
2724  return ret;
2725 }
2726 
2727 static int decode_interrupt_cb(void *ctx)
2728 {
2729  VideoState *is = ctx;
2730  return is->abort_request;
2731 }
2732 
2733 static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue) {
2734  return stream_id < 0 ||
2735  queue->abort_request ||
2737  queue->nb_packets > MIN_FRAMES && (!queue->duration || av_q2d(st->time_base) * queue->duration > 1.0);
2738 }
2739 
2741 {
2742  if( !strcmp(s->iformat->name, "rtp")
2743  || !strcmp(s->iformat->name, "rtsp")
2744  || !strcmp(s->iformat->name, "sdp")
2745  )
2746  return 1;
2747 
2748  if(s->pb && ( !strncmp(s->url, "rtp:", 4)
2749  || !strncmp(s->url, "udp:", 4)
2750  )
2751  )
2752  return 1;
2753  return 0;
2754 }
2755 
2756 /* this thread gets the stream from the disk or the network */
2757 static int read_thread(void *arg)
2758 {
2759  VideoState *is = arg;
2760  AVFormatContext *ic = NULL;
2761  int err, i, ret;
2762  int st_index[AVMEDIA_TYPE_NB];
2763  AVPacket *pkt = NULL;
2764  int64_t stream_start_time;
2765  int pkt_in_play_range = 0;
2766  AVDictionaryEntry *t;
2767  SDL_mutex *wait_mutex = SDL_CreateMutex();
2768  int scan_all_pmts_set = 0;
2769  int64_t pkt_ts;
2770 
2771  if (!wait_mutex) {
2772  av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
2773  ret = AVERROR(ENOMEM);
2774  goto fail;
2775  }
2776 
2777  memset(st_index, -1, sizeof(st_index));
2778  is->eof = 0;
2779 
2780  pkt = av_packet_alloc();
2781  if (!pkt) {
2782  av_log(NULL, AV_LOG_FATAL, "Could not allocate packet.\n");
2783  ret = AVERROR(ENOMEM);
2784  goto fail;
2785  }
2786  ic = avformat_alloc_context();
2787  if (!ic) {
2788  av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2789  ret = AVERROR(ENOMEM);
2790  goto fail;
2791  }
2794  if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
2795  av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
2796  scan_all_pmts_set = 1;
2797  }
2798  err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2799  if (err < 0) {
2800  print_error(is->filename, err);
2801  ret = -1;
2802  goto fail;
2803  }
2804  if (scan_all_pmts_set)
2805  av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
2806 
2808  av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2810  goto fail;
2811  }
2812  is->ic = ic;
2813 
2814  if (genpts)
2815  ic->flags |= AVFMT_FLAG_GENPTS;
2816 
2818 
2819  if (find_stream_info) {
2821  int orig_nb_streams = ic->nb_streams;
2822 
2823  err = avformat_find_stream_info(ic, opts);
2824 
2825  for (i = 0; i < orig_nb_streams; i++)
2826  av_dict_free(&opts[i]);
2827  av_freep(&opts);
2828 
2829  if (err < 0) {
2831  "%s: could not find codec parameters\n", is->filename);
2832  ret = -1;
2833  goto fail;
2834  }
2835  }
2836 
2837  if (ic->pb)
2838  ic->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use avio_feof() to test for the end
2839 
2840  if (seek_by_bytes < 0)
2841  seek_by_bytes = !!(ic->iformat->flags & AVFMT_TS_DISCONT) && strcmp("ogg", ic->iformat->name);
2842 
2843  is->max_frame_duration = (ic->iformat->flags & AVFMT_TS_DISCONT) ? 10.0 : 3600.0;
2844 
2845  if (!window_title && (t = av_dict_get(ic->metadata, "title", NULL, 0)))
2846  window_title = av_asprintf("%s - %s", t->value, input_filename);
2847 
2848  /* if seeking requested, we execute it */
2849  if (start_time != AV_NOPTS_VALUE) {
2850  int64_t timestamp;
2851 
2852  timestamp = start_time;
2853  /* add the stream start time */
2854  if (ic->start_time != AV_NOPTS_VALUE)
2855  timestamp += ic->start_time;
2856  ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2857  if (ret < 0) {
2858  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2859  is->filename, (double)timestamp / AV_TIME_BASE);
2860  }
2861  }
2862 
2863  is->realtime = is_realtime(ic);
2864 
2865  if (show_status)
2866  av_dump_format(ic, 0, is->filename, 0);
2867 
2868  for (i = 0; i < ic->nb_streams; i++) {
2869  AVStream *st = ic->streams[i];
2870  enum AVMediaType type = st->codecpar->codec_type;
2871  st->discard = AVDISCARD_ALL;
2872  if (type >= 0 && wanted_stream_spec[type] && st_index[type] == -1)
2873  if (avformat_match_stream_specifier(ic, st, wanted_stream_spec[type]) > 0)
2874  st_index[type] = i;
2875  }
2876  for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
2877  if (wanted_stream_spec[i] && st_index[i] == -1) {
2878  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));
2879  st_index[i] = INT_MAX;
2880  }
2881  }
2882 
2883  if (!video_disable)
2884  st_index[AVMEDIA_TYPE_VIDEO] =
2886  st_index[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
2887  if (!audio_disable)
2888  st_index[AVMEDIA_TYPE_AUDIO] =
2890  st_index[AVMEDIA_TYPE_AUDIO],
2891  st_index[AVMEDIA_TYPE_VIDEO],
2892  NULL, 0);
2894  st_index[AVMEDIA_TYPE_SUBTITLE] =
2896  st_index[AVMEDIA_TYPE_SUBTITLE],
2897  (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2898  st_index[AVMEDIA_TYPE_AUDIO] :
2899  st_index[AVMEDIA_TYPE_VIDEO]),
2900  NULL, 0);
2901 
2902  is->show_mode = show_mode;
2903  if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2904  AVStream *st = ic->streams[st_index[AVMEDIA_TYPE_VIDEO]];
2905  AVCodecParameters *codecpar = st->codecpar;
2907  if (codecpar->width)
2908  set_default_window_size(codecpar->width, codecpar->height, sar);
2909  }
2910 
2911  /* open the streams */
2912  if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2913  stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2914  }
2915 
2916  ret = -1;
2917  if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2918  ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2919  }
2920  if (is->show_mode == SHOW_MODE_NONE)
2921  is->show_mode = ret >= 0 ? SHOW_MODE_VIDEO : SHOW_MODE_RDFT;
2922 
2923  if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2924  stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2925  }
2926 
2927  if (is->video_stream < 0 && is->audio_stream < 0) {
2928  av_log(NULL, AV_LOG_FATAL, "Failed to open file '%s' or configure filtergraph\n",
2929  is->filename);
2930  ret = -1;
2931  goto fail;
2932  }
2933 
2934  if (infinite_buffer < 0 && is->realtime)
2935  infinite_buffer = 1;
2936 
2937  for (;;) {
2938  if (is->abort_request)
2939  break;
2940  if (is->paused != is->last_paused) {
2941  is->last_paused = is->paused;
2942  if (is->paused)
2943  is->read_pause_return = av_read_pause(ic);
2944  else
2945  av_read_play(ic);
2946  }
2947 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
2948  if (is->paused &&
2949  (!strcmp(ic->iformat->name, "rtsp") ||
2950  (ic->pb && !strncmp(input_filename, "mmsh:", 5)))) {
2951  /* wait 10 ms to avoid trying to get another packet */
2952  /* XXX: horrible */
2953  SDL_Delay(10);
2954  continue;
2955  }
2956 #endif
2957  if (is->seek_req) {
2958  int64_t seek_target = is->seek_pos;
2959  int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2960  int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2961 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2962 // of the seek_pos/seek_rel variables
2963 
2964  ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2965  if (ret < 0) {
2967  "%s: error while seeking\n", is->ic->url);
2968  } else {
2969  if (is->audio_stream >= 0)
2970  packet_queue_flush(&is->audioq);
2971  if (is->subtitle_stream >= 0)
2973  if (is->video_stream >= 0)
2974  packet_queue_flush(&is->videoq);
2975  if (is->seek_flags & AVSEEK_FLAG_BYTE) {
2976  set_clock(&is->extclk, NAN, 0);
2977  } else {
2978  set_clock(&is->extclk, seek_target / (double)AV_TIME_BASE, 0);
2979  }
2980  }
2981  is->seek_req = 0;
2982  is->queue_attachments_req = 1;
2983  is->eof = 0;
2984  if (is->paused)
2985  step_to_next_frame(is);
2986  }
2987  if (is->queue_attachments_req) {
2989  if ((ret = av_packet_ref(pkt, &is->video_st->attached_pic)) < 0)
2990  goto fail;
2991  packet_queue_put(&is->videoq, pkt);
2993  }
2994  is->queue_attachments_req = 0;
2995  }
2996 
2997  /* if the queue are full, no need to read more */
2998  if (infinite_buffer<1 &&
2999  (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
3000  || (stream_has_enough_packets(is->audio_st, is->audio_stream, &is->audioq) &&
3003  /* wait 10 ms */
3004  SDL_LockMutex(wait_mutex);
3005  SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3006  SDL_UnlockMutex(wait_mutex);
3007  continue;
3008  }
3009  if (!is->paused &&
3010  (!is->audio_st || (is->auddec.finished == is->audioq.serial && frame_queue_nb_remaining(&is->sampq) == 0)) &&
3011  (!is->video_st || (is->viddec.finished == is->videoq.serial && frame_queue_nb_remaining(&is->pictq) == 0))) {
3012  if (loop != 1 && (!loop || --loop)) {
3013  stream_seek(is, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
3014  } else if (autoexit) {
3015  ret = AVERROR_EOF;
3016  goto fail;
3017  }
3018  }
3019  ret = av_read_frame(ic, pkt);
3020  if (ret < 0) {
3021  if ((ret == AVERROR_EOF || avio_feof(ic->pb)) && !is->eof) {
3022  if (is->video_stream >= 0)
3024  if (is->audio_stream >= 0)
3026  if (is->subtitle_stream >= 0)
3028  is->eof = 1;
3029  }
3030  if (ic->pb && ic->pb->error) {
3031  if (autoexit)
3032  goto fail;
3033  else
3034  break;
3035  }
3036  SDL_LockMutex(wait_mutex);
3037  SDL_CondWaitTimeout(is->continue_read_thread, wait_mutex, 10);
3038  SDL_UnlockMutex(wait_mutex);
3039  continue;
3040  } else {
3041  is->eof = 0;
3042  }
3043  /* check if packet is in play range specified by user, then queue, otherwise discard */
3044  stream_start_time = ic->streams[pkt->stream_index]->start_time;
3045  pkt_ts = pkt->pts == AV_NOPTS_VALUE ? pkt->dts : pkt->pts;
3046  pkt_in_play_range = duration == AV_NOPTS_VALUE ||
3047  (pkt_ts - (stream_start_time != AV_NOPTS_VALUE ? stream_start_time : 0)) *
3048  av_q2d(ic->streams[pkt->stream_index]->time_base) -
3049  (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
3050  <= ((double)duration / 1000000);
3051  if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
3052  packet_queue_put(&is->audioq, pkt);
3053  } else if (pkt->stream_index == is->video_stream && pkt_in_play_range
3055  packet_queue_put(&is->videoq, pkt);
3056  } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
3057  packet_queue_put(&is->subtitleq, pkt);
3058  } else {
3059  av_packet_unref(pkt);
3060  }
3061  }
3062 
3063  ret = 0;
3064  fail:
3065  if (ic && !is->ic)
3066  avformat_close_input(&ic);
3067 
3068  av_packet_free(&pkt);
3069  if (ret != 0) {
3070  SDL_Event event;
3071 
3072  event.type = FF_QUIT_EVENT;
3073  event.user.data1 = is;
3074  SDL_PushEvent(&event);
3075  }
3076  SDL_DestroyMutex(wait_mutex);
3077  return 0;
3078 }
3079 
3080 static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
3081 {
3082  VideoState *is;
3083 
3084  is = av_mallocz(sizeof(VideoState));
3085  if (!is)
3086  return NULL;
3087  is->last_video_stream = is->video_stream = -1;
3088  is->last_audio_stream = is->audio_stream = -1;
3089  is->last_subtitle_stream = is->subtitle_stream = -1;
3090  is->filename = av_strdup(filename);
3091  if (!is->filename)
3092  goto fail;
3093  is->iformat = iformat;
3094  is->ytop = 0;
3095  is->xleft = 0;
3096 
3097  /* start video display */
3098  if (frame_queue_init(&is->pictq, &is->videoq, VIDEO_PICTURE_QUEUE_SIZE, 1) < 0)
3099  goto fail;
3100  if (frame_queue_init(&is->subpq, &is->subtitleq, SUBPICTURE_QUEUE_SIZE, 0) < 0)
3101  goto fail;
3102  if (frame_queue_init(&is->sampq, &is->audioq, SAMPLE_QUEUE_SIZE, 1) < 0)
3103  goto fail;
3104 
3105  if (packet_queue_init(&is->videoq) < 0 ||
3106  packet_queue_init(&is->audioq) < 0 ||
3107  packet_queue_init(&is->subtitleq) < 0)
3108  goto fail;
3109 
3110  if (!(is->continue_read_thread = SDL_CreateCond())) {
3111  av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
3112  goto fail;
3113  }
3114 
3115  init_clock(&is->vidclk, &is->videoq.serial);
3116  init_clock(&is->audclk, &is->audioq.serial);
3117  init_clock(&is->extclk, &is->extclk.serial);
3118  is->audio_clock_serial = -1;
3119  if (startup_volume < 0)
3120  av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
3121  if (startup_volume > 100)
3122  av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
3124  startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
3126  is->muted = 0;
3127  is->av_sync_type = av_sync_type;
3128  is->read_tid = SDL_CreateThread(read_thread, "read_thread", is);
3129  if (!is->read_tid) {
3130  av_log(NULL, AV_LOG_FATAL, "SDL_CreateThread(): %s\n", SDL_GetError());
3131 fail:
3132  stream_close(is);
3133  return NULL;
3134  }
3135  return is;
3136 }
3137 
3139 {
3140  AVFormatContext *ic = is->ic;
3141  int start_index, stream_index;
3142  int old_index;
3143  AVStream *st;
3144  AVProgram *p = NULL;
3145  int nb_streams = is->ic->nb_streams;
3146 
3147  if (codec_type == AVMEDIA_TYPE_VIDEO) {
3148  start_index = is->last_video_stream;
3149  old_index = is->video_stream;
3150  } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
3151  start_index = is->last_audio_stream;
3152  old_index = is->audio_stream;
3153  } else {
3154  start_index = is->last_subtitle_stream;
3155  old_index = is->subtitle_stream;
3156  }
3157  stream_index = start_index;
3158 
3159  if (codec_type != AVMEDIA_TYPE_VIDEO && is->video_stream != -1) {
3161  if (p) {
3162  nb_streams = p->nb_stream_indexes;
3163  for (start_index = 0; start_index < nb_streams; start_index++)
3164  if (p->stream_index[start_index] == stream_index)
3165  break;
3166  if (start_index == nb_streams)
3167  start_index = -1;
3168  stream_index = start_index;
3169  }
3170  }
3171 
3172  for (;;) {
3173  if (++stream_index >= nb_streams)
3174  {
3175  if (codec_type == AVMEDIA_TYPE_SUBTITLE)
3176  {
3177  stream_index = -1;
3178  is->last_subtitle_stream = -1;
3179  goto the_end;
3180  }
3181  if (start_index == -1)
3182  return;
3183  stream_index = 0;
3184  }
3185  if (stream_index == start_index)
3186  return;
3187  st = is->ic->streams[p ? p->stream_index[stream_index] : stream_index];
3188  if (st->codecpar->codec_type == codec_type) {
3189  /* check that parameters are OK */
3190  switch (codec_type) {
3191  case AVMEDIA_TYPE_AUDIO:
3192  if (st->codecpar->sample_rate != 0 &&
3193  st->codecpar->channels != 0)
3194  goto the_end;
3195  break;
3196  case AVMEDIA_TYPE_VIDEO:
3197  case AVMEDIA_TYPE_SUBTITLE:
3198  goto the_end;
3199  default:
3200  break;
3201  }
3202  }
3203  }
3204  the_end:
3205  if (p && stream_index != -1)
3206  stream_index = p->stream_index[stream_index];
3207  av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
3208  av_get_media_type_string(codec_type),
3209  old_index,
3210  stream_index);
3211 
3212  stream_component_close(is, old_index);
3213  stream_component_open(is, stream_index);
3214 }
3215 
3216 
3218 {
3220  SDL_SetWindowFullscreen(window, is_full_screen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
3221 }
3222 
3224 {
3225  int next = is->show_mode;
3226  do {
3227  next = (next + 1) % SHOW_MODE_NB;
3228  } while (next != is->show_mode && (next == SHOW_MODE_VIDEO && !is->video_st || next != SHOW_MODE_VIDEO && !is->audio_st));
3229  if (is->show_mode != next) {
3230  is->force_refresh = 1;
3231  is->show_mode = next;
3232  }
3233 }
3234 
3235 static void refresh_loop_wait_event(VideoState *is, SDL_Event *event) {
3236  double remaining_time = 0.0;
3237  SDL_PumpEvents();
3238  while (!SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
3240  SDL_ShowCursor(0);
3241  cursor_hidden = 1;
3242  }
3243  if (remaining_time > 0.0)
3244  av_usleep((int64_t)(remaining_time * 1000000.0));
3245  remaining_time = REFRESH_RATE;
3246  if (is->show_mode != SHOW_MODE_NONE && (!is->paused || is->force_refresh))
3247  video_refresh(is, &remaining_time);
3248  SDL_PumpEvents();
3249  }
3250 }
3251 
3252 static void seek_chapter(VideoState *is, int incr)
3253 {
3254  int64_t pos = get_master_clock(is) * AV_TIME_BASE;
3255  int i;
3256 
3257  if (!is->ic->nb_chapters)
3258  return;
3259 
3260  /* find the current chapter */
3261  for (i = 0; i < is->ic->nb_chapters; i++) {
3262  AVChapter *ch = is->ic->chapters[i];
3263  if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
3264  i--;
3265  break;
3266  }
3267  }
3268 
3269  i += incr;
3270  i = FFMAX(i, 0);
3271  if (i >= is->ic->nb_chapters)
3272  return;
3273 
3274  av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
3275  stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
3276  AV_TIME_BASE_Q), 0, 0);
3277 }
3278 
3279 /* handle an event sent by the GUI */
3280 static void event_loop(VideoState *cur_stream)
3281 {
3282  SDL_Event event;
3283  double incr, pos, frac;
3284 
3285  for (;;) {
3286  double x;
3287  refresh_loop_wait_event(cur_stream, &event);
3288  switch (event.type) {
3289  case SDL_KEYDOWN:
3290  if (exit_on_keydown || event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) {
3291  do_exit(cur_stream);
3292  break;
3293  }
3294  // If we don't yet have a window, skip all key events, because read_thread might still be initializing...
3295  if (!cur_stream->width)
3296  continue;
3297  switch (event.key.keysym.sym) {
3298  case SDLK_f:
3299  toggle_full_screen(cur_stream);
3300  cur_stream->force_refresh = 1;
3301  break;
3302  case SDLK_p:
3303  case SDLK_SPACE:
3304  toggle_pause(cur_stream);
3305  break;
3306  case SDLK_m:
3307  toggle_mute(cur_stream);
3308  break;
3309  case SDLK_KP_MULTIPLY:
3310  case SDLK_0:
3311  update_volume(cur_stream, 1, SDL_VOLUME_STEP);
3312  break;
3313  case SDLK_KP_DIVIDE:
3314  case SDLK_9:
3315  update_volume(cur_stream, -1, SDL_VOLUME_STEP);
3316  break;
3317  case SDLK_s: // S: Step to next frame
3318  step_to_next_frame(cur_stream);
3319  break;
3320  case SDLK_a:
3322  break;
3323  case SDLK_v:
3325  break;
3326  case SDLK_c:
3330  break;
3331  case SDLK_t:
3333  break;
3334  case SDLK_w:
3335 #if CONFIG_AVFILTER
3336  if (cur_stream->show_mode == SHOW_MODE_VIDEO && cur_stream->vfilter_idx < nb_vfilters - 1) {
3337  if (++cur_stream->vfilter_idx >= nb_vfilters)
3338  cur_stream->vfilter_idx = 0;
3339  } else {
3340  cur_stream->vfilter_idx = 0;
3341  toggle_audio_display(cur_stream);
3342  }
3343 #else
3344  toggle_audio_display(cur_stream);
3345 #endif
3346  break;
3347  case SDLK_PAGEUP:
3348  if (cur_stream->ic->nb_chapters <= 1) {
3349  incr = 600.0;
3350  goto do_seek;
3351  }
3352  seek_chapter(cur_stream, 1);
3353  break;
3354  case SDLK_PAGEDOWN:
3355  if (cur_stream->ic->nb_chapters <= 1) {
3356  incr = -600.0;
3357  goto do_seek;
3358  }
3359  seek_chapter(cur_stream, -1);
3360  break;
3361  case SDLK_LEFT:
3362  incr = seek_interval ? -seek_interval : -10.0;
3363  goto do_seek;
3364  case SDLK_RIGHT:
3365  incr = seek_interval ? seek_interval : 10.0;
3366  goto do_seek;
3367  case SDLK_UP:
3368  incr = 60.0;
3369  goto do_seek;
3370  case SDLK_DOWN:
3371  incr = -60.0;
3372  do_seek:
3373  if (seek_by_bytes) {
3374  pos = -1;
3375  if (pos < 0 && cur_stream->video_stream >= 0)
3376  pos = frame_queue_last_pos(&cur_stream->pictq);
3377  if (pos < 0 && cur_stream->audio_stream >= 0)
3378  pos = frame_queue_last_pos(&cur_stream->sampq);
3379  if (pos < 0)
3380  pos = avio_tell(cur_stream->ic->pb);
3381  if (cur_stream->ic->bit_rate)
3382  incr *= cur_stream->ic->bit_rate / 8.0;
3383  else
3384  incr *= 180000.0;
3385  pos += incr;
3386  stream_seek(cur_stream, pos, incr, 1);
3387  } else {
3388  pos = get_master_clock(cur_stream);
3389  if (isnan(pos))
3390  pos = (double)cur_stream->seek_pos / AV_TIME_BASE;
3391  pos += incr;
3392  if (cur_stream->ic->start_time != AV_NOPTS_VALUE && pos < cur_stream->ic->start_time / (double)AV_TIME_BASE)
3393  pos = cur_stream->ic->start_time / (double)AV_TIME_BASE;
3394  stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
3395  }
3396  break;
3397  default:
3398  break;
3399  }
3400  break;
3401  case SDL_MOUSEBUTTONDOWN:
3402  if (exit_on_mousedown) {
3403  do_exit(cur_stream);
3404  break;
3405  }
3406  if (event.button.button == SDL_BUTTON_LEFT) {
3407  static int64_t last_mouse_left_click = 0;
3408  if (av_gettime_relative() - last_mouse_left_click <= 500000) {
3409  toggle_full_screen(cur_stream);
3410  cur_stream->force_refresh = 1;
3411  last_mouse_left_click = 0;
3412  } else {
3413  last_mouse_left_click = av_gettime_relative();
3414  }
3415  }
3416  case SDL_MOUSEMOTION:
3417  if (cursor_hidden) {
3418  SDL_ShowCursor(1);
3419  cursor_hidden = 0;
3420  }
3422  if (event.type == SDL_MOUSEBUTTONDOWN) {
3423  if (event.button.button != SDL_BUTTON_RIGHT)
3424  break;
3425  x = event.button.x;
3426  } else {
3427  if (!(event.motion.state & SDL_BUTTON_RMASK))
3428  break;
3429  x = event.motion.x;
3430  }
3431  if (seek_by_bytes || cur_stream->ic->duration <= 0) {
3432  uint64_t size = avio_size(cur_stream->ic->pb);
3433  stream_seek(cur_stream, size*x/cur_stream->width, 0, 1);
3434  } else {
3435  int64_t ts;
3436  int ns, hh, mm, ss;
3437  int tns, thh, tmm, tss;
3438  tns = cur_stream->ic->duration / 1000000LL;
3439  thh = tns / 3600;
3440  tmm = (tns % 3600) / 60;
3441  tss = (tns % 60);
3442  frac = x / cur_stream->width;
3443  ns = frac * tns;
3444  hh = ns / 3600;
3445  mm = (ns % 3600) / 60;
3446  ss = (ns % 60);
3448  "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
3449  hh, mm, ss, thh, tmm, tss);
3450  ts = frac * cur_stream->ic->duration;
3451  if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
3452  ts += cur_stream->ic->start_time;
3453  stream_seek(cur_stream, ts, 0, 0);
3454  }
3455  break;
3456  case SDL_WINDOWEVENT:
3457  switch (event.window.event) {
3458  case SDL_WINDOWEVENT_SIZE_CHANGED:
3459  screen_width = cur_stream->width = event.window.data1;
3460  screen_height = cur_stream->height = event.window.data2;
3461  if (cur_stream->vis_texture) {
3462  SDL_DestroyTexture(cur_stream->vis_texture);
3463  cur_stream->vis_texture = NULL;
3464  }
3465  case SDL_WINDOWEVENT_EXPOSED:
3466  cur_stream->force_refresh = 1;
3467  }
3468  break;
3469  case SDL_QUIT:
3470  case FF_QUIT_EVENT:
3471  do_exit(cur_stream);
3472  break;
3473  default:
3474  break;
3475  }
3476  }
3477 }
3478 
3479 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
3480 {
3481  av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
3482  return opt_default(NULL, "video_size", arg);
3483 }
3484 
3485 static int opt_width(void *optctx, const char *opt, const char *arg)
3486 {
3487  screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3488  return 0;
3489 }
3490 
3491 static int opt_height(void *optctx, const char *opt, const char *arg)
3492 {
3493  screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
3494  return 0;
3495 }
3496 
3497 static int opt_format(void *optctx, const char *opt, const char *arg)
3498 {
3499  file_iformat = av_find_input_format(arg);
3500  if (!file_iformat) {
3501  av_log(NULL, AV_LOG_FATAL, "Unknown input format: %s\n", arg);
3502  return AVERROR(EINVAL);
3503  }
3504  return 0;
3505 }
3506 
3507 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
3508 {
3509  av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
3510  return opt_default(NULL, "pixel_format", arg);
3511 }
3512 
3513 static int opt_sync(void *optctx, const char *opt, const char *arg)
3514 {
3515  if (!strcmp(arg, "audio"))
3517  else if (!strcmp(arg, "video"))
3519  else if (!strcmp(arg, "ext"))
3521  else {
3522  av_log(NULL, AV_LOG_ERROR, "Unknown value for %s: %s\n", opt, arg);
3523  exit(1);
3524  }
3525  return 0;
3526 }
3527 
3528 static int opt_seek(void *optctx, const char *opt, const char *arg)
3529 {
3530  start_time = parse_time_or_die(opt, arg, 1);
3531  return 0;
3532 }
3533 
3534 static int opt_duration(void *optctx, const char *opt, const char *arg)
3535 {
3536  duration = parse_time_or_die(opt, arg, 1);
3537  return 0;
3538 }
3539 
3540 static int opt_show_mode(void *optctx, const char *opt, const char *arg)
3541 {
3542  show_mode = !strcmp(arg, "video") ? SHOW_MODE_VIDEO :
3543  !strcmp(arg, "waves") ? SHOW_MODE_WAVES :
3544  !strcmp(arg, "rdft" ) ? SHOW_MODE_RDFT :
3545  parse_number_or_die(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1);
3546  return 0;
3547 }
3548 
3549 static void opt_input_file(void *optctx, const char *filename)
3550 {
3551  if (input_filename) {
3553  "Argument '%s' provided as input filename, but '%s' was already specified.\n",
3554  filename, input_filename);
3555  exit(1);
3556  }
3557  if (!strcmp(filename, "-"))
3558  filename = "pipe:";
3559  input_filename = filename;
3560 }
3561 
3562 static int opt_codec(void *optctx, const char *opt, const char *arg)
3563 {
3564  const char *spec = strchr(opt, ':');
3565  if (!spec) {
3567  "No media specifier was specified in '%s' in option '%s'\n",
3568  arg, opt);
3569  return AVERROR(EINVAL);
3570  }
3571  spec++;
3572  switch (spec[0]) {
3573  case 'a' : audio_codec_name = arg; break;
3574  case 's' : subtitle_codec_name = arg; break;
3575  case 'v' : video_codec_name = arg; break;
3576  default:
3578  "Invalid media specifier '%s' in option '%s'\n", spec, opt);
3579  return AVERROR(EINVAL);
3580  }
3581  return 0;
3582 }
3583 
3584 static int dummy;
3585 
3586 static const OptionDef options[] = {
3588  { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
3589  { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
3590  { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
3591  { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
3592  { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
3593  { "vn", OPT_BOOL, { &video_disable }, "disable video" },
3594  { "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" },
3595  { "ast", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
3596  { "vst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
3597  { "sst", OPT_STRING | HAS_ARG | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
3598  { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
3599  { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
3600  { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
3601  { "seek_interval", OPT_FLOAT | HAS_ARG, { &seek_interval }, "set seek interval for left/right keys, in seconds", "seconds" },
3602  { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
3603  { "noborder", OPT_BOOL, { &borderless }, "borderless window" },
3604  { "alwaysontop", OPT_BOOL, { &alwaysontop }, "window always on top" },
3605  { "volume", OPT_INT | HAS_ARG, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
3606  { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
3607  { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
3608  { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
3609  { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
3610  { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
3611  { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
3612  { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT, { &lowres }, "", "" },
3613  { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
3614  { "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" },
3615  { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
3616  { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
3617  { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
3618  { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
3619  { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
3620  { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
3621  { "left", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_left }, "set the x position for the left of the window", "x pos" },
3622  { "top", OPT_INT | HAS_ARG | OPT_EXPERT, { &screen_top }, "set the y position for the top of the window", "y pos" },
3623 #if CONFIG_AVFILTER
3624  { "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
3625  { "af", OPT_STRING | HAS_ARG, { &afilters }, "set audio filters", "filter_graph" },
3626 #endif
3627  { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
3628  { "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
3629  { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default }, "generic catch all option", "" },
3630  { "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"},
3631  { "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
3632  { "acodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
3633  { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
3634  { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
3635  { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
3636  { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3637  "read and decode the streams to fill missing information with heuristics" },
3638  { "filter_threads", HAS_ARG | OPT_INT | OPT_EXPERT, { &filter_nbthreads }, "number of filter threads per graph" },
3639  { NULL, },
3640 };
3641 
3642 static void show_usage(void)
3643 {
3644  av_log(NULL, AV_LOG_INFO, "Simple media player\n");
3645  av_log(NULL, AV_LOG_INFO, "usage: %s [options] input_file\n", program_name);
3646  av_log(NULL, AV_LOG_INFO, "\n");
3647 }
3648 
3649 void show_help_default(const char *opt, const char *arg)
3650 {
3652  show_usage();
3653  show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
3654  show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
3655  printf("\n");
3658 #if !CONFIG_AVFILTER
3660 #else
3662 #endif
3663  printf("\nWhile playing:\n"
3664  "q, ESC quit\n"
3665  "f toggle full screen\n"
3666  "p, SPC pause\n"
3667  "m toggle mute\n"
3668  "9, 0 decrease and increase volume respectively\n"
3669  "/, * decrease and increase volume respectively\n"
3670  "a cycle audio channel in the current program\n"
3671  "v cycle video channel\n"
3672  "t cycle subtitle channel in the current program\n"
3673  "c cycle program\n"
3674  "w cycle video filters or show modes\n"
3675  "s activate frame-step mode\n"
3676  "left/right seek backward/forward 10 seconds or to custom interval if -seek_interval is set\n"
3677  "down/up seek backward/forward 1 minute\n"
3678  "page down/page up seek backward/forward 10 minutes\n"
3679  "right mouse click seek to percentage in file corresponding to fraction of width\n"
3680  "left double-click toggle full screen\n"
3681  );
3682 }
3683 
3684 /* Called from the main */
3685 int main(int argc, char **argv)
3686 {
3687  int flags;
3688  VideoState *is;
3689 
3690  init_dynload();
3691 
3693  parse_loglevel(argc, argv, options);
3694 
3695  /* register all codecs, demux and protocols */
3696 #if CONFIG_AVDEVICE
3698 #endif
3700 
3701  init_opts();
3702 
3703  signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
3704  signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
3705 
3706  show_banner(argc, argv, options);
3707 
3708  parse_options(NULL, argc, argv, options, opt_input_file);
3709 
3710  if (!input_filename) {
3711  show_usage();
3712  av_log(NULL, AV_LOG_FATAL, "An input file must be specified\n");
3714  "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3715  exit(1);
3716  }
3717 
3718  if (display_disable) {
3719  video_disable = 1;
3720  }
3721  flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3722  if (audio_disable)
3723  flags &= ~SDL_INIT_AUDIO;
3724  else {
3725  /* Try to work around an occasional ALSA buffer underflow issue when the
3726  * period size is NPOT due to ALSA resampling by forcing the buffer size. */
3727  if (!SDL_getenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE"))
3728  SDL_setenv("SDL_AUDIO_ALSA_SET_BUFFER_SIZE","1", 1);
3729  }
3730  if (display_disable)
3731  flags &= ~SDL_INIT_VIDEO;
3732  if (SDL_Init (flags)) {
3733  av_log(NULL, AV_LOG_FATAL, "Could not initialize SDL - %s\n", SDL_GetError());
3734  av_log(NULL, AV_LOG_FATAL, "(Did you set the DISPLAY variable?)\n");
3735  exit(1);
3736  }
3737 
3738  SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3739  SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3740 
3741  if (!display_disable) {
3742  int flags = SDL_WINDOW_HIDDEN;
3743  if (alwaysontop)
3744 #if SDL_VERSION_ATLEAST(2,0,5)
3745  flags |= SDL_WINDOW_ALWAYS_ON_TOP;
3746 #else
3747  av_log(NULL, AV_LOG_WARNING, "Your SDL version doesn't support SDL_WINDOW_ALWAYS_ON_TOP. Feature will be inactive.\n");
3748 #endif
3749  if (borderless)
3750  flags |= SDL_WINDOW_BORDERLESS;
3751  else
3752  flags |= SDL_WINDOW_RESIZABLE;
3753  window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
3754  SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
3755  if (window) {
3756  renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
3757  if (!renderer) {
3758  av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
3759  renderer = SDL_CreateRenderer(window, -1, 0);
3760  }
3761  if (renderer) {
3762  if (!SDL_GetRendererInfo(renderer, &renderer_info))
3763  av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", renderer_info.name);
3764  }
3765  }
3766  if (!window || !renderer || !renderer_info.num_texture_formats) {
3767  av_log(NULL, AV_LOG_FATAL, "Failed to create window or renderer: %s", SDL_GetError());
3768  do_exit(NULL);
3769  }
3770  }
3771 
3772  is = stream_open(input_filename, file_iformat);
3773  if (!is) {
3774  av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");
3775  do_exit(NULL);
3776  }
3777 
3778  event_loop(is);
3779 
3780  /* never returns */
3781 
3782  return 0;
3783 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1472
#define EXTERNAL_CLOCK_SPEED_STEP
Definition: ffplay.c:96
AVFilterContext ** filters
Definition: avfilter.h:852
static void packet_queue_abort(PacketQueue *q)
Definition: ffplay.c:523
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:514
static int opt_show_mode(void *optctx, const char *opt, const char *arg)
Definition: ffplay.c:3540
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:117
static void frame_queue_push(FrameQueue *f)
Definition: ffplay.c:778
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
static SDL_AudioDeviceID audio_dev
Definition: ffplay.c:369
static void video_image_display(VideoState *is)
Definition: ffplay.c:975
#define NULL
Definition: coverity.c:32
Clock audclk
Definition: ffplay.c:220
static int filter_nbthreads
Definition: ffplay.c:358
int av_fifo_grow(AVFifoBuffer *f, unsigned int size)
Enlarge an AVFifoBuffer.
Definition: fifo.c:107
#define AVFMT_NOBINSEARCH
Format does not allow to fall back on binary search via read_timestamp.
Definition: avformat.h:468
static void packet_queue_flush(PacketQueue *q)
Definition: ffplay.c:499
int width
Definition: ffplay.c:293
#define OPT_EXPERT
Definition: cmdutils.h:163
static double get_clock(Clock *c)
Definition: ffplay.c:1375
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:346
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
enum AVSampleFormat fmt
Definition: ffplay.c:139
static int opt_height(void *optctx, const char *opt, const char *arg)
Definition: ffplay.c:3491
static const struct TextureFormatEntry sdl_texture_format_map[]
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffplay.c:66
SDL_cond * cond
Definition: ffplay.c:179
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:2091
static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb_channels, int wanted_sample_rate, struct AudioParams *audio_hw_params)
Definition: ffplay.c:2498
FrameQueue pictq
Definition: ffplay.c:224
static int screen_top
Definition: ffplay.c:319
Decoder auddec
Definition: ffplay.c:228
#define EXTERNAL_CLOCK_SPEED_MIN
Definition: ffplay.c:94
AVStream * subtitle_st
Definition: ffplay.c:278
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
#define VIDEO_PICTURE_QUEUE_SIZE
Definition: ffplay.c:130
static SDL_Renderer * renderer
Definition: ffplay.c:367
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2641
#define SWS_BICUBIC
Definition: swscale.h:60
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1521
double rdftspeed
Definition: ffplay.c:348
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
double frame_timer
Definition: ffplay.c:281
static AVInputFormat * file_iformat
Definition: ffplay.c:311
#define OPT_VIDEO
Definition: cmdutils.h:165
static void opt_input_file(void *optctx, const char *filename)
Definition: ffplay.c:3549
double get_rotation(AVStream *st)
Definition: cmdutils.c:2201
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:585
misc image utilities
static int opt_format(void *optctx, const char *opt, const char *arg)
Definition: ffplay.c:3497
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:83
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
AVRational next_pts_tb
Definition: ffplay.c:200
static int get_master_sync_type(VideoState *is)
Definition: ffplay.c:1423
Main libavfilter public API header.
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
int rindex
Definition: ffplay.c:172
#define AV_SYNC_FRAMEDUP_THRESHOLD
Definition: ffplay.c:86
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:79
static int default_height
Definition: ffplay.c:315
Memory buffer source API.
double frame_last_filter_delay
Definition: ffplay.c:283
FrameQueue sampq
Definition: ffplay.c:226
enum VideoState::ShowMode show_mode
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:212
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:518
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
int seek_flags
Definition: ffplay.c:213
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
Definition: avfilter.h:1024
#define av_opt_set_int_list(obj, name, val, term, flags)
Set a binary option to an integer list.
Definition: opt.h:728
int serial
Definition: ffplay.c:125
AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio...
Definition: utils.c:5079
#define OPT_AUDIO
Definition: cmdutils.h:166
static void stream_cycle_channel(VideoState *is, int codec_type)
Definition: ffplay.c:3138
int num
Numerator.
Definition: rational.h:59
static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
Definition: ffplay.c:3507
int size
Definition: packet.h:364
static void stream_toggle_pause(VideoState *is)
Definition: ffplay.c:1487
#define DEBUG
Definition: vf_framerate.c:29
static void stream_seek(VideoState *is, int64_t pos, int64_t rel, int seek_by_bytes)
Definition: ffplay.c:1473
int av_log2(unsigned v)
Definition: intmath.c:26
static int seek_by_bytes
Definition: ffplay.c:324
double audio_diff_cum
Definition: ffplay.c:238
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
#define REFRESH_RATE
Definition: ffplay.c:102
AVInputFormat * iformat
Definition: ffplay.c:206
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:519
enum AVMediaType codec_type
Definition: rtp.c:37
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1365
AVCodecContext * avctx
Definition: ffplay.c:192
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: cmdutils.c:1185
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
int paused
Definition: ffplay.c:209
AVPacket * pkt
Definition: ffplay.c:190
static int opt_codec(void *optctx, const char *opt, const char *arg)
Definition: ffplay.c:3562
static AVStream * video_stream
static unsigned sws_flags
Definition: ffplay.c:112
int abort_request
Definition: ffplay.c:124
GLint GLenum type
Definition: opengl_enc.c:104
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:505
unsigned num_rects
Definition: avcodec.h:2679
static void set_clock_at(Clock *c, double pts, int serial, double time)
Definition: ffplay.c:1387
static void toggle_pause(VideoState *is)
Definition: ffplay.c:1500
int out_size
Definition: movenc.c:55
double audio_diff_threshold
Definition: ffplay.c:240
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:582
#define FF_ARRAY_ELEMS(a)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
discard all
Definition: avcodec.h:236
int64_t channel_layout
Definition: ffplay.c:138
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:95
static int audio_disable
Definition: ffplay.c:320
AVStream * audio_st
Definition: ffplay.c:242
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1003
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:388
static const char * audio_codec_name
Definition: ffplay.c:345
#define fn(a)
#define OPT_FLOAT
Definition: cmdutils.h:168
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
int serial
Definition: ffplay.c:158
AVCodec.
Definition: codec.h:190
static void seek_chapter(VideoState *is, int incr)
Definition: ffplay.c:3252
double pts_drift
Definition: ffplay.c:146
#define CMDUTILS_COMMON_OPTIONS
Definition: cmdutils.h:215
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2105
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
int width
Definition: ffplay.c:162
functionally identical to above
Definition: pixfmt.h:520
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
Definition: avfilter.h:855
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
AVStream * video_st
Definition: ffplay.c:285
Clock extclk
Definition: ffplay.c:222
static VideoState * stream_open(const char *filename, AVInputFormat *iformat)
Definition: ffplay.c:3080
void * opaque
Definition: avio.h:60
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
struct SwsContext * img_convert_ctx
Definition: ffplay.c:288
AVSubtitleRect ** rects
Definition: avcodec.h:2680
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:971
Format I/O context.
Definition: avformat.h:1243
static void toggle_audio_display(VideoState *is)
Definition: ffplay.c:3223
AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
Definition: utils.c:5102
Definition: ffplay.c:155
memory buffer sink API for audio and video
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:310
int av_sync_type
Definition: ffplay.c:234
unsigned int nb_stream_indexes
Definition: avformat.h:1165
#define AV_LOG_QUIET
Print no output.
Definition: log.h:176
int rindex_shown
Definition: ffplay.c:177
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:2643
double pts
Definition: ffplay.c:159
int av_buffersink_get_sample_rate(const AVFilterContext *ctx)
Public dictionary API.
double audio_diff_avg_coef
Definition: ffplay.c:239
AVRational start_pts_tb
Definition: ffplay.c:198
static int read_thread(void *arg)
Definition: ffplay.c:2757
int keep_last
Definition: ffplay.c:176
static int decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond)
Definition: ffplay.c:578
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:135
int rdft_bits
Definition: ffplay.c:269
int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance)
Activate resampling compensation ("soft" compensation).
Definition: swresample.c:897
int size
Definition: ffplay.c:122
static Frame * frame_queue_peek(FrameQueue *f)
Definition: ffplay.c:731
static int64_t start_time
Definition: ffplay.c:332
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:64
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
The exact code depends on how similar the blocks are and how related they are to the block
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:96
uint8_t
static int nb_streams
Definition: ffprobe.c:283
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
Definition: cmdutils.c:543
static int default_width
Definition: ffplay.c:314
int last_video_stream
Definition: ffplay.c:305
int width
Video only.
Definition: codec_par.h:126
int last_subtitle_stream
Definition: ffplay.c:305
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:668
#define HAS_ARG
Definition: cmdutils.h:161
int audio_hw_buf_size
Definition: ffplay.c:244
static void stream_component_close(VideoState *is, int stream_index)
Definition: ffplay.c:1205
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
static int decode_interrupt_cb(void *ctx)
Definition: ffplay.c:2727
#define f(width, name)
Definition: cbs_vp9.c:255
int64_t duration
Definition: ffplay.c:123
struct SwrContext * swr_ctx
Definition: ffplay.c:258
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
int finished
Definition: ffplay.c:194
static void event_loop(VideoState *cur_stream)
Definition: ffplay.c:3280
static int cmp_audio_fmts(enum AVSampleFormat fmt1, int64_t channel_count1, enum AVSampleFormat fmt2, int64_t channel_count2)
Definition: ffplay.c:407
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
Definition: utils.c:5286
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:407
static void packet_queue_destroy(PacketQueue *q)
Definition: ffplay.c:515
int av_fifo_space(const AVFifoBuffer *f)
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write int...
Definition: fifo.c:82
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1375
static int framedrop
Definition: ffplay.c:342
SDL_Texture * vis_texture
Definition: ffplay.c:273
void init_opts(void)
Initialize the cmdutils option system, in particular allocate the *_opts contexts.
Definition: cmdutils.c:82
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1311
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2183
int bytes_per_sec
Definition: ffplay.c:141
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:211
int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx)
Create and add a filter instance into an existing graph.
static float seek_interval
Definition: ffplay.c:325
AVRational av_buffersink_get_frame_rate(const AVFilterContext *ctx)
static int64_t audio_callback_time
Definition: ffplay.c:362
#define height
#define av_clip
Definition: common.h:122
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
static int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
Definition: ffplay.c:418
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1374
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
Definition: ffplay.c:543
static void sigterm_handler(int sig)
Definition: ffplay.c:1320
uint8_t * data
Definition: packet.h:363
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, void(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:381
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:879
int freq
Definition: ffplay.c:136
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:664
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:5016
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:88
Frame queue[FRAME_QUEUE_SIZE]
Definition: ffplay.c:171
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define sp
Definition: regdef.h:63
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
Definition: ffplay.c:144
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1749
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:237
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the &#39;-loglevel&#39; option in the command line args and apply it.
Definition: cmdutils.c:504
external API header
#define AV_NOSYNC_THRESHOLD
Definition: ffplay.c:88
ptrdiff_t size
Definition: opengl_enc.c:100
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:2644
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:174
static int64_t duration
Definition: ffplay.c:333
channels
Definition: aptx.h:33
AVRational sar
Definition: ffplay.c:165
static int packet_queue_put_nullpacket(PacketQueue *q, AVPacket *pkt, int stream_index)
Definition: ffplay.c:472
unsigned int * stream_index
Definition: avformat.h:1164
#define av_log(a,...)
int(* callback)(void *)
Definition: avio.h:59
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:278
PacketQueue videoq
Definition: ffplay.c:286
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:615
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:2162
AVDictionary * format_opts
Definition: cmdutils.c:70
static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
Definition: ffplay.c:839
static int borderless
Definition: ffplay.c:327
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
#define SAMPLE_ARRAY_SIZE
Definition: ffplay.c:106
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
static void toggle_mute(VideoState *is)
Definition: ffplay.c:1506
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:640
Main libavdevice API header.
static int decoder_start(Decoder *d, int(*fn)(void *), const char *thread_name, void *arg)
Definition: ffplay.c:2121
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:4204
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2076
libswresample public header
enum AVCodecID id
Definition: codec.h:204
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
Definition: utils.c:4187
int audio_diff_avg_count
Definition: ffplay.c:241
int ytop
Definition: ffplay.c:293
int width
Definition: frame.h:372
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1483
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:375
int seek_req
Definition: ffplay.c:212
#define AV_PIX_FMT_NE(be, le)
Definition: pixfmt.h:369
#define FRAME_QUEUE_SIZE
Definition: ffplay.c:133
static void video_refresh(void *opaque, double *remaining_time)
Definition: ffplay.c:1575
int read_pause_return
Definition: ffplay.c:216
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:464
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:294
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2642
static AVStream * audio_stream
static void frame_queue_next(FrameQueue *f)
Definition: ffplay.c:788
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
The libswresample context.
#define MIN_FRAMES
Definition: ffplay.c:69
RDFTContext * rdft
Definition: ffplay.c:268
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1255
static int frame_queue_nb_remaining(FrameQueue *f)
Definition: ffplay.c:804
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
#define EXTERNAL_CLOCK_MAX_FRAMES
Definition: ffplay.c:71
char * url
input or output URL.
Definition: avformat.h:1339
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:624
static int autorotate
Definition: ffplay.c:356
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:558
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
#define CURSOR_HIDE_DELAY
Definition: ffplay.c:108
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
Definition: utils.c:4272
static double compute_target_delay(double delay, VideoState *is)
Definition: ffplay.c:1526
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
const char * arg
Definition: jacosubdec.c:66
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:586
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:569
static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
Definition: ffplay.c:426
AVChapter ** chapters
Definition: avformat.h:1473
#define AV_LOG_SKIP_REPEATED
Skip repeated messages, this requires the user app to use av_log() instead of (f)printf as the 2 woul...
Definition: log.h:384
simple assert() macros that are a bit more flexible than ISO C assert().
static void stream_close(VideoState *is)
Definition: ffplay.c:1262
int av_log_get_level(void)
Get the current log level.
Definition: log.c:435
static int find_stream_info
Definition: ffplay.c:357
#define AV_PIX_FMT_0BGR32
Definition: pixfmt.h:377
int video_stream
Definition: ffplay.c:284
static int video_open(VideoState *is)
Definition: ffplay.c:1337
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:49
int * queue_serial
Definition: ffplay.c:151
static void init_clock(Clock *c, int *queue_serial)
Definition: ffplay.c:1407
int xpos
Definition: ffplay.c:271
int channels
Definition: ffplay.c:137
static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pix_fmt, SDL_BlendMode *sdl_blendmode)
Definition: ffplay.c:890
static enum ShowMode show_mode
Definition: ffplay.c:344
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1160
#define FFMAX(a, b)
Definition: common.h:103
static void packet_queue_start(PacketQueue *q)
Definition: ffplay.c:534
static const OptionDef options[]
Definition: ffplay.c:3586
int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Get a frame with filtered data from sink and put it in frame.
Definition: buffersink.c:140
float FFTSample
Definition: avfft.h:35
static int dummy
Definition: ffplay.c:3584
#define fail()
Definition: checkasm.h:133
int8_t exp
Definition: eval.c:72
enum AVPixelFormat format
Definition: ffplay.c:372
double audio_clock
Definition: ffplay.c:236
int force_refresh
Definition: ffplay.c:208
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
AVDictionary * sws_dict
Definition: cmdutils.c:68
static int opt_sync(void *optctx, const char *opt, const char *arg)
Definition: ffplay.c:3513
struct SwsContext * sws_getCachedContext(struct SwsContext *context, int srcW, int srcH, enum AVPixelFormat srcFormat, int dstW, int dstH, enum AVPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param)
Check if context can be reused, otherwise reallocate a new one.
Definition: utils.c:2397
static void update_sample_display(VideoState *is, short *samples, int samples_size)
Definition: ffplay.c:2274
void av_rdft_calc(RDFTContext *s, FFTSample *data)
uint32_t end_display_time
Definition: avcodec.h:2678
static void decoder_destroy(Decoder *d)
Definition: ffplay.c:680
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2681
static int genpts
Definition: ffplay.c:335
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:491
int flip_v
Definition: ffplay.c:167
double frame_last_returned_time
Definition: ffplay.c:282
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:543
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:502
static const char * subtitle_codec_name
Definition: ffplay.c:346
static int subtitle_disable
Definition: ffplay.c:322
void av_format_inject_global_side_data(AVFormatContext *s)
This function will cause global side data to be injected in the next packet of each stream as well as...
Definition: utils.c:150
int max_size
Definition: ffplay.c:175
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1299
int step
Definition: ffplay.c:294
SDL_Thread * decoder_tid
Definition: ffplay.c:201
AVDictionary * opts
Definition: movenc.c:50
static SDL_Window * window
Definition: ffplay.c:366
const char program_name[]
program name, defined by the program for show_version().
Definition: ffplay.c:65
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
Definition: utils.c:4281
SDL_mutex * mutex
Definition: ffplay.c:126
static av_const double hypot(double x, double y)
Definition: libm.h:366
int audio_write_buf_size
Definition: ffplay.c:250
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
int linesize[4]
Definition: avcodec.h:2659
#define SAMPLE_QUEUE_SIZE
Definition: ffplay.c:132
#define b
Definition: input.c:41
int channels
number of audio channels, only used for audio.
Definition: frame.h:620
#define SUBPICTURE_QUEUE_SIZE
Definition: ffplay.c:131
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:397
#define AV_CH_LAYOUT_STEREO_DOWNMIX
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define NAN
Definition: mathematics.h:64
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:105
SDL_mutex * mutex
Definition: ffplay.c:178
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:455
int windex
Definition: ffplay.c:173
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:172
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
static int cursor_hidden
Definition: ffplay.c:350
#define width
AVSubtitle sub
Definition: ffplay.c:157
int width
picture width / height.
Definition: avcodec.h:704
uint8_t w
Definition: llviddspenc.c:39
int main(int argc, char **argv)
Definition: ffplay.c:3685
int height
Definition: ffplay.c:163
#define SDL_VOLUME_STEP
Definition: ffplay.c:79
static void show_usage(void)
Definition: ffplay.c:3642
int nb_packets
Definition: ffplay.c:121
static int opt_width(void *optctx, const char *opt, const char *arg)
Definition: ffplay.c:3485
static int get_video_frame(VideoState *is, AVFrame *frame)
Definition: ffplay.c:1775
int frame_drops_late
Definition: ffplay.c:260
struct AudioParams audio_src
Definition: ffplay.c:253
static void refresh_loop_wait_event(VideoState *is, SDL_Event *event)
Definition: ffplay.c:3235
static void set_clock_speed(Clock *c, double speed)
Definition: ffplay.c:1401
#define SDL_AUDIO_MAX_CALLBACKS_PER_SEC
Definition: ffplay.c:76
AVFormatContext * ctx
Definition: movenc.c:48
struct SwrContext * swr_alloc_set_opts(struct SwrContext *s, int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx)
Allocate SwrContext if needed and set/reset common parameters.
Definition: swresample.c:59
static int fast
Definition: ffplay.c:334
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2337
int last_i_start
Definition: ffplay.c:267
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
uint16_t format
Definition: avcodec.h:2676
#define s(width, name)
Definition: cbs_vp9.c:257
#define OPT_INT64
Definition: cmdutils.h:170
Definition: avfft.h:72
void av_rdft_end(RDFTContext *s)
static void step_to_next_frame(VideoState *is)
Definition: ffplay.c:1518
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
static int audio_decode_frame(VideoState *is)
Decode one audio frame and return its uncompressed size.
Definition: ffplay.c:2342
RDFTContext * av_rdft_init(int nbits, enum RDFTransformType trans)
Set up a real FFT.
static int is_full_screen
Definition: ffplay.c:361
#define AV_SYNC_THRESHOLD_MAX
Definition: ffplay.c:84
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:828
static int stream_has_enough_packets(AVStream *st, int stream_id, PacketQueue *queue)
Definition: ffplay.c:2733
static int startup_volume
Definition: ffplay.c:329
#define SDL_AUDIO_MIN_BUFFER_SIZE
Definition: ffplay.c:74
static int packet_queue_init(PacketQueue *q)
Definition: ffplay.c:479
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:2658
static int decoder_reorder_pts
Definition: ffplay.c:337
#define AUDIO_DIFF_AVG_NB
Definition: ffplay.c:99
static void set_clock(Clock *c, double pts, int serial)
Definition: ffplay.c:1395
int16_t sample_array[SAMPLE_ARRAY_SIZE]
Definition: ffplay.c:265
AVFilterContext * filter_ctx
filter context associated to this input/output
Definition: avfilter.h:1018
int paused
Definition: ffplay.c:150
static const char * input_filename
Definition: ffplay.c:312
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:852
Full range content.
Definition: pixfmt.h:586
static Frame * frame_queue_peek_last(FrameQueue *f)
Definition: ffplay.c:741
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffplay.c:3649
if(ret)
int64_t pos
Definition: ffplay.c:161
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
int last_audio_stream
Definition: ffplay.c:305
Stream structure.
Definition: avformat.h:884
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: utils.c:1093
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1645
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:1013
#define SAMPLE_CORRECTION_PERCENT_MAX
Definition: ffplay.c:91
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:387
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:392
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:561
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:374