[aubio-user] Fwd: aubio help

Wed Nov 23 16:52:12 CET 2016

Hi Ilya,

Excellent, thanks for the feedback.

Best, Paul

On 11/23/2016 02:03 PM, Илья wrote:
> I found error. Now all works perfectly) Error was with types
> (dtype=np.int16, not dtype=np.float32)
> 
>> Начало переадресованного сообщения:
>>
>> *Отправитель: *Илья <ilya at perevoznik.name <mailto:ilya at perevoznik.name>>
>> *Тема: **Ответ: [aubio-user] aubio help*
>> *Дата: *23 ноября 2016 г., 15:43:01 GMT+3
>> *Получатель: *Paul Brossier <piem at piem.org <mailto:piem at piem.org>>
>>
>> Thank You again for you’re advice. 
>> I’m already trying it, but it strange, cuz i’m making stretch for each
>> channel, and compose it to one array again, but sound not stretches.
>> It was pitched down and at the same speed (i mean x2 stretch). If i
>> set stretch rate x4 it sounds twice faster then original, but still
>> pitch-downed. i must note that at mono files it works perfect. :C
>>
>>
>>> 23 нояб. 2016 г., в 13:53, Paul Brossier <piem at piem.org
>>> <mailto:piem at piem.org>> написал(а):
>>>
>>> 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> <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> <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>
>>>>>> <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> <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> <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> <mailto:aubio-user at aubio.org>
>>>>>>> https://lists.aubio.org/listinfo/aubio-user
>>>>>
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> aubio-user mailing list
>>>> aubio-user at aubio.org <mailto:aubio-user at aubio.org>
>>>> https://lists.aubio.org/listinfo/aubio-user
>>
> 