2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 #include <libavcodec/avcodec.h>
26 #include <libavutil/audioconvert.h>
27 #include <libavutil/opt.h>
28 #include <libavutil/samplefmt.h>
36 #include "ad_internal.h"
37 #include "libaf/reorder_ch.h"
41 #ifdef CONFIG_LIBAVRESAMPLE
42 #include <libavresample/avresample.h>
45 static const ad_info_t info
=
47 "libavcodec audio decoders",
52 .print_name
= "libavcodec",
58 AVCodecContext
*avctx
;
63 int previous_data_left
; // input demuxer packet data
65 #ifdef CONFIG_LIBAVRESAMPLE
66 AVAudioResampleContext
*avr
;
67 enum AVSampleFormat resample_fmt
;
68 enum AVSampleFormat out_fmt
;
69 int resample_channels
;
70 uint8_t *resample_buf
;
71 uint64_t resample_buf_size
;
75 static int preinit(sh_audio_t
*sh
)
80 static const int sample_fmt_map
[][2] = {
81 { AV_SAMPLE_FMT_U8
, AF_FORMAT_U8
},
82 { AV_SAMPLE_FMT_S16
, AF_FORMAT_S16_NE
},
83 { AV_SAMPLE_FMT_S32
, AF_FORMAT_S32_NE
},
84 { AV_SAMPLE_FMT_FLT
, AF_FORMAT_FLOAT_NE
},
87 static int sample_fmt_lavc2native(enum AVSampleFormat sample_fmt
)
89 for (int i
= 0; i
< FF_ARRAY_ELEMS(sample_fmt_map
); i
++)
90 if (sample_fmt_map
[i
][0] == sample_fmt
)
91 return sample_fmt_map
[i
][1];
92 return AF_FORMAT_UNKNOWN
;
95 /* Prefer playing audio with the samplerate given in container data
96 * if available, but take number the number of channels and sample format
97 * from the codec, since if the codec isn't using the correct values for
98 * those everything breaks anyway.
100 static int setup_format(sh_audio_t
*sh_audio
)
102 struct priv
*priv
= sh_audio
->context
;
103 AVCodecContext
*codec
= priv
->avctx
;
104 int sample_format
= sh_audio
->sample_format
;
106 sample_format
= sample_fmt_lavc2native(codec
->sample_fmt
);
107 if (sample_format
== AF_FORMAT_UNKNOWN
) {
108 #ifndef CONFIG_LIBAVRESAMPLE
109 mp_msg(MSGT_DECAUDIO
, MSGL_FATAL
, "Unsupported sample format\n");
110 sample_format
= AF_FORMAT_UNKNOWN
;
112 if (priv
->avr
&& (priv
->resample_fmt
!= codec
->sample_fmt
||
113 priv
->resample_channels
!= codec
->channels
))
114 avresample_free(&priv
->avr
);
119 enum AVSampleFormat out_fmt
=
120 av_get_packed_sample_fmt(codec
->sample_fmt
);
121 uint64_t ch_layout
= codec
->channel_layout
;
123 mp_msg(MSGT_DECAUDIO
, MSGL_V
,
124 "(Re)initializing libavresample format conversion...\n");
127 ch_layout
= av_get_default_channel_layout(codec
->channels
);
129 /* if lavc format is planar, try just getting packed equivalent */
130 sample_format
= sample_fmt_lavc2native(out_fmt
);
131 if (sample_format
== AF_FORMAT_UNKNOWN
) {
132 /* fallback to s16 */
133 out_fmt
= AV_SAMPLE_FMT_S16
;
134 sample_format
= AF_FORMAT_S16_NE
;
137 priv
->avr
= avresample_alloc_context();
139 mp_msg(MSGT_DECAUDIO
, MSGL_FATAL
, "Out of memory.\n");
142 av_opt_set_int(priv
->avr
, "in_channel_layout", ch_layout
, 0);
143 av_opt_set_int(priv
->avr
, "out_channel_layout", ch_layout
, 0);
144 av_opt_set_int(priv
->avr
, "in_sample_rate", codec
->sample_rate
, 0);
145 av_opt_set_int(priv
->avr
, "out_sample_rate", codec
->sample_rate
, 0);
146 av_opt_set_int(priv
->avr
, "in_sample_fmt", codec
->sample_fmt
, 0);
147 av_opt_set_int(priv
->avr
, "out_sample_fmt", out_fmt
, 0);
149 if ((ret
= avresample_open(priv
->avr
)) < 0) {
150 av_strerror(ret
, error
, sizeof(error
));
151 mp_msg(MSGT_DECAUDIO
, MSGL_ERR
,
152 "Error opening libavresample: %s.\n", error
);
154 priv
->resample_fmt
= codec
->sample_fmt
;
155 priv
->resample_channels
= codec
->channels
;
156 priv
->out_fmt
= out_fmt
;
157 priv
->unitsize
= av_get_bytes_per_sample(out_fmt
) *
160 sample_format
= sh_audio
->sample_format
;
161 } else if (priv
->avr
) {
162 avresample_free(&priv
->avr
);
166 bool broken_srate
= false;
167 int samplerate
= codec
->sample_rate
;
168 int container_samplerate
= sh_audio
->container_out_samplerate
;
169 if (!container_samplerate
&& sh_audio
->wf
)
170 container_samplerate
= sh_audio
->wf
->nSamplesPerSec
;
171 if (codec
->codec_id
== CODEC_ID_AAC
172 && samplerate
== 2 * container_samplerate
)
174 else if (container_samplerate
)
175 samplerate
= container_samplerate
;
177 if (codec
->channels
!= sh_audio
->channels
||
178 samplerate
!= sh_audio
->samplerate
||
179 sample_format
!= sh_audio
->sample_format
) {
180 sh_audio
->channels
= codec
->channels
;
181 sh_audio
->samplerate
= samplerate
;
182 sh_audio
->sample_format
= sample_format
;
183 sh_audio
->samplesize
= af_fmt2bits(sh_audio
->sample_format
) / 8;
185 mp_msg(MSGT_DECAUDIO
, MSGL_WARN
,
186 "Ignoring broken container sample rate for AAC with SBR\n");
192 static int init(sh_audio_t
*sh_audio
)
194 struct MPOpts
*opts
= sh_audio
->opts
;
195 AVCodecContext
*lavc_context
;
198 if (sh_audio
->codec
->dll
) {
199 lavc_codec
= avcodec_find_decoder_by_name(sh_audio
->codec
->dll
);
201 mp_tmsg(MSGT_DECAUDIO
, MSGL_ERR
,
202 "Cannot find codec '%s' in libavcodec...\n",
203 sh_audio
->codec
->dll
);
206 } else if (!sh_audio
->libav_codec_id
) {
207 mp_tmsg(MSGT_DECAUDIO
, MSGL_INFO
, "No Libav codec ID known. "
208 "Generic lavc decoder is not applicable.\n");
211 lavc_codec
= avcodec_find_decoder(sh_audio
->libav_codec_id
);
213 mp_tmsg(MSGT_DECAUDIO
, MSGL_INFO
, "Libavcodec has no decoder "
219 sh_audio
->codecname
= lavc_codec
->long_name
;
220 if (!sh_audio
->codecname
)
221 sh_audio
->codecname
= lavc_codec
->name
;
223 struct priv
*ctx
= talloc_zero(NULL
, struct priv
);
224 sh_audio
->context
= ctx
;
225 lavc_context
= avcodec_alloc_context3(lavc_codec
);
226 ctx
->avctx
= lavc_context
;
227 ctx
->avframe
= avcodec_alloc_frame();
229 // Always try to set - option only exists for AC3 at the moment
230 av_opt_set_double(lavc_context
, "drc_scale", opts
->drc_level
,
231 AV_OPT_SEARCH_CHILDREN
);
232 lavc_context
->sample_rate
= sh_audio
->samplerate
;
233 lavc_context
->bit_rate
= sh_audio
->i_bps
* 8;
235 lavc_context
->channels
= sh_audio
->wf
->nChannels
;
236 lavc_context
->sample_rate
= sh_audio
->wf
->nSamplesPerSec
;
237 lavc_context
->bit_rate
= sh_audio
->wf
->nAvgBytesPerSec
* 8;
238 lavc_context
->block_align
= sh_audio
->wf
->nBlockAlign
;
239 lavc_context
->bits_per_coded_sample
= sh_audio
->wf
->wBitsPerSample
;
241 lavc_context
->request_channels
= opts
->audio_output_channels
;
242 lavc_context
->request_sample_fmt
= AV_SAMPLE_FMT_S16P
;
243 lavc_context
->codec_tag
= sh_audio
->format
; //FOURCC
244 lavc_context
->codec_type
= AVMEDIA_TYPE_AUDIO
;
245 lavc_context
->codec_id
= lavc_codec
->id
; // not sure if required, imho not --A'rpi
247 /* alloc extra data */
248 if (sh_audio
->wf
&& sh_audio
->wf
->cbSize
> 0) {
249 lavc_context
->extradata
= av_mallocz(sh_audio
->wf
->cbSize
+ FF_INPUT_BUFFER_PADDING_SIZE
);
250 lavc_context
->extradata_size
= sh_audio
->wf
->cbSize
;
251 memcpy(lavc_context
->extradata
, sh_audio
->wf
+ 1,
252 lavc_context
->extradata_size
);
256 if (sh_audio
->codecdata_len
&& sh_audio
->codecdata
&&
257 !lavc_context
->extradata
) {
258 lavc_context
->extradata
= av_malloc(sh_audio
->codecdata_len
+
259 FF_INPUT_BUFFER_PADDING_SIZE
);
260 lavc_context
->extradata_size
= sh_audio
->codecdata_len
;
261 memcpy(lavc_context
->extradata
, (char *)sh_audio
->codecdata
,
262 lavc_context
->extradata_size
);
266 if (avcodec_open2(lavc_context
, lavc_codec
, NULL
) < 0) {
267 mp_tmsg(MSGT_DECAUDIO
, MSGL_ERR
, "Could not open codec.\n");
271 mp_msg(MSGT_DECAUDIO
, MSGL_V
, "INFO: libavcodec \"%s\" init OK!\n",
274 if (sh_audio
->format
== 0x3343414D) {
276 sh_audio
->ds
->ss_div
= 2 * 3; // 1 samples/packet
277 sh_audio
->ds
->ss_mul
= 2 * sh_audio
->wf
->nChannels
; // 1 byte*ch/packet
278 } else if (sh_audio
->format
== 0x3643414D) {
280 sh_audio
->ds
->ss_div
= 2 * 6; // 1 samples/packet
281 sh_audio
->ds
->ss_mul
= 2 * sh_audio
->wf
->nChannels
; // 1 byte*ch/packet
284 // Decode at least 1 byte: (to get header filled)
285 for (int tries
= 0;;) {
286 int x
= decode_audio(sh_audio
, sh_audio
->a_buffer
, 1,
287 sh_audio
->a_buffer_size
);
289 sh_audio
->a_buffer_len
= x
;
293 mp_msg(MSGT_DECAUDIO
, MSGL_ERR
,
294 "ad_ffmpeg: initial decode failed\n");
300 sh_audio
->i_bps
= lavc_context
->bit_rate
/ 8;
301 if (sh_audio
->wf
&& sh_audio
->wf
->nAvgBytesPerSec
)
302 sh_audio
->i_bps
= sh_audio
->wf
->nAvgBytesPerSec
;
307 static void uninit(sh_audio_t
*sh
)
309 sh
->codecname
= NULL
;
310 struct priv
*ctx
= sh
->context
;
313 AVCodecContext
*lavc_context
= ctx
->avctx
;
316 if (avcodec_close(lavc_context
) < 0)
317 mp_tmsg(MSGT_DECVIDEO
, MSGL_ERR
, "Could not close codec.\n");
318 av_freep(&lavc_context
->extradata
);
319 av_freep(&lavc_context
);
321 #ifdef CONFIG_LIBAVRESAMPLE
322 avresample_free(&ctx
->avr
);
324 #if LIBAVCODEC_VERSION_INT >= (54 << 16 | 28 << 8)
325 avcodec_free_frame(&ctx
->avframe
);
327 av_free(ctx
->avframe
);
333 static int control(sh_audio_t
*sh
, int cmd
, void *arg
, ...)
335 struct priv
*ctx
= sh
->context
;
337 case ADCTRL_RESYNC_STREAM
:
338 avcodec_flush_buffers(ctx
->avctx
);
339 ds_clear_parser(sh
->ds
);
340 ctx
->previous_data_left
= 0;
341 ctx
->output_left
= 0;
344 return CONTROL_UNKNOWN
;
347 static int decode_new_packet(struct sh_audio
*sh
)
349 struct priv
*priv
= sh
->context
;
350 AVCodecContext
*avctx
= priv
->avctx
;
351 double pts
= MP_NOPTS_VALUE
;
353 bool packet_already_used
= priv
->previous_data_left
;
354 struct demux_packet
*mpkt
= ds_get_packet2(sh
->ds
,
355 priv
->previous_data_left
);
356 unsigned char *start
;
358 assert(!priv
->previous_data_left
);
361 ds_parse(sh
->ds
, &start
, &insize
, pts
, 0);
363 return -1; // error or EOF
365 assert(mpkt
->len
>= priv
->previous_data_left
);
366 if (!priv
->previous_data_left
) {
367 priv
->previous_data_left
= mpkt
->len
;
370 insize
= priv
->previous_data_left
;
371 start
= mpkt
->buffer
+ mpkt
->len
- priv
->previous_data_left
;
372 int consumed
= ds_parse(sh
->ds
, &start
, &insize
, pts
, 0);
373 priv
->previous_data_left
-= consumed
;
374 priv
->previous_data_left
= FFMAX(priv
->previous_data_left
, 0);
378 av_init_packet(&pkt
);
381 if (mpkt
&& mpkt
->avpacket
) {
382 pkt
.side_data
= mpkt
->avpacket
->side_data
;
383 pkt
.side_data_elems
= mpkt
->avpacket
->side_data_elems
;
385 if (pts
!= MP_NOPTS_VALUE
&& !packet_already_used
) {
390 int ret
= avcodec_decode_audio4(avctx
, priv
->avframe
, &got_frame
, &pkt
);
391 // LATM may need many packets to find mux info
392 if (ret
== AVERROR(EAGAIN
))
395 mp_msg(MSGT_DECAUDIO
, MSGL_V
, "lavc_audio: error\n");
398 // The "insize >= ret" test is sanity check against decoder overreads
399 if (!sh
->parser
&& insize
>= ret
)
400 priv
->previous_data_left
= insize
- ret
;
406 #ifdef CONFIG_LIBAVRESAMPLE
409 uint64_t needed_size
= av_samples_get_buffer_size(NULL
, priv
->resample_channels
,
410 priv
->avframe
->nb_samples
,
411 priv
->resample_fmt
, 0);
412 if (needed_size
> priv
->resample_buf_size
) {
413 priv
->resample_buf
= talloc_realloc(priv
, priv
->resample_buf
,
414 uint8_t, needed_size
);
415 priv
->resample_buf_size
= needed_size
;
418 ret
= avresample_convert(priv
->avr
, &priv
->resample_buf
,
419 priv
->resample_buf_size
, priv
->avframe
->nb_samples
,
420 priv
->avframe
->extended_data
, priv
->avframe
->linesize
[0],
421 priv
->avframe
->nb_samples
);
424 av_strerror(ret
, error
, sizeof(error
));
425 mp_msg(MSGT_DECAUDIO
, MSGL_ERR
, "Error during sample format conversion: %s.\n",
430 assert(ret
== priv
->avframe
->nb_samples
);
432 priv
->output
= priv
->resample_buf
;
433 priv
->output_left
= priv
->unitsize
* ret
;
436 /* An error is reported later from output format checking, but make
437 * sure we don't crash by overreading first plane. */
438 if (!av_sample_fmt_is_planar(avctx
->sample_fmt
) || avctx
->channels
== 1) {
440 uint64_t unitsize
= (uint64_t)av_get_bytes_per_sample(avctx
->sample_fmt
) *
442 if (unitsize
> 100000)
444 priv
->unitsize
= unitsize
;
445 uint64_t output_left
= unitsize
* priv
->avframe
->nb_samples
;
446 if (output_left
> 500000000)
448 priv
->output_left
= output_left
;
449 priv
->output
= priv
->avframe
->data
[0];
452 mp_dbg(MSGT_DECAUDIO
, MSGL_DBG2
, "Decoded %d -> %d \n", insize
,
458 static int decode_audio(sh_audio_t
*sh_audio
, unsigned char *buf
, int minlen
,
461 struct priv
*priv
= sh_audio
->context
;
462 AVCodecContext
*avctx
= priv
->avctx
;
465 while (len
< minlen
) {
466 if (!priv
->output_left
) {
467 if (decode_new_packet(sh_audio
) < 0)
471 int size
= (minlen
- len
+ priv
->unitsize
- 1);
472 size
-= size
% priv
->unitsize
;
473 size
= FFMIN(size
, priv
->output_left
);
476 memcpy(buf
, priv
->output
, size
);
477 priv
->output
+= size
;
478 priv
->output_left
-= size
;
479 if (avctx
->channels
>= 5) {
480 int samplesize
= av_get_bytes_per_sample(avctx
->sample_fmt
);
481 reorder_channel_nch(buf
, AF_CHANNEL_LAYOUT_LAVC_DEFAULT
,
482 AF_CHANNEL_LAYOUT_MPLAYER_DEFAULT
,
484 size
/ samplesize
, samplesize
);
492 sh_audio
->pts_bytes
+= size
;