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