2003-06-07 21:34:02 +03:00
/*
2011-07-26 18:51:34 +03:00
* avplay : Simple Media Player based on the Libav libraries
2003-06-07 21:34:02 +03:00
* Copyright ( c ) 2003 Fabrice Bellard
*
2011-03-18 19:35:10 +02:00
* This file is part of Libav .
2006-10-07 18:30:46 +03:00
*
2011-03-18 19:35:10 +02:00
* Libav is free software ; you can redistribute it and / or
2003-06-07 21:34:02 +03:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 18:30:46 +03:00
* version 2.1 of the License , or ( at your option ) any later version .
2003-06-07 21:34:02 +03:00
*
2011-03-18 19:35:10 +02:00
* Libav is distributed in the hope that it will be useful ,
2003-06-07 21:34:02 +03:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
2011-03-18 19:35:10 +02:00
* License along with Libav ; if not , write to the Free Software
2006-01-13 00:43:26 +02:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2003-06-07 21:34:02 +03:00
*/
2007-06-10 17:34:56 +03:00
2009-11-12 01:46:11 +02:00
# include "config.h"
2010-03-11 04:32:03 +02:00
# include <inttypes.h>
2007-07-02 10:43:23 +03:00
# include <math.h>
# include <limits.h>
2013-11-23 23:32:55 +03:00
# include <stdint.h>
2008-05-09 14:56:36 +03:00
# include "libavutil/avstring.h"
2010-07-01 21:49:44 +03:00
# include "libavutil/colorspace.h"
2015-04-29 21:28:45 +02:00
# include "libavutil/display.h"
2011-06-04 14:58:23 +03:00
# include "libavutil/mathematics.h"
2010-01-30 21:10:26 +02:00
# include "libavutil/pixdesc.h"
2011-02-07 15:37:08 +02:00
# include "libavutil/imgutils.h"
2011-06-09 11:58:23 +03:00
# include "libavutil/dict.h"
2011-02-07 15:37:08 +02:00
# include "libavutil/parseutils.h"
# include "libavutil/samplefmt.h"
2012-06-21 22:31:44 +03:00
# include "libavutil/time.h"
2008-05-09 14:56:36 +03:00
# include "libavformat/avformat.h"
# include "libavdevice/avdevice.h"
2012-04-25 23:46:22 +03:00
# include "libavresample/avresample.h"
2011-02-03 15:58:59 +02:00
# include "libavutil/opt.h"
2010-03-07 23:56:48 +02:00
# include "libavcodec/avfft.h"
2003-06-07 21:34:02 +03:00
2016-01-31 15:11:50 +02:00
# include "libavfilter/avfilter.h"
# include "libavfilter/buffersink.h"
# include "libavfilter/buffersrc.h"
2010-03-05 04:20:10 +02:00
2003-06-07 21:34:02 +03:00
# include "cmdutils.h"
# include <SDL.h>
# include <SDL_thread.h>
2006-07-12 00:45:45 +03:00
# ifdef __MINGW32__
2003-06-14 14:09:57 +03:00
# undef main /* We don't want SDL to override our main() */
# endif
2010-03-11 04:35:04 +02:00
# include <assert.h>
2011-07-26 18:51:34 +03:00
const char program_name [ ] = " avplay " ;
2008-05-29 11:48:51 +03:00
const int program_birth_year = 2003 ;
2007-09-27 16:52:33 +03:00
2010-01-30 23:27:17 +02:00
# define MAX_QUEUE_SIZE (15 * 1024 * 1024)
# define MIN_AUDIOQ_SIZE (20 * 16 * 1024)
# define MIN_FRAMES 5
2003-06-07 21:34:02 +03:00
2003-08-06 16:07:23 +03:00
/* SDL audio buffer size, in samples. Should be small to have precise
A / V sync as SDL does not have hardware buffer fullness info . */
# define SDL_AUDIO_BUFFER_SIZE 1024
/* no AV sync correction is done if below the AV sync threshold */
2004-05-30 03:38:09 +03:00
# define AV_SYNC_THRESHOLD 0.01
2003-08-06 16:07:23 +03:00
/* no AV correction is done if too big error */
# define AV_NOSYNC_THRESHOLD 10.0
2010-03-11 04:35:04 +02:00
# define FRAME_SKIP_FACTOR 0.05
2003-08-06 16:07:23 +03:00
/* maximum audio speed change to get correct sync */
# define SAMPLE_CORRECTION_PERCENT_MAX 10
/* we use about AUDIO_DIFF_AVG_NB A-V differences to make the average */
# define AUDIO_DIFF_AVG_NB 20
2003-06-07 21:34:02 +03:00
/* NOTE: the size must be big enough to compensate the hardware audio buffersize size */
2012-01-01 15:21:26 +03:00
# define SAMPLE_ARRAY_SIZE (2 * 65536)
2003-06-07 21:34:02 +03:00
2012-11-28 23:23:57 +03:00
static int64_t sws_flags = SWS_BICUBIC ;
2006-08-03 19:55:36 +03:00
2003-06-07 21:34:02 +03:00
typedef struct PacketQueue {
AVPacketList * first_pkt , * last_pkt ;
int nb_packets ;
int size ;
int abort_request ;
SDL_mutex * mutex ;
SDL_cond * cond ;
} PacketQueue ;
2010-03-10 17:45:46 +02:00
# define VIDEO_PICTURE_QUEUE_SIZE 2
2005-08-14 04:29:34 +03:00
# define SUBPICTURE_QUEUE_SIZE 4
2003-06-07 21:34:02 +03:00
typedef struct VideoPicture {
2012-08-24 14:31:50 +03:00
double pts ; // presentation timestamp for this picture
2014-10-22 12:23:08 +03:00
double target_clock ; // av_gettime_relative() time at which this should be displayed ideally
2012-08-24 14:31:50 +03:00
int64_t pos ; // byte position in file
2003-06-07 21:34:02 +03:00
SDL_Overlay * bmp ;
int width , height ; /* source height & width */
int allocated ;
2011-10-21 15:56:57 +03:00
int reallocate ;
2012-10-06 13:10:34 +03:00
enum AVPixelFormat pix_fmt ;
2010-03-05 04:20:10 +02:00
2013-02-17 18:06:16 +03:00
AVRational sar ;
2003-06-07 21:34:02 +03:00
} VideoPicture ;
2005-08-14 04:29:34 +03:00
typedef struct SubPicture {
double pts ; /* presentation time stamp for this picture */
AVSubtitle sub ;
} SubPicture ;
2003-06-07 21:34:02 +03:00
enum {
AV_SYNC_AUDIO_MASTER , /* default choice */
AV_SYNC_VIDEO_MASTER ,
2003-08-06 16:07:23 +03:00
AV_SYNC_EXTERNAL_CLOCK , /* synchronize to an external clock */
2003-06-07 21:34:02 +03:00
} ;
2016-01-02 13:19:29 +02:00
typedef struct PlayerState {
2003-06-07 21:34:02 +03:00
SDL_Thread * parse_tid ;
SDL_Thread * video_tid ;
2010-03-11 04:35:04 +02:00
SDL_Thread * refresh_tid ;
2003-08-06 16:07:23 +03:00
AVInputFormat * iformat ;
2003-06-07 21:34:02 +03:00
int no_background ;
int abort_request ;
int paused ;
2003-07-17 13:29:50 +03:00
int last_paused ;
2003-11-10 20:59:45 +02:00
int seek_req ;
2004-10-11 01:05:43 +03:00
int seek_flags ;
2003-11-10 20:59:45 +02:00
int64_t seek_pos ;
2009-03-14 18:24:30 +02:00
int64_t seek_rel ;
2010-02-01 12:32:17 +02:00
int read_pause_return ;
2003-06-07 21:34:02 +03:00
AVFormatContext * ic ;
int audio_stream ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
int av_sync_type ;
2003-08-06 16:07:23 +03:00
double external_clock ; /* external clock base */
int64_t external_clock_time ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
double audio_clock ;
double audio_diff_cum ; /* used for AV difference average computation */
double audio_diff_avg_coef ;
double audio_diff_threshold ;
int audio_diff_avg_count ;
2003-06-07 21:34:02 +03:00
AVStream * audio_st ;
2016-02-09 13:36:13 +02:00
AVCodecContext * audio_dec ;
2003-06-07 21:34:02 +03:00
PacketQueue audioq ;
int audio_hw_buf_size ;
2011-10-11 22:49:39 +03:00
uint8_t silence_buf [ SDL_AUDIO_BUFFER_SIZE ] ;
2008-08-02 08:01:30 +03:00
uint8_t * audio_buf ;
2011-10-12 20:27:41 +03:00
uint8_t * audio_buf1 ;
2004-10-06 11:50:46 +03:00
unsigned int audio_buf_size ; /* in bytes */
2003-06-07 21:34:02 +03:00
int audio_buf_index ; /* in bytes */
2009-04-10 15:07:06 +03:00
AVPacket audio_pkt_temp ;
2003-06-07 21:34:02 +03:00
AVPacket audio_pkt ;
2012-04-25 23:46:22 +03:00
enum AVSampleFormat sdl_sample_fmt ;
uint64_t sdl_channel_layout ;
int sdl_channels ;
2012-10-01 01:18:00 +03:00
int sdl_sample_rate ;
2012-04-25 23:46:22 +03:00
enum AVSampleFormat resample_sample_fmt ;
uint64_t resample_channel_layout ;
2012-10-01 01:18:00 +03:00
int resample_sample_rate ;
2012-04-25 23:46:22 +03:00
AVAudioResampleContext * avr ;
2011-10-12 20:27:41 +03:00
AVFrame * frame ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
int show_audio ; /* if true, display audio samples */
int16_t sample_array [ SAMPLE_ARRAY_SIZE ] ;
int sample_array_index ;
2003-06-09 23:48:06 +03:00
int last_i_start ;
2010-03-07 23:56:48 +02:00
RDFTContext * rdft ;
2010-02-05 04:06:38 +02:00
int rdft_bits ;
2010-06-30 01:41:20 +03:00
FFTSample * rdft_data ;
2010-02-05 04:06:38 +02:00
int xpos ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
SDL_Thread * subtitle_tid ;
int subtitle_stream ;
int subtitle_stream_changed ;
AVStream * subtitle_st ;
2016-02-09 13:36:13 +02:00
AVCodecContext * subtitle_dec ;
2005-08-14 04:29:34 +03:00
PacketQueue subtitleq ;
SubPicture subpq [ SUBPICTURE_QUEUE_SIZE ] ;
int subpq_size , subpq_rindex , subpq_windex ;
SDL_mutex * subpq_mutex ;
SDL_cond * subpq_cond ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
double frame_timer ;
double frame_last_pts ;
double frame_last_delay ;
2012-08-24 14:31:50 +03:00
double video_clock ; // pts of last decoded frame / predicted pts of next decoded frame
2003-06-07 21:34:02 +03:00
int video_stream ;
AVStream * video_st ;
2016-02-09 13:36:13 +02:00
AVCodecContext * video_dec ;
2003-06-07 21:34:02 +03:00
PacketQueue videoq ;
2012-08-24 14:31:50 +03:00
double video_current_pts ; // current displayed pts (different from video_clock if frame fifos are used)
2014-10-22 12:23:08 +03:00
double video_current_pts_drift ; // video_current_pts - time (av_gettime_relative) at which we updated video_current_pts - used to have running video pts
2012-08-24 14:31:50 +03:00
int64_t video_current_pos ; // current displayed file pos
2003-06-07 21:34:02 +03:00
VideoPicture pictq [ VIDEO_PICTURE_QUEUE_SIZE ] ;
int pictq_size , pictq_rindex , pictq_windex ;
SDL_mutex * pictq_mutex ;
SDL_cond * pictq_cond ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
// QETimer *video_timer;
char filename [ 1024 ] ;
int width , height , xleft , ytop ;
2010-01-31 20:54:32 +02:00
2010-09-28 05:05:12 +03:00
PtsCorrectionContext pts_ctx ;
2010-01-31 20:54:32 +02:00
2012-08-24 14:31:50 +03:00
AVFilterContext * in_video_filter ; // the first filter in the video chain
AVFilterContext * out_video_filter ; // the last filter in the video chain
2010-03-11 04:35:04 +02:00
float skip_frames ;
float skip_frames_index ;
int refresh ;
2016-01-02 13:19:32 +02:00
SpecifierOpt * codec_names ;
int nb_codec_names ;
2016-01-02 13:19:29 +02:00
} PlayerState ;
2003-06-07 21:34:02 +03:00
/* options specified by the user */
static AVInputFormat * file_iformat ;
static const char * input_filename ;
2010-03-18 01:39:18 +02:00
static const char * window_title ;
2003-06-07 21:34:02 +03:00
static int fs_screen_width ;
static int fs_screen_height ;
2012-01-01 15:21:26 +03:00
static int screen_width = 0 ;
2006-12-30 13:22:46 +02:00
static int screen_height = 0 ;
2003-06-07 21:34:02 +03:00
static int audio_disable ;
static int video_disable ;
2012-01-01 15:21:26 +03:00
static int wanted_stream [ AVMEDIA_TYPE_NB ] = {
[ AVMEDIA_TYPE_AUDIO ] = - 1 ,
[ AVMEDIA_TYPE_VIDEO ] = - 1 ,
[ AVMEDIA_TYPE_SUBTITLE ] = - 1 ,
2010-02-23 18:56:23 +02:00
} ;
2012-01-01 15:21:26 +03:00
static int seek_by_bytes = - 1 ;
2003-06-07 21:34:02 +03:00
static int display_disable ;
2009-07-31 00:54:50 +03:00
static int show_status = 1 ;
2003-08-06 16:07:23 +03:00
static int av_sync_type = AV_SYNC_AUDIO_MASTER ;
2003-11-10 20:59:45 +02:00
static int64_t start_time = AV_NOPTS_VALUE ;
2010-04-01 23:56:23 +03:00
static int64_t duration = AV_NOPTS_VALUE ;
2003-12-28 03:19:41 +02:00
static int step = 0 ;
2004-04-30 21:54:36 +03:00
static int workaround_bugs = 1 ;
2004-09-02 18:30:46 +03:00
static int fast = 0 ;
2005-08-15 17:22:43 +03:00
static int genpts = 0 ;
2004-09-26 02:18:58 +03:00
static int idct = FF_IDCT_AUTO ;
2012-01-01 15:21:26 +03:00
static enum AVDiscard skip_frame = AVDISCARD_DEFAULT ;
static enum AVDiscard skip_idct = AVDISCARD_DEFAULT ;
static enum AVDiscard skip_loop_filter = AVDISCARD_DEFAULT ;
2005-07-17 13:18:10 +03:00
static int error_concealment = 3 ;
2012-01-01 15:21:26 +03:00
static int decoder_reorder_pts = - 1 ;
2014-09-03 01:45:21 +03:00
static int noautoexit ;
2010-07-04 15:43:12 +03:00
static int exit_on_keydown ;
static int exit_on_mousedown ;
2012-01-01 15:21:26 +03:00
static int loop = 1 ;
static int framedrop = 1 ;
avplay: Add an option for not limiting the input buffer size
For reading from normal files on disk, the queue limits for
demuxed data work fine, but for reading data from realtime
streams, they mean we're not reading from the input stream
at all once the queue limit has been reached. For TCP streams,
this means that writing to the socket from the peer side blocks
(potentially leading to the peer dropping data), and for UDP
streams it means that our kernel might drop data.
For some protocols/servers, the server initially sends a
large burst with data to fill client side buffers, but once
filled, we should keep reading to avoid dropping data.
For all realtime streams, it IMO makes sense to just buffer
as much as we get (rather in buffers in avplay.c than in
OS level buffers). With this option set, the input thread
should always be blocking waiting for more input data,
never sleeping waiting for the decoder to consume data.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-07-03 22:57:19 +03:00
static int infinite_buffer = 0 ;
2010-03-11 13:25:51 +02:00
2012-01-01 15:21:26 +03:00
static int rdftspeed = 20 ;
2010-03-05 04:20:10 +02:00
static char * vfilters = NULL ;
2015-04-29 21:28:45 +02:00
static int autorotate = 1 ;
2003-06-07 21:34:02 +03:00
/* current context */
static int is_full_screen ;
2016-01-02 13:19:31 +02:00
static PlayerState player_state ;
static PlayerState * player = & player_state ;
2003-06-09 23:48:06 +03:00
static int64_t audio_callback_time ;
2003-06-07 21:34:02 +03:00
2008-10-04 12:23:18 +03:00
static AVPacket flush_pkt ;
2006-11-16 13:58:27 +02:00
2003-06-07 21:34:02 +03:00
# define FF_ALLOC_EVENT (SDL_USEREVENT)
# define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
2003-08-06 16:07:23 +03:00
# define FF_QUIT_EVENT (SDL_USEREVENT + 2)
2003-06-07 21:34:02 +03:00
2008-10-04 12:23:18 +03:00
static SDL_Surface * screen ;
2003-06-07 21:34:02 +03:00
2010-02-01 14:22:12 +02:00
static int packet_queue_put ( PacketQueue * q , AVPacket * pkt ) ;
2003-06-07 21:34:02 +03:00
/* packet queue handling */
static void packet_queue_init ( PacketQueue * q )
{
memset ( q , 0 , sizeof ( PacketQueue ) ) ;
q - > mutex = SDL_CreateMutex ( ) ;
q - > cond = SDL_CreateCond ( ) ;
2010-02-01 14:22:12 +02:00
packet_queue_put ( q , & flush_pkt ) ;
2003-06-07 21:34:02 +03:00
}
2003-11-10 20:59:45 +02:00
static void packet_queue_flush ( PacketQueue * q )
2003-06-07 21:34:02 +03:00
{
AVPacketList * pkt , * pkt1 ;
2005-06-24 11:32:55 +03:00
SDL_LockMutex ( q - > mutex ) ;
2012-01-01 15:21:26 +03:00
for ( pkt = q - > first_pkt ; pkt ! = NULL ; pkt = pkt1 ) {
2003-06-07 21:34:02 +03:00
pkt1 = pkt - > next ;
2015-10-23 11:11:31 +02:00
av_packet_unref ( & pkt - > pkt ) ;
2004-08-17 02:17:32 +03:00
av_freep ( & pkt ) ;
2003-06-07 21:34:02 +03:00
}
2003-11-10 20:59:45 +02:00
q - > last_pkt = NULL ;
q - > first_pkt = NULL ;
q - > nb_packets = 0 ;
q - > size = 0 ;
2005-06-24 11:32:55 +03:00
SDL_UnlockMutex ( q - > mutex ) ;
2003-11-10 20:59:45 +02:00
}
static void packet_queue_end ( PacketQueue * q )
{
packet_queue_flush ( q ) ;
2003-06-07 21:34:02 +03:00
SDL_DestroyMutex ( q - > mutex ) ;
SDL_DestroyCond ( q - > cond ) ;
}
static int packet_queue_put ( PacketQueue * q , AVPacket * pkt )
{
AVPacketList * pkt1 ;
pkt1 = av_malloc ( sizeof ( AVPacketList ) ) ;
if ( ! pkt1 )
return - 1 ;
pkt1 - > pkt = * pkt ;
pkt1 - > next = NULL ;
2003-11-10 20:59:45 +02:00
2003-06-07 21:34:02 +03:00
SDL_LockMutex ( q - > mutex ) ;
if ( ! q - > last_pkt )
q - > first_pkt = pkt1 ;
else
q - > last_pkt - > next = pkt1 ;
q - > last_pkt = pkt1 ;
q - > nb_packets + + ;
2009-02-21 18:01:52 +02:00
q - > size + = pkt1 - > pkt . size + sizeof ( * pkt1 ) ;
2003-06-07 21:34:02 +03:00
/* XXX: should duplicate packet data in DV case */
SDL_CondSignal ( q - > cond ) ;
SDL_UnlockMutex ( q - > mutex ) ;
return 0 ;
}
static void packet_queue_abort ( PacketQueue * q )
{
SDL_LockMutex ( q - > mutex ) ;
q - > abort_request = 1 ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
SDL_CondSignal ( q - > cond ) ;
SDL_UnlockMutex ( q - > mutex ) ;
}
/* return < 0 if aborted, 0 if no packet and > 0 if packet. */
static int packet_queue_get ( PacketQueue * q , AVPacket * pkt , int block )
{
AVPacketList * pkt1 ;
int ret ;
SDL_LockMutex ( q - > mutex ) ;
2012-01-01 15:21:26 +03:00
for ( ; ; ) {
2003-06-07 21:34:02 +03:00
if ( q - > abort_request ) {
ret = - 1 ;
break ;
}
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
pkt1 = q - > first_pkt ;
if ( pkt1 ) {
q - > first_pkt = pkt1 - > next ;
if ( ! q - > first_pkt )
q - > last_pkt = NULL ;
q - > nb_packets - - ;
2009-02-21 18:01:52 +02:00
q - > size - = pkt1 - > pkt . size + sizeof ( * pkt1 ) ;
2003-06-07 21:34:02 +03:00
* pkt = pkt1 - > pkt ;
av_free ( pkt1 ) ;
ret = 1 ;
break ;
} else if ( ! block ) {
ret = 0 ;
break ;
} else {
SDL_CondWait ( q - > cond , q - > mutex ) ;
}
}
SDL_UnlockMutex ( q - > mutex ) ;
return ret ;
}
2005-12-17 20:14:38 +02:00
static inline void fill_rectangle ( SDL_Surface * screen ,
2003-06-07 21:34:02 +03:00
int x , int y , int w , int h , int color )
{
SDL_Rect rect ;
rect . x = x ;
rect . y = y ;
rect . w = w ;
rect . h = h ;
SDL_FillRect ( screen , & rect , color ) ;
}
2005-08-14 04:29:34 +03:00
# define ALPHA_BLEND(a, oldp, newp, s)\
( ( ( ( oldp < < s ) * ( 255 - ( a ) ) ) + ( newp * ( a ) ) ) / ( 255 < < s ) )
# define RGBA_IN(r, g, b, a, s)\
{ \
unsigned int v = ( ( const uint32_t * ) ( s ) ) [ 0 ] ; \
a = ( v > > 24 ) & 0xff ; \
r = ( v > > 16 ) & 0xff ; \
g = ( v > > 8 ) & 0xff ; \
b = v & 0xff ; \
}
# define YUVA_IN(y, u, v, a, s, pal)\
{ \
2007-08-09 21:58:35 +03:00
unsigned int val = ( ( const uint32_t * ) ( pal ) ) [ * ( const uint8_t * ) ( s ) ] ; \
2005-08-14 04:29:34 +03:00
a = ( val > > 24 ) & 0xff ; \
y = ( val > > 16 ) & 0xff ; \
u = ( val > > 8 ) & 0xff ; \
v = val & 0xff ; \
}
# define YUVA_OUT(d, y, u, v, a)\
{ \
( ( uint32_t * ) ( d ) ) [ 0 ] = ( a < < 24 ) | ( y < < 16 ) | ( u < < 8 ) | v ; \
}
# define BPP 1
2015-10-14 11:33:26 +02:00
static void blend_subrect ( uint8_t * dst [ 4 ] , uint16_t dst_linesize [ 4 ] ,
const AVSubtitleRect * rect , int imgw , int imgh )
2005-08-14 04:29:34 +03:00
{
int wrap , wrap3 , width2 , skip2 ;
int y , u , v , a , u1 , v1 , a1 , w , h ;
uint8_t * lum , * cb , * cr ;
const uint8_t * p ;
const uint32_t * pal ;
2007-08-09 19:15:59 +03:00
int dstx , dsty , dstw , dsth ;
2009-01-03 19:50:00 +02:00
dstw = av_clip ( rect - > w , 0 , imgw ) ;
dsth = av_clip ( rect - > h , 0 , imgh ) ;
dstx = av_clip ( rect - > x , 0 , imgw - dstw ) ;
dsty = av_clip ( rect - > y , 0 , imgh - dsth ) ;
2015-10-14 11:33:26 +02:00
/* sdl has U and V inverted */
lum = dst [ 0 ] + dsty * dst_linesize [ 0 ] ;
cb = dst [ 2 ] + ( dsty > > 1 ) * dst_linesize [ 2 ] ;
cr = dst [ 1 ] + ( dsty > > 1 ) * dst_linesize [ 1 ] ;
2007-08-09 19:15:59 +03:00
2009-02-09 02:27:04 +02:00
width2 = ( ( dstw + 1 ) > > 1 ) + ( dstx & ~ dstw & 1 ) ;
2007-08-09 19:15:59 +03:00
skip2 = dstx > > 1 ;
2015-10-14 11:33:26 +02:00
wrap = dst_linesize [ 0 ] ;
2015-10-14 11:33:25 +02:00
wrap3 = rect - > linesize [ 0 ] ;
p = rect - > data [ 0 ] ;
pal = ( const uint32_t * ) rect - > data [ 1 ] ; /* Now in YCrCb! */
2005-12-17 20:14:38 +02:00
2007-08-09 19:15:59 +03:00
if ( dsty & 1 ) {
lum + = dstx ;
2005-08-14 04:29:34 +03:00
cb + = skip2 ;
cr + = skip2 ;
2005-12-17 20:14:38 +02:00
2007-08-09 19:15:59 +03:00
if ( dstx & 1 ) {
2005-08-14 04:29:34 +03:00
YUVA_IN ( y , u , v , a , p , pal ) ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a > > 2 , cb [ 0 ] , u , 0 ) ;
cr [ 0 ] = ALPHA_BLEND ( a > > 2 , cr [ 0 ] , v , 0 ) ;
cb + + ;
cr + + ;
lum + + ;
p + = BPP ;
}
2012-01-01 15:21:26 +03:00
for ( w = dstw - ( dstx & 1 ) ; w > = 2 ; w - = 2 ) {
2005-08-14 04:29:34 +03:00
YUVA_IN ( y , u , v , a , p , pal ) ;
u1 = u ;
v1 = v ;
a1 = a ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
YUVA_IN ( y , u , v , a , p + BPP , pal ) ;
u1 + = u ;
v1 + = v ;
a1 + = a ;
lum [ 1 ] = ALPHA_BLEND ( a , lum [ 1 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cb [ 0 ] , u1 , 1 ) ;
cr [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cr [ 0 ] , v1 , 1 ) ;
cb + + ;
cr + + ;
p + = 2 * BPP ;
lum + = 2 ;
}
if ( w ) {
YUVA_IN ( y , u , v , a , p , pal ) ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a > > 2 , cb [ 0 ] , u , 0 ) ;
cr [ 0 ] = ALPHA_BLEND ( a > > 2 , cr [ 0 ] , v , 0 ) ;
2009-02-06 01:07:24 +02:00
p + + ;
lum + + ;
2005-08-14 04:29:34 +03:00
}
2009-02-06 01:10:05 +02:00
p + = wrap3 - dstw * BPP ;
lum + = wrap - dstw - dstx ;
2015-10-14 11:33:26 +02:00
cb + = dst_linesize [ 2 ] - width2 - skip2 ;
cr + = dst_linesize [ 1 ] - width2 - skip2 ;
2005-08-14 04:29:34 +03:00
}
2012-01-01 15:21:26 +03:00
for ( h = dsth - ( dsty & 1 ) ; h > = 2 ; h - = 2 ) {
2007-08-09 19:15:59 +03:00
lum + = dstx ;
2005-08-14 04:29:34 +03:00
cb + = skip2 ;
cr + = skip2 ;
2005-12-17 20:14:38 +02:00
2007-08-09 19:15:59 +03:00
if ( dstx & 1 ) {
2005-08-14 04:29:34 +03:00
YUVA_IN ( y , u , v , a , p , pal ) ;
u1 = u ;
v1 = v ;
a1 = a ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
p + = wrap3 ;
lum + = wrap ;
YUVA_IN ( y , u , v , a , p , pal ) ;
u1 + = u ;
v1 + = v ;
a1 + = a ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cb [ 0 ] , u1 , 1 ) ;
cr [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cr [ 0 ] , v1 , 1 ) ;
cb + + ;
cr + + ;
p + = - wrap3 + BPP ;
lum + = - wrap + 1 ;
}
2012-01-01 15:21:26 +03:00
for ( w = dstw - ( dstx & 1 ) ; w > = 2 ; w - = 2 ) {
2005-08-14 04:29:34 +03:00
YUVA_IN ( y , u , v , a , p , pal ) ;
u1 = u ;
v1 = v ;
a1 = a ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
2009-02-03 01:24:28 +02:00
YUVA_IN ( y , u , v , a , p + BPP , pal ) ;
2005-08-14 04:29:34 +03:00
u1 + = u ;
v1 + = v ;
a1 + = a ;
lum [ 1 ] = ALPHA_BLEND ( a , lum [ 1 ] , y , 0 ) ;
p + = wrap3 ;
lum + = wrap ;
YUVA_IN ( y , u , v , a , p , pal ) ;
u1 + = u ;
v1 + = v ;
a1 + = a ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
2009-02-03 01:24:28 +02:00
YUVA_IN ( y , u , v , a , p + BPP , pal ) ;
2005-08-14 04:29:34 +03:00
u1 + = u ;
v1 + = v ;
a1 + = a ;
lum [ 1 ] = ALPHA_BLEND ( a , lum [ 1 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cb [ 0 ] , u1 , 2 ) ;
cr [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cr [ 0 ] , v1 , 2 ) ;
cb + + ;
cr + + ;
p + = - wrap3 + 2 * BPP ;
lum + = - wrap + 2 ;
}
if ( w ) {
YUVA_IN ( y , u , v , a , p , pal ) ;
u1 = u ;
v1 = v ;
a1 = a ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
p + = wrap3 ;
lum + = wrap ;
YUVA_IN ( y , u , v , a , p , pal ) ;
u1 + = u ;
v1 + = v ;
a1 + = a ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cb [ 0 ] , u1 , 1 ) ;
cr [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cr [ 0 ] , v1 , 1 ) ;
cb + + ;
cr + + ;
p + = - wrap3 + BPP ;
lum + = - wrap + 1 ;
}
2007-08-09 19:15:59 +03:00
p + = wrap3 + ( wrap3 - dstw * BPP ) ;
lum + = wrap + ( wrap - dstw - dstx ) ;
2015-10-14 11:33:26 +02:00
cb + = dst_linesize [ 2 ] - width2 - skip2 ;
cr + = dst_linesize [ 1 ] - width2 - skip2 ;
2005-08-14 04:29:34 +03:00
}
/* handle odd height */
if ( h ) {
2007-08-09 19:15:59 +03:00
lum + = dstx ;
2005-08-14 04:29:34 +03:00
cb + = skip2 ;
cr + = skip2 ;
2005-12-17 20:14:38 +02:00
2007-08-09 19:15:59 +03:00
if ( dstx & 1 ) {
2005-08-14 04:29:34 +03:00
YUVA_IN ( y , u , v , a , p , pal ) ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a > > 2 , cb [ 0 ] , u , 0 ) ;
cr [ 0 ] = ALPHA_BLEND ( a > > 2 , cr [ 0 ] , v , 0 ) ;
cb + + ;
cr + + ;
lum + + ;
p + = BPP ;
}
2012-01-01 15:21:26 +03:00
for ( w = dstw - ( dstx & 1 ) ; w > = 2 ; w - = 2 ) {
2005-08-14 04:29:34 +03:00
YUVA_IN ( y , u , v , a , p , pal ) ;
u1 = u ;
v1 = v ;
a1 = a ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
YUVA_IN ( y , u , v , a , p + BPP , pal ) ;
u1 + = u ;
v1 + = v ;
a1 + = a ;
lum [ 1 ] = ALPHA_BLEND ( a , lum [ 1 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cb [ 0 ] , u , 1 ) ;
cr [ 0 ] = ALPHA_BLEND ( a1 > > 2 , cr [ 0 ] , v , 1 ) ;
cb + + ;
cr + + ;
p + = 2 * BPP ;
lum + = 2 ;
}
if ( w ) {
YUVA_IN ( y , u , v , a , p , pal ) ;
lum [ 0 ] = ALPHA_BLEND ( a , lum [ 0 ] , y , 0 ) ;
cb [ 0 ] = ALPHA_BLEND ( a > > 2 , cb [ 0 ] , u , 0 ) ;
cr [ 0 ] = ALPHA_BLEND ( a > > 2 , cr [ 0 ] , v , 0 ) ;
}
}
}
static void free_subpicture ( SubPicture * sp )
{
2010-07-11 10:35:00 +03:00
avsubtitle_free ( & sp - > sub ) ;
2005-08-14 04:29:34 +03:00
}
2016-01-02 13:19:29 +02:00
static void video_image_display ( PlayerState * is )
2003-06-07 21:34:02 +03:00
{
VideoPicture * vp ;
2005-08-14 04:29:34 +03:00
SubPicture * sp ;
2003-06-07 21:34:02 +03:00
float aspect_ratio ;
int width , height , x , y ;
SDL_Rect rect ;
2005-08-14 04:29:34 +03:00
int i ;
2003-06-07 21:34:02 +03:00
vp = & is - > pictq [ is - > pictq_rindex ] ;
if ( vp - > bmp ) {
2013-02-17 18:06:16 +03:00
if ( ! vp - > sar . num )
2010-03-05 04:20:10 +02:00
aspect_ratio = 0 ;
else
2013-02-17 18:06:16 +03:00
aspect_ratio = av_q2d ( vp - > sar ) ;
2003-06-07 21:34:02 +03:00
if ( aspect_ratio < = 0.0 )
2008-08-24 02:13:58 +03:00
aspect_ratio = 1.0 ;
2010-03-05 04:20:10 +02:00
aspect_ratio * = ( float ) vp - > width / ( float ) vp - > height ;
2003-06-07 21:34:02 +03:00
2005-08-14 04:29:34 +03:00
if ( is - > subtitle_st )
{
if ( is - > subpq_size > 0 )
{
sp = & is - > subpq [ is - > subpq_rindex ] ;
if ( vp - > pts > = sp - > pts + ( ( float ) sp - > sub . start_display_time / 1000 ) )
{
SDL_LockYUVOverlay ( vp - > bmp ) ;
for ( i = 0 ; i < sp - > sub . num_rects ; i + + )
2015-10-14 11:33:26 +02:00
blend_subrect ( vp - > bmp - > pixels , vp - > bmp - > pitches ,
sp - > sub . rects [ i ] , vp - > bmp - > w , vp - > bmp - > h ) ;
2005-08-14 04:29:34 +03:00
SDL_UnlockYUVOverlay ( vp - > bmp ) ;
}
}
}
2003-06-07 21:34:02 +03:00
/* XXX: we suppose the screen has a 1.0 pixel ratio */
height = is - > height ;
2008-09-03 14:16:29 +03:00
width = ( ( int ) rint ( height * aspect_ratio ) ) & ~ 1 ;
2003-06-07 21:34:02 +03:00
if ( width > is - > width ) {
width = is - > width ;
2008-09-03 14:16:29 +03:00
height = ( ( int ) rint ( width / aspect_ratio ) ) & ~ 1 ;
2003-06-07 21:34:02 +03:00
}
x = ( is - > width - width ) / 2 ;
y = ( is - > height - height ) / 2 ;
2011-04-26 15:29:14 +03:00
is - > no_background = 0 ;
2003-06-07 21:34:02 +03:00
rect . x = is - > xleft + x ;
2007-03-02 12:40:24 +02:00
rect . y = is - > ytop + y ;
2003-06-07 21:34:02 +03:00
rect . w = width ;
rect . h = height ;
SDL_DisplayYUVOverlay ( vp - > bmp , & rect ) ;
}
}
2011-04-12 13:06:49 +03:00
/* get the current audio output buffer size, in samples. With SDL, we
cannot have a precise information */
2016-01-02 13:19:29 +02:00
static int audio_write_get_buf_size ( PlayerState * is )
2011-04-12 13:06:49 +03:00
{
return is - > audio_buf_size - is - > audio_buf_index ;
}
2003-06-07 21:34:02 +03:00
static inline int compute_mod ( int a , int b )
{
a = a % b ;
2005-12-17 20:14:38 +02:00
if ( a > = 0 )
2003-06-07 21:34:02 +03:00
return a ;
else
return a + b ;
}
2016-01-02 13:19:29 +02:00
static void video_audio_display ( PlayerState * s )
2003-06-07 21:34:02 +03:00
{
int i , i_start , x , y1 , y , ys , delay , n , nb_display_channels ;
int ch , channels , h , h2 , bgcolor , fgcolor ;
int16_t time_diff ;
2010-02-05 17:16:38 +02:00
int rdft_bits , nb_freq ;
2012-01-01 15:21:26 +03:00
for ( rdft_bits = 1 ; ( 1 < < rdft_bits ) < 2 * s - > height ; rdft_bits + + )
2010-02-05 17:16:38 +02:00
;
2012-01-01 15:21:26 +03:00
nb_freq = 1 < < ( rdft_bits - 1 ) ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
/* compute display index : center on currently output samples */
2012-04-25 23:46:22 +03:00
channels = s - > sdl_channels ;
2003-06-07 21:34:02 +03:00
nb_display_channels = channels ;
2003-06-09 23:48:06 +03:00
if ( ! s - > paused ) {
2012-01-01 15:21:26 +03:00
int data_used = s - > show_audio = = 1 ? s - > width : ( 2 * nb_freq ) ;
2003-06-09 23:48:06 +03:00
n = 2 * channels ;
delay = audio_write_get_buf_size ( s ) ;
delay / = n ;
2005-12-17 20:14:38 +02:00
2003-06-09 23:48:06 +03:00
/* to be more precise, we take into account the time spent since
the last buffer computation */
if ( audio_callback_time ) {
2014-10-22 12:23:08 +03:00
time_diff = av_gettime_relative ( ) - audio_callback_time ;
2012-10-01 01:18:00 +03:00
delay - = ( time_diff * s - > sdl_sample_rate ) / 1000000 ;
2003-06-09 23:48:06 +03:00
}
2005-12-17 20:14:38 +02:00
2012-01-01 15:21:26 +03:00
delay + = 2 * data_used ;
2010-02-05 17:16:38 +02:00
if ( delay < data_used )
delay = data_used ;
2007-01-30 00:06:55 +02:00
i_start = x = compute_mod ( s - > sample_array_index - delay * channels , SAMPLE_ARRAY_SIZE ) ;
2012-01-01 15:21:26 +03:00
if ( s - > show_audio = = 1 ) {
h = INT_MIN ;
for ( i = 0 ; i < 1000 ; i + = channels ) {
int idx = ( SAMPLE_ARRAY_SIZE + x - i ) % SAMPLE_ARRAY_SIZE ;
int a = s - > sample_array [ idx ] ;
int b = s - > sample_array [ ( idx + 4 * channels ) % SAMPLE_ARRAY_SIZE ] ;
int c = s - > sample_array [ ( idx + 5 * channels ) % SAMPLE_ARRAY_SIZE ] ;
int d = s - > sample_array [ ( idx + 9 * channels ) % SAMPLE_ARRAY_SIZE ] ;
int score = a - d ;
if ( h < score & & ( b ^ c ) < 0 ) {
h = score ;
i_start = idx ;
2010-02-06 15:15:15 +02:00
}
2007-01-30 00:06:55 +02:00
}
}
2003-06-09 23:48:06 +03:00
s - > last_i_start = i_start ;
} else {
i_start = s - > last_i_start ;
2003-06-07 21:34:02 +03:00
}
bgcolor = SDL_MapRGB ( screen - > format , 0x00 , 0x00 , 0x00 ) ;
2012-01-01 15:21:26 +03:00
if ( s - > show_audio = = 1 ) {
2010-02-06 15:15:15 +02:00
fill_rectangle ( screen ,
s - > xleft , s - > ytop , s - > width , s - > height ,
bgcolor ) ;
fgcolor = SDL_MapRGB ( screen - > format , 0xff , 0xff , 0xff ) ;
/* total height for one channel */
h = s - > height / nb_display_channels ;
/* graph height / 2 */
h2 = ( h * 9 ) / 20 ;
2012-01-01 15:21:26 +03:00
for ( ch = 0 ; ch < nb_display_channels ; ch + + ) {
2010-02-06 15:15:15 +02:00
i = i_start + ch ;
y1 = s - > ytop + ch * h + ( h / 2 ) ; /* position of center line */
2012-01-01 15:21:26 +03:00
for ( x = 0 ; x < s - > width ; x + + ) {
2010-02-06 15:15:15 +02:00
y = ( s - > sample_array [ i ] * h2 ) > > 15 ;
if ( y < 0 ) {
y = - y ;
ys = y1 - y ;
} else {
ys = y1 ;
}
fill_rectangle ( screen ,
s - > xleft + x , ys , 1 , y ,
fgcolor ) ;
i + = channels ;
if ( i > = SAMPLE_ARRAY_SIZE )
i - = SAMPLE_ARRAY_SIZE ;
2003-06-07 21:34:02 +03:00
}
}
2010-02-06 15:15:15 +02:00
fgcolor = SDL_MapRGB ( screen - > format , 0x00 , 0x00 , 0xff ) ;
2003-06-07 21:34:02 +03:00
2012-01-01 15:21:26 +03:00
for ( ch = 1 ; ch < nb_display_channels ; ch + + ) {
2010-02-06 15:15:15 +02:00
y = s - > ytop + ch * h ;
fill_rectangle ( screen ,
s - > xleft , y , s - > width , 1 ,
fgcolor ) ;
}
SDL_UpdateRect ( screen , s - > xleft , s - > ytop , s - > width , s - > height ) ;
2012-01-01 15:21:26 +03:00
} else {
2010-02-05 04:06:38 +02:00
nb_display_channels = FFMIN ( nb_display_channels , 2 ) ;
2012-01-01 15:21:26 +03:00
if ( rdft_bits ! = s - > rdft_bits ) {
2010-03-07 23:56:48 +02:00
av_rdft_end ( s - > rdft ) ;
2010-06-30 01:41:20 +03:00
av_free ( s - > rdft_data ) ;
2010-03-07 23:56:48 +02:00
s - > rdft = av_rdft_init ( rdft_bits , DFT_R2C ) ;
2012-01-01 15:21:26 +03:00
s - > rdft_bits = rdft_bits ;
s - > rdft_data = av_malloc ( 4 * nb_freq * sizeof ( * s - > rdft_data ) ) ;
2010-02-05 04:06:38 +02:00
}
{
2010-06-30 01:41:20 +03:00
FFTSample * data [ 2 ] ;
2012-01-01 15:21:26 +03:00
for ( ch = 0 ; ch < nb_display_channels ; ch + + ) {
data [ ch ] = s - > rdft_data + 2 * nb_freq * ch ;
2010-02-05 04:06:38 +02:00
i = i_start + ch ;
2012-01-01 15:21:26 +03:00
for ( x = 0 ; x < 2 * nb_freq ; x + + ) {
double w = ( x - nb_freq ) * ( 1.0 / nb_freq ) ;
data [ ch ] [ x ] = s - > sample_array [ i ] * ( 1.0 - w * w ) ;
2010-02-05 04:06:38 +02:00
i + = channels ;
if ( i > = SAMPLE_ARRAY_SIZE )
i - = SAMPLE_ARRAY_SIZE ;
}
2010-03-07 23:56:48 +02:00
av_rdft_calc ( s - > rdft , data [ ch ] ) ;
2010-02-05 04:06:38 +02:00
}
2013-05-04 22:18:13 +03:00
/* Least efficient way to do this, we should of course
* directly access it but it is more than fast enough . */
2012-01-01 15:21:26 +03:00
for ( y = 0 ; y < s - > height ; y + + ) {
double w = 1 / sqrt ( nb_freq ) ;
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 ] ) ) ;
int b = ( nb_display_channels = = 2 ) ? sqrt ( w * sqrt ( data [ 1 ] [ 2 * y + 0 ] * data [ 1 ] [ 2 * y + 0 ]
+ data [ 1 ] [ 2 * y + 1 ] * data [ 1 ] [ 2 * y + 1 ] ) ) : a ;
a = FFMIN ( a , 255 ) ;
b = FFMIN ( b , 255 ) ;
fgcolor = SDL_MapRGB ( screen - > format , a , b , ( a + b ) / 2 ) ;
2010-02-05 04:06:38 +02:00
fill_rectangle ( screen ,
s - > xpos , s - > height - y , 1 , 1 ,
fgcolor ) ;
}
}
SDL_UpdateRect ( screen , s - > xpos , s - > ytop , 1 , s - > height ) ;
s - > xpos + + ;
2012-01-01 15:21:26 +03:00
if ( s - > xpos > = s - > width )
2010-02-05 04:06:38 +02:00
s - > xpos = s - > xleft ;
}
2003-06-07 21:34:02 +03:00
}
2016-01-02 13:19:29 +02:00
static int video_open ( PlayerState * is )
2012-01-01 15:21:26 +03:00
{
int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL ;
2006-12-31 20:01:13 +02:00
int w , h ;
2012-01-01 15:21:26 +03:00
if ( is_full_screen ) flags | = SDL_FULLSCREEN ;
else flags | = SDL_RESIZABLE ;
2006-12-31 22:04:08 +02:00
2006-12-31 20:01:13 +02:00
if ( is_full_screen & & fs_screen_width ) {
w = fs_screen_width ;
h = fs_screen_height ;
2012-01-01 15:21:26 +03:00
} else if ( ! is_full_screen & & screen_width ) {
2006-12-31 22:04:08 +02:00
w = screen_width ;
h = screen_height ;
2012-01-01 15:21:26 +03:00
} else if ( is - > out_video_filter & & is - > out_video_filter - > inputs [ 0 ] ) {
2010-03-05 04:20:10 +02:00
w = is - > out_video_filter - > inputs [ 0 ] - > w ;
h = is - > out_video_filter - > inputs [ 0 ] - > h ;
2006-12-31 20:01:13 +02:00
} else {
2006-12-31 22:04:08 +02:00
w = 640 ;
h = 480 ;
2006-12-31 20:01:13 +02:00
}
2012-01-01 15:21:26 +03:00
if ( screen & & is - > width = = screen - > w & & screen - > w = = w
2010-03-10 17:39:31 +02:00
& & is - > height = = screen - > h & & screen - > h = = h )
return 0 ;
2011-10-17 08:31:53 +03:00
# if defined(__APPLE__) && !SDL_VERSION_ATLEAST(1, 2, 14)
/* setting bits_per_pixel = 0 or 32 causes blank video on OS X and older SDL */
2006-12-31 20:01:13 +02:00
screen = SDL_SetVideoMode ( w , h , 24 , flags ) ;
2011-10-17 08:31:53 +03:00
# else
screen = SDL_SetVideoMode ( w , h , 0 , flags ) ;
2006-12-31 20:01:13 +02:00
# endif
if ( ! screen ) {
fprintf ( stderr , " SDL: could not set video mode - exiting \n " ) ;
return - 1 ;
}
2010-03-18 01:39:18 +02:00
if ( ! window_title )
window_title = input_filename ;
SDL_WM_SetCaption ( window_title , window_title ) ;
2006-12-31 20:01:13 +02:00
2012-01-01 15:21:26 +03:00
is - > width = screen - > w ;
2006-12-31 20:01:13 +02:00
is - > height = screen - > h ;
return 0 ;
}
2006-12-31 19:59:10 +02:00
2003-06-07 21:34:02 +03:00
/* display the current picture, if any */
2016-01-02 13:19:29 +02:00
static void video_display ( PlayerState * is )
2003-06-07 21:34:02 +03:00
{
2012-01-01 15:21:26 +03:00
if ( ! screen )
2016-01-02 13:19:30 +02:00
video_open ( player ) ;
2005-12-17 20:14:38 +02:00
if ( is - > audio_st & & is - > show_audio )
2003-06-07 21:34:02 +03:00
video_audio_display ( is ) ;
else if ( is - > video_st )
video_image_display ( is ) ;
}
2010-03-11 04:35:04 +02:00
static int refresh_thread ( void * opaque )
2003-06-07 21:34:02 +03:00
{
2016-01-02 13:19:29 +02:00
PlayerState * is = opaque ;
2012-01-01 15:21:26 +03:00
while ( ! is - > abort_request ) {
2011-01-15 03:28:00 +02:00
SDL_Event event ;
event . type = FF_REFRESH_EVENT ;
event . user . data1 = opaque ;
2012-01-01 15:21:26 +03:00
if ( ! is - > refresh ) {
is - > refresh = 1 ;
2011-01-15 03:28:00 +02:00
SDL_PushEvent ( & event ) ;
2010-03-11 04:35:04 +02:00
}
2012-06-21 22:31:44 +03:00
av_usleep ( is - > audio_st & & is - > show_audio ? rdftspeed * 1000 : 5000 ) ; // FIXME ideally we should wait the correct time but SDLs event passing is so slow it would be silly
2010-03-11 04:35:04 +02:00
}
return 0 ;
2003-06-07 21:34:02 +03:00
}
2003-08-06 16:07:23 +03:00
/* get the current audio clock value */
2016-01-02 13:19:29 +02:00
static double get_audio_clock ( PlayerState * is )
2003-08-06 16:07:23 +03:00
{
double pts ;
int hw_buf_size , bytes_per_sec ;
pts = is - > audio_clock ;
hw_buf_size = audio_write_get_buf_size ( is ) ;
bytes_per_sec = 0 ;
if ( is - > audio_st ) {
2012-10-01 01:18:00 +03:00
bytes_per_sec = is - > sdl_sample_rate * is - > sdl_channels *
2012-04-25 23:46:22 +03:00
av_get_bytes_per_sample ( is - > sdl_sample_fmt ) ;
2003-08-06 16:07:23 +03:00
}
if ( bytes_per_sec )
pts - = ( double ) hw_buf_size / bytes_per_sec ;
return pts ;
}
/* get the current video clock value */
2016-01-02 13:19:29 +02:00
static double get_video_clock ( PlayerState * is )
2003-08-06 16:07:23 +03:00
{
2004-01-11 02:22:03 +02:00
if ( is - > paused ) {
2010-02-01 11:26:30 +02:00
return is - > video_current_pts ;
2003-11-10 20:59:45 +02:00
} else {
2014-10-22 12:23:08 +03:00
return is - > video_current_pts_drift + av_gettime_relative ( ) / 1000000.0 ;
2003-11-10 20:59:45 +02:00
}
2003-08-06 16:07:23 +03:00
}
/* get the current external clock value */
2016-01-02 13:19:29 +02:00
static double get_external_clock ( PlayerState * is )
2003-08-06 16:07:23 +03:00
{
int64_t ti ;
2014-10-22 12:23:08 +03:00
ti = av_gettime_relative ( ) ;
2003-08-06 16:07:23 +03:00
return is - > external_clock + ( ( ti - is - > external_clock_time ) * 1e-6 ) ;
}
/* get the current master clock value */
2016-01-02 13:19:29 +02:00
static double get_master_clock ( PlayerState * is )
2003-08-06 16:07:23 +03:00
{
double val ;
2003-11-10 20:59:45 +02:00
if ( is - > av_sync_type = = AV_SYNC_VIDEO_MASTER ) {
if ( is - > video_st )
val = get_video_clock ( is ) ;
else
val = get_audio_clock ( is ) ;
} else if ( is - > av_sync_type = = AV_SYNC_AUDIO_MASTER ) {
if ( is - > audio_st )
val = get_audio_clock ( is ) ;
else
val = get_video_clock ( is ) ;
} else {
2003-08-06 16:07:23 +03:00
val = get_external_clock ( is ) ;
2003-11-10 20:59:45 +02:00
}
2003-08-06 16:07:23 +03:00
return val ;
}
2003-11-10 20:59:45 +02:00
/* seek in the stream */
2016-01-02 13:19:29 +02:00
static void stream_seek ( PlayerState * is , int64_t pos , int64_t rel , int seek_by_bytes )
2003-11-10 20:59:45 +02:00
{
2005-06-24 11:32:55 +03:00
if ( ! is - > seek_req ) {
is - > seek_pos = pos ;
2009-03-14 18:24:30 +02:00
is - > seek_rel = rel ;
2010-02-02 18:01:22 +02:00
is - > seek_flags & = ~ AVSEEK_FLAG_BYTE ;
2006-11-08 00:35:41 +02:00
if ( seek_by_bytes )
is - > seek_flags | = AVSEEK_FLAG_BYTE ;
2005-06-24 11:32:55 +03:00
is - > seek_req = 1 ;
}
2003-11-10 20:59:45 +02:00
}
/* pause or resume the video */
2016-01-02 13:19:29 +02:00
static void stream_pause ( PlayerState * is )
2003-11-10 20:59:45 +02:00
{
2010-02-01 12:55:51 +02:00
if ( is - > paused ) {
2014-10-22 12:23:08 +03:00
is - > frame_timer + = av_gettime_relative ( ) / 1000000.0 + is - > video_current_pts_drift - is - > video_current_pts ;
2012-01-01 15:21:26 +03:00
if ( is - > read_pause_return ! = AVERROR ( ENOSYS ) ) {
2014-10-22 12:23:08 +03:00
is - > video_current_pts = is - > video_current_pts_drift + av_gettime_relative ( ) / 1000000.0 ;
2010-02-01 12:32:17 +02:00
}
2014-10-22 12:23:08 +03:00
is - > video_current_pts_drift = is - > video_current_pts - av_gettime_relative ( ) / 1000000.0 ;
2003-11-10 20:59:45 +02:00
}
2010-02-01 12:55:51 +02:00
is - > paused = ! is - > paused ;
2003-11-10 20:59:45 +02:00
}
2016-01-02 13:19:29 +02:00
static double compute_target_time ( double frame_current_pts , PlayerState * is )
2009-02-18 17:17:39 +02:00
{
2015-04-28 21:24:27 +02:00
double delay , sync_threshold , diff = 0 ;
2009-02-18 17:17:39 +02:00
/* compute nominal delay */
delay = frame_current_pts - is - > frame_last_pts ;
if ( delay < = 0 | | delay > = 10.0 ) {
/* if incorrect delay, use previous one */
delay = is - > frame_last_delay ;
2009-02-18 17:23:05 +02:00
} else {
2009-02-18 17:23:30 +02:00
is - > frame_last_delay = delay ;
2009-02-18 17:23:05 +02:00
}
2009-02-18 17:17:39 +02:00
is - > frame_last_pts = frame_current_pts ;
/* update delay to follow master synchronisation source */
if ( ( ( is - > av_sync_type = = AV_SYNC_AUDIO_MASTER & & is - > audio_st ) | |
is - > av_sync_type = = AV_SYNC_EXTERNAL_CLOCK ) ) {
/* if video is slave, we try to correct big delays by
duplicating or deleting a frame */
2010-02-03 01:22:35 +02:00
diff = get_video_clock ( is ) - get_master_clock ( is ) ;
2009-02-18 17:17:39 +02:00
/* skip or repeat frame. We take into account the
delay to compute the threshold . I still don ' t know
if it is the best guess */
sync_threshold = FFMAX ( AV_SYNC_THRESHOLD , delay ) ;
if ( fabs ( diff ) < AV_NOSYNC_THRESHOLD ) {
if ( diff < = - sync_threshold )
delay = 0 ;
else if ( diff > = sync_threshold )
delay = 2 * delay ;
}
}
is - > frame_timer + = delay ;
2011-06-08 01:41:12 +03:00
2015-03-16 10:57:35 +02:00
av_log ( NULL , AV_LOG_TRACE , " video: delay=%0.3f pts=%0.3f A-V=%f \n " ,
2011-06-08 01:41:12 +03:00
delay , frame_current_pts , - diff ) ;
2009-02-18 17:25:57 +02:00
2010-03-11 04:35:04 +02:00
return is - > frame_timer ;
2009-02-18 17:17:39 +02:00
}
2003-06-07 21:34:02 +03:00
/* called to display each frame */
static void video_refresh_timer ( void * opaque )
{
2016-01-02 13:19:29 +02:00
PlayerState * is = opaque ;
2003-06-07 21:34:02 +03:00
VideoPicture * vp ;
2003-08-06 16:07:23 +03:00
2005-08-14 04:29:34 +03:00
SubPicture * sp , * sp2 ;
2003-06-07 21:34:02 +03:00
if ( is - > video_st ) {
2010-03-11 04:35:04 +02:00
retry :
2003-06-07 21:34:02 +03:00
if ( is - > pictq_size = = 0 ) {
2012-01-01 15:21:26 +03:00
// nothing to do, no picture to display in the que
2003-06-07 21:34:02 +03:00
} else {
2014-10-22 12:23:08 +03:00
double time = av_gettime_relative ( ) / 1000000.0 ;
2010-03-11 04:35:04 +02:00
double next_target ;
2003-08-06 16:07:23 +03:00
/* dequeue the picture */
2003-06-07 21:34:02 +03:00
vp = & is - > pictq [ is - > pictq_rindex ] ;
2003-08-06 16:07:23 +03:00
2012-01-01 15:21:26 +03:00
if ( time < vp - > target_clock )
2010-03-11 04:35:04 +02:00
return ;
2003-08-06 16:07:23 +03:00
/* update current video pts */
is - > video_current_pts = vp - > pts ;
2010-03-11 04:35:04 +02:00
is - > video_current_pts_drift = is - > video_current_pts - time ;
2010-02-02 23:31:20 +02:00
is - > video_current_pos = vp - > pos ;
2012-01-01 15:21:26 +03:00
if ( is - > pictq_size > 1 ) {
VideoPicture * nextvp = & is - > pictq [ ( is - > pictq_rindex + 1 ) % VIDEO_PICTURE_QUEUE_SIZE ] ;
2010-03-11 04:35:04 +02:00
assert ( nextvp - > target_clock > = vp - > target_clock ) ;
next_target = nextvp - > target_clock ;
2012-01-01 15:21:26 +03:00
} else {
next_target = vp - > target_clock + is - > video_clock - vp - > pts ; // FIXME pass durations cleanly
2010-03-11 04:35:04 +02:00
}
2012-01-01 15:21:26 +03:00
if ( framedrop & & time > next_target ) {
2010-03-11 04:35:04 +02:00
is - > skip_frames * = 1.0 + FRAME_SKIP_FACTOR ;
2012-01-01 15:21:26 +03:00
if ( is - > pictq_size > 1 | | time > next_target + 0.5 ) {
2010-03-11 04:35:04 +02:00
/* update queue size and signal for next picture */
if ( + + is - > pictq_rindex = = VIDEO_PICTURE_QUEUE_SIZE )
is - > pictq_rindex = 0 ;
SDL_LockMutex ( is - > pictq_mutex ) ;
is - > pictq_size - - ;
SDL_CondSignal ( is - > pictq_cond ) ;
SDL_UnlockMutex ( is - > pictq_mutex ) ;
goto retry ;
}
}
2003-08-06 16:07:23 +03:00
2012-01-01 15:21:26 +03:00
if ( is - > subtitle_st ) {
2005-08-14 04:29:34 +03:00
if ( is - > subtitle_stream_changed ) {
SDL_LockMutex ( is - > subpq_mutex ) ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
while ( is - > subpq_size ) {
free_subpicture ( & is - > subpq [ is - > subpq_rindex ] ) ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
/* update queue size and signal for next picture */
if ( + + is - > subpq_rindex = = SUBPICTURE_QUEUE_SIZE )
is - > subpq_rindex = 0 ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
is - > subpq_size - - ;
}
is - > subtitle_stream_changed = 0 ;
SDL_CondSignal ( is - > subpq_cond ) ;
SDL_UnlockMutex ( is - > subpq_mutex ) ;
} else {
if ( is - > subpq_size > 0 ) {
sp = & is - > subpq [ is - > subpq_rindex ] ;
if ( is - > subpq_size > 1 )
sp2 = & is - > subpq [ ( is - > subpq_rindex + 1 ) % SUBPICTURE_QUEUE_SIZE ] ;
else
sp2 = NULL ;
if ( ( is - > video_current_pts > ( sp - > pts + ( ( float ) sp - > sub . end_display_time / 1000 ) ) )
| | ( sp2 & & is - > video_current_pts > ( sp2 - > pts + ( ( float ) sp2 - > sub . start_display_time / 1000 ) ) ) )
{
free_subpicture ( sp ) ;
/* update queue size and signal for next picture */
if ( + + is - > subpq_rindex = = SUBPICTURE_QUEUE_SIZE )
is - > subpq_rindex = 0 ;
SDL_LockMutex ( is - > subpq_mutex ) ;
is - > subpq_size - - ;
SDL_CondSignal ( is - > subpq_cond ) ;
SDL_UnlockMutex ( is - > subpq_mutex ) ;
}
}
}
}
2003-06-07 21:34:02 +03:00
/* display picture */
2011-01-15 19:21:09 +02:00
if ( ! display_disable )
2011-01-15 19:21:12 +02:00
video_display ( is ) ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
/* update queue size and signal for next picture */
if ( + + is - > pictq_rindex = = VIDEO_PICTURE_QUEUE_SIZE )
is - > pictq_rindex = 0 ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
SDL_LockMutex ( is - > pictq_mutex ) ;
is - > pictq_size - - ;
SDL_CondSignal ( is - > pictq_cond ) ;
SDL_UnlockMutex ( is - > pictq_mutex ) ;
}
} else if ( is - > audio_st ) {
/* draw the next audio frame */
/* if only audio stream, then display the audio bars (better
than nothing , just to test the implementation */
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
/* display picture */
2011-01-15 19:21:09 +02:00
if ( ! display_disable )
2011-01-15 19:21:12 +02:00
video_display ( is ) ;
2003-06-07 21:34:02 +03:00
}
if ( show_status ) {
static int64_t last_time ;
int64_t cur_time ;
2005-08-14 04:29:34 +03:00
int aqsize , vqsize , sqsize ;
2003-08-06 16:07:23 +03:00
double av_diff ;
2005-12-17 20:14:38 +02:00
2014-10-22 12:23:08 +03:00
cur_time = av_gettime_relative ( ) ;
2009-07-31 00:54:50 +03:00
if ( ! last_time | | ( cur_time - last_time ) > = 30000 ) {
2003-06-07 21:34:02 +03:00
aqsize = 0 ;
vqsize = 0 ;
2005-08-14 04:29:34 +03:00
sqsize = 0 ;
2003-06-07 21:34:02 +03:00
if ( is - > audio_st )
aqsize = is - > audioq . size ;
if ( is - > video_st )
vqsize = is - > videoq . size ;
2005-08-14 04:29:34 +03:00
if ( is - > subtitle_st )
sqsize = is - > subtitleq . size ;
2003-08-06 16:07:23 +03:00
av_diff = 0 ;
if ( is - > audio_st & & is - > video_st )
av_diff = get_audio_clock ( is ) - get_video_clock ( is ) ;
2010-03-12 17:12:05 +02:00
printf ( " %7.2f A-V:%7.3f s:%3.1f aq=%5dKB vq=%5dKB sq=%5dB f=% " PRId64 " /% " PRId64 " \r " ,
2012-01-01 15:21:26 +03:00
get_master_clock ( is ) , av_diff , FFMAX ( is - > skip_frames - 1 , 0 ) , aqsize / 1024 ,
vqsize / 1024 , sqsize , is - > pts_ctx . num_faulty_dts , is - > pts_ctx . num_faulty_pts ) ;
2003-06-07 21:34:02 +03:00
fflush ( stdout ) ;
last_time = cur_time ;
}
}
}
2016-01-02 13:19:29 +02:00
static void player_close ( PlayerState * is )
2010-08-17 10:46:09 +03:00
{
VideoPicture * vp ;
int i ;
/* XXX: use a special url_shutdown call to abort parse cleanly */
is - > abort_request = 1 ;
SDL_WaitThread ( is - > parse_tid , NULL ) ;
SDL_WaitThread ( is - > refresh_tid , NULL ) ;
/* free all pictures */
2012-01-01 15:21:26 +03:00
for ( i = 0 ; i < VIDEO_PICTURE_QUEUE_SIZE ; i + + ) {
2010-08-17 10:46:09 +03:00
vp = & is - > pictq [ i ] ;
if ( vp - > bmp ) {
SDL_FreeYUVOverlay ( vp - > bmp ) ;
vp - > bmp = NULL ;
}
}
SDL_DestroyMutex ( is - > pictq_mutex ) ;
SDL_DestroyCond ( is - > pictq_cond ) ;
SDL_DestroyMutex ( is - > subpq_mutex ) ;
SDL_DestroyCond ( is - > subpq_cond ) ;
}
static void do_exit ( void )
{
2016-01-02 13:19:30 +02:00
if ( player ) {
player_close ( player ) ;
player = NULL ;
2010-08-17 10:46:09 +03:00
}
2010-10-02 11:44:33 +03:00
uninit_opts ( ) ;
2011-11-06 03:47:48 +03:00
avformat_network_deinit ( ) ;
2010-08-17 10:46:09 +03:00
if ( show_status )
printf ( " \n " ) ;
SDL_Quit ( ) ;
2010-09-24 18:39:10 +03:00
av_log ( NULL , AV_LOG_QUIET , " " ) ;
2010-08-17 10:46:09 +03:00
exit ( 0 ) ;
}
2003-06-07 21:34:02 +03:00
/* allocate a picture (needs to do that in main thread to avoid
potential locking problems */
static void alloc_picture ( void * opaque )
{
2016-01-02 13:19:29 +02:00
PlayerState * is = opaque ;
2003-06-07 21:34:02 +03:00
VideoPicture * vp ;
vp = & is - > pictq [ is - > pictq_windex ] ;
if ( vp - > bmp )
SDL_FreeYUVOverlay ( vp - > bmp ) ;
2010-03-05 04:20:10 +02:00
vp - > width = is - > out_video_filter - > inputs [ 0 ] - > w ;
vp - > height = is - > out_video_filter - > inputs [ 0 ] - > h ;
vp - > pix_fmt = is - > out_video_filter - > inputs [ 0 ] - > format ;
vp - > bmp = SDL_CreateYUVOverlay ( vp - > width , vp - > height ,
2005-12-17 20:14:38 +02:00
SDL_YV12_OVERLAY ,
2003-09-16 22:37:27 +03:00
screen ) ;
2010-08-17 10:47:44 +03:00
if ( ! vp - > bmp | | vp - > bmp - > pitches [ 0 ] < vp - > width ) {
/* SDL allocates a buffer smaller than requested if the video
* overlay hardware is unable to support the requested size . */
fprintf ( stderr , " Error: the video system does not support an image \n "
2012-04-12 15:55:49 +03:00
" size of %dx%d pixels. Try using -vf \" scale=w:h \" \n "
2010-08-17 10:47:44 +03:00
" to reduce the image size. \n " , vp - > width , vp - > height ) ;
do_exit ( ) ;
}
2003-06-07 21:34:02 +03:00
SDL_LockMutex ( is - > pictq_mutex ) ;
vp - > allocated = 1 ;
SDL_CondSignal ( is - > pictq_cond ) ;
SDL_UnlockMutex ( is - > pictq_mutex ) ;
}
2012-08-24 14:31:50 +03:00
/* The 'pts' parameter is the dts of the packet / pts of the frame and
* guessed if not known . */
2016-01-02 13:19:29 +02:00
static int queue_picture ( PlayerState * is , AVFrame * src_frame , double pts , int64_t pos )
2003-06-07 21:34:02 +03:00
{
VideoPicture * vp ;
2016-01-31 15:11:50 +02:00
2003-06-07 21:34:02 +03:00
/* wait until we have space to put a new picture */
SDL_LockMutex ( is - > pictq_mutex ) ;
2010-03-11 04:35:04 +02:00
2012-01-01 15:21:26 +03:00
if ( is - > pictq_size > = VIDEO_PICTURE_QUEUE_SIZE & & ! is - > refresh )
is - > skip_frames = FFMAX ( 1.0 - FRAME_SKIP_FACTOR , is - > skip_frames * ( 1.0 - FRAME_SKIP_FACTOR ) ) ;
2010-03-11 04:35:04 +02:00
2003-06-07 21:34:02 +03:00
while ( is - > pictq_size > = VIDEO_PICTURE_QUEUE_SIZE & &
! is - > videoq . abort_request ) {
SDL_CondWait ( is - > pictq_cond , is - > pictq_mutex ) ;
}
SDL_UnlockMutex ( is - > pictq_mutex ) ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
if ( is - > videoq . abort_request )
return - 1 ;
vp = & is - > pictq [ is - > pictq_windex ] ;
2014-07-06 23:18:27 +03:00
vp - > sar = src_frame - > sample_aspect_ratio ;
2003-06-07 21:34:02 +03:00
/* alloc or resize hardware picture buffer */
2011-10-21 15:56:57 +03:00
if ( ! vp - > bmp | | vp - > reallocate | |
2010-03-05 04:20:10 +02:00
vp - > width ! = is - > out_video_filter - > inputs [ 0 ] - > w | |
vp - > height ! = is - > out_video_filter - > inputs [ 0 ] - > h ) {
2003-06-07 21:34:02 +03:00
SDL_Event event ;
2011-10-21 15:56:57 +03:00
vp - > allocated = 0 ;
vp - > reallocate = 0 ;
2003-06-07 21:34:02 +03:00
/* the allocation must be done in the main thread to avoid
locking problems */
event . type = FF_ALLOC_EVENT ;
event . user . data1 = is ;
SDL_PushEvent ( & event ) ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
/* wait until the picture is allocated */
SDL_LockMutex ( is - > pictq_mutex ) ;
while ( ! vp - > allocated & & ! is - > videoq . abort_request ) {
SDL_CondWait ( is - > pictq_cond , is - > pictq_mutex ) ;
}
SDL_UnlockMutex ( is - > pictq_mutex ) ;
if ( is - > videoq . abort_request )
return - 1 ;
}
2003-08-06 16:07:23 +03:00
/* if the frame is not skipped, then display it */
2003-06-07 21:34:02 +03:00
if ( vp - > bmp ) {
2015-10-14 11:33:26 +02:00
uint8_t * data [ 4 ] ;
int linesize [ 4 ] ;
2009-03-23 18:43:06 +02:00
2003-06-07 21:34:02 +03:00
/* get a pointer on the bitmap */
SDL_LockYUVOverlay ( vp - > bmp ) ;
2015-10-14 11:33:26 +02:00
data [ 0 ] = vp - > bmp - > pixels [ 0 ] ;
data [ 1 ] = vp - > bmp - > pixels [ 2 ] ;
data [ 2 ] = vp - > bmp - > pixels [ 1 ] ;
2003-06-07 21:34:02 +03:00
2015-10-14 11:33:26 +02:00
linesize [ 0 ] = vp - > bmp - > pitches [ 0 ] ;
linesize [ 1 ] = vp - > bmp - > pitches [ 2 ] ;
linesize [ 2 ] = vp - > bmp - > pitches [ 1 ] ;
2010-03-05 04:20:10 +02:00
2012-01-01 15:21:26 +03:00
// FIXME use direct rendering
2015-10-14 11:33:26 +02:00
av_image_copy ( data , linesize , src_frame - > data , src_frame - > linesize ,
vp - > pix_fmt , vp - > width , vp - > height ) ;
2016-01-31 15:11:50 +02:00
2003-06-07 21:34:02 +03:00
/* update the bitmap content */
SDL_UnlockYUVOverlay ( vp - > bmp ) ;
2003-08-06 16:07:23 +03:00
vp - > pts = pts ;
2010-02-02 18:51:02 +02:00
vp - > pos = pos ;
2003-06-07 21:34:02 +03:00
/* now we can update the picture count */
if ( + + is - > pictq_windex = = VIDEO_PICTURE_QUEUE_SIZE )
is - > pictq_windex = 0 ;
SDL_LockMutex ( is - > pictq_mutex ) ;
2012-01-01 15:21:26 +03:00
vp - > target_clock = compute_target_time ( vp - > pts , is ) ;
2010-03-11 04:35:04 +02:00
2003-06-07 21:34:02 +03:00
is - > pictq_size + + ;
SDL_UnlockMutex ( is - > pictq_mutex ) ;
}
2003-08-06 16:07:23 +03:00
return 0 ;
}
2012-08-24 14:31:50 +03:00
/* Compute the exact PTS for the picture if it is omitted in the stream.
* The ' pts1 ' parameter is the dts of the packet / pts of the frame . */
2016-01-02 13:19:29 +02:00
static int output_picture2 ( PlayerState * is , AVFrame * src_frame , double pts1 , int64_t pos )
2003-08-06 16:07:23 +03:00
{
double frame_delay , pts ;
2013-02-17 18:06:16 +03:00
int ret ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
pts = pts1 ;
2003-06-07 21:34:02 +03:00
if ( pts ! = 0 ) {
2003-08-06 16:07:23 +03:00
/* update video clock with pts, if present */
2003-06-07 21:34:02 +03:00
is - > video_clock = pts ;
} else {
2003-11-10 20:59:45 +02:00
pts = is - > video_clock ;
}
/* update video clock for next frame */
2016-02-09 13:36:13 +02:00
frame_delay = av_q2d ( is - > video_dec - > time_base ) ;
2003-11-10 20:59:45 +02:00
/* for MPEG2, the frame can be repeated, so we update the
clock accordingly */
2005-09-20 21:47:08 +03:00
frame_delay + = src_frame - > repeat_pict * ( frame_delay * 0.5 ) ;
2003-11-10 20:59:45 +02:00
is - > video_clock + = frame_delay ;
2003-08-06 16:07:23 +03:00
2013-02-17 18:06:16 +03:00
ret = queue_picture ( is , src_frame , pts , pos ) ;
av_frame_unref ( src_frame ) ;
return ret ;
2003-06-07 21:34:02 +03:00
}
2016-01-02 13:19:29 +02:00
static int get_video_frame ( PlayerState * is , AVFrame * frame , int64_t * pts , AVPacket * pkt )
2003-06-07 21:34:02 +03:00
{
2011-07-11 18:04:15 +03:00
int got_picture , i ;
2003-06-07 21:34:02 +03:00
2011-01-16 19:26:00 +02:00
if ( packet_queue_get ( & is - > videoq , pkt , 1 ) < 0 )
return - 1 ;
2010-02-01 14:19:28 +02:00
2011-01-16 19:26:00 +02:00
if ( pkt - > data = = flush_pkt . data ) {
2016-02-09 13:36:13 +02:00
avcodec_flush_buffers ( is - > video_dec ) ;
2010-02-01 14:19:28 +02:00
2011-01-16 19:26:00 +02:00
SDL_LockMutex ( is - > pictq_mutex ) ;
2012-01-01 15:21:26 +03:00
// Make sure there are no long delay timers (ideally we should just flush the que but thats harder)
2011-01-16 19:26:00 +02:00
for ( i = 0 ; i < VIDEO_PICTURE_QUEUE_SIZE ; i + + ) {
is - > pictq [ i ] . target_clock = 0 ;
}
while ( is - > pictq_size & & ! is - > videoq . abort_request ) {
SDL_CondWait ( is - > pictq_cond , is - > pictq_mutex ) ;
2006-11-16 13:58:27 +02:00
}
2011-01-16 19:26:00 +02:00
is - > video_current_pos = - 1 ;
SDL_UnlockMutex ( is - > pictq_mutex ) ;
2006-11-16 13:58:27 +02:00
2011-01-16 19:26:00 +02:00
init_pts_correction ( & is - > pts_ctx ) ;
is - > frame_last_pts = AV_NOPTS_VALUE ;
is - > frame_last_delay = 0 ;
2014-10-22 12:23:08 +03:00
is - > frame_timer = ( double ) av_gettime_relative ( ) / 1000000.0 ;
2011-01-16 19:26:00 +02:00
is - > skip_frames = 1 ;
is - > skip_frames_index = 0 ;
return 0 ;
}
2010-09-28 05:05:12 +03:00
2016-02-09 13:36:13 +02:00
avcodec_decode_video2 ( is - > video_dec , frame , & got_picture , pkt ) ;
2011-01-16 19:26:00 +02:00
if ( got_picture ) {
if ( decoder_reorder_pts = = - 1 ) {
2011-02-05 07:28:24 +02:00
* pts = guess_correct_pts ( & is - > pts_ctx , frame - > pkt_pts , frame - > pkt_dts ) ;
2011-01-16 19:26:00 +02:00
} else if ( decoder_reorder_pts ) {
2011-01-16 19:39:34 +02:00
* pts = frame - > pkt_pts ;
2011-01-16 19:26:00 +02:00
} else {
2011-02-05 07:28:24 +02:00
* pts = frame - > pkt_dts ;
2011-01-16 19:26:00 +02:00
}
if ( * pts = = AV_NOPTS_VALUE ) {
* pts = 0 ;
2010-02-01 15:03:46 +02:00
}
2013-02-07 20:42:39 +03:00
if ( is - > video_st - > sample_aspect_ratio . num ) {
frame - > sample_aspect_ratio = is - > video_st - > sample_aspect_ratio ;
}
2010-01-31 20:54:32 +02:00
2010-03-11 04:35:04 +02:00
is - > skip_frames_index + = 1 ;
2012-01-01 15:21:26 +03:00
if ( is - > skip_frames_index > = is - > skip_frames ) {
2010-03-11 04:35:04 +02:00
is - > skip_frames_index - = FFMAX ( is - > skip_frames , 1.0 ) ;
return 1 ;
}
2013-02-17 18:06:16 +03:00
av_frame_unref ( frame ) ;
2010-03-11 04:35:04 +02:00
}
2010-03-05 04:20:10 +02:00
return 0 ;
}
2016-01-02 13:19:29 +02:00
static int configure_video_filters ( AVFilterGraph * graph , PlayerState * is , const char * vfilters )
2010-03-05 04:20:10 +02:00
{
2010-05-09 00:39:57 +03:00
char sws_flags_str [ 128 ] ;
2012-05-30 09:53:08 +03:00
char buffersrc_args [ 256 ] ;
2011-02-01 20:28:09 +02:00
int ret ;
2015-04-29 21:24:48 +02:00
AVFilterContext * filt_src = NULL , * filt_out = NULL , * last_filter ;
2016-02-09 13:36:13 +02:00
AVCodecContext * codec = is - > video_dec ;
2012-05-30 09:53:08 +03:00
2012-11-28 23:23:57 +03:00
snprintf ( sws_flags_str , sizeof ( sws_flags_str ) , " flags=% " PRId64 , sws_flags ) ;
2010-05-09 00:39:57 +03:00
graph - > scale_sws_opts = av_strdup ( sws_flags_str ) ;
2010-03-05 04:20:10 +02:00
2012-05-30 09:53:08 +03:00
snprintf ( buffersrc_args , sizeof ( buffersrc_args ) , " %d:%d:%d:%d:%d:%d:%d " ,
codec - > width , codec - > height , codec - > pix_fmt ,
is - > video_st - > time_base . num , is - > video_st - > time_base . den ,
codec - > sample_aspect_ratio . num , codec - > sample_aspect_ratio . den ) ;
if ( ( ret = avfilter_graph_create_filter ( & filt_src ,
avfilter_get_by_name ( " buffer " ) ,
" src " , buffersrc_args , NULL ,
graph ) ) < 0 )
2011-07-11 17:32:54 +03:00
return ret ;
2012-04-27 07:56:56 +03:00
if ( ( ret = avfilter_graph_create_filter ( & filt_out ,
avfilter_get_by_name ( " buffersink " ) ,
" out " , NULL , NULL , graph ) ) < 0 )
2011-07-11 17:32:54 +03:00
return ret ;
2010-03-05 04:20:10 +02:00
2015-04-29 21:24:48 +02:00
last_filter = filt_out ;
/* Note: this macro adds a filter before the lastly added filter, so the
* processing order of the filters is in reverse */
# define INSERT_FILT(name, arg) do { \
AVFilterContext * filt_ctx ; \
\
ret = avfilter_graph_create_filter ( & filt_ctx , \
avfilter_get_by_name ( name ) , \
" avplay_ " name , arg , NULL , graph ) ; \
if ( ret < 0 ) \
return ret ; \
\
ret = avfilter_link ( filt_ctx , 0 , last_filter , 0 ) ; \
if ( ret < 0 ) \
return ret ; \
\
last_filter = filt_ctx ; \
} while ( 0 )
INSERT_FILT ( " format " , " yuv420p " ) ;
2012-04-27 07:56:56 +03:00
2015-04-29 21:28:45 +02:00
if ( autorotate ) {
uint8_t * displaymatrix = av_stream_get_side_data ( is - > video_st ,
AV_PKT_DATA_DISPLAYMATRIX , NULL ) ;
if ( displaymatrix ) {
double rot = av_display_rotation_get ( ( int32_t * ) displaymatrix ) ;
if ( rot < - 135 | | rot > 135 ) {
INSERT_FILT ( " vflip " , NULL ) ;
INSERT_FILT ( " hflip " , NULL ) ;
} else if ( rot < - 45 ) {
INSERT_FILT ( " transpose " , " dir=clock " ) ;
} else if ( rot > 45 ) {
INSERT_FILT ( " transpose " , " dir=cclock " ) ;
}
}
}
2012-01-01 15:21:26 +03:00
if ( vfilters ) {
2011-06-11 16:30:46 +03:00
AVFilterInOut * outputs = avfilter_inout_alloc ( ) ;
AVFilterInOut * inputs = avfilter_inout_alloc ( ) ;
2010-03-05 04:20:10 +02:00
outputs - > name = av_strdup ( " in " ) ;
2010-11-07 20:40:18 +02:00
outputs - > filter_ctx = filt_src ;
2010-03-05 04:20:10 +02:00
outputs - > pad_idx = 0 ;
outputs - > next = NULL ;
inputs - > name = av_strdup ( " out " ) ;
2015-04-29 21:24:48 +02:00
inputs - > filter_ctx = last_filter ;
2010-03-05 04:20:10 +02:00
inputs - > pad_idx = 0 ;
inputs - > next = NULL ;
2011-02-01 20:28:09 +02:00
if ( ( ret = avfilter_graph_parse ( graph , vfilters , inputs , outputs , NULL ) ) < 0 )
2011-07-11 17:32:54 +03:00
return ret ;
2010-03-05 04:20:10 +02:00
} else {
2015-04-29 21:24:48 +02:00
if ( ( ret = avfilter_link ( filt_src , 0 , last_filter , 0 ) ) < 0 )
2011-07-11 17:32:54 +03:00
return ret ;
2010-03-05 04:20:10 +02:00
}
2011-02-01 20:28:09 +02:00
if ( ( ret = avfilter_graph_config ( graph , NULL ) ) < 0 )
2011-07-11 17:32:54 +03:00
return ret ;
2010-03-05 04:20:10 +02:00
2012-05-30 09:53:08 +03:00
is - > in_video_filter = filt_src ;
2010-03-05 04:20:10 +02:00
is - > out_video_filter = filt_out ;
2011-07-11 17:32:54 +03:00
2011-02-01 20:28:09 +02:00
return ret ;
}
static int video_thread ( void * arg )
{
2012-06-28 21:55:04 +03:00
AVPacket pkt = { 0 } ;
2016-01-02 13:19:29 +02:00
PlayerState * is = arg ;
2013-02-17 18:06:16 +03:00
AVFrame * frame = av_frame_alloc ( ) ;
2011-02-01 20:28:09 +02:00
int64_t pts_int ;
double pts ;
int ret ;
AVFilterGraph * graph = avfilter_graph_alloc ( ) ;
2012-05-30 09:53:08 +03:00
AVFilterContext * filt_out = NULL , * filt_in = NULL ;
2016-02-09 13:36:13 +02:00
int last_w = is - > video_dec - > width ;
int last_h = is - > video_dec - > height ;
2015-04-19 12:43:14 +02:00
if ( ! graph ) {
av_frame_free ( & frame ) ;
2015-03-21 12:44:56 +02:00
return AVERROR ( ENOMEM ) ;
2015-04-19 12:43:14 +02:00
}
2011-02-01 20:28:09 +02:00
if ( ( ret = configure_video_filters ( graph , is , vfilters ) ) < 0 )
goto the_end ;
2012-05-30 09:53:08 +03:00
filt_in = is - > in_video_filter ;
2011-02-01 20:28:09 +02:00
filt_out = is - > out_video_filter ;
2010-03-05 04:20:10 +02:00
2015-04-19 12:43:14 +02:00
if ( ! frame ) {
avfilter_graph_free ( & graph ) ;
2015-02-04 16:20:59 +02:00
return AVERROR ( ENOMEM ) ;
2015-04-19 12:43:14 +02:00
}
2015-02-04 16:20:59 +02:00
2012-01-01 15:21:26 +03:00
for ( ; ; ) {
2010-10-12 21:40:16 +03:00
AVRational tb ;
2010-03-05 04:20:10 +02:00
while ( is - > paused & & ! is - > videoq . abort_request )
SDL_Delay ( 10 ) ;
2012-05-30 09:53:08 +03:00
2015-10-23 11:11:31 +02:00
av_packet_unref ( & pkt ) ;
2012-06-28 21:55:04 +03:00
2012-05-30 09:53:08 +03:00
ret = get_video_frame ( is , frame , & pts_int , & pkt ) ;
if ( ret < 0 )
goto the_end ;
if ( ! ret )
continue ;
2016-02-09 13:36:13 +02:00
if ( last_w ! = is - > video_dec - > width
| | last_h ! = is - > video_dec - > height ) {
2015-03-16 10:57:35 +02:00
av_log ( NULL , AV_LOG_TRACE , " Changing size %dx%d -> %dx%d \n " , last_w , last_h ,
2016-02-09 13:36:13 +02:00
is - > video_dec - > width , is - > video_dec - > height ) ;
2011-08-13 19:44:04 +03:00
avfilter_graph_free ( & graph ) ;
graph = avfilter_graph_alloc ( ) ;
if ( ( ret = configure_video_filters ( graph , is , vfilters ) ) < 0 )
goto the_end ;
2012-07-04 12:35:18 +03:00
filt_in = is - > in_video_filter ;
2011-08-13 19:44:04 +03:00
filt_out = is - > out_video_filter ;
2016-02-09 13:36:13 +02:00
last_w = is - > video_dec - > width ;
last_h = is - > video_dec - > height ;
2011-08-13 19:44:04 +03:00
}
2012-05-30 09:53:08 +03:00
frame - > pts = pts_int ;
2013-02-17 18:06:16 +03:00
ret = av_buffersrc_add_frame ( filt_in , frame ) ;
if ( ret < 0 )
goto the_end ;
2012-05-30 09:53:08 +03:00
while ( ret > = 0 ) {
2013-02-17 18:06:16 +03:00
ret = av_buffersink_get_frame ( filt_out , frame ) ;
2012-05-30 09:53:08 +03:00
if ( ret < 0 ) {
ret = 0 ;
break ;
}
2013-02-17 18:06:16 +03:00
pts_int = frame - > pts ;
2012-04-27 07:56:56 +03:00
tb = filt_out - > inputs [ 0 ] - > time_base ;
2012-05-30 09:53:08 +03:00
if ( av_cmp_q ( tb , is - > video_st - > time_base ) ) {
av_unused int64_t pts1 = pts_int ;
pts_int = av_rescale_q ( pts_int , tb , is - > video_st - > time_base ) ;
2015-03-16 10:57:35 +02:00
av_log ( NULL , AV_LOG_TRACE , " video_thread(): "
2012-05-30 09:53:08 +03:00
" tb:%d/%d pts:% " PRId64 " -> tb:%d/%d pts:% " PRId64 " \n " ,
tb . num , tb . den , pts1 ,
is - > video_st - > time_base . num , is - > video_st - > time_base . den , pts_int ) ;
}
pts = pts_int * av_q2d ( is - > video_st - > time_base ) ;
2013-02-17 18:06:16 +03:00
ret = output_picture2 ( is , frame , pts , 0 ) ;
2010-10-12 21:40:16 +03:00
}
2012-05-30 09:53:08 +03:00
2010-03-05 04:20:10 +02:00
if ( ret < 0 )
goto the_end ;
2013-02-17 18:06:16 +03:00
2005-12-17 20:14:38 +02:00
if ( step )
2016-01-02 13:19:30 +02:00
if ( player )
stream_pause ( player ) ;
2003-06-07 21:34:02 +03:00
}
the_end :
2012-04-11 04:18:53 +03:00
av_freep ( & vfilters ) ;
2011-02-01 21:02:17 +02:00
avfilter_graph_free ( & graph ) ;
2015-10-23 11:11:31 +02:00
av_packet_unref ( & pkt ) ;
2013-02-17 18:06:16 +03:00
av_frame_free ( & frame ) ;
2003-06-07 21:34:02 +03:00
return 0 ;
}
2005-08-14 04:29:34 +03:00
static int subtitle_thread ( void * arg )
{
2016-01-02 13:19:29 +02:00
PlayerState * is = arg ;
2005-08-14 04:29:34 +03:00
SubPicture * sp ;
AVPacket pkt1 , * pkt = & pkt1 ;
2011-07-11 18:04:15 +03:00
int got_subtitle ;
2005-08-14 04:29:34 +03:00
double pts ;
int i , j ;
int r , g , b , y , u , v , a ;
2012-01-01 15:21:26 +03:00
for ( ; ; ) {
2005-08-14 04:29:34 +03:00
while ( is - > paused & & ! is - > subtitleq . abort_request ) {
SDL_Delay ( 10 ) ;
}
if ( packet_queue_get ( & is - > subtitleq , pkt , 1 ) < 0 )
break ;
2005-12-17 20:14:38 +02:00
2012-01-01 15:21:26 +03:00
if ( pkt - > data = = flush_pkt . data ) {
2016-02-09 13:36:13 +02:00
avcodec_flush_buffers ( is - > subtitle_dec ) ;
2006-11-16 13:58:27 +02:00
continue ;
}
2005-08-14 04:29:34 +03:00
SDL_LockMutex ( is - > subpq_mutex ) ;
while ( is - > subpq_size > = SUBPICTURE_QUEUE_SIZE & &
! is - > subtitleq . abort_request ) {
SDL_CondWait ( is - > subpq_cond , is - > subpq_mutex ) ;
}
SDL_UnlockMutex ( is - > subpq_mutex ) ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
if ( is - > subtitleq . abort_request )
2011-07-11 17:32:54 +03:00
return 0 ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
sp = & is - > subpq [ is - > subpq_windex ] ;
/* NOTE: ipts is the PTS of the _first_ picture beginning in
this packet , if any */
pts = 0 ;
if ( pkt - > pts ! = AV_NOPTS_VALUE )
2016-02-09 13:36:13 +02:00
pts = av_q2d ( is - > subtitle_dec - > time_base ) * pkt - > pts ;
2005-08-14 04:29:34 +03:00
2016-02-09 13:36:13 +02:00
avcodec_decode_subtitle2 ( is - > subtitle_dec , & sp - > sub ,
2011-07-11 18:04:15 +03:00
& got_subtitle , pkt ) ;
2005-08-14 04:29:34 +03:00
if ( got_subtitle & & sp - > sub . format = = 0 ) {
sp - > pts = pts ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
for ( i = 0 ; i < sp - > sub . num_rects ; i + + )
{
2009-01-03 19:54:48 +02:00
for ( j = 0 ; j < sp - > sub . rects [ i ] - > nb_colors ; j + + )
2005-08-14 04:29:34 +03:00
{
2015-10-14 11:33:25 +02:00
RGBA_IN ( r , g , b , a , ( uint32_t * ) sp - > sub . rects [ i ] - > data [ 1 ] + j ) ;
2005-08-14 04:29:34 +03:00
y = RGB_TO_Y_CCIR ( r , g , b ) ;
u = RGB_TO_U_CCIR ( r , g , b , 0 ) ;
v = RGB_TO_V_CCIR ( r , g , b , 0 ) ;
2015-10-14 11:33:25 +02:00
YUVA_OUT ( ( uint32_t * ) sp - > sub . rects [ i ] - > data [ 1 ] + j , y , u , v , a ) ;
2005-08-14 04:29:34 +03:00
}
}
/* now we can update the picture count */
if ( + + is - > subpq_windex = = SUBPICTURE_QUEUE_SIZE )
is - > subpq_windex = 0 ;
SDL_LockMutex ( is - > subpq_mutex ) ;
is - > subpq_size + + ;
SDL_UnlockMutex ( is - > subpq_mutex ) ;
}
2015-10-23 11:11:31 +02:00
av_packet_unref ( pkt ) ;
2005-08-14 04:29:34 +03:00
}
return 0 ;
}
2003-06-07 21:34:02 +03:00
/* copy samples for viewing in editor window */
2016-01-02 13:19:29 +02:00
static void update_sample_display ( PlayerState * is , short * samples , int samples_size )
2003-06-07 21:34:02 +03:00
{
2011-06-25 15:09:40 +03:00
int size , len ;
2003-06-07 21:34:02 +03:00
size = samples_size / sizeof ( short ) ;
while ( size > 0 ) {
len = SAMPLE_ARRAY_SIZE - is - > sample_array_index ;
if ( len > size )
len = size ;
memcpy ( is - > sample_array + is - > sample_array_index , samples , len * sizeof ( short ) ) ;
samples + = len ;
is - > sample_array_index + = len ;
if ( is - > sample_array_index > = SAMPLE_ARRAY_SIZE )
is - > sample_array_index = 0 ;
size - = len ;
}
}
/* return the new audio buffer size (samples can be added or deleted
to get better sync if video or external master clock ) */
2016-01-02 13:19:29 +02:00
static int synchronize_audio ( PlayerState * is , short * samples ,
2003-08-06 16:07:23 +03:00
int samples_size1 , double pts )
2003-06-07 21:34:02 +03:00
{
2003-08-06 16:07:23 +03:00
int n , samples_size ;
2003-06-07 21:34:02 +03:00
double ref_clock ;
2005-12-17 20:14:38 +02:00
2012-04-25 23:46:22 +03:00
n = is - > sdl_channels * av_get_bytes_per_sample ( is - > sdl_sample_fmt ) ;
2003-08-06 16:07:23 +03:00
samples_size = samples_size1 ;
2003-06-07 21:34:02 +03:00
/* if not master, then we try to remove or add samples to correct the clock */
if ( ( ( is - > av_sync_type = = AV_SYNC_VIDEO_MASTER & & is - > video_st ) | |
2003-08-06 16:07:23 +03:00
is - > av_sync_type = = AV_SYNC_EXTERNAL_CLOCK ) ) {
double diff , avg_diff ;
2003-06-07 21:34:02 +03:00
int wanted_size , min_size , max_size , nb_samples ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
ref_clock = get_master_clock ( is ) ;
diff = get_audio_clock ( is ) - ref_clock ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
if ( diff < AV_NOSYNC_THRESHOLD ) {
is - > audio_diff_cum = diff + is - > audio_diff_avg_coef * is - > audio_diff_cum ;
if ( is - > audio_diff_avg_count < AUDIO_DIFF_AVG_NB ) {
/* not enough measures to have a correct estimate */
is - > audio_diff_avg_count + + ;
} else {
/* estimate the A-V difference */
avg_diff = is - > audio_diff_cum * ( 1.0 - is - > audio_diff_avg_coef ) ;
if ( fabs ( avg_diff ) > = is - > audio_diff_threshold ) {
2012-10-01 01:18:00 +03:00
wanted_size = samples_size + ( ( int ) ( diff * is - > sdl_sample_rate ) * n ) ;
2003-08-06 16:07:23 +03:00
nb_samples = samples_size / n ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
min_size = ( ( nb_samples * ( 100 - SAMPLE_CORRECTION_PERCENT_MAX ) ) / 100 ) * n ;
max_size = ( ( nb_samples * ( 100 + SAMPLE_CORRECTION_PERCENT_MAX ) ) / 100 ) * n ;
if ( wanted_size < min_size )
wanted_size = min_size ;
else if ( wanted_size > max_size )
wanted_size = max_size ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
/* add or remove samples to correction the synchro */
if ( wanted_size < samples_size ) {
/* remove samples */
samples_size = wanted_size ;
} else if ( wanted_size > samples_size ) {
uint8_t * samples_end , * q ;
int nb ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
/* add samples */
nb = ( samples_size - wanted_size ) ;
samples_end = ( uint8_t * ) samples + samples_size - n ;
q = samples_end + n ;
while ( nb > 0 ) {
memcpy ( q , samples_end , n ) ;
q + = n ;
nb - = n ;
}
samples_size = wanted_size ;
}
}
2015-03-16 10:57:35 +02:00
av_log ( NULL , AV_LOG_TRACE , " diff=%f adiff=%f sample_diff=%d apts=%0.3f vpts=%0.3f %f \n " ,
2011-04-29 18:27:01 +03:00
diff , avg_diff , samples_size - samples_size1 ,
is - > audio_clock , is - > video_clock , is - > audio_diff_threshold ) ;
2003-06-07 21:34:02 +03:00
}
2003-08-06 16:07:23 +03:00
} else {
/* too big difference : may be initial PTS errors, so
reset A - V filter */
is - > audio_diff_avg_count = 0 ;
2012-01-01 15:21:26 +03:00
is - > audio_diff_cum = 0 ;
2003-06-07 21:34:02 +03:00
}
}
return samples_size ;
}
/* decode one audio frame and returns its uncompressed size */
2016-01-02 13:19:29 +02:00
static int audio_decode_frame ( PlayerState * is , double * pts_ptr )
2003-06-07 21:34:02 +03:00
{
2009-04-10 15:07:06 +03:00
AVPacket * pkt_temp = & is - > audio_pkt_temp ;
2003-06-07 21:34:02 +03:00
AVPacket * pkt = & is - > audio_pkt ;
2016-02-09 13:36:13 +02:00
AVCodecContext * dec = is - > audio_dec ;
2011-10-12 20:27:41 +03:00
int n , len1 , data_size , got_frame ;
2003-06-07 21:34:02 +03:00
double pts ;
2011-09-07 22:29:53 +03:00
int new_packet = 0 ;
int flush_complete = 0 ;
2003-06-07 21:34:02 +03:00
2012-01-01 15:21:26 +03:00
for ( ; ; ) {
2003-11-10 20:59:45 +02:00
/* NOTE: the audio packet can contain several frames */
2011-09-07 22:29:53 +03:00
while ( pkt_temp - > size > 0 | | ( ! pkt_temp - > data & & new_packet ) ) {
2012-04-25 23:46:22 +03:00
int resample_changed , audio_resample ;
2011-10-12 20:27:41 +03:00
if ( ! is - > frame ) {
2013-11-09 12:05:22 +03:00
if ( ! ( is - > frame = av_frame_alloc ( ) ) )
2011-10-12 20:27:41 +03:00
return AVERROR ( ENOMEM ) ;
2013-12-09 13:49:23 +03:00
}
2011-10-12 20:27:41 +03:00
2011-09-07 22:29:53 +03:00
if ( flush_complete )
break ;
new_packet = 0 ;
2011-10-12 20:27:41 +03:00
len1 = avcodec_decode_audio4 ( dec , is - > frame , & got_frame , pkt_temp ) ;
2003-11-10 20:59:45 +02:00
if ( len1 < 0 ) {
/* if error, we skip the frame */
2009-04-10 15:07:06 +03:00
pkt_temp - > size = 0 ;
2003-06-07 21:34:02 +03:00
break ;
2003-11-10 20:59:45 +02:00
}
2005-12-17 20:14:38 +02:00
2009-04-10 15:07:06 +03:00
pkt_temp - > data + = len1 ;
pkt_temp - > size - = len1 ;
2011-09-07 22:29:53 +03:00
2011-10-12 20:27:41 +03:00
if ( ! got_frame ) {
2011-09-07 22:29:53 +03:00
/* stop sending empty packets if the decoder is finished */
2015-07-07 02:41:27 +02:00
if ( ! pkt_temp - > data & & ( dec - > codec - > capabilities & AV_CODEC_CAP_DELAY ) )
2011-09-07 22:29:53 +03:00
flush_complete = 1 ;
2003-11-10 20:59:45 +02:00
continue ;
2011-09-07 22:29:53 +03:00
}
2011-10-12 20:27:41 +03:00
data_size = av_samples_get_buffer_size ( NULL , dec - > channels ,
is - > frame - > nb_samples ,
2012-10-08 06:55:32 +03:00
is - > frame - > format , 1 ) ;
2008-08-02 08:01:30 +03:00
2012-10-01 01:18:00 +03:00
audio_resample = is - > frame - > format ! = is - > sdl_sample_fmt | |
is - > frame - > channel_layout ! = is - > sdl_channel_layout | |
is - > frame - > sample_rate ! = is - > sdl_sample_rate ;
2012-04-25 23:46:22 +03:00
2012-10-01 01:18:00 +03:00
resample_changed = is - > frame - > format ! = is - > resample_sample_fmt | |
is - > frame - > channel_layout ! = is - > resample_channel_layout | |
is - > frame - > sample_rate ! = is - > resample_sample_rate ;
2012-04-25 23:46:22 +03:00
if ( ( ! is - > avr & & audio_resample ) | | resample_changed ) {
2012-05-04 01:57:02 +03:00
int ret ;
2012-04-25 23:46:22 +03:00
if ( is - > avr )
avresample_close ( is - > avr ) ;
else if ( audio_resample ) {
is - > avr = avresample_alloc_context ( ) ;
if ( ! is - > avr ) {
fprintf ( stderr , " error allocating AVAudioResampleContext \n " ) ;
2008-08-02 08:01:30 +03:00
break ;
2012-04-25 23:46:22 +03:00
}
2012-05-04 01:57:02 +03:00
}
if ( audio_resample ) {
2012-10-08 06:55:32 +03:00
av_opt_set_int ( is - > avr , " in_channel_layout " , is - > frame - > channel_layout , 0 ) ;
av_opt_set_int ( is - > avr , " in_sample_fmt " , is - > frame - > format , 0 ) ;
av_opt_set_int ( is - > avr , " in_sample_rate " , is - > frame - > sample_rate , 0 ) ;
2012-10-01 01:18:00 +03:00
av_opt_set_int ( is - > avr , " out_channel_layout " , is - > sdl_channel_layout , 0 ) ;
av_opt_set_int ( is - > avr , " out_sample_fmt " , is - > sdl_sample_fmt , 0 ) ;
av_opt_set_int ( is - > avr , " out_sample_rate " , is - > sdl_sample_rate , 0 ) ;
2012-04-25 23:46:22 +03:00
if ( ( ret = avresample_open ( is - > avr ) ) < 0 ) {
fprintf ( stderr , " error initializing libavresample \n " ) ;
break ;
}
2008-08-02 08:01:30 +03:00
}
2012-10-08 06:55:32 +03:00
is - > resample_sample_fmt = is - > frame - > format ;
is - > resample_channel_layout = is - > frame - > channel_layout ;
2012-10-01 01:18:00 +03:00
is - > resample_sample_rate = is - > frame - > sample_rate ;
2008-08-02 08:01:30 +03:00
}
2012-04-25 23:46:22 +03:00
if ( audio_resample ) {
void * tmp_out ;
int out_samples , out_size , out_linesize ;
int osize = av_get_bytes_per_sample ( is - > sdl_sample_fmt ) ;
int nb_samples = is - > frame - > nb_samples ;
out_size = av_samples_get_buffer_size ( & out_linesize ,
is - > sdl_channels ,
nb_samples ,
is - > sdl_sample_fmt , 0 ) ;
tmp_out = av_realloc ( is - > audio_buf1 , out_size ) ;
if ( ! tmp_out )
2011-10-12 20:27:41 +03:00
return AVERROR ( ENOMEM ) ;
2012-04-25 23:46:22 +03:00
is - > audio_buf1 = tmp_out ;
out_samples = avresample_convert ( is - > avr ,
2012-10-05 07:56:00 +03:00
& is - > audio_buf1 ,
2012-04-25 23:46:22 +03:00
out_linesize , nb_samples ,
2012-10-05 07:56:00 +03:00
is - > frame - > data ,
2012-04-25 23:46:22 +03:00
is - > frame - > linesize [ 0 ] ,
is - > frame - > nb_samples ) ;
if ( out_samples < 0 ) {
fprintf ( stderr , " avresample_convert() failed \n " ) ;
2008-08-02 08:01:30 +03:00
break ;
}
2011-10-12 20:27:41 +03:00
is - > audio_buf = is - > audio_buf1 ;
2012-04-25 23:46:22 +03:00
data_size = out_samples * osize * is - > sdl_channels ;
2012-01-01 15:21:26 +03:00
} else {
2011-10-12 20:27:41 +03:00
is - > audio_buf = is - > frame - > data [ 0 ] ;
2008-08-02 08:01:30 +03:00
}
2003-11-10 20:59:45 +02:00
/* if no pts, then compute it */
pts = is - > audio_clock ;
* pts_ptr = pts ;
2012-04-25 23:46:22 +03:00
n = is - > sdl_channels * av_get_bytes_per_sample ( is - > sdl_sample_fmt ) ;
2005-12-17 20:14:38 +02:00
is - > audio_clock + = ( double ) data_size /
2012-10-01 01:18:00 +03:00
( double ) ( n * is - > sdl_sample_rate ) ;
2011-06-06 01:53:31 +03:00
# ifdef DEBUG
2003-11-10 20:59:45 +02:00
{
static double last_clock ;
printf ( " audio: delay=%0.3f clock=%0.3f pts=%0.3f \n " ,
is - > audio_clock - last_clock ,
is - > audio_clock , pts ) ;
last_clock = is - > audio_clock ;
2003-06-07 21:34:02 +03:00
}
2003-11-10 20:59:45 +02:00
# endif
return data_size ;
2003-06-07 21:34:02 +03:00
}
2003-11-10 20:59:45 +02:00
/* free the current packet */
if ( pkt - > data )
2015-10-23 11:11:31 +02:00
av_packet_unref ( pkt ) ;
2011-12-14 02:38:23 +03:00
memset ( pkt_temp , 0 , sizeof ( * pkt_temp ) ) ;
2005-12-17 20:14:38 +02:00
2003-11-10 20:59:45 +02:00
if ( is - > paused | | is - > audioq . abort_request ) {
return - 1 ;
}
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
/* read next packet */
2011-09-07 22:29:53 +03:00
if ( ( new_packet = packet_queue_get ( & is - > audioq , pkt , 1 ) ) < 0 )
2003-06-07 21:34:02 +03:00
return - 1 ;
2011-09-07 22:29:53 +03:00
2012-02-05 01:32:26 +03:00
if ( pkt - > data = = flush_pkt . data ) {
2008-08-02 04:26:38 +03:00
avcodec_flush_buffers ( dec ) ;
2012-02-05 01:32:26 +03:00
flush_complete = 0 ;
}
2006-11-16 13:58:27 +02:00
2011-10-12 20:27:41 +03:00
* pkt_temp = * pkt ;
2005-12-17 20:14:38 +02:00
2003-11-10 20:59:45 +02:00
/* if update the audio clock with the pts */
if ( pkt - > pts ! = AV_NOPTS_VALUE ) {
2005-05-01 00:43:59 +03:00
is - > audio_clock = av_q2d ( is - > audio_st - > time_base ) * pkt - > pts ;
2003-11-10 20:59:45 +02:00
}
2003-06-07 21:34:02 +03:00
}
}
/* prepare a new audio buffer */
2008-05-01 18:10:44 +03:00
static void sdl_audio_callback ( void * opaque , Uint8 * stream , int len )
2003-06-07 21:34:02 +03:00
{
2016-01-02 13:19:29 +02:00
PlayerState * is = opaque ;
2003-06-07 21:34:02 +03:00
int audio_size , len1 ;
double pts ;
2014-10-22 12:23:08 +03:00
audio_callback_time = av_gettime_relative ( ) ;
2005-12-17 20:14:38 +02:00
2003-06-07 21:34:02 +03:00
while ( len > 0 ) {
if ( is - > audio_buf_index > = is - > audio_buf_size ) {
2008-08-02 08:01:30 +03:00
audio_size = audio_decode_frame ( is , & pts ) ;
2003-06-07 21:34:02 +03:00
if ( audio_size < 0 ) {
/* if error, just output silence */
2011-10-11 22:49:39 +03:00
is - > audio_buf = is - > silence_buf ;
is - > audio_buf_size = sizeof ( is - > silence_buf ) ;
2003-06-07 21:34:02 +03:00
} else {
if ( is - > show_audio )
update_sample_display ( is , ( int16_t * ) is - > audio_buf , audio_size ) ;
2005-12-17 20:14:38 +02:00
audio_size = synchronize_audio ( is , ( int16_t * ) is - > audio_buf , audio_size ,
2003-06-07 21:34:02 +03:00
pts ) ;
is - > audio_buf_size = audio_size ;
}
is - > audio_buf_index = 0 ;
}
len1 = is - > audio_buf_size - is - > audio_buf_index ;
if ( len1 > len )
len1 = len ;
memcpy ( stream , ( uint8_t * ) is - > audio_buf + is - > audio_buf_index , len1 ) ;
len - = len1 ;
stream + = len1 ;
is - > audio_buf_index + = len1 ;
}
}
2016-01-02 13:19:32 +02:00
static AVCodec * find_codec_or_die ( const char * name , enum AVMediaType type )
{
const AVCodecDescriptor * desc ;
AVCodec * codec = avcodec_find_decoder_by_name ( name ) ;
if ( ! codec & & ( desc = avcodec_descriptor_get_by_name ( name ) ) ) {
codec = avcodec_find_decoder ( desc - > id ) ;
if ( codec )
av_log ( NULL , AV_LOG_VERBOSE , " Matched decoder '%s' for codec '%s'. \n " ,
codec - > name , desc - > name ) ;
}
if ( ! codec ) {
av_log ( NULL , AV_LOG_FATAL , " Unknown decoder '%s' \n " , name ) ;
exit_program ( 1 ) ;
}
if ( codec - > type ! = type ) {
av_log ( NULL , AV_LOG_FATAL , " Invalid decoder type '%s' \n " , name ) ;
exit_program ( 1 ) ;
}
return codec ;
}
static AVCodec * choose_decoder ( PlayerState * is , AVFormatContext * ic , AVStream * st )
{
char * codec_name = NULL ;
int i , ret ;
for ( i = 0 ; i < is - > nb_codec_names ; i + + ) {
char * spec = is - > codec_names [ i ] . specifier ;
if ( ( ret = check_stream_specifier ( ic , st , spec ) ) > 0 )
codec_name = is - > codec_names [ i ] . u . str ;
else if ( ret < 0 )
exit_program ( 1 ) ;
}
if ( codec_name ) {
2016-02-09 15:23:30 +02:00
AVCodec * codec = find_codec_or_die ( codec_name , st - > codecpar - > codec_type ) ;
st - > codecpar - > codec_id = codec - > id ;
2016-01-02 13:19:32 +02:00
return codec ;
} else
2016-02-09 15:23:30 +02:00
return avcodec_find_decoder ( st - > codecpar - > codec_id ) ;
2016-01-02 13:19:32 +02:00
}
2003-06-07 21:34:02 +03:00
/* open a given stream. Return 0 if OK */
2016-01-02 13:19:29 +02:00
static int stream_component_open ( PlayerState * is , int stream_index )
2003-06-07 21:34:02 +03:00
{
AVFormatContext * ic = is - > ic ;
2010-02-17 00:38:43 +02:00
AVCodecContext * avctx ;
2003-06-07 21:34:02 +03:00
AVCodec * codec ;
SDL_AudioSpec wanted_spec , spec ;
2011-05-25 17:59:51 +03:00
AVDictionary * opts ;
AVDictionaryEntry * t = NULL ;
2014-10-14 18:46:39 +03:00
int ret = 0 ;
2003-06-07 21:34:02 +03:00
if ( stream_index < 0 | | stream_index > = ic - > nb_streams )
return - 1 ;
2016-02-09 13:36:13 +02:00
avctx = avcodec_alloc_context3 ( NULL ) ;
if ( ! avctx )
return AVERROR ( ENOMEM ) ;
2016-02-09 15:23:30 +02:00
ret = avcodec_parameters_to_context ( avctx , ic - > streams [ stream_index ] - > codecpar ) ;
2016-02-09 13:36:13 +02:00
if ( ret < 0 ) {
avcodec_free_context ( & avctx ) ;
return ret ;
}
2005-12-17 20:14:38 +02:00
2012-06-30 01:28:02 +03:00
opts = filter_codec_opts ( codec_opts , avctx - > codec_id , ic , ic - > streams [ stream_index ] , NULL ) ;
2011-05-25 17:59:51 +03:00
2016-01-02 13:19:32 +02:00
codec = choose_decoder ( is , ic , ic - > streams [ stream_index ] ) ;
2012-01-01 15:21:26 +03:00
avctx - > workaround_bugs = workaround_bugs ;
avctx - > idct_algo = idct ;
avctx - > skip_frame = skip_frame ;
avctx - > skip_idct = skip_idct ;
avctx - > skip_loop_filter = skip_loop_filter ;
avctx - > error_concealment = error_concealment ;
2015-06-29 21:59:37 +02:00
if ( fast )
avctx - > flags2 | = AV_CODEC_FLAG2_FAST ;
2010-02-17 00:38:43 +02:00
2012-01-18 12:53:41 +03:00
if ( ! av_dict_get ( opts , " threads " , NULL , 0 ) )
av_dict_set ( & opts , " threads " , " auto " , 0 ) ;
2013-02-17 18:06:16 +03:00
if ( avctx - > codec_type = = AVMEDIA_TYPE_VIDEO )
av_dict_set ( & opts , " refcounted_frames " , " 1 " , 0 ) ;
2003-06-07 21:34:02 +03:00
if ( ! codec | |
2014-10-14 18:46:39 +03:00
( ret = avcodec_open2 ( avctx , codec , & opts ) ) < 0 ) {
goto fail ;
}
2011-05-25 17:59:51 +03:00
if ( ( t = av_dict_get ( opts , " " , NULL , AV_DICT_IGNORE_SUFFIX ) ) ) {
av_log ( NULL , AV_LOG_ERROR , " Option %s not found. \n " , t - > key ) ;
2014-10-14 18:46:39 +03:00
ret = AVERROR_OPTION_NOT_FOUND ;
goto fail ;
2011-05-25 17:59:51 +03:00
}
2008-01-06 04:44:05 +02:00
/* prepare audio output */
2010-03-31 02:30:55 +03:00
if ( avctx - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
2012-10-01 01:18:00 +03:00
is - > sdl_sample_rate = avctx - > sample_rate ;
2012-04-25 23:46:22 +03:00
if ( ! avctx - > channel_layout )
avctx - > channel_layout = av_get_default_channel_layout ( avctx - > channels ) ;
if ( ! avctx - > channel_layout ) {
fprintf ( stderr , " unable to guess channel layout \n " ) ;
2014-10-14 18:46:39 +03:00
ret = AVERROR_INVALIDDATA ;
goto fail ;
2012-04-25 23:46:22 +03:00
}
if ( avctx - > channels = = 1 )
is - > sdl_channel_layout = AV_CH_LAYOUT_MONO ;
else
is - > sdl_channel_layout = AV_CH_LAYOUT_STEREO ;
is - > sdl_channels = av_get_channel_layout_nb_channels ( is - > sdl_channel_layout ) ;
2012-10-01 01:18:00 +03:00
wanted_spec . format = AUDIO_S16SYS ;
wanted_spec . freq = is - > sdl_sample_rate ;
2012-04-25 23:46:22 +03:00
wanted_spec . channels = is - > sdl_channels ;
2008-01-06 04:44:05 +02:00
wanted_spec . silence = 0 ;
wanted_spec . samples = SDL_AUDIO_BUFFER_SIZE ;
wanted_spec . callback = sdl_audio_callback ;
wanted_spec . userdata = is ;
if ( SDL_OpenAudio ( & wanted_spec , & spec ) < 0 ) {
fprintf ( stderr , " SDL_OpenAudio: %s \n " , SDL_GetError ( ) ) ;
2014-10-14 18:46:39 +03:00
ret = AVERROR_UNKNOWN ;
goto fail ;
2008-01-06 04:44:05 +02:00
}
is - > audio_hw_buf_size = spec . size ;
2012-04-25 23:46:22 +03:00
is - > sdl_sample_fmt = AV_SAMPLE_FMT_S16 ;
is - > resample_sample_fmt = is - > sdl_sample_fmt ;
2012-10-01 01:18:00 +03:00
is - > resample_channel_layout = avctx - > channel_layout ;
is - > resample_sample_rate = avctx - > sample_rate ;
2008-01-06 04:44:05 +02:00
}
2008-08-18 20:09:34 +03:00
ic - > streams [ stream_index ] - > discard = AVDISCARD_DEFAULT ;
2012-01-01 15:21:26 +03:00
switch ( avctx - > codec_type ) {
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_AUDIO :
2003-06-07 21:34:02 +03:00
is - > audio_stream = stream_index ;
is - > audio_st = ic - > streams [ stream_index ] ;
2016-02-09 13:36:13 +02:00
is - > audio_dec = avctx ;
2012-01-01 15:21:26 +03:00
is - > audio_buf_size = 0 ;
2003-06-07 21:34:02 +03:00
is - > audio_buf_index = 0 ;
2003-08-06 16:07:23 +03:00
/* init averaging filter */
2012-01-01 15:21:26 +03:00
is - > audio_diff_avg_coef = exp ( log ( 0.01 ) / AUDIO_DIFF_AVG_NB ) ;
2003-08-06 16:07:23 +03:00
is - > audio_diff_avg_count = 0 ;
/* since we do not have a precise anough audio fifo fullness,
we correct audio sync only if larger than this threshold */
2010-02-17 00:38:43 +02:00
is - > audio_diff_threshold = 2.0 * SDL_AUDIO_BUFFER_SIZE / avctx - > sample_rate ;
2003-08-06 16:07:23 +03:00
2003-06-07 21:34:02 +03:00
memset ( & is - > audio_pkt , 0 , sizeof ( is - > audio_pkt ) ) ;
packet_queue_init ( & is - > audioq ) ;
2005-12-22 03:10:11 +02:00
SDL_PauseAudio ( 0 ) ;
2003-06-07 21:34:02 +03:00
break ;
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_VIDEO :
2003-06-07 21:34:02 +03:00
is - > video_stream = stream_index ;
is - > video_st = ic - > streams [ stream_index ] ;
2016-02-09 13:36:13 +02:00
is - > video_dec = avctx ;
2003-06-07 21:34:02 +03:00
packet_queue_init ( & is - > videoq ) ;
is - > video_tid = SDL_CreateThread ( video_thread , is ) ;
break ;
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_SUBTITLE :
2005-08-14 04:29:34 +03:00
is - > subtitle_stream = stream_index ;
is - > subtitle_st = ic - > streams [ stream_index ] ;
2016-02-09 13:36:13 +02:00
is - > subtitle_dec = avctx ;
2005-08-14 04:29:34 +03:00
packet_queue_init ( & is - > subtitleq ) ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
is - > subtitle_tid = SDL_CreateThread ( subtitle_thread , is ) ;
break ;
2003-06-07 21:34:02 +03:00
default :
break ;
}
2014-10-14 18:46:39 +03:00
fail :
av_dict_free ( & opts ) ;
return ret ;
2003-06-07 21:34:02 +03:00
}
2016-01-02 13:19:29 +02:00
static void stream_component_close ( PlayerState * is , int stream_index )
2003-06-07 21:34:02 +03:00
{
AVFormatContext * ic = is - > ic ;
2016-02-09 15:23:30 +02:00
AVCodecParameters * par ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
if ( stream_index < 0 | | stream_index > = ic - > nb_streams )
return ;
2016-02-09 15:23:30 +02:00
par = ic - > streams [ stream_index ] - > codecpar ;
2003-06-07 21:34:02 +03:00
2016-02-09 15:23:30 +02:00
switch ( par - > codec_type ) {
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_AUDIO :
2003-06-07 21:34:02 +03:00
packet_queue_abort ( & is - > audioq ) ;
SDL_CloseAudio ( ) ;
packet_queue_end ( & is - > audioq ) ;
2015-10-23 11:11:31 +02:00
av_packet_unref ( & is - > audio_pkt ) ;
2012-04-25 23:46:22 +03:00
if ( is - > avr )
avresample_free ( & is - > avr ) ;
2011-10-12 20:27:41 +03:00
av_freep ( & is - > audio_buf1 ) ;
is - > audio_buf = NULL ;
2013-11-29 23:41:52 +03:00
av_frame_free ( & is - > frame ) ;
2011-10-12 21:38:02 +03:00
if ( is - > rdft ) {
av_rdft_end ( is - > rdft ) ;
av_freep ( & is - > rdft_data ) ;
2011-11-08 18:33:18 +03:00
is - > rdft = NULL ;
is - > rdft_bits = 0 ;
2011-10-12 21:38:02 +03:00
}
2003-06-07 21:34:02 +03:00
break ;
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_VIDEO :
2003-06-07 21:34:02 +03:00
packet_queue_abort ( & is - > videoq ) ;
/* note: we also signal this mutex to make sure we deblock the
video thread in all cases */
SDL_LockMutex ( is - > pictq_mutex ) ;
SDL_CondSignal ( is - > pictq_cond ) ;
SDL_UnlockMutex ( is - > pictq_mutex ) ;
SDL_WaitThread ( is - > video_tid , NULL ) ;
packet_queue_end ( & is - > videoq ) ;
break ;
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_SUBTITLE :
2005-08-14 04:29:34 +03:00
packet_queue_abort ( & is - > subtitleq ) ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
/* note: we also signal this mutex to make sure we deblock the
video thread in all cases */
SDL_LockMutex ( is - > subpq_mutex ) ;
is - > subtitle_stream_changed = 1 ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
SDL_CondSignal ( is - > subpq_cond ) ;
SDL_UnlockMutex ( is - > subpq_mutex ) ;
SDL_WaitThread ( is - > subtitle_tid , NULL ) ;
packet_queue_end ( & is - > subtitleq ) ;
break ;
2003-06-07 21:34:02 +03:00
default :
break ;
}
2008-08-18 20:09:34 +03:00
ic - > streams [ stream_index ] - > discard = AVDISCARD_ALL ;
2016-02-09 15:23:30 +02:00
switch ( par - > codec_type ) {
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_AUDIO :
2016-02-09 13:36:13 +02:00
avcodec_free_context ( & is - > audio_dec ) ;
2003-06-07 21:34:02 +03:00
is - > audio_st = NULL ;
is - > audio_stream = - 1 ;
break ;
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_VIDEO :
2016-02-09 13:36:13 +02:00
avcodec_free_context ( & is - > video_dec ) ;
2003-06-07 21:34:02 +03:00
is - > video_st = NULL ;
is - > video_stream = - 1 ;
break ;
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_SUBTITLE :
2016-02-09 13:36:13 +02:00
avcodec_free_context ( & is - > subtitle_dec ) ;
2005-08-14 04:29:34 +03:00
is - > subtitle_st = NULL ;
is - > subtitle_stream = - 1 ;
break ;
2003-06-07 21:34:02 +03:00
default :
break ;
}
}
2003-07-17 13:29:50 +03:00
/* since we have only one decoding thread, we can use a global
variable instead of a thread local variable */
2016-01-02 13:19:29 +02:00
static PlayerState * global_video_state ;
2003-07-17 13:29:50 +03:00
2011-11-07 00:28:49 +03:00
static int decode_interrupt_cb ( void * ctx )
2003-07-17 13:29:50 +03:00
{
2011-12-30 00:23:16 +03:00
return global_video_state & & global_video_state - > abort_request ;
2003-07-17 13:29:50 +03:00
}
2003-06-07 21:34:02 +03:00
2016-01-02 13:19:29 +02:00
static void stream_close ( PlayerState * is )
2016-01-02 13:19:27 +02:00
{
/* disable interrupting */
global_video_state = NULL ;
/* close each stream */
if ( is - > audio_stream > = 0 )
stream_component_close ( is , is - > audio_stream ) ;
if ( is - > video_stream > = 0 )
stream_component_close ( is , is - > video_stream ) ;
if ( is - > subtitle_stream > = 0 )
stream_component_close ( is , is - > subtitle_stream ) ;
if ( is - > ic ) {
avformat_close_input ( & is - > ic ) ;
}
}
2016-01-02 13:19:29 +02:00
static int stream_setup ( PlayerState * is )
2003-06-07 21:34:02 +03:00
{
2011-06-09 11:58:23 +03:00
AVFormatContext * ic = NULL ;
2010-02-23 18:46:40 +02:00
int err , i , ret ;
2010-03-31 02:30:55 +03:00
int st_index [ AVMEDIA_TYPE_NB ] ;
2011-06-09 11:58:23 +03:00
AVDictionaryEntry * t ;
2011-05-25 17:59:51 +03:00
AVDictionary * * opts ;
int orig_nb_streams ;
2010-01-31 00:47:08 +02:00
2010-02-23 18:46:40 +02:00
memset ( st_index , - 1 , sizeof ( st_index ) ) ;
2003-06-07 21:34:02 +03:00
is - > video_stream = - 1 ;
is - > audio_stream = - 1 ;
2005-08-14 04:29:34 +03:00
is - > subtitle_stream = - 1 ;
2003-06-07 21:34:02 +03:00
2003-07-17 13:29:50 +03:00
global_video_state = is ;
2011-11-07 00:28:49 +03:00
ic = avformat_alloc_context ( ) ;
2015-02-04 16:21:01 +02:00
if ( ! ic ) {
av_log ( NULL , AV_LOG_FATAL , " Could not allocate context. \n " ) ;
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
2011-11-07 00:28:49 +03:00
ic - > interrupt_callback . callback = decode_interrupt_cb ;
2011-06-09 11:58:23 +03:00
err = avformat_open_input ( & ic , is - > filename , is - > iformat , & format_opts ) ;
2003-08-06 16:07:23 +03:00
if ( err < 0 ) {
print_error ( is - > filename , err ) ;
ret = - 1 ;
goto fail ;
}
2016-01-02 13:19:32 +02:00
2011-06-09 11:58:23 +03:00
if ( ( t = av_dict_get ( format_opts , " " , NULL , AV_DICT_IGNORE_SUFFIX ) ) ) {
av_log ( NULL , AV_LOG_ERROR , " Option %s not found. \n " , t - > key ) ;
ret = AVERROR_OPTION_NOT_FOUND ;
goto fail ;
}
2003-06-07 21:34:02 +03:00
is - > ic = ic ;
2005-08-15 17:22:43 +03:00
2012-01-01 15:21:26 +03:00
if ( genpts )
2005-08-15 17:22:43 +03:00
ic - > flags | = AVFMT_FLAG_GENPTS ;
2011-07-17 17:19:28 +03:00
opts = setup_find_stream_info_opts ( ic , codec_opts ) ;
2011-05-25 17:59:51 +03:00
orig_nb_streams = ic - > nb_streams ;
2011-04-24 23:48:42 +03:00
2016-01-02 13:19:32 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + )
2016-02-09 15:23:30 +02:00
choose_decoder ( is , ic , ic - > streams [ i ] ) ;
2016-01-02 13:19:32 +02:00
2011-05-25 17:59:51 +03:00
err = avformat_find_stream_info ( ic , opts ) ;
2014-10-14 18:46:38 +03:00
for ( i = 0 ; i < orig_nb_streams ; i + + )
av_dict_free ( & opts [ i ] ) ;
av_freep ( & opts ) ;
2007-08-24 10:20:28 +03:00
if ( err < 0 ) {
fprintf ( stderr , " %s: could not find codec parameters \n " , is - > filename ) ;
ret = - 1 ;
goto fail ;
}
2011-05-25 17:59:51 +03:00
2012-01-01 15:21:26 +03:00
if ( ic - > pb )
ic - > pb - > eof_reached = 0 ; // FIXME hack, avplay maybe should not use url_feof() to test for the end
2003-11-10 20:59:45 +02:00
2012-01-01 15:21:26 +03:00
if ( seek_by_bytes < 0 )
seek_by_bytes = ! ! ( ic - > iformat - > flags & AVFMT_TS_DISCONT ) ;
2010-02-02 20:02:16 +02:00
2003-11-10 20:59:45 +02:00
/* if seeking requested, we execute it */
if ( start_time ! = AV_NOPTS_VALUE ) {
int64_t timestamp ;
timestamp = start_time ;
/* add the stream start time */
if ( ic - > start_time ! = AV_NOPTS_VALUE )
timestamp + = ic - > start_time ;
2009-03-14 18:24:30 +02:00
ret = avformat_seek_file ( ic , - 1 , INT64_MIN , timestamp , INT64_MAX , 0 ) ;
2003-11-10 20:59:45 +02:00
if ( ret < 0 ) {
2005-12-17 20:14:38 +02:00
fprintf ( stderr , " %s: could not seek to position %0.3f \n " ,
2003-11-10 20:59:45 +02:00
is - > filename , ( double ) timestamp / AV_TIME_BASE ) ;
}
}
2010-12-27 11:08:36 +02:00
for ( i = 0 ; i < ic - > nb_streams ; i + + )
2008-08-18 20:09:34 +03:00
ic - > streams [ i ] - > discard = AVDISCARD_ALL ;
2010-12-28 11:52:31 +02:00
if ( ! video_disable )
2010-12-27 11:08:36 +02:00
st_index [ AVMEDIA_TYPE_VIDEO ] =
av_find_best_stream ( ic , AVMEDIA_TYPE_VIDEO ,
wanted_stream [ AVMEDIA_TYPE_VIDEO ] , - 1 , NULL , 0 ) ;
2010-12-28 11:52:31 +02:00
if ( ! audio_disable )
2010-12-27 11:08:36 +02:00
st_index [ AVMEDIA_TYPE_AUDIO ] =
av_find_best_stream ( ic , AVMEDIA_TYPE_AUDIO ,
wanted_stream [ AVMEDIA_TYPE_AUDIO ] ,
st_index [ AVMEDIA_TYPE_VIDEO ] ,
NULL , 0 ) ;
2010-12-28 11:52:31 +02:00
if ( ! video_disable )
2010-12-27 11:08:36 +02:00
st_index [ AVMEDIA_TYPE_SUBTITLE ] =
av_find_best_stream ( ic , AVMEDIA_TYPE_SUBTITLE ,
wanted_stream [ AVMEDIA_TYPE_SUBTITLE ] ,
( st_index [ AVMEDIA_TYPE_AUDIO ] > = 0 ?
st_index [ AVMEDIA_TYPE_AUDIO ] :
st_index [ AVMEDIA_TYPE_VIDEO ] ) ,
NULL , 0 ) ;
2003-06-07 21:34:02 +03:00
if ( show_status ) {
2011-02-16 10:52:35 +02:00
av_dump_format ( ic , 0 , is - > filename , 0 ) ;
2003-06-07 21:34:02 +03:00
}
/* open the streams */
2010-03-31 02:30:55 +03:00
if ( st_index [ AVMEDIA_TYPE_AUDIO ] > = 0 ) {
stream_component_open ( is , st_index [ AVMEDIA_TYPE_AUDIO ] ) ;
2003-06-07 21:34:02 +03:00
}
2012-01-01 15:21:26 +03:00
ret = - 1 ;
2010-03-31 02:30:55 +03:00
if ( st_index [ AVMEDIA_TYPE_VIDEO ] > = 0 ) {
2012-01-01 15:21:26 +03:00
ret = stream_component_open ( is , st_index [ AVMEDIA_TYPE_VIDEO ] ) ;
2010-02-18 02:19:50 +02:00
}
2012-01-01 15:21:26 +03:00
if ( ret < 0 ) {
2003-06-07 21:34:02 +03:00
if ( ! display_disable )
2010-02-05 17:26:42 +02:00
is - > show_audio = 2 ;
2003-06-07 21:34:02 +03:00
}
2010-03-31 02:30:55 +03:00
if ( st_index [ AVMEDIA_TYPE_SUBTITLE ] > = 0 ) {
stream_component_open ( is , st_index [ AVMEDIA_TYPE_SUBTITLE ] ) ;
2009-02-09 03:38:12 +02:00
}
2003-06-07 21:34:02 +03:00
if ( is - > video_stream < 0 & & is - > audio_stream < 0 ) {
2003-08-06 16:07:23 +03:00
fprintf ( stderr , " %s: could not open codecs \n " , is - > filename ) ;
ret = - 1 ;
2003-06-07 21:34:02 +03:00
goto fail ;
}
2016-01-02 13:19:27 +02:00
return 0 ;
fail :
return ret ;
}
/* this thread gets the stream from the disk or the network */
static int decode_thread ( void * arg )
{
2016-01-02 13:19:29 +02:00
PlayerState * is = arg ;
2016-01-02 13:19:27 +02:00
AVPacket pkt1 , * pkt = & pkt1 ;
AVFormatContext * ic = is - > ic ;
int pkt_in_play_range = 0 ;
int ret , eof = 0 ;
2012-01-01 15:21:26 +03:00
for ( ; ; ) {
2003-06-07 21:34:02 +03:00
if ( is - > abort_request )
break ;
2003-07-17 13:29:50 +03:00
if ( is - > paused ! = is - > last_paused ) {
is - > last_paused = is - > paused ;
2003-11-10 20:59:45 +02:00
if ( is - > paused )
2012-01-01 15:21:26 +03:00
is - > read_pause_return = av_read_pause ( ic ) ;
2003-11-10 20:59:45 +02:00
else
av_read_play ( ic ) ;
2003-07-17 13:29:50 +03:00
}
2009-01-19 23:39:07 +02:00
# if CONFIG_RTSP_DEMUXER
if ( is - > paused & & ! strcmp ( ic - > iformat - > name , " rtsp " ) ) {
2003-07-17 13:29:50 +03:00
/* wait 10 ms to avoid trying to get another packet */
/* XXX: horrible */
SDL_Delay ( 10 ) ;
continue ;
}
2003-08-29 02:11:23 +03:00
# endif
2003-11-10 20:59:45 +02:00
if ( is - > seek_req ) {
2012-01-01 15:21:26 +03:00
int64_t seek_target = is - > seek_pos ;
int64_t seek_min = is - > seek_rel > 0 ? seek_target - is - > seek_rel + 2 : INT64_MIN ;
int64_t seek_max = is - > seek_rel < 0 ? seek_target - is - > seek_rel - 2 : INT64_MAX ;
// FIXME the +-2 is due to rounding being not done in the correct direction in generation
2009-03-14 18:24:30 +02:00
// of the seek_pos/seek_rel variables
2007-01-23 16:22:25 +02:00
2009-03-14 18:24:30 +02:00
ret = avformat_seek_file ( is - > ic , - 1 , seek_min , seek_target , seek_max , is - > seek_flags ) ;
2003-11-10 20:59:45 +02:00
if ( ret < 0 ) {
fprintf ( stderr , " %s: error while seeking \n " , is - > ic - > filename ) ;
2012-01-01 15:21:26 +03:00
} else {
2004-01-11 00:36:35 +02:00
if ( is - > audio_stream > = 0 ) {
packet_queue_flush ( & is - > audioq ) ;
2006-11-16 13:58:27 +02:00
packet_queue_put ( & is - > audioq , & flush_pkt ) ;
2004-01-11 00:36:35 +02:00
}
2005-08-14 04:29:34 +03:00
if ( is - > subtitle_stream > = 0 ) {
packet_queue_flush ( & is - > subtitleq ) ;
2006-11-16 13:58:27 +02:00
packet_queue_put ( & is - > subtitleq , & flush_pkt ) ;
2005-08-14 04:29:34 +03:00
}
2004-01-11 00:36:35 +02:00
if ( is - > video_stream > = 0 ) {
packet_queue_flush ( & is - > videoq ) ;
2006-11-16 13:58:27 +02:00
packet_queue_put ( & is - > videoq , & flush_pkt ) ;
2004-01-11 00:36:35 +02:00
}
2003-11-10 20:59:45 +02:00
}
is - > seek_req = 0 ;
2012-01-01 15:21:26 +03:00
eof = 0 ;
2003-11-10 20:59:45 +02:00
}
2003-07-17 13:29:50 +03:00
2003-06-07 21:34:02 +03:00
/* if the queue are full, no need to read more */
avplay: Add an option for not limiting the input buffer size
For reading from normal files on disk, the queue limits for
demuxed data work fine, but for reading data from realtime
streams, they mean we're not reading from the input stream
at all once the queue limit has been reached. For TCP streams,
this means that writing to the socket from the peer side blocks
(potentially leading to the peer dropping data), and for UDP
streams it means that our kernel might drop data.
For some protocols/servers, the server initially sends a
large burst with data to fill client side buffers, but once
filled, we should keep reading to avoid dropping data.
For all realtime streams, it IMO makes sense to just buffer
as much as we get (rather in buffers in avplay.c than in
OS level buffers). With this option set, the input thread
should always be blocking waiting for more input data,
never sleeping waiting for the decoder to consume data.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-07-03 22:57:19 +03:00
if ( ! infinite_buffer & &
( is - > audioq . size + is - > videoq . size + is - > subtitleq . size > MAX_QUEUE_SIZE
2012-01-01 15:21:26 +03:00
| | ( ( is - > audioq . size > MIN_AUDIOQ_SIZE | | is - > audio_stream < 0 )
& & ( is - > videoq . nb_packets > MIN_FRAMES | | is - > video_stream < 0 )
avplay: Add an option for not limiting the input buffer size
For reading from normal files on disk, the queue limits for
demuxed data work fine, but for reading data from realtime
streams, they mean we're not reading from the input stream
at all once the queue limit has been reached. For TCP streams,
this means that writing to the socket from the peer side blocks
(potentially leading to the peer dropping data), and for UDP
streams it means that our kernel might drop data.
For some protocols/servers, the server initially sends a
large burst with data to fill client side buffers, but once
filled, we should keep reading to avoid dropping data.
For all realtime streams, it IMO makes sense to just buffer
as much as we get (rather in buffers in avplay.c than in
OS level buffers). With this option set, the input thread
should always be blocking waiting for more input data,
never sleeping waiting for the decoder to consume data.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-07-03 22:57:19 +03:00
& & ( is - > subtitleq . nb_packets > MIN_FRAMES | | is - > subtitle_stream < 0 ) ) ) ) {
2003-06-07 21:34:02 +03:00
/* wait 10 ms */
SDL_Delay ( 10 ) ;
continue ;
}
2012-01-01 15:21:26 +03:00
if ( eof ) {
if ( is - > video_stream > = 0 ) {
2009-04-20 00:44:25 +03:00
av_init_packet ( pkt ) ;
2012-01-01 15:21:26 +03:00
pkt - > data = NULL ;
pkt - > size = 0 ;
pkt - > stream_index = is - > video_stream ;
2009-04-20 00:44:25 +03:00
packet_queue_put ( & is - > videoq , pkt ) ;
2009-04-20 00:44:03 +03:00
}
2011-09-07 22:29:53 +03:00
if ( is - > audio_stream > = 0 & &
2016-02-09 13:36:13 +02:00
( is - > audio_dec - > codec - > capabilities & AV_CODEC_CAP_DELAY ) ) {
2011-09-07 22:29:53 +03:00
av_init_packet ( pkt ) ;
pkt - > data = NULL ;
pkt - > size = 0 ;
pkt - > stream_index = is - > audio_stream ;
packet_queue_put ( & is - > audioq , pkt ) ;
}
2009-04-19 23:25:20 +03:00
SDL_Delay ( 10 ) ;
2012-01-01 15:21:26 +03:00
if ( is - > audioq . size + is - > videoq . size + is - > subtitleq . size = = 0 ) {
if ( loop ! = 1 & & ( ! loop | | - - loop ) ) {
2016-01-02 13:19:30 +02:00
stream_seek ( player , start_time ! = AV_NOPTS_VALUE ? start_time : 0 , 0 , 0 ) ;
2014-09-03 01:45:21 +03:00
} else if ( ! noautoexit ) {
2012-01-01 15:21:26 +03:00
ret = AVERROR_EOF ;
2010-03-23 19:39:51 +02:00
goto fail ;
}
2010-02-04 03:54:24 +02:00
}
2009-01-07 22:45:39 +02:00
continue ;
}
2003-11-10 20:59:45 +02:00
ret = av_read_frame ( ic , pkt ) ;
2003-06-07 21:34:02 +03:00
if ( ret < 0 ) {
2011-03-21 15:52:54 +02:00
if ( ret = = AVERROR_EOF | | ( ic - > pb & & ic - > pb - > eof_reached ) )
2012-01-01 15:21:26 +03:00
eof = 1 ;
2011-03-21 15:52:54 +02:00
if ( ic - > pb & & ic - > pb - > error )
2005-12-22 03:10:11 +02:00
break ;
2009-04-19 23:24:44 +03:00
SDL_Delay ( 100 ) ; /* wait for user event */
continue ;
2003-06-07 21:34:02 +03:00
}
2010-04-01 23:56:23 +03:00
/* check if packet is in play range specified by user, then queue, otherwise discard */
pkt_in_play_range = duration = = AV_NOPTS_VALUE | |
( pkt - > pts - ic - > streams [ pkt - > stream_index ] - > start_time ) *
av_q2d ( ic - > streams [ pkt - > stream_index ] - > time_base ) -
2012-01-01 15:21:26 +03:00
( double ) ( start_time ! = AV_NOPTS_VALUE ? start_time : 0 ) / 1000000
< = ( ( double ) duration / 1000000 ) ;
2010-04-01 23:56:23 +03:00
if ( pkt - > stream_index = = is - > audio_stream & & pkt_in_play_range ) {
2003-06-07 21:34:02 +03:00
packet_queue_put ( & is - > audioq , pkt ) ;
2010-04-01 23:56:23 +03:00
} else if ( pkt - > stream_index = = is - > video_stream & & pkt_in_play_range ) {
2003-06-07 21:34:02 +03:00
packet_queue_put ( & is - > videoq , pkt ) ;
2010-04-01 23:56:23 +03:00
} else if ( pkt - > stream_index = = is - > subtitle_stream & & pkt_in_play_range ) {
2005-08-14 04:29:34 +03:00
packet_queue_put ( & is - > subtitleq , pkt ) ;
2003-06-07 21:34:02 +03:00
} else {
2015-10-23 11:11:31 +02:00
av_packet_unref ( pkt ) ;
2003-06-07 21:34:02 +03:00
}
}
/* wait until the end */
while ( ! is - > abort_request ) {
SDL_Delay ( 100 ) ;
}
2003-08-06 16:07:23 +03:00
ret = 0 ;
2003-07-17 13:29:50 +03:00
2016-01-02 13:19:27 +02:00
fail :
stream_close ( is ) ;
2003-07-17 13:29:50 +03:00
2003-08-06 16:07:23 +03:00
if ( ret ! = 0 ) {
SDL_Event event ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
event . type = FF_QUIT_EVENT ;
event . user . data1 = is ;
SDL_PushEvent ( & event ) ;
}
2003-06-07 21:34:02 +03:00
return 0 ;
}
2016-01-02 13:19:31 +02:00
static int stream_open ( PlayerState * is ,
const char * filename , AVInputFormat * iformat )
2003-06-07 21:34:02 +03:00
{
2016-01-02 13:19:31 +02:00
int ret ;
2003-06-07 21:34:02 +03:00
2007-06-24 14:27:12 +03:00
av_strlcpy ( is - > filename , filename , sizeof ( is - > filename ) ) ;
2003-08-06 16:07:23 +03:00
is - > iformat = iformat ;
2012-01-01 15:21:26 +03:00
is - > ytop = 0 ;
is - > xleft = 0 ;
2003-06-07 21:34:02 +03:00
2016-01-02 13:19:31 +02:00
if ( ( ret = stream_setup ( is ) ) < 0 ) {
return ret ;
2016-01-02 13:19:27 +02:00
}
2003-06-07 21:34:02 +03:00
/* start video display */
is - > pictq_mutex = SDL_CreateMutex ( ) ;
2012-01-01 15:21:26 +03:00
is - > pictq_cond = SDL_CreateCond ( ) ;
2005-12-17 20:14:38 +02:00
2005-08-14 04:29:34 +03:00
is - > subpq_mutex = SDL_CreateMutex ( ) ;
2012-01-01 15:21:26 +03:00
is - > subpq_cond = SDL_CreateCond ( ) ;
2005-12-17 20:14:38 +02:00
2003-08-06 16:07:23 +03:00
is - > av_sync_type = av_sync_type ;
2016-01-02 13:19:28 +02:00
is - > refresh_tid = SDL_CreateThread ( refresh_thread , is ) ;
2016-01-02 13:19:31 +02:00
if ( ! is - > refresh_tid )
return - 1 ;
2012-01-01 15:21:26 +03:00
is - > parse_tid = SDL_CreateThread ( decode_thread , is ) ;
2016-01-02 13:19:31 +02:00
if ( ! is - > parse_tid )
return - 1 ;
return 0 ;
2003-06-07 21:34:02 +03:00
}
2016-01-02 13:19:29 +02:00
static void stream_cycle_channel ( PlayerState * is , int codec_type )
2003-08-06 16:07:23 +03:00
{
AVFormatContext * ic = is - > ic ;
int start_index , stream_index ;
AVStream * st ;
2010-03-31 02:30:55 +03:00
if ( codec_type = = AVMEDIA_TYPE_VIDEO )
2003-08-06 16:07:23 +03:00
start_index = is - > video_stream ;
2010-03-31 02:30:55 +03:00
else if ( codec_type = = AVMEDIA_TYPE_AUDIO )
2003-08-06 16:07:23 +03:00
start_index = is - > audio_stream ;
2005-08-14 04:29:34 +03:00
else
start_index = is - > subtitle_stream ;
2010-03-31 02:30:55 +03:00
if ( start_index < ( codec_type = = AVMEDIA_TYPE_SUBTITLE ? - 1 : 0 ) )
2003-08-06 16:07:23 +03:00
return ;
stream_index = start_index ;
2012-01-01 15:21:26 +03:00
for ( ; ; ) {
2003-08-06 16:07:23 +03:00
if ( + + stream_index > = is - > ic - > nb_streams )
2005-08-14 04:29:34 +03:00
{
2010-03-31 02:30:55 +03:00
if ( codec_type = = AVMEDIA_TYPE_SUBTITLE )
2005-08-14 04:29:34 +03:00
{
stream_index = - 1 ;
goto the_end ;
} else
stream_index = 0 ;
}
2003-08-06 16:07:23 +03:00
if ( stream_index = = start_index )
return ;
st = ic - > streams [ stream_index ] ;
2016-02-09 15:23:30 +02:00
if ( st - > codecpar - > codec_type = = codec_type ) {
2003-08-06 16:07:23 +03:00
/* check that parameters are OK */
2012-01-01 15:21:26 +03:00
switch ( codec_type ) {
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_AUDIO :
2016-02-09 15:23:30 +02:00
if ( st - > codecpar - > sample_rate ! = 0 & &
st - > codecpar - > channels ! = 0 )
2003-08-06 16:07:23 +03:00
goto the_end ;
break ;
2010-03-31 02:30:55 +03:00
case AVMEDIA_TYPE_VIDEO :
case AVMEDIA_TYPE_SUBTITLE :
2003-08-06 16:07:23 +03:00
goto the_end ;
default :
break ;
}
}
}
the_end :
stream_component_close ( is , start_index ) ;
stream_component_open ( is , stream_index ) ;
}
2006-06-18 14:33:14 +03:00
static void toggle_full_screen ( void )
2003-06-07 21:34:02 +03:00
{
2011-10-21 15:56:57 +03:00
# if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
2011-12-12 23:21:24 +03:00
/* OS X needs to empty the picture_queue */
2012-06-14 11:19:06 +03:00
int i ;
for ( i = 0 ; i < VIDEO_PICTURE_QUEUE_SIZE ; i + + )
2016-01-02 13:19:30 +02:00
player - > pictq [ i ] . reallocate = 1 ;
2011-10-21 15:56:57 +03:00
# endif
2012-06-14 11:19:06 +03:00
is_full_screen = ! is_full_screen ;
2016-01-02 13:19:30 +02:00
video_open ( player ) ;
2003-06-07 21:34:02 +03:00
}
2006-06-18 14:33:14 +03:00
static void toggle_pause ( void )
2003-06-07 21:34:02 +03:00
{
2016-01-02 13:19:30 +02:00
if ( player )
stream_pause ( player ) ;
2003-12-28 03:19:41 +02:00
step = 0 ;
}
2006-06-18 14:33:14 +03:00
static void step_to_next_frame ( void )
2003-12-28 03:19:41 +02:00
{
2016-01-02 13:19:30 +02:00
if ( player ) {
2007-08-27 11:06:48 +03:00
/* if the stream is paused unpause it, then step */
2016-01-02 13:19:30 +02:00
if ( player - > paused )
stream_pause ( player ) ;
2003-12-28 03:19:41 +02:00
}
step = 1 ;
2003-06-07 21:34:02 +03:00
}
2006-06-18 14:33:14 +03:00
static void toggle_audio_display ( void )
2003-06-07 21:34:02 +03:00
{
2016-01-02 13:19:30 +02:00
if ( player ) {
2010-02-04 01:34:06 +02:00
int bgcolor = SDL_MapRGB ( screen - > format , 0x00 , 0x00 , 0x00 ) ;
2016-01-02 13:19:30 +02:00
player - > show_audio = ( player - > show_audio + 1 ) % 3 ;
2010-02-04 01:34:06 +02:00
fill_rectangle ( screen ,
2016-01-02 13:19:30 +02:00
player - > xleft , player - > ytop , player - > width , player - > height ,
2012-01-01 15:21:26 +03:00
bgcolor ) ;
2016-01-02 13:19:30 +02:00
SDL_UpdateRect ( screen , player - > xleft , player - > ytop , player - > width , player - > height ) ;
2003-06-07 21:34:02 +03:00
}
}
2016-01-02 13:19:29 +02:00
static void seek_chapter ( PlayerState * is , int incr )
2013-09-04 21:30:28 +03:00
{
int64_t pos = get_master_clock ( is ) * AV_TIME_BASE ;
int i ;
if ( ! is - > ic - > nb_chapters )
return ;
/* find the current chapter */
for ( i = 0 ; i < is - > ic - > nb_chapters ; i + + ) {
AVChapter * ch = is - > ic - > chapters [ i ] ;
if ( av_compare_ts ( pos , AV_TIME_BASE_Q , ch - > start , ch - > time_base ) < 0 ) {
i - - ;
break ;
}
}
i + = incr ;
i = FFMAX ( i , 0 ) ;
if ( i > = is - > ic - > nb_chapters )
return ;
av_log ( NULL , AV_LOG_VERBOSE , " Seeking to chapter %d. \n " , i ) ;
stream_seek ( is , av_rescale_q ( is - > ic - > chapters [ i ] - > start , is - > ic - > chapters [ i ] - > time_base ,
AV_TIME_BASE_Q ) , 0 , 0 ) ;
}
2003-06-07 21:34:02 +03:00
/* handle an event sent by the GUI */
2006-06-18 14:33:14 +03:00
static void event_loop ( void )
2003-06-07 21:34:02 +03:00
{
SDL_Event event ;
2003-11-28 21:19:01 +02:00
double incr , pos , frac ;
2003-06-07 21:34:02 +03:00
2012-01-01 15:21:26 +03:00
for ( ; ; ) {
2010-02-05 02:37:39 +02:00
double x ;
2003-06-07 21:34:02 +03:00
SDL_WaitEvent ( & event ) ;
2012-01-01 15:21:26 +03:00
switch ( event . type ) {
2003-06-07 21:34:02 +03:00
case SDL_KEYDOWN :
2010-07-04 15:43:12 +03:00
if ( exit_on_keydown ) {
do_exit ( ) ;
break ;
}
2012-01-01 15:21:26 +03:00
switch ( event . key . keysym . sym ) {
2003-06-07 21:34:02 +03:00
case SDLK_ESCAPE :
case SDLK_q :
do_exit ( ) ;
break ;
case SDLK_f :
toggle_full_screen ( ) ;
break ;
case SDLK_p :
case SDLK_SPACE :
toggle_pause ( ) ;
break ;
2012-01-01 15:21:26 +03:00
case SDLK_s : // S: Step to next frame
2003-12-28 03:19:41 +02:00
step_to_next_frame ( ) ;
break ;
2003-06-07 21:34:02 +03:00
case SDLK_a :
2016-01-02 13:19:30 +02:00
if ( player )
stream_cycle_channel ( player , AVMEDIA_TYPE_AUDIO ) ;
2003-08-06 16:07:23 +03:00
break ;
case SDLK_v :
2016-01-02 13:19:30 +02:00
if ( player )
stream_cycle_channel ( player , AVMEDIA_TYPE_VIDEO ) ;
2003-08-06 16:07:23 +03:00
break ;
2005-08-14 04:29:34 +03:00
case SDLK_t :
2016-01-02 13:19:30 +02:00
if ( player )
stream_cycle_channel ( player , AVMEDIA_TYPE_SUBTITLE ) ;
2005-08-14 04:29:34 +03:00
break ;
2003-08-06 16:07:23 +03:00
case SDLK_w :
2003-06-07 21:34:02 +03:00
toggle_audio_display ( ) ;
break ;
2013-09-04 21:30:28 +03:00
case SDLK_PAGEUP :
2016-01-02 13:19:30 +02:00
seek_chapter ( player , 1 ) ;
2013-09-04 21:30:28 +03:00
break ;
case SDLK_PAGEDOWN :
2016-01-02 13:19:30 +02:00
seek_chapter ( player , - 1 ) ;
2013-09-04 21:30:28 +03:00
break ;
2003-11-10 20:59:45 +02:00
case SDLK_LEFT :
incr = - 10.0 ;
goto do_seek ;
case SDLK_RIGHT :
incr = 10.0 ;
goto do_seek ;
case SDLK_UP :
incr = 60.0 ;
goto do_seek ;
case SDLK_DOWN :
incr = - 60.0 ;
do_seek :
2016-01-02 13:19:30 +02:00
if ( player ) {
2006-11-08 00:35:41 +02:00
if ( seek_by_bytes ) {
2016-01-02 13:19:30 +02:00
if ( player - > video_stream > = 0 & & player - > video_current_pos > = 0 ) {
pos = player - > video_current_pos ;
} else if ( player - > audio_stream > = 0 & & player - > audio_pkt . pos > = 0 ) {
pos = player - > audio_pkt . pos ;
2012-01-01 15:21:26 +03:00
} else
2016-01-02 13:19:30 +02:00
pos = avio_tell ( player - > ic - > pb ) ;
if ( player - > ic - > bit_rate )
incr * = player - > ic - > bit_rate / 8.0 ;
2006-11-08 00:35:41 +02:00
else
incr * = 180000.0 ;
pos + = incr ;
2016-01-02 13:19:30 +02:00
stream_seek ( player , pos , incr , 1 ) ;
2006-11-08 00:35:41 +02:00
} else {
2016-01-02 13:19:30 +02:00
pos = get_master_clock ( player ) ;
2006-11-08 00:35:41 +02:00
pos + = incr ;
2016-01-02 13:19:30 +02:00
stream_seek ( player , ( int64_t ) ( pos * AV_TIME_BASE ) , ( int64_t ) ( incr * AV_TIME_BASE ) , 0 ) ;
2006-11-08 00:35:41 +02:00
}
2003-11-10 20:59:45 +02:00
}
break ;
2003-06-07 21:34:02 +03:00
default :
break ;
}
break ;
2003-11-28 21:19:01 +02:00
case SDL_MOUSEBUTTONDOWN :
2010-07-04 15:43:12 +03:00
if ( exit_on_mousedown ) {
do_exit ( ) ;
break ;
}
2010-02-05 02:37:39 +02:00
case SDL_MOUSEMOTION :
2012-01-01 15:21:26 +03:00
if ( event . type = = SDL_MOUSEBUTTONDOWN ) {
x = event . button . x ;
} else {
if ( event . motion . state ! = SDL_PRESSED )
2010-02-05 02:37:39 +02:00
break ;
2012-01-01 15:21:26 +03:00
x = event . motion . x ;
2010-02-05 02:37:39 +02:00
}
2016-01-02 13:19:30 +02:00
if ( player ) {
if ( seek_by_bytes | | player - > ic - > duration < = 0 ) {
uint64_t size = avio_size ( player - > ic - > pb ) ;
stream_seek ( player , size * x / player - > width , 0 , 1 ) ;
2012-01-01 15:21:26 +03:00
} else {
2010-01-31 20:07:58 +02:00
int64_t ts ;
int ns , hh , mm , ss ;
int tns , thh , tmm , tss ;
2016-01-02 13:19:30 +02:00
tns = player - > ic - > duration / 1000000LL ;
2012-01-01 15:21:26 +03:00
thh = tns / 3600 ;
tmm = ( tns % 3600 ) / 60 ;
tss = ( tns % 60 ) ;
2016-01-02 13:19:30 +02:00
frac = x / player - > width ;
2012-01-01 15:21:26 +03:00
ns = frac * tns ;
hh = ns / 3600 ;
mm = ( ns % 3600 ) / 60 ;
ss = ( ns % 60 ) ;
2010-01-31 20:07:58 +02:00
fprintf ( stderr , " Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d) \n " , frac * 100 ,
hh , mm , ss , thh , tmm , tss ) ;
2016-01-02 13:19:30 +02:00
ts = frac * player - > ic - > duration ;
if ( player - > ic - > start_time ! = AV_NOPTS_VALUE )
ts + = player - > ic - > start_time ;
stream_seek ( player , ts , 0 , 0 ) ;
2010-01-31 01:19:59 +02:00
}
2005-12-22 03:10:11 +02:00
}
break ;
2003-06-07 21:34:02 +03:00
case SDL_VIDEORESIZE :
2016-01-02 13:19:30 +02:00
if ( player ) {
2005-12-17 20:14:38 +02:00
screen = SDL_SetVideoMode ( event . resize . w , event . resize . h , 0 ,
2003-06-07 21:34:02 +03:00
SDL_HWSURFACE | SDL_RESIZABLE | SDL_ASYNCBLIT | SDL_HWACCEL ) ;
2016-01-02 13:19:30 +02:00
screen_width = player - > width = event . resize . w ;
screen_height = player - > height = event . resize . h ;
2003-06-07 21:34:02 +03:00
}
break ;
case SDL_QUIT :
2003-08-06 16:07:23 +03:00
case FF_QUIT_EVENT :
2003-06-07 21:34:02 +03:00
do_exit ( ) ;
break ;
case FF_ALLOC_EVENT :
2006-12-30 13:22:46 +02:00
video_open ( event . user . data1 ) ;
2003-06-07 21:34:02 +03:00
alloc_picture ( event . user . data1 ) ;
break ;
case FF_REFRESH_EVENT :
video_refresh_timer ( event . user . data1 ) ;
2016-01-02 13:19:30 +02:00
player - > refresh = 0 ;
2003-06-07 21:34:02 +03:00
break ;
default :
break ;
}
}
}
2012-09-10 15:37:46 +03:00
static int opt_frame_size ( void * optctx , const char * opt , const char * arg )
2007-02-22 02:33:09 +02:00
{
2011-07-17 00:08:06 +03:00
av_log ( NULL , AV_LOG_ERROR ,
" Option '%s' has been removed, use private format options instead \n " , opt ) ;
return AVERROR ( EINVAL ) ;
2007-02-22 02:33:09 +02:00
}
2012-09-10 15:37:46 +03:00
static int opt_width ( void * optctx , const char * opt , const char * arg )
2003-06-07 21:34:02 +03:00
{
2008-03-22 20:50:23 +02:00
screen_width = parse_number_or_die ( opt , arg , OPT_INT64 , 1 , INT_MAX ) ;
return 0 ;
2003-06-07 21:34:02 +03:00
}
2012-09-10 15:37:46 +03:00
static int opt_height ( void * optctx , const char * opt , const char * arg )
2003-06-07 21:34:02 +03:00
{
2008-03-22 20:50:23 +02:00
screen_height = parse_number_or_die ( opt , arg , OPT_INT64 , 1 , INT_MAX ) ;
return 0 ;
2003-06-07 21:34:02 +03:00
}
2012-09-10 15:37:46 +03:00
static int opt_format ( void * optctx , const char * opt , const char * arg )
2003-06-07 21:34:02 +03:00
{
file_iformat = av_find_input_format ( arg ) ;
if ( ! file_iformat ) {
fprintf ( stderr , " Unknown input format: %s \n " , arg ) ;
2011-05-28 02:53:00 +03:00
return AVERROR ( EINVAL ) ;
2003-06-07 21:34:02 +03:00
}
2011-05-28 02:53:00 +03:00
return 0 ;
2003-06-07 21:34:02 +03:00
}
2003-09-16 22:37:27 +03:00
2012-09-10 15:37:46 +03:00
static int opt_frame_pix_fmt ( void * optctx , const char * opt , const char * arg )
2007-02-22 02:33:09 +02:00
{
2011-07-16 23:43:11 +03:00
av_log ( NULL , AV_LOG_ERROR ,
" Option '%s' has been removed, use private format options instead \n " , opt ) ;
return AVERROR ( EINVAL ) ;
2007-02-22 02:33:09 +02:00
}
2012-09-10 15:37:46 +03:00
static int opt_sync ( void * optctx , const char * opt , const char * arg )
2003-08-06 16:07:23 +03:00
{
if ( ! strcmp ( arg , " audio " ) )
av_sync_type = AV_SYNC_AUDIO_MASTER ;
else if ( ! strcmp ( arg , " video " ) )
av_sync_type = AV_SYNC_VIDEO_MASTER ;
else if ( ! strcmp ( arg , " ext " ) )
av_sync_type = AV_SYNC_EXTERNAL_CLOCK ;
2007-08-09 15:13:29 +03:00
else {
2008-06-12 14:33:53 +03:00
fprintf ( stderr , " Unknown value for %s: %s \n " , opt , arg ) ;
2007-08-09 15:13:29 +03:00
exit ( 1 ) ;
}
2008-06-12 14:33:53 +03:00
return 0 ;
2003-08-06 16:07:23 +03:00
}
2012-09-10 15:37:46 +03:00
static int opt_seek ( void * optctx , const char * opt , const char * arg )
2003-11-10 20:59:45 +02:00
{
2008-04-01 15:22:33 +03:00
start_time = parse_time_or_die ( opt , arg , 1 ) ;
return 0 ;
2003-11-10 20:59:45 +02:00
}
2012-09-10 15:37:46 +03:00
static int opt_duration ( void * optctx , const char * opt , const char * arg )
2010-04-01 23:56:23 +03:00
{
duration = parse_time_or_die ( opt , arg , 1 ) ;
return 0 ;
}
2016-01-02 13:19:32 +02:00
# define OFF(x) offsetof(PlayerState, x)
2008-05-01 18:10:44 +03:00
static const OptionDef options [ ] = {
2009-11-30 01:12:19 +02:00
# include "cmdutils_common_opts.h"
2012-09-10 15:37:46 +03:00
{ " x " , HAS_ARG , { . func_arg = opt_width } , " force displayed width " , " width " } ,
{ " y " , HAS_ARG , { . func_arg = opt_height } , " force displayed height " , " height " } ,
{ " s " , HAS_ARG | OPT_VIDEO , { . func_arg = opt_frame_size } , " set frame size (WxH or abbreviation) " , " size " } ,
2012-09-10 15:42:24 +03:00
{ " fs " , OPT_BOOL , { & is_full_screen } , " force full screen " } ,
{ " an " , OPT_BOOL , { & audio_disable } , " disable audio " } ,
{ " vn " , OPT_BOOL , { & video_disable } , " disable video " } ,
{ " ast " , OPT_INT | HAS_ARG | OPT_EXPERT , { & wanted_stream [ AVMEDIA_TYPE_AUDIO ] } , " select desired audio stream " , " stream_number " } ,
{ " vst " , OPT_INT | HAS_ARG | OPT_EXPERT , { & wanted_stream [ AVMEDIA_TYPE_VIDEO ] } , " select desired video stream " , " stream_number " } ,
{ " sst " , OPT_INT | HAS_ARG | OPT_EXPERT , { & wanted_stream [ AVMEDIA_TYPE_SUBTITLE ] } , " select desired subtitle stream " , " stream_number " } ,
2012-09-10 15:37:46 +03:00
{ " ss " , HAS_ARG , { . func_arg = opt_seek } , " seek to a given position in seconds " , " pos " } ,
{ " t " , HAS_ARG , { . func_arg = opt_duration } , " play \" duration \" seconds of audio/video " , " duration " } ,
2012-09-10 15:42:24 +03:00
{ " bytes " , OPT_INT | HAS_ARG , { & seek_by_bytes } , " seek by bytes 0=off 1=on -1=auto " , " val " } ,
{ " nodisp " , OPT_BOOL , { & display_disable } , " disable graphical display " } ,
2012-09-10 15:37:46 +03:00
{ " f " , HAS_ARG , { . func_arg = opt_format } , " force format " , " fmt " } ,
{ " pix_fmt " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { . func_arg = opt_frame_pix_fmt } , " set pixel format " , " format " } ,
2012-09-10 15:42:24 +03:00
{ " stats " , OPT_BOOL | OPT_EXPERT , { & show_status } , " show status " , " " } ,
{ " bug " , OPT_INT | HAS_ARG | OPT_EXPERT , { & workaround_bugs } , " workaround bugs " , " " } ,
{ " fast " , OPT_BOOL | OPT_EXPERT , { & fast } , " non spec compliant optimizations " , " " } ,
{ " genpts " , OPT_BOOL | OPT_EXPERT , { & genpts } , " generate pts " , " " } ,
{ " drp " , OPT_INT | HAS_ARG | OPT_EXPERT , { & decoder_reorder_pts } , " let decoder reorder pts 0=off 1=on -1=auto " , " " } ,
{ " skiploop " , OPT_INT | HAS_ARG | OPT_EXPERT , { & skip_loop_filter } , " " , " " } ,
{ " skipframe " , OPT_INT | HAS_ARG | OPT_EXPERT , { & skip_frame } , " " , " " } ,
{ " skipidct " , OPT_INT | HAS_ARG | OPT_EXPERT , { & skip_idct } , " " , " " } ,
{ " idct " , OPT_INT | HAS_ARG | OPT_EXPERT , { & idct } , " set idct algo " , " algo " } ,
{ " ec " , OPT_INT | HAS_ARG | OPT_EXPERT , { & error_concealment } , " set error concealment options " , " bit_mask " } ,
2012-09-10 15:37:46 +03:00
{ " sync " , HAS_ARG | OPT_EXPERT , { . func_arg = opt_sync } , " set audio-video sync. type (type=audio/video/ext) " , " type " } ,
2014-09-03 01:45:21 +03:00
{ " noautoexit " , OPT_BOOL | OPT_EXPERT , { & noautoexit } , " Do not exit at the end of playback " , " " } ,
2012-09-10 15:42:24 +03:00
{ " exitonkeydown " , OPT_BOOL | OPT_EXPERT , { & exit_on_keydown } , " exit on key down " , " " } ,
{ " exitonmousedown " , OPT_BOOL | OPT_EXPERT , { & exit_on_mousedown } , " exit on mouse down " , " " } ,
{ " loop " , OPT_INT | HAS_ARG | OPT_EXPERT , { & loop } , " set number of times the playback shall be looped " , " loop count " } ,
{ " framedrop " , OPT_BOOL | OPT_EXPERT , { & framedrop } , " drop frames when cpu is too slow " , " " } ,
{ " infbuf " , OPT_BOOL | OPT_EXPERT , { & infinite_buffer } , " don't limit the input buffer size (useful with realtime streams) " , " " } ,
{ " window_title " , OPT_STRING | HAS_ARG , { & window_title } , " set window title " , " window title " } ,
{ " vf " , OPT_STRING | HAS_ARG , { & vfilters } , " video filters " , " filter list " } ,
{ " rdftspeed " , OPT_INT | HAS_ARG | OPT_AUDIO | OPT_EXPERT , { & rdftspeed } , " rdft speed " , " msecs " } ,
{ " default " , HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT , { opt_default } , " generic catch all option " , " " } ,
2012-01-01 15:21:26 +03:00
{ " i " , 0 , { NULL } , " avconv compatibility dummy option " , " " } ,
2015-04-29 21:28:45 +02:00
{ " autorotate " , OPT_BOOL , { & autorotate } , " automatically rotate video " , " " } ,
2016-01-02 13:19:32 +02:00
{ " c " , HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT , { . off = OFF ( codec_names ) } , " codec name " , " codec " } ,
{ " codec " , HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT , { . off = OFF ( codec_names ) } , " codec name " , " codec " } ,
2003-06-07 21:34:02 +03:00
{ NULL , } ,
} ;
2009-12-21 04:12:34 +02:00
static void show_usage ( void )
2003-06-07 21:34:02 +03:00
{
2009-12-21 04:09:17 +02:00
printf ( " Simple media player \n " ) ;
2011-07-26 18:51:34 +03:00
printf ( " usage: %s [options] input_file \n " , program_name ) ;
2003-06-07 21:34:02 +03:00
printf ( " \n " ) ;
2009-12-21 04:12:34 +02:00
}
2012-08-13 21:06:25 +03:00
void show_help_default ( const char * opt , const char * arg )
2009-12-21 04:12:34 +02:00
{
2010-09-24 03:51:43 +03:00
av_log_set_callback ( log_callback_help ) ;
2009-12-21 04:12:34 +02:00
show_usage ( ) ;
2012-08-15 11:31:46 +03:00
show_help_options ( options , " Main options: " , 0 , OPT_EXPERT , 0 ) ;
show_help_options ( options , " Advanced options: " , OPT_EXPERT , 0 , 0 ) ;
2010-09-24 03:51:43 +03:00
printf ( " \n " ) ;
2011-10-04 15:50:00 +03:00
show_help_children ( avcodec_get_class ( ) , AV_OPT_FLAG_DECODING_PARAM ) ;
show_help_children ( avformat_get_class ( ) , AV_OPT_FLAG_DECODING_PARAM ) ;
2003-06-07 21:34:02 +03:00
printf ( " \n While playing: \n "
" q, ESC quit \n "
" f toggle full screen \n "
" p, SPC pause \n "
2003-08-06 16:07:23 +03:00
" a cycle audio channel \n "
" v cycle video channel \n "
2005-08-14 04:29:34 +03:00
" t cycle subtitle channel \n "
2003-08-06 16:07:23 +03:00
" w show audio waves \n "
2010-04-09 20:52:34 +03:00
" s activate frame-step mode \n "
2003-11-10 20:59:45 +02:00
" left/right seek backward/forward 10 seconds \n "
" down/up seek backward/forward 1 minute \n "
2003-11-28 21:19:01 +02:00
" mouse click seek to percentage in file corresponding to fraction of width \n "
2003-06-07 21:34:02 +03:00
) ;
}
2011-08-28 15:43:54 +03:00
static void opt_input_file ( void * optctx , const char * filename )
2003-06-07 21:34:02 +03:00
{
2010-03-02 01:10:27 +02:00
if ( input_filename ) {
fprintf ( stderr , " Argument '%s' provided as input filename, but '%s' was already specified. \n " ,
filename , input_filename ) ;
exit ( 1 ) ;
}
2003-08-29 23:22:16 +03:00
if ( ! strcmp ( filename , " - " ) )
2007-08-14 12:14:31 +03:00
filename = " pipe: " ;
2003-06-07 21:34:02 +03:00
input_filename = filename ;
}
/* Called from the main */
int main ( int argc , char * * argv )
{
2010-10-02 11:44:33 +03:00
int flags ;
2005-12-17 20:14:38 +02:00
2010-09-24 18:39:10 +03:00
av_log_set_flags ( AV_LOG_SKIP_REPEATED ) ;
2011-09-26 09:15:37 +03:00
parse_loglevel ( argc , argv , options ) ;
2010-09-24 18:39:10 +03:00
2003-06-07 21:34:02 +03:00
/* register all codecs, demux and protocols */
2007-11-22 18:10:02 +02:00
avcodec_register_all ( ) ;
2010-04-22 11:55:23 +03:00
# if CONFIG_AVDEVICE
2007-11-22 18:10:02 +02:00
avdevice_register_all ( ) ;
2010-04-22 11:55:23 +03:00
# endif
2010-03-05 04:20:10 +02:00
avfilter_register_all ( ) ;
2003-06-07 21:34:02 +03:00
av_register_all ( ) ;
2011-11-06 03:47:48 +03:00
avformat_network_init ( ) ;
2003-06-07 21:34:02 +03:00
2010-10-02 11:44:33 +03:00
init_opts ( ) ;
2008-09-28 22:39:18 +03:00
2008-05-29 11:48:51 +03:00
show_banner ( ) ;
2007-09-27 16:52:33 +03:00
2016-01-02 13:19:32 +02:00
parse_options ( player , argc , argv , options , opt_input_file ) ;
2003-06-07 21:34:02 +03:00
2007-08-09 15:13:29 +03:00
if ( ! input_filename ) {
2009-12-21 04:15:46 +02:00
show_usage ( ) ;
2008-11-18 01:15:29 +02:00
fprintf ( stderr , " An input file must be specified \n " ) ;
2011-07-26 18:51:34 +03:00
fprintf ( stderr , " Use -h to get full help or, even better, run 'man %s' \n " , program_name ) ;
2007-08-09 15:13:29 +03:00
exit ( 1 ) ;
}
2003-06-07 21:34:02 +03:00
if ( display_disable ) {
video_disable = 1 ;
}
2003-06-14 14:09:57 +03:00
flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER ;
2007-08-27 12:17:03 +03:00
# if !defined(__MINGW32__) && !defined(__APPLE__)
flags | = SDL_INIT_EVENTTHREAD ; /* Not supported on Windows or Mac OS X */
2003-06-14 14:09:57 +03:00
# endif
2003-06-07 21:34:02 +03:00
if ( SDL_Init ( flags ) ) {
2003-09-29 03:14:13 +03:00
fprintf ( stderr , " Could not initialize SDL - %s \n " , SDL_GetError ( ) ) ;
2003-06-07 21:34:02 +03:00
exit ( 1 ) ;
}
if ( ! display_disable ) {
2006-06-10 01:43:21 +03:00
const SDL_VideoInfo * vi = SDL_GetVideoInfo ( ) ;
fs_screen_width = vi - > current_w ;
fs_screen_height = vi - > current_h ;
2003-06-07 21:34:02 +03:00
}
SDL_EventState ( SDL_ACTIVEEVENT , SDL_IGNORE ) ;
SDL_EventState ( SDL_SYSWMEVENT , SDL_IGNORE ) ;
SDL_EventState ( SDL_USEREVENT , SDL_IGNORE ) ;
2006-11-16 13:58:27 +02:00
av_init_packet ( & flush_pkt ) ;
2013-04-15 12:10:14 +03:00
flush_pkt . data = ( uint8_t * ) & flush_pkt ;
2006-11-16 13:58:27 +02:00
2016-01-02 13:19:31 +02:00
if ( stream_open ( player , input_filename , file_iformat ) < 0 ) {
fprintf ( stderr , " Could not setup the player \n " ) ;
stream_close ( player ) ;
exit ( 1 ) ;
}
2003-06-07 21:34:02 +03:00
event_loop ( ) ;
/* never returns */
return 0 ;
}