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