10 #include "stream/stream.h"
11 #include "libmpdemux/demuxer.h"
13 #include "codec-cfg.h"
14 #include "libmpdemux/stheader.h"
16 #include "dec_audio.h"
18 #include "libaf/af_format.h"
22 #ifdef CONFIG_DYNAMIC_PLUGINS
26 #ifdef CONFIG_FAKE_MONO
30 /* used for ac3surround decoder - set using -channels option */
31 int audio_output_channels
= 2;
32 af_cfg_t af_cfg
= { 1, NULL
}; // Configuration for audio filters
37 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, MSGTR_AvailableAudioFm
);
38 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AUDIO_DRIVERS\n");
39 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, " afm: info: (comment)\n");
40 for (i
= 0; mpcodecs_ad_drivers
[i
] != NULL
; i
++)
41 if (mpcodecs_ad_drivers
[i
]->info
->comment
42 && mpcodecs_ad_drivers
[i
]->info
->comment
[0])
43 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, "%9s %s (%s)\n",
44 mpcodecs_ad_drivers
[i
]->info
->short_name
,
45 mpcodecs_ad_drivers
[i
]->info
->name
,
46 mpcodecs_ad_drivers
[i
]->info
->comment
);
48 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, "%9s %s\n",
49 mpcodecs_ad_drivers
[i
]->info
->short_name
,
50 mpcodecs_ad_drivers
[i
]->info
->name
);
53 static int init_audio_codec(sh_audio_t
*sh_audio
)
55 if ((af_cfg
.force
& AF_INIT_FORMAT_MASK
) == AF_INIT_FLOAT
) {
56 int fmt
= AF_FORMAT_FLOAT_NE
;
57 if (sh_audio
->ad_driver
->control(sh_audio
, ADCTRL_QUERY_FORMAT
,
58 &fmt
) == CONTROL_TRUE
) {
59 sh_audio
->sample_format
= fmt
;
60 sh_audio
->samplesize
= 4;
63 if (!sh_audio
->ad_driver
->preinit(sh_audio
)) {
64 mp_msg(MSGT_DECAUDIO
, MSGL_ERR
, MSGTR_ADecoderPreinitFailed
);
68 /* allocate audio in buffer: */
69 if (sh_audio
->audio_in_minsize
> 0) {
70 sh_audio
->a_in_buffer_size
= sh_audio
->audio_in_minsize
;
71 mp_msg(MSGT_DECAUDIO
, MSGL_V
, MSGTR_AllocatingBytesForInputBuffer
,
72 sh_audio
->a_in_buffer_size
);
73 sh_audio
->a_in_buffer
= av_mallocz(sh_audio
->a_in_buffer_size
);
74 sh_audio
->a_in_buffer_len
= 0;
77 sh_audio
->a_buffer_size
= sh_audio
->audio_out_minsize
+ MAX_OUTBURST
;
79 mp_msg(MSGT_DECAUDIO
, MSGL_V
, MSGTR_AllocatingBytesForOutputBuffer
,
80 sh_audio
->audio_out_minsize
, MAX_OUTBURST
, sh_audio
->a_buffer_size
);
82 sh_audio
->a_buffer
= av_mallocz(sh_audio
->a_buffer_size
);
83 if (!sh_audio
->a_buffer
) {
84 mp_msg(MSGT_DECAUDIO
, MSGL_ERR
, MSGTR_CantAllocAudioBuf
);
87 sh_audio
->a_buffer_len
= 0;
89 if (!sh_audio
->ad_driver
->init(sh_audio
)) {
90 mp_msg(MSGT_DECAUDIO
, MSGL_WARN
, MSGTR_ADecoderInitFailed
);
91 uninit_audio(sh_audio
); // free buffers
95 sh_audio
->initialized
= 1;
97 if (!sh_audio
->channels
|| !sh_audio
->samplerate
) {
98 mp_msg(MSGT_DECAUDIO
, MSGL_WARN
, MSGTR_UnknownAudio
);
99 uninit_audio(sh_audio
); // free buffers
103 if (!sh_audio
->o_bps
)
104 sh_audio
->o_bps
= sh_audio
->channels
* sh_audio
->samplerate
105 * sh_audio
->samplesize
;
107 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
,
108 "AUDIO: %d Hz, %d ch, %s, %3.1f kbit/%3.2f%% (ratio: %d->%d)\n",
109 sh_audio
->samplerate
, sh_audio
->channels
,
110 af_fmt2str_short(sh_audio
->sample_format
),
111 sh_audio
->i_bps
* 8 * 0.001,
112 ((float) sh_audio
->i_bps
/ sh_audio
->o_bps
) * 100.0,
113 sh_audio
->i_bps
, sh_audio
->o_bps
);
114 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
,
115 "ID_AUDIO_BITRATE=%d\nID_AUDIO_RATE=%d\n" "ID_AUDIO_NCH=%d\n",
116 sh_audio
->i_bps
* 8, sh_audio
->samplerate
, sh_audio
->channels
);
118 sh_audio
->a_out_buffer_size
= 0;
119 sh_audio
->a_out_buffer
= NULL
;
120 sh_audio
->a_out_buffer_len
= 0;
125 static int init_audio(sh_audio_t
*sh_audio
, char *codecname
, char *afm
,
126 int status
, stringset_t
*selected
)
128 unsigned int orig_fourcc
= sh_audio
->wf
? sh_audio
->wf
->wFormatTag
: 0;
130 if (codecname
&& codecname
[0] == '+') {
131 codecname
= &codecname
[1];
134 sh_audio
->codec
= NULL
;
136 ad_functions_t
*mpadec
;
138 sh_audio
->ad_driver
= 0;
139 // restore original fourcc:
141 sh_audio
->wf
->wFormatTag
= i
= orig_fourcc
;
142 if (!(sh_audio
->codec
= find_audio_codec(sh_audio
->format
,
143 sh_audio
->wf
? (&i
) : NULL
,
144 sh_audio
->codec
, force
)))
147 sh_audio
->wf
->wFormatTag
= i
;
148 // ok we found one codec
149 if (stringset_test(selected
, sh_audio
->codec
->name
))
150 continue; // already tried & failed
151 if (codecname
&& strcmp(sh_audio
->codec
->name
, codecname
))
153 if (afm
&& strcmp(sh_audio
->codec
->drv
, afm
))
154 continue; // afm doesn't match
155 if (!force
&& sh_audio
->codec
->status
< status
)
156 continue; // too unstable
157 stringset_add(selected
, sh_audio
->codec
->name
); // tagging it
158 // ok, it matches all rules, let's find the driver!
159 for (i
= 0; mpcodecs_ad_drivers
[i
] != NULL
; i
++)
160 if (!strcmp(mpcodecs_ad_drivers
[i
]->info
->short_name
,
161 sh_audio
->codec
->drv
))
163 mpadec
= mpcodecs_ad_drivers
[i
];
164 #ifdef CONFIG_DYNAMIC_PLUGINS
166 /* try to open shared decoder plugin */
169 ad_functions_t
*funcs_sym
;
173 strlen(MPLAYER_LIBDIR
) + strlen(sh_audio
->codec
->drv
) + 16;
174 buf
= malloc(buf_len
);
177 snprintf(buf
, buf_len
, "%s/mplayer/ad_%s.so", MPLAYER_LIBDIR
,
178 sh_audio
->codec
->drv
);
179 mp_msg(MSGT_DECAUDIO
, MSGL_DBG2
,
180 "Trying to open external plugin: %s\n", buf
);
181 sh_audio
->dec_handle
= dlopen(buf
, RTLD_LAZY
);
182 if (!sh_audio
->dec_handle
)
184 snprintf(buf
, buf_len
, "mpcodecs_ad_%s", sh_audio
->codec
->drv
);
185 funcs_sym
= dlsym(sh_audio
->dec_handle
, buf
);
186 if (!funcs_sym
|| !funcs_sym
->info
|| !funcs_sym
->preinit
187 || !funcs_sym
->init
|| !funcs_sym
->uninit
188 || !funcs_sym
->control
|| !funcs_sym
->decode_audio
)
190 info_sym
= funcs_sym
->info
;
191 if (strcmp(info_sym
->short_name
, sh_audio
->codec
->drv
))
195 mp_msg(MSGT_DECAUDIO
, MSGL_V
,
196 "Using external decoder plugin (%s/mplayer/ad_%s.so)!\n",
197 MPLAYER_LIBDIR
, sh_audio
->codec
->drv
);
200 if (!mpadec
) { // driver not available (==compiled in)
201 mp_msg(MSGT_DECAUDIO
, MSGL_ERR
,
202 MSGTR_AudioCodecFamilyNotAvailableStr
,
203 sh_audio
->codec
->name
, sh_audio
->codec
->drv
);
206 // it's available, let's try to init!
208 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, MSGTR_OpeningAudioDecoder
,
209 mpadec
->info
->short_name
, mpadec
->info
->name
);
210 sh_audio
->ad_driver
= mpadec
;
211 if (!init_audio_codec(sh_audio
)) {
212 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, MSGTR_ADecoderInitFailed
);
213 continue; // try next...
221 int init_best_audio_codec(sh_audio_t
*sh_audio
, char **audio_codec_list
,
222 char **audio_fm_list
)
224 stringset_t selected
;
225 char *ac_l_default
[2] = { "", (char *) NULL
};
227 if (!audio_codec_list
)
228 audio_codec_list
= ac_l_default
;
229 // Go through the codec.conf and find the best codec...
230 sh_audio
->initialized
= 0;
231 stringset_init(&selected
);
232 while (!sh_audio
->initialized
&& *audio_codec_list
) {
233 char *audio_codec
= *(audio_codec_list
++);
234 if (audio_codec
[0]) {
235 if (audio_codec
[0] == '-') {
236 // disable this codec:
237 stringset_add(&selected
, audio_codec
+ 1);
239 // forced codec by name:
240 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, MSGTR_ForcedAudioCodec
,
242 init_audio(sh_audio
, audio_codec
, NULL
, -1, &selected
);
246 // try in stability order: UNTESTED, WORKING, BUGGY.
247 // never try CRASHING.
249 char **fmlist
= audio_fm_list
;
250 // try first the preferred codec families:
251 while (!sh_audio
->initialized
&& *fmlist
) {
252 char *audio_fm
= *(fmlist
++);
253 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, MSGTR_TryForceAudioFmtStr
,
255 for (status
= CODECS_STATUS__MAX
;
256 status
>= CODECS_STATUS__MIN
; --status
)
257 if (init_audio(sh_audio
, NULL
, audio_fm
, status
, &selected
))
261 if (!sh_audio
->initialized
)
262 for (status
= CODECS_STATUS__MAX
; status
>= CODECS_STATUS__MIN
;
264 if (init_audio(sh_audio
, NULL
, NULL
, status
, &selected
))
268 stringset_free(&selected
);
270 if (!sh_audio
->initialized
) {
271 mp_msg(MSGT_DECAUDIO
, MSGL_ERR
, MSGTR_CantFindAudioCodec
,
273 mp_msg(MSGT_DECAUDIO
, MSGL_HINT
, MSGTR_RTFMCodecs
);
277 mp_msg(MSGT_DECAUDIO
, MSGL_INFO
, MSGTR_SelectedAudioCodec
,
278 sh_audio
->codec
->name
, sh_audio
->codec
->drv
, sh_audio
->codec
->info
);
282 void uninit_audio(sh_audio_t
*sh_audio
)
284 if (sh_audio
->afilter
) {
285 mp_msg(MSGT_DECAUDIO
, MSGL_V
, "Uninit audio filters...\n");
286 af_uninit(sh_audio
->afilter
);
287 free(sh_audio
->afilter
);
288 sh_audio
->afilter
= NULL
;
290 if (sh_audio
->initialized
) {
291 mp_msg(MSGT_DECAUDIO
, MSGL_V
, MSGTR_UninitAudioStr
,
292 sh_audio
->codec
->drv
);
293 sh_audio
->ad_driver
->uninit(sh_audio
);
294 #ifdef CONFIG_DYNAMIC_PLUGINS
295 if (sh_audio
->dec_handle
)
296 dlclose(sh_audio
->dec_handle
);
298 sh_audio
->initialized
= 0;
300 free(sh_audio
->a_out_buffer
);
301 sh_audio
->a_out_buffer
= NULL
;
302 sh_audio
->a_out_buffer_size
= 0;
303 av_freep(&sh_audio
->a_buffer
);
304 av_freep(&sh_audio
->a_in_buffer
);
308 int init_audio_filters(sh_audio_t
*sh_audio
, int in_samplerate
,
309 int *out_samplerate
, int *out_channels
, int *out_format
)
311 af_stream_t
*afs
= sh_audio
->afilter
;
313 afs
= malloc(sizeof(af_stream_t
));
314 memset(afs
, 0, sizeof(af_stream_t
));
316 // input format: same as codec's output format:
317 afs
->input
.rate
= in_samplerate
;
318 afs
->input
.nch
= sh_audio
->channels
;
319 afs
->input
.format
= sh_audio
->sample_format
;
320 af_fix_parameters(&(afs
->input
));
322 // output format: same as ao driver's input format (if missing, fallback to input)
323 afs
->output
.rate
= *out_samplerate
;
324 afs
->output
.nch
= *out_channels
;
325 afs
->output
.format
= *out_format
;
326 af_fix_parameters(&(afs
->output
));
329 memcpy(&afs
->cfg
, &af_cfg
, sizeof(af_cfg_t
));
331 mp_msg(MSGT_DECAUDIO
, MSGL_V
, MSGTR_BuildingAudioFilterChain
,
332 afs
->input
.rate
, afs
->input
.nch
,
333 af_fmt2str_short(afs
->input
.format
), afs
->output
.rate
,
334 afs
->output
.nch
, af_fmt2str_short(afs
->output
.format
));
336 // let's autoprobe it!
337 if (0 != af_init(afs
)) {
338 sh_audio
->afilter
= NULL
;
340 return 0; // failed :(
343 *out_samplerate
= afs
->output
.rate
;
344 *out_channels
= afs
->output
.nch
;
345 *out_format
= afs
->output
.format
;
347 sh_audio
->a_out_buffer_len
= 0;
350 sh_audio
->afilter
= (void *) afs
;
354 static int filter_n_bytes(sh_audio_t
*sh
, int len
)
358 af_data_t filter_input
= {
359 .audio
= sh
->a_buffer
,
360 .rate
= sh
->samplerate
,
362 .format
= sh
->sample_format
364 af_data_t
*filter_output
;
366 assert(len
-1 + sh
->audio_out_minsize
<= sh
->a_buffer_size
);
368 // Decode more bytes if needed
369 while (sh
->a_buffer_len
< len
) {
370 unsigned char *buf
= sh
->a_buffer
+ sh
->a_buffer_len
;
371 int minlen
= len
- sh
->a_buffer_len
;
372 int maxlen
= sh
->a_buffer_size
- sh
->a_buffer_len
;
373 int ret
= sh
->ad_driver
->decode_audio(sh
, buf
, minlen
, maxlen
);
376 len
= sh
->a_buffer_len
;
379 sh
->a_buffer_len
+= ret
;
382 filter_input
.len
= len
;
383 af_fix_parameters(&filter_input
);
384 filter_output
= af_play(sh
->afilter
, &filter_input
);
387 if (sh
->a_out_buffer_size
< sh
->a_out_buffer_len
+ filter_output
->len
) {
388 int newlen
= sh
->a_out_buffer_len
+ filter_output
->len
;
389 mp_msg(MSGT_DECAUDIO
, MSGL_V
, "Increasing filtered audio buffer size "
390 "from %d to %d\n", sh
->a_out_buffer_size
, newlen
);
391 sh
->a_out_buffer
= realloc(sh
->a_out_buffer
, newlen
);
392 sh
->a_out_buffer_size
= newlen
;
394 memcpy(sh
->a_out_buffer
+ sh
->a_out_buffer_len
, filter_output
->audio
,
396 sh
->a_out_buffer_len
+= filter_output
->len
;
398 // remove processed data from decoder buffer:
399 sh
->a_buffer_len
-= len
;
400 memmove(sh
->a_buffer
, sh
->a_buffer
+ len
, sh
->a_buffer_len
);
405 /* Try to get at least minlen decoded+filtered bytes in sh_audio->a_out_buffer
406 * (total length including possible existing data).
407 * Return 0 on success, -1 on error/EOF (not distinguished).
408 * In the former case sh_audio->a_out_buffer_len is always >= minlen
409 * on return. In case of EOF/error it might or might not be.
410 * Can reallocate sh_audio->a_out_buffer if needed to fit all filter output. */
411 int decode_audio(sh_audio_t
*sh_audio
, int minlen
)
413 // Indicates that a filter seems to be buffering large amounts of data
414 int huge_filter_buffer
= 0;
415 // Decoded audio must be cut at boundaries of this many bytes
416 int unitsize
= sh_audio
->channels
* sh_audio
->samplesize
* 16;
418 /* Filter output size will be about filter_multiplier times input size.
419 * If some filter buffers audio in big blocks this might only hold
420 * as average over time. */
421 double filter_multiplier
= af_calc_filter_multiplier(sh_audio
->afilter
);
423 /* If the decoder set audio_out_minsize then it can do the equivalent of
424 * "while (output_len < target_len) output_len += audio_out_minsize;",
425 * so we must guarantee there is at least audio_out_minsize-1 bytes
426 * more space in the output buffer than the minimum length we try to
428 int max_decode_len
= sh_audio
->a_buffer_size
- sh_audio
->audio_out_minsize
;
429 max_decode_len
-= max_decode_len
% unitsize
;
431 while (sh_audio
->a_out_buffer_len
< minlen
) {
432 int declen
= (minlen
- sh_audio
->a_out_buffer_len
) / filter_multiplier
433 + (unitsize
<< 5); // some extra for possible filter buffering
434 if (huge_filter_buffer
)
435 /* Some filter must be doing significant buffering if the estimated
436 * input length didn't produce enough output from filters.
437 * Feed the filters 2k bytes at a time until we have enough output.
438 * Very small amounts could make filtering inefficient while large
439 * amounts can make MPlayer demux the file unnecessarily far ahead
440 * to get audio data and buffer video frames in memory while doing
441 * so. However the performance impact of either is probably not too
442 * significant as long as the value is not completely insane. */
444 declen
-= declen
% unitsize
;
445 if (declen
> max_decode_len
)
446 declen
= max_decode_len
;
448 /* if this iteration does not fill buffer, we must have lots
449 * of buffering in filters */
450 huge_filter_buffer
= 1;
451 if (filter_n_bytes(sh_audio
, declen
) < 0)
457 void resync_audio_stream(sh_audio_t
*sh_audio
)
459 sh_audio
->a_in_buffer_len
= 0; // clear audio input buffer
460 if (!sh_audio
->initialized
)
462 sh_audio
->ad_driver
->control(sh_audio
, ADCTRL_RESYNC_STREAM
, NULL
);
465 void skip_audio_frame(sh_audio_t
*sh_audio
)
467 if (!sh_audio
->initialized
)
469 if (sh_audio
->ad_driver
->control(sh_audio
, ADCTRL_SKIP_FRAME
, NULL
) ==
472 // default skip code:
473 ds_fill_buffer(sh_audio
->ds
); // skip block