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