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