Libav
avplay.c
Go to the documentation of this file.
1 /*
2  * avplay : Simple Media Player based on the Libav libraries
3  * Copyright (c) 2003 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "config.h"
23 #include <inttypes.h>
24 #include <math.h>
25 #include <limits.h>
26 #include <stdint.h>
27 
28 #include "libavutil/avstring.h"
29 #include "libavutil/colorspace.h"
30 #include "libavutil/display.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/dict.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/samplefmt.h"
37 #include "libavutil/time.h"
38 #include "libavformat/avformat.h"
39 #include "libavdevice/avdevice.h"
41 #include "libavutil/opt.h"
42 #include "libavcodec/avfft.h"
43 
44 #include "libavfilter/avfilter.h"
45 #include "libavfilter/buffersink.h"
46 #include "libavfilter/buffersrc.h"
47 
48 #include "cmdutils.h"
49 
50 #include <SDL.h>
51 #include <SDL_thread.h>
52 
53 #ifdef __MINGW32__
54 #undef main /* We don't want SDL to override our main() */
55 #endif
56 
57 #include <assert.h>
58 
59 const char program_name[] = "avplay";
60 const int program_birth_year = 2003;
61 
62 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
63 #define MIN_AUDIOQ_SIZE (20 * 16 * 1024)
64 #define MIN_FRAMES 5
65 
66 /* SDL audio buffer size, in samples. Should be small to have precise
67  A/V sync as SDL does not have hardware buffer fullness info. */
68 #define SDL_AUDIO_BUFFER_SIZE 1024
69 
70 /* no AV sync correction is done if below the AV sync threshold */
71 #define AV_SYNC_THRESHOLD 0.01
72 /* no AV correction is done if too big error */
73 #define AV_NOSYNC_THRESHOLD 10.0
74 
75 #define FRAME_SKIP_FACTOR 0.05
76 
77 /* maximum audio speed change to get correct sync */
78 #define SAMPLE_CORRECTION_PERCENT_MAX 10
79 
80 /* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
81 #define AUDIO_DIFF_AVG_NB 20
82 
83 /* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
84 #define SAMPLE_ARRAY_SIZE (2 * 65536)
85 
86 static int64_t sws_flags = SWS_BICUBIC;
87 
88 typedef struct PacketQueue {
91  int size;
93  SDL_mutex *mutex;
94  SDL_cond *cond;
95 } PacketQueue;
96 
97 #define VIDEO_PICTURE_QUEUE_SIZE 2
98 #define SUBPICTURE_QUEUE_SIZE 4
99 
100 typedef struct VideoPicture {
101  double pts; // presentation timestamp for this picture
102  double target_clock; // av_gettime_relative() time at which this should be displayed ideally
103  int64_t pos; // byte position in file
104  SDL_Overlay *bmp;
105  int width, height; /* source height & width */
109 
111 } VideoPicture;
112 
113 typedef struct SubPicture {
114  double pts; /* presentation time stamp for this picture */
116 } SubPicture;
117 
118 enum {
119  AV_SYNC_AUDIO_MASTER, /* default choice */
121  AV_SYNC_EXTERNAL_CLOCK, /* synchronize to an external clock */
122 };
123 
124 typedef struct PlayerState {
125  SDL_Thread *parse_tid;
126  SDL_Thread *video_tid;
127  SDL_Thread *refresh_tid;
131  int paused;
133  int seek_req;
135  int64_t seek_pos;
136  int64_t seek_rel;
139 
141 
143  double external_clock; /* external clock base */
145 
146  double audio_clock;
147  double audio_diff_cum; /* used for AV difference average computation */
158  unsigned int audio_buf_size; /* in bytes */
159  int audio_buf_index; /* in bytes */
162  enum AVSampleFormat sdl_sample_fmt;
166  enum AVSampleFormat resample_sample_fmt;
171 
172  int show_audio; /* if true, display audio samples */
173  int16_t sample_array[SAMPLE_ARRAY_SIZE];
179  int xpos;
180 
181  SDL_Thread *subtitle_tid;
188  int subpq_size, subpq_rindex, subpq_windex;
189  SDL_mutex *subpq_mutex;
190  SDL_cond *subpq_cond;
191 
192  double frame_timer;
195  double video_clock; // pts of last decoded frame / predicted pts of next decoded frame
200  double video_current_pts; // current displayed pts (different from video_clock if frame fifos are used)
201  double video_current_pts_drift; // video_current_pts - time (av_gettime_relative) at which we updated video_current_pts - used to have running video pts
202  int64_t video_current_pos; // current displayed file pos
204  int pictq_size, pictq_rindex, pictq_windex;
205  SDL_mutex *pictq_mutex;
206  SDL_cond *pictq_cond;
207 
208  // QETimer *video_timer;
209  char filename[1024];
210  int width, height, xleft, ytop;
211 
213 
214  AVFilterContext *in_video_filter; // the first filter in the video chain
215  AVFilterContext *out_video_filter; // the last filter in the video chain
216  SDL_mutex *video_filter_mutex;
217 
218  float skip_frames;
220  int refresh;
221 
224 } PlayerState;
225 
226 /* options specified by the user */
228 static const char *input_filename;
229 static const char *window_title;
230 static int fs_screen_width;
231 static int fs_screen_height;
232 static int screen_width = 0;
233 static int screen_height = 0;
234 static int audio_disable;
235 static int video_disable;
237  [AVMEDIA_TYPE_AUDIO] = -1,
238  [AVMEDIA_TYPE_VIDEO] = -1,
239  [AVMEDIA_TYPE_SUBTITLE] = -1,
240 };
241 static int seek_by_bytes = -1;
242 static int display_disable;
243 static int show_status = 1;
245 static int64_t start_time = AV_NOPTS_VALUE;
246 static int64_t duration = AV_NOPTS_VALUE;
247 static int step = 0;
248 static int workaround_bugs = 1;
249 static int fast = 0;
250 static int genpts = 0;
251 static int idct = FF_IDCT_AUTO;
255 static int error_concealment = 3;
256 static int decoder_reorder_pts = -1;
257 static int noautoexit;
258 static int exit_on_keydown;
259 static int exit_on_mousedown;
260 static int loop = 1;
261 static int framedrop = 1;
262 static int infinite_buffer = 0;
263 
264 static int rdftspeed = 20;
265 static char *vfilters = NULL;
266 static int autorotate = 1;
267 
268 /* current context */
269 static int is_full_screen;
272 static int64_t audio_callback_time;
273 
275 
276 #define FF_ALLOC_EVENT (SDL_USEREVENT)
277 #define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
278 #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
279 
280 static SDL_Surface *screen;
281 
282 static int packet_queue_put(PacketQueue *q, AVPacket *pkt);
283 
284 /* packet queue handling */
286 {
287  memset(q, 0, sizeof(PacketQueue));
288  q->mutex = SDL_CreateMutex();
289  q->cond = SDL_CreateCond();
290  packet_queue_put(q, &flush_pkt);
291 }
292 
294 {
295  AVPacketList *pkt, *pkt1;
296 
297  SDL_LockMutex(q->mutex);
298  for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
299  pkt1 = pkt->next;
300  av_packet_unref(&pkt->pkt);
301  av_freep(&pkt);
302  }
303  q->last_pkt = NULL;
304  q->first_pkt = NULL;
305  q->nb_packets = 0;
306  q->size = 0;
307  SDL_UnlockMutex(q->mutex);
308 }
309 
311 {
313  SDL_DestroyMutex(q->mutex);
314  SDL_DestroyCond(q->cond);
315 }
316 
318 {
319  AVPacketList *pkt1;
320 
321  pkt1 = av_malloc(sizeof(AVPacketList));
322  if (!pkt1)
323  return -1;
324  pkt1->pkt = *pkt;
325  pkt1->next = NULL;
326 
327 
328  SDL_LockMutex(q->mutex);
329 
330  if (!q->last_pkt)
331 
332  q->first_pkt = pkt1;
333  else
334  q->last_pkt->next = pkt1;
335  q->last_pkt = pkt1;
336  q->nb_packets++;
337  q->size += pkt1->pkt.size + sizeof(*pkt1);
338  /* XXX: should duplicate packet data in DV case */
339  SDL_CondSignal(q->cond);
340 
341  SDL_UnlockMutex(q->mutex);
342  return 0;
343 }
344 
346 {
347  SDL_LockMutex(q->mutex);
348 
349  q->abort_request = 1;
350 
351  SDL_CondSignal(q->cond);
352 
353  SDL_UnlockMutex(q->mutex);
354 }
355 
356 /* return < 0 if aborted, 0 if no packet and > 0 if packet. */
357 static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
358 {
359  AVPacketList *pkt1;
360  int ret;
361 
362  SDL_LockMutex(q->mutex);
363 
364  for (;;) {
365  if (q->abort_request) {
366  ret = -1;
367  break;
368  }
369 
370  pkt1 = q->first_pkt;
371  if (pkt1) {
372  q->first_pkt = pkt1->next;
373  if (!q->first_pkt)
374  q->last_pkt = NULL;
375  q->nb_packets--;
376  q->size -= pkt1->pkt.size + sizeof(*pkt1);
377  *pkt = pkt1->pkt;
378  av_free(pkt1);
379  ret = 1;
380  break;
381  } else if (!block) {
382  ret = 0;
383  break;
384  } else {
385  SDL_CondWait(q->cond, q->mutex);
386  }
387  }
388  SDL_UnlockMutex(q->mutex);
389  return ret;
390 }
391 
392 static inline void fill_rectangle(SDL_Surface *screen,
393  int x, int y, int w, int h, int color)
394 {
395  SDL_Rect rect;
396  rect.x = x;
397  rect.y = y;
398  rect.w = w;
399  rect.h = h;
400  SDL_FillRect(screen, &rect, color);
401 }
402 
403 #define ALPHA_BLEND(a, oldp, newp, s)\
404 ((((oldp << s) * (255 - (a))) + (newp * (a))) / (255 << s))
405 
406 #define RGBA_IN(r, g, b, a, s)\
407 {\
408  unsigned int v = ((const uint32_t *)(s))[0];\
409  a = (v >> 24) & 0xff;\
410  r = (v >> 16) & 0xff;\
411  g = (v >> 8) & 0xff;\
412  b = v & 0xff;\
413 }
414 
415 #define YUVA_IN(y, u, v, a, s, pal)\
416 {\
417  unsigned int val = ((const uint32_t *)(pal))[*(const uint8_t*)(s)];\
418  a = (val >> 24) & 0xff;\
419  y = (val >> 16) & 0xff;\
420  u = (val >> 8) & 0xff;\
421  v = val & 0xff;\
422 }
423 
424 #define YUVA_OUT(d, y, u, v, a)\
425 {\
426  ((uint32_t *)(d))[0] = (a << 24) | (y << 16) | (u << 8) | v;\
427 }
428 
429 
430 #define BPP 1
431 
432 static void blend_subrect(uint8_t *dst[4], uint16_t dst_linesize[4],
433  const AVSubtitleRect *rect, int imgw, int imgh)
434 {
435  int wrap, wrap3, width2, skip2;
436  int y, u, v, a, u1, v1, a1, w, h;
437  uint8_t *lum, *cb, *cr;
438  const uint8_t *p;
439  const uint32_t *pal;
440  int dstx, dsty, dstw, dsth;
441 
442  dstw = av_clip(rect->w, 0, imgw);
443  dsth = av_clip(rect->h, 0, imgh);
444  dstx = av_clip(rect->x, 0, imgw - dstw);
445  dsty = av_clip(rect->y, 0, imgh - dsth);
446  /* sdl has U and V inverted */
447  lum = dst[0] + dsty * dst_linesize[0];
448  cb = dst[2] + (dsty >> 1) * dst_linesize[2];
449  cr = dst[1] + (dsty >> 1) * dst_linesize[1];
450 
451  width2 = ((dstw + 1) >> 1) + (dstx & ~dstw & 1);
452  skip2 = dstx >> 1;
453  wrap = dst_linesize[0];
454  wrap3 = rect->linesize[0];
455  p = rect->data[0];
456  pal = (const uint32_t *)rect->data[1]; /* Now in YCrCb! */
457 
458  if (dsty & 1) {
459  lum += dstx;
460  cb += skip2;
461  cr += skip2;
462 
463  if (dstx & 1) {
464  YUVA_IN(y, u, v, a, p, pal);
465  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
466  cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
467  cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
468  cb++;
469  cr++;
470  lum++;
471  p += BPP;
472  }
473  for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
474  YUVA_IN(y, u, v, a, p, pal);
475  u1 = u;
476  v1 = v;
477  a1 = a;
478  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
479 
480  YUVA_IN(y, u, v, a, p + BPP, pal);
481  u1 += u;
482  v1 += v;
483  a1 += a;
484  lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
485  cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
486  cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
487  cb++;
488  cr++;
489  p += 2 * BPP;
490  lum += 2;
491  }
492  if (w) {
493  YUVA_IN(y, u, v, a, p, pal);
494  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
495  cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
496  cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
497  p++;
498  lum++;
499  }
500  p += wrap3 - dstw * BPP;
501  lum += wrap - dstw - dstx;
502  cb += dst_linesize[2] - width2 - skip2;
503  cr += dst_linesize[1] - width2 - skip2;
504  }
505  for (h = dsth - (dsty & 1); h >= 2; h -= 2) {
506  lum += dstx;
507  cb += skip2;
508  cr += skip2;
509 
510  if (dstx & 1) {
511  YUVA_IN(y, u, v, a, p, pal);
512  u1 = u;
513  v1 = v;
514  a1 = a;
515  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
516  p += wrap3;
517  lum += wrap;
518  YUVA_IN(y, u, v, a, p, pal);
519  u1 += u;
520  v1 += v;
521  a1 += a;
522  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
523  cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
524  cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
525  cb++;
526  cr++;
527  p += -wrap3 + BPP;
528  lum += -wrap + 1;
529  }
530  for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
531  YUVA_IN(y, u, v, a, p, pal);
532  u1 = u;
533  v1 = v;
534  a1 = a;
535  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
536 
537  YUVA_IN(y, u, v, a, p + BPP, pal);
538  u1 += u;
539  v1 += v;
540  a1 += a;
541  lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
542  p += wrap3;
543  lum += wrap;
544 
545  YUVA_IN(y, u, v, a, p, pal);
546  u1 += u;
547  v1 += v;
548  a1 += a;
549  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
550 
551  YUVA_IN(y, u, v, a, p + BPP, pal);
552  u1 += u;
553  v1 += v;
554  a1 += a;
555  lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
556 
557  cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
558  cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);
559 
560  cb++;
561  cr++;
562  p += -wrap3 + 2 * BPP;
563  lum += -wrap + 2;
564  }
565  if (w) {
566  YUVA_IN(y, u, v, a, p, pal);
567  u1 = u;
568  v1 = v;
569  a1 = a;
570  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
571  p += wrap3;
572  lum += wrap;
573  YUVA_IN(y, u, v, a, p, pal);
574  u1 += u;
575  v1 += v;
576  a1 += a;
577  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
578  cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
579  cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
580  cb++;
581  cr++;
582  p += -wrap3 + BPP;
583  lum += -wrap + 1;
584  }
585  p += wrap3 + (wrap3 - dstw * BPP);
586  lum += wrap + (wrap - dstw - dstx);
587  cb += dst_linesize[2] - width2 - skip2;
588  cr += dst_linesize[1] - width2 - skip2;
589  }
590  /* handle odd height */
591  if (h) {
592  lum += dstx;
593  cb += skip2;
594  cr += skip2;
595 
596  if (dstx & 1) {
597  YUVA_IN(y, u, v, a, p, pal);
598  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
599  cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
600  cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
601  cb++;
602  cr++;
603  lum++;
604  p += BPP;
605  }
606  for (w = dstw - (dstx & 1); w >= 2; w -= 2) {
607  YUVA_IN(y, u, v, a, p, pal);
608  u1 = u;
609  v1 = v;
610  a1 = a;
611  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
612 
613  YUVA_IN(y, u, v, a, p + BPP, pal);
614  u1 += u;
615  v1 += v;
616  a1 += a;
617  lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
618  cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
619  cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
620  cb++;
621  cr++;
622  p += 2 * BPP;
623  lum += 2;
624  }
625  if (w) {
626  YUVA_IN(y, u, v, a, p, pal);
627  lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
628  cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
629  cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
630  }
631  }
632 }
633 
634 static void free_subpicture(SubPicture *sp)
635 {
636  avsubtitle_free(&sp->sub);
637 }
638 
640 {
641  VideoPicture *vp;
642  SubPicture *sp;
643  float aspect_ratio;
644  int width, height, x, y;
645  SDL_Rect rect;
646  int i;
647 
648  vp = &is->pictq[is->pictq_rindex];
649  if (vp->bmp) {
650  if (!vp->sar.num)
651  aspect_ratio = 0;
652  else
653  aspect_ratio = av_q2d(vp->sar);
654  if (aspect_ratio <= 0.0)
655  aspect_ratio = 1.0;
656  aspect_ratio *= (float)vp->width / (float)vp->height;
657 
658  if (is->subtitle_st)
659  {
660  if (is->subpq_size > 0)
661  {
662  sp = &is->subpq[is->subpq_rindex];
663 
664  if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000))
665  {
666  SDL_LockYUVOverlay (vp->bmp);
667 
668  for (i = 0; i < sp->sub.num_rects; i++)
669  blend_subrect(vp->bmp->pixels, vp->bmp->pitches,
670  sp->sub.rects[i], vp->bmp->w, vp->bmp->h);
671 
672  SDL_UnlockYUVOverlay (vp->bmp);
673  }
674  }
675  }
676 
677 
678  /* XXX: we suppose the screen has a 1.0 pixel ratio */
679  height = is->height;
680  width = ((int)rint(height * aspect_ratio)) & ~1;
681  if (width > is->width) {
682  width = is->width;
683  height = ((int)rint(width / aspect_ratio)) & ~1;
684  }
685  x = (is->width - width) / 2;
686  y = (is->height - height) / 2;
687  is->no_background = 0;
688  rect.x = is->xleft + x;
689  rect.y = is->ytop + y;
690  rect.w = width;
691  rect.h = height;
692  SDL_DisplayYUVOverlay(vp->bmp, &rect);
693  }
694 }
695 
696 /* get the current audio output buffer size, in samples. With SDL, we
697  cannot have a precise information */
699 {
700  return is->audio_buf_size - is->audio_buf_index;
701 }
702 
703 static inline int compute_mod(int a, int b)
704 {
705  a = a % b;
706  if (a >= 0)
707  return a;
708  else
709  return a + b;
710 }
711 
713 {
714  int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
715  int ch, channels, h, h2, bgcolor, fgcolor;
716  int16_t time_diff;
717  int rdft_bits, nb_freq;
718 
719  for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
720  ;
721  nb_freq = 1 << (rdft_bits - 1);
722 
723  /* compute display index : center on currently output samples */
724  channels = s->sdl_channels;
725  nb_display_channels = channels;
726  if (!s->paused) {
727  int data_used = s->show_audio == 1 ? s->width : (2 * nb_freq);
728  n = 2 * channels;
729  delay = audio_write_get_buf_size(s);
730  delay /= n;
731 
732  /* to be more precise, we take into account the time spent since
733  the last buffer computation */
734  if (audio_callback_time) {
736  delay -= (time_diff * s->sdl_sample_rate) / 1000000;
737  }
738 
739  delay += 2 * data_used;
740  if (delay < data_used)
741  delay = data_used;
742 
743  i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
744  if (s->show_audio == 1) {
745  h = INT_MIN;
746  for (i = 0; i < 1000; i += channels) {
747  int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
748  int a = s->sample_array[idx];
749  int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
750  int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
751  int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
752  int score = a - d;
753  if (h < score && (b ^ c) < 0) {
754  h = score;
755  i_start = idx;
756  }
757  }
758  }
759 
760  s->last_i_start = i_start;
761  } else {
762  i_start = s->last_i_start;
763  }
764 
765  bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
766  if (s->show_audio == 1) {
768  s->xleft, s->ytop, s->width, s->height,
769  bgcolor);
770 
771  fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
772 
773  /* total height for one channel */
774  h = s->height / nb_display_channels;
775  /* graph height / 2 */
776  h2 = (h * 9) / 20;
777  for (ch = 0; ch < nb_display_channels; ch++) {
778  i = i_start + ch;
779  y1 = s->ytop + ch * h + (h / 2); /* position of center line */
780  for (x = 0; x < s->width; x++) {
781  y = (s->sample_array[i] * h2) >> 15;
782  if (y < 0) {
783  y = -y;
784  ys = y1 - y;
785  } else {
786  ys = y1;
787  }
789  s->xleft + x, ys, 1, y,
790  fgcolor);
791  i += channels;
792  if (i >= SAMPLE_ARRAY_SIZE)
793  i -= SAMPLE_ARRAY_SIZE;
794  }
795  }
796 
797  fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
798 
799  for (ch = 1; ch < nb_display_channels; ch++) {
800  y = s->ytop + ch * h;
802  s->xleft, y, s->width, 1,
803  fgcolor);
804  }
805  SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
806  } else {
807  nb_display_channels= FFMIN(nb_display_channels, 2);
808  if (rdft_bits != s->rdft_bits) {
809  av_rdft_end(s->rdft);
810  av_free(s->rdft_data);
811  s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
812  s->rdft_bits = rdft_bits;
813  s->rdft_data = av_malloc(4 * nb_freq * sizeof(*s->rdft_data));
814  }
815  {
816  FFTSample *data[2];
817  for (ch = 0; ch < nb_display_channels; ch++) {
818  data[ch] = s->rdft_data + 2 * nb_freq * ch;
819  i = i_start + ch;
820  for (x = 0; x < 2 * nb_freq; x++) {
821  double w = (x-nb_freq) * (1.0 / nb_freq);
822  data[ch][x] = s->sample_array[i] * (1.0 - w * w);
823  i += channels;
824  if (i >= SAMPLE_ARRAY_SIZE)
825  i -= SAMPLE_ARRAY_SIZE;
826  }
827  av_rdft_calc(s->rdft, data[ch]);
828  }
829  /* Least efficient way to do this, we should of course
830  * directly access it but it is more than fast enough. */
831  for (y = 0; y < s->height; y++) {
832  double w = 1 / sqrt(nb_freq);
833  int a = sqrt(w * sqrt(data[0][2 * y + 0] * data[0][2 * y + 0] + data[0][2 * y + 1] * data[0][2 * y + 1]));
834  int b = (nb_display_channels == 2 ) ? sqrt(w * sqrt(data[1][2 * y + 0] * data[1][2 * y + 0]
835  + data[1][2 * y + 1] * data[1][2 * y + 1])) : a;
836  a = FFMIN(a, 255);
837  b = FFMIN(b, 255);
838  fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);
839 
841  s->xpos, s->height-y, 1, 1,
842  fgcolor);
843  }
844  }
845  SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
846  s->xpos++;
847  if (s->xpos >= s->width)
848  s->xpos= s->xleft;
849  }
850 }
851 
852 static int video_open(PlayerState *is)
853 {
854  int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
855  int w,h;
856 
857  if (is_full_screen) flags |= SDL_FULLSCREEN;
858  else flags |= SDL_RESIZABLE;
859 
861  w = fs_screen_width;
862  h = fs_screen_height;
863  } else if (!is_full_screen && screen_width) {
864  w = screen_width;
865  h = screen_height;
866  } else if (is->out_video_filter && is->out_video_filter->inputs[0]) {
867  w = is->out_video_filter->inputs[0]->w;
868  h = is->out_video_filter->inputs[0]->h;
869  } else {
870  w = 640;
871  h = 480;
872  }
873  if (screen && is->width == screen->w && screen->w == w
874  && is->height== screen->h && screen->h == h)
875  return 0;
876 
877 #if defined(__APPLE__) && !SDL_VERSION_ATLEAST(1, 2, 14)
878  /* setting bits_per_pixel = 0 or 32 causes blank video on OS X and older SDL */
879  screen = SDL_SetVideoMode(w, h, 24, flags);
880 #else
881  screen = SDL_SetVideoMode(w, h, 0, flags);
882 #endif
883  if (!screen) {
884  fprintf(stderr, "SDL: could not set video mode - exiting\n");
885  return -1;
886  }
887  if (!window_title)
889  SDL_WM_SetCaption(window_title, window_title);
890 
891  is->width = screen->w;
892  is->height = screen->h;
893 
894  return 0;
895 }
896 
897 /* display the current picture, if any */
898 static void video_display(PlayerState *is)
899 {
900  if (!screen)
901  video_open(player);
902  if (is->audio_st && is->show_audio)
904  else if (is->video_st)
906 }
907 
908 static int refresh_thread(void *opaque)
909 {
910  PlayerState *is= opaque;
911  while (!is->abort_request) {
912  SDL_Event event;
913  event.type = FF_REFRESH_EVENT;
914  event.user.data1 = opaque;
915  if (!is->refresh) {
916  is->refresh = 1;
917  SDL_PushEvent(&event);
918  }
919  av_usleep(is->audio_st && is->show_audio ? rdftspeed * 1000 : 5000); // FIXME ideally we should wait the correct time but SDLs event passing is so slow it would be silly
920  }
921  return 0;
922 }
923 
924 /* get the current audio clock value */
925 static double get_audio_clock(PlayerState *is)
926 {
927  double pts;
928  int hw_buf_size, bytes_per_sec;
929  pts = is->audio_clock;
930  hw_buf_size = audio_write_get_buf_size(is);
931  bytes_per_sec = 0;
932  if (is->audio_st) {
933  bytes_per_sec = is->sdl_sample_rate * is->sdl_channels *
935  }
936  if (bytes_per_sec)
937  pts -= (double)hw_buf_size / bytes_per_sec;
938  return pts;
939 }
940 
941 /* get the current video clock value */
942 static double get_video_clock(PlayerState *is)
943 {
944  if (is->paused) {
945  return is->video_current_pts;
946  } else {
947  return is->video_current_pts_drift + av_gettime_relative() / 1000000.0;
948  }
949 }
950 
951 /* get the current external clock value */
952 static double get_external_clock(PlayerState *is)
953 {
954  int64_t ti;
955  ti = av_gettime_relative();
956  return is->external_clock + ((ti - is->external_clock_time) * 1e-6);
957 }
958 
959 /* get the current master clock value */
960 static double get_master_clock(PlayerState *is)
961 {
962  double val;
963 
964  if (is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
965  if (is->video_st)
966  val = get_video_clock(is);
967  else
968  val = get_audio_clock(is);
969  } else if (is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
970  if (is->audio_st)
971  val = get_audio_clock(is);
972  else
973  val = get_video_clock(is);
974  } else {
975  val = get_external_clock(is);
976  }
977  return val;
978 }
979 
980 /* seek in the stream */
981 static void stream_seek(PlayerState *is, int64_t pos, int64_t rel, int seek_by_bytes)
982 {
983  if (!is->seek_req) {
984  is->seek_pos = pos;
985  is->seek_rel = rel;
987  if (seek_by_bytes)
989  is->seek_req = 1;
990  }
991 }
992 
993 /* pause or resume the video */
994 static void stream_pause(PlayerState *is)
995 {
996  if (is->paused) {
998  if (is->read_pause_return != AVERROR(ENOSYS)) {
1000  }
1002  }
1003  is->paused = !is->paused;
1004 }
1005 
1006 static double compute_target_time(double frame_current_pts, PlayerState *is)
1007 {
1008  double delay, sync_threshold, diff = 0;
1009 
1010  /* compute nominal delay */
1011  delay = frame_current_pts - is->frame_last_pts;
1012  if (delay <= 0 || delay >= 10.0) {
1013  /* if incorrect delay, use previous one */
1014  delay = is->frame_last_delay;
1015  } else {
1016  is->frame_last_delay = delay;
1017  }
1018  is->frame_last_pts = frame_current_pts;
1019 
1020  /* update delay to follow master synchronisation source */
1021  if (((is->av_sync_type == AV_SYNC_AUDIO_MASTER && is->audio_st) ||
1023  /* if video is slave, we try to correct big delays by
1024  duplicating or deleting a frame */
1025  diff = get_video_clock(is) - get_master_clock(is);
1026 
1027  /* skip or repeat frame. We take into account the
1028  delay to compute the threshold. I still don't know
1029  if it is the best guess */
1030  sync_threshold = FFMAX(AV_SYNC_THRESHOLD, delay);
1031  if (fabs(diff) < AV_NOSYNC_THRESHOLD) {
1032  if (diff <= -sync_threshold)
1033  delay = 0;
1034  else if (diff >= sync_threshold)
1035  delay = 2 * delay;
1036  }
1037  }
1038  is->frame_timer += delay;
1039 
1040  av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f pts=%0.3f A-V=%f\n",
1041  delay, frame_current_pts, -diff);
1042 
1043  return is->frame_timer;
1044 }
1045 
1046 /* called to display each frame */
1047 static void video_refresh_timer(void *opaque)
1048 {
1049  PlayerState *is = opaque;
1050  VideoPicture *vp;
1051 
1052  SubPicture *sp, *sp2;
1053 
1054  if (is->video_st) {
1055 retry:
1056  if (is->pictq_size == 0) {
1057  // nothing to do, no picture to display in the que
1058  } else {
1059  double time = av_gettime_relative() / 1000000.0;
1060  double next_target;
1061  /* dequeue the picture */
1062  vp = &is->pictq[is->pictq_rindex];
1063 
1064  if (time < vp->target_clock)
1065  return;
1066  /* update current video pts */
1067  is->video_current_pts = vp->pts;
1068  is->video_current_pts_drift = is->video_current_pts - time;
1069  is->video_current_pos = vp->pos;
1070  if (is->pictq_size > 1) {
1071  VideoPicture *nextvp = &is->pictq[(is->pictq_rindex + 1) % VIDEO_PICTURE_QUEUE_SIZE];
1072  assert(nextvp->target_clock >= vp->target_clock);
1073  next_target= nextvp->target_clock;
1074  } else {
1075  next_target = vp->target_clock + is->video_clock - vp->pts; // FIXME pass durations cleanly
1076  }
1077  if (framedrop && time > next_target) {
1078  is->skip_frames *= 1.0 + FRAME_SKIP_FACTOR;
1079  if (is->pictq_size > 1 || time > next_target + 0.5) {
1080  /* update queue size and signal for next picture */
1082  is->pictq_rindex = 0;
1083 
1084  SDL_LockMutex(is->pictq_mutex);
1085  is->pictq_size--;
1086  SDL_CondSignal(is->pictq_cond);
1087  SDL_UnlockMutex(is->pictq_mutex);
1088  goto retry;
1089  }
1090  }
1091 
1092  if (is->subtitle_st) {
1093  if (is->subtitle_stream_changed) {
1094  SDL_LockMutex(is->subpq_mutex);
1095 
1096  while (is->subpq_size) {
1097  free_subpicture(&is->subpq[is->subpq_rindex]);
1098 
1099  /* update queue size and signal for next picture */
1100  if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1101  is->subpq_rindex = 0;
1102 
1103  is->subpq_size--;
1104  }
1105  is->subtitle_stream_changed = 0;
1106 
1107  SDL_CondSignal(is->subpq_cond);
1108  SDL_UnlockMutex(is->subpq_mutex);
1109  } else {
1110  if (is->subpq_size > 0) {
1111  sp = &is->subpq[is->subpq_rindex];
1112 
1113  if (is->subpq_size > 1)
1114  sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
1115  else
1116  sp2 = NULL;
1117 
1118  if ((is->video_current_pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
1119  || (sp2 && is->video_current_pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
1120  {
1121  free_subpicture(sp);
1122 
1123  /* update queue size and signal for next picture */
1124  if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
1125  is->subpq_rindex = 0;
1126 
1127  SDL_LockMutex(is->subpq_mutex);
1128  is->subpq_size--;
1129  SDL_CondSignal(is->subpq_cond);
1130  SDL_UnlockMutex(is->subpq_mutex);
1131  }
1132  }
1133  }
1134  }
1135 
1136  /* display picture */
1137  if (!display_disable)
1138  video_display(is);
1139 
1140  /* update queue size and signal for next picture */
1142  is->pictq_rindex = 0;
1143 
1144  SDL_LockMutex(is->pictq_mutex);
1145  is->pictq_size--;
1146  SDL_CondSignal(is->pictq_cond);
1147  SDL_UnlockMutex(is->pictq_mutex);
1148  }
1149  } else if (is->audio_st) {
1150  /* draw the next audio frame */
1151 
1152  /* if only audio stream, then display the audio bars (better
1153  than nothing, just to test the implementation */
1154 
1155  /* display picture */
1156  if (!display_disable)
1157  video_display(is);
1158  }
1159  if (show_status) {
1160  static int64_t last_time;
1161  int64_t cur_time;
1162  int aqsize, vqsize, sqsize;
1163  double av_diff;
1164 
1165  cur_time = av_gettime_relative();
1166  if (!last_time || (cur_time - last_time) >= 30000) {
1167  aqsize = 0;
1168  vqsize = 0;
1169  sqsize = 0;
1170  if (is->audio_st)
1171  aqsize = is->audioq.size;
1172  if (is->video_st)
1173  vqsize = is->videoq.size;
1174  if (is->subtitle_st)
1175  sqsize = is->subtitleq.size;
1176  av_diff = 0;
1177  if (is->audio_st && is->video_st)
1178  av_diff = get_audio_clock(is) - get_video_clock(is);
1179  printf("%7.2f A-V:%7.3f s:%3.1f aq=%5dKB vq=%5dKB sq=%5dB f=%"PRId64"/%"PRId64" \r",
1180  get_master_clock(is), av_diff, FFMAX(is->skip_frames - 1, 0), aqsize / 1024,
1181  vqsize / 1024, sqsize, is->pts_ctx.num_faulty_dts, is->pts_ctx.num_faulty_pts);
1182  fflush(stdout);
1183  last_time = cur_time;
1184  }
1185  }
1186 }
1187 
1188 static void player_close(PlayerState *is)
1189 {
1190  VideoPicture *vp;
1191  int i;
1192  /* XXX: use a special url_shutdown call to abort parse cleanly */
1193  is->abort_request = 1;
1194  SDL_WaitThread(is->parse_tid, NULL);
1195  SDL_WaitThread(is->refresh_tid, NULL);
1196 
1197  /* free all pictures */
1198  for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++) {
1199  vp = &is->pictq[i];
1200  if (vp->bmp) {
1201  SDL_FreeYUVOverlay(vp->bmp);
1202  vp->bmp = NULL;
1203  }
1204  }
1205  SDL_DestroyMutex(is->video_filter_mutex);
1206  SDL_DestroyMutex(is->pictq_mutex);
1207  SDL_DestroyCond(is->pictq_cond);
1208  SDL_DestroyMutex(is->subpq_mutex);
1209  SDL_DestroyCond(is->subpq_cond);
1210 }
1211 
1212 static void do_exit(void)
1213 {
1214  if (player) {
1215  player_close(player);
1216  player = NULL;
1217  }
1218  uninit_opts();
1220  if (show_status)
1221  printf("\n");
1222  SDL_Quit();
1223  av_log(NULL, AV_LOG_QUIET, "");
1224  exit(0);
1225 }
1226 
1227 /* allocate a picture (needs to do that in main thread to avoid
1228  potential locking problems */
1229 static void alloc_picture(void *opaque)
1230 {
1231  PlayerState *is = opaque;
1232  VideoPicture *vp;
1233 
1234  vp = &is->pictq[is->pictq_windex];
1235 
1236  if (vp->bmp)
1237  SDL_FreeYUVOverlay(vp->bmp);
1238 
1239  vp->width = is->out_video_filter->inputs[0]->w;
1240  vp->height = is->out_video_filter->inputs[0]->h;
1241  vp->pix_fmt = is->out_video_filter->inputs[0]->format;
1242 
1243  vp->bmp = SDL_CreateYUVOverlay(vp->width, vp->height,
1244  SDL_YV12_OVERLAY,
1245  screen);
1246  if (!vp->bmp || vp->bmp->pitches[0] < vp->width) {
1247  /* SDL allocates a buffer smaller than requested if the video
1248  * overlay hardware is unable to support the requested size. */
1249  fprintf(stderr, "Error: the video system does not support an image\n"
1250  "size of %dx%d pixels. Try using -vf \"scale=w:h\"\n"
1251  "to reduce the image size.\n", vp->width, vp->height );
1252  do_exit();
1253  }
1254 
1255  SDL_LockMutex(is->pictq_mutex);
1256  vp->allocated = 1;
1257  SDL_CondSignal(is->pictq_cond);
1258  SDL_UnlockMutex(is->pictq_mutex);
1259 }
1260 
1261 /* The 'pts' parameter is the dts of the packet / pts of the frame and
1262  * guessed if not known. */
1263 static int queue_picture(PlayerState *is, AVFrame *src_frame, double pts, int64_t pos)
1264 {
1265  VideoPicture *vp;
1266 
1267  /* wait until we have space to put a new picture */
1268  SDL_LockMutex(is->pictq_mutex);
1269 
1270  if (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !is->refresh)
1271  is->skip_frames = FFMAX(1.0 - FRAME_SKIP_FACTOR, is->skip_frames * (1.0 - FRAME_SKIP_FACTOR));
1272 
1273  while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE &&
1274  !is->videoq.abort_request) {
1275  SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1276  }
1277  SDL_UnlockMutex(is->pictq_mutex);
1278 
1279  if (is->videoq.abort_request)
1280  return -1;
1281 
1282  vp = &is->pictq[is->pictq_windex];
1283 
1284  vp->sar = src_frame->sample_aspect_ratio;
1285 
1286  /* alloc or resize hardware picture buffer */
1287  if (!vp->bmp || vp->reallocate ||
1288  vp->width != is->out_video_filter->inputs[0]->w ||
1289  vp->height != is->out_video_filter->inputs[0]->h) {
1290  SDL_Event event;
1291 
1292  vp->allocated = 0;
1293  vp->reallocate = 0;
1294 
1295  /* the allocation must be done in the main thread to avoid
1296  locking problems */
1297  event.type = FF_ALLOC_EVENT;
1298  event.user.data1 = is;
1299  SDL_PushEvent(&event);
1300 
1301  /* wait until the picture is allocated */
1302  SDL_LockMutex(is->pictq_mutex);
1303  while (!vp->allocated && !is->videoq.abort_request) {
1304  SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1305  }
1306  SDL_UnlockMutex(is->pictq_mutex);
1307 
1308  if (is->videoq.abort_request)
1309  return -1;
1310  }
1311 
1312  /* if the frame is not skipped, then display it */
1313  if (vp->bmp) {
1314  uint8_t *data[4];
1315  int linesize[4];
1316 
1317  /* get a pointer on the bitmap */
1318  SDL_LockYUVOverlay (vp->bmp);
1319 
1320  data[0] = vp->bmp->pixels[0];
1321  data[1] = vp->bmp->pixels[2];
1322  data[2] = vp->bmp->pixels[1];
1323 
1324  linesize[0] = vp->bmp->pitches[0];
1325  linesize[1] = vp->bmp->pitches[2];
1326  linesize[2] = vp->bmp->pitches[1];
1327 
1328  // FIXME use direct rendering
1329  av_image_copy(data, linesize, src_frame->data, src_frame->linesize,
1330  vp->pix_fmt, vp->width, vp->height);
1331 
1332  /* update the bitmap content */
1333  SDL_UnlockYUVOverlay(vp->bmp);
1334 
1335  vp->pts = pts;
1336  vp->pos = pos;
1337 
1338  /* now we can update the picture count */
1340  is->pictq_windex = 0;
1341  SDL_LockMutex(is->pictq_mutex);
1342  vp->target_clock = compute_target_time(vp->pts, is);
1343 
1344  is->pictq_size++;
1345  SDL_UnlockMutex(is->pictq_mutex);
1346  }
1347  return 0;
1348 }
1349 
1350 /* Compute the exact PTS for the picture if it is omitted in the stream.
1351  * The 'pts1' parameter is the dts of the packet / pts of the frame. */
1352 static int output_picture2(PlayerState *is, AVFrame *src_frame, double pts1, int64_t pos)
1353 {
1354  double frame_delay, pts;
1355  int ret;
1356 
1357  pts = pts1;
1358 
1359  if (pts != 0) {
1360  /* update video clock with pts, if present */
1361  is->video_clock = pts;
1362  } else {
1363  pts = is->video_clock;
1364  }
1365  /* update video clock for next frame */
1366  frame_delay = av_q2d(is->video_dec->time_base);
1367  /* For MPEG-2, the frame can be repeated, so we update the
1368  clock accordingly */
1369  frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
1370  is->video_clock += frame_delay;
1371 
1372  ret = queue_picture(is, src_frame, pts, pos);
1373  av_frame_unref(src_frame);
1374  return ret;
1375 }
1376 
1377 static int get_video_frame(PlayerState *is, AVFrame *frame, int64_t *pts, AVPacket *pkt)
1378 {
1379  int got_picture, i;
1380 
1381  if (packet_queue_get(&is->videoq, pkt, 1) < 0)
1382  return -1;
1383 
1384  if (pkt->data == flush_pkt.data) {
1386 
1387  SDL_LockMutex(is->pictq_mutex);
1388  // Make sure there are no long delay timers (ideally we should just flush the que but thats harder)
1389  for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++) {
1390  is->pictq[i].target_clock= 0;
1391  }
1392  while (is->pictq_size && !is->videoq.abort_request) {
1393  SDL_CondWait(is->pictq_cond, is->pictq_mutex);
1394  }
1395  is->video_current_pos = -1;
1396  SDL_UnlockMutex(is->pictq_mutex);
1397 
1400  is->frame_last_delay = 0;
1401  is->frame_timer = (double)av_gettime_relative() / 1000000.0;
1402  is->skip_frames = 1;
1403  is->skip_frames_index = 0;
1404  return 0;
1405  }
1406 
1407  avcodec_decode_video2(is->video_dec, frame, &got_picture, pkt);
1408 
1409  if (got_picture) {
1410  if (decoder_reorder_pts == -1) {
1411  *pts = guess_correct_pts(&is->pts_ctx, frame->pts, frame->pkt_dts);
1412  } else if (decoder_reorder_pts) {
1413  *pts = frame->pts;
1414  } else {
1415  *pts = frame->pkt_dts;
1416  }
1417 
1418  if (*pts == AV_NOPTS_VALUE) {
1419  *pts = 0;
1420  }
1421  if (is->video_st->sample_aspect_ratio.num) {
1423  }
1424 
1425  is->skip_frames_index += 1;
1426  if (is->skip_frames_index >= is->skip_frames) {
1427  is->skip_frames_index -= FFMAX(is->skip_frames, 1.0);
1428  return 1;
1429  }
1430  av_frame_unref(frame);
1431  }
1432  return 0;
1433 }
1434 
1435 static int configure_video_filters(AVFilterGraph *graph, PlayerState *is, const char *vfilters)
1436 {
1437  char sws_flags_str[128];
1438  char buffersrc_args[256];
1439  int ret;
1440  AVFilterContext *filt_src = NULL, *filt_out = NULL, *last_filter;
1441  AVCodecContext *codec = is->video_dec;
1442 
1443  snprintf(sws_flags_str, sizeof(sws_flags_str), "flags=%"PRId64, sws_flags);
1444  graph->scale_sws_opts = av_strdup(sws_flags_str);
1445 
1446  snprintf(buffersrc_args, sizeof(buffersrc_args), "%d:%d:%d:%d:%d:%d:%d",
1447  codec->width, codec->height, codec->pix_fmt,
1450 
1451 
1452  if ((ret = avfilter_graph_create_filter(&filt_src,
1453  avfilter_get_by_name("buffer"),
1454  "src", buffersrc_args, NULL,
1455  graph)) < 0)
1456  return ret;
1457  if ((ret = avfilter_graph_create_filter(&filt_out,
1458  avfilter_get_by_name("buffersink"),
1459  "out", NULL, NULL, graph)) < 0)
1460  return ret;
1461 
1462  last_filter = filt_out;
1463 
1464 /* Note: this macro adds a filter before the lastly added filter, so the
1465  * processing order of the filters is in reverse */
1466 #define INSERT_FILT(name, arg) do { \
1467  AVFilterContext *filt_ctx; \
1468  \
1469  ret = avfilter_graph_create_filter(&filt_ctx, \
1470  avfilter_get_by_name(name), \
1471  "avplay_" name, arg, NULL, graph); \
1472  if (ret < 0) \
1473  return ret; \
1474  \
1475  ret = avfilter_link(filt_ctx, 0, last_filter, 0); \
1476  if (ret < 0) \
1477  return ret; \
1478  \
1479  last_filter = filt_ctx; \
1480 } while (0)
1481 
1482  INSERT_FILT("format", "yuv420p");
1483 
1484  if (autorotate) {
1485  uint8_t* displaymatrix = av_stream_get_side_data(is->video_st,
1487  if (displaymatrix) {
1488  double rot = av_display_rotation_get((int32_t*) displaymatrix);
1489  if (rot < -135 || rot > 135) {
1490  INSERT_FILT("vflip", NULL);
1491  INSERT_FILT("hflip", NULL);
1492  } else if (rot < -45) {
1493  INSERT_FILT("transpose", "dir=clock");
1494  } else if (rot > 45) {
1495  INSERT_FILT("transpose", "dir=cclock");
1496  }
1497  }
1498  }
1499 
1500  if (vfilters) {
1503 
1504  outputs->name = av_strdup("in");
1505  outputs->filter_ctx = filt_src;
1506  outputs->pad_idx = 0;
1507  outputs->next = NULL;
1508 
1509  inputs->name = av_strdup("out");
1510  inputs->filter_ctx = last_filter;
1511  inputs->pad_idx = 0;
1512  inputs->next = NULL;
1513 
1514  if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
1515  return ret;
1516  } else {
1517  if ((ret = avfilter_link(filt_src, 0, last_filter, 0)) < 0)
1518  return ret;
1519  }
1520 
1521  if ((ret = avfilter_graph_config(graph, NULL)) < 0)
1522  return ret;
1523 
1524  is->in_video_filter = filt_src;
1525  is->out_video_filter = filt_out;
1526 
1527  return ret;
1528 }
1529 
1530 static int video_thread(void *arg)
1531 {
1532  AVPacket pkt = { 0 };
1533  PlayerState *is = arg;
1534  AVFrame *frame = av_frame_alloc();
1535  int64_t pts_int;
1536  double pts;
1537  int ret;
1538 
1540  AVFilterContext *filt_out = NULL, *filt_in = NULL;
1541  int last_w = is->video_dec->width;
1542  int last_h = is->video_dec->height;
1543  if (!graph) {
1544  av_frame_free(&frame);
1545  return AVERROR(ENOMEM);
1546  }
1547 
1548  if ((ret = configure_video_filters(graph, is, vfilters)) < 0)
1549  goto the_end;
1550  filt_in = is->in_video_filter;
1551  filt_out = is->out_video_filter;
1552 
1553  if (!frame) {
1554  avfilter_graph_free(&graph);
1555  return AVERROR(ENOMEM);
1556  }
1557 
1558  for (;;) {
1559  AVRational tb;
1560  while (is->paused && !is->videoq.abort_request)
1561  SDL_Delay(10);
1562 
1563  av_packet_unref(&pkt);
1564 
1565  ret = get_video_frame(is, frame, &pts_int, &pkt);
1566  if (ret < 0)
1567  goto the_end;
1568 
1569  if (!ret)
1570  continue;
1571 
1572  if ( last_w != is->video_dec->width
1573  || last_h != is->video_dec->height) {
1574  av_log(NULL, AV_LOG_TRACE, "Changing size %dx%d -> %dx%d\n", last_w, last_h,
1575  is->video_dec->width, is->video_dec->height);
1576  avfilter_graph_free(&graph);
1577  graph = avfilter_graph_alloc();
1578  if ((ret = configure_video_filters(graph, is, vfilters)) < 0)
1579  goto the_end;
1580  filt_in = is->in_video_filter;
1581  filt_out = is->out_video_filter;
1582  last_w = is->video_dec->width;
1583  last_h = is->video_dec->height;
1584  }
1585 
1586  frame->pts = pts_int;
1587  ret = av_buffersrc_add_frame(filt_in, frame);
1588  if (ret < 0)
1589  goto the_end;
1590 
1591  while (ret >= 0) {
1592  ret = av_buffersink_get_frame(filt_out, frame);
1593  if (ret < 0) {
1594  ret = 0;
1595  break;
1596  }
1597 
1598  pts_int = frame->pts;
1599  tb = filt_out->inputs[0]->time_base;
1600  if (av_cmp_q(tb, is->video_st->time_base)) {
1601  av_unused int64_t pts1 = pts_int;
1602  pts_int = av_rescale_q(pts_int, tb, is->video_st->time_base);
1603  av_log(NULL, AV_LOG_TRACE, "video_thread(): "
1604  "tb:%d/%d pts:%"PRId64" -> tb:%d/%d pts:%"PRId64"\n",
1605  tb.num, tb.den, pts1,
1606  is->video_st->time_base.num, is->video_st->time_base.den, pts_int);
1607  }
1608  pts = pts_int * av_q2d(is->video_st->time_base);
1609  ret = output_picture2(is, frame, pts, 0);
1610  }
1611 
1612  if (ret < 0)
1613  goto the_end;
1614 
1615 
1616  if (step)
1617  if (player)
1618  stream_pause(player);
1619  }
1620  the_end:
1621  SDL_LockMutex(is->video_filter_mutex);
1622  is->out_video_filter = NULL;
1623  SDL_UnlockMutex(is->video_filter_mutex);
1624  av_freep(&vfilters);
1625  avfilter_graph_free(&graph);
1626  av_packet_unref(&pkt);
1627  av_frame_free(&frame);
1628  return 0;
1629 }
1630 
1631 static int subtitle_thread(void *arg)
1632 {
1633  PlayerState *is = arg;
1634  SubPicture *sp;
1635  AVPacket pkt1, *pkt = &pkt1;
1636  int got_subtitle;
1637  double pts;
1638  int i, j;
1639  int r, g, b, y, u, v, a;
1640 
1641  for (;;) {
1642  while (is->paused && !is->subtitleq.abort_request) {
1643  SDL_Delay(10);
1644  }
1645  if (packet_queue_get(&is->subtitleq, pkt, 1) < 0)
1646  break;
1647 
1648  if (pkt->data == flush_pkt.data) {
1650  continue;
1651  }
1652  SDL_LockMutex(is->subpq_mutex);
1653  while (is->subpq_size >= SUBPICTURE_QUEUE_SIZE &&
1654  !is->subtitleq.abort_request) {
1655  SDL_CondWait(is->subpq_cond, is->subpq_mutex);
1656  }
1657  SDL_UnlockMutex(is->subpq_mutex);
1658 
1659  if (is->subtitleq.abort_request)
1660  return 0;
1661 
1662  sp = &is->subpq[is->subpq_windex];
1663 
1664  /* NOTE: ipts is the PTS of the _first_ picture beginning in
1665  this packet, if any */
1666  pts = 0;
1667  if (pkt->pts != AV_NOPTS_VALUE)
1668  pts = av_q2d(is->subtitle_dec->time_base) * pkt->pts;
1669 
1671  &got_subtitle, pkt);
1672 
1673  if (got_subtitle && sp->sub.format == 0) {
1674  sp->pts = pts;
1675 
1676  for (i = 0; i < sp->sub.num_rects; i++)
1677  {
1678  for (j = 0; j < sp->sub.rects[i]->nb_colors; j++)
1679  {
1680  RGBA_IN(r, g, b, a, (uint32_t *)sp->sub.rects[i]->data[1] + j);
1681  y = RGB_TO_Y_CCIR(r, g, b);
1682  u = RGB_TO_U_CCIR(r, g, b, 0);
1683  v = RGB_TO_V_CCIR(r, g, b, 0);
1684  YUVA_OUT((uint32_t *)sp->sub.rects[i]->data[1] + j, y, u, v, a);
1685  }
1686  }
1687 
1688  /* now we can update the picture count */
1689  if (++is->subpq_windex == SUBPICTURE_QUEUE_SIZE)
1690  is->subpq_windex = 0;
1691  SDL_LockMutex(is->subpq_mutex);
1692  is->subpq_size++;
1693  SDL_UnlockMutex(is->subpq_mutex);
1694  }
1695  av_packet_unref(pkt);
1696  }
1697  return 0;
1698 }
1699 
1700 /* copy samples for viewing in editor window */
1701 static void update_sample_display(PlayerState *is, short *samples, int samples_size)
1702 {
1703  int size, len;
1704 
1705  size = samples_size / sizeof(short);
1706  while (size > 0) {
1708  if (len > size)
1709  len = size;
1710  memcpy(is->sample_array + is->sample_array_index, samples, len * sizeof(short));
1711  samples += len;
1712  is->sample_array_index += len;
1714  is->sample_array_index = 0;
1715  size -= len;
1716  }
1717 }
1718 
1719 /* return the new audio buffer size (samples can be added or deleted
1720  to get better sync if video or external master clock) */
1721 static int synchronize_audio(PlayerState *is, short *samples,
1722  int samples_size1, double pts)
1723 {
1724  int n, samples_size;
1725  double ref_clock;
1726 
1728  samples_size = samples_size1;
1729 
1730  /* if not master, then we try to remove or add samples to correct the clock */
1731  if (((is->av_sync_type == AV_SYNC_VIDEO_MASTER && is->video_st) ||
1733  double diff, avg_diff;
1734  int wanted_size, min_size, max_size, nb_samples;
1735 
1736  ref_clock = get_master_clock(is);
1737  diff = get_audio_clock(is) - ref_clock;
1738 
1739  if (diff < AV_NOSYNC_THRESHOLD) {
1740  is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
1742  /* not enough measures to have a correct estimate */
1743  is->audio_diff_avg_count++;
1744  } else {
1745  /* estimate the A-V difference */
1746  avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
1747 
1748  if (fabs(avg_diff) >= is->audio_diff_threshold) {
1749  wanted_size = samples_size + ((int)(diff * is->sdl_sample_rate) * n);
1750  nb_samples = samples_size / n;
1751 
1752  min_size = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
1753  max_size = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
1754  if (wanted_size < min_size)
1755  wanted_size = min_size;
1756  else if (wanted_size > max_size)
1757  wanted_size = max_size;
1758 
1759  /* add or remove samples to correction the synchro */
1760  if (wanted_size < samples_size) {
1761  /* remove samples */
1762  samples_size = wanted_size;
1763  } else if (wanted_size > samples_size) {
1764  uint8_t *samples_end, *q;
1765  int nb;
1766 
1767  /* add samples */
1768  nb = (samples_size - wanted_size);
1769  samples_end = (uint8_t *)samples + samples_size - n;
1770  q = samples_end + n;
1771  while (nb > 0) {
1772  memcpy(q, samples_end, n);
1773  q += n;
1774  nb -= n;
1775  }
1776  samples_size = wanted_size;
1777  }
1778  }
1779  av_log(NULL, AV_LOG_TRACE, "diff=%f adiff=%f sample_diff=%d apts=%0.3f vpts=%0.3f %f\n",
1780  diff, avg_diff, samples_size - samples_size1,
1782  }
1783  } else {
1784  /* too big difference : may be initial PTS errors, so
1785  reset A-V filter */
1786  is->audio_diff_avg_count = 0;
1787  is->audio_diff_cum = 0;
1788  }
1789  }
1790 
1791  return samples_size;
1792 }
1793 
1794 /* decode one audio frame and returns its uncompressed size */
1795 static int audio_decode_frame(PlayerState *is, double *pts_ptr)
1796 {
1797  AVPacket *pkt_temp = &is->audio_pkt_temp;
1798  AVPacket *pkt = &is->audio_pkt;
1799  AVCodecContext *dec = is->audio_dec;
1800  int n, len1, data_size, got_frame;
1801  double pts;
1802  int new_packet = 0;
1803  int flush_complete = 0;
1804 
1805  for (;;) {
1806  /* NOTE: the audio packet can contain several frames */
1807  while (pkt_temp->size > 0 || (!pkt_temp->data && new_packet)) {
1808  int resample_changed, audio_resample;
1809 
1810  if (!is->frame) {
1811  if (!(is->frame = av_frame_alloc()))
1812  return AVERROR(ENOMEM);
1813  }
1814 
1815  if (flush_complete)
1816  break;
1817  new_packet = 0;
1818  len1 = avcodec_decode_audio4(dec, is->frame, &got_frame, pkt_temp);
1819  if (len1 < 0) {
1820  /* if error, we skip the frame */
1821  pkt_temp->size = 0;
1822  break;
1823  }
1824 
1825  pkt_temp->data += len1;
1826  pkt_temp->size -= len1;
1827 
1828  if (!got_frame) {
1829  /* stop sending empty packets if the decoder is finished */
1830  if (!pkt_temp->data && (dec->codec->capabilities & AV_CODEC_CAP_DELAY))
1831  flush_complete = 1;
1832  continue;
1833  }
1834  data_size = av_samples_get_buffer_size(NULL, dec->channels,
1835  is->frame->nb_samples,
1836  is->frame->format, 1);
1837 
1838  audio_resample = is->frame->format != is->sdl_sample_fmt ||
1839  is->frame->channel_layout != is->sdl_channel_layout ||
1840  is->frame->sample_rate != is->sdl_sample_rate;
1841 
1842  resample_changed = is->frame->format != is->resample_sample_fmt ||
1845 
1846  if ((!is->avr && audio_resample) || resample_changed) {
1847  int ret;
1848  if (is->avr)
1849  avresample_close(is->avr);
1850  else if (audio_resample) {
1851  is->avr = avresample_alloc_context();
1852  if (!is->avr) {
1853  fprintf(stderr, "error allocating AVAudioResampleContext\n");
1854  break;
1855  }
1856  }
1857  if (audio_resample) {
1858  av_opt_set_int(is->avr, "in_channel_layout", is->frame->channel_layout, 0);
1859  av_opt_set_int(is->avr, "in_sample_fmt", is->frame->format, 0);
1860  av_opt_set_int(is->avr, "in_sample_rate", is->frame->sample_rate, 0);
1861  av_opt_set_int(is->avr, "out_channel_layout", is->sdl_channel_layout, 0);
1862  av_opt_set_int(is->avr, "out_sample_fmt", is->sdl_sample_fmt, 0);
1863  av_opt_set_int(is->avr, "out_sample_rate", is->sdl_sample_rate, 0);
1864 
1865  if ((ret = avresample_open(is->avr)) < 0) {
1866  fprintf(stderr, "error initializing libavresample\n");
1867  break;
1868  }
1869  }
1870  is->resample_sample_fmt = is->frame->format;
1873  }
1874 
1875  if (audio_resample) {
1876  void *tmp_out;
1877  int out_samples, out_size, out_linesize;
1878  int osize = av_get_bytes_per_sample(is->sdl_sample_fmt);
1879  int nb_samples = is->frame->nb_samples;
1880 
1881  out_size = av_samples_get_buffer_size(&out_linesize,
1882  is->sdl_channels,
1883  nb_samples,
1884  is->sdl_sample_fmt, 0);
1885  tmp_out = av_realloc(is->audio_buf1, out_size);
1886  if (!tmp_out)
1887  return AVERROR(ENOMEM);
1888  is->audio_buf1 = tmp_out;
1889 
1890  out_samples = avresample_convert(is->avr,
1891  &is->audio_buf1,
1892  out_linesize, nb_samples,
1893  is->frame->data,
1894  is->frame->linesize[0],
1895  is->frame->nb_samples);
1896  if (out_samples < 0) {
1897  fprintf(stderr, "avresample_convert() failed\n");
1898  break;
1899  }
1900  is->audio_buf = is->audio_buf1;
1901  data_size = out_samples * osize * is->sdl_channels;
1902  } else {
1903  is->audio_buf = is->frame->data[0];
1904  }
1905 
1906  /* if no pts, then compute it */
1907  pts = is->audio_clock;
1908  *pts_ptr = pts;
1910  is->audio_clock += (double)data_size /
1911  (double)(n * is->sdl_sample_rate);
1912 #ifdef DEBUG
1913  {
1914  static double last_clock;
1915  printf("audio: delay=%0.3f clock=%0.3f pts=%0.3f\n",
1916  is->audio_clock - last_clock,
1917  is->audio_clock, pts);
1918  last_clock = is->audio_clock;
1919  }
1920 #endif
1921  return data_size;
1922  }
1923 
1924  /* free the current packet */
1925  if (pkt->data)
1926  av_packet_unref(pkt);
1927  memset(pkt_temp, 0, sizeof(*pkt_temp));
1928 
1929  if (is->paused || is->audioq.abort_request) {
1930  return -1;
1931  }
1932 
1933  /* read next packet */
1934  if ((new_packet = packet_queue_get(&is->audioq, pkt, 1)) < 0)
1935  return -1;
1936 
1937  if (pkt->data == flush_pkt.data) {
1938  avcodec_flush_buffers(dec);
1939  flush_complete = 0;
1940  }
1941 
1942  *pkt_temp = *pkt;
1943 
1944  /* if update the audio clock with the pts */
1945  if (pkt->pts != AV_NOPTS_VALUE) {
1946  is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
1947  }
1948  }
1949 }
1950 
1951 /* prepare a new audio buffer */
1952 static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
1953 {
1954  PlayerState *is = opaque;
1955  int audio_size, len1;
1956  double pts;
1957 
1959 
1960  while (len > 0) {
1961  if (is->audio_buf_index >= is->audio_buf_size) {
1962  audio_size = audio_decode_frame(is, &pts);
1963  if (audio_size < 0) {
1964  /* if error, just output silence */
1965  is->audio_buf = is->silence_buf;
1966  is->audio_buf_size = sizeof(is->silence_buf);
1967  } else {
1968  if (is->show_audio)
1969  update_sample_display(is, (int16_t *)is->audio_buf, audio_size);
1970  audio_size = synchronize_audio(is, (int16_t *)is->audio_buf, audio_size,
1971  pts);
1972  is->audio_buf_size = audio_size;
1973  }
1974  is->audio_buf_index = 0;
1975  }
1976  len1 = is->audio_buf_size - is->audio_buf_index;
1977  if (len1 > len)
1978  len1 = len;
1979  memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
1980  len -= len1;
1981  stream += len1;
1982  is->audio_buf_index += len1;
1983  }
1984 }
1985 
1986 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type)
1987 {
1988  const AVCodecDescriptor *desc;
1989  AVCodec *codec = avcodec_find_decoder_by_name(name);
1990 
1991  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
1992  codec = avcodec_find_decoder(desc->id);
1993  if (codec)
1994  av_log(NULL, AV_LOG_VERBOSE, "Matched decoder '%s' for codec '%s'.\n",
1995  codec->name, desc->name);
1996  }
1997 
1998  if (!codec) {
1999  av_log(NULL, AV_LOG_FATAL, "Unknown decoder '%s'\n", name);
2000  exit_program(1);
2001  }
2002 
2003  if (codec->type != type) {
2004  av_log(NULL, AV_LOG_FATAL, "Invalid decoder type '%s'\n", name);
2005  exit_program(1);
2006  }
2007 
2008  return codec;
2009 }
2010 
2012 {
2013  char *codec_name = NULL;
2014  int i, ret;
2015 
2016  for (i = 0; i < is->nb_codec_names; i++) {
2017  char *spec = is->codec_names[i].specifier;
2018  if ((ret = check_stream_specifier(ic, st, spec)) > 0)
2019  codec_name = is->codec_names[i].u.str;
2020  else if (ret < 0)
2021  exit_program(1);
2022  }
2023 
2024  if (codec_name) {
2025  AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type);
2026  st->codecpar->codec_id = codec->id;
2027  return codec;
2028  } else
2029  return avcodec_find_decoder(st->codecpar->codec_id);
2030 }
2031 
2032 /* open a given stream. Return 0 if OK */
2033 static int stream_component_open(PlayerState *is, int stream_index)
2034 {
2035  AVFormatContext *ic = is->ic;
2036  AVCodecContext *avctx;
2037  AVCodec *codec;
2038  SDL_AudioSpec wanted_spec, spec;
2039  AVDictionary *opts;
2040  AVDictionaryEntry *t = NULL;
2041  int ret = 0;
2042 
2043  if (stream_index < 0 || stream_index >= ic->nb_streams)
2044  return -1;
2045 
2046  avctx = avcodec_alloc_context3(NULL);
2047  if (!avctx)
2048  return AVERROR(ENOMEM);
2049 
2050  ret = avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
2051  if (ret < 0) {
2052  avcodec_free_context(&avctx);
2053  return ret;
2054  }
2055 
2056  opts = filter_codec_opts(codec_opts, avctx->codec_id, ic, ic->streams[stream_index], NULL);
2057 
2058  codec = choose_decoder(is, ic, ic->streams[stream_index]);
2060  avctx->idct_algo = idct;
2061  avctx->skip_frame = skip_frame;
2062  avctx->skip_idct = skip_idct;
2065 
2066  if (fast)
2067  avctx->flags2 |= AV_CODEC_FLAG2_FAST;
2068 
2069  if (!av_dict_get(opts, "threads", NULL, 0))
2070  av_dict_set(&opts, "threads", "auto", 0);
2071  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
2072  av_dict_set(&opts, "refcounted_frames", "1", 0);
2073  if (!codec ||
2074  (ret = avcodec_open2(avctx, codec, &opts)) < 0) {
2075  goto fail;
2076  }
2077  if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
2078  av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2080  goto fail;
2081  }
2082 
2083  /* prepare audio output */
2084  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2085  is->sdl_sample_rate = avctx->sample_rate;
2086 
2087  if (!avctx->channel_layout)
2089  if (!avctx->channel_layout) {
2090  fprintf(stderr, "unable to guess channel layout\n");
2091  ret = AVERROR_INVALIDDATA;
2092  goto fail;
2093  }
2094  if (avctx->channels == 1)
2096  else
2099 
2100  wanted_spec.format = AUDIO_S16SYS;
2101  wanted_spec.freq = is->sdl_sample_rate;
2102  wanted_spec.channels = is->sdl_channels;
2103  wanted_spec.silence = 0;
2104  wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
2105  wanted_spec.callback = sdl_audio_callback;
2106  wanted_spec.userdata = is;
2107  if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
2108  fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
2109  ret = AVERROR_UNKNOWN;
2110  goto fail;
2111  }
2112  is->audio_hw_buf_size = spec.size;
2116  is->resample_sample_rate = avctx->sample_rate;
2117  }
2118 
2119  ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
2120  switch (avctx->codec_type) {
2121  case AVMEDIA_TYPE_AUDIO:
2122  is->audio_stream = stream_index;
2123  is->audio_st = ic->streams[stream_index];
2124  is->audio_dec = avctx;
2125  is->audio_buf_size = 0;
2126  is->audio_buf_index = 0;
2127 
2128  /* init averaging filter */
2129  is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB);
2130  is->audio_diff_avg_count = 0;
2131  /* since we do not have a precise enough audio FIFO fullness,
2132  we correct audio sync only if larger than this threshold */
2134 
2135  memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
2136  packet_queue_init(&is->audioq);
2137  SDL_PauseAudio(0);
2138  break;
2139  case AVMEDIA_TYPE_VIDEO:
2140  is->video_stream = stream_index;
2141  is->video_st = ic->streams[stream_index];
2142  is->video_dec = avctx;
2143 
2144  packet_queue_init(&is->videoq);
2145  is->video_tid = SDL_CreateThread(video_thread, is);
2146  break;
2147  case AVMEDIA_TYPE_SUBTITLE:
2148  is->subtitle_stream = stream_index;
2149  is->subtitle_st = ic->streams[stream_index];
2150  is->subtitle_dec = avctx;
2152 
2153  is->subtitle_tid = SDL_CreateThread(subtitle_thread, is);
2154  break;
2155  default:
2156  break;
2157  }
2158 
2159 fail:
2160  av_dict_free(&opts);
2161 
2162  return ret;
2163 }
2164 
2165 static void stream_component_close(PlayerState *is, int stream_index)
2166 {
2167  AVFormatContext *ic = is->ic;
2168  AVCodecParameters *par;
2169 
2170  if (stream_index < 0 || stream_index >= ic->nb_streams)
2171  return;
2172  par = ic->streams[stream_index]->codecpar;
2173 
2174  switch (par->codec_type) {
2175  case AVMEDIA_TYPE_AUDIO:
2176  packet_queue_abort(&is->audioq);
2177 
2178  SDL_CloseAudio();
2179 
2180  packet_queue_end(&is->audioq);
2181  av_packet_unref(&is->audio_pkt);
2182  if (is->avr)
2183  avresample_free(&is->avr);
2184  av_freep(&is->audio_buf1);
2185  is->audio_buf = NULL;
2186  av_frame_free(&is->frame);
2187 
2188  if (is->rdft) {
2189  av_rdft_end(is->rdft);
2190  av_freep(&is->rdft_data);
2191  is->rdft = NULL;
2192  is->rdft_bits = 0;
2193  }
2194  break;
2195  case AVMEDIA_TYPE_VIDEO:
2196  packet_queue_abort(&is->videoq);
2197 
2198  /* note: we also signal this mutex to make sure we deblock the
2199  video thread in all cases */
2200  SDL_LockMutex(is->pictq_mutex);
2201  SDL_CondSignal(is->pictq_cond);
2202  SDL_UnlockMutex(is->pictq_mutex);
2203 
2204  SDL_WaitThread(is->video_tid, NULL);
2205 
2206  packet_queue_end(&is->videoq);
2207  break;
2208  case AVMEDIA_TYPE_SUBTITLE:
2210 
2211  /* note: we also signal this mutex to make sure we deblock the
2212  video thread in all cases */
2213  SDL_LockMutex(is->subpq_mutex);
2214  is->subtitle_stream_changed = 1;
2215 
2216  SDL_CondSignal(is->subpq_cond);
2217  SDL_UnlockMutex(is->subpq_mutex);
2218 
2219  SDL_WaitThread(is->subtitle_tid, NULL);
2220 
2222  break;
2223  default:
2224  break;
2225  }
2226 
2227  ic->streams[stream_index]->discard = AVDISCARD_ALL;
2228  switch (par->codec_type) {
2229  case AVMEDIA_TYPE_AUDIO:
2231  is->audio_st = NULL;
2232  is->audio_stream = -1;
2233  break;
2234  case AVMEDIA_TYPE_VIDEO:
2236  is->video_st = NULL;
2237  is->video_stream = -1;
2238  break;
2239  case AVMEDIA_TYPE_SUBTITLE:
2241  is->subtitle_st = NULL;
2242  is->subtitle_stream = -1;
2243  break;
2244  default:
2245  break;
2246  }
2247 }
2248 
2249 /* since we have only one decoding thread, we can use a global
2250  variable instead of a thread local variable */
2252 
2253 static int decode_interrupt_cb(void *ctx)
2254 {
2255  return global_video_state && global_video_state->abort_request;
2256 }
2257 
2258 static void stream_close(PlayerState *is)
2259 {
2260  /* disable interrupting */
2261  global_video_state = NULL;
2262 
2263  /* close each stream */
2264  if (is->audio_stream >= 0)
2266  if (is->video_stream >= 0)
2268  if (is->subtitle_stream >= 0)
2270  if (is->ic) {
2271  avformat_close_input(&is->ic);
2272  }
2273 }
2274 
2275 static int stream_setup(PlayerState *is)
2276 {
2277  AVFormatContext *ic = NULL;
2278  int err, i, ret;
2279  int st_index[AVMEDIA_TYPE_NB];
2280  AVDictionaryEntry *t;
2281  AVDictionary **opts;
2282  int orig_nb_streams;
2283 
2284  memset(st_index, -1, sizeof(st_index));
2285  is->video_stream = -1;
2286  is->audio_stream = -1;
2287  is->subtitle_stream = -1;
2288 
2289  global_video_state = is;
2290 
2291  ic = avformat_alloc_context();
2292  if (!ic) {
2293  av_log(NULL, AV_LOG_FATAL, "Could not allocate context.\n");
2294  ret = AVERROR(ENOMEM);
2295  goto fail;
2296  }
2298  err = avformat_open_input(&ic, is->filename, is->iformat, &format_opts);
2299  if (err < 0) {
2300  print_error(is->filename, err);
2301  ret = -1;
2302  goto fail;
2303  }
2304 
2306  av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
2308  goto fail;
2309  }
2310  is->ic = ic;
2311 
2312  if (genpts)
2313  ic->flags |= AVFMT_FLAG_GENPTS;
2314 
2316  orig_nb_streams = ic->nb_streams;
2317 
2318  for (i = 0; i < ic->nb_streams; i++)
2319  choose_decoder(is, ic, ic->streams[i]);
2320 
2321  err = avformat_find_stream_info(ic, opts);
2322 
2323  for (i = 0; i < orig_nb_streams; i++)
2324  av_dict_free(&opts[i]);
2325  av_freep(&opts);
2326 
2327  if (err < 0) {
2328  fprintf(stderr, "%s: could not find codec parameters\n", is->filename);
2329  ret = -1;
2330  goto fail;
2331  }
2332 
2333  if (ic->pb)
2334  ic->pb->eof_reached = 0; // FIXME hack, avplay maybe should not use url_feof() to test for the end
2335 
2336  if (seek_by_bytes < 0)
2338 
2339  /* if seeking requested, we execute it */
2340  if (start_time != AV_NOPTS_VALUE) {
2341  int64_t timestamp;
2342 
2343  timestamp = start_time;
2344  /* add the stream start time */
2345  if (ic->start_time != AV_NOPTS_VALUE)
2346  timestamp += ic->start_time;
2347  ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, INT64_MAX, 0);
2348  if (ret < 0) {
2349  fprintf(stderr, "%s: could not seek to position %0.3f\n",
2350  is->filename, (double)timestamp / AV_TIME_BASE);
2351  }
2352  }
2353 
2354  for (i = 0; i < ic->nb_streams; i++)
2355  ic->streams[i]->discard = AVDISCARD_ALL;
2356  if (!video_disable)
2357  st_index[AVMEDIA_TYPE_VIDEO] =
2360  if (!audio_disable)
2361  st_index[AVMEDIA_TYPE_AUDIO] =
2364  st_index[AVMEDIA_TYPE_VIDEO],
2365  NULL, 0);
2366  if (!video_disable)
2367  st_index[AVMEDIA_TYPE_SUBTITLE] =
2370  (st_index[AVMEDIA_TYPE_AUDIO] >= 0 ?
2371  st_index[AVMEDIA_TYPE_AUDIO] :
2372  st_index[AVMEDIA_TYPE_VIDEO]),
2373  NULL, 0);
2374  if (show_status) {
2375  av_dump_format(ic, 0, is->filename, 0);
2376  }
2377 
2378  /* open the streams */
2379  if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
2380  stream_component_open(is, st_index[AVMEDIA_TYPE_AUDIO]);
2381  }
2382 
2383  ret = -1;
2384  if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
2385  ret = stream_component_open(is, st_index[AVMEDIA_TYPE_VIDEO]);
2386  }
2387  if (ret < 0) {
2388  if (!display_disable)
2389  is->show_audio = 2;
2390  }
2391 
2392  if (st_index[AVMEDIA_TYPE_SUBTITLE] >= 0) {
2393  stream_component_open(is, st_index[AVMEDIA_TYPE_SUBTITLE]);
2394  }
2395 
2396  if (is->video_stream < 0 && is->audio_stream < 0) {
2397  fprintf(stderr, "%s: could not open codecs\n", is->filename);
2398  ret = -1;
2399  goto fail;
2400  }
2401 
2402  return 0;
2403 
2404 fail:
2405  return ret;
2406 }
2407 
2408 /* this thread gets the stream from the disk or the network */
2409 static int decode_thread(void *arg)
2410 {
2411  PlayerState *is = arg;
2412  AVPacket pkt1, *pkt = &pkt1;
2413  AVFormatContext *ic = is->ic;
2414  int pkt_in_play_range = 0;
2415  int ret, eof = 0;
2416 
2417  for (;;) {
2418  if (is->abort_request)
2419  break;
2420  if (is->paused != is->last_paused) {
2421  is->last_paused = is->paused;
2422  if (is->paused)
2423  is->read_pause_return = av_read_pause(ic);
2424  else
2425  av_read_play(ic);
2426  }
2427 #if CONFIG_RTSP_DEMUXER
2428  if (is->paused && !strcmp(ic->iformat->name, "rtsp")) {
2429  /* wait 10 ms to avoid trying to get another packet */
2430  /* XXX: horrible */
2431  SDL_Delay(10);
2432  continue;
2433  }
2434 #endif
2435  if (is->seek_req) {
2436  int64_t seek_target = is->seek_pos;
2437  int64_t seek_min = is->seek_rel > 0 ? seek_target - is->seek_rel + 2: INT64_MIN;
2438  int64_t seek_max = is->seek_rel < 0 ? seek_target - is->seek_rel - 2: INT64_MAX;
2439 // FIXME the +-2 is due to rounding being not done in the correct direction in generation
2440 // of the seek_pos/seek_rel variables
2441 
2442  ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
2443  if (ret < 0) {
2444  fprintf(stderr, "%s: error while seeking\n", is->ic->filename);
2445  } else {
2446  if (is->audio_stream >= 0) {
2447  packet_queue_flush(&is->audioq);
2448  packet_queue_put(&is->audioq, &flush_pkt);
2449  }
2450  if (is->subtitle_stream >= 0) {
2452  packet_queue_put(&is->subtitleq, &flush_pkt);
2453  }
2454  if (is->video_stream >= 0) {
2455  packet_queue_flush(&is->videoq);
2456  packet_queue_put(&is->videoq, &flush_pkt);
2457  }
2458  }
2459  is->seek_req = 0;
2460  eof = 0;
2461  }
2462 
2463  /* if the queue are full, no need to read more */
2464  if (!infinite_buffer &&
2465  (is->audioq.size + is->videoq.size + is->subtitleq.size > MAX_QUEUE_SIZE
2466  || ( (is->audioq .size > MIN_AUDIOQ_SIZE || is->audio_stream < 0)
2467  && (is->videoq .nb_packets > MIN_FRAMES || is->video_stream < 0)
2468  && (is->subtitleq.nb_packets > MIN_FRAMES || is->subtitle_stream < 0)))) {
2469  /* wait 10 ms */
2470  SDL_Delay(10);
2471  continue;
2472  }
2473  if (eof) {
2474  if (is->video_stream >= 0) {
2475  av_init_packet(pkt);
2476  pkt->data = NULL;
2477  pkt->size = 0;
2478  pkt->stream_index = is->video_stream;
2479  packet_queue_put(&is->videoq, pkt);
2480  }
2481  if (is->audio_stream >= 0 &&
2483  av_init_packet(pkt);
2484  pkt->data = NULL;
2485  pkt->size = 0;
2486  pkt->stream_index = is->audio_stream;
2487  packet_queue_put(&is->audioq, pkt);
2488  }
2489  SDL_Delay(10);
2490  if (is->audioq.size + is->videoq.size + is->subtitleq.size == 0) {
2491  if (loop != 1 && (!loop || --loop)) {
2492  stream_seek(player, start_time != AV_NOPTS_VALUE ? start_time : 0, 0, 0);
2493  } else if (!noautoexit) {
2494  ret = AVERROR_EOF;
2495  goto fail;
2496  }
2497  }
2498  continue;
2499  }
2500  ret = av_read_frame(ic, pkt);
2501  if (ret < 0) {
2502  if (ret == AVERROR_EOF || (ic->pb && ic->pb->eof_reached))
2503  eof = 1;
2504  if (ic->pb && ic->pb->error)
2505  break;
2506  SDL_Delay(100); /* wait for user event */
2507  continue;
2508  }
2509  /* check if packet is in play range specified by user, then queue, otherwise discard */
2510  pkt_in_play_range = duration == AV_NOPTS_VALUE ||
2511  (pkt->pts - ic->streams[pkt->stream_index]->start_time) *
2512  av_q2d(ic->streams[pkt->stream_index]->time_base) -
2513  (double)(start_time != AV_NOPTS_VALUE ? start_time : 0) / 1000000
2514  <= ((double)duration / 1000000);
2515  if (pkt->stream_index == is->audio_stream && pkt_in_play_range) {
2516  packet_queue_put(&is->audioq, pkt);
2517  } else if (pkt->stream_index == is->video_stream && pkt_in_play_range) {
2518  packet_queue_put(&is->videoq, pkt);
2519  } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
2520  packet_queue_put(&is->subtitleq, pkt);
2521  } else {
2522  av_packet_unref(pkt);
2523  }
2524  }
2525  /* wait until the end */
2526  while (!is->abort_request) {
2527  SDL_Delay(100);
2528  }
2529 
2530  ret = 0;
2531 
2532 fail:
2533  stream_close(is);
2534 
2535  if (ret != 0) {
2536  SDL_Event event;
2537 
2538  event.type = FF_QUIT_EVENT;
2539  event.user.data1 = is;
2540  SDL_PushEvent(&event);
2541  }
2542  return 0;
2543 }
2544 
2545 static int stream_open(PlayerState *is,
2546  const char *filename, AVInputFormat *iformat)
2547 {
2548  int ret;
2549 
2550  av_strlcpy(is->filename, filename, sizeof(is->filename));
2551  is->iformat = iformat;
2552  is->ytop = 0;
2553  is->xleft = 0;
2554 
2555  if ((ret = stream_setup(is)) < 0) {
2556  return ret;
2557  }
2558 
2559  is->video_filter_mutex = SDL_CreateMutex();
2560 
2561  /* start video display */
2562  is->pictq_mutex = SDL_CreateMutex();
2563  is->pictq_cond = SDL_CreateCond();
2564 
2565  is->subpq_mutex = SDL_CreateMutex();
2566  is->subpq_cond = SDL_CreateCond();
2567 
2568  is->av_sync_type = av_sync_type;
2569  is->refresh_tid = SDL_CreateThread(refresh_thread, is);
2570  if (!is->refresh_tid)
2571  return -1;
2572  is->parse_tid = SDL_CreateThread(decode_thread, is);
2573  if (!is->parse_tid)
2574  return -1;
2575  return 0;
2576 }
2577 
2579 {
2580  AVFormatContext *ic = is->ic;
2581  int start_index, stream_index;
2582  AVStream *st;
2583 
2584  if (codec_type == AVMEDIA_TYPE_VIDEO)
2585  start_index = is->video_stream;
2586  else if (codec_type == AVMEDIA_TYPE_AUDIO)
2587  start_index = is->audio_stream;
2588  else
2589  start_index = is->subtitle_stream;
2590  if (start_index < (codec_type == AVMEDIA_TYPE_SUBTITLE ? -1 : 0))
2591  return;
2592  stream_index = start_index;
2593  for (;;) {
2594  if (++stream_index >= is->ic->nb_streams)
2595  {
2596  if (codec_type == AVMEDIA_TYPE_SUBTITLE)
2597  {
2598  stream_index = -1;
2599  goto the_end;
2600  } else
2601  stream_index = 0;
2602  }
2603  if (stream_index == start_index)
2604  return;
2605  st = ic->streams[stream_index];
2606  if (st->codecpar->codec_type == codec_type) {
2607  /* check that parameters are OK */
2608  switch (codec_type) {
2609  case AVMEDIA_TYPE_AUDIO:
2610  if (st->codecpar->sample_rate != 0 &&
2611  st->codecpar->channels != 0)
2612  goto the_end;
2613  break;
2614  case AVMEDIA_TYPE_VIDEO:
2615  case AVMEDIA_TYPE_SUBTITLE:
2616  goto the_end;
2617  default:
2618  break;
2619  }
2620  }
2621  }
2622  the_end:
2623  stream_component_close(is, start_index);
2624  stream_component_open(is, stream_index);
2625 }
2626 
2627 
2628 static void toggle_full_screen(void)
2629 {
2630 #if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
2631  /* OS X needs to empty the picture_queue */
2632  int i;
2633  for (i = 0; i < VIDEO_PICTURE_QUEUE_SIZE; i++)
2634  player->pictq[i].reallocate = 1;
2635 #endif
2637  video_open(player);
2638 }
2639 
2640 static void toggle_pause(void)
2641 {
2642  if (player)
2643  stream_pause(player);
2644  step = 0;
2645 }
2646 
2647 static void step_to_next_frame(void)
2648 {
2649  if (player) {
2650  /* if the stream is paused unpause it, then step */
2651  if (player->paused)
2652  stream_pause(player);
2653  }
2654  step = 1;
2655 }
2656 
2657 static void toggle_audio_display(void)
2658 {
2659  if (player) {
2660  int bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
2661  player->show_audio = (player->show_audio + 1) % 3;
2663  player->xleft, player->ytop, player->width, player->height,
2664  bgcolor);
2665  SDL_UpdateRect(screen, player->xleft, player->ytop, player->width, player->height);
2666  }
2667 }
2668 
2669 static void seek_chapter(PlayerState *is, int incr)
2670 {
2671  int64_t pos = get_master_clock(is) * AV_TIME_BASE;
2672  int i;
2673 
2674  if (!is->ic->nb_chapters)
2675  return;
2676 
2677  /* find the current chapter */
2678  for (i = 0; i < is->ic->nb_chapters; i++) {
2679  AVChapter *ch = is->ic->chapters[i];
2680  if (av_compare_ts(pos, AV_TIME_BASE_Q, ch->start, ch->time_base) < 0) {
2681  i--;
2682  break;
2683  }
2684  }
2685 
2686  i += incr;
2687  i = FFMAX(i, 0);
2688  if (i >= is->ic->nb_chapters)
2689  return;
2690 
2691  av_log(NULL, AV_LOG_VERBOSE, "Seeking to chapter %d.\n", i);
2692  stream_seek(is, av_rescale_q(is->ic->chapters[i]->start, is->ic->chapters[i]->time_base,
2693  AV_TIME_BASE_Q), 0, 0);
2694 }
2695 
2696 /* handle an event sent by the GUI */
2697 static void event_loop(void)
2698 {
2699  SDL_Event event;
2700  double incr, pos, frac;
2701 
2702  for (;;) {
2703  double x;
2704  SDL_WaitEvent(&event);
2705  switch (event.type) {
2706  case SDL_KEYDOWN:
2707  if (exit_on_keydown) {
2708  do_exit();
2709  break;
2710  }
2711  switch (event.key.keysym.sym) {
2712  case SDLK_ESCAPE:
2713  case SDLK_q:
2714  do_exit();
2715  break;
2716  case SDLK_f:
2718  break;
2719  case SDLK_p:
2720  case SDLK_SPACE:
2721  toggle_pause();
2722  break;
2723  case SDLK_s: // S: Step to next frame
2725  break;
2726  case SDLK_a:
2727  if (player)
2729  break;
2730  case SDLK_v:
2731  if (player)
2733  break;
2734  case SDLK_t:
2735  if (player)
2737  break;
2738  case SDLK_w:
2740  break;
2741  case SDLK_PAGEUP:
2742  seek_chapter(player, 1);
2743  break;
2744  case SDLK_PAGEDOWN:
2745  seek_chapter(player, -1);
2746  break;
2747  case SDLK_LEFT:
2748  incr = -10.0;
2749  goto do_seek;
2750  case SDLK_RIGHT:
2751  incr = 10.0;
2752  goto do_seek;
2753  case SDLK_UP:
2754  incr = 60.0;
2755  goto do_seek;
2756  case SDLK_DOWN:
2757  incr = -60.0;
2758  do_seek:
2759  if (player) {
2760  if (seek_by_bytes) {
2761  if (player->video_stream >= 0 && player->video_current_pos >= 0) {
2762  pos = player->video_current_pos;
2763  } else if (player->audio_stream >= 0 && player->audio_pkt.pos >= 0) {
2764  pos = player->audio_pkt.pos;
2765  } else
2766  pos = avio_tell(player->ic->pb);
2767  if (player->ic->bit_rate)
2768  incr *= player->ic->bit_rate / 8.0;
2769  else
2770  incr *= 180000.0;
2771  pos += incr;
2772  stream_seek(player, pos, incr, 1);
2773  } else {
2774  pos = get_master_clock(player);
2775  pos += incr;
2776  stream_seek(player, (int64_t)(pos * AV_TIME_BASE), (int64_t)(incr * AV_TIME_BASE), 0);
2777  }
2778  }
2779  break;
2780  default:
2781  break;
2782  }
2783  break;
2784  case SDL_MOUSEBUTTONDOWN:
2785  if (exit_on_mousedown) {
2786  do_exit();
2787  break;
2788  }
2789  case SDL_MOUSEMOTION:
2790  if (event.type == SDL_MOUSEBUTTONDOWN) {
2791  x = event.button.x;
2792  } else {
2793  if (event.motion.state != SDL_PRESSED)
2794  break;
2795  x = event.motion.x;
2796  }
2797  if (player) {
2798  if (seek_by_bytes || player->ic->duration <= 0) {
2799  uint64_t size = avio_size(player->ic->pb);
2800  stream_seek(player, size*x/player->width, 0, 1);
2801  } else {
2802  int64_t ts;
2803  int ns, hh, mm, ss;
2804  int tns, thh, tmm, tss;
2805  tns = player->ic->duration / 1000000LL;
2806  thh = tns / 3600;
2807  tmm = (tns % 3600) / 60;
2808  tss = (tns % 60);
2809  frac = x / player->width;
2810  ns = frac * tns;
2811  hh = ns / 3600;
2812  mm = (ns % 3600) / 60;
2813  ss = (ns % 60);
2814  fprintf(stderr, "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n", frac*100,
2815  hh, mm, ss, thh, tmm, tss);
2816  ts = frac * player->ic->duration;
2817  if (player->ic->start_time != AV_NOPTS_VALUE)
2818  ts += player->ic->start_time;
2819  stream_seek(player, ts, 0, 0);
2820  }
2821  }
2822  break;
2823  case SDL_VIDEORESIZE:
2824  if (player) {
2825  screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0,
2826  SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
2827  screen_width = player->width = event.resize.w;
2828  screen_height = player->height = event.resize.h;
2829  }
2830  break;
2831  case SDL_QUIT:
2832  case FF_QUIT_EVENT:
2833  do_exit();
2834  break;
2835  case FF_ALLOC_EVENT:
2836  SDL_LockMutex(player->video_filter_mutex);
2837  if (player->out_video_filter) {
2838  video_open(event.user.data1);
2839  alloc_picture(event.user.data1);
2840  }
2841  SDL_UnlockMutex(player->video_filter_mutex);
2842  break;
2843  case FF_REFRESH_EVENT:
2844  video_refresh_timer(event.user.data1);
2845  player->refresh = 0;
2846  break;
2847  default:
2848  break;
2849  }
2850  }
2851 }
2852 
2853 static int opt_frame_size(void *optctx, const char *opt, const char *arg)
2854 {
2856  "Option '%s' has been removed, use private format options instead\n", opt);
2857  return AVERROR(EINVAL);
2858 }
2859 
2860 static int opt_width(void *optctx, const char *opt, const char *arg)
2861 {
2862  screen_width = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
2863  return 0;
2864 }
2865 
2866 static int opt_height(void *optctx, const char *opt, const char *arg)
2867 {
2868  screen_height = parse_number_or_die(opt, arg, OPT_INT64, 1, INT_MAX);
2869  return 0;
2870 }
2871 
2872 static int opt_format(void *optctx, const char *opt, const char *arg)
2873 {
2874  file_iformat = av_find_input_format(arg);
2875  if (!file_iformat) {
2876  fprintf(stderr, "Unknown input format: %s\n", arg);
2877  return AVERROR(EINVAL);
2878  }
2879  return 0;
2880 }
2881 
2882 static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
2883 {
2885  "Option '%s' has been removed, use private format options instead\n", opt);
2886  return AVERROR(EINVAL);
2887 }
2888 
2889 static int opt_sync(void *optctx, const char *opt, const char *arg)
2890 {
2891  if (!strcmp(arg, "audio"))
2893  else if (!strcmp(arg, "video"))
2895  else if (!strcmp(arg, "ext"))
2897  else {
2898  fprintf(stderr, "Unknown value for %s: %s\n", opt, arg);
2899  exit(1);
2900  }
2901  return 0;
2902 }
2903 
2904 static int opt_seek(void *optctx, const char *opt, const char *arg)
2905 {
2906  start_time = parse_time_or_die(opt, arg, 1);
2907  return 0;
2908 }
2909 
2910 static int opt_duration(void *optctx, const char *opt, const char *arg)
2911 {
2912  duration = parse_time_or_die(opt, arg, 1);
2913  return 0;
2914 }
2915 
2916 #define OFF(x) offsetof(PlayerState, x)
2917 static const OptionDef options[] = {
2918 #include "cmdutils_common_opts.h"
2919  { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
2920  { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
2921  { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
2922  { "fs", OPT_BOOL, { &is_full_screen }, "force full screen" },
2923  { "an", OPT_BOOL, { &audio_disable }, "disable audio" },
2924  { "vn", OPT_BOOL, { &video_disable }, "disable video" },
2925  { "ast", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_number" },
2926  { "vst", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_number" },
2927  { "sst", OPT_INT | HAS_ARG | OPT_EXPERT, { &wanted_stream[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_number" },
2928  { "ss", HAS_ARG, { .func_arg = opt_seek }, "seek to a given position in seconds", "pos" },
2929  { "t", HAS_ARG, { .func_arg = opt_duration }, "play \"duration\" seconds of audio/video", "duration" },
2930  { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
2931  { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
2932  { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
2933  { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
2934  { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
2935  { "bug", OPT_INT | HAS_ARG | OPT_EXPERT, { &workaround_bugs }, "workaround bugs", "" },
2936  { "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
2937  { "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" },
2938  { "drp", OPT_INT | HAS_ARG | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
2939  { "skiploop", OPT_INT | HAS_ARG | OPT_EXPERT, { &skip_loop_filter }, "", "" },
2940  { "skipframe", OPT_INT | HAS_ARG | OPT_EXPERT, { &skip_frame }, "", "" },
2941  { "skipidct", OPT_INT | HAS_ARG | OPT_EXPERT, { &skip_idct }, "", "" },
2942  { "idct", OPT_INT | HAS_ARG | OPT_EXPERT, { &idct }, "set idct algo", "algo" },
2943  { "ec", OPT_INT | HAS_ARG | OPT_EXPERT, { &error_concealment }, "set error concealment options", "bit_mask" },
2944  { "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
2945  { "noautoexit", OPT_BOOL | OPT_EXPERT, { &noautoexit }, "Do not exit at the end of playback", "" },
2946  { "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
2947  { "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
2948  { "loop", OPT_INT | HAS_ARG | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
2949  { "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
2950  { "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
2951  { "window_title", OPT_STRING | HAS_ARG, { &window_title }, "set window title", "window title" },
2952  { "vf", OPT_STRING | HAS_ARG, { &vfilters }, "video filters", "filter list" },
2953  { "rdftspeed", OPT_INT | HAS_ARG| OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
2954  { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { opt_default }, "generic catch all option", "" },
2955  { "i", 0, { NULL }, "avconv compatibility dummy option", ""},
2956  { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
2957  { "c", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFF(codec_names) }, "codec name", "codec" },
2958  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFF(codec_names) }, "codec name", "codec" },
2959 
2960  { NULL, },
2961 };
2962 
2963 static void show_usage(void)
2964 {
2965  printf("Simple media player\n");
2966  printf("usage: %s [options] input_file\n", program_name);
2967  printf("\n");
2968 }
2969 
2970 void show_help_default(const char *opt, const char *arg)
2971 {
2973  show_usage();
2974  show_help_options(options, "Main options:", 0, OPT_EXPERT, 0);
2975  show_help_options(options, "Advanced options:", OPT_EXPERT, 0, 0);
2976  printf("\n");
2979  printf("\nWhile playing:\n"
2980  "q, ESC quit\n"
2981  "f toggle full screen\n"
2982  "p, SPC pause\n"
2983  "a cycle audio channel\n"
2984  "v cycle video channel\n"
2985  "t cycle subtitle channel\n"
2986  "w show audio waves\n"
2987  "s activate frame-step mode\n"
2988  "left/right seek backward/forward 10 seconds\n"
2989  "down/up seek backward/forward 1 minute\n"
2990  "mouse click seek to percentage in file corresponding to fraction of width\n"
2991  );
2992 }
2993 
2994 static void opt_input_file(void *optctx, const char *filename)
2995 {
2996  if (input_filename) {
2997  fprintf(stderr, "Argument '%s' provided as input filename, but '%s' was already specified.\n",
2998  filename, input_filename);
2999  exit(1);
3000  }
3001  if (!strcmp(filename, "-"))
3002  filename = "pipe:";
3003  input_filename = filename;
3004 }
3005 
3006 /* Called from the main */
3007 int main(int argc, char **argv)
3008 {
3009  int flags;
3010 
3012  parse_loglevel(argc, argv, options);
3013 
3014  /* register all codecs, demux and protocols */
3016 #if CONFIG_AVDEVICE
3018 #endif
3020  av_register_all();
3022 
3023  init_opts();
3024 
3025  show_banner();
3026 
3027  parse_options(player, argc, argv, options, opt_input_file);
3028 
3029  if (!input_filename) {
3030  show_usage();
3031  fprintf(stderr, "An input file must be specified\n");
3032  fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
3033  exit(1);
3034  }
3035 
3036  if (display_disable) {
3037  video_disable = 1;
3038  }
3039  flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
3040 #if !defined(__MINGW32__) && !defined(__APPLE__)
3041  flags |= SDL_INIT_EVENTTHREAD; /* Not supported on Windows or Mac OS X */
3042 #endif
3043  if (SDL_Init (flags)) {
3044  fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
3045  exit(1);
3046  }
3047 
3048  if (!display_disable) {
3049  const SDL_VideoInfo *vi = SDL_GetVideoInfo();
3050  fs_screen_width = vi->current_w;
3051  fs_screen_height = vi->current_h;
3052  }
3053 
3054  SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
3055  SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
3056  SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
3057 
3058  av_init_packet(&flush_pkt);
3059  flush_pkt.data = (uint8_t *)&flush_pkt;
3060 
3061  if (stream_open(player, input_filename, file_iformat) < 0) {
3062  fprintf(stderr, "Could not setup the player\n");
3063  stream_close(player);
3064  exit(1);
3065  }
3066 
3067  event_loop();
3068 
3069  /* never returns */
3070 
3071  return 0;
3072 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1137
SDL_Overlay * bmp
Definition: avplay.c:104
double audio_diff_avg_coef
Definition: avplay.c:148
AVStream * video_st
Definition: avplay.c:197
uint64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
AVPacketList * first_pkt
Definition: avplay.c:89
int64_t num_faulty_dts
Number of incorrect PTS values so far.
Definition: cmdutils.h:465
const struct AVCodec * codec
Definition: avcodec.h:1418
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
static void update_sample_display(PlayerState *is, short *samples, int samples_size)
Definition: avplay.c:1701
int show_audio
Definition: avplay.c:172
SDL_Thread * refresh_tid
Definition: avplay.c:127
double frame_last_delay
Definition: avplay.c:194
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
#define OPT_EXPERT
Definition: cmdutils.h:144
static int audio_write_get_buf_size(PlayerState *is)
Definition: avplay.c:698
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:297
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
double target_clock
Definition: avplay.c:102
double video_current_pts
Definition: avplay.c:200
static double rint(double x)
Definition: libm.h:130
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:3426
int64_t num_faulty_pts
Definition: cmdutils.h:464
#define SWS_BICUBIC
Definition: swscale.h:59
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1181
int last_paused
Definition: avplay.c:132
int seek_flags
Definition: avplay.c:134
#define OPT_VIDEO
Definition: cmdutils.h:146
static int subtitle_thread(void *arg)
Definition: avplay.c:1631
static int64_t sws_flags
Definition: avplay.c:86
enum AVSampleFormat sdl_sample_fmt
Definition: avplay.c:162
misc image utilities
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:71
SDL_mutex * subpq_mutex
Definition: avplay.c:189
static const AVFilterPad outputs[]
Definition: af_ashowinfo.c:259
int ytop
Definition: avplay.c:210
int avresample_convert(AVAudioResampleContext *avr, uint8_t **output, int out_plane_size, int out_samples, uint8_t *const *input, int in_plane_size, int in_samples)
Convert input samples and write them to the output FIFO.
Definition: utils.c:330
Main libavfilter public API header.
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1366
int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:284
AVRational sar
Definition: avplay.c:110
Memory buffer source API.
const char * desc
Definition: nvenc.c:101
static int workaround_bugs
Definition: avplay.c:248
void show_banner(void)
Print the program banner to stderr.
Definition: cmdutils.c:820
static void free_subpicture(SubPicture *sp)
Definition: avplay.c:634
attribute_deprecated int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: utils.c:1624
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
Definition: avfilter.h:758
double audio_diff_cum
Definition: avplay.c:147
static int show_status
Definition: avplay.c:243
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1492
#define OPT_AUDIO
Definition: cmdutils.h:147
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3483
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:770
int num
numerator
Definition: rational.h:44
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:258
int nb_colors
number of colors in pict, undefined when pict is not set
Definition: avcodec.h:3430
int subpq_size
Definition: avplay.c:188
int size
Definition: avcodec.h:1347
static void toggle_pause(void)
Definition: avplay.c:2640
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
static double get_audio_clock(PlayerState *is)
Definition: avplay.c:925
Various defines for YUV<->RGB conversion.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1804
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
enum AVMediaType codec_type
Definition: rtp.c:36
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
Definition: avplay.c:357
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1621
uint8_t * av_stream_get_side_data(AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:3265
int abort_request
Definition: avplay.c:92
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:55
unsigned num_rects
Definition: avcodec.h:3463
static void packet_queue_abort(PacketQueue *q)
Definition: avplay.c:345
int out_size
Definition: movenc.c:55
void avdevice_register_all(void)
Initialize libavdevice and register all the input and output devices.
Definition: alldevices.c:41
enum AVPixelFormat pix_fmt
Definition: avplay.c:108
enum AVMediaType type
Definition: avcodec.h:3133
static int configure_video_filters(AVFilterGraph *graph, PlayerState *is, const char *vfilters)
Definition: avplay.c:1435
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:68
discard all
Definition: avcodec.h:689
int subtitle_stream_changed
Definition: avplay.c:183
#define AV_CH_LAYOUT_STEREO
static void packet_queue_flush(PacketQueue *q)
Definition: avplay.c:293
void avcodec_register_all(void)
Register all the codecs, parsers and bitstream filters which were enabled at configuration time...
Definition: allcodecs.c:61
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: utils.c:1673
VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE]
Definition: avplay.c:203
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: avplay.c:60
AVCodec.
Definition: avcodec.h:3120
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:1597
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3475
void init_pts_correction(PtsCorrectionContext *ctx)
Reset the state of the PtsCorrectionContext.
Definition: cmdutils.c:1431
static double get_master_clock(PlayerState *is)
Definition: avplay.c:960
static void video_audio_display(PlayerState *s)
Definition: avplay.c:712
static int get_video_frame(PlayerState *is, AVFrame *frame, int64_t *pts, AVPacket *pkt)
Definition: avplay.c:1377
static int64_t duration
Definition: avplay.c:246
void avresample_free(AVAudioResampleContext **avr)
Free AVAudioResampleContext and associated AVOption values.
Definition: utils.c:278
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
Definition: avfilter.h:608
SDL_Thread * video_tid
Definition: avplay.c:126
AVFilterContext * in_video_filter
Definition: avplay.c:214
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1535
static AVInputFormat * file_iformat
Definition: avplay.c:227
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:202
AVSubtitleRect ** rects
Definition: avcodec.h:3464
int pictq_size
Definition: avplay.c:204
static void video_display(PlayerState *is)
Definition: avplay.c:898
static void opt_input_file(void *optctx, const char *filename)
Definition: avplay.c:2994
Format I/O context.
Definition: avformat.h:940
#define FF_REFRESH_EVENT
Definition: avplay.c:277
int last_i_start
Definition: avplay.c:175
enum AVDiscard skip_frame
Definition: avcodec.h:2989
#define OFF(x)
Definition: avplay.c:2916
memory buffer sink API
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:248
static int opt_format(void *optctx, const char *opt, const char *arg)
Definition: avplay.c:2872
static int16_t block[64]
Definition: dct.c:97
#define AV_LOG_QUIET
Print no output.
Definition: log.h:106
static int stream_component_open(PlayerState *is, int stream_index)
Definition: avplay.c:2033
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:3428
static void blend_subrect(uint8_t *dst[4], uint16_t dst_linesize[4], const AVSubtitleRect *rect, int imgw, int imgh)
Definition: avplay.c:432
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:863
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:270
#define SAMPLE_ARRAY_SIZE
Definition: avplay.c:84
int sdl_sample_rate
Definition: avplay.c:165
Public dictionary API.
uint64_t sdl_channel_layout
Definition: avplay.c:163
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:77
int size
Definition: avplay.c:91
static double get_video_clock(PlayerState *is)
Definition: avplay.c:942
int width
Definition: avplay.c:210
void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Trivial log callback.
Definition: cmdutils.c:82
uint8_t
double pts
Definition: avplay.c:114
static double get_external_clock(PlayerState *is)
Definition: avplay.c:952
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:68
static int stream_setup(PlayerState *is)
Definition: avplay.c:2275
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:439
static int opt_frame_pix_fmt(void *optctx, const char *opt, const char *arg)
Definition: avplay.c:2882
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.
Definition: avformat.h:543
#define HAS_ARG
Definition: cmdutils.h:142
static int wanted_stream[AVMEDIA_TYPE_NB]
Definition: avplay.c:236
AVFrame * frame
Definition: avplay.c:170
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:150
AVPacket pkt
Definition: avformat.h:1298
static int decode_thread(void *arg)
Definition: avplay.c:2409
static int seek_by_bytes
Definition: avplay.c:241
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: avcodec.h:1254
#define b
Definition: input.c:52
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:211
#define AVFMT_FLAG_GENPTS
Generate missing pts even if it requires parsing future frames.
Definition: avformat.h:1052
#define RGBA_IN(r, g, b, a, s)
Definition: avplay.c:406
static void stream_close(PlayerState *is)
Definition: avplay.c:2258
void init_opts(void)
Initialize the cmdutils option system, in particular allocate the *_opts contexts.
Definition: cmdutils.c:63
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1008
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:2885
void avfilter_register_all(void)
Initialize the filter system.
Definition: allfilters.c:39
static PlayerState * player
Definition: avplay.c:271
AVCodecContext * audio_dec
Definition: avplay.c:152
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:136
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.
const char data[16]
Definition: mxf.c:70
static PlayerState player_state
Definition: avplay.c:270
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:69
static int synchronize_audio(PlayerState *is, short *samples, int samples_size1, double pts)
Definition: avplay.c:1721
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:38
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1051
static int audio_disable
Definition: avplay.c:234
uint8_t * data
Definition: avcodec.h:1346
void parse_options(void *optctx, int argc, char **argv, const OptionDef *options, void(*parse_arg_function)(void *, const char *))
Definition: cmdutils.c:339
double frame_timer
Definition: avplay.c:192
static int flags
Definition: log.c:50
int avformat_network_init(void)
Do global initialization of network components.
Definition: utils.c:3100
int refresh
Definition: avplay.c:220
#define OPT_SPEC
Definition: cmdutils.h:157
#define AVERROR_EOF
End of file.
Definition: error.h:51
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:140
static const OptionDef options[]
Definition: avplay.c:2917
int width
Definition: avplay.c:105
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:153
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the &#39;-loglevel&#39; option in the command line args and apply it.
Definition: cmdutils.c:429
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:3429
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:295
#define INSERT_FILT(name, arg)
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:135
double video_current_pts_drift
Definition: avplay.c:201
static int genpts
Definition: avplay.c:250
static AVPacket flush_pkt
Definition: avplay.c:274
int(* callback)(void *)
Definition: avio.h:52
void avresample_close(AVAudioResampleContext *avr)
Close AVAudioResampleContext.
Definition: utils.c:262
#define FF_IDCT_AUTO
Definition: avcodec.h:2736
PacketQueue subtitleq
Definition: avplay.c:186
#define r
Definition: input.c:51
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:1653
SpecifierOpt * codec_names
Definition: avplay.c:222
int64_t external_clock_time
Definition: avplay.c:144
AVDictionary * format_opts
Definition: cmdutils.c:59
FFTSample * rdft_data
Definition: avplay.c:178
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:99
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:453
Main libavdevice API header.
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:2482
enum AVCodecID id
Definition: avcodec.h:3134
SDL_cond * pictq_cond
Definition: avplay.c:206
static int64_t start_time
Definition: avplay.c:245
double external_clock
Definition: avplay.c:143
static void packet_queue_end(PacketQueue *q)
Definition: avplay.c:310
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:190
unsigned int audio_buf_size
Definition: avplay.c:158
uint8_t * audio_buf1
Definition: avplay.c:157
int main(int argc, char **argv)
Definition: avplay.c:3007
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:422
static void show_usage(void)
Definition: avplay.c:2963
int av_sync_type
Definition: avplay.c:142
int audio_diff_avg_count
Definition: avplay.c:150
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:3427
static int decode_interrupt_cb(void *ctx)
Definition: avplay.c:2253
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:80
uint64_t resample_channel_layout
Definition: avplay.c:167
int error_concealment
error concealment flags
Definition: avcodec.h:2617
static int fast
Definition: avplay.c:249
g
Definition: yuv2rgb.c:546
int capabilities
Codec capabilities.
Definition: avcodec.h:3139
static int framedrop
Definition: avplay.c:261
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
Definition: utils.c:2536
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:175
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3479
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:307
float skip_frames_index
Definition: avplay.c:219
static enum AVDiscard skip_idct
Definition: avplay.c:253
AVChapter ** chapters
Definition: avformat.h:1138
#define wrap(func)
Definition: neontest.h:62
#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:274
static int64_t audio_callback_time
Definition: avplay.c:272
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
static double compute_target_time(double frame_current_pts, PlayerState *is)
Definition: avplay.c:1006
#define FFMAX(a, b)
Definition: common.h:64
float FFTSample
Definition: avfft.h:35
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:81
#define fail()
Definition: checkasm.h:80
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:268
#define AV_NOSYNC_THRESHOLD
Definition: avplay.c:73
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2203
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:104
void av_rdft_calc(RDFTContext *s, FFTSample *data)
uint32_t end_display_time
Definition: avcodec.h:3462
int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
Attempt to guess proper monotonic timestamps for decoded video frames which might have incorrect time...
Definition: cmdutils.c:1437
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:294
static int fs_screen_width
Definition: avplay.c:230
AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: avfilter.c:299
static int refresh_thread(void *opaque)
Definition: avplay.c:908
static int screen_height
Definition: avplay.c:233
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:996
int video_stream
Definition: avplay.c:196
AVDictionary * opts
Definition: movenc.c:50
PacketQueue audioq
Definition: avplay.c:153
static void toggle_audio_display(void)
Definition: avplay.c:2657
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
Definition: utils.c:2545
SDL_mutex * mutex
Definition: avplay.c:93
AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:162
int linesize[4]
Definition: avcodec.h:3444
const char * name
Definition: qsvenc.c:44
char filename[1024]
input or output filename
Definition: avformat.h:1016
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:241
external API header
#define FFMIN(a, b)
Definition: common.h:66
static int noautoexit
Definition: avplay.c:257
int reallocate
Definition: avplay.c:107
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:215
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:136
int width
picture width / height.
Definition: avcodec.h:1580
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:2735
int nb_packets
Definition: avplay.c:90
int audio_buf_index
Definition: avplay.c:159
#define AV_SYNC_THRESHOLD
Definition: avplay.c:71
static int audio_decode_frame(PlayerState *is, double *pts_ptr)
Definition: avplay.c:1795
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
AVCodecContext * video_dec
Definition: avplay.c:198
#define MIN_FRAMES
Definition: avplay.c:64
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color)
Definition: avplay.c:392
static int autorotate
Definition: avplay.c:266
uint16_t format
Definition: avcodec.h:3460
double audio_diff_threshold
Definition: avplay.c:149
#define OPT_INT64
Definition: cmdutils.h:151
Definition: avfft.h:72
void av_rdft_end(RDFTContext *s)
char * specifier
stream/chapter/program/...
Definition: cmdutils.h:129
RDFTContext * av_rdft_init(int nbits, enum RDFTransformType trans)
Set up a real FFT.
AVSubtitle sub
Definition: avplay.c:115
static AVCodec * find_codec_or_die(const char *name, enum AVMediaType type)
Definition: avplay.c:1986
int rdft_bits
Definition: avplay.c:177
int subtitle_stream
Definition: avplay.c:182
enum AVPixelFormat pix_fmt
Definition: movenc.c:853
float skip_frames
Definition: avplay.c:218
union SpecifierOpt::@2 u
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:3443
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:2481
AVFilterContext * filter_ctx
filter context associated to this input/output
Definition: avfilter.h:752
#define BPP
Definition: avplay.c:430
int xleft
Definition: avplay.c:210
AVPacket audio_pkt_temp
Definition: avplay.c:160
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:94
if(ac->has_optimized_func)
static int opt_sync(void *optctx, const char *opt, const char *arg)
Definition: avplay.c:2889
uint8_t * str
Definition: cmdutils.h:131
int audio_hw_buf_size
Definition: avplay.c:154
Stream structure.
Definition: avformat.h:705
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal decoder state / flush internal buffers.
Definition: utils.c:2285
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:747
#define FF_ALLOC_EVENT
Definition: avplay.c:276
#define MIN_AUDIOQ_SIZE
Definition: avplay.c:63
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:191
static int stream_open(PlayerState *is, const char *filename, AVInputFormat *iformat)
Definition: avplay.c:2545
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:3112
NULL
Definition: eval.c:55
static SDL_Surface * screen
Definition: avplay.c:280
static int width
Definition: utils.c:156
const char program_name[]
program name, defined by the program for show_version().
Definition: avplay.c:59
static void stream_component_close(PlayerState *is, int stream_index)
Definition: avplay.c:2165
enum AVMediaType codec_type
Definition: avcodec.h:1417
#define SUBPICTURE_QUEUE_SIZE
Definition: avplay.c:98
double pts
Definition: avplay.c:101
static void do_exit(void)
Definition: avplay.c:1212
AVPacketList * last_pkt
Definition: avplay.c:89
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:60
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:151
enum AVCodecID codec_id
Definition: avcodec.h:1426
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:247
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:219
int sample_rate
samples per second
Definition: avcodec.h:2152
enum AVDiscard skip_idct
Definition: avcodec.h:2983
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:158
AVIOContext * pb
I/O context.
Definition: avformat.h:982
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:803
SDL_cond * subpq_cond
Definition: avplay.c:190
FFT functions.
SDL_Thread * parse_tid
Definition: avplay.c:125
main external API structure.
Definition: avcodec.h:1409
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:2029
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:347
double frame_last_pts
Definition: avplay.c:193
static int opt_width(void *optctx, const char *opt, const char *arg)
Definition: avplay.c:2860
#define YUVA_OUT(d, y, u, v, a)
Definition: avplay.c:424
static int video_thread(void *arg)
Definition: avplay.c:1530
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1687
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:206
static void toggle_full_screen(void)
Definition: avplay.c:2628
#define ALPHA_BLEND(a, oldp, newp, s)
Definition: avplay.c:403
AVAudioResampleContext * avr
Definition: avplay.c:169
int height
Definition: avplay.c:210
SDL_mutex * pictq_mutex
Definition: avplay.c:205
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, AVFilterInOut *inputs, AVFilterInOut *outputs, void *log_ctx)
Add a graph described by a string to a graph.
Definition: graphparser.c:486
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:68
static int opt_seek(void *optctx, const char *opt, const char *arg)
Definition: avplay.c:2904
static void stream_seek(PlayerState *is, int64_t pos, int64_t rel, int seek_by_bytes)
Definition: avplay.c:981
int sample_rate
Sample rate of the audio data.
Definition: frame.h:289
static const AVFilterPad inputs[]
Definition: af_ashowinfo.c:248
int pad_idx
index of the filt_ctx pad to use for linking
Definition: avfilter.h:755
static const uint8_t color[NB_LEVELS]
Definition: log.c:62
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:108
rational number numerator/denominator
Definition: rational.h:43
static int is_full_screen
Definition: avplay.c:269
static void stream_cycle_channel(PlayerState *is, int codec_type)
Definition: avplay.c:2578
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:265
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
Parse a string specifying a time and return its corresponding value as a number of microseconds...
Definition: cmdutils.c:123
#define OPT_STRING
Definition: cmdutils.h:145
static void seek_chapter(PlayerState *is, int incr)
Definition: avplay.c:2669
SDL_cond * cond
Definition: avplay.c:94
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:1658
static int output_picture2(PlayerState *is, AVFrame *src_frame, double pts1, int64_t pos)
Definition: avplay.c:1352
AVMediaType
Definition: avutil.h:192
discard useless packets like 0 size packets in avi
Definition: avcodec.h:685
SDL_Thread * subtitle_tid
Definition: avplay.c:181
AVPacket audio_pkt
Definition: avplay.c:161
static int decoder_reorder_pts
Definition: avplay.c:256
#define AUDIO_DIFF_AVG_NB
Definition: avplay.c:81
int read_pause_return
Definition: avplay.c:137
static const char * input_filename
Definition: avplay.c:228
static int step
Definition: avplay.c:247
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:588
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:850
int pictq_windex
Definition: avplay.c:204
#define FRAME_SKIP_FACTOR
Definition: avplay.c:75
static int infinite_buffer
Definition: avplay.c:262
#define u(width,...)
void show_help_default(const char *opt, const char *arg)
Per-avtool specific help handler.
Definition: avplay.c:2970
int error
contains the error code or 0 if no error happened
Definition: avio.h:138
uint8_t silence_buf[SDL_AUDIO_BUFFER_SIZE]
Definition: avplay.c:155
misc parsing utilities
#define SAMPLE_CORRECTION_PERCENT_MAX
Definition: avplay.c:78
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
Add a frame to the buffer source.
Definition: buffersrc.c:152
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1021
SDL_mutex * video_filter_mutex
Definition: avplay.c:216
int64_t seek_pos
Definition: avplay.c:135
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: utils.c:1575
int paused
Definition: avplay.c:131
static int opt_duration(void *optctx, const char *opt, const char *arg)
Definition: avplay.c:2910
int resample_sample_rate
Definition: avplay.c:168
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:580
double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:102
int subpq_rindex
Definition: avplay.c:188
char * name
unique name for this input/output in the list
Definition: avfilter.h:749
#define RGB_TO_U_CCIR(r1, g1, b1, shift)
Definition: colorspace.h:114
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:302
static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
Definition: avplay.c:317
static int64_t pts
Global timestamp for the audio frames.
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:57
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: utils.c:2034
uint8_t * audio_buf
Definition: avplay.c:156
static void stream_pause(PlayerState *is)
Definition: avplay.c:994
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1025
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:146
AVFilterContext * out_video_filter
Definition: avplay.c:215
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:95
int no_background
Definition: avplay.c:129
#define RGB_TO_V_CCIR(r1, g1, b1, shift)
Definition: colorspace.h:118
int height
Definition: gxfenc.c:72
int64_t start
Definition: avformat.h:926
#define MAX_QUEUE_SIZE
Definition: avplay.c:62
int sample_rate
Audio only.
Definition: avcodec.h:3564
static int loop
Definition: avplay.c:260
static int exit_on_keydown
Definition: avplay.c:258
#define OPT_BOOL
Definition: cmdutils.h:143
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:225
AVAudioResampleContext * avresample_alloc_context(void)
Allocate AVAudioResampleContext and set options.
Definition: options.c:96
Main libavformat public API header.
void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.c:765
int64_t pos
Definition: avplay.c:103
#define FF_QUIT_EVENT
Definition: avplay.c:278
AVStream * audio_st
Definition: avplay.c:151
static PlayerState * global_video_state
Definition: avplay.c:2251
#define OPT_INT
Definition: cmdutils.h:148
AVFilterInOut * avfilter_inout_alloc(void)
Allocate a single AVFilterInOut entry.
Definition: graphparser.c:209
AVDictionary * codec_opts
Definition: cmdutils.c:59
int height
Definition: avplay.c:105
struct AVPacketList * next
Definition: avformat.h:1299
int xpos
Definition: avplay.c:179
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:117
static AVInputFormat * iformat
Definition: avprobe.c:68
static const char * window_title
Definition: avplay.c:229
#define YUVA_IN(y, u, v, a, s, pal)
Definition: avplay.c:415
int allocated
Definition: avplay.c:106
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:2092
int64_t start_time
Decoding: pts of the first frame of the stream, in stream time base.
Definition: avformat.h:750
signed 16 bits
Definition: samplefmt.h:63
static int av_sync_type
Definition: avplay.c:244
static void video_image_display(PlayerState *is)
Definition: avplay.c:639
AVInputFormat * iformat
Definition: avplay.c:128
static int compute_mod(int a, int b)
Definition: avplay.c:703
char filename[1024]
Definition: avplay.c:209
uint32_t start_display_time
Definition: avcodec.h:3461
static int queue_picture(PlayerState *is, AVFrame *src_frame, double pts, int64_t pos)
Definition: avplay.c:1263
AVCodecContext * subtitle_dec
Definition: avplay.c:185
static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
Definition: avplay.c:1952
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:2571
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:925
static int fs_screen_height
Definition: avplay.c:231
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:31
enum AVDiscard skip_loop_filter
Definition: avcodec.h:2977
char * key
Definition: dict.h:73
int pictq_rindex
Definition: avplay.c:204
int den
denominator
Definition: rational.h:45
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents...
Definition: cmdutils.c:71
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:61
struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:952
double av_display_rotation_get(const int32_t matrix[9])
The display transformation matrix specifies an affine transformation that should be applied to video ...
Definition: display.c:34
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:2626
RDFTContext * rdft
Definition: avplay.c:176
#define RGB_TO_Y_CCIR(r, g, b)
Definition: colorspace.h:110
int audio_stream
Definition: avplay.c:140
static void event_loop(void)
Definition: avplay.c:2697
enum AVCodecID id
Definition: avcodec.h:581
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:56
int eof_reached
true if eof reached
Definition: avio.h:132
static void video_refresh_timer(void *opaque)
Definition: avplay.c:1047
int len
int channels
number of audio channels
Definition: avcodec.h:2153
double video_clock
Definition: avplay.c:195
int sample_array_index
Definition: avplay.c:174
static int error_concealment
Definition: avplay.c:255
void av_log_set_flags(int arg)
Definition: log.c:210
static int opt_height(void *optctx, const char *opt, const char *arg)
Definition: avplay.c:2866
static int opt_frame_size(void *optctx, const char *opt, const char *arg)
Definition: avplay.c:2853
void show_help_children(const AVClass *class, int flags)
Show help for all options with given flags in class and all its children.
Definition: cmdutils.c:164
int subpq_windex
Definition: avplay.c:188
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1510
double audio_clock
Definition: avplay.c:146
static void step_to_next_frame(void)
Definition: avplay.c:2647
AVDiscard
Definition: avcodec.h:681
int channels
Audio only.
Definition: avcodec.h:3560
An instance of a filter.
Definition: avfilter.h:262
#define VIDEO_PICTURE_QUEUE_SIZE
Definition: avplay.c:97
int bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1042
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1035
static void player_close(PlayerState *is)
Definition: avplay.c:1188
AVStream * subtitle_st
Definition: avplay.c:184
static char * vfilters
Definition: avplay.c:265
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:529
static int video_open(PlayerState *is)
Definition: avplay.c:852
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:60
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:118
static int exit_on_mousedown
Definition: avplay.c:259
AVCodecParameters * codecpar
Definition: avformat.h:831
#define SDL_AUDIO_BUFFER_SIZE
Definition: avplay.c:68
int abort_request
Definition: avplay.c:130
int16_t sample_array[SAMPLE_ARRAY_SIZE]
Definition: avplay.c:173
static int rdftspeed
Definition: avplay.c:264
int64_t seek_rel
Definition: avplay.c:136
AVFormatContext * ic
Definition: avplay.c:138
int stream_index
Definition: avcodec.h:1348
#define OPT_INPUT
Definition: cmdutils.h:162
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:742
static int display_disable
Definition: avplay.c:242
static enum AVDiscard skip_loop_filter
Definition: avplay.c:254
attribute_deprecated int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: utils.c:1559
static int video_disable
Definition: avplay.c:235
#define AV_CH_LAYOUT_MONO
enum AVSampleFormat resample_sample_fmt
Definition: avplay.c:166
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:763
PtsCorrectionContext pts_ctx
Definition: avplay.c:212
int attribute_align_arg av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame)
Get a frame with filtered data from sink and put it in frame.
Definition: buffersink.c:62
static int screen_width
Definition: avplay.c:232
int seek_req
Definition: avplay.c:133
SubPicture subpq[SUBPICTURE_QUEUE_SIZE]
Definition: avplay.c:187
AVPixelFormat
Pixel format.
Definition: pixfmt.h:57
This structure stores compressed data.
Definition: avcodec.h:1323
void av_register_all(void)
Initialize libavformat and register all the muxers, demuxers and protocols.
Definition: allformats.c:44
int avresample_open(AVAudioResampleContext *avr)
Initialize AVAudioResampleContext.
Definition: utils.c:36
static AVCodec * choose_decoder(PlayerState *is, AVFormatContext *ic, AVStream *st)
Definition: avplay.c:2011
int64_t video_current_pos
Definition: avplay.c:202
static void alloc_picture(void *opaque)
Definition: avplay.c:1229
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:184
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1339
PacketQueue videoq
Definition: avplay.c:199
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:235
int nb_codec_names
Definition: avplay.c:223
#define av_unused
Definition: attributes.h:86
static enum AVDiscard skip_frame
Definition: avplay.c:252
static void packet_queue_init(PacketQueue *q)
Definition: avplay.c:285
int sdl_channels
Definition: avplay.c:164
static int idct
Definition: avplay.c:251