Seeking Guidance on Opening a PR for DaisySP

viniciusfersil · November 6, 2023, 12:24am

Hi there,

I hope this message finds you well. I’m a bit unsure about the best practices for opening a pull request (PR) given that the DaisySP repository’s access is restricted.

My contributions involve a new module that I believe could be valuable to the DaisySP ecosystem.

It is GranularPlayer for the DaisySP. It’s designed to playback arrays of samples in both directions and offers independent control over time-stretching and pitch-shifting.

To give you a better idea, I am sending along a video that showcases a working example of my module in action. However, I want to make sure I follow the correct procedures and maintain a smooth and coordinated process with the DaisySP community.

I have a couple of questions that I would appreciate some guidance on:

Should I wait to open a PR for the module’s examples until the PR for the module itself is merged?
What is the process for contributing to the DaisySP repository, considering my contributions are local? Are there specific steps or guidelines I should follow? I have already read the contribution guidelines and style guide and made sure that the code follows it.

I understand that the DaisySP has some restrictions on access, and I want to make sure I respect these rules while actively participating in its development.

Your guidance and advice would be greatly appreciated, and I’m looking forward to your insights on the best practices for contributing to the DaisySP repository. Thank you for your time and support.

here is the video : https://youtu.be/fa7yxalXuXE

and the fork i am working on: GitHub - viniciusfersil123/DaisyExamples: Examples for the Daisy Platform

Best regards,

Vinícius Fernandes

Takumi_Ogata · November 9, 2023, 10:51pm

Hi Vinícius!

Thank you for the wait. I’m really excited to see that the GranularPlayer is ready for a PR now! I have been looking forward to it. It’s sounding awesome!

What you would need to do is to make your own fork and then create the pull request from that. And then, one of us will review and we’ll go from there.
I believe this should get you started: Creating a pull request from a fork - GitHub Docs
Or this: How To: Fork a GitHub Repository & Submit a Pull Request – Jake Jarvis

Please let me know if you have any questions! We’re excited to have a closer look at the granular synth.

viniciusfersil · November 15, 2023, 2:47pm

Hi Takumi,

Thank you so much for your prompt response and for expressing enthusiasm about the GranularPlayer module! I truly appreciate your guidance.

I have taken your advice and created a fork, and I am excited to let you know that I have just opened the pull request for the GranularPlayer module. You can find the PR at the following link:

GranularPlayer Pull Request

I’ve followed the steps outlined in the GitHub documentation you shared, and I’m looking forward to your feedback and any further instructions you may have.

If you have any questions or if there’s anything else I can provide, please feel free to let me know. I’m eager to contribute to the DaisySP community and improve the platform.

Thanks again for your time and support!

Best regards,
Vinícius Fernandes

viniciusfersil · November 15, 2023, 2:54pm

Also, I wanted to inform you that I have an example ready in my DaisyExamples fork repository,.This example is ready for publication whenever it is appropriate. The link to the fork is: https://github.com/viniciusfersil123/DaisyExamples

Takumi_Ogata · November 15, 2023, 9:11pm

This is great news, Vinícius! Thank you so much for opening the PR.
The team will review it as soon as we find get a chance.

tele_player · November 16, 2023, 1:12am

I cloned that repo (with --recurse), rebuilt libs.
Tried to build granularPlayer, got:

granularplayer.cpp:21:1: error: ‘GranularPlayer’ does not name a type
21 | GranularPlayer granularPlayer;

Am I just making some kind of GitHub error?

viniciusfersil · November 26, 2023, 4:06pm

Thank you so much, @Takumi_Ogata! Feel free to reach out anytime if you believe I can be of assistance in any way

viniciusfersil · November 26, 2023, 4:17pm

Hi @tele_player,

Thanks a lot for giving my implementation a try. Since it’s a PR still under review, you can follow these steps to address the issue and make use of the GranularPlayer module:

After completing all the steps outlined here, go ahead and delete the DaisySP folder from your DaisyExamples directory.
Clone the DaisySP version I’ve provided anywhere you prefer (cloning it in the root of the DaisyExamples folder would be easier). If you decide to clone the DaisySP folder elsewhere, make sure to copy it to the root folder of DaisyExamples. Note that this version is on the granular_player branch of my repository.
Execute the “rebuild_all” shell script found in the DaisyExamples repository.

You should be all set! If you encounter any further issues, feel free to reach out to me. I’ll do my best to respond promptly. Thanks!

tele_player · November 26, 2023, 5:09pm

Thanks -

As is suspected, it was a git error - I didn’t get the correct DaisySP branch.
Build is sucessful now - I’ll probably hack it to use Patch.Init().

Edit: running granularplayer, with minor changes, on Patch.Init(). Making interesting noises!

viniciusfersil · November 28, 2023, 10:17pm

Hey @tele_player , great to see it is working. Thanks for trying the port ! My SD card module just arrived today, I will try to play around with larger samples and post my results here in the forum !

kursiv · November 30, 2023, 12:11pm

Unless it’s intentional, judging by how it sounds in your video example I’d suggest you add interpolation in the process() function. It sounds all kinds of glitchy

viniciusfersil · November 30, 2023, 8:22pm

Hey @kursiv, appreciate the feedback! I previously implemented the same algorithm in Pure Data using the tabred4~ object, and it did sound better to me—more precisely, it seemed “cleaner.” I’m in the final weeks of my doctoral semester, but once that’s wrapped up, I plan to experiment with implementing some interpolation. If you have any recommendations regarding which interpolation algorithm I should consider or any suggested readings on the topic, feel free to share your thoughts. Thanks again!

kursiv · November 30, 2023, 8:54pm

Yeah the tabread4 seems to implement cubic hermite interpolation by the looks of it.

github.com

pure-data/pure-data/blob/0259d00373b9e6f3bc1d76eebc5b243283ca7063/src/d_array.c#L817


      
          if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
              pd_error(x, "%s: no such array", x->x_arrayname->s_name);
          else if (!garray_getfloatwords(a, &npoints, &vec))
              pd_error(x, "%s: bad template for tabread4", x->x_arrayname->s_name);
          else if (npoints < 4)
              outlet_float(x->x_obj.ob_outlet, 0);
          else if (f <= 1)
              outlet_float(x->x_obj.ob_outlet, vec[1].w_float);
          else if (f >= npoints - 2)
              outlet_float(x->x_obj.ob_outlet, vec[npoints - 2].w_float);
          else
          {
              int n = f;
              float a, b, c, d, cminusb, frac;
              t_word *wp;
              if (n >= npoints - 2)
                  n = npoints - 3;
              wp = vec + n;
              frac = f - n;
              a = wp[-1].w_float;
              b = wp[0].w_float;

I’ve been toying around with a granular player myself and I’ve tried a few different interpolations. Linear interpolation gave lots of aliasing, but could be fine for integer down/upsampling. Cubic hermite on the other hand seems like it’s doing the job.
I’m not sure how comfortable you are with math, but if you google cubic hermite interpolation you’ll find lots of different resources that explain how it works and how to implement it.

I’ve implemented it here if you want to have a look, it’s quite similar to what they do in tabread4.

github.com

virvel/virveldsp/blob/aa31725fb543658fa435f1ca976e5f598215bee0/src/granulator.cpp

#include "granulator.h"

void dsp::Grain::init(float * const  buffer, const uint32_t size) {
    m_buf = buffer;
    m_active = false; 
    m_position = 0;
    m_size = size;
    m_rate = 1.f;
    m_duration = m_size;
    m_offset = 0;
    m_next_offset = 0;
}

float dsp::Grain::play() {
    
    if (m_position >= m_duration) {
        m_active = false;
        m_delay = static_cast<uint32_t>(static_cast<float>(m_duration) * static_cast<float>(rand() / static_cast<float>(RAND_MAX)));
    }

This file has been truncated. show original

viniciusfersil · December 15, 2023, 1:38pm

Hey @kursiv,

I really appreciate your suggestions and the code examples you provided. It’s really helpful to have a starting point for implementing cubic hermite interpolation.

I’ll dive into the resources on cubic hermite interpolation as you suggested and take a closer look at your code example. Your experience with different interpolations, especially highlighting the aliasing concerns with linear interpolation, is insightful. I’ll definitely keep that in mind as I work on enhancing the GranularPlayer.

I’m comfortable with math and eager to experiment with the implementation. Once I’ve made updates, I’ll share the changes and welcome any further feedback you might have.

Thanks again for your support and for taking the time to share your expertise.