Changes in / [81abf91:92948ab]


Ignore:
Files:
30 edited

Legend:

Unmodified
Added
Removed

  • azure-pipelines.yml

    r81abf91 r92948ab  
    11#  configuration file for azure continuous integration
    22jobs:
    3 
    43- job: linux
    54  pool:
    65    vmImage: 'Ubuntu 16.04'
     6
    77  steps:
    88  - script: |
    99      make
    1010    displayName: 'make'
    11     env:
    12       CFLAGS: -Werror
    13 
    1411- job: windows
    1512  pool:
    1613    vmIMage: 'VS2017-Win2016'
     14
    1715  steps:
    1816  - script: |
    … …  
    2624  pool:
    2725    vmIMage: macOS-10.13
     26
    2827  steps:
    2928  - script: |
    … …  
    3534      make
    3635    displayName: 'make'
    37     env:
    38       CFLAGS: -Werror

  • doc/about.rst

    r81abf91 r92948ab  
    6060-------
    6161
    62 aubio is a `free <https://www.debian.org/intro/free>`_ and `open source
     62aubio is a `free <http://www.debian.org/intro/free>`_ and `open source
    6363<http://www.opensource.org/docs/definition.php>`_ software; **you** can
    6464redistribute it and/or modify it under the terms of the `GNU

  • doc/aubiomfcc.txt

    r81abf91 r92948ab  
    5252  url:
    5353
    54   https://engineering.purdue.edu/~malcolm/interval/1998-010/ (see file mfcc.m)
     54  http://cobweb.ecn.purdue.edu/~malcolm/interval/1998-010/ (see file mfcc.m)
    5555
    5656SEE ALSO

  • doc/aubionotes.txt

    r81abf91 r92948ab  
    77  aubionotes [[-i] source]
    88             [-r rate] [-B win] [-H hop]
    9              [-O method] [-t thres] [-d drop]
     9             [-O method] [-t thres]
    1010             [-p method] [-u unit] [-l thres]
    1111             [-T time-format]
    … …  
    6969  loudest ones. A value of -90.0 would select all onsets. Defaults to -90.0.
    7070
    71   -d, --release-drop  Set the release drop threshold, in dB. If the level is
    72   found to drop more than this amount since the last note has started, the
    73   note will be turned-off. Defaults to 10.
    74 
    7571  -T, --timeformat format  Set time format (samples, ms, seconds). Defaults to
    7672  seconds.

  • doc/conf.py

    r81abf91 r92948ab  
    4646# General information about the project.
    4747project = u'aubio'
    48 copyright = u'2018, Paul Brossier'
     48copyright = u'2016, Paul Brossier'
    4949
    5050# The version info for the project you're documenting, acts as replacement for

  • doc/python_module.rst

    r81abf91 r92948ab  
    8080.. _demo_filter.py: https://github.com/aubio/aubio/blob/master/python/demos/demo_filter.py
    8181.. _python tests: https://github.com/aubio/aubio/blob/master/python/tests
     82

  • examples/aubionotes.c

    r81abf91 r92948ab  
    2222#define PROG_HAS_PITCH 1
    2323#define PROG_HAS_ONSET 1
    24 #define PROG_HAS_NOTES 1
    2524#define PROG_HAS_SILENCE 1
    2625#define PROG_HAS_JACK 1
    … …  
    8483    }
    8584  }
    86   if (release_drop != 10.) {
    87     if (aubio_notes_set_release_drop (notes, release_drop) != 0) {
    88       errmsg ("failed setting notes release drop to %.2f\n",
    89           release_drop);
    90     }
    91   }
    9285
    9386  examples_common_process((aubio_process_func_t)process_block, process_print);

  • examples/parse_args.h

    r81abf91 r92948ab  
    4848// more general stuff
    4949extern smpl_t silence_threshold;
    50 extern smpl_t release_drop;
    5150extern uint_t mix_input;
    5251// midi tap
    … …  
    109108      "                 a value in dB, for instance -70, or -100; default=-90\n"
    110109#endif /* PROG_HAS_SILENCE */
    111 #ifdef PROG_HAS_NOTES
    112       "       -d      --release-drop     select release drop threshold\n"
    113       "                 a positive value in dB; default=10\n"
    114 #endif
    115110      "       -T      --time-format      select time values output format\n"
    116111      "                 (samples, ms, seconds) default=seconds\n"
    … …  
    163158    "s:"
    164159#endif /* PROG_HAS_SILENCE */
    165 #ifdef PROG_HAS_NOTES
    166     "d:"
    167 #endif /* PROG_HAS_SILENCE */
    168160#ifdef PROG_HAS_OUTPUT
    169161    "mf"
    … …  
    201193    {"silence",               1, NULL, 's'},
    202194#endif /* PROG_HAS_SILENCE */
    203 #ifdef PROG_HAS_NOTES
    204     {"release-drop",          1, NULL, 'd'},
    205 #endif /* PROG_HAS_NOTES */
    206195    {"time-format",           1, NULL, 'T'},
    207196#ifdef PROG_HAS_OUTPUT
    … …  
    285274      case 's':                /* silence threshold */
    286275        silence_threshold = (smpl_t) atof (optarg);
    287         break;
    288       case 'd':                /* release-drop threshold */
    289         release_drop = (smpl_t) atof (optarg);
    290276        break;
    291277      case 'm':                /* mix_input flag */

  • examples/utils.c

    r81abf91 r92948ab  
    5555// more general stuff
    5656smpl_t silence_threshold = -90.;
    57 smpl_t release_drop = 10.;
    5857uint_t mix_input = 0;
    5958

  • python/demos/demo_bpm_extract.py

    r81abf91 r92948ab  
    2323            pass
    2424        else:
    25             raise ValueError("unknown mode {:s}".format(params.mode))
     25            print("unknown mode {:s}".format(params.mode))
    2626    # manual settings
    2727    if 'samplerate' in params:
    … …  
    7070    parser.add_argument('-m', '--mode',
    7171            help="mode [default|fast|super-fast]",
    72             dest="mode", default='default')
     72            dest="mode")
    7373    parser.add_argument('sources',
    74             nargs='+',
     74            nargs='*',
    7575            help="input_files")
    7676    args = parser.parse_args()

  • python/ext/aubiomodule.c

    r81abf91 r92948ab  
    238238  smpl_t output;
    239239
    240   if (!PyArg_ParseTuple (args,
    241         "" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR,
    242         &input, &samplerate, &fftsize)) {
     240  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR , &input, &samplerate, &fftsize)) {
    243241    return NULL;
    244242  }
    … …  
    255253  smpl_t output;
    256254
    257   if (!PyArg_ParseTuple (args,
    258         "" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR,
    259         &input, &samplerate, &fftsize)) {
     255  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR , &input, &samplerate, &fftsize)) {
    260256    return NULL;
    261257  }
    … …  
    272268  smpl_t output;
    273269
    274   if (!PyArg_ParseTuple (args,
    275         "" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR,
    276         &input, &samplerate, &fftsize)) {
     270  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR, &input, &samplerate, &fftsize)) {
    277271    return NULL;
    278272  }
    … …  
    289283  smpl_t output;
    290284
    291   if (!PyArg_ParseTuple (args,
    292         "" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR,
    293         &input, &samplerate, &fftsize)) {
     285  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR, &input, &samplerate, &fftsize)) {
    294286    return NULL;
    295287  }

  • python/ext/py-filterbank.c

    r81abf91 r92948ab  
    9595  if (self->vec.length != self->win_s / 2 + 1) {
    9696    PyErr_Format(PyExc_ValueError,
    97                  "input cvec has length %d, but filterbank expects length %d",
     97                 "input cvec has length %d, but fft expects length %d",
    9898                 self->vec.length, self->win_s / 2 + 1);
    9999    return NULL;
    … …  
    140140  if (err > 0) {
    141141    PyErr_SetString (PyExc_ValueError,
    142         "error when running set_triangle_bands");
     142        "error when setting filter to A-weighting");
    143143    return NULL;
    144144  }
    … …  
    159159  if (err > 0) {
    160160    PyErr_SetString (PyExc_ValueError,
    161         "error when running set_mel_coeffs_slaney");
     161        "error when setting filter to A-weighting");
    162162    return NULL;
    163163  }

  • python/lib/aubio/cmd.py

    r81abf91 r92948ab  
    102102    subparser.add_input()
    103103    subparser.add_buf_hop_size()
    104     subparser.add_silence()
    105     subparser.add_release_drop()
    106104    subparser.add_time_format()
    107105    subparser.add_verbose_help()
    … …  
    209207                action="store", dest="silence", default=-70,
    210208                help="silence threshold")
    211 
    212     def add_release_drop(self):
    213         self.add_argument("-d", "--release-drop",
    214                 metavar = "<value>", type=float,
    215                 action="store", dest="release_drop", default=10,
    216                 help="release drop threshold")
    217209
    218210    def add_minioi(self, default="12ms"):
    … …  
    256248                action = "store", dest = "cut_until_nslices", default = None,
    257249                help="how many extra slices should be added at the end of each slice")
    258         self.add_argument("--create-first",
    259                 action = "store_true", dest = "create_first", default = False,
    260                 help="always include first slice")
    261250
    262251# some utilities
    … …  
    391380        self.parse_options(args, self.valid_opts)
    392381        self.notes = aubio.notes(**self.options)
    393         if args.silence is not None:
    394             self.notes.set_silence(args.silence)
    395         if args.release_drop is not None:
    396             self.notes.set_release_drop(args.release_drop)
    397382        super(process_notes, self).__init__(args)
    398383    def __call__(self, block):
    … …  
    515500def main():
    516501    parser = aubio_parser()
    517     if sys.version_info[0] != 3:
    518         # on py2, create a dummy ArgumentParser to workaround the
    519         # optional subcommand issue. See https://bugs.python.org/issue9253
    520         # This ensures that:
    521         #  - version string is shown when only '-V' is passed
    522         #  - help is printed if  '-V' is passed with any other argument
    523         #  - any other argument get forwarded to the real parser
    524         parser_root = argparse.ArgumentParser(add_help=False)
    525         parser_root.add_argument('-V', '--version', help="show version",
    526                 action="store_true", dest="show_version")
    527         args, extras = parser_root.parse_known_args()
    528         if args.show_version == False: # no -V, forward to parser
    529             args = parser.parse_args(extras, namespace=args)
    530         elif len(extras) != 0: # -V with other arguments, print help
    531             parser.print_help()
    532             sys.exit(1)
    533     else: # in py3, we can simply use parser directly
    534         args = parser.parse_args()
     502    args = parser.parse_args()
    535503    if 'show_version' in args and args.show_version:
    536504        sys.stdout.write('aubio version ' + aubio.version + '\n')

  • python/lib/aubio/cut.py

    r81abf91 r92948ab  
    102102    s = source(source_uri, samplerate, hopsize)
    103103    if samplerate == 0:
    104         samplerate = s.samplerate
     104        samplerate = s.get_samplerate()
    105105        options.samplerate = samplerate
    106106
    … …  
    151151                timestamps, timestamps_end = timestamps_end,
    152152                output_dir = options.output_directory,
    153                 samplerate = options.samplerate,
    154                 create_first = options.create_first)
     153                samplerate = options.samplerate)
    155154
    156155def main():

  • python/lib/aubio/midiconv.py

    r81abf91 r92948ab  
    22""" utilities to convert midi note number to and from note names """
    33
    4 __all__ = ['note2midi', 'midi2note', 'freq2note', 'note2freq']
     4__all__ = ['note2midi', 'midi2note', 'freq2note']
    55
    66import sys
    7 from ._aubio import freqtomidi, miditofreq
    8 
    97py3 = sys.version_info[0] == 3
    108if py3:
    … …  
    2725    _valid_octaves = range(-1, 10)
    2826    if not isinstance(note, str_instances):
    29         msg = "a string is required, got {:s} ({:s})"
    30         raise TypeError(msg.format(str(type(note)), repr(note)))
     27        raise TypeError("a string is required, got %s (%s)" % (note, str(type(note))))
    3128    if len(note) not in range(2, 5):
    32         msg = "string of 2 to 4 characters expected, got {:d} ({:s})"
    33         raise ValueError(msg.format(len(note), note))
     29        raise ValueError("string of 2 to 4 characters expected, got %d (%s)" \
     30                         % (len(note), note))
    3431    notename, modifier, octave = [None]*3
    3532
    … …  
    5552        raise ValueError("%s is not a valid octave" % octave)
    5653
    57     midi = 12 + octave * 12 + _valid_notenames[notename] \
    58             + _valid_modifiers[modifier]
     54    midi = 12 + octave * 12 + _valid_notenames[notename] + _valid_modifiers[modifier]
    5955    if midi > 127:
    6056        raise ValueError("%s is outside of the range C-2 to G8" % note)
    … …  
    6662        raise TypeError("an integer is required, got %s" % midi)
    6763    if midi not in range(0, 128):
    68         msg = "an integer between 0 and 127 is excepted, got {:d}"
    69         raise ValueError(msg.format(midi))
    70     _valid_notenames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#',
    71             'A', 'A#', 'B']
     64        raise ValueError("an integer between 0 and 127 is excepted, got %d" % midi)
     65    _valid_notenames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
    7266    return _valid_notenames[midi % 12] + str(int(midi / 12) - 1)
    7367
    7468def freq2note(freq):
    7569    " convert frequency in Hz to nearest note name, e.g. [0, 22050.] -> [C-1, G9] "
    76     nearest_note = int(freqtomidi(freq) + .5)
    77     return midi2note(nearest_note)
    78 
    79 def note2freq(note):
    80     """Convert note name to corresponding frequency, in Hz.
    81 
    82     Parameters
    83     ----------
    84     note : str
    85         input note name
    86 
    87     Returns
    88     -------
    89     freq : float [0, 23000[
    90         frequency, in Hz
    91 
    92     Example
    93     -------
    94     >>> aubio.note2freq('A4')
    95     440
    96     >>> aubio.note2freq('A3')
    97     220.1
    98     """
    99     midi = note2midi(note)
    100     return miditofreq(midi)
     70    from aubio import freqtomidi
     71    return midi2note(int(freqtomidi(freq)))

  • python/lib/aubio/slicing.py

    r81abf91 r92948ab  
    77
    88def slice_source_at_stamps(source_file, timestamps, timestamps_end=None,
    9                            output_dir=None, samplerate=0, hopsize=256,
    10                            create_first=False):
     9                           output_dir=None, samplerate=0, hopsize=256):
    1110    """ slice a sound file at given timestamps """
    1211
    … …  
    1413        raise ValueError("no timestamps given")
    1514
    16     if timestamps[0] != 0 and create_first:
     15    if timestamps[0] != 0:
    1716        timestamps = [0] + timestamps
    1817        if timestamps_end is not None:
    … …  
    2019
    2120    if timestamps_end is not None:
    22         if len(timestamps_end) == len(timestamps) - 1:
    23             timestamps_end = timestamps_end + [_max_timestamp]
    24         elif len(timestamps_end) != len(timestamps):
     21        if len(timestamps_end) != len(timestamps):
    2522            raise ValueError("len(timestamps_end) != len(timestamps)")
    2623    else:
    … …  
    5249        vec, read = _source.do_multi()
    5350        # if the total number of frames read will exceed the next region start
    54         while len(regions) and total_frames + read >= regions[0][0]:
     51        if len(regions) and total_frames + read >= regions[0][0]:
    5552            #print "getting", regions[0], "at", total_frames
    5653            # get next region
    … …  
    7976                    # write remaining samples from current region
    8077                    _sink.do_multi(vec[:, start:remaining], remaining - start)
    81                     #print("closing region", "remaining", remaining)
     78                    #print "closing region", "remaining", remaining
    8279                    # close this file
    8380                    _sink.close()
    … …  
    8683                _sink.do_multi(vec[:, start:read], read - start)
    8784        total_frames += read
    88         # remove old slices
    89         slices = list(filter(lambda s: s['end_stamp'] > total_frames,
    90             slices))
    9185        if read < hopsize:
    9286            break

  • python/tests/test_aubio_cmd.py

    r81abf91 r92948ab  
    2020
    2121    def test_samples2seconds(self):
    22         self.assertEqual(aubio.cmd.samples2seconds(3200, 32000),
    23                 "0.100000\t")
     22        self.assertEqual(aubio.cmd.samples2seconds(3200, 32000), "0.100000\t")
    2423
    2524    def test_samples2milliseconds(self):
    26         self.assertEqual(aubio.cmd.samples2milliseconds(3200, 32000),
    27                 "100.000000\t")
     25        self.assertEqual(aubio.cmd.samples2milliseconds(3200, 32000), "100.000000\t")
    2826
    2927    def test_samples2samples(self):
    30         self.assertEqual(aubio.cmd.samples2samples(3200, 32000),
    31                 "3200\t")
     28        self.assertEqual(aubio.cmd.samples2samples(3200, 32000), "3200\t")
    3229
    3330if __name__ == '__main__':

  • python/tests/test_note2midi.py

    r81abf91 r92948ab  
    44from __future__ import unicode_literals
    55
    6 from aubio import note2midi, freq2note, note2freq, float_type
     6from aubio import note2midi, freq2note
    77from nose2.tools import params
    88import unittest
    … …  
    112112class freq2note_simple_test(unittest.TestCase):
    113113
    114     def test_freq2note_above(self):
     114    def test_freq2note(self):
    115115        " make sure freq2note(441) == A4 "
    116116        self.assertEqual("A4", freq2note(441))
    117 
    118     def test_freq2note_under(self):
    119         " make sure freq2note(439) == A4 "
    120         self.assertEqual("A4", freq2note(439))
    121 
    122 class note2freq_simple_test(unittest.TestCase):
    123 
    124     def test_note2freq(self):
    125         " make sure note2freq('A3') == 220"
    126         self.assertEqual(220, note2freq("A3"))
    127 
    128     def test_note2freq_under(self):
    129         " make sure note2freq(A4) == 440"
    130         if float_type == 'float32':
    131             self.assertEqual(440, note2freq("A4"))
    132         else:
    133             self.assertLess(abs(note2freq("A4")-440), 1.e-12)
    134117
    135118if __name__ == '__main__':

  • python/tests/test_notes.py

    r81abf91 r92948ab  
    66
    77AUBIO_DEFAULT_NOTES_SILENCE = -70.
    8 AUBIO_DEFAULT_NOTES_RELEASE_DROP = 10.
    98AUBIO_DEFAULT_NOTES_MINIOI_MS = 30.
    109
    … …  
    3938        self.o.set_silence(val)
    4039        assert_equal (self.o.get_silence(), val)
    41 
    42     def test_get_release_drop(self):
    43         assert_equal (self.o.get_release_drop(), AUBIO_DEFAULT_NOTES_RELEASE_DROP)
    44 
    45     def test_set_release_drop(self):
    46         val = 50
    47         self.o.set_release_drop(val)
    48         assert_equal (self.o.get_release_drop(), val)
    49 
    50     def test_set_release_drop_wrong(self):
    51         val = -10
    52         with self.assertRaises(ValueError):
    53             self.o.set_release_drop(val)
    5440
    5541from .utils import list_all_sounds

  • python/tests/test_slicing.py

    r81abf91 r92948ab  
    2424    def test_slice_start_only_no_zero(self):
    2525        regions_start = [i*1000 for i in range(1, n_slices)]
    26         slice_source_at_stamps(self.source_file, regions_start,
    27                 output_dir = self.output_dir, create_first=True)
     26        slice_source_at_stamps(self.source_file, regions_start, output_dir = self.output_dir)
    2827
    2928    def test_slice_start_beyond_end(self):
    3029        regions_start = [i*1000 for i in range(1, n_slices)]
    3130        regions_start += [count_samples_in_file(self.source_file) + 1000]
    32         slice_source_at_stamps(self.source_file, regions_start,
    33                 output_dir = self.output_dir, create_first=True)
     31        slice_source_at_stamps(self.source_file, regions_start, output_dir = self.output_dir)
    3432
    3533    def test_slice_start_every_blocksize(self):
    3634        hopsize = 200
    37         regions_start = [i*hopsize for i in range(0, n_slices)]
     35        regions_start = [i*hopsize for i in range(1, n_slices)]
    3836        slice_source_at_stamps(self.source_file, regions_start, output_dir = self.output_dir,
    3937                hopsize = 200)
    40 
    41     def test_slice_start_every_half_blocksize(self):
    42         hopsize = 200
    43         regions_start = [i*hopsize//2 for i in range(0, n_slices)]
    44         slice_source_at_stamps(self.source_file, regions_start,
    45                 output_dir = self.output_dir, hopsize = 200)
    4638
    4739    def tearDown(self):
    … …  
    10092            "number of samples written different from number of original samples")
    10193
    102     def test_slice_start_and_ends_with_missing_end(self):
    103         regions_start = [i*1000 for i in range(n_slices)]
    104         regions_ends = [r-1 for r in regions_start[1:]]
    105         slice_source_at_stamps(self.source_file, regions_start, regions_ends,
    106                 output_dir = self.output_dir)
    107         written_samples = count_samples_in_directory(self.output_dir)
    108         original_samples = count_samples_in_file(self.source_file)
    109         total_files = count_files_in_directory(self.output_dir)
    110         assert_equal(n_slices, total_files,
    111             "number of slices created different from expected")
    112         assert_equal(written_samples, original_samples,
    113             "number of samples written different from number of original samples")
    114 
    11594    def tearDown(self):
    11695        shutil.rmtree(self.output_dir)
    … …  
    155134        regions_end = None
    156135        slice_source_at_stamps (self.source_file, regions_start, regions_end,
    157                 output_dir = self.output_dir, create_first=True)
     136                output_dir = self.output_dir)
    158137        total_files = count_files_in_directory(self.output_dir)
    159138        assert_equal(n_slices, total_files,

  • src/io/source_avcodec.c

    r81abf91 r92948ab  
    3535// determine whether we use libavformat from ffmpeg or from libav
    3636#define FFMPEG_LIBAVFORMAT (LIBAVFORMAT_VERSION_MICRO > 99 )
    37 // max_analyze_duration2 was used from ffmpeg libavformat 55.43.100 -> 57.2.100
     37// max_analyze_duration2 was used from ffmpeg libavformat 55.43.100 through 57.2.100
    3838#define FFMPEG_LIBAVFORMAT_MAX_DUR2 FFMPEG_LIBAVFORMAT && ( \
    3939      (LIBAVFORMAT_VERSION_MAJOR == 55 && LIBAVFORMAT_VERSION_MINOR >= 43) \
    … …  
    9393};
    9494
    95 // create or re-create the context when _do or _do_multi is called
    96 void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s,
    97     uint_t multi);
    98 // actually read a frame
    99 void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s,
    100     uint_t * read_samples);
     95// hack to create or re-create the context the first time _do or _do_multi is called
     96void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi);
     97void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples);
    10198
    10299uint_t aubio_source_avcodec_has_network_url(aubio_source_avcodec_t *s);
    … …  
    115112
    116113
    117 aubio_source_avcodec_t * new_aubio_source_avcodec(const char_t * path,
    118     uint_t samplerate, uint_t hop_size) {
     114aubio_source_avcodec_t * new_aubio_source_avcodec(const char_t * path, uint_t samplerate, uint_t hop_size) {
    119115  aubio_source_avcodec_t * s = AUBIO_NEW(aubio_source_avcodec_t);
    120116  AVFormatContext *avFormatCtx = s->avFormatCtx;
    … …  
    133129  }
    134130  if ((sint_t)samplerate < 0) {
    135     AUBIO_ERR("source_avcodec: Can not open %s with samplerate %d\n",
    136         path, samplerate);
     131    AUBIO_ERR("source_avcodec: Can not open %s with samplerate %d\n", path, samplerate);
    137132    goto beach;
    138133  }
    139134  if ((sint_t)hop_size <= 0) {
    140     AUBIO_ERR("source_avcodec: Can not open %s with hop_size %d\n",
    141         path, hop_size);
     135    AUBIO_ERR("source_avcodec: Can not open %s with hop_size %d\n", path, hop_size);
    142136    goto beach;
    143137  }
    … …  
    179173    char errorstr[256];
    180174    av_strerror (err, errorstr, sizeof(errorstr));
    181     AUBIO_ERR("source_avcodec: Could not find stream information "
    182         "for %s (%s)\n", s->path, errorstr);
     175    AUBIO_ERR("source_avcodec: Could not find stream information " "for %s (%s)\n", s->path,
     176        errorstr);
    183177    goto beach;
    184178  }
    … …  
    220214  avCodecCtx = avcodec_alloc_context3(codec);
    221215  if (!avCodecCtx) {
    222     AUBIO_ERR("source_avcodec: Failed to allocate the %s codec context "
    223         "for path %s\n", av_get_media_type_string(AVMEDIA_TYPE_AUDIO),
    224         s->path);
     216    AUBIO_ERR("source_avcodec: Failed to allocate the %s codec context for path %s\n",
     217        av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path);
    225218    goto beach;
    226219  }
    … …  
    237230  /* Copy codec parameters from input stream to output codec context */
    238231  if ((err = avcodec_parameters_to_context(avCodecCtx, codecpar)) < 0) {
    239     AUBIO_ERR("source_avcodec: Failed to copy %s codec parameters to "
    240         "decoder context for %s\n",
    241         av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path);
     232    AUBIO_ERR("source_avcodec: Failed to copy %s codec parameters to decoder context for %s\n",
     233       av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path);
    242234    goto beach;
    243235  }
    … …  
    247239    char errorstr[256];
    248240    av_strerror (err, errorstr, sizeof(errorstr));
    249     AUBIO_ERR("source_avcodec: Could not load codec for %s (%s)\n", s->path,
    250         errorstr);
     241    AUBIO_ERR("source_avcodec: Could not load codec for %s (%s)\n", s->path, errorstr);
    251242    goto beach;
    252243  }
    … …  
    275266
    276267  /* allocate output for avr */
    277   s->output = (smpl_t *)av_malloc(AUBIO_AVCODEC_MAX_BUFFER_SIZE
    278       * sizeof(smpl_t));
     268  s->output = (smpl_t *)av_malloc(AUBIO_AVCODEC_MAX_BUFFER_SIZE * sizeof(smpl_t));
    279269
    280270  s->read_samples = 0;
    … …  
    304294}
    305295
    306 void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s,
    307     uint_t multi)
    308 {
     296void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi) {
    309297  // create or reset resampler to/from mono/multi-channel
    310298  if ( (multi != s->multi) || (s->avr == NULL) ) {
    … …  
    321309#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
    322310
    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);
     311    av_opt_set_int(avr, "in_channel_layout",  input_layout,           0);
     312    av_opt_set_int(avr, "out_channel_layout", output_layout,          0);
     313    av_opt_set_int(avr, "in_sample_rate",     s->input_samplerate,    0);
     314    av_opt_set_int(avr, "out_sample_rate",    s->samplerate,          0);
    327315    av_opt_set_int(avr, "in_sample_fmt",      s->avCodecCtx->sample_fmt, 0);
    328316#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);
     317    av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_DBL,      0);
     318#else
     319    av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_FLT,      0);
    332320#endif
    333321    // TODO: use planar?
    … …  
    341329      char errorstr[256];
    342330      av_strerror (err, errorstr, sizeof(errorstr));
    343       AUBIO_ERR("source_avcodec: Could not open resampling context"
    344          " for %s (%s)\n", s->path, errorstr);
     331      AUBIO_ERR("source_avcodec: Could not open resampling context for %s (%s)\n",
     332          s->path, errorstr);
    345333      return;
    346334    }
    … …  
    359347}
    360348
    361 void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s,
    362     uint_t * read_samples)
    363 {
     349void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples) {
    364350  AVFormatContext *avFormatCtx = s->avFormatCtx;
    365351  AVCodecContext *avCodecCtx = s->avCodecCtx;
    … …  
    402388      char errorstr[256];
    403389      av_strerror (err, errorstr, sizeof(errorstr));
    404       AUBIO_ERR("source_avcodec: could not read frame in %s (%s)\n",
    405           s->path, errorstr);
     390      AUBIO_ERR("source_avcodec: could not read frame in %s (%s)\n", s->path, errorstr);
    406391      s->eof = 1;
    407392      goto beach;
    … …  
    421406  if (ret < 0) {
    422407    if (ret == AVERROR(EAGAIN)) {
    423       //AUBIO_WRN("source_avcodec: output is not available right now - "
    424       //    "user must try to send new input\n");
     408      //AUBIO_WRN("source_avcodec: output is not available right now - user must try to send new input\n");
    425409      goto beach;
    426410    } else if (ret == AVERROR_EOF) {
    427       AUBIO_WRN("source_avcodec: the decoder has been fully flushed, "
    428           "and there will be no more output frames\n");
     411      AUBIO_WRN("source_avcodec: the decoder has been fully flushed, and there will be no more output frames\n");
    429412    } else {
    430413      AUBIO_ERR("source_avcodec: decoding errors on %s\n", s->path);
    … …  
    441424#endif
    442425  if (got_frame == 0) {
    443     AUBIO_WRN("source_avcodec: did not get a frame when reading %s\n",
    444         s->path);
     426    AUBIO_WRN("source_avcodec: did not get a frame when reading %s\n", s->path);
    445427    goto beach;
    446428  }
    … …  
    449431  if (avFrame->channels != (sint_t)s->input_channels) {
    450432    AUBIO_WRN ("source_avcodec: trying to read from %d channel(s),"
    451         "but configured for %d; is '%s' corrupt?\n",
    452         avFrame->channels, s->input_channels, s->path);
    453     goto beach;
    454   }
    455 #else
    456 #warning "avutil < 53 is deprecated, crashes might occur on corrupt files"
     433        "but configured for %d; is '%s' corrupt?\n", avFrame->channels,
     434        s->input_channels, s->path);
     435    goto beach;
     436  }
    457437#endif
    458438
    … …  
    475455#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
    476456  if (out_samples <= 0) {
    477     AUBIO_WRN("source_avcodec: no sample found while converting frame (%s)\n",
    478         s->path);
     457    AUBIO_WRN("source_avcodec: no sample found while converting frame (%s)\n", s->path);
    479458    goto beach;
    480459  }
    … …  
    494473}
    495474
    496 void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data,
    497     uint_t * read) {
     475void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data, uint_t * read){
    498476  uint_t i;
    499477  uint_t end = 0;
    … …  
    527505}
    528506
    529 void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s,
    530     fmat_t * read_data, uint_t * read) {
     507void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s, fmat_t * read_data, uint_t * read){
    531508  uint_t i,j;
    532509  uint_t end = 0;
    … …  
    574551
    575552uint_t aubio_source_avcodec_seek (aubio_source_avcodec_t * s, uint_t pos) {
    576   int64_t resampled_pos =
    577     (uint_t)ROUND(pos * (s->input_samplerate * 1. / s->samplerate));
     553  int64_t resampled_pos = (uint_t)ROUND(pos * (s->input_samplerate * 1. / s->samplerate));
    578554  int64_t min_ts = MAX(resampled_pos - 2000, 0);
    579555  int64_t max_ts = MIN(resampled_pos + 2000, INT64_MAX);
    … …  
    583559    ret = AUBIO_OK;
    584560  } else {
    585     AUBIO_ERR("source_avcodec: failed seeking in %s (file not opened?)",
    586         s->path);
     561    AUBIO_ERR("source_avcodec: failed seeking in %s (file not opened?)", s->path);
    587562    return ret;
    588563  }
    … …  
    595570      min_ts, resampled_pos, max_ts, seek_flags);
    596571  if (ret < 0) {
    597     AUBIO_ERR("source_avcodec: failed seeking to %d in file %s",
    598         pos, s->path);
     572    AUBIO_ERR("source_avcodec: failed seeking to %d in file %s", pos, s->path);
    599573  }
    600574  // reset read status

  • src/mathutils.c

    r81abf91 r92948ab  
    523523  /* log(freq/A-2)/log(2) */
    524524  midi = freq / 6.875;
    525   midi = LOG (midi) / 0.6931471805599453;
     525  midi = LOG (midi) / 0.69314718055995;
    526526  midi *= 12;
    527527  midi -= 3;
    … …  
    535535  if (midi > 140.) return 0.; // avoid infs
    536536  freq = (midi + 3.) / 12.;
    537   freq = EXP (freq * 0.6931471805599453);
     537  freq = EXP (freq * 0.69314718055995);
    538538  freq *= 6.875;
    539539  return freq;

  • src/notes/notes.c

    r81abf91 r92948ab  
    11/*
    2   Copyright (C) 2014-2018 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2014 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2626
    2727#define AUBIO_DEFAULT_NOTES_SILENCE -70.
    28 #define AUBIO_DEFAULT_NOTES_RELEASE_DROP 10.
    2928// increase to 10. for .1  cent precision
    3029//      or to 100. for .01 cent precision
    … …  
    5857
    5958  uint_t isready;
    60 
    61   smpl_t last_onset_level;
    62   smpl_t release_drop_level;
    6359};
    6460
    … …  
    106102  aubio_notes_set_minioi_ms (o, AUBIO_DEFAULT_NOTES_MINIOI_MS);
    107103
    108   o->last_onset_level = AUBIO_DEFAULT_NOTES_SILENCE;
    109   o->release_drop_level = AUBIO_DEFAULT_NOTES_RELEASE_DROP;
    110 
    111104  return o;
    112105
    … …  
    146139{
    147140  return aubio_onset_get_minioi_ms(o->onset);
    148 }
    149 
    150 uint_t aubio_notes_set_release_drop(aubio_notes_t *o, smpl_t release_drop_level)
    151 {
    152   uint_t err = AUBIO_OK;
    153   if (release_drop_level <= 0.) {
    154     AUBIO_ERR("notes: release_drop should be >= 0, got %f\n", release_drop_level);
    155     err = AUBIO_FAIL;
    156   } else {
    157     o->release_drop_level = release_drop_level;
    158   }
    159   return err;
    160 }
    161 
    162 smpl_t aubio_notes_get_release_drop(const aubio_notes_t *o)
    163 {
    164   return o->release_drop_level;
    165141}
    166142
    … …  
    209185      //notes->data[0] = o->curnote;
    210186      //notes->data[1] = 0.;
    211       //AUBIO_WRN("notes: sending note-off at onset, not enough level\n");
    212187      notes->data[2] = o->curnote;
    213188    } else {
    … …  
    217192        /* kill old note */
    218193        //send_noteon(o->curnote,0, o->samplerate);
    219         //AUBIO_WRN("notes: sending note-off at onset, new onset detected\n");
    220194        notes->data[2] = o->curnote;
    221195        /* get and send new one */
    … …  
    225199        o->curnote = new_pitch;
    226200      }
    227       o->last_onset_level = curlevel;
    228201    }
    229202  } else {
    230     if (curlevel < o->last_onset_level - o->release_drop_level)
    231     {
    232       // send note off
    233       //AUBIO_WRN("notes: sending note-off, release detected\n");
    234       notes->data[0] = 0;
    235       notes->data[1] = 0;
    236       notes->data[2] = o->curnote;
    237       // reset last_onset_level to silence_threshold
    238       o->last_onset_level = o->silence_threshold;
    239       o->curnote = 0;
    240     }
    241     else if (o->median)
    242     {
     203    if (o->median) {
    243204      if (o->isready > 0)
    244205        o->isready++;
    … …  
    247208        /* kill old note */
    248209        //send_noteon(curnote,0);
    249         if (o->curnote != 0)
    250         {
    251           //AUBIO_WRN("notes: sending note-off, new note detected\n");
    252           notes->data[2] = o->curnote;
    253         }
     210        notes->data[2] = o->curnote;
    254211        o->newnote = aubio_notes_get_latest_note(o);
    255212        o->curnote = o->newnote;

  • src/notes/notes.h

    r81abf91 r92948ab  
    107107uint_t aubio_notes_set_minioi_ms (aubio_notes_t *o, smpl_t minioi_ms);
    108108
    109 /** get notes object release drop level, in dB
    110 
    111   \param o notes detection object as returned by new_aubio_notes()
    112 
    113   \return current release drop level, in dB
    114 
    115  */
    116 smpl_t aubio_notes_get_release_drop (const aubio_notes_t *o);
    117 
    118 /** set note release drop level, in dB
    119 
    120   This function sets the release_drop_level parameter, in dB. When a new note
    121   is found, the current level in dB is measured. If the measured level drops
    122   under that initial level - release_drop_level, then a note-off will be
    123   emitted.
    124 
    125   Defaults to `10`, in dB.
    126 
    127   \note This parameter was added in version `0.4.8`. Results obtained with
    128   earlier versions can be reproduced by setting this value to `100`, so that
    129   note-off will not be played until the next note.
    130 
    131   \param o notes detection object as returned by new_aubio_notes()
    132   \param release_drop new release drop level, in dB
    133 
    134   \return 0 on success, non-zero otherwise
    135 
    136 */
    137 uint_t aubio_notes_set_release_drop (aubio_notes_t *o, smpl_t release_drop);
    138 
    139109#ifdef __cplusplus
    140110}

  • src/spectral/filterbank_mel.h

    r81abf91 r92948ab  
    5959
    6060  The filter coefficients are built according to Malcolm Slaney's Auditory
    61   Toolbox, available online at the following address (see file mfcc.m):
    62 
    63   https://engineering.purdue.edu/~malcolm/interval/1998-010/
     61  Toolbox, available at http://engineering.purdue.edu/~malcolm/interval/1998-010/
     62  (see file mfcc.m).
    6463
    6564*/

  • src/spectral/mfcc.h

    r81abf91 r92948ab  
    2727
    2828  The implementation follows the specifications established by Malcolm Slaney
    29   in its Auditory Toolbox, available online at the following address (see
    30   file mfcc.m):
     29  in its Auditory Toolbox, available online (see file mfcc.m).
    3130
    32   https://engineering.purdue.edu/~malcolm/interval/1998-010/
     31  http://engineering.ecn.purdue.edu/~malcolm/interval/1998-010/
    3332
    3433  \example spectral/test-mfcc.c

  • src/spectral/phasevoc.c

    r81abf91 r92948ab  
    213213    synthold[i] += synth[i + pv->hop_s] * pv->scale;
    214214}
    215 
    216 uint_t aubio_pvoc_get_win(aubio_pvoc_t* pv)
    217 {
    218   return pv->win_s;
    219 }
    220 
    221 uint_t aubio_pvoc_get_hop(aubio_pvoc_t* pv)
    222 {
    223   return pv->hop_s;
    224 }

  • src/spectral/phasevoc.h

    r81abf91 r92948ab  
    8989*/
    9090uint_t aubio_pvoc_get_win(aubio_pvoc_t* pv);
    91 
    9291/** get hop size
    9392

  • src/synth/wavetable.c

    r81abf91 r92948ab  
    165165  aubio_wavetable_set_amp (s, 0.);
    166166  //s->last_pos = 0;
    167   return aubio_wavetable_set_playing (s, 0);
     167  return aubio_wavetable_set_playing (s, 1);
    168168}
    169169

  • src/synth/wavetable.h

    r81abf91 r92948ab  
    5151*/
    5252aubio_wavetable_t * new_aubio_wavetable(uint_t samplerate, uint_t hop_size);
     53
     54/** load source in wavetable
     55
     56  \param o wavetable, created by new_aubio_wavetable()
     57  \param uri the uri of the source to load
     58
     59  \return 0 if successful, non-zero otherwise
     60
     61*/
     62uint_t aubio_wavetable_load( aubio_wavetable_t * o, const char_t * uri );
    5363
    5464/** process wavetable function
Note: See TracChangeset for help on using the changeset viewer.