GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffplay.c Lines: 0 2075 0.0 %
Date: 2020-07-13 04:22:34 Branches: 0 1427 0.0 %

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