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