예제 #1
0
    def render(self, name: str, cadence: old.Cadence) -> subprocess.Popen:
        seq = []
        for chord in cadence:
            dur = float(chord.delay)
            if chord.pitch != mel.TheEmptyPitch and bool(chord.pitch):
                size = len(chord.pitch)
                for idx, pi in enumerate(chord.pitch):
                    if idx + 1 == size:
                        de = float(dur)
                    else:
                        de = 0
                    if pi != mel.TheEmptyPitch:
                        if chord.volume:
                            volume = chord.volume
                        else:
                            volume = self.volume

                        tone = midiplug.PyteqTone(
                            ji.JIPitch(pi, multiply=self.CONCERT_PITCH),
                            de,
                            dur,
                            volume=volume,
                        )
                    else:
                        tone = midiplug.PyteqTone(
                            mel.TheEmptyPitch, de, dur, volume=self.volume
                        )
                    seq.append(tone)
            else:
                seq.append(old.Rest(dur))

        pt = midiplug.Pianoteq(tuple(seq), self.available_midi_notes)
        return pt.export2wav(name, 1, self.preset, self.fxp)
예제 #2
0
def mk_empty_attack(
    duration: float,
    volume: float,
    frequency: float = 35,
    hammer_noise: float = 3,
    impedance: float = 0.3,
    cutoff: float = 0.3,
    q_factor: float = 5,
    string_length: float = 0.8,
    strike_point: float = 1 / 2,
    hammer_hard_piano: float = 1,
    hammer_hard_mezzo: float = 1.5,
    hammer_hard_forte: float = 2,
    blooming_energy: float = 0,
) -> midiplug.PyteqTone:
    """Helps making percussive sounds with Pianoteq."""
    return midiplug.PyteqTone(
        ji.JIPitch(ji.r(1, 1), multiply=frequency),
        duration,
        duration,
        volume=volume,
        hammer_noise=hammer_noise,
        impedance=impedance,
        cutoff=cutoff,
        q_factor=q_factor,
        string_length=string_length,
        strike_point=strike_point,
        hammer_hard_piano=hammer_hard_piano,
        hammer_hard_mezzo=hammer_hard_mezzo,
        hammer_hard_forte=hammer_hard_forte,
        blooming_energy=blooming_energy,
    )
예제 #3
0
    def synthesize(self, name: str) -> None:
        sequence = []
        for tone in self:
            p = tone.pitch
            d = tone.delay
            p.multiply = self.concert_pitch
            d *= 4
            sequence.append(midiplug.PyteqTone(p, d, d))

        midiplug.Pianoteq(sequence).export2wav(name, preset='"Erard Player"')
예제 #4
0
    def synthesize(
        self,
        stretch_factor: float = 1,
        n_divisions: int = 8,
        min_tone_size: fractions.Fraction = 0,
        min_rest_size: fractions.Fraction = fractions.Fraction(1, 10),
        concert_pitch: float = None,
        tie_notes: bool = False,
        remove_rests: bool = False,
    ) -> None:

        if not concert_pitch:
            concert_pitch = self.concert_pitch

        pitches, delays = self.quantizise(
            stretch_factor=stretch_factor,
            n_divisions=n_divisions,
            min_tone_size=min_tone_size,
            min_rest_size=min_rest_size,
        )

        melody = old.Melody([old.Tone(p, d) for p, d in zip(pitches, delays)])

        if remove_rests:
            melody = melody.discard_rests()

        if tie_notes:
            melody = melody.tie()

        sequence = []
        for tone in melody:
            p = tone.pitch
            d = tone.delay
            p.multiply = concert_pitch
            d *= 4
            sequence.append(midiplug.PyteqTone(p, d, d))

        midiplug.Pianoteq(sequence).export2wav("{}_transcription".format(
            self.name),
                                               preset='"Erard Player"')
예제 #5
0
    def render(self, path: str) -> subprocess.Popen:
        adapted_rhythms = [
            rhythm * self.__tempo_factor for rhythm in self.__rhythm
        ]
        adapted_rhythms[-1] += self.__overlaying_time

        melody = old.Melody(
            tuple(
                old.Tone(p, r, r, volume=v) for p, r, v in zip(
                    self.__pitches, adapted_rhythms, self.__dynamics)))

        is_consonant_pitch_per_tone = tuple(
            self.__is_not_dissonant_pitch_per_tone)
        spectrum_profile_per_tone = tuple(self.__spectrum_profile_per_tone)

        if self.convert_dissonant_tones2glissandi:
            melody = self._convert_dissonant_tones2glissandi(melody)

        if self.__tremolo is not None:
            info = self.__tremolo(melody, is_consonant_pitch_per_tone,
                                  spectrum_profile_per_tone)
            melody, is_consonant_pitch_per_tone, spectrum_profile_per_tone = info

        for modulator in self.modulator:
            melody = modulator(melody)

        sequence = []
        for tone, is_not_dissonant_pitch, spectrum_profile in zip(
                melody, is_consonant_pitch_per_tone,
                spectrum_profile_per_tone):

            pitch, rhythm, volume, glissando = (
                tone.pitch,
                tone.delay,
                tone.volume,
                tone.glissando,
            )

            if pitch.is_empty:
                tone = pteqer.mk_empty_attack(
                    rhythm, next(self.empty_attack_dynamic_maker))

            else:
                if is_not_dissonant_pitch:
                    parameters = dict(self.parameter_non_dissonant_pitches)

                else:
                    parameters = dict(self.parameter_dissonant_pitches)

                for par in parameters:
                    value = parameters[par]
                    if isinstance(value, infit.InfIt):
                        parameters[par] = next(value)
                    elif (isinstance(value, float) or isinstance(value, int)
                          or value is None):
                        parameters[par] = value
                    else:
                        msg = "Unknown value type: {}.".format(type(value))
                        raise TypeError(msg)

                if parameters["pinch_harmonic_pedal"] == 1:
                    if parameters["pinch_harmonic_pedal"]:
                        pitch -= ji.r(2, 1)

                tone = midiplug.PyteqTone(
                    ji.JIPitch(pitch, multiply=globals.CONCERT_PITCH),
                    rhythm,
                    rhythm,
                    volume=volume,
                    glissando=glissando,
                    spectrum_profile_3=spectrum_profile[0],
                    spectrum_profile_5=spectrum_profile[1],
                    spectrum_profile_6=spectrum_profile[0],
                    spectrum_profile_7=spectrum_profile[2],
                    **parameters,
                )

            sequence.append(tone)

        pteq = midiplug.Pianoteq(tuple(sequence))
        return pteq.export2wav(path, preset=self.preset, fxp=self.fxp)