Transposing and switching tenor/alto/soprano etc.

[petermoz]

Hi everyone,

I'm interested in working on a transposition feature that I think could also cover the use case of switching from tenor to alto, etc. There's a bit more discussion over at cardonabits/haxo-rs#19, but Javier suggested I post here to get community feedback on the proposal.

As background information: the current way to switch between (e.g.) tenor and alto is to change the notemap.json file. This file defines the "sounding pitch" of the key combination. i.e. "no keys pressed", which a sax player would read as a "C#" is defined as midi 59 (B). Therefore, to make your haxophone an alto you'd rewrite the notemap.

So far we see three different possibilities with various tradeoffs that I'll try to explain below.

1. Buttons for +/- half-step increments. This would be similar to changing instruments. Essentially you would enter command mode, and then press buttons to increase or decrease the transpose offset. Pros: fits with the control scheme for instrument selection. Cons: relies on user remembering the current offset, and counting how many half-steps they need (e.g. to get from tenor to alto)

2. Play note to set offset. User enters "transpose mode", then plays the note in concert pitch that they want to hear when pressing keys for a written "C". i.e. to behave like a tenor, you would play an Bb. For an alto, you would play an Eb. The system would then compute an offset and use it for the rest of the session. This version of the proposal doesn't touch the notemap.json file, so a user could still make their haxophone an alto by changing the notemap.json file, but could temporarily transpose or convert to a tenor via "transpose mode". Pros: easy to jump to specific key. Cons: confusing that both the notemap and the transposition can affect the pitch, might be hard to implement something that works for all notemaps.

3. Play note to set offset, and change notemap to 'written' pitch. This proposal is similar to (2) but would also involve changing the notemap.json file to represent written pitch. i.e. "no keys pressed" would be defined as "C#", "lowest note" would be "Bb", etc. This would be coupled with a new command line flag --transpose which would define saxophone type. e.g. the default haxo.service would specify --transpose -2 (or should that be -14?) and a user could make their haxophone an alto by editing the service file and changing the value to --transpose +3 (or -9?). That would just change the default transposition, a user could change during a session by entering "transpose mode" same as in (2). Pros: simple way to set default pitch, eliminates need to change notemap.json (unless you want to do something really custom like change fingerings). Cons: "breaking" change for people that have their own notemap.json they want to continue using

Regarding the "transpose mode" I mentioned above. The existing "command mode" (used to change instrument sound) is entered by pressing "Low Bb" and drawing air in through the mouthpieces for <1 second. Once in command mode you can change the instrument sound and then press all three left palm keys to return to "play mode". We'd need to implement something similar for "transpose mode", and so far I've suggested "Low B" just because it's the next note up from "Low Bb", but we're open to other ideas, especially if it can make the command more memorable.

Just to spell it out completely, changing the transposition would involve:
1. Low B + draw air for 1s (or better idea if you have one) to enter Transpose Mode
2. Blow fingering to pick the concert note (e.g. concert Eb) that will sound when you play "C" (haxo plays back this note)
3. Press all 3 left-palm keys together to exit Transpose Mode

I think proposal 3 (Play note to set offset, and change notemap to 'written' pitch.) is the best path forward as it solves both the "play this song in a different key" and "switch between alto/tenor" use case in a consistent way. But I'm interested to get feedback from other haxophone users. Do you have any use cases that aren't solved by the above? Any suggestions for how to handle this differently?

Thanks,
Peter

[thuntjazz]

@petermoz thanks for working on this! A transposing function will improve the usability for me immeasurably.

I've been traveling recently and haven't been working with my haxophone as much, but I'm looking forward to diving back in. My next project is making it "talk" with my 2 favorite hardware synths.

[stardusthamster]

Thank you very much for these ideas!

I am currently working on my own notemap.json for C instruments. So with your proposal no 3 I would have no work to to just change the setting, that would really be nice!

What about entering transpose mode using the same keys as leaving it = the three left palm keys?

One question concerning the notemap.json: I am thinking about defining a simpler notemap.json with less fingerings and other fingerings for the # and b notes.
Would your proposal No 3 still work with such a modified notemap.json?

[jcard0na]

What about entering transpose mode using the same keys as leaving it = the three left palm keys?

I would advise against using the three left palm key to enter transpose mode because this combination can be hit accidentally while playing. The reason for using a 1-second air draw is because this is incompatible with normal playing.

To exit transpose/control mode, as there are no risks of fingering conflicts with normal playing, I chose the three left palm key combination which is faster and easier than drawing air.

I'm happy to revisit this if there is consensus on a better alternative, though!

[petermoz]

Thanks for the support. With respect to an "simpler notemap" - yes this would work. The main change that will happen after my code is submitted is that the notes will be defined in "written pitch". So whereas the notemap currently converts between "the keys pressed" and "the sound you should hear", soon the notemap will convert between "the keys pressed" and "the note you would read on the music" (and then the transpose functionality converts between "what you read on the music" and "what you should hear")

[petermoz]

If anyone reading this thread would like to try out the concept, I've implemented a very rough version here:
https://github.com/petermoz/haxo-rs/tree/transpose-mode

It has everything implemented (as described above) but there's lots of small details that could be improved (like the feedback about what transposition has been "set"). Let me know if you try it out! There's more discussion about the implementation on the issue tracker: cardonabits/haxo-rs#19

[Ekolide]

Hi I felt like chiming in to say the most important use case for me is to be able to set the Haxophone to launch C-transposed and then never ever ever change it. In my opinion, C-transposed should be the baseline, especially inside the notemap, and transpositions are worked out from there. I am not sure how that fits in with your proposed solutions.

I've skimmed through the discussion on the issue page, and admittedly talking transposition makes my head spin a little.

I don't know if I fully understand what is meant about changing the notemap. With that said, from a tinkering perspective I think it's fundamentally important that the notemap plays the MIDI note it says it will. If the notemap says a certain fingering will result in MIDI Note 62, but sends MIDI Note 60 to Fluidsynth by default, that seems needlessly confusing, though I'm not sure that's what anyone is actually suggesting.

In this way I don't see an issue that both the notemap and the haxo.service both change the pitch, because the notemap is C-transposed. Changing the transposition inside the notemap is a hassle right now, and since the point of all this transposition is to keep the fingerings called the same thing, C is still called C no matter how you then choose to transpose with haxo.service. That way the notemap has been clear as day about what it's going to do.

Anyways, I'm rambling, take these thoughts with a grain of salt. I am very excited for whatever the result ends up being, I get a bad feeling in my stomach when I play something called "D" and it sounds like C, so whatever happens will be a usability improvement for me.

[jcard0na]

Hi @Ekolide,

Thanks for chiming in. The good news is that with the approach @petermoz is suggesting, you will be able "to launch C-transposed and then never ever ever change it". This would be achieved by selecting your preferred transposition in haxo.service file (--transposition 0), and never using the special transposition mode sequence (1-s draw on low B fingering).

If transposition is changed during playing (via the aforementioned sequence), the note sent to Fluidsynth will no longer match what is in the notemap, but that is unavoidable: you ask for transposition, and transposition is what you get.

I've played this morning with the @petermoz's first implementation, and I find it fantastic. Definitely a big usability improvement!

Cheers,

[Ekolide]

Heya @jcard0na !

Thanks for clearing it up. That seems like a very sensible implementation. Looking forwards to it.

Thanks!