1 | /* |
---|
2 | Copyright (C) 2013 Paul Brossier <piem@aubio.org> |
---|
3 | |
---|
4 | This file is part of aubio. |
---|
5 | |
---|
6 | aubio is free software: you can redistribute it and/or modify |
---|
7 | it under the terms of the GNU General Public License as published by |
---|
8 | the Free Software Foundation, either version 3 of the License, or |
---|
9 | (at your option) any later version. |
---|
10 | |
---|
11 | aubio is distributed in the hope that it will be useful, |
---|
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
14 | GNU General Public License for more details. |
---|
15 | |
---|
16 | You should have received a copy of the GNU General Public License |
---|
17 | along with aubio. If not, see <http://www.gnu.org/licenses/>. |
---|
18 | |
---|
19 | */ |
---|
20 | |
---|
21 | #include "aubio_priv.h" |
---|
22 | |
---|
23 | #ifdef HAVE_LIBAV |
---|
24 | |
---|
25 | #include <libavcodec/avcodec.h> |
---|
26 | #include <libavformat/avformat.h> |
---|
27 | #if defined(HAVE_SWRESAMPLE) |
---|
28 | #include <libswresample/swresample.h> |
---|
29 | #elif defined(HAVE_AVRESAMPLE) |
---|
30 | #include <libavresample/avresample.h> |
---|
31 | #endif |
---|
32 | #include <libavutil/opt.h> |
---|
33 | #include <stdlib.h> |
---|
34 | |
---|
35 | // determine whether we use libavformat from ffmpeg or from libav |
---|
36 | #define FFMPEG_LIBAVFORMAT (LIBAVFORMAT_VERSION_MICRO > 99 ) |
---|
37 | // max_analyze_duration2 was used from ffmpeg libavformat 55.43.100 through 57.2.100 |
---|
38 | #define FFMPEG_LIBAVFORMAT_MAX_DUR2 FFMPEG_LIBAVFORMAT && ( \ |
---|
39 | (LIBAVFORMAT_VERSION_MAJOR == 55 && LIBAVFORMAT_VERSION_MINOR >= 43) \ |
---|
40 | || (LIBAVFORMAT_VERSION_MAJOR == 56) \ |
---|
41 | || (LIBAVFORMAT_VERSION_MAJOR == 57 && LIBAVFORMAT_VERSION_MINOR < 2) \ |
---|
42 | ) |
---|
43 | |
---|
44 | // backward compatibility with libavcodec55 |
---|
45 | #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55,28,1) |
---|
46 | #warning "libavcodec55 is deprecated" |
---|
47 | #define HAVE_AUBIO_LIBAVCODEC_DEPRECATED 1 |
---|
48 | #define av_frame_alloc avcodec_alloc_frame |
---|
49 | #define av_frame_free avcodec_free_frame |
---|
50 | #define av_packet_unref av_free_packet |
---|
51 | #endif |
---|
52 | |
---|
53 | #include "aubio_priv.h" |
---|
54 | #include "fvec.h" |
---|
55 | #include "fmat.h" |
---|
56 | #include "source_avcodec.h" |
---|
57 | |
---|
58 | #define AUBIO_AVCODEC_MAX_BUFFER_SIZE FF_MIN_BUFFER_SIZE |
---|
59 | |
---|
60 | struct _aubio_source_avcodec_t { |
---|
61 | uint_t hop_size; |
---|
62 | uint_t samplerate; |
---|
63 | uint_t channels; |
---|
64 | |
---|
65 | // some data about the file |
---|
66 | char_t *path; |
---|
67 | uint_t input_samplerate; |
---|
68 | uint_t input_channels; |
---|
69 | |
---|
70 | // avcodec stuff |
---|
71 | AVFormatContext *avFormatCtx; |
---|
72 | AVCodecContext *avCodecCtx; |
---|
73 | AVFrame *avFrame; |
---|
74 | AVPacket avPacket; |
---|
75 | #ifdef HAVE_AVRESAMPLE |
---|
76 | AVAudioResampleContext *avr; |
---|
77 | #elif defined(HAVE_SWRESAMPLE) |
---|
78 | SwrContext *avr; |
---|
79 | #endif |
---|
80 | smpl_t *output; |
---|
81 | uint_t read_samples; |
---|
82 | uint_t read_index; |
---|
83 | sint_t selected_stream; |
---|
84 | uint_t eof; |
---|
85 | uint_t multi; |
---|
86 | }; |
---|
87 | |
---|
88 | // hack to create or re-create the context the first time _do or _do_multi is called |
---|
89 | void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi); |
---|
90 | void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples); |
---|
91 | |
---|
92 | uint_t aubio_source_avcodec_has_network_url(aubio_source_avcodec_t *s); |
---|
93 | |
---|
94 | uint_t aubio_source_avcodec_has_network_url(aubio_source_avcodec_t *s) { |
---|
95 | char proto[20], authorization[256], hostname[128], uripath[256]; |
---|
96 | int proto_size = 20, authorization_size = 256, hostname_size = 128, |
---|
97 | *port_ptr = 0, path_size = 256; |
---|
98 | av_url_split(proto, proto_size, authorization, authorization_size, hostname, |
---|
99 | hostname_size, port_ptr, uripath, path_size, s->path); |
---|
100 | if (strlen(proto)) { |
---|
101 | return 1; |
---|
102 | } |
---|
103 | return 0; |
---|
104 | } |
---|
105 | |
---|
106 | |
---|
107 | aubio_source_avcodec_t * new_aubio_source_avcodec(const char_t * path, uint_t samplerate, uint_t hop_size) { |
---|
108 | aubio_source_avcodec_t * s = AUBIO_NEW(aubio_source_avcodec_t); |
---|
109 | int err; |
---|
110 | if (path == NULL) { |
---|
111 | AUBIO_ERR("source_avcodec: Aborted opening null path\n"); |
---|
112 | goto beach; |
---|
113 | } |
---|
114 | if ((sint_t)samplerate < 0) { |
---|
115 | AUBIO_ERR("source_avcodec: Can not open %s with samplerate %d\n", path, samplerate); |
---|
116 | goto beach; |
---|
117 | } |
---|
118 | if ((sint_t)hop_size <= 0) { |
---|
119 | AUBIO_ERR("source_avcodec: Can not open %s with hop_size %d\n", path, hop_size); |
---|
120 | goto beach; |
---|
121 | } |
---|
122 | |
---|
123 | s->hop_size = hop_size; |
---|
124 | s->channels = 1; |
---|
125 | |
---|
126 | if (s->path) AUBIO_FREE(s->path); |
---|
127 | s->path = AUBIO_ARRAY(char_t, strnlen(path, PATH_MAX) + 1); |
---|
128 | strncpy(s->path, path, strnlen(path, PATH_MAX) + 1); |
---|
129 | |
---|
130 | // register all formats and codecs |
---|
131 | av_register_all(); |
---|
132 | |
---|
133 | if (aubio_source_avcodec_has_network_url(s)) { |
---|
134 | avformat_network_init(); |
---|
135 | } |
---|
136 | |
---|
137 | // try opening the file and get some info about it |
---|
138 | AVFormatContext *avFormatCtx = s->avFormatCtx; |
---|
139 | avFormatCtx = NULL; |
---|
140 | if ( (err = avformat_open_input(&avFormatCtx, s->path, NULL, NULL) ) < 0 ) { |
---|
141 | char errorstr[256]; |
---|
142 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
143 | AUBIO_ERR("source_avcodec: Failed opening %s (%s)\n", s->path, errorstr); |
---|
144 | goto beach; |
---|
145 | } |
---|
146 | |
---|
147 | // try to make sure max_analyze_duration is big enough for most songs |
---|
148 | #if FFMPEG_LIBAVFORMAT_MAX_DUR2 |
---|
149 | avFormatCtx->max_analyze_duration2 *= 100; |
---|
150 | #else |
---|
151 | avFormatCtx->max_analyze_duration *= 100; |
---|
152 | #endif |
---|
153 | |
---|
154 | // retrieve stream information |
---|
155 | if ( (err = avformat_find_stream_info(avFormatCtx, NULL)) < 0 ) { |
---|
156 | char errorstr[256]; |
---|
157 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
158 | AUBIO_ERR("source_avcodec: Could not find stream information " "for %s (%s)\n", s->path, |
---|
159 | errorstr); |
---|
160 | goto beach; |
---|
161 | } |
---|
162 | |
---|
163 | // dump information about file onto standard error |
---|
164 | //av_dump_format(avFormatCtx, 0, s->path, 0); |
---|
165 | |
---|
166 | // look for the first audio stream |
---|
167 | uint_t i; |
---|
168 | sint_t selected_stream = -1; |
---|
169 | for (i = 0; i < avFormatCtx->nb_streams; i++) { |
---|
170 | #if FF_API_LAVF_AVCTX |
---|
171 | if (avFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { |
---|
172 | #else |
---|
173 | if (avFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) { |
---|
174 | #endif |
---|
175 | if (selected_stream == -1) { |
---|
176 | selected_stream = i; |
---|
177 | } else { |
---|
178 | AUBIO_WRN("source_avcodec: More than one audio stream in %s, " |
---|
179 | "taking the first one\n", s->path); |
---|
180 | } |
---|
181 | } |
---|
182 | } |
---|
183 | if (selected_stream == -1) { |
---|
184 | AUBIO_ERR("source_avcodec: No audio stream in %s\n", s->path); |
---|
185 | goto beach; |
---|
186 | } |
---|
187 | //AUBIO_DBG("Taking stream %d in file %s\n", selected_stream, s->path); |
---|
188 | s->selected_stream = selected_stream; |
---|
189 | |
---|
190 | AVCodecContext *avCodecCtx = s->avCodecCtx; |
---|
191 | #if FF_API_LAVF_AVCTX |
---|
192 | AVCodecParameters *codecpar = avFormatCtx->streams[selected_stream]->codecpar; |
---|
193 | if (codecpar == NULL) { |
---|
194 | AUBIO_ERR("source_avcodec: Could not find decoder for %s", s->path); |
---|
195 | goto beach; |
---|
196 | } |
---|
197 | AVCodec *codec = avcodec_find_decoder(codecpar->codec_id); |
---|
198 | |
---|
199 | /* Allocate a codec context for the decoder */ |
---|
200 | avCodecCtx = avcodec_alloc_context3(codec); |
---|
201 | if (!avCodecCtx) { |
---|
202 | AUBIO_ERR("source_avcodec: Failed to allocate the %s codec context for path %s\n", |
---|
203 | av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path); |
---|
204 | goto beach; |
---|
205 | } |
---|
206 | #else |
---|
207 | avCodecCtx = avFormatCtx->streams[selected_stream]->codec; |
---|
208 | AVCodec *codec = avcodec_find_decoder(avCodecCtx->codec_id); |
---|
209 | #endif |
---|
210 | if (codec == NULL) { |
---|
211 | AUBIO_ERR("source_avcodec: Could not find decoder for %s", s->path); |
---|
212 | goto beach; |
---|
213 | } |
---|
214 | |
---|
215 | #if FF_API_LAVF_AVCTX |
---|
216 | /* Copy codec parameters from input stream to output codec context */ |
---|
217 | if ((err = avcodec_parameters_to_context(avCodecCtx, codecpar)) < 0) { |
---|
218 | AUBIO_ERR("source_avcodec: Failed to copy %s codec parameters to decoder context for %s\n", |
---|
219 | av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path); |
---|
220 | goto beach; |
---|
221 | } |
---|
222 | #endif |
---|
223 | |
---|
224 | if ( ( err = avcodec_open2(avCodecCtx, codec, NULL) ) < 0) { |
---|
225 | char errorstr[256]; |
---|
226 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
227 | AUBIO_ERR("source_avcodec: Could not load codec for %s (%s)\n", s->path, errorstr); |
---|
228 | goto beach; |
---|
229 | } |
---|
230 | |
---|
231 | /* get input specs */ |
---|
232 | s->input_samplerate = avCodecCtx->sample_rate; |
---|
233 | s->input_channels = avCodecCtx->channels; |
---|
234 | //AUBIO_DBG("input_samplerate: %d\n", s->input_samplerate); |
---|
235 | //AUBIO_DBG("input_channels: %d\n", s->input_channels); |
---|
236 | |
---|
237 | if (samplerate == 0) { |
---|
238 | s->samplerate = s->input_samplerate; |
---|
239 | } else { |
---|
240 | s->samplerate = samplerate; |
---|
241 | } |
---|
242 | |
---|
243 | if (s->samplerate > s->input_samplerate) { |
---|
244 | AUBIO_WRN("source_avcodec: upsampling %s from %d to %d\n", s->path, |
---|
245 | s->input_samplerate, s->samplerate); |
---|
246 | } |
---|
247 | |
---|
248 | AVFrame *avFrame = s->avFrame; |
---|
249 | avFrame = av_frame_alloc(); |
---|
250 | if (!avFrame) { |
---|
251 | AUBIO_ERR("source_avcodec: Could not allocate frame for (%s)\n", s->path); |
---|
252 | } |
---|
253 | |
---|
254 | /* allocate output for avr */ |
---|
255 | s->output = (smpl_t *)av_malloc(AUBIO_AVCODEC_MAX_BUFFER_SIZE * sizeof(smpl_t)); |
---|
256 | |
---|
257 | s->read_samples = 0; |
---|
258 | s->read_index = 0; |
---|
259 | |
---|
260 | s->avFormatCtx = avFormatCtx; |
---|
261 | s->avCodecCtx = avCodecCtx; |
---|
262 | s->avFrame = avFrame; |
---|
263 | |
---|
264 | // default to mono output |
---|
265 | aubio_source_avcodec_reset_resampler(s, 0); |
---|
266 | |
---|
267 | s->eof = 0; |
---|
268 | s->multi = 0; |
---|
269 | |
---|
270 | //av_log_set_level(AV_LOG_QUIET); |
---|
271 | |
---|
272 | return s; |
---|
273 | |
---|
274 | beach: |
---|
275 | //AUBIO_ERR("can not read %s at samplerate %dHz with a hop_size of %d\n", |
---|
276 | // s->path, s->samplerate, s->hop_size); |
---|
277 | del_aubio_source_avcodec(s); |
---|
278 | return NULL; |
---|
279 | } |
---|
280 | |
---|
281 | void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi) { |
---|
282 | // create or reset resampler to/from mono/multi-channel |
---|
283 | if ( (multi != s->multi) || (s->avr == NULL) ) { |
---|
284 | int64_t input_layout = av_get_default_channel_layout(s->input_channels); |
---|
285 | uint_t output_channels = multi ? s->input_channels : 1; |
---|
286 | int64_t output_layout = av_get_default_channel_layout(output_channels); |
---|
287 | #ifdef HAVE_AVRESAMPLE |
---|
288 | AVAudioResampleContext *avr = avresample_alloc_context(); |
---|
289 | AVAudioResampleContext *oldavr = s->avr; |
---|
290 | #elif defined(HAVE_SWRESAMPLE) |
---|
291 | SwrContext *avr = swr_alloc(); |
---|
292 | SwrContext *oldavr = s->avr; |
---|
293 | #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */ |
---|
294 | |
---|
295 | av_opt_set_int(avr, "in_channel_layout", input_layout, 0); |
---|
296 | av_opt_set_int(avr, "out_channel_layout", output_layout, 0); |
---|
297 | av_opt_set_int(avr, "in_sample_rate", s->input_samplerate, 0); |
---|
298 | av_opt_set_int(avr, "out_sample_rate", s->samplerate, 0); |
---|
299 | av_opt_set_int(avr, "in_sample_fmt", s->avCodecCtx->sample_fmt, 0); |
---|
300 | #if HAVE_AUBIO_DOUBLE |
---|
301 | av_opt_set_int(avr, "out_sample_fmt", AV_SAMPLE_FMT_DBL, 0); |
---|
302 | #else |
---|
303 | av_opt_set_int(avr, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0); |
---|
304 | #endif |
---|
305 | // TODO: use planar? |
---|
306 | //av_opt_set_int(avr, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0); |
---|
307 | int err; |
---|
308 | #ifdef HAVE_AVRESAMPLE |
---|
309 | if ( ( err = avresample_open(avr) ) < 0) { |
---|
310 | #elif defined(HAVE_SWRESAMPLE) |
---|
311 | if ( ( err = swr_init(avr) ) < 0) { |
---|
312 | #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */ |
---|
313 | char errorstr[256]; |
---|
314 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
315 | AUBIO_ERR("source_avcodec: Could not open AVAudioResampleContext for %s (%s)\n", |
---|
316 | s->path, errorstr); |
---|
317 | //goto beach; |
---|
318 | return; |
---|
319 | } |
---|
320 | s->avr = avr; |
---|
321 | if (oldavr != NULL) { |
---|
322 | #ifdef HAVE_AVRESAMPLE |
---|
323 | avresample_close( oldavr ); |
---|
324 | #elif defined(HAVE_SWRESAMPLE) |
---|
325 | swr_close ( oldavr ); |
---|
326 | #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */ |
---|
327 | av_free ( oldavr ); |
---|
328 | oldavr = NULL; |
---|
329 | } |
---|
330 | s->multi = multi; |
---|
331 | } |
---|
332 | } |
---|
333 | |
---|
334 | void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples) { |
---|
335 | AVFormatContext *avFormatCtx = s->avFormatCtx; |
---|
336 | AVCodecContext *avCodecCtx = s->avCodecCtx; |
---|
337 | AVFrame *avFrame = s->avFrame; |
---|
338 | AVPacket avPacket = s->avPacket; |
---|
339 | av_init_packet (&avPacket); |
---|
340 | #ifdef HAVE_AVRESAMPLE |
---|
341 | AVAudioResampleContext *avr = s->avr; |
---|
342 | #elif defined(HAVE_SWRESAMPLE) |
---|
343 | SwrContext *avr = s->avr; |
---|
344 | #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */ |
---|
345 | smpl_t *output = s->output; |
---|
346 | *read_samples = 0; |
---|
347 | |
---|
348 | do |
---|
349 | { |
---|
350 | int err = av_read_frame (avFormatCtx, &avPacket); |
---|
351 | if (err == AVERROR_EOF) { |
---|
352 | s->eof = 1; |
---|
353 | goto beach; |
---|
354 | } |
---|
355 | if (err != 0) { |
---|
356 | char errorstr[256]; |
---|
357 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
358 | AUBIO_ERR("source_avcodec: could not read frame in %s (%s)\n", s->path, errorstr); |
---|
359 | s->eof = 1; |
---|
360 | goto beach; |
---|
361 | } |
---|
362 | } while (avPacket.stream_index != s->selected_stream); |
---|
363 | |
---|
364 | int got_frame = 0; |
---|
365 | #if FF_API_LAVF_AVCTX |
---|
366 | int ret = avcodec_send_packet(avCodecCtx, &avPacket); |
---|
367 | if (ret < 0 && ret != AVERROR_EOF) { |
---|
368 | AUBIO_ERR("source_avcodec: error when sending packet for %s\n", s->path); |
---|
369 | goto beach; |
---|
370 | } |
---|
371 | ret = avcodec_receive_frame(avCodecCtx, avFrame); |
---|
372 | if (ret >= 0) { |
---|
373 | got_frame = 1; |
---|
374 | } |
---|
375 | if (ret < 0) { |
---|
376 | if (ret == AVERROR(EAGAIN)) { |
---|
377 | //AUBIO_WRN("source_avcodec: output is not available right now - user must try to send new input\n"); |
---|
378 | goto beach; |
---|
379 | } else if (ret == AVERROR_EOF) { |
---|
380 | AUBIO_WRN("source_avcodec: the decoder has been fully flushed, and there will be no more output frames\n"); |
---|
381 | } else { |
---|
382 | AUBIO_ERR("source_avcodec: decoding errors on %s\n", s->path); |
---|
383 | goto beach; |
---|
384 | } |
---|
385 | } |
---|
386 | #else |
---|
387 | int len = avcodec_decode_audio4(avCodecCtx, avFrame, &got_frame, &avPacket); |
---|
388 | |
---|
389 | if (len < 0) { |
---|
390 | AUBIO_ERR("source_avcodec: error while decoding %s\n", s->path); |
---|
391 | goto beach; |
---|
392 | } |
---|
393 | #endif |
---|
394 | if (got_frame == 0) { |
---|
395 | AUBIO_WRN("source_avcodec: did not get a frame when reading %s\n", s->path); |
---|
396 | goto beach; |
---|
397 | } |
---|
398 | |
---|
399 | #ifdef HAVE_AVRESAMPLE |
---|
400 | int in_linesize = 0; |
---|
401 | av_samples_get_buffer_size(&in_linesize, avCodecCtx->channels, |
---|
402 | avFrame->nb_samples, avCodecCtx->sample_fmt, 1); |
---|
403 | int in_samples = avFrame->nb_samples; |
---|
404 | int out_linesize = 0; |
---|
405 | int max_out_samples = AUBIO_AVCODEC_MAX_BUFFER_SIZE; |
---|
406 | int out_samples = avresample_convert ( avr, |
---|
407 | (uint8_t **)&output, out_linesize, max_out_samples, |
---|
408 | (uint8_t **)avFrame->data, in_linesize, in_samples); |
---|
409 | #elif defined(HAVE_SWRESAMPLE) |
---|
410 | int in_samples = avFrame->nb_samples; |
---|
411 | int max_out_samples = AUBIO_AVCODEC_MAX_BUFFER_SIZE / avCodecCtx->channels; |
---|
412 | int out_samples = swr_convert( avr, |
---|
413 | (uint8_t **)&output, max_out_samples, |
---|
414 | (const uint8_t **)avFrame->data, in_samples); |
---|
415 | #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */ |
---|
416 | if (out_samples <= 0) { |
---|
417 | AUBIO_WRN("source_avcodec: no sample found while converting frame (%s)\n", s->path); |
---|
418 | goto beach; |
---|
419 | } |
---|
420 | |
---|
421 | *read_samples = out_samples; |
---|
422 | |
---|
423 | beach: |
---|
424 | s->avFormatCtx = avFormatCtx; |
---|
425 | s->avCodecCtx = avCodecCtx; |
---|
426 | s->avFrame = avFrame; |
---|
427 | #if defined(HAVE_AVRESAMPLE) || defined(HAVE_SWRESAMPLE) |
---|
428 | s->avr = avr; |
---|
429 | #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */ |
---|
430 | s->output = output; |
---|
431 | |
---|
432 | av_packet_unref(&avPacket); |
---|
433 | } |
---|
434 | |
---|
435 | void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data, uint_t * read){ |
---|
436 | uint_t i; |
---|
437 | uint_t end = 0; |
---|
438 | uint_t total_wrote = 0; |
---|
439 | // switch from multi |
---|
440 | if (s->multi == 1) aubio_source_avcodec_reset_resampler(s, 0); |
---|
441 | while (total_wrote < s->hop_size) { |
---|
442 | end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote); |
---|
443 | for (i = 0; i < end; i++) { |
---|
444 | read_data->data[i + total_wrote] = s->output[i + s->read_index]; |
---|
445 | } |
---|
446 | total_wrote += end; |
---|
447 | if (total_wrote < s->hop_size) { |
---|
448 | uint_t avcodec_read = 0; |
---|
449 | aubio_source_avcodec_readframe(s, &avcodec_read); |
---|
450 | s->read_samples = avcodec_read; |
---|
451 | s->read_index = 0; |
---|
452 | if (s->eof) { |
---|
453 | break; |
---|
454 | } |
---|
455 | } else { |
---|
456 | s->read_index += end; |
---|
457 | } |
---|
458 | } |
---|
459 | if (total_wrote < s->hop_size) { |
---|
460 | for (i = total_wrote; i < s->hop_size; i++) { |
---|
461 | read_data->data[i] = 0.; |
---|
462 | } |
---|
463 | } |
---|
464 | *read = total_wrote; |
---|
465 | } |
---|
466 | |
---|
467 | void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s, fmat_t * read_data, uint_t * read){ |
---|
468 | uint_t i,j; |
---|
469 | uint_t end = 0; |
---|
470 | uint_t total_wrote = 0; |
---|
471 | // switch from mono |
---|
472 | if (s->multi == 0) aubio_source_avcodec_reset_resampler(s, 1); |
---|
473 | while (total_wrote < s->hop_size) { |
---|
474 | end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote); |
---|
475 | for (j = 0; j < read_data->height; j++) { |
---|
476 | for (i = 0; i < end; i++) { |
---|
477 | read_data->data[j][i + total_wrote] = |
---|
478 | s->output[(i + s->read_index) * s->input_channels + j]; |
---|
479 | } |
---|
480 | } |
---|
481 | total_wrote += end; |
---|
482 | if (total_wrote < s->hop_size) { |
---|
483 | uint_t avcodec_read = 0; |
---|
484 | aubio_source_avcodec_readframe(s, &avcodec_read); |
---|
485 | s->read_samples = avcodec_read; |
---|
486 | s->read_index = 0; |
---|
487 | if (s->eof) { |
---|
488 | break; |
---|
489 | } |
---|
490 | } else { |
---|
491 | s->read_index += end; |
---|
492 | } |
---|
493 | } |
---|
494 | if (total_wrote < s->hop_size) { |
---|
495 | for (j = 0; j < read_data->height; j++) { |
---|
496 | for (i = total_wrote; i < s->hop_size; i++) { |
---|
497 | read_data->data[j][i] = 0.; |
---|
498 | } |
---|
499 | } |
---|
500 | } |
---|
501 | *read = total_wrote; |
---|
502 | } |
---|
503 | |
---|
504 | uint_t aubio_source_avcodec_get_samplerate(const aubio_source_avcodec_t * s) { |
---|
505 | return s->samplerate; |
---|
506 | } |
---|
507 | |
---|
508 | uint_t aubio_source_avcodec_get_channels(const aubio_source_avcodec_t * s) { |
---|
509 | return s->input_channels; |
---|
510 | } |
---|
511 | |
---|
512 | uint_t aubio_source_avcodec_seek (aubio_source_avcodec_t * s, uint_t pos) { |
---|
513 | int64_t resampled_pos = (uint_t)ROUND(pos * (s->input_samplerate * 1. / s->samplerate)); |
---|
514 | int64_t min_ts = MAX(resampled_pos - 2000, 0); |
---|
515 | int64_t max_ts = MIN(resampled_pos + 2000, INT64_MAX); |
---|
516 | int seek_flags = AVSEEK_FLAG_FRAME | AVSEEK_FLAG_ANY; |
---|
517 | int ret = AUBIO_FAIL; |
---|
518 | if (s->avFormatCtx != NULL && s->avr != NULL) { |
---|
519 | ret = AUBIO_OK; |
---|
520 | } else { |
---|
521 | AUBIO_ERR("source_avcodec: failed seeking in %s (file not opened?)", s->path); |
---|
522 | return ret; |
---|
523 | } |
---|
524 | if ((sint_t)pos < 0) { |
---|
525 | AUBIO_ERR("source_avcodec: could not seek %s at %d (seeking position" |
---|
526 | " should be >= 0)\n", s->path, pos); |
---|
527 | return AUBIO_FAIL; |
---|
528 | } |
---|
529 | ret = avformat_seek_file(s->avFormatCtx, s->selected_stream, |
---|
530 | min_ts, resampled_pos, max_ts, seek_flags); |
---|
531 | if (ret < 0) { |
---|
532 | AUBIO_ERR("source_avcodec: failed seeking to %d in file %s", pos, s->path); |
---|
533 | } |
---|
534 | // reset read status |
---|
535 | s->eof = 0; |
---|
536 | s->read_index = 0; |
---|
537 | s->read_samples = 0; |
---|
538 | #ifdef HAVE_AVRESAMPLE |
---|
539 | // reset the AVAudioResampleContext |
---|
540 | avresample_close(s->avr); |
---|
541 | avresample_open(s->avr); |
---|
542 | #elif defined(HAVE_SWRESAMPLE) |
---|
543 | swr_close(s->avr); |
---|
544 | swr_init(s->avr); |
---|
545 | #endif |
---|
546 | return ret; |
---|
547 | } |
---|
548 | |
---|
549 | uint_t aubio_source_avcodec_get_duration (aubio_source_avcodec_t * s) { |
---|
550 | if (s && &(s->avFormatCtx) != NULL) { |
---|
551 | int64_t duration = s->avFormatCtx->duration; |
---|
552 | return s->samplerate * ((uint_t)duration / 1e6 ); |
---|
553 | } |
---|
554 | return 0; |
---|
555 | } |
---|
556 | |
---|
557 | uint_t aubio_source_avcodec_close(aubio_source_avcodec_t * s) { |
---|
558 | if (s->avr != NULL) { |
---|
559 | #ifdef HAVE_AVRESAMPLE |
---|
560 | avresample_close( s->avr ); |
---|
561 | #elif defined(HAVE_SWRESAMPLE) |
---|
562 | swr_close ( s->avr ); |
---|
563 | #endif |
---|
564 | av_free ( s->avr ); |
---|
565 | } |
---|
566 | s->avr = NULL; |
---|
567 | if (s->avCodecCtx != NULL) { |
---|
568 | #ifndef HAVE_AUBIO_LIBAVCODEC_DEPRECATED |
---|
569 | avcodec_free_context( &s->avCodecCtx ); |
---|
570 | #else |
---|
571 | avcodec_close ( s->avCodecCtx ); |
---|
572 | #endif |
---|
573 | } |
---|
574 | s->avCodecCtx = NULL; |
---|
575 | if (s->avFormatCtx != NULL) { |
---|
576 | avformat_close_input(&s->avFormatCtx); |
---|
577 | #ifndef HAVE_AUBIO_LIBAVCODEC_DEPRECATED // avoid crash on old libavcodec54 |
---|
578 | avformat_free_context(s->avFormatCtx); |
---|
579 | #endif |
---|
580 | s->avFormatCtx = NULL; |
---|
581 | } |
---|
582 | av_packet_unref(&s->avPacket); |
---|
583 | return AUBIO_OK; |
---|
584 | } |
---|
585 | |
---|
586 | void del_aubio_source_avcodec(aubio_source_avcodec_t * s){ |
---|
587 | if (!s) return; |
---|
588 | aubio_source_avcodec_close(s); |
---|
589 | if (s->output != NULL) { |
---|
590 | av_free(s->output); |
---|
591 | } |
---|
592 | s->output = NULL; |
---|
593 | if (s->avFrame != NULL) { |
---|
594 | av_frame_free( &(s->avFrame) ); |
---|
595 | } |
---|
596 | s->avFrame = NULL; |
---|
597 | if (s->path) { |
---|
598 | AUBIO_FREE(s->path); |
---|
599 | } |
---|
600 | s->path = NULL; |
---|
601 | AUBIO_FREE(s); |
---|
602 | } |
---|
603 | |
---|
604 | #endif /* HAVE_LIBAV */ |
---|