RocketGit

sylware / nyanmp (public) (License: AGPLv3) (since 2020-02-12) (hash sha1)

intended to become a collection of media players for gnu/linux based on ffmpeg, alsa, vulkan, x11, wayland, etc.

Clone URLs: https://rocketgit.com/user/sylware/nyanmp ssh://rocketgit@ssh.rocketgit.com/user/sylware/nyanmp git://git.rocketgit.com/user/sylware/nyanmp

master

List of commits:

Subject	Hash	Author	Date (UTC)
npa: tons of love	68a79110ca4a6f5bdb41ed90e421b6f46c1c1877	Sylvain BERTRAND	2020-11-06 15:20:13
npv: spurious unsigned	5b4e039ffd921438a37112f0b4108480366f4d6d	Sylvain BERTRAND	2020-11-06 04:31:18
npv: backward discontinuity handling	0fc81a53996993992dd86a96a26afd2aab0ac366	Sylvain BERTRAND	2020-09-25 16:14:26
npv: more monotonic, more pts discontinuity	1ab37ad2a24ca8f9fbf6d51eac8f996bd2eefacf	Sylvain BERTRAND	2020-09-25 01:34:41
npv: workaround a mesa bug (which leads to linux state corruption)	780e5bec0b90a9e931778cf68fec62a7c5241c13	Sylvain BERTRAND	2020-09-23 15:57:25
npv: fix filter time base handling, prepare discontinuity support	2b7347be805d17a2b6f06e276e897c51431b9c6c	Sylvain BERTRAND	2020-09-22 17:38:46
npv: correct coarse sync of vulkan image acquisition	a9b52940ff2d567dc6c26b28d86eab54f5876819	Sylvain BERTRAND	2020-09-20 22:00:32
npv: fix channel layout handling and a tad more	88f74f181a567d108874a936fe3d306d34cfefb7	Sylvain BERTRAND	2020-09-19 23:12:04
npv: dynamic audio filter configuration	d8a0ff688ddb2abcde22c01a2ae52ea74e9f0f2f	Sylvain BERTRAND	2020-09-19 20:54:04
npv:protection against tantrum of media audio	78589150b7c6f1f3cae49b4b4bc8b572c6d8e6b7	Sylvain BERTRAND	2020-09-18 15:26:17
npv/npa:finish to workaround null channel layout	314788563e01d7ffb364a1775ba68619ee3f6c5c	Sylvain BERTRAND	2020-09-15 22:50:57
npv: handle empty channel layout	5b5794fc4d5300b671b684a2f41196f66bd1fc4a	Sylvain BERTRAND	2020-09-15 22:11:07
npv: tidy mutex locking	1962092d9675f76604414086200e88f6c857346f	Sylvain BERTRAND	2020-09-15 00:51:12
npv: less incorrect reprogramming of blits	b319e79f4f1b79670f6eef754142cc65c891ad4b	Sylvain BERTRAND	2020-09-12 15:14:27
npv:fix osd restoration	8c64f703eca6b8c54b4cb5c95231dd02aa394135	Sylvain BERTRAND	2020-08-29 20:36:12
npv:osd:solo compilation modulo a few warnings	7805bd8f34f913b1535cc81c5be2a3132bd7e0e5	Sylvain BERTRAND	2020-08-29 14:51:35
npv: cleanup and color component fix	44f294e1de96c7974740f1187ebdbe12204884ae	Sylvain BERTRAND	2020-08-28 23:48:18
npv:osd:timer, will add more if pertinent	6d34403c2c49bfa6ccf8e7a72e35a69e6f0527c5	Sylvain BERTRAND	2020-08-28 22:47:18
npv/npa: document properly snd_pcm_drain behavior	510ca39ee6a9ac9fcd646484793b7556eaa5972f	Sylvain BERTRAND	2020-08-26 17:36:29
npv:remove locale layout dependent key binds	f69bbbe529045b4243ece8957c838cb1465352da	Sylvain BERTRAND	2020-08-24 21:27:08

Commit 68a79110ca4a6f5bdb41ed90e421b6f46c1c1877 - npa: tons of love
Author: Sylvain BERTRAND
Author date (UTC): 2020-11-06 15:20
Committer name: Sylvain BERTRAND
Committer date (UTC): 2020-11-06 15:20
Parent(s): 5b4e039ffd921438a37112f0b4108480366f4d6d
Signer:
Signing key:
Signing status: N
Tree: 06c5ad8bf51b4bc5a520ed5a791a3f52fe52e87d

File	Lines added	Lines deleted
npa/TODO	1	7
npa/npa.c	741	419

File npa/TODO changed (mode: 100644) (index 70b2a25..c57e505)
1	1	not ordered:	not ordered:
2		- port npv proper usage of filter time base
3		- port npv dynamic audio reconfiguration
4		- port npv initial ffmpeg audio parameter override code
5		- we were lied to: presentation/decoding timestamps from a demuxer can be
6		discontinuous without any warning.
7		- support dynamic re-configuration based on decoder output?
8		(the plumbing should be roughly in place for that)
	2		- make the circular buffer size dynamic in order to increase buffering

File npa/npa.c changed (mode: 100644) (index 177f23b..141a136)
18	18	* cfg : ConFiGuration	* cfg : ConFiGuration
19	19	* ctx : ConTeX	* ctx : ConTeX
20	20	* dec : DECoder/DECoded	* dec : DECoder/DECoded
	21		* desc : DESCription
21	22	* dev : DEVice	* dev : DEVice
22	23	* e : End (usually a pointer on the byte past the last valid byte)	* e : End (usually a pointer on the byte past the last valid byte)
23	24	* eof : End Of File	* eof : End Of File

26	27	* evt(s) : EVenT(S)	* evt(s) : EVenT(S)
27	28	* err : ERRor	* err : ERRor
28	29	* fd : File Descriptor	* fd : File Descriptor
	30		* ff : FFmpeg
29	31	* filt : FILTer	* filt : FILTer
30	32	* fmt : ForMaT	* fmt : ForMaT
31	33	* fr(s) : FRame(S)	* fr(s) : FRame(S)

38	40	* nr : NumbeR	* nr : NumbeR
39	41	* out : OUTput	* out : OUTput
40	42	* pkt(s) : PacKeT(S)	* pkt(s) : PacKeT(S)
	43		* pts : Presentation TimeStamp
41	44	* rd : ReaD	* rd : ReaD
42	45	* ref(s) : REFerence(S)	* ref(s) : REFerence(S)
43	46	* s : Start	* s : Start

59	62	* and/or similar cleanup: we have a virtual machine with a garbage collector,	* and/or similar cleanup: we have a virtual machine with a garbage collector,
60	63	* it is linux.	* it is linux.
61	64	*	*
62		* we do presume we won't play more than 8 chans and ffmpeg chans layout will
	65		* we do presume we won't play more than 8 chans and ff chans layout will
63	66	* fit alsa chans map	* fit alsa chans map
64	67	*	*
65	68	* XXX: we don't know how the alsa silence machinery works, then we use brutal	* XXX: we don't know how the alsa silence machinery works, then we use brutal

88	91	#include <sys/epoll.h>	#include <sys/epoll.h>
89	92	#include <sys/signalfd.h>	#include <sys/signalfd.h>
90	93	#include <sys/timerfd.h>	#include <sys/timerfd.h>
91		/* ffmpeg */
	94		/* ff */
92	95	#include <libavformat/avformat.h>	#include <libavformat/avformat.h>
93	96	#include <libavcodec/avcodec.h>	#include <libavcodec/avcodec.h>
94	97	#include <libavfilter/avfilter.h>	#include <libavfilter/avfilter.h>

97	100	#include <libavutil/opt.h>	#include <libavutil/opt.h>
98	101	/* alsa */	/* alsa */
99	102	#include <alsa/asoundlib.h>	#include <alsa/asoundlib.h>
	103		/============================================================================/
	104		/* namespaces -- START */
100	105	/----------------------------------------------------------------------------/	/----------------------------------------------------------------------------/
101		/* fix C */
	106		/* fix C -- START */
102	107	#define u8 uint8_t	#define u8 uint8_t
103	108	#define U8_MAX 255	#define U8_MAX 255
104	109	#define u32 uint32_t	#define u32 uint32_t

110	115	#else	#else
111	116	#error "unable to find the right atomic for a 8 bits byte, be sure to have __STDC_WANT_IEC_60559_BFP_EXT__ defined"	#error "unable to find the right atomic for a 8 bits byte, be sure to have __STDC_WANT_IEC_60559_BFP_EXT__ defined"
112	117	#endif	#endif
	118		/* fix C -- END */
113	119	/----------------------------------------------------------------------------/	/----------------------------------------------------------------------------/
114
	120		/* ff namespace -- START*/
	121		#define AV_FR_FMT_NONE AV_SAMPLE_FMT_NONE
	122		#define av_bufsink_get_frs av_buffersink_get_frame
	123		#define av_bufsrc_add_frs_flags av_buffersrc_add_frame_flags
	124		#define AV_BUFSRC_FLAG_KEEP_REF AV_BUFFERSRC_FLAG_KEEP_REF
	125		#define AV_BUFSRC_FLAG_PUSH AV_BUFFERSRC_FLAG_PUSH
	126		#define av_codec AVCodec
	127		#define av_codec_ctx AVCodecContext
	128		#define av_dump_fmt av_dump_format
	129		#define av_duration_estimation_method AVDurationEstimationMethod
	130		#define av_filt AVFilter
	131		#define av_filt_ctx AVFilterContext
	132		#define av_filt_get_by_name avfilter_get_by_name
	133		#define av_filt_graph AVFilterGraph
	134		#define av_filt_graph_alloc avfilter_graph_alloc
	135		#define av_filt_graph_alloc_filt avfilter_graph_alloc_filter
	136		#define av_filt_graph_cfg avfilter_graph_config
	137		#define av_filt_graph_dump avfilter_graph_dump
	138		#define av_filt_graph_free avfilter_graph_free
	139		#define av_filt_graph_send_cmd avfilter_graph_send_command
	140		#define av_filt_init_str avfilter_init_str
	141		#define av_filt_link avfilter_link
	142		#define av_find_best_st av_find_best_stream
	143		#define av_flush_bufs avcodec_flush_buffers
	144		#define av_fmt_ctx AVFormatContext
	145		#define AV_FMT_DURATION_FROM_BITRATE AVFMT_DURATION_FROM_BITRATE
	146		#define AV_FMT_DURATION_FROM_PTS AVFMT_DURATION_FROM_PTS
	147		#define AV_FMT_DURATION_FROM_ST AVFMT_DURATION_FROM_STREAM
	148		#define av_fmt_find_st_info avformat_find_stream_info
	149		#define av_fmt_flush avformat_flush
	150		#define av_fmt_open_input avformat_open_input
	151		#define av_fr_fmt_is_planar av_sample_fmt_is_planar
	152		#define AV_FR_FMT_DBL AV_SAMPLE_FMT_DBL
	153		#define AV_FR_FMT_DBLP AV_SAMPLE_FMT_DBLP
	154		#define AV_FR_FMT_FLT AV_SAMPLE_FMT_FLT
	155		#define AV_FR_FMT_FLTP AV_SAMPLE_FMT_FLTP
	156		#define AV_FR_FMT_S16 AV_SAMPLE_FMT_S16
	157		#define AV_FR_FMT_S16P AV_SAMPLE_FMT_S16P
	158		#define AV_FR_FMT_S32 AV_SAMPLE_FMT_S32
	159		#define AV_FR_FMT_S32P AV_SAMPLE_FMT_S32P
	160		#define AV_FR_FMT_U8P AV_SAMPLE_FMT_U8P
	161		#define AV_FR_FMT_U8 AV_SAMPLE_FMT_U8
	162		#define av_frs_alloc av_frame_alloc
	163		#define av_frs_set_silence av_samples_set_silence
	164		#define av_frs_unref av_frame_unref
	165		#define av_get_chan_layout_str av_get_channel_layout_string
	166		#define av_get_default_chans_layout av_get_default_channel_layout
	167		#define av_get_fr_fmt_name av_get_sample_fmt_name
	168		#define av_get_fr_fmt_str av_get_sample_fmt_string
	169		#define av_io_flush avio_flush
	170		#define AV_MEDIA_TYPE_AUDIO AVMEDIA_TYPE_AUDIO
	171		#define av_pkt AVPacket
	172		#define av_pkt_unref av_packet_unref
	173		#define av_read_pkt av_read_frame
	174		#define av_rational AVRational
	175		#define av_seek_pkt av_seek_frame
	176		#define av_receive_frs avcodec_receive_frame
	177		#define av_fr_fmt AVSampleFormat
	178		#define av_frs AVFrame
	179		#define av_sd_pkt avcodec_send_packet
	180		#define av_st AVStream
	181		#define chans_layout channel_layout
	182		#define chans_n channels
	183		#define fmt format
	184		#define fr_fmt sample_fmt
	185		#define fr_rate sample_rate
	186		#define frs_n nb_samples
	187		#define st_idx stream_index
	188		#define sts streams
	189		#define tb time_base
	190		/* ff namespace -- END */
	191		/----------------------------------------------------------------------------/
	192		/* alsa namespace -- START */
	193		#define snd_pcm_fmt_desc snd_pcm_format_description
	194		#define snd_pcm_fmt_set_silence snd_pcm_format_set_silence
	195		#define SND_PCM_FMT_FLT SND_PCM_FORMAT_FLOAT
	196		#define SND_PCM_FMT_S16 SND_PCM_FORMAT_S16
	197		#define SND_PCM_FMT_S24 SND_PCM_FORMAT_S24
	198		#define SND_PCM_FMT_S32 SND_PCM_FORMAT_S32
	199		#define SND_PCM_FMT_S8 SND_PCM_FORMAT_S8
	200		#define snd_pcm_fmt_t snd_pcm_format_t
	201		#define SND_PCM_FMT_U16 SND_PCM_FORMAT_U16
	202		#define SND_PCM_FMT_U24 SND_PCM_FORMAT_U24
	203		#define SND_PCM_FMT_U32 SND_PCM_FORMAT_U32
	204		#define SND_PCM_FMT_U8 SND_PCM_FORMAT_U8
	205		#define snd_pcm_frs_to_bytes snd_pcm_frames_to_bytes
	206		#define snd_pcm_hw_params_get_buf_size snd_pcm_hw_params_get_buffer_size
	207		#define snd_pcm_hw_params_get_chans snd_pcm_hw_params_get_channels
	208		#define snd_pcm_hw_params_get_chans_max snd_pcm_hw_params_get_channels_max
	209		#define snd_pcm_hw_params_get_chans_min snd_pcm_hw_params_get_channels_min
	210		#define snd_pcm_hw_params_get_fmt snd_pcm_hw_params_get_format
	211		#define snd_pcm_hw_params_set_buf_size_near snd_pcm_hw_params_set_buffer_size_near
	212		#define snd_pcm_hw_params_set_chans snd_pcm_hw_params_set_channels
	213		#define snd_pcm_hw_params_set_fmt snd_pcm_hw_params_set_format
	214		#define snd_pcm_hw_params_test_chans snd_pcm_hw_params_test_channels
	215		#define snd_pcm_hw_params_test_fmt snd_pcm_hw_params_test_format
	216		#define snd_pcm_sfrs_t snd_pcm_sframes_t
	217		#define SND_PCM_ST_PLAYBACK SND_PCM_STREAM_PLAYBACK
	218		#define snd_pcm_ufrs_t snd_pcm_uframes_t
	219		/* alsa namespace -- END */
	220		/* namespaces -- END */
	221		/============================================================================/
115	222	#define ARRAY_N(x) (sizeof(x) / sizeof((x)[0]))	#define ARRAY_N(x) (sizeof(x) / sizeof((x)[0]))
116
117		#define POUT(fmt, ...) fprintf(stdout, fmt, ##__VA_ARGS__)
118		#define PERR(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)
119		#define WARNING(fmt, ...) fprintf(stderr, "WARNING:" fmt, ##__VA_ARGS__)
120		#define FATAL(fmt, ...) ({perr("FATAL:" fmt, ##__VA_ARGS__);stdin_flags_restore();stdin_tty_cfg_restore();exit(1);})
121		#define EXIT(fmt, ...) ({pout("EXITING:" fmt, ##__VA_ARGS__);stdin_flags_restore();stdin_tty_cfg_restore();exit(0);})
122	223	#define STR_SZ 255 /* sz and idx fit in 1 byte */	#define STR_SZ 255 /* sz and idx fit in 1 byte */
123	224	/---------------------------------------------------------------------------/	/---------------------------------------------------------------------------/
124	225	static u8 *current_url;	static u8 *current_url;

...	...	static int current_st_idx;
127	228	static struct {	static struct {
128	229	struct {	struct {
129	230	int64_t duration;	int64_t duration;
130		enum AVDurationEstimationMethod m;
	231		enum av_duration_estimation_method m;
131	232	} fmt;	} fmt;
132	233	struct {	struct {
133		AVRational tb;
	234		av_rational tb;
134	235	int id;	int id;
135	236	int64_t duration;	int64_t duration;
136	237	} st;	} st;

...	...	static struct {
140	241	static int ep_fd;	static int ep_fd;
141	242	static int sig_fd;	static int sig_fd;
142	243	/---------------------------------------------------------------------------/	/---------------------------------------------------------------------------/
143		/* linux alsa */
	244		/* alsa */
144	245	static snd_pcm_t *pcm_g;	static snd_pcm_t *pcm_g;
145	246	static snd_output_t *pcm_pout;	static snd_output_t *pcm_pout;
146	247	static snd_output_t *pcm_perr;	static snd_output_t *pcm_perr;

...	...	static snd_output_t pcm_perr;*
148	249	static struct pollfd pcm_pollfds[PCM_POLLFDS_N_MAX];	static struct pollfd pcm_pollfds[PCM_POLLFDS_N_MAX];
149	250	static u8 pcm_pollfds_n;	static u8 pcm_pollfds_n;
150	251	/---------------------------------------------------------------------------/	/---------------------------------------------------------------------------/
151		/* ffmpeg dec */
152		/*
153		* XXX: a ffmpeg fr is not 1 audio fr but a collection of frs.
154		* ffmpeg dec fr "nb_samples" is actually the number of audio frs
155		* av_read_frame is actually av_read_pkt, like av_seek*
156		* we personally did not like the resulting confusion.
157		* we purposely "fix" the namespace even if some others won't like it.
158		*/
159		#define AVFrames AVFrame
160		#define frames_n nb_samples
161		#define av_frames_alloc av_frame_alloc
162		#define av_read_pkt av_read_frame
163		#define av_seek_pkt av_seek_frame
164		#define avcodec_receive_frames avcodec_receive_frame
165		#define AVFrameFormat AVSampleFormat
166		#define av_frames_set_silence av_samples_set_silence
167		#define av_get_frame_fmt_name av_get_sample_fmt_name
168		#define av_get_frame_fmt_string av_get_sample_fmt_string
169		#define frame_rate sample_rate
170		#define av_frame_fmt_is_planar av_sample_fmt_is_planar
171		#define frame_fmt sample_fmt
172		#define av_frames_unref av_frame_unref
173		static AVPacket *rd_thd_pkt;
174		static AVFormatContext *fmt_ctx;
	252		/* ff dec */
	253		static av_pkt *rd_thd_pkt;
	254		static av_fmt_ctx *fmt_ctx;
175	255	static pthread_mutex_t fmt_ctx_mutex;	static pthread_mutex_t fmt_ctx_mutex;
176		static AVCodec *dec;
177		static AVCodecContext *dec_ctx;
	256		static av_codec *dec;
	257		static av_codec_ctx *dec_ctx;
178	258	/---------------------------------------------------------------------------/	/---------------------------------------------------------------------------/
179		/* ffmpeg filter graph */
180		static AVFilterGraph *filter_graph;
181		static AVFilterContext *abufsrc_ctx;
182		static const AVFilter *abufsrc_filt;
183		static AVFilterContext *vol_ctx;
184		static const AVFilter *vol_filt;
	259		/* ff filt graph */
	260		static av_filt_graph *filt_graph;
	261		static av_filt_ctx *abufsrc_ctx;
	262		static const av_filt *abufsrc_filt;
	263		static struct { /* used to detected reconfiguration */
	264		int chans_n;
	265		uint64_t chans_layout;
	266		int rate;
	267		enum av_fr_fmt fmt;
	268		} abufsrc_key;
	269		static av_filt_ctx *vol_ctx;
	270		static const av_filt *vol_filt;
185	271	static u8 double_zero_l10n_str[sizeof("xxx.xx")];	static u8 double_zero_l10n_str[sizeof("xxx.xx")];
186		static AVFilterContext *afmt_ctx;
187		static const AVFilter *afmt_filt;
188		static AVFilterContext *abufsink_ctx;
189		static const AVFilter *abufsink_filt;
	272		static av_filt_ctx *afmt_ctx;
	273		static const av_filt *afmt_filt;
	274		static av_filt_ctx *abufsink_ctx;
	275		static const av_filt *abufsink_filt;
190	276	/---------------------------------------------------------------------------/	/---------------------------------------------------------------------------/
191	277	/* a formally proven concurrently accessed lockless cb */	/* a formally proven concurrently accessed lockless cb */
192	278	struct {	struct {
193	279	atomic_u8 reset;	atomic_u8 reset;
	280		atomic_u8 hold;
194	281
195	282	atomic_int st_idx;	atomic_int st_idx;
196		AVPacket *pkts[U8_MAX + 1];
	283		av_pkt *pkts[U8_MAX + 1];
197	284	atomic_u8 rd;	atomic_u8 rd;
198	285	atomic_u8 sd;	atomic_u8 sd;
199	286	} cb;	} cb;
200	287	/* running state */	/* running state */
201	288	struct {	struct {
202		AVFrames *av;
	289		av_frs *av;
	290		bool pushed_in_filt_graph;
203	291	int64_t most_recent_ts; /* a very "coarse-grained" clock */	int64_t most_recent_ts; /* a very "coarse-grained" clock */
204	292	} dec_frs;	} dec_frs;
205	293	struct {	struct {
206		AVFrames *av;
207		bool no_more_dec_frs;
	294		av_frs *av;
208	295	float vol;	float vol;
209	296	bool muted;	bool muted;
210		snd_pcm_uframes_t pcm_written_ufrs_n;
	297		snd_pcm_ufrs_t pcm_written_ufrs_n;
211	298	} filt_frs;	} filt_frs;
212	299	/* we will inject silence frs while paused */	/* we will inject silence frs while paused */
213	300	bool paused;	bool paused;

...	...	static void fmt_ctx_unlock(void)
348	435	if (r != 0)	if (r != 0)
349	436	fatal("unable to unlock the format context\n");	fatal("unable to unlock the format context\n");
350	437	}	}
351		static u8 *duration_estimate_to_str(enum AVDurationEstimationMethod m)
	438		static u8 *duration_estimate_to_str(enum av_duration_estimation_method m)
352	439	{	{
353	440	switch (m) {	switch (m) {
354		case AVFMT_DURATION_FROM_PTS:
	441		case AV_FMT_DURATION_FROM_PTS:
355	442	return "from PTS(Presentation TimeStamp)";	return "from PTS(Presentation TimeStamp)";
356		case AVFMT_DURATION_FROM_STREAM:
	443		case AV_FMT_DURATION_FROM_ST:
357	444	return "from stream";	return "from stream";
358		case AVFMT_DURATION_FROM_BITRATE:
	445		case AV_FMT_DURATION_FROM_BITRATE:
359	446	return "from bitrate";	return "from bitrate";
360	447	default:	default:
361	448	return "unkwown";	return "unkwown";
362	449	}	}
363	450	}	}
364	451	/* meh... */	/* meh... */
365		static u8 ts_to_str(int64_t ts, AVRational tb, int64_t remaining)
	452		static u8 ts_to_str(int64_t ts, av_rational tb, int64_t remaining)
366	453	{	{
367	454	static u8 str[sizeof("~S00:00:00.000 remains S9223372036854775807 time base units")];	static u8 str[sizeof("~S00:00:00.000 remains S9223372036854775807 time base units")];
368	455	bool is_neg;	bool is_neg;

...	...	static u8 ts_to_str(int64_t ts, AVRational tb, int64_t remaining)
370	457	int64_t mins_n;	int64_t mins_n;
371	458	int64_t secs_n;	int64_t secs_n;
372	459	int64_t msecs_n;	int64_t msecs_n;
373		int64_t one_hour; /* in ffmpeg time_base units */
374		int64_t one_min; /* in ffmpeg time_base units */
375		int64_t one_sec; /* in ffmpeg time_base units */
376		int64_t one_msec; /* in ffmpeg time_base units */
	460		int64_t one_hour; /* in ff tb units */
	461		int64_t one_min; /* in ff tb units */
	462		int64_t one_sec; /* in ff tb units */
	463		int64_t one_msec; /* in ff tb units */
377	464
378	465	if (ts < 0) {	if (ts < 0) {
379	466	ts = -ts;	ts = -ts;

...	...	static void cmd_info(void)
436	523	snprintf(duration_str, sizeof(duration_str), "%"PRId64, cmd_info_data.fmt.duration);	snprintf(duration_str, sizeof(duration_str), "%"PRId64, cmd_info_data.fmt.duration);
437	524	ts_str = ts_to_str(cmd_info_data.fmt.duration, AV_TIME_BASE_Q,	ts_str = ts_to_str(cmd_info_data.fmt.duration, AV_TIME_BASE_Q,
438	525	&remaining);	&remaining);
439		pout("duration=");RED;POUT("%s", ts_str);RESTORE;
	526		pout("duration=");RED;pout("%s", ts_str);RESTORE;
440	527	if (remaining != 0)	if (remaining != 0)
441	528	pout(" remaining %"PRId64" av_time_base units\n", remaining);	pout(" remaining %"PRId64" av_time_base units\n", remaining);
442	529	else	else

...	...	static void cmd_info(void)
449	536	} else {	} else {
450	537	snprintf(duration_str, sizeof(duration_str), "%"PRId64, cmd_info_data.st.duration);	snprintf(duration_str, sizeof(duration_str), "%"PRId64, cmd_info_data.st.duration);
451	538	ts_str = ts_to_str(cmd_info_data.st.duration, cmd_info_data.st.tb, &remaining);	ts_str = ts_to_str(cmd_info_data.st.duration, cmd_info_data.st.tb, &remaining);
452		pout(";duration=");RED;POUT("%s\n", ts_str);RESTORE;
	539		pout(";duration=");RED;pout("%s\n", ts_str);RESTORE;
453	540	if (remaining != 0)	if (remaining != 0)
454	541	pout(" remaining %"PRId64" stream time base units\n", remaining);	pout(" remaining %"PRId64" stream time base units\n", remaining);
455	542	else	else

...	...	static void do_reset(void)
499	586	u8 i;	u8 i;
500	587
501	588	fmt_ctx_lock();	fmt_ctx_lock();
502		avformat_flush(fmt_ctx);
503		avio_flush(fmt_ctx->pb);
	589		av_fmt_flush(fmt_ctx);
	590		av_io_flush(fmt_ctx->pb);
504	591	fmt_ctx_unlock();	fmt_ctx_unlock();
505	592	i = 0;	i = 0;
506	593	loop {	loop {
507		av_packet_unref(cb.pkts[i]);
	594		av_pkt_unref(cb.pkts[i]);
508	595	if (i == U8_MAX)	if (i == U8_MAX)
509	596	break;	break;
510	597	++i;	++i;

...	...	static void do_reset(void)
515	602	}	}
516	603	#undef RESET_DONE	#undef RESET_DONE
517	604	#define DO_RESET 1	#define DO_RESET 1
	605		#define HOLD 1
518	606	static void rd_loop(void) { loop /* infinite loop */	static void rd_loop(void) { loop /* infinite loop */
519	607	{	{
520	608	int r;	int r;

...	...	static void rd_loop(void) { loop / infinite loop /
523	611	u8 sd;	u8 sd;
524	612	u8 reset;	u8 reset;
525	613	int st_idx;	int st_idx;
	614		u8 hold;
526	615	/*	/*
527	616	* XXX: we actually perform reset on this thd, with a little lockfree	* XXX: we actually perform reset on this thd, with a little lockfree
528	617	* protocol and reasonable wait loops	* protocol and reasonable wait loops

...	...	static void rd_loop(void) { loop / infinite loop /
531	620	if (reset == DO_RESET)	if (reset == DO_RESET)
532	621	do_reset();	do_reset();
533	622	/--------------------------------------------------------------------/	/--------------------------------------------------------------------/
	623		hold = atomic_load(&cb.hold);
	624		if (hold == HOLD) {
	625		wait(1000000); /* 1ms */
	626		continue;
	627		}
	628		/--------------------------------------------------------------------/
534	629	rd = atomic_load(&cb.rd);	rd = atomic_load(&cb.rd);
535	630	sd = atomic_load(&cb.sd);	sd = atomic_load(&cb.sd);
536	631	next_rd = rd + 1;	next_rd = rd + 1;

...	...	static void rd_loop(void) { loop / infinite loop /
554	649	fatal("ffmpeg:error while demuxing coded/compressed data into packets\n");	fatal("ffmpeg:error while demuxing coded/compressed data into packets\n");
555	650	else { /* r == 0 */	else { /* r == 0 */
556	651	st_idx = atomic_load(&cb.st_idx);	st_idx = atomic_load(&cb.st_idx);
557		if (rd_thd_pkt->stream_index != st_idx) { /* sd_idx can be -1 */
558		av_packet_unref(rd_thd_pkt);
	652		if (rd_thd_pkt->st_idx != st_idx) { /* sd_idx can be -1 */
	653		av_pkt_unref(rd_thd_pkt);
559	654	continue;	continue;
560	655	}	}
561	656	av_packet_move_ref(cb.pkts[rd], rd_thd_pkt);	av_packet_move_ref(cb.pkts[rd], rd_thd_pkt);

...	...	static void rd_loop(void) { loop / infinite loop /
563	658	atomic_store(&cb.rd, next_rd);	atomic_store(&cb.rd, next_rd);
564	659	}}	}}
565	660	#undef DO_RESET	#undef DO_RESET
	661		#undef HOLD
566	662	static void rd_thd_entry(void arg)	static void rd_thd_entry(void arg)
567	663	{	{
568	664	int r;	int r;

...	...	static uint64_t pcm_chmaps2ff_chans_layout(snd_pcm_t pcm,*
646	742	pout("alsa:your pcm device support channel maps, but fine granularity wiring strategy is not implemented\n");	pout("alsa:your pcm device support channel maps, but fine granularity wiring strategy is not implemented\n");
647	743	free(pcm_chmap);	free(pcm_chmap);
648	744	}	}
649		ff_chans_layout = av_get_default_channel_layout((int)pcm_chans_n);
650		av_get_channel_layout_string(chans_layout_str, sizeof(chans_layout_str),
	745		ff_chans_layout = av_get_default_chans_layout((int)pcm_chans_n);
	746		av_get_chan_layout_str(chans_layout_str, sizeof(chans_layout_str),
651	747	(int)pcm_chans_n, ff_chans_layout);	(int)pcm_chans_n, ff_chans_layout);
652	748	if (print_info)	if (print_info)
653	749	pout("alsa channel map wired to ffmpeg channel layout:\"%s\" (%u pcm channels)\n", chans_layout_str, pcm_chans_n);	pout("alsa channel map wired to ffmpeg channel layout:\"%s\" (%u pcm channels)\n", chans_layout_str, pcm_chans_n);
654	750	return ff_chans_layout;	return ff_chans_layout;
655	751	}	}
656	752	/* fatal if the wiring cannot be done */	/* fatal if the wiring cannot be done */
657		static void pcm_layout2ff_fmt_strict(snd_pcm_format_t alsa_fmt,
658		snd_pcm_access_t alsa_access, enum AVSampleFormat *ff_fmt,
659		bool print_info)
	753		static void pcm_layout2ff_fmt_strict(snd_pcm_fmt_t alsa_fmt,
	754		snd_pcm_access_t alsa_access, enum av_fr_fmt *ff_fmt, bool print_info)
660	755	{	{
661	756	/*	/*
662	757	* ff fmt byte order is always native.	* ff fmt byte order is always native.
663	758	* here we handle little endian only	* here we handle little endian only
664	759	*/	*/
665	760	switch (alsa_fmt) {	switch (alsa_fmt) {
666		case SND_PCM_FORMAT_FLOAT:
	761		case SND_PCM_FMT_FLT:
667	762	if (alsa_access == SND_PCM_ACCESS_RW_INTERLEAVED)	if (alsa_access == SND_PCM_ACCESS_RW_INTERLEAVED)
668		*ff_fmt = AV_SAMPLE_FMT_FLT;
	763		*ff_fmt = AV_FR_FMT_FLT;
669	764	else	else
670		*ff_fmt = AV_SAMPLE_FMT_FLTP;
	765		*ff_fmt = AV_FR_FMT_FLTP;
671	766	break;	break;
672		case SND_PCM_FORMAT_S32:
	767		case SND_PCM_FMT_S32:
673	768	if (alsa_access == SND_PCM_ACCESS_RW_INTERLEAVED)	if (alsa_access == SND_PCM_ACCESS_RW_INTERLEAVED)
674		*ff_fmt = AV_SAMPLE_FMT_S32;
	769		*ff_fmt = AV_FR_FMT_S32;
675	770	else	else
676		*ff_fmt = AV_SAMPLE_FMT_S32P;
	771		*ff_fmt = AV_FR_FMT_S32P;
677	772	break;	break;
678		case SND_PCM_FORMAT_S16:
	773		case SND_PCM_FMT_S16:
679	774	if (alsa_access == SND_PCM_ACCESS_RW_INTERLEAVED)	if (alsa_access == SND_PCM_ACCESS_RW_INTERLEAVED)
680		*ff_fmt = AV_SAMPLE_FMT_S16;
	775		*ff_fmt = AV_FR_FMT_S16;
681	776	else	else
682		*ff_fmt = AV_SAMPLE_FMT_S16P;
	777		*ff_fmt = AV_FR_FMT_S16P;
683	778	break;	break;
684		case SND_PCM_FORMAT_U8:
	779		case SND_PCM_FMT_U8:
685	780	if (alsa_access == SND_PCM_ACCESS_RW_INTERLEAVED)	if (alsa_access == SND_PCM_ACCESS_RW_INTERLEAVED)
686		*ff_fmt = AV_SAMPLE_FMT_U8;
	781		*ff_fmt = AV_FR_FMT_U8;
687	782	else	else
688		*ff_fmt = AV_SAMPLE_FMT_U8P;
	783		*ff_fmt = AV_FR_FMT_U8P;
689	784	break;	break;
690	785	default:	default:
691		fatal("unable to wire strictly alsa layout \"%s\"/\"%s\" to a ffmpeg format\n", snd_pcm_format_description(alsa_fmt), snd_pcm_access_name(alsa_access));
	786		fatal("unable to wire strictly alsa layout \"%s\"/\"%s\" to a ffmpeg format\n", snd_pcm_fmt_desc(alsa_fmt), snd_pcm_access_name(alsa_access));
692	787	}	}
693	788	if (print_info) {	if (print_info) {
694	789	u8 ff_fmt_str[STR_SZ];	u8 ff_fmt_str[STR_SZ];
695	790
696		av_get_sample_fmt_string(ff_fmt_str, sizeof(ff_fmt_str),
697		*ff_fmt);
698		pout("alsa pcm layout \"%s\"/\"%s\" wired strictly to ffmpeg format \"%sbits\"\n", snd_pcm_format_description(alsa_fmt), snd_pcm_access_name(alsa_access), ff_fmt_str);
	791		av_get_fr_fmt_str(ff_fmt_str, sizeof(ff_fmt_str), *ff_fmt);
	792		pout("alsa pcm layout \"%s\"/\"%s\" wired strictly to ffmpeg format \"%sbits\"\n", snd_pcm_fmt_desc(alsa_fmt), snd_pcm_access_name(alsa_access), ff_fmt_str);
699	793	}	}
700	794	}	}
701		static void pcm2ff(snd_pcm_t pcm, enum AVSampleFormat ff_fmt,
	795		static void pcm2ff(snd_pcm_t pcm, enum av_fr_fmt ff_fmt,
702	796	int ff_rate, int ff_chans_n, uint64_t *ff_chans_layout,	int ff_rate, int ff_chans_n, uint64_t *ff_chans_layout,
703	797	bool print_info)	bool print_info)
704	798	{	{
705	799	int r;	int r;
706	800	snd_pcm_hw_params_t *hw_params;	snd_pcm_hw_params_t *hw_params;
707	801	snd_pcm_access_t pcm_access;	snd_pcm_access_t pcm_access;
708		snd_pcm_format_t pcm_fmt;
	802		snd_pcm_fmt_t pcm_fmt;
709	803	unsigned int pcm_rate;	unsigned int pcm_rate;
710	804	unsigned int pcm_chans_n;	unsigned int pcm_chans_n;
711	805

...	...	static void pcm2ff(snd_pcm_t pcm, enum AVSampleFormat ff_fmt,
718	812	r = snd_pcm_hw_params_get_access(hw_params, &pcm_access);	r = snd_pcm_hw_params_get_access(hw_params, &pcm_access);
719	813	if (r < 0)	if (r < 0)
720	814	fatal("alsa:unable to get the pcm access for ffmpeg filter wiring\n");	fatal("alsa:unable to get the pcm access for ffmpeg filter wiring\n");
721		r = snd_pcm_hw_params_get_format(hw_params, &pcm_fmt);
	815		r = snd_pcm_hw_params_get_fmt(hw_params, &pcm_fmt);
722	816	if (r < 0)	if (r < 0)
723	817	fatal("alsa:unable to get the pcm format for ffmpeg filter wiring\n");	fatal("alsa:unable to get the pcm format for ffmpeg filter wiring\n");
724	818	/--------------------------------------------------------------------/	/--------------------------------------------------------------------/
725	819	pcm_layout2ff_fmt_strict(pcm_fmt, pcm_access, ff_fmt, print_info);	pcm_layout2ff_fmt_strict(pcm_fmt, pcm_access, ff_fmt, print_info);
726	820	/--------------------------------------------------------------------/	/--------------------------------------------------------------------/
727	821	r = snd_pcm_hw_params_get_rate(hw_params, &pcm_rate,	r = snd_pcm_hw_params_get_rate(hw_params, &pcm_rate,
728		SND_PCM_STREAM_PLAYBACK);
	822		SND_PCM_ST_PLAYBACK);
729	823	if (r < 0)	if (r < 0)
730	824	fatal("alsa:unable to get the pcm rate for ffmpeg filter wiring\n");	fatal("alsa:unable to get the pcm rate for ffmpeg filter wiring\n");
731	825	*ff_rate = (int)pcm_rate;	*ff_rate = (int)pcm_rate;
732		r = snd_pcm_hw_params_get_channels(hw_params, &pcm_chans_n);
	826		r = snd_pcm_hw_params_get_chans(hw_params, &pcm_chans_n);
733	827	if (r < 0)	if (r < 0)
734	828	fatal("alsa:unable to get the pcm count of channels for ffmpeg filter wiring\n");	fatal("alsa:unable to get the pcm count of channels for ffmpeg filter wiring\n");
735	829	*ff_chans_n = (int)pcm_chans_n;	*ff_chans_n = (int)pcm_chans_n;

...	...	static void pcm2ff(snd_pcm_t pcm, enum AVSampleFormat ff_fmt,
739	833	/--------------------------------------------------------------------/	/--------------------------------------------------------------------/
740	834	snd_pcm_hw_params_free(hw_params);	snd_pcm_hw_params_free(hw_params);
741	835	}	}
742		static void abufsrc_cfg(enum AVFrameFormat fmt, int rate, int chans_n,
	836		/* XXX: we don't program the tb of the filter since it should not be used */
	837		static void abufsrc_cfg(enum av_fr_fmt fmt, int rate, int chans_n,
743	838	uint64_t chans_layout, bool print_info)	uint64_t chans_layout, bool print_info)
744	839	{	{
745	840	int r;	int r;
746		AVRational tb;
747	841	u8 chans_layout_str[STR_SZ]; /* should be overkill */	u8 chans_layout_str[STR_SZ]; /* should be overkill */
748	842
749		abufsrc_filt = avfilter_get_by_name("abuffer");
	843		abufsrc_filt = av_filt_get_by_name("abuffer");
750	844	if (abufsrc_filt == 0)	if (abufsrc_filt == 0)
751	845	fatal("audio buffer source:could not find the filter\n");	fatal("audio buffer source:could not find the filter\n");
752		abufsrc_ctx = avfilter_graph_alloc_filter(filter_graph, abufsrc_filt,
	846		abufsrc_ctx = av_filt_graph_alloc_filt(filt_graph, abufsrc_filt,
753	847	"src_abuf");	"src_abuf");
754	848	if (abufsrc_ctx == 0)	if (abufsrc_ctx == 0)
755	849	fatal("audio buffer source context:could not allocate the instance in the filter graph\n");	fatal("audio buffer source context:could not allocate the instance in the filter graph\n");
756		r = av_opt_set(abufsrc_ctx, "sample_fmt", av_get_frame_fmt_name(fmt),
	850		r = av_opt_set(abufsrc_ctx, "sample_fmt", av_get_fr_fmt_name(fmt),
757	851	AV_OPT_SEARCH_CHILDREN);	AV_OPT_SEARCH_CHILDREN);
758	852	if (r < 0)	if (r < 0)
759	853	fatal("audio buffer source context:unable to set the decoder frame format option\n");	fatal("audio buffer source context:unable to set the decoder frame format option\n");

...	...	static void abufsrc_cfg(enum AVFrameFormat fmt, int rate, int chans_n,
761	855	AV_OPT_SEARCH_CHILDREN);	AV_OPT_SEARCH_CHILDREN);
762	856	if (r < 0)	if (r < 0)
763	857	fatal("audio buffer source context:unable to set the decoder rate option\n");	fatal("audio buffer source context:unable to set the decoder rate option\n");
764		av_get_channel_layout_string(chans_layout_str, sizeof(chans_layout_str),
	858		av_get_chan_layout_str(chans_layout_str, sizeof(chans_layout_str),
765	859	chans_n, chans_layout);	chans_n, chans_layout);
766	860	if (print_info)	if (print_info)
767	861	pout("audio buffer source context:using channels layout \"%s\" (%d pcm channels)\n", chans_layout_str, chans_n);	pout("audio buffer source context:using channels layout \"%s\" (%d pcm channels)\n", chans_layout_str, chans_n);

...	...	static void abufsrc_cfg(enum AVFrameFormat fmt, int rate, int chans_n,
769	863	AV_OPT_SEARCH_CHILDREN);	AV_OPT_SEARCH_CHILDREN);
770	864	if (r < 0)	if (r < 0)
771	865	fatal("audio buffer source context:unable to set the decoder channel layout option\n");	fatal("audio buffer source context:unable to set the decoder channel layout option\n");
772		r = avfilter_init_str(abufsrc_ctx, 0);
	866		r = av_filt_init_str(abufsrc_ctx, 0);
773	867	if (r < 0)	if (r < 0)
774	868	fatal("audio buffer source context:unable to initialize\n");	fatal("audio buffer source context:unable to initialize\n");
775	869	}	}

...	...	static void vol_cfg(bool muted, double vol)
779	873	u8 vol_l10n_str[sizeof("xxx.xx")]; /* should be overkill */	u8 vol_l10n_str[sizeof("xxx.xx")]; /* should be overkill */
780	874	int r;	int r;
781	875
782		vol_filt = avfilter_get_by_name("volume");
	876		vol_filt = av_filt_get_by_name("volume");
783	877	if (vol_filt == 0)	if (vol_filt == 0)
784	878	fatal("volume:could not find the filter\n");	fatal("volume:could not find the filter\n");
785		vol_ctx = avfilter_graph_alloc_filter(filter_graph, vol_filt, "vol");
	879		vol_ctx = av_filt_graph_alloc_filt(filt_graph, vol_filt, "vol");
786	880	if (vol_ctx == 0)	if (vol_ctx == 0)
787	881	fatal("volume context:could not allocate the instance in the filter graph\n");	fatal("volume context:could not allocate the instance in the filter graph\n");
788	882	if (muted)	if (muted)

...	...	static void vol_cfg(bool muted, double vol)
794	888	r = av_opt_set(vol_ctx, "volume", vol_l10n_str, AV_OPT_SEARCH_CHILDREN);	r = av_opt_set(vol_ctx, "volume", vol_l10n_str, AV_OPT_SEARCH_CHILDREN);
795	889	if (r < 0)	if (r < 0)
796	890	fatal("volume context:unable to set the volume option\n");	fatal("volume context:unable to set the volume option\n");
797		r = avfilter_init_str(vol_ctx, 0);
	891		r = av_filt_init_str(vol_ctx, 0);
798	892	if (r < 0)	if (r < 0)
799	893	fatal("volume buffer context:unable to initialize\n");	fatal("volume buffer context:unable to initialize\n");
800	894	}	}
801		static void afmt_cfg(enum AVFrameFormat fmt, int rate, int chans_n,
	895		static void afmt_cfg(enum av_fr_fmt fmt, int rate, int chans_n,
802	896	uint64_t chans_layout, bool print_info)	uint64_t chans_layout, bool print_info)
803	897	{	{
804	898	int r;	int r;
805	899	u8 rate_str[sizeof("dddddd")];	u8 rate_str[sizeof("dddddd")];
806	900	u8 chans_layout_str[STR_SZ]; /* should be overkill */	u8 chans_layout_str[STR_SZ]; /* should be overkill */
807	901
808		afmt_filt = avfilter_get_by_name("aformat");
	902		afmt_filt = av_filt_get_by_name("aformat");
809	903	if (afmt_filt == 0)	if (afmt_filt == 0)
810	904	fatal("audio format:could not find the filter");	fatal("audio format:could not find the filter");
811		afmt_ctx = avfilter_graph_alloc_filter(filter_graph, afmt_filt, "afmt");
	905		afmt_ctx = av_filt_graph_alloc_filt(filt_graph, afmt_filt, "afmt");
812	906	if (afmt_ctx == 0)	if (afmt_ctx == 0)
813	907	fatal("audio format:could not allocate the instance in the filter graph\n");	fatal("audio format:could not allocate the instance in the filter graph\n");
814		r = av_opt_set(afmt_ctx, "sample_fmts", av_get_frame_fmt_name(fmt),
	908		r = av_opt_set(afmt_ctx, "sample_fmts", av_get_fr_fmt_name(fmt),
815	909	AV_OPT_SEARCH_CHILDREN);	AV_OPT_SEARCH_CHILDREN);
816	910	if (r < 0)	if (r < 0)
817	911	fatal("audio format context:could to set the pcm sample format\n");	fatal("audio format context:could to set the pcm sample format\n");

...	...	static void afmt_cfg(enum AVFrameFormat fmt, int rate, int chans_n,
820	914	AV_OPT_SEARCH_CHILDREN);	AV_OPT_SEARCH_CHILDREN);
821	915	if (r < 0)	if (r < 0)
822	916	fatal("audio format context:could not set the pcm rate\n");	fatal("audio format context:could not set the pcm rate\n");
823		av_get_channel_layout_string(chans_layout_str, sizeof(chans_layout_str),
	917		av_get_chan_layout_str(chans_layout_str, sizeof(chans_layout_str),
824	918	chans_n, chans_layout);	chans_n, chans_layout);
825	919	r = av_opt_set(afmt_ctx, "channel_layouts", chans_layout_str,	r = av_opt_set(afmt_ctx, "channel_layouts", chans_layout_str,
826	920	AV_OPT_SEARCH_CHILDREN);	AV_OPT_SEARCH_CHILDREN);

...	...	static void afmt_cfg(enum AVFrameFormat fmt, int rate, int chans_n,
828	922	fatal("audio format context:could not set the layout of channels\n");	fatal("audio format context:could not set the layout of channels\n");
829	923	if (print_info)	if (print_info)
830	924	pout("audio format context:channel layout is \"%s\"\n", chans_layout_str);	pout("audio format context:channel layout is \"%s\"\n", chans_layout_str);
831		r = avfilter_init_str(afmt_ctx, 0);
	925		r = av_filt_init_str(afmt_ctx, 0);
832	926	if (r < 0)	if (r < 0)
833	927	fatal("audio format context:unable to initialize\n");	fatal("audio format context:unable to initialize\n");
834	928	}	}

...	...	static void abufsink_cfg(void)
836	930	{	{
837	931	int r;	int r;
838	932
839		abufsink_filt = avfilter_get_by_name("abuffersink");
	933		abufsink_filt = av_filt_get_by_name("abuffersink");
840	934	if (abufsink_filt == 0)	if (abufsink_filt == 0)
841	935	fatal("audio buffer sink:could not find the filter\n");	fatal("audio buffer sink:could not find the filter\n");
842		abufsink_ctx = avfilter_graph_alloc_filter(filter_graph, abufsink_filt,
	936		abufsink_ctx = av_filt_graph_alloc_filt(filt_graph, abufsink_filt,
843	937	"sink_abuf");	"sink_abuf");
844	938	if (abufsink_ctx == 0)	if (abufsink_ctx == 0)
845	939	fatal("audio buffer sink context:could not allocate the instance in the filter graph\n");	fatal("audio buffer sink context:could not allocate the instance in the filter graph\n");
846		r = avfilter_init_str(abufsink_ctx, 0);
	940		r = av_filt_init_str(abufsink_ctx, 0);
847	941	if (r < 0)	if (r < 0)
848	942	fatal("audio buffer sink context:unable to initialize\n");	fatal("audio buffer sink context:unable to initialize\n");
849	943	}	}

...	...	static void dec_ctx_cfg(AVCodecParameters params)*
868	962	if (r < 0)	if (r < 0)
869	963	fatal("ffmpeg:unable to open the decoder context\n");	fatal("ffmpeg:unable to open the decoder context\n");
870	964	}	}
871		static void filter_graph_cfg(
872		enum AVSampleFormat src_fmt, int src_rate, int src_chans_n,
	965		static void filt_graph_cfg(
	966		enum av_fr_fmt src_fmt, int src_rate, int src_chans_n,
873	967	uint64_t src_chans_layout,	uint64_t src_chans_layout,
874	968	bool muted, double vol,	bool muted, double vol,
875		enum AVSampleFormat dst_fmt, int dst_rate, int dst_chans_n,
	969		enum av_fr_fmt dst_fmt, int dst_rate, int dst_chans_n,
876	970	uint64_t dst_chans_layout, bool print_info)	uint64_t dst_chans_layout, bool print_info)
877	971	{	{
878	972	int r;	int r;
879	973	char *dump_str;	char *dump_str;
880	974
881		avfilter_graph_free(&filter_graph);
	975		av_filt_graph_free(&filt_graph);
882	976
883		filter_graph = avfilter_graph_alloc();
884		if (filter_graph == 0)
	977		filt_graph = av_filt_graph_alloc();
	978		if (filt_graph == 0)
885	979	fatal("unable to create filter graph\n");	fatal("unable to create filter graph\n");
886	980	abufsrc_cfg(src_fmt, src_rate, src_chans_n, src_chans_layout,	abufsrc_cfg(src_fmt, src_rate, src_chans_n, src_chans_layout,
887	981	print_info);	print_info);
	982		/--------------------------------------------------------------------/
	983		abufsrc_key.chans_n = src_chans_n;
	984		abufsrc_key.chans_layout = src_chans_layout;
	985		abufsrc_key.rate = src_rate;
	986		abufsrc_key.fmt = src_fmt;
	987		/--------------------------------------------------------------------/
888	988	vol_cfg(muted, vol);	vol_cfg(muted, vol);
889	989	afmt_cfg(dst_fmt, dst_rate, dst_chans_n, dst_chans_layout, print_info);	afmt_cfg(dst_fmt, dst_rate, dst_chans_n, dst_chans_layout, print_info);
890	990	abufsink_cfg();	abufsink_cfg();
891		r = avfilter_link(abufsrc_ctx, 0, vol_ctx, 0);
	991		r = av_filt_link(abufsrc_ctx, 0, vol_ctx, 0);
892	992	if (r < 0)	if (r < 0)
893	993	fatal("unable to connect the audio buffer source filter to the volume filter\n");	fatal("unable to connect the audio buffer source filter to the volume filter\n");
894		r = avfilter_link(vol_ctx, 0, afmt_ctx, 0);
	994		r = av_filt_link(vol_ctx, 0, afmt_ctx, 0);
895	995	if (r < 0)	if (r < 0)
896	996	fatal("unable to connect the volume filter to the audio format filter\n");	fatal("unable to connect the volume filter to the audio format filter\n");
897		r = avfilter_link(afmt_ctx, 0, abufsink_ctx, 0);
	997		r = av_filt_link(afmt_ctx, 0, abufsink_ctx, 0);
898	998	if (r < 0)	if (r < 0)
899	999	fatal("unable to connect the audio format filter to the audio buffer sink filter\n");	fatal("unable to connect the audio format filter to the audio buffer sink filter\n");
900		r = avfilter_graph_config(filter_graph, 0);
	1000		r = av_filt_graph_cfg(filt_graph, 0);
901	1001	if (r < 0)	if (r < 0)
902	1002	fatal("unable to configure the filter graph\n");	fatal("unable to configure the filter graph\n");
903	1003	/--------------------------------------------------------------------/	/--------------------------------------------------------------------/
904	1004	if (!print_info)	if (!print_info)
905	1005	return;	return;
906		dump_str = avfilter_graph_dump(filter_graph, 0);
	1006		dump_str = av_filt_graph_dump(filt_graph, 0);
907	1007	if (dump_str == 0) {	if (dump_str == 0) {
908	1008	warning("unable to get a filter graph description\n");	warning("unable to get a filter graph description\n");
909	1009	return;	return;

...	...	static void filter_graph_cfg(
916	1016	#define DONT_PRINT_INFO false	#define DONT_PRINT_INFO false
917	1017	static void filt_flush(void)	static void filt_flush(void)
918	1018	{	{
919		enum AVSampleFormat dst_fmt;
	1019		enum av_fr_fmt dst_fmt;
920	1020	int dst_rate;	int dst_rate;
921	1021	int dst_chans_n;	int dst_chans_n;
922	1022	uint64_t src_chans_layout;	uint64_t src_chans_layout;
923	1023	uint64_t dst_chans_layout;	uint64_t dst_chans_layout;
924	1024
925		av_frames_unref(filt_frs.av);
	1025		av_frs_unref(filt_frs.av);
926	1026	filt_frs.pcm_written_ufrs_n = 0;	filt_frs.pcm_written_ufrs_n = 0;
927	1027
928	1028	pcm2ff(pcm_g, &dst_fmt, &dst_rate, &dst_chans_n, &dst_chans_layout,	pcm2ff(pcm_g, &dst_fmt, &dst_rate, &dst_chans_n, &dst_chans_layout,
929	1029	DONT_PRINT_INFO);	DONT_PRINT_INFO);
930	1030	/* the audio dec ctx may not have a valid chans layout */	/* the audio dec ctx may not have a valid chans layout */
931		if (dec_ctx->channel_layout == 0) {
932		src_chans_layout = av_get_default_channel_layout(
933		dec_ctx->channels);
	1031		if (dec_ctx->chans_layout == 0) {
	1032		src_chans_layout = av_get_default_chans_layout(dec_ctx->chans_n);
934	1033	} else	} else
935		src_chans_layout = dec_ctx->channel_layout;
936		filter_graph_cfg(
937		dec_ctx->sample_fmt, dec_ctx->sample_rate,
938		dec_ctx->channels, src_chans_layout,
	1034		src_chans_layout = dec_ctx->chans_layout;
	1035		filt_graph_cfg(
	1036		dec_ctx->fr_fmt, dec_ctx->fr_rate,
	1037		dec_ctx->chans_n, src_chans_layout,
939	1038	filt_frs.muted, filt_frs.vol,	filt_frs.muted, filt_frs.vol,
940	1039	dst_fmt, dst_rate, dst_chans_n, dst_chans_layout,	dst_fmt, dst_rate, dst_chans_n, dst_chans_layout,
941	1040	DONT_PRINT_INFO);	DONT_PRINT_INFO);

...	...	static void dec_fill(void) { loop
1297	1396	/* at start, we must read pkt before we can send one */	/* at start, we must read pkt before we can send one */
1298	1397	if (rd == sd)	if (rd == sd)
1299	1398	break;	break;
1300		r = avcodec_send_packet(dec_ctx, cb.pkts[sd]);
	1399		r = av_sd_pkt(dec_ctx, cb.pkts[sd]);
1301	1400	/* dec is full and the pkt was rejected, or the decoder is in EOF */	/* dec is full and the pkt was rejected, or the decoder is in EOF */
1302	1401	if (r == AVERROR(EAGAIN) \|\| r == AVERROR_EOF)	if (r == AVERROR(EAGAIN) \|\| r == AVERROR_EOF)
1303	1402	break;	break;
1304	1403	else if (r != 0)	else if (r != 0)
1305	1404	fatal("ffmpeg:error while sending the packet to the decoder\n");	fatal("ffmpeg:error while sending the packet to the decoder\n");
1306	1405	/* r == 0 */	/* r == 0 */
1307		av_packet_unref(cb.pkts[sd]);
	1406		av_pkt_unref(cb.pkts[sd]);
1308	1407	next_sd = sd + 1;	next_sd = sd + 1;
1309	1408	atomic_store(&cb.sd, next_sd);	atomic_store(&cb.sd, next_sd);
1310	1409	}}	}}
1311		/*
1312		* return true if we have 1 dec_frs.av, false if no more dec_frs.av
1313		* will come
1314		*/
1315		static bool dec_frs_get(void) { loop
	1410		static void dec_frs_get(void) { loop
1316	1411	{	{
1317	1412	int r;	int r;
1318	1413
1319	1414	dec_fill();	dec_fill();
1320	1415
1321	1416	/* will unref the dec_frs.av bufs for us */	/* will unref the dec_frs.av bufs for us */
1322		r = avcodec_receive_frames(dec_ctx, dec_frs.av);
	1417		r = av_receive_frs(dec_ctx, dec_frs.av);
1323	1418	if (r == AVERROR(EAGAIN))	if (r == AVERROR(EAGAIN))
1324	1419	continue;	continue;
1325	1420	else if (r == 0) {	else if (r == 0) {

...	...	static bool dec_frs_get(void) { loop
1329	1424	dec_frs.most_recent_ts = dec_frs.av->pkt_dts;	dec_frs.most_recent_ts = dec_frs.av->pkt_dts;
1330	1425	else	else
1331	1426	dec_frs.most_recent_ts = dec_frs.av->pkt_dts;	dec_frs.most_recent_ts = dec_frs.av->pkt_dts;
1332		return true; /* "return" the current dec_frs.av */
	1427		dec_frs.pushed_in_filt_graph = false;
	1428		return; /* "return" the current dec_frs.av */
1333	1429	} else if (r == AVERROR_EOF) {	} else if (r == AVERROR_EOF) {
1334	1430	pout("ffmpeg:last decoder frames reached (receiving)\n");	pout("ffmpeg:last decoder frames reached (receiving)\n");
1335		return false;
	1431		loop { /* spinning */
	1432		snd_pcm_state_t state;
	1433
	1434		r = snd_pcm_drain(pcm_g);
	1435		if (r == 0)
	1436		break;
	1437		if (r == -EAGAIN)
	1438		continue;
	1439		/*
	1440		* the pcm state can change asynchronously.
	1441		* _old_ behavior:
	1442		* if the draining was successful, the pcm
	1443		* should be in SETUP state, and in this
	1444		* state, snd_pcm_drain will fail
	1445		* _new and fixed__ behavior:
	1446		* this won't happen because calling
	1447		* snd_pcm_drain while in the SETUP state
	1448		* won't return an error anymore
	1449		*/
	1450		state = snd_pcm_state(pcm_g);
	1451		if (state == SND_PCM_STATE_SETUP)
	1452		break;
	1453		}
	1454		/**********************************************/
	1455		exit_ok("finished playing\n");
	1456		/**********************************************/
1336	1457	}	}
1337	1458	fatal("ffmpeg:error while receiving frames from the decoder\n");	fatal("ffmpeg:error while receiving frames from the decoder\n");
1338	1459	}}	}}
1339		static bool filt_frs_get(void) { loop
	1460		static bool is_recfg_required(av_frs *frs)
	1461		{
	1462		if ( frs->chans_n != abufsrc_key.chans_n
	1463		\|\| frs->chans_layout != abufsrc_key.chans_layout
	1464		\|\| frs->fr_rate != abufsrc_key.rate
	1465		\|\| frs->fmt != abufsrc_key.fmt)
	1466		return true;
	1467		return false;
	1468		}
	1469		#define AGAIN 0
	1470		#define PUSHED 1
	1471		#define FILT_RECFG_REQUIRED 2
	1472		static u8 filt_graph_push_dec_frs(int new_chans_n, uint64_t new_chans_layout,
	1473		int new_fr_rate, enum av_fr_fmt new_fmt)
1340	1474	{	{
1341	1475	int r;	int r;
1342	1476
1343		if (!filt_frs.no_more_dec_frs) {
1344		if(!dec_frs_get()) {
1345		filt_frs.no_more_dec_frs = true;
1346
1347		r = av_buffersrc_add_frame_flags(abufsrc_ctx,
1348		0 , AV_BUFFERSRC_FLAG_PUSH
1349		\| AV_BUFFERSRC_FLAG_KEEP_REF);
1350		if (r < 0)
1351		fatal("ffmpeg:unable to notify the end of data to the filter source audio buffer context\n");
1352		} else {
1353		/*
1354		* the dec_frs bufs will be unref in
1355		* avcodec_receive_frames
1356		*/
1357		r = av_buffersrc_add_frame_flags(abufsrc_ctx,
1358		dec_frs.av, AV_BUFFERSRC_FLAG_PUSH
1359		\| AV_BUFFERSRC_FLAG_KEEP_REF);
1360		if (r < 0)
1361		fatal("ffmpeg:unable to submit the decoder frames to the filter source audio buffer context\n");
1362		}
	1477		if (dec_frs.pushed_in_filt_graph)
	1478		dec_frs_get();
	1479		if (dec_frs.av->chans_layout == 0) /* choose one for the filt */
	1480		dec_frs.av->chans_layout = av_get_default_chans_layout(
	1481		dec_frs.av->chans_n);
	1482		if (is_recfg_required(dec_frs.av)) {
	1483		*new_chans_n = dec_frs.av->chans_n;
	1484		*new_chans_layout = dec_frs.av->chans_layout;
	1485		*new_fr_rate = dec_frs.av->fr_rate;
	1486		*new_fmt = dec_frs.av->fmt;
	1487		return FILT_RECFG_REQUIRED;
1363	1488	}	}
1364		/*
1365		* the last dec_frs should switch the filter in draining mode,
1366		* and filt_frs.av won't matter.
1367		*/
1368		r = av_buffersink_get_frame(abufsink_ctx, filt_frs.av);
1369		if (r == AVERROR(EAGAIN)) {
1370		/*
1371		* won't happen if no more dec frs are available thanks
1372		* to eof propagation along the processing graph, in theory
1373		*/
1374		continue;
1375		} else if (r >= 0) {
	1489		/* the dec_frs.av bufs will be unref in av_receive_frs */
	1490		r = av_bufsrc_add_frs_flags(abufsrc_ctx, dec_frs.av,
	1491		AV_BUFSRC_FLAG_KEEP_REF);
	1492		if (r >= 0) {
	1493		dec_frs.pushed_in_filt_graph = true;
	1494		return PUSHED;
	1495		} else if (r == AVERROR(EAGAIN))
	1496		return AGAIN;
	1497		fatal("ffmpeg:unable to submit a decoder set of frames to the filter source audio buffer context\n");
	1498		}
	1499		#undef AGAIN
	1500		#undef PUSHED
	1501		#undef FILT_RECFG_REQUIRED
	1502		static void filt_frs_get(void)
	1503		{
	1504		int r;
	1505
	1506		r = av_bufsink_get_frs(abufsink_ctx, filt_frs.av);
	1507		if (r >= 0) {
1376	1508	filt_frs.pcm_written_ufrs_n = 0;	filt_frs.pcm_written_ufrs_n = 0;
1377		return true;
1378		} else if (r == AVERROR_EOF) {
1379		pout("ffmpeg:last filter frs reached (getting)\n");
1380		return false;
	1509		return;
1381	1510	}	}
1382		fatal("ffmpeg:error while getting frs from the filter\n");
1383		}}
	1511		fatal("ffmpeg:error while getting frames from the filter\n");
	1512		}
	1513		#define FILT_RECFG_REQUIRED 2
	1514		#define EOF_FILT 2
	1515		#define DRAINING 3
	1516		#define HAVE_FILT_SET 1
	1517		#define PRINT_INFO true
	1518		/* synchronous filtering */
	1519		static void dec_frs_filter(void)
	1520		{
	1521		loop {
	1522		u8 r;
	1523		int new_chans_n;
	1524		uint64_t new_chans_layout;
	1525		int new_fr_rate;
	1526		enum av_fr_fmt new_fmt;
	1527		int dst_chans_n;
	1528		uint64_t dst_chans_layout;
	1529		int dst_rate;
	1530		enum av_fr_fmt dst_fmt;
	1531
	1532		r = filt_graph_push_dec_frs(&new_chans_n, &new_chans_layout,
	1533		&new_fr_rate, &new_fmt);
	1534		if (r != FILT_RECFG_REQUIRED) {
	1535		/* PUSHED \| AGAIN */
	1536		break;
	1537		}
	1538		/* FILT_RECFG_REQUIRED */
	1539		pcm2ff(pcm_g, &dst_fmt, &dst_rate, &dst_chans_n,
	1540		&dst_chans_layout, PRINT_INFO);
	1541		filt_graph_cfg(
	1542		new_fmt, new_fr_rate, new_chans_n, new_chans_layout,
	1543		filt_frs.muted, filt_frs.vol,
	1544		dst_fmt, dst_rate, dst_chans_n, dst_chans_layout,
	1545		PRINT_INFO);
	1546		}
	1547		filt_frs_get();
	1548		}
	1549		#undef FILT_RECFG_REQUIRED
	1550		#undef EOF_FILT
	1551		#undef DRAINING
	1552		#undef HAVE_FILT_SET
	1553		#undef PRINT_INFO
1384	1554	#define NO 0	#define NO 0
1385	1555	static void chans_buf_init(u8 **chans_buf, int start_fr_idx)	static void chans_buf_init(u8 **chans_buf, int start_fr_idx)
1386	1556	{	{
1387	1557	int is_planar_fmt;	int is_planar_fmt;
1388	1558	int sample_bytes_n;	int sample_bytes_n;
1389	1559
1390		sample_bytes_n = av_get_bytes_per_sample(filt_frs.av->format);
	1560		sample_bytes_n = av_get_bytes_per_sample(filt_frs.av->fmt);
1391	1561
1392		is_planar_fmt = av_frame_fmt_is_planar(filt_frs.av->format);
	1562		is_planar_fmt = av_fr_fmt_is_planar(filt_frs.av->fmt);
1393	1563	if (is_planar_fmt == NO) { /* or is pcm interleaved */	if (is_planar_fmt == NO) { /* or is pcm interleaved */
1394	1564	int fr_bytes_n;	int fr_bytes_n;
1395	1565
1396		fr_bytes_n = sample_bytes_n * filt_frs.av->channels;
	1566		fr_bytes_n = sample_bytes_n * filt_frs.av->chans_n;
1397	1567	chans_buf[0] = (u8*)filt_frs.av->data[0] + start_fr_idx	chans_buf[0] = (u8*)filt_frs.av->data[0] + start_fr_idx
1398	1568	* fr_bytes_n;	* fr_bytes_n;
1399		} else { /* ffmpeg planar or pcm noninterleaved */
	1569		} else { /* ff planar or pcm noninterleaved */
1400	1570	int p;	int p;
1401	1571
1402	1572	p = 0;	p = 0;
1403	1573	loop {	loop {
1404		if (p == filt_frs.av->channels)
	1574		if (p == filt_frs.av->chans_n)
1405	1575	break;	break;
1406	1576	chans_buf[p] = (u8*)filt_frs.av->data[p]	chans_buf[p] = (u8*)filt_frs.av->data[p]
1407	1577	+ start_fr_idx * sample_bytes_n;	+ start_fr_idx * sample_bytes_n;

...	...	static void chans_buf_inc(u8 chans_buf, int frs_inc)
1416	1586	int is_planar_fmt;	int is_planar_fmt;
1417	1587	int sample_bytes_n;	int sample_bytes_n;
1418	1588
1419		sample_bytes_n = av_get_bytes_per_sample(filt_frs.av->format);
	1589		sample_bytes_n = av_get_bytes_per_sample(filt_frs.av->fmt);
1420	1590
1421		is_planar_fmt = av_frame_fmt_is_planar(filt_frs.av->format);
	1591		is_planar_fmt = av_fr_fmt_is_planar(filt_frs.av->fmt);
1422	1592	if (is_planar_fmt == NO) { /* or is pcm interleaved */	if (is_planar_fmt == NO) { /* or is pcm interleaved */
1423	1593	int fr_bytes_n;	int fr_bytes_n;
1424	1594
1425		fr_bytes_n = sample_bytes_n * filt_frs.av->channels;
	1595		fr_bytes_n = sample_bytes_n * filt_frs.av->chans_n;
1426	1596	chans_buf[0] += frs_inc * fr_bytes_n;	chans_buf[0] += frs_inc * fr_bytes_n;
1427		} else { /* ffmpeg planar or pcm noninterleaved */
	1597		} else { /* ff planar or pcm noninterleaved */
1428	1598	u8 p;	u8 p;
1429	1599
1430	1600	p = 0;	p = 0;
1431	1601	loop {	loop {
1432		if (p == filt_frs.av->channels)
	1602		if (p == filt_frs.av->chans_n)
1433	1603	break;	break;
1434	1604	chans_buf[p] += frs_inc * sample_bytes_n;	chans_buf[p] += frs_inc * sample_bytes_n;
1435	1605	++p;	++p;

...	...	static void chans_buf_inc(u8 chans_buf, int frs_inc)
1438	1608	}	}
1439	1609	#undef NO	#undef NO
1440	1610	#define NO 0	#define NO 0
1441		static void pcm_silence_frs_write(snd_pcm_uframes_t ufrs_n)
	1611		static void pcm_silence_frs_write(snd_pcm_ufrs_t ufrs_n)
1442	1612	{	{
1443	1613	int is_planar_fmt;	int is_planar_fmt;
1444	1614
1445	1615	if (ufrs_n == 0)	if (ufrs_n == 0)
1446	1616	return;	return;
1447	1617
1448		is_planar_fmt = av_frame_fmt_is_planar(filt_frs.av->format);
	1618		is_planar_fmt = av_fr_fmt_is_planar(filt_frs.av->fmt);
1449	1619	if (is_planar_fmt == NO)	if (is_planar_fmt == NO)
1450	1620	(void)snd_pcm_writei(pcm_g, silence_bufs[0], ufrs_n);	(void)snd_pcm_writei(pcm_g, silence_bufs[0], ufrs_n);
1451	1621	else	else

...	...	static void pcm_silence_frs_write(snd_pcm_uframes_t ufrs_n)
1453	1623	}	}
1454	1624	#undef NO	#undef NO
1455	1625	#define NO 0	#define NO 0
1456		static void pcm_filt_frs_write(snd_pcm_uframes_t ufrs_n) { loop
	1626		static void pcm_filt_frs_write(snd_pcm_ufrs_t ufrs_n) { loop
1457	1627	{	{
1458	1628	u8 chan_buf;	u8 chan_buf;
1459	1629	u8 *chans_buf[AV_NUM_DATA_POINTERS];	u8 *chans_buf[AV_NUM_DATA_POINTERS];
1460		snd_pcm_sframes_t r0;
1461		snd_pcm_uframes_t ufrs_to_write_n;
1462		snd_pcm_uframes_t filt_frs_remaining_ufrs_n; /* for clarity */
	1630		snd_pcm_sfrs_t r0;
	1631		snd_pcm_ufrs_t ufrs_to_write_n;
	1632		snd_pcm_ufrs_t filt_frs_remaining_ufrs_n; /* for clarity */
1463	1633
1464	1634	if (ufrs_n == 0)	if (ufrs_n == 0)
1465	1635	return;	return;
1466
	1636		if (filt_frs.pcm_written_ufrs_n == (snd_pcm_ufrs_t)filt_frs.av->frs_n) {
	1637		av_frs_unref(filt_frs.av);
	1638		dec_frs_filter(); /* synchronous filtering */
	1639		}
1467	1640	/* create the chan buf pointers */	/* create the chan buf pointers */
1468	1641	chans_buf_init(chans_buf, (int)filt_frs.pcm_written_ufrs_n);	chans_buf_init(chans_buf, (int)filt_frs.pcm_written_ufrs_n);
1469
1470		filt_frs_remaining_ufrs_n = (snd_pcm_uframes_t)filt_frs.av->frames_n
	1642		filt_frs_remaining_ufrs_n = (snd_pcm_ufrs_t)filt_frs.av->frs_n
1471	1643	- filt_frs.pcm_written_ufrs_n;	- filt_frs.pcm_written_ufrs_n;
1472	1644	if (filt_frs_remaining_ufrs_n > ufrs_n)	if (filt_frs_remaining_ufrs_n > ufrs_n)
1473	1645	ufrs_to_write_n = ufrs_n;	ufrs_to_write_n = ufrs_n;

...	...	static void pcm_filt_frs_write(snd_pcm_uframes_t ufrs_n) { loop
1476	1648
1477	1649	loop {	loop {
1478	1650	int is_planar_fmt;	int is_planar_fmt;
1479		snd_pcm_uframes_t written_ufrs_n;
	1651		snd_pcm_ufrs_t written_ufrs_n;
1480	1652
1481		is_planar_fmt = av_frame_fmt_is_planar(filt_frs.av->format);
	1653		is_planar_fmt = av_fr_fmt_is_planar(filt_frs.av->fmt);
1482	1654	if (is_planar_fmt == NO)	if (is_planar_fmt == NO)
1483	1655	r0 = snd_pcm_writei(pcm_g, chans_buf[0],	r0 = snd_pcm_writei(pcm_g, chans_buf[0],
1484	1656	ufrs_to_write_n);	ufrs_to_write_n);

...	...	static void pcm_filt_frs_write(snd_pcm_uframes_t ufrs_n) { loop
1502	1674	fatal("alsa:fatal/unhandled error while writing the frames\n");	fatal("alsa:fatal/unhandled error while writing the frames\n");
1503	1675	}	}
1504	1676	/* r0 >= 0 */	/* r0 >= 0 */
1505		written_ufrs_n = (snd_pcm_uframes_t)r0;
	1677		written_ufrs_n = (snd_pcm_ufrs_t)r0;
1506	1678	filt_frs.pcm_written_ufrs_n += written_ufrs_n;	filt_frs.pcm_written_ufrs_n += written_ufrs_n;
1507	1679	ufrs_n -= written_ufrs_n;	ufrs_n -= written_ufrs_n;
1508	1680	ufrs_to_write_n -= written_ufrs_n;	ufrs_to_write_n -= written_ufrs_n;
1509
1510	1681	chans_buf_inc(chans_buf, (int)written_ufrs_n);	chans_buf_inc(chans_buf, (int)written_ufrs_n);
1511
1512	1682	if (ufrs_to_write_n == 0)	if (ufrs_to_write_n == 0)
1513	1683	break;	break;
1514	1684	}	}
1515		if (filt_frs.pcm_written_ufrs_n
1516		== (snd_pcm_uframes_t)filt_frs.av->frames_n) {
1517		av_frame_unref(filt_frs.av);
1518
1519		if (!filt_frs_get()) { /* no more filt frs ? */
1520		loop { /* spinning */
1521		int r1;
1522		snd_pcm_state_t state;
1523
1524		r1 = snd_pcm_drain(pcm_g);
1525		if (r1 == 0)
1526		break;
1527		if (r1 == -EAGAIN)
1528		continue;
1529		/*
1530		* the pcm state can change asynchronously.
1531		* _old_ behavior:
1532		* if the draining was successful, the pcm
1533		* should be in SETUP state, and in this
1534		* state, snd_pcm_drain will fail
1535		* _new and fixed__ behavior:
1536		* this won't happen because calling
1537		* snd_pcm_drain while in the SETUP state
1538		* won't return an error anymore
1539		*/
1540		state = snd_pcm_state(pcm_g);
1541		if (state == SND_PCM_STATE_SETUP)
1542		break;
1543		}
1544		/**********************************************/
1545		exit_ok("finished playing\n");
1546		/**********************************************/
1547		}
1548		}
1549	1685	}}	}}
1550	1686	#undef NO	#undef NO
1551	1687	static void evt_pcm_write(void)	static void evt_pcm_write(void)
1552	1688	{	{
1553		snd_pcm_sframes_t r0;
	1689		snd_pcm_sfrs_t r0;
1554	1690	/* try only 2 times */	/* try only 2 times */
1555	1691	r0 = snd_pcm_avail(pcm_g);	r0 = snd_pcm_avail(pcm_g);
1556	1692	if (r0 < 0) {	if (r0 < 0) {

...	...	static void evt_pcm_write(void)
1571	1707	}	}
1572	1708
1573	1709	if (paused)	if (paused)
1574		pcm_silence_frs_write((snd_pcm_uframes_t)r0);
	1710		pcm_silence_frs_write((snd_pcm_ufrs_t)r0);
1575	1711	else	else
1576		pcm_filt_frs_write((snd_pcm_uframes_t)r0);
	1712		pcm_filt_frs_write((snd_pcm_ufrs_t)r0);
1577	1713	}	}
1578	1714	#define EPOLL_EVTS_N 8 /* why not */	#define EPOLL_EVTS_N 8 /* why not */
1579	1715	static void evts_loop(void)	static void evts_loop(void)

...	...	static void silence_bufs_cfg(snd_pcm_t pcm, bool print_info)*
1628	1764	{	{
1629	1765	int r;	int r;
1630	1766	snd_pcm_hw_params_t *hw_params;	snd_pcm_hw_params_t *hw_params;
1631		snd_pcm_uframes_t buf_ufrs_n;
1632		snd_pcm_format_t fmt;
	1767		snd_pcm_ufrs_t buf_ufrs_n;
	1768		snd_pcm_fmt_t fmt;
1633	1769	snd_pcm_access_t access;	snd_pcm_access_t access;
1634	1770	unsigned int chans_n;	unsigned int chans_n;
1635	1771	u8 c;	u8 c;

...	...	static void silence_bufs_cfg(snd_pcm_t pcm, bool print_info)*
1640	1776	r = snd_pcm_hw_params_current(pcm, hw_params);	r = snd_pcm_hw_params_current(pcm, hw_params);
1641	1777	if (r != 0)	if (r != 0)
1642	1778	fatal("silence:alsa:unable to get the pcm hardware parameters\n");	fatal("silence:alsa:unable to get the pcm hardware parameters\n");
1643		r = snd_pcm_hw_params_get_buffer_size(hw_params, &buf_ufrs_n);
	1779		r = snd_pcm_hw_params_get_buf_size(hw_params, &buf_ufrs_n);
1644	1780	if (r < 0)	if (r < 0)
1645		fatal("silence:alsa:unable to get the number of frames in the pcm buffer\n");
1646		r = snd_pcm_hw_params_get_format(hw_params, &fmt);
	1781		fatal("silence:alsa:unable to get the number of frs in the pcm buffer\n");
	1782		r = snd_pcm_hw_params_get_fmt(hw_params, &fmt);
1647	1783	if (r < 0)	if (r < 0)
1648	1784	fatal("silence:alsa:unable to get the pcm format\n");	fatal("silence:alsa:unable to get the pcm format\n");
1649	1785	r = snd_pcm_hw_params_get_access(hw_params, &access);	r = snd_pcm_hw_params_get_access(hw_params, &access);
1650	1786	if (r < 0)	if (r < 0)
1651	1787	fatal("silence:alsa:unable to get the pcm access mode\n");	fatal("silence:alsa:unable to get the pcm access mode\n");
1652		r = snd_pcm_hw_params_get_channels(hw_params, &chans_n);
	1788		r = snd_pcm_hw_params_get_chans(hw_params, &chans_n);
1653	1789	if (r < 0)	if (r < 0)
1654	1790	fatal("silence:alsa:unable to get the pcm number of channels\n");	fatal("silence:alsa:unable to get the pcm number of channels\n");
1655	1791	/* wipe silence bufs first */	/* wipe silence bufs first */

...	...	static void silence_bufs_cfg(snd_pcm_t pcm, bool print_info)*
1667	1803	\|\| access == SND_PCM_ACCESS_MMAP_INTERLEAVED) {	\|\| access == SND_PCM_ACCESS_MMAP_INTERLEAVED) {
1668	1804	ssize_t buf_bytes_n;	ssize_t buf_bytes_n;
1669	1805
1670		buf_bytes_n = snd_pcm_frames_to_bytes(pcm,
1671		(snd_pcm_sframes_t)buf_ufrs_n);
	1806		buf_bytes_n = snd_pcm_frs_to_bytes(pcm,
	1807		(snd_pcm_sfrs_t)buf_ufrs_n);
1672	1808	if (buf_bytes_n <= 0)	if (buf_bytes_n <= 0)
1673	1809	fatal("silence:alsa:interleaved:unable to get the pcm number of bytes of all buffer frames\n");	fatal("silence:alsa:interleaved:unable to get the pcm number of bytes of all buffer frames\n");
1674	1810	silence_bufs[0] = malloc((size_t)buf_bytes_n);	silence_bufs[0] = malloc((size_t)buf_bytes_n);

...	...	static void silence_bufs_cfg(snd_pcm_t pcm, bool print_info)*
1676	1812	fatal("silence:interleaved:unable to allocate the silence buffer of %d bytes\n", (int)buf_bytes_n);	fatal("silence:interleaved:unable to allocate the silence buffer of %d bytes\n", (int)buf_bytes_n);
1677	1813	if (print_info)	if (print_info)
1678	1814	pout("silence:interleaved:buffer of %d bytes is allocated\n", (int)buf_bytes_n);	pout("silence:interleaved:buffer of %d bytes is allocated\n", (int)buf_bytes_n);
1679		r = snd_pcm_format_set_silence(fmt, silence_bufs[0],
	1815		r = snd_pcm_fmt_set_silence(fmt, silence_bufs[0],
1680	1816	(unsigned int)buf_ufrs_n);	(unsigned int)buf_ufrs_n);
1681	1817	if (r < 0)	if (r < 0)
1682	1818	fatal("silence:interleaved:unable to fill with silence the buffer\n");	fatal("silence:interleaved:unable to fill with silence the buffer\n");

...	...	static void silence_bufs_cfg(snd_pcm_t pcm, bool print_info)*
1697	1833	silence_bufs[c] = malloc((size_t)buf_bytes_n);	silence_bufs[c] = malloc((size_t)buf_bytes_n);
1698	1834	if (silence_bufs[c] == 0)	if (silence_bufs[c] == 0)
1699	1835	fatal("silence:non interleaved:unable to allocate silence buffer %u of %d bytes\n", c, (int)buf_bytes_n);	fatal("silence:non interleaved:unable to allocate silence buffer %u of %d bytes\n", c, (int)buf_bytes_n);
1700		r = snd_pcm_format_set_silence(fmt, silence_bufs[c],
	1836		r = snd_pcm_fmt_set_silence(fmt, silence_bufs[c],
1701	1837	(unsigned int)buf_samples_n);	(unsigned int)buf_samples_n);
1702	1838	if (r < 0)	if (r < 0)
1703	1839	fatal("silence:non interleaved:unable to fill with silence the buffer\n");	fatal("silence:non interleaved:unable to fill with silence the buffer\n");

...	...	static void silence_bufs_cfg(snd_pcm_t pcm, bool print_info)*
1711	1847	fatal("silence:the pcm access type is not supported\n");	fatal("silence:the pcm access type is not supported\n");
1712	1848	snd_pcm_hw_params_free(hw_params);	snd_pcm_hw_params_free(hw_params);
1713	1849	}	}
1714		static void ffmpeg_log_stdout(void a, int b, const char fmt, va_list ap)
	1850		static void ff_log_stdout(void a, int b, const char fmt, va_list ap)
1715	1851	{	{
1716	1852	vprintf(fmt, ap);	vprintf(fmt, ap);
1717	1853	}	}
	1854		struct ff_supported_fr_fmt_t {
	1855		u8 *str;
	1856		enum av_fr_fmt fmt;
	1857		};
	1858		/* this is the intersection of ff audio fr fmt and alsa pcm fmt */
	1859		static struct ff_supported_fr_fmt_t ff_supported_fr_fmts[] = {
	1860		{"u8", AV_FR_FMT_U8},
	1861		{"u8planar", AV_FR_FMT_U8P},
	1862		{"s16", AV_FR_FMT_S16},
	1863		{"s16planar", AV_FR_FMT_S16P},
	1864		{"s32", AV_FR_FMT_S32},
	1865		{"s32planar", AV_FR_FMT_S32P},
	1866		{"float32", AV_FR_FMT_FLT},
	1867		{"float32planar", AV_FR_FMT_FLTP},
	1868		{"float64", AV_FR_FMT_DBL},
	1869		{"float64planar", AV_FR_FMT_DBLP},
	1870		{0,0}
	1871		};
1718	1872	static void usage(void)	static void usage(void)
1719	1873	{	{
	1874		struct ff_supported_fr_fmt_t *fmt;
	1875
1720	1876	pout("\	pout("\
1721		npa [-p alsa pcm] [-v volume(0..100)] [-h] url\n");
	1877		npa [-p alsa pcm] [-v volume(0..100)]\n\
	1878		[-fc override initial ffmpeg count of channels used to approximate the alsa\n\
	1879		pcm configuration]\n\
	1880		[-fr override initial ffmpeg rate(hz) used to approximate the alsa pcm\n\
	1881		configuration]\n\
	1882		[-ff override initial ffmpeg audio frame format used to approximate the alsa\n\
	1883		pcm configuration, see below for a list]\n\
	1884		[-h]\n\
	1885		url\n\
	1886		\n\
	1887		the ffmpeg audio frame formats which intersect alsa pcm audio formats are:\n");
	1888
	1889		fmt = ff_supported_fr_fmts;
	1890		loop {
	1891		if (fmt->str == 0)
	1892		break;
	1893		pout("\t%s\n", fmt->str);
	1894		++fmt;
	1895		}
1722	1896	}	}
1723	1897	static void opts_parse(int argc, u8 args, u8 url, u8 **pcm_str,	static void opts_parse(int argc, u8 args, u8 url, u8 **pcm_str,
1724		double *initial_vol)
	1898		double initial_vol, int override_initial_ff_chans_n,
	1899		int *override_initial_ff_rate,
	1900		enum av_fr_fmt *override_initial_ff_fr_fmt)
1725	1901	{	{
1726	1902	int i;	int i;
1727	1903	int url_idx;	int url_idx;

...	...	static void opts_parse(int argc, u8 args, u8 url, u8 pcm_str,
1748	1924	*initial_vol = (double)vol_ul / 100.0;	*initial_vol = (double)vol_ul / 100.0;
1749	1925	pout("-v:using initial volume %f\n", *initial_vol);	pout("-v:using initial volume %f\n", *initial_vol);
1750	1926	i += 2;	i += 2;
	1927		/------------------------------------------------------------/
	1928		/* ff initial override for alsa pcm cfg -- start */
	1929		} else if (strcmp("-fr", args[i]) == 0) {
	1930		if ((i + 1) == argc) {
	1931		perr("-fr:override initial ffmpeg rate(hz) is missing\n");
	1932		usage();
	1933		exit(1);
	1934		}
	1935		*override_initial_ff_rate = (int)strtol(args[i + 1], 0,
	1936		10);
	1937		pout("-fr:override initial ffmpeg audio rate to %dHz used for alsa pcm configuration\n", *override_initial_ff_rate);
	1938		i += 2;
	1939		} else if (strcmp("-fc", args[i]) == 0) {
	1940		if ((i + 1) == argc) {
	1941		perr("-fc:override initial ffmpeg channel count is missing\n");
	1942		usage();
	1943		exit(1);
	1944		}
	1945		*override_initial_ff_chans_n = (int)strtol(args[i + 1],
	1946		0, 10);
	1947		pout("-fc:override initial ffmpeg count of channels to %d used for alsa pcm configuration\n", *override_initial_ff_chans_n);
	1948		i += 2;
	1949		} else if (strcmp("-ff", args[i]) == 0) {
	1950		struct ff_supported_fr_fmt_t *fmt;
	1951
	1952		if ((i + 1) == argc) {
	1953		perr("-fc:override initial ffmpeg audio frame format is missing\n");
	1954		usage();
	1955		exit(1);
	1956		}
	1957		fmt = ff_supported_fr_fmts;
	1958		loop {
	1959		if (fmt->str == 0) {
	1960		perr("-ff:unknown ffmpeg audio frame format\n");
	1961		usage();
	1962		exit(1);
	1963		}
	1964		if (strcmp(fmt->str, args[i + 1]) == 0) {
	1965		*override_initial_ff_fr_fmt = fmt->fmt;
	1966		break;
	1967		}
	1968		++fmt;
	1969		}
	1970		pout("-ff:override initial ffmpeg audio frame format is %s\n", av_get_fr_fmt_name(*override_initial_ff_fr_fmt));
	1971		i += 2;
	1972		/* ff initial override for alsa pcm cfg -- end */
	1973		/------------------------------------------------------------/
1751	1974	} else if (strcmp("-h", args[i]) == 0) {	} else if (strcmp("-h", args[i]) == 0) {
1752	1975	usage();	usage();
1753	1976	exit(0);	exit(0);

...	...	static void opts_parse(int argc, u8 args, u8 url, u8 pcm_str,
1762	1985	pout("playing ####%s####\n", *url);	pout("playing ####%s####\n", *url);
1763	1986	}	}
1764	1987	#define RESET_DONE 0	#define RESET_DONE 0
	1988		#define DONT_HOLD 0
1765	1989	static void cb_init_once(void)	static void cb_init_once(void)
1766	1990	{	{
1767	1991	u8 i;	u8 i;

...	...	static void cb_init_once(void)
1779	2003	atomic_store(&cb.sd, 0);	atomic_store(&cb.sd, 0);
1780	2004	atomic_store(&cb.st_idx, -1);	atomic_store(&cb.st_idx, -1);
1781	2005	atomic_store(&cb.reset, RESET_DONE);	atomic_store(&cb.reset, RESET_DONE);
	2006		atomic_store(&cb.hold, DONT_HOLD);
1782	2007	}	}
1783	2008	#undef RESET_DONE	#undef RESET_DONE
1784		static void filter_graph_init_once(void)
	2009		#undef DONT_HOLD
	2010		static void filt_graph_init_once(void)
1785	2011	{	{
1786		filter_graph = 0;
	2012		filt_graph = 0;
1787	2013	abufsrc_ctx = 0;	abufsrc_ctx = 0;
1788	2014	abufsrc_filt = 0;	abufsrc_filt = 0;
1789	2015	vol_ctx = 0;	vol_ctx = 0;

...	...	static void filter_graph_init_once(void)
1795	2021	/* floating point strs are localized... */	/* floating point strs are localized... */
1796	2022	snprintf(double_zero_l10n_str, sizeof(double_zero_l10n_str), "%f", 0.);	snprintf(double_zero_l10n_str, sizeof(double_zero_l10n_str), "%f", 0.);
1797	2023	memset(&filt_frs, 0, sizeof(filt_frs));	memset(&filt_frs, 0, sizeof(filt_frs));
1798		filt_frs.av = av_frames_alloc();
	2024		filt_frs.av = av_frs_alloc();
1799	2025	if (filt_frs.av == 0)	if (filt_frs.av == 0)
1800	2026	fatal("ffmpeg:unable to allocate a filtered frames structure\n");	fatal("ffmpeg:unable to allocate a filtered frames structure\n");
	2027		filt_frs.pcm_written_ufrs_n = 0;
1801	2028	}	}
1802	2029	static void dec_init_once(void)	static void dec_init_once(void)
1803	2030	{	{
1804	2031	dec = 0;	dec = 0;
1805	2032	dec_ctx = 0;	dec_ctx = 0;
1806		dec_frs.av = av_frames_alloc();
	2033		dec_frs.av = av_frs_alloc();
1807	2034	if (dec_frs.av == 0)	if (dec_frs.av == 0)
1808	2035	fatal("ffmpeg:unable to allocate a decoded frames structure\n");	fatal("ffmpeg:unable to allocate a decoded frames structure\n");
	2036		dec_frs.pushed_in_filt_graph = true;
1809	2037	dec_frs.most_recent_ts = AV_NOPTS_VALUE;	dec_frs.most_recent_ts = AV_NOPTS_VALUE;
1810	2038	}	}
1811	2039	static void rd_thd_init_once(void)	static void rd_thd_init_once(void)

...	...	static void fmt_init_once(u8 url)*
1819	2047	int r;	int r;
1820	2048
1821	2049	fmt_ctx = 0;	fmt_ctx = 0;
1822		r = avformat_open_input(&fmt_ctx, url, NULL, NULL);
	2050		r = av_fmt_open_input(&fmt_ctx, url, NULL, NULL);
1823	2051	if (r < 0)	if (r < 0)
1824	2052	fatal("ffmpeg:unable to open \"%s\"\n", url);	fatal("ffmpeg:unable to open \"%s\"\n", url);
1825	2053	/* probe beyond the header, if any */	/* probe beyond the header, if any */
1826		r = avformat_find_stream_info(fmt_ctx, 0);
	2054		r = av_fmt_find_st_info(fmt_ctx, 0);
1827	2055	if (r < 0)	if (r < 0)
1828	2056	fatal("ffmpeg:unable to probe \"%s\"\n", url);	fatal("ffmpeg:unable to probe \"%s\"\n", url);
1829	2057	r = pthread_mutex_init(&fmt_ctx_mutex, 0);	r = pthread_mutex_init(&fmt_ctx_mutex, 0);

...	...	static void pcm_init_once(u8 pcm_str)*
1840	2068	r = snd_output_stdio_attach(&pcm_perr, stderr, 0);	r = snd_output_stdio_attach(&pcm_perr, stderr, 0);
1841	2069	if (r < 0)	if (r < 0)
1842	2070	fatal("alsa:unable to attach stderr\n");	fatal("alsa:unable to attach stderr\n");
1843		r = snd_pcm_open(&pcm_g, pcm_str, SND_PCM_STREAM_PLAYBACK,
	2071		r = snd_pcm_open(&pcm_g, pcm_str, SND_PCM_ST_PLAYBACK,
1844	2072	SND_PCM_NONBLOCK);	SND_PCM_NONBLOCK);
1845	2073	if (r < 0) {	if (r < 0) {
1846	2074	if (r == -EAGAIN)	if (r == -EAGAIN)

...	...	static void init_once(u8 url, u8 pcm_str)
1868	2096	stdout_init_once();	stdout_init_once();
1869	2097	input_state_init_once();	input_state_init_once();
1870	2098	cb_init_once();	cb_init_once();
1871		filter_graph_init_once();
	2099		filt_graph_init_once();
1872	2100	silence_bufs_init_once();	silence_bufs_init_once();
1873	2101	dec_init_once();	dec_init_once();
1874	2102	pcm_init_once(pcm_str);	pcm_init_once(pcm_str);

...	...	static int find_best_st(void)
1880	2108	{	{
1881	2109	int r;	int r;
1882	2110
1883		r = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, 0, 0);
	2111		r = av_find_best_st(fmt_ctx, AV_MEDIA_TYPE_AUDIO, -1, -1, 0, 0);
1884	2112	if (r < 0)	if (r < 0)
1885	2113	fatal("ffmpeg:no audio stream found\n");	fatal("ffmpeg:no audio stream found\n");
1886	2114	return r;	return r;

...	...	static void pcm_hw_chans_n_decide(snd_pcm_t pcm,*
1892	2120	unsigned int chans_n_max;	unsigned int chans_n_max;
1893	2121	unsigned int chans_n_min;	unsigned int chans_n_min;
1894	2122
1895		r = snd_pcm_hw_params_test_channels(pcm, pcm_hw_params, chans_n);
	2123		r = snd_pcm_hw_params_test_chans(pcm, pcm_hw_params, chans_n);
1896	2124	if (r == 0) {	if (r == 0) {
1897		r = snd_pcm_hw_params_set_channels(pcm, pcm_hw_params, chans_n);
	2125		r = snd_pcm_hw_params_set_chans(pcm, pcm_hw_params, chans_n);
1898	2126	if (r != 0)	if (r != 0)
1899	2127	fatal("alsa:unable to restrict pcm device to %u channels, count which was successfully tested\n", chans_n);	fatal("alsa:unable to restrict pcm device to %u channels, count which was successfully tested\n", chans_n);
1900	2128	pout("alsa:using %u channels\n", chans_n);	pout("alsa:using %u channels\n", chans_n);

...	...	static void pcm_hw_chans_n_decide(snd_pcm_t pcm,*
1902	2130	}	}
1903	2131	pout("alsa:unable to use %u channels\n", chans_n);	pout("alsa:unable to use %u channels\n", chans_n);
1904	2132	/* try to use the max chans n the pcm can */	/* try to use the max chans n the pcm can */
1905		r = snd_pcm_hw_params_get_channels_max(pcm_hw_params, &chans_n_max);
	2133		r = snd_pcm_hw_params_get_chans_max(pcm_hw_params, &chans_n_max);
1906	2134	if (r != 0)	if (r != 0)
1907	2135	fatal("alsa:unable to get the maximum count of pcm device channels\n");	fatal("alsa:unable to get the maximum count of pcm device channels\n");
1908		r = snd_pcm_hw_params_test_channels(pcm, pcm_hw_params, chans_n_max);
	2136		r = snd_pcm_hw_params_test_chans(pcm, pcm_hw_params, chans_n_max);
1909	2137	if (r == 0) {	if (r == 0) {
1910		r = snd_pcm_hw_params_set_channels(pcm, pcm_hw_params,
	2138		r = snd_pcm_hw_params_set_chans(pcm, pcm_hw_params,
1911	2139	chans_n_max);	chans_n_max);
1912	2140	if (r != 0)	if (r != 0)
1913	2141	fatal("alsa:unable to restrict pcm device to %u channels, count which was successfully tested\n", chans_n_max);	fatal("alsa:unable to restrict pcm device to %u channels, count which was successfully tested\n", chans_n_max);

...	...	static void pcm_hw_chans_n_decide(snd_pcm_t pcm,*
1915	2143	return;	return;
1916	2144	}	}
1917	2145	/* ok... last try, the pcm dev min chans n */	/* ok... last try, the pcm dev min chans n */
1918		r = snd_pcm_hw_params_get_channels_min(pcm_hw_params, &chans_n_min);
	2146		r = snd_pcm_hw_params_get_chans_min(pcm_hw_params, &chans_n_min);
1919	2147	if (r != 0)	if (r != 0)
1920	2148	fatal("alsa:unable to get the minimum count of pcm device channels\n");	fatal("alsa:unable to get the minimum count of pcm device channels\n");
1921		r = snd_pcm_hw_params_test_channels(pcm, pcm_hw_params, chans_n_min);
	2149		r = snd_pcm_hw_params_test_chans(pcm, pcm_hw_params, chans_n_min);
1922	2150	if (r == 0) {	if (r == 0) {
1923		r = snd_pcm_hw_params_set_channels(pcm, pcm_hw_params,
	2151		r = snd_pcm_hw_params_set_chans(pcm, pcm_hw_params,
1924	2152	chans_n_min);	chans_n_min);
1925	2153	if (r != 0)	if (r != 0)
1926	2154	fatal("alsa:unable to restrict pcm device to %u channels, count which was successfully tested\n", chans_n_min);	fatal("alsa:unable to restrict pcm device to %u channels, count which was successfully tested\n", chans_n_min);

...	...	static void pcm_hw_rate_decide(snd_pcm_t pcm,*
1938	2166	unsigned int rate_min;	unsigned int rate_min;
1939	2167
1940	2168	r = snd_pcm_hw_params_test_rate(pcm, pcm_hw_params, rate,	r = snd_pcm_hw_params_test_rate(pcm, pcm_hw_params, rate,
1941		SND_PCM_STREAM_PLAYBACK);
	2169		SND_PCM_ST_PLAYBACK);
1942	2170	if (r == 0) {	if (r == 0) {
1943	2171	r = snd_pcm_hw_params_set_rate(pcm, pcm_hw_params, rate,	r = snd_pcm_hw_params_set_rate(pcm, pcm_hw_params, rate,
1944		SND_PCM_STREAM_PLAYBACK);
	2172		SND_PCM_ST_PLAYBACK);
1945	2173	if (r != 0)	if (r != 0)
1946	2174	fatal("alsa:unable to restrict pcm device to %uHz, which was successfully tested\n", rate);	fatal("alsa:unable to restrict pcm device to %uHz, which was successfully tested\n", rate);
1947	2175	pout("alsa:using %uHz\n", rate);	pout("alsa:using %uHz\n", rate);

...	...	static void pcm_hw_rate_decide(snd_pcm_t pcm,*
1950	2178	pout("alsa:unable to use %uHz\n", rate);	pout("alsa:unable to use %uHz\n", rate);
1951	2179	/* try to use the max rate the pcm can */	/* try to use the max rate the pcm can */
1952	2180	r = snd_pcm_hw_params_get_rate_max(pcm_hw_params, &rate_max,	r = snd_pcm_hw_params_get_rate_max(pcm_hw_params, &rate_max,
1953		SND_PCM_STREAM_PLAYBACK);
	2181		SND_PCM_ST_PLAYBACK);
1954	2182	if (r != 0)	if (r != 0)
1955	2183	fatal("alsa:unable to get the maximum rate of pcm device\n");	fatal("alsa:unable to get the maximum rate of pcm device\n");
1956	2184	r = snd_pcm_hw_params_test_rate(pcm, pcm_hw_params, rate_max,	r = snd_pcm_hw_params_test_rate(pcm, pcm_hw_params, rate_max,
1957		SND_PCM_STREAM_PLAYBACK);
	2185		SND_PCM_ST_PLAYBACK);
1958	2186	if (r == 0) {	if (r == 0) {
1959	2187	r = snd_pcm_hw_params_set_rate(pcm, pcm_hw_params, rate_max,	r = snd_pcm_hw_params_set_rate(pcm, pcm_hw_params, rate_max,
1960		SND_PCM_STREAM_PLAYBACK);
	2188		SND_PCM_ST_PLAYBACK);
1961	2189	if (r != 0)	if (r != 0)
1962	2190	fatal("alsa:unable to restrict pcm device to %uHz, which was successfully tested\n", rate_max);	fatal("alsa:unable to restrict pcm device to %uHz, which was successfully tested\n", rate_max);
1963	2191	pout("alsa:using pcm device %uHz\n", rate_max);	pout("alsa:using pcm device %uHz\n", rate_max);

...	...	static void pcm_hw_rate_decide(snd_pcm_t pcm,*
1966	2194	/* try to use a rate "near" of what the pcm dev can */	/* try to use a rate "near" of what the pcm dev can */
1967	2195	rate_near = rate;	rate_near = rate;
1968	2196	r = snd_pcm_hw_params_set_rate_near(pcm, pcm_hw_params, &rate_near,	r = snd_pcm_hw_params_set_rate_near(pcm, pcm_hw_params, &rate_near,
1969		SND_PCM_STREAM_PLAYBACK);
	2197		SND_PCM_ST_PLAYBACK);
1970	2198	if (r == 0) {	if (r == 0) {
1971	2199	pout("alsa:using pcm device %uHz\n", rate_near);	pout("alsa:using pcm device %uHz\n", rate_near);
1972	2200	return;	return;
1973	2201	}	}
1974	2202	/* even a "near" rate did failed... try the min */	/* even a "near" rate did failed... try the min */
1975	2203	r = snd_pcm_hw_params_get_rate_min(pcm_hw_params, &rate_min,	r = snd_pcm_hw_params_get_rate_min(pcm_hw_params, &rate_min,
1976		SND_PCM_STREAM_PLAYBACK);
	2204		SND_PCM_ST_PLAYBACK);
1977	2205	if (r != 0)	if (r != 0)
1978	2206	fatal("alsa:unable to get the minimum rate of pcm device\n");	fatal("alsa:unable to get the minimum rate of pcm device\n");
1979	2207	r = snd_pcm_hw_params_test_rate(pcm, pcm_hw_params, rate_min,	r = snd_pcm_hw_params_test_rate(pcm, pcm_hw_params, rate_min,
1980		SND_PCM_STREAM_PLAYBACK);
	2208		SND_PCM_ST_PLAYBACK);
1981	2209	if (r == 0) {	if (r == 0) {
1982	2210	r = snd_pcm_hw_params_set_rate(pcm, pcm_hw_params, rate_min,	r = snd_pcm_hw_params_set_rate(pcm, pcm_hw_params, rate_min,
1983		SND_PCM_STREAM_PLAYBACK);
	2211		SND_PCM_ST_PLAYBACK);
1984	2212	if (r != 0)	if (r != 0)
1985	2213	fatal("alsa:unable to restrict pcm device to %uHz, which was successfully tested\n", rate_min);	fatal("alsa:unable to restrict pcm device to %uHz, which was successfully tested\n", rate_min);
1986	2214	pout("alsa:using pcm device %uHz\n", rate_min);	pout("alsa:using pcm device %uHz\n", rate_min);

...	...	static void pcm_hw_rate_decide(snd_pcm_t pcm,*
1988	2216	}	}
1989	2217	fatal("alsa:unable to find a suitable rate\n");	fatal("alsa:unable to find a suitable rate\n");
1990	2218	}	}
1991		static bool ff_fmt2pcm_layout_best_effort(enum AVSampleFormat ff_fmt,
1992		snd_pcm_format_t alsa_fmt, snd_pcm_access_t alsa_access)
	2219		static bool ff_fmt2pcm_layout_best_effort(enum av_fr_fmt ff_fmt,
	2220		snd_pcm_fmt_t alsa_fmt, snd_pcm_access_t alsa_access)
1993	2221	{	{
1994	2222	static u8 ff_fmt_str[STR_SZ];	static u8 ff_fmt_str[STR_SZ];
1995	2223
1996		av_get_sample_fmt_string(ff_fmt_str, STR_SZ, ff_fmt);
	2224		av_get_fr_fmt_str(ff_fmt_str, STR_SZ, ff_fmt);
1997	2225	/* XXX: only classic non-mmap ones */	/* XXX: only classic non-mmap ones */
1998	2226	switch (ff_fmt) {	switch (ff_fmt) {
1999		case AV_SAMPLE_FMT_U8:
2000		*alsa_fmt = SND_PCM_FORMAT_U8;
	2227		case AV_FR_FMT_U8:
	2228		*alsa_fmt = SND_PCM_FMT_U8;
2001	2229	*alsa_access = SND_PCM_ACCESS_RW_INTERLEAVED;	*alsa_access = SND_PCM_ACCESS_RW_INTERLEAVED;
2002	2230	break;	break;
2003		case AV_SAMPLE_FMT_S16:
2004		*alsa_fmt = SND_PCM_FORMAT_S16;
	2231		case AV_FR_FMT_S16:
	2232		*alsa_fmt = SND_PCM_FMT_S16;
2005	2233	*alsa_access = SND_PCM_ACCESS_RW_INTERLEAVED;	*alsa_access = SND_PCM_ACCESS_RW_INTERLEAVED;
2006	2234	break;	break;
2007		case AV_SAMPLE_FMT_S32:
2008		*alsa_fmt = SND_PCM_FORMAT_S32;
	2235		case AV_FR_FMT_S32:
	2236		*alsa_fmt = SND_PCM_FMT_S32;
2009	2237	*alsa_access = SND_PCM_ACCESS_RW_INTERLEAVED;	*alsa_access = SND_PCM_ACCESS_RW_INTERLEAVED;
2010	2238	break;	break;
2011		case AV_SAMPLE_FMT_FLT:
2012		*alsa_fmt = SND_PCM_FORMAT_FLOAT;
	2239		case AV_FR_FMT_FLT:
	2240		*alsa_fmt = SND_PCM_FMT_FLT;
2013	2241	*alsa_access = SND_PCM_ACCESS_RW_INTERLEAVED;	*alsa_access = SND_PCM_ACCESS_RW_INTERLEAVED;
2014	2242	break;	break;
2015	2243	/* ff "planar" fmts are actually non interleaved fmts */	/* ff "planar" fmts are actually non interleaved fmts */
2016		case AV_SAMPLE_FMT_U8P:
2017		*alsa_fmt = SND_PCM_FORMAT_U8;
	2244		case AV_FR_FMT_U8P:
	2245		*alsa_fmt = SND_PCM_FMT_U8;
2018	2246	*alsa_access = SND_PCM_ACCESS_RW_NONINTERLEAVED;	*alsa_access = SND_PCM_ACCESS_RW_NONINTERLEAVED;
2019	2247	break;	break;
2020		case AV_SAMPLE_FMT_S16P:
2021		*alsa_fmt = SND_PCM_FORMAT_S16;
	2248		case AV_FR_FMT_S16P:
	2249		*alsa_fmt = SND_PCM_FMT_S16;
2022	2250	*alsa_access = SND_PCM_ACCESS_RW_NONINTERLEAVED;	*alsa_access = SND_PCM_ACCESS_RW_NONINTERLEAVED;
2023	2251	break;	break;
2024		case AV_SAMPLE_FMT_S32P:
2025		*alsa_fmt = SND_PCM_FORMAT_S32;
	2252		case AV_FR_FMT_S32P:
	2253		*alsa_fmt = SND_PCM_FMT_S32;
2026	2254	*alsa_access = SND_PCM_ACCESS_RW_NONINTERLEAVED;	*alsa_access = SND_PCM_ACCESS_RW_NONINTERLEAVED;
2027	2255	break;	break;
2028		case AV_SAMPLE_FMT_FLTP:
2029		*alsa_fmt = SND_PCM_FORMAT_FLOAT;
	2256		case AV_FR_FMT_FLTP:
	2257		*alsa_fmt = SND_PCM_FMT_FLT;
2030	2258	*alsa_access = SND_PCM_ACCESS_RW_NONINTERLEAVED;	*alsa_access = SND_PCM_ACCESS_RW_NONINTERLEAVED;
2031	2259	break;	break;
2032	2260	default:	default:
2033	2261	pout("best effort:unable to wire ffmpeg sample format \"%sbits\" to alsa sample format, \n,", ff_fmt_str);	pout("best effort:unable to wire ffmpeg sample format \"%sbits\" to alsa sample format, \n,", ff_fmt_str);
2034	2262	return false;	return false;
2035	2263	}	}
2036		pout("best effort:ffmpeg format \"%sbits\" (%u bytes) to alsa layout \"%s\" and access \"%s\"\n", ff_fmt_str, av_get_bytes_per_sample(ff_fmt), snd_pcm_format_description(alsa_fmt), snd_pcm_access_name(alsa_access));
	2264		pout("best effort:ffmpeg format \"%sbits\" (%u bytes) to alsa layout \"%s\" and access \"%s\"\n", ff_fmt_str, av_get_bytes_per_sample(ff_fmt), snd_pcm_fmt_desc(alsa_fmt), snd_pcm_access_name(alsa_access));
2037	2265	return true;	return true;
2038	2266	}	}
2039	2267	static bool pcm_hw_fmt_decide_x(snd_pcm_t *pcm,	static bool pcm_hw_fmt_decide_x(snd_pcm_t *pcm,
2040		snd_pcm_hw_params_t *pcm_hw_params, snd_pcm_format_t fmt)
	2268		snd_pcm_hw_params_t *pcm_hw_params, snd_pcm_fmt_t fmt)
2041	2269	{	{
2042	2270	int r;	int r;
2043	2271
2044		r = snd_pcm_hw_params_test_format(pcm, pcm_hw_params, fmt);
	2272		r = snd_pcm_hw_params_test_fmt(pcm, pcm_hw_params, fmt);
2045	2273	if (r != 0)	if (r != 0)
2046	2274	return false;	return false;
2047		r = snd_pcm_hw_params_set_format(pcm, pcm_hw_params, fmt);
	2275		r = snd_pcm_hw_params_set_fmt(pcm, pcm_hw_params, fmt);
2048	2276	if (r != 0)	if (r != 0)
2049		fatal("alsa:unable to restrict pcm device to \"%s\", which was successfully tested\n", snd_pcm_format_description(fmt));
2050		pout("alsa:using \"%s\" format\n", snd_pcm_format_description(fmt));
	2277		fatal("alsa:unable to restrict pcm device to \"%s\", which was successfully tested\n", snd_pcm_fmt_desc(fmt));
	2278		pout("alsa:using \"%s\" format\n", snd_pcm_fmt_desc(fmt));
2051	2279	return true;	return true;
2052	2280	}	}
2053	2281	#define PCM_HW_FMT_DECIDE_X(fmt) pcm_hw_fmt_decide_x(pcm, pcm_hw_params, fmt)	#define PCM_HW_FMT_DECIDE_X(fmt) pcm_hw_fmt_decide_x(pcm, pcm_hw_params, fmt)
2054	2282	static void pcm_hw_fmt_decide(snd_pcm_t *pcm,	static void pcm_hw_fmt_decide(snd_pcm_t *pcm,
2055	2283	snd_pcm_hw_params_t *pcm_hw_params, bool force,	snd_pcm_hw_params_t *pcm_hw_params, bool force,
2056		snd_pcm_format_t forced_fmt)
	2284		snd_pcm_fmt_t forced_fmt)
2057	2285	{	{
2058	2286	int r;	int r;
2059		snd_pcm_format_t *fmt;
	2287		snd_pcm_fmt_t *fmt;
2060	2288
2061	2289	if (force) {	if (force) {
2062		r = snd_pcm_hw_params_test_format(pcm, pcm_hw_params,
2063		forced_fmt);
	2290		r = snd_pcm_hw_params_test_fmt(pcm, pcm_hw_params, forced_fmt);
2064	2291	if (r == 0) {	if (r == 0) {
2065		r = snd_pcm_hw_params_set_format(pcm, pcm_hw_params,
	2292		r = snd_pcm_hw_params_set_fmt(pcm, pcm_hw_params,
2066	2293	forced_fmt);	forced_fmt);
2067	2294	if (r != 0)	if (r != 0)
2068		fatal("alsa:unable to restrict pcm device to \"%s\", which was successfully tested\n", snd_pcm_format_description(forced_fmt));
2069		pout("alsa:using forced \"%s\" format\n", snd_pcm_format_description(forced_fmt));
	2295		fatal("alsa:unable to restrict pcm device to \"%s\", which was successfully tested\n", snd_pcm_fmt_desc(forced_fmt));
	2296		pout("alsa:using forced \"%s\" format\n", snd_pcm_fmt_desc(forced_fmt));
2070	2297	return;	return;
2071	2298	}	}
2072	2299	}	}
2073	2300	/* then we try to select from the reasonable "best" to the lowest */	/* then we try to select from the reasonable "best" to the lowest */
2074	2301	/* prefer fmts we know supported by ff */	/* prefer fmts we know supported by ff */
2075		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_FLOAT))
	2302		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_FLT))
2076	2303	return;	return;
2077		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_S32))
	2304		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_S32))
2078	2305	return;	return;
2079		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_S16))
	2306		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_S16))
2080	2307	return;	return;
2081		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_U8))
	2308		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_U8))
2082	2309	return;	return;
2083	2310	/*	/*
2084	2311	* from here, at the time of writting, those fmts have no ff	* from here, at the time of writting, those fmts have no ff
2085	2312	* wiring, but we are alsa centric here, validate that later	* wiring, but we are alsa centric here, validate that later
2086	2313	*/	*/
2087		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_U32))
	2314		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_U32))
2088	2315	return;	return;
2089		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_S24))
	2316		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_S24))
2090	2317	return;	return;
2091		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_U24))
	2318		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_U24))
2092	2319	return;	return;
2093		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_U16))
	2320		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_U16))
2094	2321	return;	return;
2095		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FORMAT_S8))
	2322		if (PCM_HW_FMT_DECIDE_X(SND_PCM_FMT_S8))
2096	2323	return;	return;
2097	2324	fatal("alsa:unable to find a suitable format\n");	fatal("alsa:unable to find a suitable format\n");
2098	2325	}	}

...	...	static void pcm_hw_buf_sz_cfg(snd_pcm_t pcm,*
2155	2382	snd_pcm_hw_params_t *pcm_hw_params)	snd_pcm_hw_params_t *pcm_hw_params)
2156	2383	{	{
2157	2384	int r;	int r;
2158		snd_pcm_uframes_t latency_control_target_buf_ufrs_n;
2159		snd_pcm_uframes_t latency_control_buf_ufrs_n;
	2385		snd_pcm_ufrs_t latency_control_target_buf_ufrs_n;
	2386		snd_pcm_ufrs_t latency_control_buf_ufrs_n;
2160	2387	unsigned int rate;	unsigned int rate;
2161	2388
2162	2389	r = snd_pcm_hw_params_get_rate(pcm_hw_params, &rate, 0);	r = snd_pcm_hw_params_get_rate(pcm_hw_params, &rate, 0);

...	...	static void pcm_hw_buf_sz_cfg(snd_pcm_t pcm,*
2164	2391	warning("alsa:latency control:DISABLING LATENCY CONTROL:unable to get the decided rate from the current device parameters\n");	warning("alsa:latency control:DISABLING LATENCY CONTROL:unable to get the decided rate from the current device parameters\n");
2165	2392	return;	return;
2166	2393	}	}
2167		latency_control_target_buf_ufrs_n = (snd_pcm_uframes_t)rate;
	2394		latency_control_target_buf_ufrs_n = (snd_pcm_ufrs_t)rate;
2168	2395	latency_control_target_buf_ufrs_n /= 4;	latency_control_target_buf_ufrs_n /= 4;
2169	2396	latency_control_buf_ufrs_n = latency_control_target_buf_ufrs_n;	latency_control_buf_ufrs_n = latency_control_target_buf_ufrs_n;
2170		r = snd_pcm_hw_params_set_buffer_size_near(pcm, pcm_hw_params,
	2397		r = snd_pcm_hw_params_set_buf_size_near(pcm, pcm_hw_params,
2171	2398	&latency_control_buf_ufrs_n);	&latency_control_buf_ufrs_n);
2172	2399	if (r < 0) {	if (r < 0) {
2173	2400	warning("alsa:latency control:DISABLING_LATENCY_CONTROL:unable to set the audio buffer size (count of frames) to %u periods for the current device parameters\n", latency_control_buf_ufrs_n);	warning("alsa:latency control:DISABLING_LATENCY_CONTROL:unable to set the audio buffer size (count of frames) to %u periods for the current device parameters\n", latency_control_buf_ufrs_n);

...	...	static void pcm_cfg_sw(snd_pcm_t pcm)*
2208	2435	* we try to use a sensible restrict order regarding audio props	* we try to use a sensible restrict order regarding audio props
2209	2436	*/	*/
2210	2437	static void pcm_cfg_hw_core(snd_pcm_t pcm, snd_pcm_hw_params_t pcm_hw_params,	static void pcm_cfg_hw_core(snd_pcm_t pcm, snd_pcm_hw_params_t pcm_hw_params,
2211		int chans_n, int rate, enum AVSampleFormat ff_fmt)
	2438		int chans_n, int rate, enum av_fr_fmt ff_fmt)
2212	2439	{	{
2213	2440	int r;	int r;
2214	2441	bool best_effort_wiring_success;	bool best_effort_wiring_success;
2215		snd_pcm_format_t fmt_from_best_effort;
	2442		snd_pcm_fmt_t fmt_from_best_effort;
2216	2443	snd_pcm_access_t access_from_best_effort;	snd_pcm_access_t access_from_best_effort;
2217	2444
2218	2445	/* the return value is from a first refine of the raw hw params */	/* the return value is from a first refine of the raw hw params */

...	...	static void pcm_cfg_hw_core(snd_pcm_t pcm, snd_pcm_hw_params_t pcm_hw_params,
2231	2458	pcm_hw_buf_sz_cfg(pcm, pcm_hw_params);	pcm_hw_buf_sz_cfg(pcm, pcm_hw_params);
2232	2459	}	}
2233	2460	static void pcm_cfg_hw(snd_pcm_t *pcm, unsigned int chans_n, unsigned int rate,	static void pcm_cfg_hw(snd_pcm_t *pcm, unsigned int chans_n, unsigned int rate,
2234		enum AVSampleFormat ff_fmt)
	2461		enum av_fr_fmt ff_fmt)
2235	2462	{	{
2236	2463	int r;	int r;
2237	2464	snd_pcm_access_t access;	snd_pcm_access_t access;

...	...	static void pcm_cfg_hw(snd_pcm_t pcm, unsigned int chans_n, unsigned int rate,*
2253	2480	pout("ALSA:HW_PARAMS END--------------------------------------------------------------\n");	pout("ALSA:HW_PARAMS END--------------------------------------------------------------\n");
2254	2481	}	}
2255	2482	static void pcm_cfg(snd_pcm_t *pcm, unsigned int chans_n, unsigned int rate,	static void pcm_cfg(snd_pcm_t *pcm, unsigned int chans_n, unsigned int rate,
2256		enum AVSampleFormat ff_fmt)
	2483		enum av_fr_fmt ff_fmt)
2257	2484	{	{
2258	2485	pcm_cfg_hw(pcm, chans_n, rate, ff_fmt);	pcm_cfg_hw(pcm, chans_n, rate, ff_fmt);
2259	2486	pcm_cfg_sw(pcm);	pcm_cfg_sw(pcm);

...	...	static void evt_pcm_install(void)
2281	2508	}	}
2282	2509	pout("alsa:pcm events installed\n");	pout("alsa:pcm events installed\n");
2283	2510	}	}
2284		static void evt_pcm_uninstall(void)
2285		{
2286		u8 i;
2287
2288		i = 0;
2289		loop {
2290		if (i == pcm_pollfds_n)
2291		break;
2292		(void)epoll_ctl(ep_fd, EPOLL_CTL_DEL, pcm_pollfds[i].fd, 0);
2293		++i;
2294		}
2295		pout("alsa:pcm events uninstalled\n");
2296		}
2297	2511	#define PRINT_INFO true	#define PRINT_INFO true
2298		static void play(int st_idx, double initial_vol, bool do_rd_thd_reset)
2299		{
2300		enum AVSampleFormat dst_fmt;
	2512		#define CHANS_N_NOT_OVERRIDDEN 0
	2513		#define RATE_NOT_OVERRIDDEN 0
	2514		#define FR_FMT_NOT_OVERRIDDEN AV_FR_FMT_NONE
	2515		static void prepare(int st_idx, double initial_vol,
	2516		int override_initial_ff_chans_n, int override_initial_ff_rate,
	2517		enum av_fr_fmt override_initial_ff_audio_fr_fmt)
	2518		{
	2519		enum av_fr_fmt dst_fmt;
2301	2520	int dst_rate;	int dst_rate;
2302	2521	int dst_chans_n;	int dst_chans_n;
2303	2522	uint64_t src_chans_layout;	uint64_t src_chans_layout;
2304	2523	uint64_t dst_chans_layout;	uint64_t dst_chans_layout;
	2524		int initial_ff_chans_n;
	2525		int initial_ff_rate;
	2526		enum av_fr_fmt initial_ff_audio_fr_fmt;
2305	2527
2306	2528	current_st_idx = st_idx;	current_st_idx = st_idx;
2307		/* XXX: reset will flush all pkts dmuxed by the the rd thd until now */
2308		if (do_rd_thd_reset)
2309		rd_thd_reset(st_idx);
2310	2529	fmt_ctx_lock();	fmt_ctx_lock();
2311		dec_ctx_cfg(fmt_ctx->streams[st_idx]->codecpar);
2312		dec_frs.most_recent_ts = fmt_ctx->streams[st_idx]->start_time;
	2530		dec_ctx_cfg(fmt_ctx->sts[st_idx]->codecpar);
	2531		dec_frs.most_recent_ts = fmt_ctx->sts[st_idx]->start_time;
2313	2532	cmd_info_data.fmt.duration = fmt_ctx->duration;	cmd_info_data.fmt.duration = fmt_ctx->duration;
2314	2533	cmd_info_data.fmt.m = fmt_ctx->duration_estimation_method;	cmd_info_data.fmt.m = fmt_ctx->duration_estimation_method;
2315		cmd_info_data.st.tb = fmt_ctx->streams[st_idx]->time_base;
2316		cmd_info_data.st.id = fmt_ctx->streams[st_idx]->id;
2317		cmd_info_data.st.duration = fmt_ctx->streams[st_idx]->duration;
	2534		cmd_info_data.st.tb = fmt_ctx->sts[st_idx]->tb;
	2535		cmd_info_data.st.id = fmt_ctx->sts[st_idx]->id;
	2536		cmd_info_data.st.duration = fmt_ctx->sts[st_idx]->duration;
2318	2537	fmt_ctx_unlock();	fmt_ctx_unlock();
2319	2538
2320		evt_pcm_uninstall();
2321		/*
2322		* do our best to match the pcm cfg to audio ff dec output, BUT we don't
2323		* expect to match it "exactly": see right below why
2324		*/
2325		pcm_cfg(pcm_g, dec_ctx->channels, dec_ctx->sample_rate,
2326		dec_ctx->sample_fmt);
2327		evt_pcm_install();
2328		/* use a ff filt to fill in the gap between the pcm and audio ff dec */
2329		pcm2ff(pcm_g, &dst_fmt, &dst_rate, &dst_chans_n,
2330		&dst_chans_layout, PRINT_INFO);
2331		/* the audio dec ctx may not have a valid chans layout */
2332		if (dec_ctx->channel_layout == 0) {
2333		src_chans_layout = av_get_default_channel_layout(
2334		dec_ctx->channels);
2335		} else
2336		src_chans_layout = dec_ctx->channel_layout;
2337		filter_graph_cfg(
2338		dec_ctx->sample_fmt, dec_ctx->sample_rate,
2339		dec_ctx->channels, src_chans_layout,
2340		false, initial_vol,
2341		dst_fmt, dst_rate, dst_chans_n, dst_chans_layout,
2342		PRINT_INFO);
	2539		if (override_initial_ff_chans_n == CHANS_N_NOT_OVERRIDDEN)
	2540		initial_ff_chans_n = dec_ctx->chans_n;
	2541		else
	2542		initial_ff_chans_n = override_initial_ff_chans_n;
	2543		if (override_initial_ff_rate == RATE_NOT_OVERRIDDEN)
	2544		initial_ff_rate = dec_ctx->fr_rate;
	2545		else
	2546		initial_ff_rate = override_initial_ff_rate;
	2547		if (override_initial_ff_audio_fr_fmt == FR_FMT_NOT_OVERRIDDEN)
	2548		initial_ff_audio_fr_fmt = dec_ctx->fr_fmt;
	2549		else
	2550		initial_ff_audio_fr_fmt = override_initial_ff_audio_fr_fmt;
	2551		/* best effort configuration of the pcm based on initial ff params */
	2552		pcm_cfg(pcm_g, initial_ff_chans_n, initial_ff_rate,
	2553		initial_ff_audio_fr_fmt);
2343	2554	silence_bufs_cfg(pcm_g, PRINT_INFO);	silence_bufs_cfg(pcm_g, PRINT_INFO);
	2555		evt_pcm_install();
2344	2556	filt_frs.vol = initial_vol;	filt_frs.vol = initial_vol;
2345	2557	}	}
2346	2558	#undef PRINT_INFO	#undef PRINT_INFO
	2559		#undef CHANS_N_NOT_OVERRIDDEN
	2560		#undef RATE_NOT_OVERRIDDEN
	2561		#undef AUDIO_FR_FMT_NOT_OVERRIDDEN
	2562		#define HOLD 1
	2563		#define DONT_HOLD 0
2347	2564	static void seek_x(int64_t delta)	static void seek_x(int64_t delta)
2348	2565	{	{
2349	2566	int r;	int r;
2350	2567	int64_t new_ts;	int64_t new_ts;
2351		AVStream *st;
2352		AVRational st_tb;
	2568		av_st *st;
	2569		av_rational st_tb;
2353	2570
2354	2571	if (dec_frs.most_recent_ts == AV_NOPTS_VALUE)	if (dec_frs.most_recent_ts == AV_NOPTS_VALUE)
2355	2572	warning("unable to seek because no time stamp are currently available\n");	warning("unable to seek because no time stamp are currently available\n");
2356	2573	fmt_ctx_lock();	fmt_ctx_lock();
2357		st = fmt_ctx->streams[current_st_idx];
2358		st_tb = st->time_base;
	2574		st = fmt_ctx->sts[current_st_idx];
	2575		st_tb = st->tb;
2359	2576	fmt_ctx_unlock();	fmt_ctx_unlock();
2360	2577
2361		new_ts = dec_frs.most_recent_ts + delta * st_tb.den / st_tb.num;
	2578		new_ts = dec_frs.most_recent_ts + delta * (int64_t)st_tb.den
	2579		/ (int64_t)st_tb.num;
2362	2580	/* rewind capping */	/* rewind capping */
2363	2581	pout("trying to seek to %"PRId64" stream time base units\n", new_ts);	pout("trying to seek to %"PRId64" stream time base units\n", new_ts);
	2582
	2583		atomic_store(&cb.hold, HOLD);
	2584		rd_thd_reset(current_st_idx);
2364	2585	fmt_ctx_lock();	fmt_ctx_lock();
2365	2586	r = av_seek_pkt(fmt_ctx, st->id, new_ts, 0);	r = av_seek_pkt(fmt_ctx, st->id, new_ts, 0);
2366	2587	fmt_ctx_unlock();	fmt_ctx_unlock();
2367	2588	if (r < 0)	if (r < 0)
2368	2589	warning("unable to seek to %"PRId64" stream time base units\n", new_ts);	warning("unable to seek to %"PRId64" stream time base units\n", new_ts);
2369	2590	dec_frs.most_recent_ts = AV_NOPTS_VALUE;	dec_frs.most_recent_ts = AV_NOPTS_VALUE;
2370		rd_thd_reset(current_st_idx);
2371		avcodec_flush_buffers(dec_ctx);
2372		filt_frs.no_more_dec_frs = false; /* reset by the previous line */
	2591		av_flush_bufs(dec_ctx);
2373	2592	filt_flush();	filt_flush();
2374		if (!filt_frs_get())
2375		exit_ok("no more audio frames to play\n");
	2593		atomic_store(&cb.hold, DONT_HOLD);
2376	2594	}	}
	2595		#undef HOLD
	2596		#undef DONT_HOLD
2377	2597	static void cmd_rewind(void)	static void cmd_rewind(void)
2378	2598	{	{
2379	2599	pout("COMMAND:rewind\n");	pout("COMMAND:rewind\n");

...	...	static void cmd_vol_up(void)
2417	2637	pout("COMMAND:volume up to value %s(%s)\n", vol_l10n_str, filt_frs.muted ? "muted" : "unmuted");	pout("COMMAND:volume up to value %s(%s)\n", vol_l10n_str, filt_frs.muted ? "muted" : "unmuted");
2418	2638	if (filt_frs.muted)	if (filt_frs.muted)
2419	2639	return;	return;
2420		r = avfilter_graph_send_command(filter_graph, "vol", "volume",
2421		vol_l10n_str, response, sizeof(response), 0);
	2640		r = av_filt_graph_send_cmd(filt_graph, "vol", "volume", vol_l10n_str,
	2641		response, sizeof(response), 0);
2422	2642	if (r < 0)	if (r < 0)
2423	2643	warning("ffmpeg:volume context:unable to set the volume up to \"%s\":response from volume filter:\"%s\"\n", response);	warning("ffmpeg:volume context:unable to set the volume up to \"%s\":response from volume filter:\"%s\"\n", response);
2424	2644	}	}

...	...	static void cmd_vol_down(void)
2435	2655	pout("COMMAND:volume down to value %s(%s)\n", vol_l10n_str, filt_frs.muted ? "muted" : "unmuted");	pout("COMMAND:volume down to value %s(%s)\n", vol_l10n_str, filt_frs.muted ? "muted" : "unmuted");
2436	2656	if (filt_frs.muted)	if (filt_frs.muted)
2437	2657	return;	return;
2438		r = avfilter_graph_send_command(filter_graph, "vol", "volume",
2439		vol_l10n_str, response, sizeof(response), 0);
	2658		r = av_filt_graph_send_cmd(filt_graph, "vol", "volume", vol_l10n_str,
	2659		response, sizeof(response), 0);
2440	2660	if (r < 0)	if (r < 0)
2441	2661	warning("ffmpeg:volume context:unable to set the volume down to \"%s\":response from volume filter:\"%s\"\n", response);	warning("ffmpeg:volume context:unable to set the volume down to \"%s\":response from volume filter:\"%s\"\n", response);
2442	2662	}	}

...	...	static void cmd_mute(void)
2451	2671
2452	2672	snprintf(vol_l10n_str, sizeof(vol_l10n_str), "%f",	snprintf(vol_l10n_str, sizeof(vol_l10n_str), "%f",
2453	2673	filt_frs.vol);	filt_frs.vol);
2454		r = avfilter_graph_send_command(filter_graph, "vol", "volume",
	2674		r = av_filt_graph_send_cmd(filt_graph, "vol", "volume",
2455	2675	vol_l10n_str, response, sizeof(response), 0);	vol_l10n_str, response, sizeof(response), 0);
2456	2676	if (r < 0) {	if (r < 0) {
2457	2677	warning("ffmpeg:volume context:unable to mute the volume to 0:response from volume filter:%s\n", response);	warning("ffmpeg:volume context:unable to mute the volume to 0:response from volume filter:%s\n", response);

...	...	static void cmd_mute(void)
2461	2681	} else {	} else {
2462	2682	pout("COMMAND:muting\n");	pout("COMMAND:muting\n");
2463	2683
2464		r = avfilter_graph_send_command(filter_graph, "vol", "volume",
	2684		r = av_filt_graph_send_cmd(filt_graph, "vol", "volume",
2465	2685	double_zero_l10n_str, response, sizeof(response), 0);	double_zero_l10n_str, response, sizeof(response), 0);
2466	2686	if (r < 0) {	if (r < 0) {
2467	2687	warning("ffmpeg:volume context:unable to mute the volume to 0:response from volume filter:%s\n", response);	warning("ffmpeg:volume context:unable to mute the volume to 0:response from volume filter:%s\n", response);

...	...	static void cmd_mute(void)
2470	2690	}	}
2471	2691	}	}
2472	2692	}	}
2473		#define NO_RD_THD_RESET false
	2693		#define CHANS_N_NOT_OVERRIDDEN 0
	2694		#define RATE_NOT_OVERRIDDEN 0
	2695		#define FR_FMT_NOT_OVERRIDDEN AV_FR_FMT_NONE
2474	2696	int main(int argc, u8 **args)	int main(int argc, u8 **args)
2475	2697	{	{
2476	2698	u8 *url;	u8 *url;
2477	2699	u8 *pcm_str;	u8 *pcm_str;
2478	2700	double initial_vol;	double initial_vol;
2479	2701	int best_st_idx;	int best_st_idx;
	2702		/* audio override -- start */
	2703		/*
	2704		* we could have got direct parameters for alsa, but doing only an
	2705		* override triggers an autoconfiguration of any missing parameters
	2706		* based on initial codec params. In other words, the user is not
	2707		* required to provide all audio params, the code will try to fit the
	2708		* missing ones with the initial codec params, which is the default
	2709		* behavior.
	2710		*/
	2711		int override_initial_ff_chans_n;
	2712		int override_initial_ff_rate;
	2713		enum av_fr_fmt override_initial_ff_audio_fr_fmt;
	2714		/* audio override -- end */
2480	2715	/* "turn on utf8" processing in used libs if any AND locale system */	/* "turn on utf8" processing in used libs if any AND locale system */
2481	2716	setlocale(LC_ALL, "");	setlocale(LC_ALL, "");
2482	2717	/* av_log_set_level(AV_LOG_VERBOSE); */	/* av_log_set_level(AV_LOG_VERBOSE); */
2483	2718	/* av_log_set_level(AV_LOG_DEBUG); */	/* av_log_set_level(AV_LOG_DEBUG); */
2484	2719	url = 0;	url = 0;
	2720		override_initial_ff_chans_n = CHANS_N_NOT_OVERRIDDEN;
	2721		override_initial_ff_rate = RATE_NOT_OVERRIDDEN;
	2722		override_initial_ff_audio_fr_fmt = FR_FMT_NOT_OVERRIDDEN;
2485	2723	pcm_str = "default";	pcm_str = "default";
2486	2724	initial_vol = 1.;	initial_vol = 1.;
2487		opts_parse(argc, args, &url, &pcm_str, &initial_vol);
	2725		opts_parse(argc, args, &url, &pcm_str, &initial_vol,
	2726		&override_initial_ff_chans_n, &override_initial_ff_rate,
	2727		&override_initial_ff_audio_fr_fmt);
2488	2728	init_once(url, pcm_str);	init_once(url, pcm_str);
2489	2729	best_st_idx = find_best_st();	best_st_idx = find_best_st();
2490	2730	rd_thd_start(best_st_idx);	rd_thd_start(best_st_idx);
2491		/* play with reset will flush the already dmuxed pkts */
2492		play(best_st_idx, initial_vol, NO_RD_THD_RESET);
2493		/* switch the ffmpeg log to stdout for metadata/etc dump */
2494		av_log_set_callback(ffmpeg_log_stdout);
	2731		prepare(best_st_idx, initial_vol, override_initial_ff_chans_n,
	2732		override_initial_ff_rate, override_initial_ff_audio_fr_fmt);
	2733		/* switch the ff log to stdout for metadata/etc dump */
	2734		av_log_set_callback(ff_log_stdout);
2495	2735	fmt_ctx_lock();	fmt_ctx_lock();
2496		av_dump_format(fmt_ctx, 0, url, 0);
	2736		av_dump_fmt(fmt_ctx, 0, url, 0);
2497	2737	fmt_ctx_unlock();	fmt_ctx_unlock();
2498	2738	av_log_set_callback(av_log_default_callback);	av_log_set_callback(av_log_default_callback);
2499		if (!filt_frs_get()) /* must have some frames to play */
2500		exit_ok("no initial audio frames to play\n");
2501	2739	loop evts_loop();	loop evts_loop();
2502	2740	/* unreachable */	/* unreachable */
2503	2741	}	}
2504		#undef NO_RD_THD_RESET
	2742		#undef CHANS_N_NOT_OVERRIDDEN
	2743		#undef RATE_NOT_OVERRIDDEN
	2744		#undef AUDIO_FR_FMT_NOT_OVERRIDDEN
2505	2745	/----------------------------------------------------------------------------/	/----------------------------------------------------------------------------/
2506		#undef ARRAY_N
2507		#undef av_frames_alloc
2508		#undef av_frame_fmt_is_planar
2509		#undef av_frames_set_silence
2510		#undef av_frames_unref
2511		#undef av_get_frame_fmt_name
2512		#undef av_get_frame_fmt_string
	2746		/* alsa */
	2747		#undef snd_pcm_fmt_desc
	2748		#undef snd_pcm_fmt_set_silence
	2749		#undef SND_PCM_FMT_FLT
	2750		#undef SND_PCM_FMT_S16
	2751		#undef SND_PCM_FMT_S24
	2752		#undef SND_PCM_FMT_S32
	2753		#undef SND_PCM_FMT_S8
	2754		#undef snd_pcm_fmt_t
	2755		#undef SND_PCM_FMT_U16
	2756		#undef SND_PCM_FMT_U24
	2757		#undef SND_PCM_FMT_U32
	2758		#undef SND_PCM_FMT_U8
	2759		#undef SND_PCM_ST_PLAYBACK
	2760		#undef snd_pcm_frs_to_bytes
	2761		#undef snd_pcm_hw_params_get_chans
	2762		#undef snd_pcm_hw_params_get_chans_max
	2763		#undef snd_pcm_hw_params_get_chans_min
	2764		#undef snd_pcm_hw_params_get_buf_size
	2765		#undef snd_pcm_hw_params_get_fmt
	2766		#undef snd_pcm_hw_params_set_buf_size_near
	2767		#undef snd_pcm_hw_params_set_chans
	2768		#undef snd_pcm_hw_params_set_fmt
	2769		#undef snd_pcm_hw_params_test_chans
	2770		#undef snd_pcm_hw_params_test_fmt
	2771		#undef snd_pcm_sfrs_t
	2772		#undef snd_pcm_ufrs_t
	2773		/----------------------------------------------------------------------------/
	2774		/* ff */
	2775		#undef AV_AUDIO_FR_FMT_NONE
	2776		#undef av_bufsink_get_frs
	2777		#undef av_bufsrc_add_frs_flags
	2778		#undef AV_BUFSRC_FLAG_KEEP_REF
	2779		#undef AV_BUFSRC_FLAG_PUSH
	2780		#undef av_codec
	2781		#undef av_codec_ctx
	2782		#undef av_dump_fmt
	2783		#undef av_duration_estimation_method
	2784		#undef av_filt
	2785		#undef av_filt_ctx
	2786		#undef av_filt_get_by_name
	2787		#undef av_filt_graph
	2788		#undef av_filt_graph_alloc
	2789		#undef av_filt_graph_alloc_filt
	2790		#undef av_filt_graph_cfg
	2791		#undef av_filt_graph_dump
	2792		#undef av_filt_graph_free
	2793		#undef av_filt_graph_send_cmd
	2794		#undef av_filt_init_str
	2795		#undef av_filt_link
	2796		#undef av_find_best_st
	2797		#undef av_flush_bufs
	2798		#undef av_fmt_ctx
	2799		#undef AV_FMT_DURATION_FROM_BITRATE
	2800		#undef AV_FMT_DURATION_FROM_PTS
	2801		#undef AV_FMT_DURATION_FROM_ST
	2802		#undef av_fmt_find_st_info
	2803		#undef av_fmt_flush
	2804		#undef av_fmt_open_input
	2805		#undef av_fr_fmt_is_planar
	2806		#undef AV_FR_FMT_FLT
	2807		#undef AV_FR_FMT_FLTP
	2808		#undef AV_FR_FMT_S16
	2809		#undef AV_FR_FMT_S16P
	2810		#undef AV_FR_FMT_S32
	2811		#undef AV_FR_FMT_S32P
	2812		#undef AV_FR_FMT_U8P
	2813		#undef AV_FR_FMT_U8
	2814		#undef av_frs_alloc
	2815		#undef av_frs_set_silence
	2816		#undef av_frs_unref
	2817		#undef av_get_chan_layout_str
	2818		#undef av_get_default_chans_layout
	2819		#undef av_get_fr_fmt_name
	2820		#undef av_get_fr_fmt_str
	2821		#undef av_io_flush
	2822		#undef AV_MEDIA_TYPE_AUDIO
	2823		#undef av_pkt
	2824		#undef av_pkt_unref
2513	2825	#undef av_read_pkt	#undef av_read_pkt
	2826		#undef av_rational
2514	2827	#undef av_seek_pkt	#undef av_seek_pkt
2515		#undef avcodec_receive_frames
2516		#undef AVFrameFormat
2517		#undef AVFrames
	2828		#undef av_receive_frs
	2829		#undef av_fr_fmt
	2830		#undef av_frs
	2831		#undef av_sd_pkt
	2832		#undef av_st
	2833		#undef chan_layout
	2834		#undef chans_n
	2835		#undef format
	2836		#undef fr_fmt
	2837		#undef fr_rate
	2838		#undef frs_n
	2839		#undef st_idx
	2840		#undef sts
	2841		/----------------------------------------------------------------------------/
	2842		#undef ARRAY_N
2518	2843	#undef esc_seq_sz	#undef esc_seq_sz
2519	2844	#undef f32	#undef f32
2520		#undef frame_fmt
2521		#undef frame_rate
2522		#undef frames_n
2523	2845	#undef INPUT_ESC_SEQ_TIMEOUT_SECS_N	#undef INPUT_ESC_SEQ_TIMEOUT_SECS_N
2524	2846	#undef loop	#undef loop
2525	2847	#undef PCM_POLLFDS_N_MAX	#undef PCM_POLLFDS_N_MAX

Hints:
Before first commit, do not forget to setup your git environment:

git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):

git clone https://rocketgit.com/user/sylware/nyanmp

Clone this repository using ssh (do not forget to upload a key first):

git clone ssh://rocketgit@ssh.rocketgit.com/user/sylware/nyanmp

Clone this repository using git:

git clone git://git.rocketgit.com/user/sylware/nyanmp

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:

... clone the repository ...
... make some changes and some commits ...
git push origin main