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