[ba0ba10] | 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 | |
---|
| 22 | #include "config.h" |
---|
| 23 | |
---|
[549928e] | 24 | #ifdef HAVE_LIBAV |
---|
[ba0ba10] | 25 | |
---|
[a9c33a2] | 26 | // determine whether we use libavformat from ffmpeg or from libav |
---|
| 27 | #define FFMPEG_LIBAVFORMAT (LIBAVFORMAT_VERSION_MICRO > 99 ) |
---|
| 28 | // max_analyze_duration2 was used from ffmpeg libavformat 55.43.100 through 57.2.100 |
---|
[9ac77ac] | 29 | #define FFMPEG_LIBAVFORMAT_MAX_DUR2 FFMPEG_LIBAVFORMAT && ( \ |
---|
[a9c33a2] | 30 | (LIBAVFORMAT_VERSION_MAJOR == 55 && LIBAVFORMAT_VERSION_MINOR >= 43) \ |
---|
| 31 | || (LIBAVFORMAT_VERSION_MAJOR == 56) \ |
---|
| 32 | || (LIBAVFORMAT_VERSION_MAJOR == 57 && LIBAVFORMAT_VERSION_MINOR < 2) \ |
---|
| 33 | ) |
---|
[2a32644] | 34 | |
---|
[ba0ba10] | 35 | #include <libavcodec/avcodec.h> |
---|
| 36 | #include <libavformat/avformat.h> |
---|
| 37 | #include <libavresample/avresample.h> |
---|
| 38 | #include <libavutil/opt.h> |
---|
| 39 | #include <stdlib.h> |
---|
| 40 | |
---|
| 41 | #include "aubio_priv.h" |
---|
| 42 | #include "fvec.h" |
---|
| 43 | #include "fmat.h" |
---|
| 44 | #include "source_avcodec.h" |
---|
| 45 | |
---|
[0af9003] | 46 | #define AUBIO_AVCODEC_MAX_BUFFER_SIZE FF_MIN_BUFFER_SIZE |
---|
[ba0ba10] | 47 | |
---|
| 48 | struct _aubio_source_avcodec_t { |
---|
| 49 | uint_t hop_size; |
---|
| 50 | uint_t samplerate; |
---|
| 51 | uint_t channels; |
---|
| 52 | |
---|
| 53 | // some data about the file |
---|
| 54 | char_t *path; |
---|
[d3b9fe4] | 55 | uint_t input_samplerate; |
---|
| 56 | uint_t input_channels; |
---|
[ba0ba10] | 57 | |
---|
| 58 | // avcodec stuff |
---|
| 59 | AVFormatContext *avFormatCtx; |
---|
| 60 | AVCodecContext *avCodecCtx; |
---|
| 61 | AVFrame *avFrame; |
---|
| 62 | AVAudioResampleContext *avr; |
---|
[2f89ef4] | 63 | smpl_t *output; |
---|
[d3b9fe4] | 64 | uint_t read_samples; |
---|
| 65 | uint_t read_index; |
---|
[7760b40] | 66 | sint_t selected_stream; |
---|
[eadd8d5] | 67 | uint_t eof; |
---|
[fcd963a] | 68 | uint_t multi; |
---|
[ba0ba10] | 69 | }; |
---|
| 70 | |
---|
[61ecd1a] | 71 | // hack to create or re-create the context the first time _do or _do_multi is called |
---|
| 72 | void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi); |
---|
[029bf4e] | 73 | void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples); |
---|
[fcd963a] | 74 | |
---|
[6769586] | 75 | uint_t aubio_source_avcodec_has_network_url(aubio_source_avcodec_t *s); |
---|
| 76 | |
---|
| 77 | uint_t aubio_source_avcodec_has_network_url(aubio_source_avcodec_t *s) { |
---|
| 78 | char proto[20], authorization[256], hostname[128], uripath[256]; |
---|
| 79 | int proto_size = 20, authorization_size = 256, hostname_size = 128, |
---|
| 80 | *port_ptr = 0, path_size = 256; |
---|
| 81 | av_url_split(proto, proto_size, authorization, authorization_size, hostname, |
---|
| 82 | hostname_size, port_ptr, uripath, path_size, s->path); |
---|
| 83 | if (strlen(proto)) { |
---|
| 84 | return 1; |
---|
| 85 | } |
---|
| 86 | return 0; |
---|
| 87 | } |
---|
| 88 | |
---|
| 89 | |
---|
[ae5d58a] | 90 | aubio_source_avcodec_t * new_aubio_source_avcodec(const char_t * path, uint_t samplerate, uint_t hop_size) { |
---|
[ba0ba10] | 91 | aubio_source_avcodec_t * s = AUBIO_NEW(aubio_source_avcodec_t); |
---|
| 92 | int err; |
---|
| 93 | if (path == NULL) { |
---|
[491e6ea] | 94 | AUBIO_ERR("source_avcodec: Aborted opening null path\n"); |
---|
[b294b3e] | 95 | goto beach; |
---|
| 96 | } |
---|
| 97 | if ((sint_t)samplerate < 0) { |
---|
[491e6ea] | 98 | AUBIO_ERR("source_avcodec: Can not open %s with samplerate %d\n", path, samplerate); |
---|
[b294b3e] | 99 | goto beach; |
---|
| 100 | } |
---|
| 101 | if ((sint_t)hop_size <= 0) { |
---|
[491e6ea] | 102 | AUBIO_ERR("source_avcodec: Can not open %s with hop_size %d\n", path, hop_size); |
---|
[b294b3e] | 103 | goto beach; |
---|
[ba0ba10] | 104 | } |
---|
| 105 | |
---|
| 106 | s->hop_size = hop_size; |
---|
| 107 | s->channels = 1; |
---|
[b643a33] | 108 | |
---|
| 109 | if (s->path) AUBIO_FREE(s->path); |
---|
[d2be104] | 110 | s->path = AUBIO_ARRAY(char_t, strnlen(path, PATH_MAX) + 1); |
---|
| 111 | strncpy(s->path, path, strnlen(path, PATH_MAX) + 1); |
---|
[ba0ba10] | 112 | |
---|
| 113 | // register all formats and codecs |
---|
| 114 | av_register_all(); |
---|
| 115 | |
---|
[6769586] | 116 | if (aubio_source_avcodec_has_network_url(s)) { |
---|
| 117 | avformat_network_init(); |
---|
| 118 | } |
---|
[eadd8d5] | 119 | |
---|
[d75e2d5] | 120 | // try opening the file and get some info about it |
---|
[ba0ba10] | 121 | AVFormatContext *avFormatCtx = s->avFormatCtx; |
---|
| 122 | avFormatCtx = NULL; |
---|
| 123 | if ( (err = avformat_open_input(&avFormatCtx, s->path, NULL, NULL) ) < 0 ) { |
---|
[0af9003] | 124 | char errorstr[256]; |
---|
| 125 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
[491e6ea] | 126 | AUBIO_ERR("source_avcodec: Failed opening %s (%s)\n", s->path, errorstr); |
---|
[ba0ba10] | 127 | goto beach; |
---|
| 128 | } |
---|
| 129 | |
---|
[6abb4de] | 130 | // try to make sure max_analyze_duration is big enough for most songs |
---|
[a9c33a2] | 131 | #if FFMPEG_LIBAVFORMAT_MAX_DUR2 |
---|
[2a32644] | 132 | avFormatCtx->max_analyze_duration2 *= 100; |
---|
| 133 | #else |
---|
[6abb4de] | 134 | avFormatCtx->max_analyze_duration *= 100; |
---|
[2a32644] | 135 | #endif |
---|
[6abb4de] | 136 | |
---|
[ba0ba10] | 137 | // retrieve stream information |
---|
| 138 | if ( (err = avformat_find_stream_info(avFormatCtx, NULL)) < 0 ) { |
---|
[0af9003] | 139 | char errorstr[256]; |
---|
| 140 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
[491e6ea] | 141 | AUBIO_ERR("source_avcodec: Could not find stream information " "for %s (%s)\n", s->path, |
---|
[0af9003] | 142 | errorstr); |
---|
[ba0ba10] | 143 | goto beach; |
---|
| 144 | } |
---|
| 145 | |
---|
[1fe3ac2] | 146 | // dump information about file onto standard error |
---|
[ba0ba10] | 147 | //av_dump_format(avFormatCtx, 0, s->path, 0); |
---|
| 148 | |
---|
[1fe3ac2] | 149 | // look for the first audio stream |
---|
[ba0ba10] | 150 | uint_t i; |
---|
| 151 | sint_t selected_stream = -1; |
---|
| 152 | for (i = 0; i < avFormatCtx->nb_streams; i++) { |
---|
[2b3c438] | 153 | #if FF_API_LAVF_AVCTX |
---|
| 154 | if (avFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { |
---|
| 155 | #else |
---|
[ba0ba10] | 156 | if (avFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) { |
---|
[2b3c438] | 157 | #endif |
---|
[ba0ba10] | 158 | if (selected_stream == -1) { |
---|
| 159 | selected_stream = i; |
---|
| 160 | } else { |
---|
[491e6ea] | 161 | AUBIO_WRN("source_avcodec: More than one audio stream in %s, " |
---|
[1fe3ac2] | 162 | "taking the first one\n", s->path); |
---|
[ba0ba10] | 163 | } |
---|
| 164 | } |
---|
| 165 | } |
---|
| 166 | if (selected_stream == -1) { |
---|
[491e6ea] | 167 | AUBIO_ERR("source_avcodec: No audio stream in %s\n", s->path); |
---|
[ba0ba10] | 168 | goto beach; |
---|
[d3b9fe4] | 169 | } |
---|
[eadd8d5] | 170 | //AUBIO_DBG("Taking stream %d in file %s\n", selected_stream, s->path); |
---|
[7760b40] | 171 | s->selected_stream = selected_stream; |
---|
[ba0ba10] | 172 | |
---|
| 173 | AVCodecContext *avCodecCtx = s->avCodecCtx; |
---|
[2b3c438] | 174 | #if FF_API_LAVF_AVCTX |
---|
| 175 | AVCodecParameters *codecpar = avFormatCtx->streams[selected_stream]->codecpar; |
---|
| 176 | if (codecpar == NULL) { |
---|
| 177 | AUBIO_ERR("source_avcodec: Could not find decoder for %s", s->path); |
---|
| 178 | goto beach; |
---|
| 179 | } |
---|
| 180 | AVCodec *codec = avcodec_find_decoder(codecpar->codec_id); |
---|
| 181 | |
---|
| 182 | /* Allocate a codec context for the decoder */ |
---|
| 183 | avCodecCtx = avcodec_alloc_context3(codec); |
---|
| 184 | if (!avCodecCtx) { |
---|
| 185 | AUBIO_ERR("source_avcodec: Failed to allocate the %s codec context for path %s\n", |
---|
| 186 | av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path); |
---|
| 187 | goto beach; |
---|
| 188 | } |
---|
| 189 | #else |
---|
[d3b9fe4] | 190 | avCodecCtx = avFormatCtx->streams[selected_stream]->codec; |
---|
[ba0ba10] | 191 | AVCodec *codec = avcodec_find_decoder(avCodecCtx->codec_id); |
---|
[2b3c438] | 192 | #endif |
---|
[ba0ba10] | 193 | if (codec == NULL) { |
---|
[491e6ea] | 194 | AUBIO_ERR("source_avcodec: Could not find decoder for %s", s->path); |
---|
[ba0ba10] | 195 | goto beach; |
---|
| 196 | } |
---|
| 197 | |
---|
[2b3c438] | 198 | #if FF_API_LAVF_AVCTX |
---|
| 199 | /* Copy codec parameters from input stream to output codec context */ |
---|
| 200 | if ((err = avcodec_parameters_to_context(avCodecCtx, codecpar)) < 0) { |
---|
| 201 | AUBIO_ERR("source_avcodec: Failed to copy %s codec parameters to decoder context for %s\n", |
---|
| 202 | av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path); |
---|
| 203 | goto beach; |
---|
| 204 | } |
---|
| 205 | #endif |
---|
| 206 | |
---|
[ba0ba10] | 207 | if ( ( err = avcodec_open2(avCodecCtx, codec, NULL) ) < 0) { |
---|
[0af9003] | 208 | char errorstr[256]; |
---|
| 209 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
[491e6ea] | 210 | AUBIO_ERR("source_avcodec: Could not load codec for %s (%s)\n", s->path, errorstr); |
---|
[ba0ba10] | 211 | goto beach; |
---|
| 212 | } |
---|
| 213 | |
---|
| 214 | /* get input specs */ |
---|
| 215 | s->input_samplerate = avCodecCtx->sample_rate; |
---|
| 216 | s->input_channels = avCodecCtx->channels; |
---|
| 217 | //AUBIO_DBG("input_samplerate: %d\n", s->input_samplerate); |
---|
| 218 | //AUBIO_DBG("input_channels: %d\n", s->input_channels); |
---|
| 219 | |
---|
| 220 | if (samplerate == 0) { |
---|
[26a6af7] | 221 | s->samplerate = s->input_samplerate; |
---|
| 222 | } else { |
---|
| 223 | s->samplerate = samplerate; |
---|
[ba0ba10] | 224 | } |
---|
| 225 | |
---|
[018e511] | 226 | if (s->samplerate > s->input_samplerate) { |
---|
[491e6ea] | 227 | AUBIO_WRN("source_avcodec: upsampling %s from %d to %d\n", s->path, |
---|
[018e511] | 228 | s->input_samplerate, s->samplerate); |
---|
| 229 | } |
---|
| 230 | |
---|
[ba0ba10] | 231 | AVFrame *avFrame = s->avFrame; |
---|
[cd4c997] | 232 | avFrame = av_frame_alloc(); |
---|
[ba0ba10] | 233 | if (!avFrame) { |
---|
[491e6ea] | 234 | AUBIO_ERR("source_avcodec: Could not allocate frame for (%s)\n", s->path); |
---|
[ba0ba10] | 235 | } |
---|
| 236 | |
---|
[d3b9fe4] | 237 | /* allocate output for avr */ |
---|
[2f89ef4] | 238 | s->output = (smpl_t *)av_malloc(AUBIO_AVCODEC_MAX_BUFFER_SIZE * sizeof(smpl_t)); |
---|
[ba0ba10] | 239 | |
---|
| 240 | s->read_samples = 0; |
---|
| 241 | s->read_index = 0; |
---|
| 242 | |
---|
| 243 | s->avFormatCtx = avFormatCtx; |
---|
| 244 | s->avCodecCtx = avCodecCtx; |
---|
| 245 | s->avFrame = avFrame; |
---|
[fcd963a] | 246 | |
---|
| 247 | // default to mono output |
---|
[61ecd1a] | 248 | aubio_source_avcodec_reset_resampler(s, 0); |
---|
[ba0ba10] | 249 | |
---|
[eadd8d5] | 250 | s->eof = 0; |
---|
[fcd963a] | 251 | s->multi = 0; |
---|
[eadd8d5] | 252 | |
---|
[ba0ba10] | 253 | //av_log_set_level(AV_LOG_QUIET); |
---|
| 254 | |
---|
| 255 | return s; |
---|
| 256 | |
---|
| 257 | beach: |
---|
[fcd963a] | 258 | //AUBIO_ERR("can not read %s at samplerate %dHz with a hop_size of %d\n", |
---|
| 259 | // s->path, s->samplerate, s->hop_size); |
---|
[ba0ba10] | 260 | del_aubio_source_avcodec(s); |
---|
| 261 | return NULL; |
---|
| 262 | } |
---|
| 263 | |
---|
[61ecd1a] | 264 | void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi) { |
---|
[2f89ef4] | 265 | // create or reset resampler to/from mono/multi-channel |
---|
[61ecd1a] | 266 | if ( (multi != s->multi) || (s->avr == NULL) ) { |
---|
| 267 | int64_t input_layout = av_get_default_channel_layout(s->input_channels); |
---|
| 268 | uint_t output_channels = multi ? s->input_channels : 1; |
---|
| 269 | int64_t output_layout = av_get_default_channel_layout(output_channels); |
---|
[7cc80b6] | 270 | AVAudioResampleContext *avr = avresample_alloc_context(); |
---|
| 271 | AVAudioResampleContext *oldavr = s->avr; |
---|
[61ecd1a] | 272 | |
---|
| 273 | av_opt_set_int(avr, "in_channel_layout", input_layout, 0); |
---|
| 274 | av_opt_set_int(avr, "out_channel_layout", output_layout, 0); |
---|
| 275 | av_opt_set_int(avr, "in_sample_rate", s->input_samplerate, 0); |
---|
| 276 | av_opt_set_int(avr, "out_sample_rate", s->samplerate, 0); |
---|
| 277 | av_opt_set_int(avr, "in_sample_fmt", s->avCodecCtx->sample_fmt, 0); |
---|
[2f89ef4] | 278 | #if HAVE_AUBIO_DOUBLE |
---|
| 279 | av_opt_set_int(avr, "out_sample_fmt", AV_SAMPLE_FMT_DBL, 0); |
---|
| 280 | #else |
---|
[61ecd1a] | 281 | av_opt_set_int(avr, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0); |
---|
[2f89ef4] | 282 | #endif |
---|
| 283 | // TODO: use planar? |
---|
| 284 | //av_opt_set_int(avr, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0); |
---|
[61ecd1a] | 285 | int err; |
---|
| 286 | if ( ( err = avresample_open(avr) ) < 0) { |
---|
| 287 | char errorstr[256]; |
---|
| 288 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
[491e6ea] | 289 | AUBIO_ERR("source_avcodec: Could not open AVAudioResampleContext for %s (%s)\n", |
---|
[61ecd1a] | 290 | s->path, errorstr); |
---|
| 291 | //goto beach; |
---|
| 292 | return; |
---|
| 293 | } |
---|
| 294 | s->avr = avr; |
---|
[7cc80b6] | 295 | if (oldavr != NULL) { |
---|
| 296 | avresample_close( oldavr ); |
---|
| 297 | av_free ( oldavr ); |
---|
| 298 | oldavr = NULL; |
---|
| 299 | } |
---|
[61ecd1a] | 300 | s->multi = multi; |
---|
| 301 | } |
---|
| 302 | } |
---|
| 303 | |
---|
[d3b9fe4] | 304 | void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples) { |
---|
[ba0ba10] | 305 | AVFormatContext *avFormatCtx = s->avFormatCtx; |
---|
| 306 | AVCodecContext *avCodecCtx = s->avCodecCtx; |
---|
| 307 | AVFrame *avFrame = s->avFrame; |
---|
[f3b93c6] | 308 | AVPacket avPacket; |
---|
| 309 | av_init_packet (&avPacket); |
---|
[ba0ba10] | 310 | AVAudioResampleContext *avr = s->avr; |
---|
[877b3b8] | 311 | smpl_t *output = s->output; |
---|
[0af9003] | 312 | *read_samples = 0; |
---|
[ba0ba10] | 313 | |
---|
[7760b40] | 314 | do |
---|
| 315 | { |
---|
| 316 | int err = av_read_frame (avFormatCtx, &avPacket); |
---|
[0af9003] | 317 | if (err == AVERROR_EOF) { |
---|
| 318 | s->eof = 1; |
---|
| 319 | goto beach; |
---|
| 320 | } |
---|
[7760b40] | 321 | if (err != 0) { |
---|
[0af9003] | 322 | char errorstr[256]; |
---|
| 323 | av_strerror (err, errorstr, sizeof(errorstr)); |
---|
[8d41c1d] | 324 | AUBIO_ERR("source_avcodec: could not read frame in %s (%s)\n", s->path, errorstr); |
---|
[0af9003] | 325 | goto beach; |
---|
[7760b40] | 326 | } |
---|
| 327 | } while (avPacket.stream_index != s->selected_stream); |
---|
[ba0ba10] | 328 | |
---|
| 329 | int got_frame = 0; |
---|
[2b3c438] | 330 | #if FF_API_LAVF_AVCTX |
---|
| 331 | int ret = avcodec_send_packet(avCodecCtx, &avPacket); |
---|
| 332 | if (ret < 0 && ret != AVERROR_EOF) { |
---|
| 333 | AUBIO_ERR("source_avcodec: error when sending packet for %s\n", s->path); |
---|
| 334 | goto beach; |
---|
| 335 | } |
---|
| 336 | ret = avcodec_receive_frame(avCodecCtx, avFrame); |
---|
| 337 | if (ret >= 0) { |
---|
| 338 | got_frame = 1; |
---|
| 339 | } |
---|
| 340 | if (ret < 0) { |
---|
| 341 | if (ret == AVERROR(EAGAIN)) { |
---|
| 342 | AUBIO_WRN("source_avcodec: output is not available right now - user must try to send new input\n"); |
---|
| 343 | } else if (ret == AVERROR_EOF) { |
---|
| 344 | AUBIO_WRN("source_avcodec: the decoder has been fully flushed, and there will be no more output frames\n"); |
---|
| 345 | } else { |
---|
| 346 | AUBIO_ERR("source_avcodec: decoding errors on %s\n", s->path); |
---|
| 347 | goto beach; |
---|
| 348 | } |
---|
| 349 | } |
---|
| 350 | #else |
---|
[ba0ba10] | 351 | int len = avcodec_decode_audio4(avCodecCtx, avFrame, &got_frame, &avPacket); |
---|
| 352 | |
---|
| 353 | if (len < 0) { |
---|
| 354 | AUBIO_ERR("Error while decoding %s\n", s->path); |
---|
[0af9003] | 355 | goto beach; |
---|
[ba0ba10] | 356 | } |
---|
[2b3c438] | 357 | #endif |
---|
[ba0ba10] | 358 | if (got_frame == 0) { |
---|
[eadd8d5] | 359 | //AUBIO_ERR("Could not get frame for (%s)\n", s->path); |
---|
[0af9003] | 360 | goto beach; |
---|
| 361 | } |
---|
| 362 | |
---|
| 363 | int in_linesize = 0; |
---|
| 364 | av_samples_get_buffer_size(&in_linesize, avCodecCtx->channels, |
---|
| 365 | avFrame->nb_samples, avCodecCtx->sample_fmt, 1); |
---|
[ba0ba10] | 366 | int in_samples = avFrame->nb_samples; |
---|
[0af9003] | 367 | int out_linesize = 0; |
---|
| 368 | int max_out_samples = AUBIO_AVCODEC_MAX_BUFFER_SIZE; |
---|
[0044b43] | 369 | int out_samples = avresample_convert ( avr, |
---|
[0af9003] | 370 | (uint8_t **)&output, out_linesize, max_out_samples, |
---|
| 371 | (uint8_t **)avFrame->data, in_linesize, in_samples); |
---|
| 372 | if (out_samples <= 0) { |
---|
[5c6acbb2] | 373 | //AUBIO_ERR("No sample found while converting frame (%s)\n", s->path); |
---|
[0af9003] | 374 | goto beach; |
---|
[ba0ba10] | 375 | } |
---|
| 376 | |
---|
[0af9003] | 377 | *read_samples = out_samples; |
---|
| 378 | |
---|
| 379 | beach: |
---|
[ba0ba10] | 380 | s->avFormatCtx = avFormatCtx; |
---|
| 381 | s->avCodecCtx = avCodecCtx; |
---|
| 382 | s->avFrame = avFrame; |
---|
| 383 | s->avr = avr; |
---|
| 384 | s->output = output; |
---|
| 385 | |
---|
[a9c33a2] | 386 | av_packet_unref(&avPacket); |
---|
[ba0ba10] | 387 | } |
---|
| 388 | |
---|
| 389 | void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data, uint_t * read){ |
---|
[61ecd1a] | 390 | if (s->multi == 1) aubio_source_avcodec_reset_resampler(s, 0); |
---|
[ba0ba10] | 391 | uint_t i; |
---|
[eadd8d5] | 392 | uint_t end = 0; |
---|
| 393 | uint_t total_wrote = 0; |
---|
| 394 | while (total_wrote < s->hop_size) { |
---|
| 395 | end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote); |
---|
| 396 | for (i = 0; i < end; i++) { |
---|
[3d5cddf] | 397 | read_data->data[i + total_wrote] = s->output[i + s->read_index]; |
---|
[ba0ba10] | 398 | } |
---|
[eadd8d5] | 399 | total_wrote += end; |
---|
| 400 | if (total_wrote < s->hop_size) { |
---|
| 401 | uint_t avcodec_read = 0; |
---|
| 402 | aubio_source_avcodec_readframe(s, &avcodec_read); |
---|
| 403 | s->read_samples = avcodec_read; |
---|
| 404 | s->read_index = 0; |
---|
| 405 | if (s->eof) { |
---|
| 406 | break; |
---|
[ba0ba10] | 407 | } |
---|
[eadd8d5] | 408 | } else { |
---|
| 409 | s->read_index += end; |
---|
[ba0ba10] | 410 | } |
---|
[eadd8d5] | 411 | } |
---|
| 412 | if (total_wrote < s->hop_size) { |
---|
[eacc55c] | 413 | for (i = total_wrote; i < s->hop_size; i++) { |
---|
[eadd8d5] | 414 | read_data->data[i] = 0.; |
---|
[ba0ba10] | 415 | } |
---|
| 416 | } |
---|
[eadd8d5] | 417 | *read = total_wrote; |
---|
[ba0ba10] | 418 | } |
---|
| 419 | |
---|
| 420 | void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s, fmat_t * read_data, uint_t * read){ |
---|
[61ecd1a] | 421 | if (s->multi == 0) aubio_source_avcodec_reset_resampler(s, 1); |
---|
[fcd963a] | 422 | uint_t i,j; |
---|
| 423 | uint_t end = 0; |
---|
| 424 | uint_t total_wrote = 0; |
---|
| 425 | while (total_wrote < s->hop_size) { |
---|
| 426 | end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote); |
---|
| 427 | for (j = 0; j < read_data->height; j++) { |
---|
| 428 | for (i = 0; i < end; i++) { |
---|
| 429 | read_data->data[j][i + total_wrote] = |
---|
| 430 | s->output[(i + s->read_index) * s->input_channels + j]; |
---|
| 431 | } |
---|
| 432 | } |
---|
| 433 | total_wrote += end; |
---|
| 434 | if (total_wrote < s->hop_size) { |
---|
| 435 | uint_t avcodec_read = 0; |
---|
| 436 | aubio_source_avcodec_readframe(s, &avcodec_read); |
---|
| 437 | s->read_samples = avcodec_read; |
---|
| 438 | s->read_index = 0; |
---|
| 439 | if (s->eof) { |
---|
| 440 | break; |
---|
| 441 | } |
---|
| 442 | } else { |
---|
| 443 | s->read_index += end; |
---|
| 444 | } |
---|
| 445 | } |
---|
| 446 | if (total_wrote < s->hop_size) { |
---|
| 447 | for (j = 0; j < read_data->height; j++) { |
---|
[eacc55c] | 448 | for (i = total_wrote; i < s->hop_size; i++) { |
---|
[fcd963a] | 449 | read_data->data[j][i] = 0.; |
---|
| 450 | } |
---|
| 451 | } |
---|
| 452 | } |
---|
| 453 | *read = total_wrote; |
---|
[ba0ba10] | 454 | } |
---|
| 455 | |
---|
[ae5d58a] | 456 | uint_t aubio_source_avcodec_get_samplerate(const aubio_source_avcodec_t * s) { |
---|
[ba0ba10] | 457 | return s->samplerate; |
---|
| 458 | } |
---|
| 459 | |
---|
[ae5d58a] | 460 | uint_t aubio_source_avcodec_get_channels(const aubio_source_avcodec_t * s) { |
---|
[ba0ba10] | 461 | return s->input_channels; |
---|
| 462 | } |
---|
| 463 | |
---|
| 464 | uint_t aubio_source_avcodec_seek (aubio_source_avcodec_t * s, uint_t pos) { |
---|
[50bb325] | 465 | int64_t resampled_pos = (uint_t)ROUND(pos * (s->input_samplerate * 1. / s->samplerate)); |
---|
| 466 | int64_t min_ts = MAX(resampled_pos - 2000, 0); |
---|
| 467 | int64_t max_ts = MIN(resampled_pos + 2000, INT64_MAX); |
---|
| 468 | int seek_flags = AVSEEK_FLAG_FRAME | AVSEEK_FLAG_ANY; |
---|
| 469 | int ret = avformat_seek_file(s->avFormatCtx, s->selected_stream, |
---|
| 470 | min_ts, resampled_pos, max_ts, seek_flags); |
---|
| 471 | if (ret < 0) { |
---|
| 472 | AUBIO_ERR("Failed seeking to %d in file %s", pos, s->path); |
---|
| 473 | } |
---|
| 474 | // reset read status |
---|
| 475 | s->eof = 0; |
---|
| 476 | s->read_index = 0; |
---|
| 477 | s->read_samples = 0; |
---|
| 478 | // reset the AVAudioResampleContext |
---|
| 479 | avresample_close(s->avr); |
---|
| 480 | avresample_open(s->avr); |
---|
| 481 | return ret; |
---|
[ba0ba10] | 482 | } |
---|
| 483 | |
---|
[2d071ad] | 484 | uint_t aubio_source_avcodec_get_duration (aubio_source_avcodec_t * s) { |
---|
| 485 | if (s && &(s->avFormatCtx) != NULL) { |
---|
| 486 | int64_t duration = s->avFormatCtx->duration; |
---|
| 487 | return s->samplerate * ((uint_t)duration / 1e6 ); |
---|
| 488 | } |
---|
| 489 | return 0; |
---|
| 490 | } |
---|
| 491 | |
---|
[422452b] | 492 | uint_t aubio_source_avcodec_close(aubio_source_avcodec_t * s) { |
---|
[ba0ba10] | 493 | if (s->avr != NULL) { |
---|
| 494 | avresample_close( s->avr ); |
---|
| 495 | av_free ( s->avr ); |
---|
| 496 | } |
---|
| 497 | s->avr = NULL; |
---|
| 498 | if (s->avCodecCtx != NULL) { |
---|
| 499 | avcodec_close ( s->avCodecCtx ); |
---|
| 500 | } |
---|
| 501 | s->avCodecCtx = NULL; |
---|
| 502 | if (s->avFormatCtx != NULL) { |
---|
| 503 | avformat_close_input ( &(s->avFormatCtx) ); |
---|
| 504 | } |
---|
| 505 | s->avFormatCtx = NULL; |
---|
[422452b] | 506 | return AUBIO_OK; |
---|
| 507 | } |
---|
| 508 | |
---|
| 509 | void del_aubio_source_avcodec(aubio_source_avcodec_t * s){ |
---|
| 510 | if (!s) return; |
---|
| 511 | aubio_source_avcodec_close(s); |
---|
| 512 | if (s->output != NULL) { |
---|
| 513 | av_free(s->output); |
---|
| 514 | } |
---|
| 515 | s->output = NULL; |
---|
| 516 | if (s->avFrame != NULL) { |
---|
[cd4c997] | 517 | av_frame_free( &(s->avFrame) ); |
---|
[422452b] | 518 | } |
---|
[b643a33] | 519 | if (s->path) AUBIO_FREE(s->path); |
---|
[422452b] | 520 | s->avFrame = NULL; |
---|
[ba0ba10] | 521 | AUBIO_FREE(s); |
---|
| 522 | } |
---|
| 523 | |
---|
[549928e] | 524 | #endif /* HAVE_LIBAV */ |
---|