TextToSpeech QML Type

Le type TextToSpeech permet d'accéder à des moteurs de synthèse vocale. En savoir plus...

• Liste de tous les membres, y compris les membres hérités

Propriétés

• engine : string
• engineCapabilities : enumeration (since 6.6)
• engineParameters : map
• locale : locale
• pitch : double
• rate : double
• state : enumeration
• voice : voice
• volume : double

Signaux

• aboutToSynthesize(number id) (since 6.6)
• void errorOccurred(enumeration reason, string errorString)
• sayingWord(string word, int id, int start, int length) (since 6.6)

Méthodes

• list<string> availableEngines()
• list<voice> availableLocales()
• list<voice> availableVoices()
• int enqueue(string utterance) (since 6.6)
• enumeration errorReason()
• string errorString()
• list<voice> findVoices(map criteria) (since 6.6)
• void pause(BoundaryHint boundaryHint)
• void resume()
• void say(string text)
• void stop(BoundaryHint boundaryHint)

Description détaillée

Utilisez la fonction say() pour lancer la lecture du texte sur le périphérique audio par défaut, et les fonctions stop(), pause() et resume() pour contrôler la lecture du texte.

    TextToSpeech {
        id: tts
        volume: volumeSlider.value
        pitch: pitchSlider.value
        rate: rateSlider.value
    ...

        RowLayout {
            Button {
                text: qsTr("Speak")
                enabled: [TextToSpeech.Paused, TextToSpeech.Ready].includes(tts.state)
                onClicked: {
                    let voices = tts.availableVoices()
                    tts.voice = voices[voicesComboBox.currentIndex]
                    tts.say(input.text)
                }
            }
            Button {
                text: qsTr("Pause")
                enabled: tts.state == TextToSpeech.Speaking
                onClicked: tts.pause()
                visible: tts.engineCapabilities & TextToSpeech.Capabilities.PauseResume
            }
            Button {
                text: qsTr("Resume")
                enabled: tts.state == TextToSpeech.Paused
                onClicked: tts.resume()
                visible: tts.engineCapabilities & TextToSpeech.Capabilities.PauseResume
            }
    ...

Pour synthétiser le texte en données PCM en vue d'un traitement ultérieur, utilisez la méthode `synthesize()`.

Pour définir une voix, utilisez la propriété associée « VoiceSelector » comme suit :

TextToSpeech {
    VoiceSelector.locale: Qt.locale("en_UK")
    VoiceSelector.gender: Voice.Male
}

La première voix correspondant à tous les critères spécifiés sera utilisée. Si aucune voix ne correspond à tous les critères, la voix ne changera pas.

Vous pouvez également utiliser la fonction ` findVoices()` pour obtenir une liste des voix correspondantes, ou la fonction ` availableVoices()` pour obtenir la liste des voix prenant en charge les paramètres régionaux actuels. Modifiez la propriété ` locale ` en utilisant l’une des fonctions ` availableLocales()` qui correspond le mieux à la langue du texte saisi et à l’accent de la sortie vocale souhaitée. Cela modifiera la liste des voix disponibles sur la plupart des plateformes. Utilisez ensuite l’une des voix disponibles dans la propriété ` voice `.

Tous les moteurs ne prennent pas en charge l’ensemble des fonctionnalités. Utilisez la fonction engineCapabilities() pour vérifier quelles fonctionnalités sont disponibles, puis adaptez l’utilisation du type en conséquence.

Documentation sur les propriétés

engine : string

Le moteur utilisé pour la synthèse vocale.

Le changement de moteur interrompt toute lecture en cours.

Sur la plupart des plateformes, le changement de moteur entraîne la mise à jour de la liste des fichiers « available locales » et « available voices ».

engineCapabilities : enumeration [since 6.6]

Cette propriété contient les fonctionnalités implémentées par le moteur actuel.

Cette propriété a été introduite dans Qt 6.6.

Voir également engine et QTextToSpeech::Capability.

engineParameters : map

Cette propriété contient des paramètres spécifiques au moteur.

Voir également engine.

locale : locale

Cette propriété contient les paramètres régionaux actuellement utilisés.

Par défaut, c'est la locale système qui est utilisée.

Voir également voice.

pitch : double

Cette propriété définit la hauteur de la voix, comprise entre -1,0 et 1,0.

La valeur par défaut, 0,0, correspond à la hauteur de la voix normale.

rate : double

Cette propriété contient la vitesse de parole actuelle, comprise entre -1,0 et 1,0.

La valeur par défaut, 0,0, correspond à un débit de parole normal.

state : enumeration

Cette propriété contient l'état actuel du synthétiseur vocal.

        onStateChanged: updateStateLabel(state)

        function updateStateLabel(state)
        {
            switch (state) {
                case TextToSpeech.Ready:
                    statusLabel.text = qsTr("Ready")
                    break
                case TextToSpeech.Speaking:
                    statusLabel.text = qsTr("Speaking")
                    break
                case TextToSpeech.Paused:
                    statusLabel.text = qsTr("Paused...")
                    break
                case TextToSpeech.Error:
                    statusLabel.text = qsTr("Error!")
                    break
            }
        }

Voir également QTextToSpeech::State, say(), stop() et pause().

voice : voice

Cette propriété définit la voix qui sera utilisée pour la synthèse vocale.

La voix doit faire partie de la liste des voix disponibles pour le moteur ( voices available ).

Sur certaines plateformes, la configuration de la voix modifie d’autres attributs vocaux tels que « locale », « pitch », etc. Ces modifications déclenchent l’émission de signaux.

volume : double

Cette propriété contient le volume actuel, compris entre 0,0 et 1,0.

La valeur par défaut correspond au volume par défaut de la plateforme.

Documentation sur les signaux

[since 6.6] aboutToSynthesize(number id)

Ce signal est émis juste avant que le moteur ne commence à synthétiser le flux audio de id. Les applications peuvent utiliser ce signal pour apporter des modifications de dernière minute aux attributs de voice, ou pour suivre le traitement du texte mis en file d'attente via enqueue().

Ce signal a été introduit dans Qt 6.6.

Voir également enqueue() et voice.

void errorOccurred(enumeration reason, string errorString)

Ce signal est émis lorsqu'une erreur s'est produite et que l'state a été défini sur TextToSpeech.Error. Le paramètre reason spécifie le type d'erreur, tandis que le paramètre errorString fournit une description de l'erreur lisible par l'utilisateur.

Voir également state, errorReason() et errorString().

[since 6.6] sayingWord(string word, int id, int start, int length)

Ce signal est émis lorsque l'word, c'est-à-dire la partie de texte indiquée par start et length dans l'énoncé id, est diffusée sur le périphérique audio.

Le code suivant met en évidence le mot prononcé dans un TextArea input :

        onSayingWord: (word, id, start, length)=> {
            input.select(start, start + length)
        }

Ce signal a été introduit dans Qt 6.6.

Voir également QTextToSpeech::Capability et say().

Documentation de la méthode

list<string> availableEngines()

Contient la liste des plug-ins de synthèse vocale pris en charge.

list<voice> availableLocales()

Contient la liste des paramètres régionaux pris en charge par l'engine e active.

list<voice> availableVoices()

Contient la liste des voix disponibles pour l'locale ion en cours.

[since 6.6] int enqueue(string utterance)

Ajoute utterance à la file d'attente des textes à lire à voix haute, puis commence la lecture.

Si le message « state » du moteur est actuellement « Ready », « utterance » sera lu immédiatement. Sinon, le moteur commencera à lire « utterance » une fois qu’il aura fini de lire le texte actuel.

Chaque fois que le moteur passe à l’entrée de texte suivante dans la file d’attente, le signal aboutToSynthesize() est émis. Cela permet aux applications de suivre la progression et d’apporter des modifications de dernière minute aux attributs vocaux.

L'appel à stop() vide la file d’attente.

Cette méthode a été introduite dans Qt 6.6.

Voir également say(), stop() et aboutToSynthesize().

enumeration errorReason()

Renvoie la raison pour laquelle le moteur a signalé une erreur.

Voir également QTextToSpeech::ErrorReason.

string errorString()

Renvoie le message d'erreur actuel du moteur.

[since 6.6] list<voice> findVoices(map criteria)

Renvoie la liste des voix qui correspondent à tous les critères de recherche spécifiés criteria.

criteria Il s'agit d'une table associant le nom d'une propriété de voix à sa valeur, prenant en charge des combinaisons de critères de recherche telles que :

let daniel = tts.findVoices({
    "name": "Daniel"
})
let maleEnglish = tts.findVoices({
    "gender": Voice.Male,
    "language": Qt.locale('en')
})

Cette méthode a été introduite dans Qt 6.6.

Voir également VoiceSelector.

void pause(BoundaryHint boundaryHint)

Met en pause le discours en cours à l'adresse boundaryHint.

Le respect de l'boundaryHint dépend de l'engine.

Voir également resume(), QTextToSpeech::BoundaryHint et PauseResume.

void resume()

Reprendre la lecture une fois que la fonction pause() a été appelée.

Voir également pause().

void say(string text)

Lance la synthèse de l'text.

Cette fonction lance la synthèse vocale de manière asynchrone et lit le texte sur le périphérique de sortie audio par défaut.

        RowLayout {
            Button {
                text: qsTr("Speak")
                enabled: [TextToSpeech.Paused, TextToSpeech.Ready].includes(tts.state)
                onClicked: {
                    let voices = tts.availableVoices()
                    tts.voice = voices[voicesComboBox.currentIndex]
                    tts.say(input.text)
                }
            }

L'état actuel est accessible via la propriété ` state ` et est défini sur ` QTextToSpeech::Speaking ` dès que la lecture commence. Une fois la lecture terminée, ` state ` sera défini sur ` QTextToSpeech::Ready`.

Voir également stop(), pause() et resume().

void stop(BoundaryHint boundaryHint)

Interrompt la lecture en cours à l'adresse boundaryHint et efface la file d'attente des textes en attente.

La lecture ne peut pas être reprise. Le respect de la valeur « boundaryHint » dépend du moteur.

Voir également say(), enqueue(), pause() et QTextToSpeech::BoundaryHint.