static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)
{
AConvertContext *aconvert = inlink->dst->priv;
AVFilterBufferRef *curbuf = insamplesref;
AVFilterLink * const outlink = inlink->dst->outputs[0];
int chan_mult;
/* in/reinint the internal buffers if this is the first buffer
* provided or it is needed to use a bigger one */
if (!aconvert->max_nb_samples ||
(curbuf->audio->nb_samples > aconvert->max_nb_samples))
if (init_buffers(inlink, curbuf->audio->nb_samples) < 0) {
av_log(inlink->dst, AV_LOG_ERROR, "Could not initialize buffers.\n");
return;
}
/* if channel mixing is required */
if (aconvert->mix_samplesref) {
memcpy(aconvert->in_mix, curbuf->data, sizeof(aconvert->in_mix));
memcpy(aconvert->out_mix, aconvert->mix_samplesref->data, sizeof(aconvert->out_mix));
aconvert->convert_chlayout(aconvert->out_mix,
aconvert->in_mix,
curbuf->audio->nb_samples,
aconvert);
curbuf = aconvert->mix_samplesref;
}
if (aconvert->audioconvert_ctx) {
if (!aconvert->mix_samplesref) {
if (aconvert->in_conv == aconvert->packed_data) {
int i, packed_stride = av_get_bytes_per_sample(inlink->format);
aconvert->packed_data[0] = curbuf->data[0];
for (i = 1; i < aconvert->out_nb_channels; i++)
aconvert->packed_data[i] = aconvert->packed_data[i-1] + packed_stride;
} else {
aconvert->in_conv = curbuf->data;
}
}
chan_mult = inlink->planar == outlink->planar && inlink->planar == 0 ?
aconvert->out_nb_channels : 1;
av_audio_convert(aconvert->audioconvert_ctx,
(void * const *) aconvert->out_conv,
aconvert->out_strides,
(const void * const *) aconvert->in_conv,
aconvert->in_strides,
curbuf->audio->nb_samples * chan_mult);
curbuf = aconvert->out_samplesref;
}
avfilter_copy_buffer_ref_props(curbuf, insamplesref);
curbuf->audio->channel_layout = outlink->channel_layout;
curbuf->audio->planar = outlink->planar;
avfilter_filter_samples(inlink->dst->outputs[0],
avfilter_ref_buffer(curbuf, ~0));
avfilter_unref_buffer(insamplesref);
}
int decode_audio_file(ChromaprintContext *chromaprint_ctx, int16_t *buffer1, int16_t *buffer2, const char *file_name, int max_length, int *duration)
{
int i, ok = 0, remaining, length, consumed, buffer_size, codec_ctx_opened = 0;
AVFormatContext *format_ctx = NULL;
AVCodecContext *codec_ctx = NULL;
AVCodec *codec = NULL;
AVStream *stream = NULL;
AVPacket packet, packet_temp;
#ifdef HAVE_AV_AUDIO_CONVERT
AVAudioConvert *convert_ctx = NULL;
#endif
int16_t *buffer;
if (!strcmp(file_name, "-")) {
file_name = "pipe:0";
}
#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(53, 2, 0)
if (av_open_input_file(&format_ctx, file_name, NULL, 0, NULL) != 0) {
#else
if (avformat_open_input(&format_ctx, file_name, NULL, NULL) != 0) {
#endif
fprintf(stderr, "ERROR: couldn't open the file\n");
goto done;
}
if (av_find_stream_info(format_ctx) < 0) {
fprintf(stderr, "ERROR: couldn't find stream information in the file\n");
goto done;
}
for (i = 0; i < format_ctx->nb_streams; i++) {
codec_ctx = format_ctx->streams[i]->codec;
if (codec_ctx && codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
stream = format_ctx->streams[i];
break;
}
}
if (!stream) {
fprintf(stderr, "ERROR: couldn't find any audio stream in the file\n");
goto done;
}
codec = avcodec_find_decoder(codec_ctx->codec_id);
if (!codec) {
fprintf(stderr, "ERROR: unknown codec\n");
goto done;
}
if (avcodec_open(codec_ctx, codec) < 0) {
fprintf(stderr, "ERROR: couldn't open the codec\n");
goto done;
}
codec_ctx_opened = 1;
if (codec_ctx->channels <= 0) {
fprintf(stderr, "ERROR: no channels found in the audio stream\n");
goto done;
}
if (codec_ctx->sample_fmt != AV_SAMPLE_FMT_S16) {
#ifdef HAVE_AV_AUDIO_CONVERT
convert_ctx = av_audio_convert_alloc(AV_SAMPLE_FMT_S16, codec_ctx->channels,
codec_ctx->sample_fmt, codec_ctx->channels, NULL, 0);
if (!convert_ctx) {
fprintf(stderr, "ERROR: couldn't create sample format converter\n");
goto done;
}
#else
fprintf(stderr, "ERROR: unsupported sample format\n");
goto done;
#endif
}
*duration = stream->time_base.num * stream->duration / stream->time_base.den;
av_init_packet(&packet);
av_init_packet(&packet_temp);
remaining = max_length * codec_ctx->channels * codec_ctx->sample_rate;
chromaprint_start(chromaprint_ctx, codec_ctx->sample_rate, codec_ctx->channels);
while (1) {
if (av_read_frame(format_ctx, &packet) < 0) {
break;
}
packet_temp.data = packet.data;
packet_temp.size = packet.size;
while (packet_temp.size > 0) {
buffer_size = BUFFER_SIZE;
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52, 23, 0)
consumed = avcodec_decode_audio2(codec_ctx,
buffer1, &buffer_size, packet_temp.data, packet_temp.size);
#else
consumed = avcodec_decode_audio3(codec_ctx,
buffer1, &buffer_size, &packet_temp);
#endif
if (consumed < 0) {
break;
}
packet_temp.data += consumed;
packet_temp.size -= consumed;
if (buffer_size <= 0) {
if (buffer_size < 0) {
fprintf(stderr, "WARNING: size returned from avcodec_decode_audioX is too small\n");
}
continue;
}
if (buffer_size > BUFFER_SIZE) {
fprintf(stderr, "WARNING: size returned from avcodec_decode_audioX is too large\n");
continue;
}
#ifdef HAVE_AV_AUDIO_CONVERT
if (convert_ctx) {
const void *ibuf[6] = { buffer1 };
void *obuf[6] = { buffer2 };
#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(51, 8, 0)
int istride[6] = { av_get_bits_per_sample_format(codec_ctx->sample_fmt) / 8 };
#else
int istride[6] = { av_get_bytes_per_sample(codec_ctx->sample_fmt) };
#endif
int ostride[6] = { 2 };
int len = buffer_size / istride[0];
if (av_audio_convert(convert_ctx, obuf, ostride, ibuf, istride, len) < 0) {
break;
}
buffer = buffer2;
buffer_size = len * ostride[0];
}
else {
buffer = buffer1;
}
#else
buffer = buffer1;
#endif
length = MIN(remaining, buffer_size / 2);
if (!chromaprint_feed(chromaprint_ctx, buffer, length)) {
fprintf(stderr, "ERROR: fingerprint calculation failed\n");
goto done;
}
if (max_length) {
remaining -= length;
if (remaining <= 0) {
goto finish;
}
}
}
if (packet.data) {
av_free_packet(&packet);
}
}
finish:
if (!chromaprint_finish(chromaprint_ctx)) {
fprintf(stderr, "ERROR: fingerprint calculation failed\n");
goto done;
}
ok = 1;
done:
if (codec_ctx_opened) {
avcodec_close(codec_ctx);
}
if (format_ctx) {
av_close_input_file(format_ctx);
}
#ifdef HAVE_AV_AUDIO_CONVERT
if (convert_ctx) {
av_audio_convert_free(convert_ctx);
}
#endif
return ok;
}
int fpcalc_main(int argc, char **argv)
{
int i, j, max_length = 120, num_file_names = 0, raw = 0, raw_fingerprint_size, duration;
int16_t *buffer1, *buffer2;
int32_t *raw_fingerprint;
char *file_name, *fingerprint, **file_names;
ChromaprintContext *chromaprint_ctx;
int algo = CHROMAPRINT_ALGORITHM_DEFAULT;
file_names = malloc(argc * sizeof(char *));
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!strcmp(arg, "-length") && i + 1 < argc) {
max_length = atoi(argv[++i]);
}
else if (!strcmp(arg, "-version") || !strcmp(arg, "-v")) {
printf("fpcalc version %s\n", chromaprint_get_version());
return 0;
}
else if (!strcmp(arg, "-raw")) {
raw = 1;
}
else if (!strcmp(arg, "-algo") && i + 1 < argc) {
const char *v = argv[++i];
if (!strcmp(v, "test1")) { algo = CHROMAPRINT_ALGORITHM_TEST1; }
else if (!strcmp(v, "test2")) { algo = CHROMAPRINT_ALGORITHM_TEST2; }
else if (!strcmp(v, "test3")) { algo = CHROMAPRINT_ALGORITHM_TEST3; }
else if (!strcmp(v, "test4")) { algo = CHROMAPRINT_ALGORITHM_TEST4; }
else {
fprintf(stderr, "WARNING: unknown algorithm, using the default\n");
}
}
else if (!strcmp(arg, "-set") && i + 1 < argc) {
i += 1;
}
else {
file_names[num_file_names++] = argv[i];
}
}
if (!num_file_names) {
printf("usage: %s [OPTIONS] FILE...\n\n", argv[0]);
printf("Options:\n");
printf(" -version print version information\n");
printf(" -length SECS length of the audio data used for fingerprint calculation (default 120)\n");
printf(" -raw output the raw uncompressed fingerprint\n");
printf(" -algo NAME version of the fingerprint algorithm\n");
return 2;
}
av_register_all();
av_log_set_level(AV_LOG_ERROR);
buffer1 = av_malloc(BUFFER_SIZE + 16);
buffer2 = av_malloc(BUFFER_SIZE + 16);
chromaprint_ctx = chromaprint_new(algo);
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (!strcmp(arg, "-set") && i + 1 < argc) {
char *name = argv[++i];
char *value = strchr(name, '=');
if (value) {
*value++ = '\0';
chromaprint_set_option(chromaprint_ctx, name, atoi(value));
}
}
}
for (i = 0; i < num_file_names; i++) {
file_name = file_names[i];
if (!decode_audio_file(chromaprint_ctx, buffer1, buffer2, file_name, max_length, &duration)) {
fprintf(stderr, "ERROR: unable to calculate fingerprint for file %s, skipping\n", file_name);
continue;
}
if (i > 0) {
printf("\n");
}
printf("FILE=%s\n", file_name);
printf("DURATION=%d\n", duration);
if (raw) {
if (!chromaprint_get_raw_fingerprint(chromaprint_ctx, (void **)&raw_fingerprint, &raw_fingerprint_size)) {
fprintf(stderr, "ERROR: unable to calculate fingerprint for file %s, skipping\n", file_name);
continue;
}
printf("FINGERPRINT=");
for (j = 0; j < raw_fingerprint_size; j++) {
printf("%d%s", raw_fingerprint[j], j + 1 < raw_fingerprint_size ? "," : "");
}
printf("\n");
chromaprint_dealloc(raw_fingerprint);
}
else {
if (!chromaprint_get_fingerprint(chromaprint_ctx, &fingerprint)) {
fprintf(stderr, "ERROR: unable to calculate fingerprint for file %s, skipping\n", file_name);
continue;
}
printf("FINGERPRINT=%s\n", fingerprint);
chromaprint_dealloc(fingerprint);
}
}
chromaprint_free(chromaprint_ctx);
av_free(buffer1);
av_free(buffer2);
free(file_names);
return 0;
}
/**
* Gets the AVPacket stored in _packet, and decodes all the samples it can from it,
* putting them in _buffer, the total number of bytes written begin stored in _dataSize.
*/
int AudioLoader::decodePacket() {
/*
E_DEBUG(EAlgorithm, "-----------------------------------------------------");
E_DEBUG(EAlgorithm, "decoding packet of " << _packet.size << " bytes");
E_DEBUG(EAlgorithm, "pts: " << _packet.pts << " - dts: " << _packet.dts); //" - pos: " << pkt->pos);
E_DEBUG(EAlgorithm, "flags: " << _packet.flags);
E_DEBUG(EAlgorithm, "duration: " << _packet.duration);
*/
int len = 0;
// buff is an offset in our output buffer, it points to where we should start
// writing the next decoded samples
int16_t* buff = _buffer;
#if !HAVE_SWRESAMPLE
if (_audioConvert) { buff = _buff1; }
#endif
// _dataSize gets the size of the buffer, in bytes
_dataSize = FFMPEG_BUFFER_SIZE*sizeof(int16_t);
// _dataSize input = number of bytes available for write in buff
// output = number of bytes actually written (actual: S16 data)
//E_DEBUG(EAlgorithm, "decode_audio_frame, available bytes in buffer = " << _dataSize);
len = decode_audio_frame(_audioCtx, buff, &_dataSize, &_packet);
if (len < 0) {
// only print error msg when file is not an mp3, because mp3 streams can have tag
// frames (id3v2?) which libavcodec tries to read as audio anyway, and we don't want
// to print an error message for that...
if (_audioCtx->codec_id == CODEC_ID_MP3) {
E_DEBUG(EAlgorithm, "AudioLoader: invalid frame, probably an mp3 tag frame, skipping it");
}
else {
E_WARNING("AudioLoader: error while decoding, skipping frame");
}
return 0;
}
if (_dataSize <= 0) {
// No data yet, get more frames
//cout << "no data yet, get more frames" << endl;
_dataSize = 0;
return 0;
}
#if !HAVE_SWRESAMPLE
if (_audioConvert) {
// this assumes that all audio is interleaved in the first channel
// it works as we're only doing sample format conversion, but we
// should be very careful
const void* ibuf[6] = { buff };
void* obuf[6] = { _buff2 };
int istride[6] = { av_get_bytes_per_sample(_audioCtx->sample_fmt) };
int ostride[6] = { av_get_bytes_per_sample(AV_SAMPLE_FMT_S16) };
int totalsamples = _dataSize / istride[0]; // == num_samp_per_channel * num_channels
if (av_audio_convert(_audioConvert, obuf, ostride, ibuf, istride, totalsamples) < 0) {
ostringstream msg;
msg << "AudioLoader: Error converting "
<< " from " << avcodec_get_sample_fmt_name(_audioCtx->sample_fmt)
<< " to " << avcodec_get_sample_fmt_name(SAMPLE_FMT_S16);
throw EssentiaException(msg);
}
// when entering the current block, dataSize contained the size in bytes
// that the audio was taking in its native format. Now it needs to be set
// to the size of the audio we're returning, after conversion
_dataSize = totalsamples * av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
memcpy(_buffer, _buff2, _dataSize);
}
#endif
if (len != _packet.size) {
// FIXME: investigate why this happens and whether it is a big issue
// (looks like it only loses silent samples at the end of files)
// more than 1 frame in a packet, happens a lot with flac for instance...
E_WARNING("AudioLoader: more than 1 frame in packet, dropping remaining bytes...");
E_WARNING("at sample index: " << output("audio").totalProduced());
E_WARNING("decoded samples: " << len);
E_WARNING("packet size: " << _packet.size);
}
return len;
}
static hb_buffer_t * Encode( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
uint64_t pts, pos;
hb_audio_t * audio = w->audio;
hb_buffer_t * buf;
if( hb_list_bytes( pv->list ) < pv->input_samples * sizeof( float ) )
{
return NULL;
}
hb_list_getbytes( pv->list, pv->buf, pv->input_samples * sizeof( float ),
&pts, &pos);
// XXX: ffaac fails to remap from the internal libav* channel map (SMPTE) to the native AAC channel map
// do it here - this hack should be removed if Libav fixes the bug
hb_chan_map_t * out_map = ( w->codec_param == CODEC_ID_AAC ) ? &hb_qt_chan_map : &hb_smpte_chan_map;
if ( audio->config.in.channel_map != out_map )
{
hb_layout_remap( audio->config.in.channel_map, out_map, pv->layout,
(float*)pv->buf, pv->samples_per_frame );
}
// Do we need to convert our internal float format?
if ( pv->context->sample_fmt != AV_SAMPLE_FMT_FLT )
{
int isamp, osamp;
AVAudioConvert *ctx;
isamp = av_get_bytes_per_sample( AV_SAMPLE_FMT_FLT );
osamp = av_get_bytes_per_sample( pv->context->sample_fmt );
ctx = av_audio_convert_alloc( pv->context->sample_fmt, 1,
AV_SAMPLE_FMT_FLT, 1,
NULL, 0 );
// get output buffer size then malloc a buffer
//nsamples = out_size / isamp;
//buffer = av_malloc( nsamples * sizeof(hb_sample_t) );
// we're doing straight sample format conversion which
// behaves as if there were only one channel.
const void * const ibuf[6] = { pv->buf };
void * const obuf[6] = { pv->buf };
const int istride[6] = { isamp };
const int ostride[6] = { osamp };
av_audio_convert( ctx, obuf, ostride, ibuf, istride, pv->input_samples );
av_audio_convert_free( ctx );
}
buf = hb_buffer_init( pv->output_bytes );
buf->size = avcodec_encode_audio( pv->context, buf->data, buf->alloc,
(short*)pv->buf );
buf->start = pts + 90000 * pos / pv->out_discrete_channels / sizeof( float ) / audio->config.out.samplerate;
buf->stop = buf->start + 90000 * pv->samples_per_frame / audio->config.out.samplerate;
buf->frametype = HB_FRAME_AUDIO;
if ( !buf->size )
{
hb_buffer_close( &buf );
return Encode( w );
}
else if (buf->size < 0)
{
hb_log( "encavcodeca: avcodec_encode_audio failed" );
hb_buffer_close( &buf );
return NULL;
}
return buf;
}
