[aubio-user] Fwd: aubio help

Wed Nov 23 11:53:42 CET 2016

Hi Ilya,

Glad to know it works.

For multichannel support, you could simply process each channel
individually with the function you wrote.

Best, Paul

On 11/23/2016 10:34 AM, Илья wrote:
> 
> 
>> Начало переадресованного сообщения:
>>
>> *Отправитель: *Илья <ilya at perevoznik.name <mailto:ilya at perevoznik.name>>
>> *Тема: **Ответ: [aubio-user] Fwd: aubio help*
>> *Дата: *23 ноября 2016 г., 11:46:26 GMT+3
>> *Получатель: *Paul Brossier <piem at aubio.org <mailto:piem at aubio.org>>
>>
>> I can’t believe and i don’t not how BUT IT’S WORK. Thank You very
>> much, it was really helpful, but i must note that 
>>
>> np.append(sink_out, stretched) 
>>
>> not works cuz np.append function returns new ndarray. it means to use
>> it like this
>>
>> sink_out = np.append(sink_out, stretched).
>>
>>
>> Thank You very much again. Now I have only to add stereo support :D
>>
>>
>>> 23 нояб. 2016 г., в 0:45, Paul Brossier <piem at aubio.org
>>> <mailto:piem at aubio.org>> написал(а):
>>>
>>> Hi Ilya,
>>>
>>> First, note that I am currently working on integrating time-stretch in
>>> the C library (see the timestretch git branch). In a future release
>>> (probably one release after the upcoming one), this will become much
>>> easier, including in Python.
>>>
>>> Also, I would suggest that you start from `demo_timestretch_online.py`,
>>> which is much more memory efficient than `demo_timestretch.py`.
>>>
>>> A few notes from from reading your code, I would suggest:
>>>
>>> - initializing sink_out as an array, not as a list:
>>>
>>>    import numpy as np
>>>    sink_out = np.ndarray([])
>>>
>>> - append each produced frames with numpy.stack (list.append would
>>> create a list of arrays, so it's not really what you want):
>>>
>>>    if t > warmup:  # skip the first few frames to warm up phase vocoder
>>>        # write to sink
>>>        np.append(sink_out, stretched_samples)
>>>
>>> The final conversion of your list to an array needs to be checked. If
>>> you need the output as integers, you most likely want to multiply the
>>> float samples by a constant. With the above modifications, it could
>>> become something like:
>>>
>>>    sink_out_int = (sink_out * 32768).astype(np.int16)
>>>
>>> To debug your code, you could add print statements to each steps to
>>> check the size of the sink_out array, which you should see grow at each
>>> step. Also, make sure to avoid not overwriting local variables by using
>>> the same name (self._samples, samples, samples_proc...).
>>>
>>> Let us know how it works out for you,
>>>
>>> Best, Paul
>>>
>>> On 11/22/2016 08:43 PM, Илья wrote:
>>>>
>>>>
>>>>> Начало переадресованного сообщения:
>>>>>
>>>>> *Отправитель: *Илья <ilya at perevoznik.name
>>>>> <mailto:ilya at perevoznik.name> <mailto:ilya at perevoznik.name>>
>>>>> *Тема: **aubio help*
>>>>> *Дата: *22 ноября 2016 г., 19:25:41 GMT+3
>>>>> *Получатель: *piem at piem.org
>>>>> <mailto:piem at piem.org> <mailto:piem at piem.org>
>>>>>
>>>>> Hello, i’m coding app, that use `aubio` in it and i want to make a
>>>>> time-stretch of sound. (i’m using python module)
>>>>>
>>>>> i found a demo (in you’re python/demos folder) that actually what I’m
>>>>> looking for, but i need to rewrite it to compatibility with my already
>>>>> existing functions etc.
>>>>> I have a trouble with sink_out, i tried to look in clang code of it,
>>>>> but anyway i can’t understand, but i can’t use it cause i have my own
>>>>> file saving system. i tried to emulate sink_out with a list (that
>>>>> would convert to ndarray after stretching) and it doesn’t works, cuz i
>>>>> have just 1279 samples at the out, but at in it was 352800 :D
>>>>>
>>>>> please, help me to understand how to rewrite it without sink_out. i
>>>>> need to write all to ndarray. my code below:
>>>>>
>>>>> def time_stretch(self, rate):
>>>>> win_s = self._win_size
>>>>>    hop_s = self._hop_size
>>>>>
>>>>>    warmup = win_s // hop_s - 1
>>>>>
>>>>> p = pvoc(win_s, hop_s)
>>>>>
>>>>> # allocate memory to store norms and phases
>>>>> n_blocks = len(self._samples) // hop_s + 1
>>>>> # adding an empty frame at end of spectrogram
>>>>> norms = np.zeros((n_blocks + 1, win_s // 2 + 1), dtype=float_type)
>>>>> phases = np.zeros((n_blocks + 1, win_s // 2 + 1), dtype=float_type)
>>>>>
>>>>> block_read = 0
>>>>> samples = self._samples
>>>>>    steps_max = len(samples) - (len(samples) % hop_s)
>>>>>
>>>>> for i in range(0, steps_max, hop_s):
>>>>> # pitchin = pitch_o(samples[i:i + self._hop_size])
>>>>> # read from source
>>>>> samples_proc = np.asarray(samples[i:i + hop_s]).astype(np.float32)
>>>>> # compute fftgrain
>>>>> spec = p(samples_proc)
>>>>> # store current grain
>>>>> norms[block_read] = spec.norm
>>>>>        phases[block_read] = spec.phas
>>>>>        # increment block counter
>>>>> block_read += 1
>>>>>
>>>>> # just to make sure
>>>>> # source_in.close()
>>>>>
>>>>> sink_out = []
>>>>>
>>>>> # interpolated time steps (j = alpha * i)
>>>>> steps = np.arange(0, n_blocks, rate, dtype=float_type)
>>>>> # initial phase
>>>>> phas_acc = phases[0]
>>>>> # excepted phase advance in each bin
>>>>> phi_advance = np.linspace(0, np.pi * hop_s, win_s / 2 +
>>>>> 1).astype(float_type)
>>>>>
>>>>> new_grain = cvec(win_s)
>>>>>
>>>>> for (t, step) in enumerate(steps):
>>>>>
>>>>> frac = 1. - np.mod(step, 1.0)
>>>>> # get pair of frames
>>>>> t_norms = norms[int(step):int(step + 2)]
>>>>> t_phases = phases[int(step):int(step + 2)]
>>>>>
>>>>> # compute interpolated frame
>>>>> new_grain.norm = frac * t_norms[0] + (1. - frac) * t_norms[1]
>>>>> new_grain.phas = phas_acc
>>>>>        # print t, step, new_grain.norm
>>>>> # print t, step, phas_acc
>>>>>
>>>>> # psola
>>>>> samples_proc = p.rdo(new_grain)
>>>>> if t > warmup: # skip the first few frames to warm up phase vocoder
>>>>> # write to sink
>>>>> sink_out.append(samples_proc[:hop_s])
>>>>>
>>>>> # calculate phase advance
>>>>> dphas = t_phases[1] - t_phases[0] - phi_advance
>>>>>        # unwrap angle to [-pi; pi]
>>>>> dphas = unwrap2pi(dphas)
>>>>> # cumulate phase, to be used for next frame
>>>>> phas_acc += phi_advance + dphas
>>>>>
>>>>>    for t in range(warmup + 1): # purge the last frames from the
>>>>> phase vocoder
>>>>> new_grain.norm[:] = 0
>>>>> new_grain.phas[:] = 0
>>>>> samples_proc = p.rdo(new_grain)
>>>>> sink_out.append(samples_proc[:hop_s])
>>>>>
>>>>> self._samples = np.asarray(sink_out).astype(np.int16)
>>>>> P.S. Sorry for my bad English.
>>>>>
>>>>> Thank You!
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> aubio-user mailing list
>>>> aubio-user at aubio.org <mailto:aubio-user at aubio.org>
>>>> https://lists.aubio.org/listinfo/aubio-user
>>
> 
> 
> 
> _______________________________________________
> aubio-user mailing list
> aubio-user at aubio.org
> https://lists.aubio.org/listinfo/aubio-user
> 