YAMAHA P525 : Damper release : poly aftertouch at 18 and Vel off at 64

Borealis wrote:

Thanks for the info, Olivier.

Strange that modern DPs like the P525 don't have the full not off feature.

No the Half damper position with Poly aftertouch is better :

here my soluce for pianoteq : (Apple Swift )

-----------
import Foundation
import CoreMIDI

class MIDIHandler {
    private var client = MIDIClientRef()
    private var inputPort = MIDIPortRef()
    private var virtualSource = MIDIEndpointRef()
    private var keyAcceleration: UInt8 = 0
    private var noteOnFull: [(note: UInt8, velocity: UInt8, keyAcceleration: UInt8)] = []

    init() {
        // Création du client MIDI
        MIDIClientCreate("MIDI Poly Aftertouch Converter" as CFString, nil, nil, &client)

        // Création d'un port d'entrée
        MIDIInputPortCreate(client, "Input Port" as CFString, midiReadCallback, Unmanaged.passUnretained(self).toOpaque(), &inputPort)

        // Création d'une source MIDI virtuelle visible pour les autres logiciels
        MIDISourceCreate(client, "P525-SMART_release" as CFString, &virtualSource)
    }

    func findMIDIEndpoint(named name: String) -> MIDIEndpointRef? {
        let sourceCount = MIDIGetNumberOfSources()
        for i in 0..<sourceCount {
            let endpoint = MIDIGetSource(i)
            if let endpointName = getMIDIEndpointName(endpoint), endpointName.contains(name) {
                return endpoint
            }
        }
        return nil
    }

    private func getMIDIEndpointName(_ endpoint: MIDIEndpointRef) -> String? {
        var name: Unmanaged<CFString>?
        MIDIObjectGetStringProperty(endpoint, kMIDIPropertyName, &name)
        return name?.takeUnretainedValue() as String?
    }

    func connectToPSeries() {
        guard let source = findMIDIEndpoint(named: "P-Series") else {
            print("P-Series MIDI device not found.")
            return
        }

        MIDIPortConnectSource(inputPort, source, nil)
        print("Connected to P-Series MIDI device.")
    }

    private let midiReadCallback: MIDIReadProc = { packetList, refCon, _ in
        let handler = Unmanaged<MIDIHandler>.fromOpaque(refCon!).takeUnretainedValue()
        let packets = packetList.pointee
        var packet = packets.packet

        for _ in 0..<packets.numPackets {
            // Accès sûr aux données du paquet
            let midiMessage = withUnsafeBytes(of: &packet.data) { rawBuffer -> [UInt8] in
                let buffer = rawBuffer.bindMemory(to: UInt8.self)
                return Array(buffer.prefix(Int(packet.length)))
            }

            if midiMessage.count >= 3 {
                var status = midiMessage[0] & 0xF0
                let channel = midiMessage[0] & 0x0F
                let note = midiMessage[1]
                let value = midiMessage[2]

                if status == 0xB0, midiMessage[1] == 19 { // Controller 19
                    handler.keyAcceleration = value
                    handler.sendMIDI(message: [0xB0 | channel, 19, value])
                } else if status == 0xA0 { // Polyphonic Aftertouch
                    if value == 18 {
                        print("Poly Aftertouch (Note: \(note), Channel: \(channel)) | Converting 18 to 5")
                        handler.sendNoteOff(note: note, channel: channel, value: 5)
                        print("Converted Note Off (Note: \(note), Velocity: 5)")
                    } else {
                        handler.sendNoteOff(note: note, channel: channel, value: value)
                    }
                } else if status == 0x80 { // Note Off
                    print("Note Off (Note: \(note), Velocity: \(value))")
                    if value == 64 {
                        print("___________________")
                    }
                    handler.sendMIDI(message: [0x80 | channel, note, value])
                } else if status == 0x90 { // Note On
                    handler.noteOnFull.append((note: note, velocity: value, keyAcceleration: handler.keyAcceleration))
                    print("NOTE ON FULL: \(handler.noteOnFull.last ?? (note: 0, velocity: 0, keyAcceleration: 0))")
                    handler.sendMIDI(message: [0x90 | channel, note, value]) // Forward Note On to virtual port
                } else {
                    handler.forwardMessage(midiMessage)
                }
            }

            packet = MIDIPacketNext(&packet).pointee
        }
    }

    private func sendNoteOff(note: UInt8, channel: UInt8, value: UInt8) {
        let noteOffMessage: [UInt8] = [0x80 | channel, note, value]
        sendMIDI(message: noteOffMessage)
    }

    private func forwardMessage(_ message: [UInt8]) {
        sendMIDI(message: message)
    }

    private func sendMIDI(message: [UInt8]) {
        var packetList = MIDIPacketList()
        var packet = MIDIPacketListInit(&packetList)
        packet = MIDIPacketListAdd(&packetList, 1024, packet, 0, message.count, message)

        // Envoi des données MIDI à la source virtuelle
        MIDIReceived(virtualSource, &packetList)
    }
}

let handler = MIDIHandler()

print("MIDI Poly Aftertouch to Note Off Converter")
handler.connectToPSeries()

RunLoop.main.run()
-----------------------------

And in Pianoteq :

Choose the new midi P525-SMART-RELEASE midi port
And set the note off velocity curve like this :

Note-Off Velocity = [0, 64, 127; 0, 127, 127]

Olivier W wrote:

Hi,

In Yamaha P525, the note OFF velocity is fixed at 64.

But...

Yamaha simulate smooth release with Poly aftertouch.

When the Damper is near the escapement or string (virtual) , P525 send a Aftertouch value at 18. (just before note off value fixed at vel 64)

With this NOTE OFF 64 and aftertouch at 18, you can make a midi script to simulate smooth release. (how fast you have value between aftertouch and note off, or with a note off velocity curve)

Just convert Poly Aftertouch for example to a note off value for each preleased key at 18. And you will have two note off velocity value (18 and 64)  and you can simulate a smooth damper release with a xript , midi timing, or note off velocity curve ...

(set a note off velocity curve in PIANOTEQ with the converted Aftertouch value and the fixed note off 64 value)

But Pianoteq can't convert MIDI poly aftertouch to note off velocity....

It would be great to have this feature.

Instead i make a midi script in Logic 11.

And in P525 you have key acceleration in Controller 19. (for internal sound CFX and others for Grand expression, more advanced than single velocity value)

Just make a script with the key midi information played with the controller 19 value, and you can simulate Velocity/keyacceleration in Pianoteq.
But Pianoteq don't allow to use this and make a script to use both note on per key information with the near Controller 19 value.

Please improve midi script in Pianoteq, and add poly aftertouch conversion (only mono aftertouch in current PTQ release midi conversion ) to note off velocity in next Pianoteq update. With this i can make a nice preset for Yamaha P525, with smooth release and Grand expression, like Yamaha internal CFX.

Regards,

Olivier F.

It’s weird that your P525 doesn’t send full poly-aftertouch messages.
My RSC3 silent system send more than just one PA message. If I remember correctly, about 5 messages ranging from 20 to 36.
Your script is a good idea but the real good solution would be for Modartt to upgrade the PianoTeq engine to allow to dampen the sound when encountering incoming PA messages. A kind of « Yamaha’s Grand Expression modeling compatibility mode ».
Converting PA messages into one single note-off velocity is flawed because the note-off event always occurs well « after the fact » in the case of slow dampening.