From: Paul Brossier Date: Thu, 5 Dec 2013 02:40:44 +0000 (-0500) Subject: src/io/source_avcodec.c: added first draft X-Git-Tag: 0.4.0-beta1~52^2~23 X-Git-Url: https://git.aubio.org/?p=aubio.git;a=commitdiff_plain;h=ba0ba1066d77d8c8c1ddcf16c2661ed65a52375d src/io/source_avcodec.c: added first draft --- diff --git a/src/io/source_avcodec.c b/src/io/source_avcodec.c new file mode 100644 index 00000000..0f0e801f --- /dev/null +++ b/src/io/source_avcodec.c @@ -0,0 +1,414 @@ +/* + Copyright (C) 2013 Paul Brossier + + This file is part of aubio. + + aubio is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + aubio is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with aubio. If not, see . + +*/ + + +#include "config.h" + +#ifdef HAVE_AVCODEC + +#include +#include +#include +#include +#include +#include + +#include "aubio_priv.h" +#include "fvec.h" +#include "fmat.h" +#include "source_avcodec.h" + +#define MAX_CHANNELS 6 +#define MAX_SIZE 4096 +#define MAX_SAMPLES MAX_CHANNELS * MAX_SIZE + +#define SHORT_TO_FLOAT(x) (smpl_t)(x * 3.0517578125e-05) + +struct _aubio_source_avcodec_t { + uint_t hop_size; + uint_t samplerate; + uint_t channels; + + // some data about the file + char_t *path; + int input_samplerate; + int input_channels; + + // avcodec stuff + AVFormatContext *avFormatCtx; + AVCodecContext *avCodecCtx; + AVFrame *avFrame; + AVPacket avPacket; + AVAudioResampleContext *avr; + int16_t *output; + int read_samples; + int read_index; +}; + +aubio_source_avcodec_t * new_aubio_source_avcodec(char_t * path, uint_t samplerate, uint_t hop_size) { + aubio_source_avcodec_t * s = AUBIO_NEW(aubio_source_avcodec_t); + int err; + + if (path == NULL) { + AUBIO_ERR("Aborted opening null path\n"); + return NULL; + } + + s->hop_size = hop_size; + s->channels = 1; + s->path = path; + + // try opening the file and get some info about it + // register all formats and codecs + av_register_all(); + + // open file + AVFormatContext *avFormatCtx = s->avFormatCtx; + avFormatCtx = NULL; + if ( (err = avformat_open_input(&avFormatCtx, s->path, NULL, NULL) ) < 0 ) { + uint8_t errorstr_len = 128; + char errorstr[errorstr_len]; + if (av_strerror (err, errorstr, errorstr_len) == 0) { + AUBIO_ERR("Failed opening %s (%s)\n", s->path, errorstr); + } else { + AUBIO_ERR("Failed opening %s (unknown error)\n", s->path); + } + goto beach; + } + + // retrieve stream information + if ( (err = avformat_find_stream_info(avFormatCtx, NULL)) < 0 ) { + uint8_t errorstr_len = 128; + char errorstr[errorstr_len]; + if (av_strerror (err, errorstr, errorstr_len) == 0) { + AUBIO_ERR("Could not find stream information for %s (%s)\n", s->path, errorstr); + } else { + AUBIO_ERR("Could not find stream information for %s (unknown error)\n", s->path); + } + goto beach; + } + + // Dump information about file onto standard error + //av_dump_format(avFormatCtx, 0, s->path, 0); + + uint_t i; + sint_t selected_stream = -1; + for (i = 0; i < avFormatCtx->nb_streams; i++) { + if (avFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) { + if (selected_stream == -1) { + selected_stream = i; + } else { + AUBIO_WRN("More than one audio stream in %s, taking the first one\n", s->path); + } + } + } + if (selected_stream == -1) { + AUBIO_ERR("No audio stream in %s\n", s->path); + goto beach; + } + + //AUBIO_DBG("Taking stream %d in file %s\n", selected_stream, s->path); + + AVCodecContext *avCodecCtx = s->avCodecCtx; + avCodecCtx = avFormatCtx->streams[selected_stream]->codec; + AVCodec *codec = avcodec_find_decoder(avCodecCtx->codec_id); + if (codec == NULL) { + AUBIO_ERR("Could not find decoder for %s", s->path); + goto beach; + } + + if ( ( err = avcodec_open2(avCodecCtx, codec, NULL) ) < 0) { + uint8_t errorstr_len = 128; + char errorstr[errorstr_len]; + if (av_strerror (err, errorstr, errorstr_len) == 0) { + AUBIO_ERR("Could not load codec for %s (%s)\n", s->path, errorstr); + } else { + AUBIO_ERR("Could not load codec for %s (unknown error)\n", s->path); + } + goto beach; + } + + /* get input specs */ + s->input_samplerate = avCodecCtx->sample_rate; + s->input_channels = avCodecCtx->channels; + + //AUBIO_DBG("input_samplerate: %d\n", s->input_samplerate); + //AUBIO_DBG("input_channels: %d\n", s->input_channels); + + if (samplerate == 0) { + samplerate = s->input_samplerate; + //AUBIO_DBG("sampling rate set to 0, automagically adjusting to %d\n", samplerate); + } + s->samplerate = samplerate; + + int64_t input_layout = av_get_default_channel_layout(s->input_channels); + int64_t mono_layout = av_get_default_channel_layout(1); + + AVAudioResampleContext *avr = s->avr; + avr = avresample_alloc_context(); + av_opt_set_int(avr, "in_channel_layout", input_layout, 0); + av_opt_set_int(avr, "out_channel_layout", mono_layout, 0); + av_opt_set_int(avr, "in_sample_rate", s->input_samplerate, 0); + av_opt_set_int(avr, "out_sample_rate", s->samplerate, 0); + av_opt_set_int(avr, "in_sample_fmt", avCodecCtx->sample_fmt, 0); + av_opt_set_int(avr, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0); + if ( ( err = avresample_open(avr) ) < 0) { + uint8_t errorstr_len = 128; + char errorstr[errorstr_len]; + if (av_strerror (err, errorstr, errorstr_len) == 0) { + AUBIO_ERR("Could not open AVAudioResampleContext for %s (%s)\n", s->path, errorstr); + } else { + AUBIO_ERR("Could not open AVAudioResampleContext for %s (unknown error)\n", s->path); + } + goto beach; + } + + AVFrame *avFrame = s->avFrame; + avFrame = avcodec_alloc_frame(); + if (!avFrame) { + AUBIO_ERR("Could not allocate frame for (%s)\n", s->path); + } + AVPacket avPacket = s->avPacket; + av_init_packet(&avPacket); + + s->output = (int16_t *)av_malloc(FF_MIN_BUFFER_SIZE * sizeof(int16_t)); + + + s->read_samples = 0; + s->read_index = 0; + + //goto beach; + + /* allocate data for de/interleaving reallocated when needed. */ + //s->scratch_size = s->input_hop_size * s->input_channels; + //s->scratch_data = AUBIO_ARRAY(float,s->scratch_size); + s->avFormatCtx = avFormatCtx; + s->avCodecCtx = avCodecCtx; + s->avFrame = avFrame; + s->avPacket = avPacket; + s->avr = avr; + + //av_log_set_level(AV_LOG_QUIET); + + return s; + +beach: + AUBIO_ERR("can not read %s at samplerate %dHz with a hop_size of %d\n", + s->path, s->samplerate, s->hop_size); + del_aubio_source_avcodec(s); + return NULL; +} + +void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, int * read_samples) { + AVFormatContext *avFormatCtx = s->avFormatCtx; + AVCodecContext *avCodecCtx = s->avCodecCtx; + AVFrame *avFrame = s->avFrame; + AVPacket avPacket = s->avPacket; + AVAudioResampleContext *avr = s->avr; + int16_t *output = s->output; + + uint_t i; + int err = av_read_frame (avFormatCtx, &avPacket); + if (err != 0) { + //AUBIO_ERR("Could not read frame for (%s)\n", s->path); + *read_samples = 0; + return; + } + + int got_frame = 0; + int len = avcodec_decode_audio4(avCodecCtx, avFrame, &got_frame, &avPacket); + + if (len < 0) { + AUBIO_ERR("Error while decoding %s\n", s->path); + //goto beach; + return; + } + if (got_frame == 0) { + AUBIO_ERR("Could not get frame for (%s)\n", s->path); + } else { + //int data_size = + av_samples_get_buffer_size(NULL, + avCodecCtx->channels, avFrame->nb_samples, + avCodecCtx->sample_fmt, 1); + //AUBIO_WRN("Got data_size %d frame for (%s)\n", data_size, s->path); + } + + int in_samples = avFrame->nb_samples; + for (i = 0; i < in_samples; i ++) { + //AUBIO_WRN("%d\n", avFrame->data[i]); + } + + +#if 1 + int in_plane_size = 0; //avFrame->linesize[0]; + int out_plane_size = 0; //sizeof(float); //in_samples * sizeof(float); + int max_out_samples = FF_MIN_BUFFER_SIZE; + if (avresample_convert ( avr, + (void **)&output, out_plane_size, max_out_samples, + (void **)avFrame->data, in_plane_size, in_samples) < 0) { + AUBIO_ERR("Could not convert frame (%s)\n", s->path); + } + //AUBIO_ERR("Got in_plane_size %d frame for (%s)\n", in_plane_size, s->path); + //AUBIO_WRN("Delay is %d for %s\n", avresample_get_delay(avr), s->path); + //AUBIO_WRN("max_out_samples is %d for FF_MIN_BUFFER_SIZE %d\n", + // max_out_samples, FF_MIN_BUFFER_SIZE); + + int out_samples = avresample_available(avr) + (avresample_get_delay(avr) + + in_samples) * s->samplerate / s->input_samplerate; + //AUBIO_WRN("Converted %d to %d samples\n", in_samples, out_samples); + for (i = 0; i < out_samples; i ++) { + //AUBIO_DBG("%f\n", SHORT_TO_FLOAT(output[i])); + } +#else + int in_plane_size = 0; //avFrame->linesize[0]; + int out_plane_size = 0; //sizeof(float); //in_samples * sizeof(float); + int max_out_samples = FF_MIN_BUFFER_SIZE; + if (avresample_convert ( avr, + NULL, out_plane_size, max_out_samples, + (uint8_t **)avFrame->data, in_plane_size, in_samples) < 0) { + AUBIO_ERR("Could not convert frame (%s)\n", s->path); + } + AUBIO_ERR("Got in_plane_size %d frame for (%s)\n", in_plane_size, s->path); + AUBIO_WRN("Delay is %d for %s\n", avresample_get_delay(avr), s->path); + AUBIO_WRN("max_out_samples is %d for FF_MIN_BUFFER_SIZE %d\n", + max_out_samples, FF_MIN_BUFFER_SIZE); + + //int out_samples = avresample_available (avr) + + // (avresample_get_delay(avr) + in_samples) * s->samplerate / s->input_samplerate; + int out_samples = avresample_available(avr); + AUBIO_WRN("Found %d samples available for %s\n", avresample_available(avr), s->path); + // + err = avresample_read (avr, (uint8_t **)output, out_samples); + if (err != 0) { + AUBIO_WRN("Error %d while reading %s\n", err, s->path); + } + AUBIO_WRN("Converted %d to %d samples\n", in_samples, out_samples); + + for (i = 0; i < out_samples; i ++) { + AUBIO_WRN("%f\n", SHORT_TO_FLOAT(output[i])); + } +#endif + s->avFormatCtx = avFormatCtx; + s->avCodecCtx = avCodecCtx; + s->avFrame = avFrame; + s->avPacket = avPacket; + s->avr = avr; + s->output = output; + + *read_samples = out_samples; +} + + +void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data, uint_t * read){ + uint_t i; + //AUBIO_DBG("entering 'do' with %d, %d\n", s->read_samples, s->read_index); + // begin reading + if (s->read_samples == 0) { + int avcodec_read = 0; + aubio_source_avcodec_readframe(s, &avcodec_read); + s->read_samples += avcodec_read; + s->read_index = 0; + } + if (s->read_samples < s->hop_size) { + // write the end of the buffer to the beginning of read_data + int partial = s->read_samples; + for (i = 0; i < partial; i++) { + read_data->data[i] = SHORT_TO_FLOAT(s->output[i + s->read_index]); + } + s->read_samples = 0; + s->read_index = 0; + // get more data + int avcodec_read = 0; + aubio_source_avcodec_readframe(s, &avcodec_read); + s->read_samples += avcodec_read; + s->read_index = 0; + // write the beginning of the buffer to the end of read_data + int end = MIN((int)(s->hop_size), s->read_samples); + if (avcodec_read == 0) { + end = partial; + } + for (i = partial; i < end; i++) { + read_data->data[i] = SHORT_TO_FLOAT(s->output[i - partial + s->read_index]); + } + if (end < s->hop_size) { + for (i = end; i < s->hop_size; i++) { + read_data->data[i] = 0.; + } + } + s->read_index += partial; + s->read_samples -= partial; + *read = end; + } else { + for (i = 0; i < s->hop_size; i++) { + read_data->data[i] = SHORT_TO_FLOAT(s->output[i + s->read_index]); + } + s->read_index += s->hop_size; + s->read_samples -= s->hop_size; + *read = s->hop_size; + } +} + +void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s, fmat_t * read_data, uint_t * read){ + //uint_t i,j, input_channels = s->input_channels; +} + +uint_t aubio_source_avcodec_get_samplerate(aubio_source_avcodec_t * s) { + return s->samplerate; +} + +uint_t aubio_source_avcodec_get_channels(aubio_source_avcodec_t * s) { + return s->input_channels; +} + +uint_t aubio_source_avcodec_seek (aubio_source_avcodec_t * s, uint_t pos) { + //uint_t resampled_pos = (uint_t)ROUND(pos * s->input_samplerate * 1. / s->samplerate); + return 0; //sf_seek (s->handle, resampled_pos, SEEK_SET); +} + +void del_aubio_source_avcodec(aubio_source_avcodec_t * s){ + if (!s) return; + if (s->output != NULL) { + av_free(s->output); + } + if (s->avr != NULL) { + avresample_close( s->avr ); + av_free ( s->avr ); + } + s->avr = NULL; + if (s->avFrame != NULL) { + avcodec_free_frame( &(s->avFrame) ); + } + s->avFrame = NULL; + if ( &(s->avPacket) != NULL) { + av_free_packet( &(s->avPacket) ); + } + if (s->avCodecCtx != NULL) { + avcodec_close ( s->avCodecCtx ); + } + s->avCodecCtx = NULL; + if (s->avFormatCtx != NULL) { + avformat_close_input ( &(s->avFormatCtx) ); + } + s->avFrame = NULL; + s->avFormatCtx = NULL; + AUBIO_FREE(s); +} + +#endif /* HAVE_SNDFILE */ diff --git a/src/io/source_avcodec.h b/src/io/source_avcodec.h new file mode 100644 index 00000000..d3344159 --- /dev/null +++ b/src/io/source_avcodec.h @@ -0,0 +1,134 @@ +/* + Copyright (C) 2013 Paul Brossier + + This file is part of aubio. + + aubio is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + aubio is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with aubio. If not, see . + +*/ + +#ifndef _AUBIO_SOURCE_AVCODEC_H +#define _AUBIO_SOURCE_AVCODEC_H + +/** \file + + Read from file using [libavcodec](http://libav.org/) + + Avoid including this file directly! Prefer using ::aubio_source_t instead to + make your code portable. + + To write to file, use ::aubio_sink_t. + + \example io/test-source_avcodec.c + +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +/** avcodec media source object */ +typedef struct _aubio_source_avcodec_t aubio_source_avcodec_t; + +/** + + create new ::aubio_source_avcodec_t + + \param uri the file path or uri to read from + \param samplerate sampling rate to view the fie at + \param hop_size the size of the blocks to read from + + Creates a new source object. If `0` is passed as `samplerate`, the sample + rate of the original file is used. + + The samplerate of newly created source can be obtained using + ::aubio_source_avcodec_get_samplerate. + +*/ +aubio_source_avcodec_t * new_aubio_source_avcodec(char_t * uri, uint_t samplerate, uint_t hop_size); + +/** + + read monophonic vector of length hop_size from source object + + \param s source object, created with ::new_aubio_source_avcodec + \param read_to ::fvec_t of data to read to + \param read upon returns, equals to number of frames actually read + + Upon returns, `read` contains the number of frames actually read from the + source. `hop_size` if enough frames could be read, less otherwise. + +*/ +void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_to, uint_t * read); + +/** + + read polyphonic vector of length hop_size from source object + + \param s source object, created with ::new_aubio_source_avcodec + \param read_to ::fmat_t of data to read to + \param read upon returns, equals to number of frames actually read + + Upon returns, `read` contains the number of frames actually read from the + source. `hop_size` if enough frames could be read, less otherwise. + +*/ +void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s, fmat_t * read_to, uint_t * read); + +/** + + get samplerate of source object + + \param s source object, created with ::new_aubio_source_avcodec + \return samplerate, in Hz + +*/ +uint_t aubio_source_avcodec_get_samplerate(aubio_source_avcodec_t * s); + +/** + + get number of channels of source object + + \param s source object, created with ::new_aubio_source_avcodec + \return number of channels + +*/ +uint_t aubio_source_avcodec_get_channels (aubio_source_avcodec_t * s); + +/** + + seek source object + + \param s source object, created with ::new_aubio_source_avcodec + \param pos position to seek to, in frames + + \return 0 if sucessful, non-zero on failure + +*/ +uint_t aubio_source_avcodec_seek (aubio_source_avcodec_t *s, uint_t pos); + +/** + + close source and cleanup memory + + \param s source object, created with ::new_aubio_source_avcodec + +*/ +void del_aubio_source_avcodec(aubio_source_avcodec_t * s); + +#ifdef __cplusplus +} +#endif + +#endif /* _AUBIO_SOURCE_AVCODEC_H */ diff --git a/src/wscript_build b/src/wscript_build index 2e71be60..74fc3af5 100644 --- a/src/wscript_build +++ b/src/wscript_build @@ -5,6 +5,10 @@ uselib = [] uselib += ['FFTW3', 'FFTW3F'] uselib += ['SAMPLERATE'] uselib += ['SNDFILE'] +uselib += ['AVCODEC'] +uselib += ['AVFORMAT'] +uselib += ['AVRESAMPLE'] +uselib += ['AVUTIL'] uselib += ['JACK'] uselib += ['LASH'] diff --git a/tests/src/io/test-source_avcodec.c b/tests/src/io/test-source_avcodec.c new file mode 100644 index 00000000..70c2ca59 --- /dev/null +++ b/tests/src/io/test-source_avcodec.c @@ -0,0 +1,47 @@ +#define AUBIO_UNSTABLE 1 +#include +#include "utils_tests.h" +#include "config.h" + +// this file uses the unstable aubio api, please use aubio_source instead +// see src/io/source.h and tests/src/source/test-source.c + +int main (int argc, char **argv) +{ + uint_t err = 0; + if (argc < 2) { + err = 2; + PRINT_ERR("not enough arguments\n"); + PRINT_MSG("usage: %s [samplerate]\n", argv[0]); + return err; + } + +#ifdef HAVE_AVCODEC + uint_t samplerate = 0; + uint_t hop_size = 256; + uint_t n_frames = 0, read = 0; + if ( argc == 3 ) samplerate = atoi(argv[2]); + + char_t *source_path = argv[1]; + + fvec_t *vec = new_fvec(hop_size); + aubio_source_avcodec_t * s = new_aubio_source_avcodec(source_path, samplerate, hop_size); + if (samplerate == 0 ) samplerate = aubio_source_avcodec_get_samplerate(s); + + if (!s) { err = 1; goto beach; } + + do { + aubio_source_avcodec_do(s, vec, &read); + fvec_print (vec); + n_frames += read; + } while ( read == hop_size ); + +beach: + del_aubio_source_avcodec (s); + del_fvec (vec); +#else + err = 3; + PRINT_ERR("aubio was not compiled with aubio_source_avcodec\n"); +#endif /* HAVE_AVCODEC */ + return err; +} diff --git a/wscript b/wscript index b8f67fe3..aa792ded 100644 --- a/wscript +++ b/wscript @@ -56,6 +56,8 @@ def options(ctx): help_str = 'compile with LASH (auto)', help_disable_str = 'disable LASH' ) add_option_enable_disable(ctx, 'sndfile', default = None, help_str = 'compile with sndfile (auto)', help_disable_str = 'disable sndfile') + add_option_enable_disable(ctx, 'avcodec', default = None, + help_str = 'compile with libavcodec (auto)', help_disable_str = 'disable libavcodec') add_option_enable_disable(ctx, 'samplerate', default = None, help_str = 'compile with samplerate (auto)', help_disable_str = 'disable samplerate') add_option_enable_disable(ctx, 'memcpy', default = True, @@ -199,6 +201,16 @@ def configure(ctx): ctx.check_cfg(package = 'lash-1.0', atleast_version = '0.5.0', args = '--cflags --libs', uselib_store = 'LASH', mandatory = False) + if (ctx.options.enable_avcodec != False): + ctx.check_cfg(package = 'libavcodec', atleast_version = '54.35.0', + args = '--cflags --libs', uselib_store = 'AVCODEC', mandatory = False) + ctx.check_cfg(package = 'libavformat', atleast_version = '52.3.0', + args = '--cflags --libs', uselib_store = 'AVFORMAT', mandatory = False) + ctx.check_cfg(package = 'libavutil', atleast_version = '52.3.0', + args = '--cflags --libs', uselib_store = 'AVUTIL', mandatory = False) + ctx.check_cfg(package = 'libavresample', atleast_version = '1.0.1', + args = '--cflags --libs', uselib_store = 'AVRESAMPLE', mandatory = False) + # write configuration header ctx.write_config_header('src/config.h')