# Translation of gst-plugins-bad to French
# Copyright (C) 2003-2011 GStreamer core team
# This file is distributed under the same license as the gst-plugins-bad package.
#
# Claude Paroz <claude@2xlibre.net>, 2008-2011.
# Stéphane Aulery <lkppo@free.fr>, 2015.
#
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-bad 1.7.2\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2016-07-06 11:51+0300\n"
"PO-Revision-Date: 2016-02-20 16:27+0100\n"
"Last-Translator: Stéphane Aulery <lkppo@free.fr>\n"
"Language-Team: French <traduc@traduc.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

msgid "failed to draw pattern"
msgstr ""

msgid "A GL error occured"
msgstr ""

msgid "format wasn't negotiated before get function"
msgstr "Format non négocié avant l'appel de la fonction get"

msgid "OpenCV failed to load template image"
msgstr "OpenCV n’a pas pu charger l’image modèle"

msgid "Could not read title information for DVD."
msgstr "Impossible de lire les informations de titre du DVD."

#, c-format
msgid "Failed to open DVD device '%s'."
msgstr "Impossible d’ouvrir le périphérique du DVD « %s »."

msgid "Failed to set PGC based seeking."
msgstr "Impossible de définir la recherche basée sur PGC."

msgid ""
"Could not read DVD. This may be because the DVD is encrypted and a DVD "
"decryption library is not installed."
msgstr ""
"Impossible de lire le DVD. Il se peut qu’il soit chiffré et qu’aucune "
"bibliothèque de déchiffrement DVD ne soit installée."

msgid "Could not read DVD."
msgstr "Impossible de lire le DVD."

msgid "This file contains no playable streams."
msgstr "Ce fichier ne contient aucun flux exploitable."

msgid "Could not open sndfile stream for reading."
msgstr "Impossible d’ouvrir le fichier snd en lecture."

msgid "Could not establish connection to sndio"
msgstr "Impossible de se connecter à sndio"

msgid "Failed to query sndio capabilities"
msgstr "Impossible d’interroger les capacités de sndio"

msgid "Could not configure sndio"
msgstr "Impossible de configurer sndio"

msgid "Could not start sndio"
msgstr "Impossible de démarrer sndio"

msgid "Internal data flow error."
msgstr "Erreur du flux de données interne."

msgid "Generated file has a larger preroll time than its streams duration"
msgstr ""
"Le fichier généré a un temps de lancement plus long que la durée du flux"

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr "Élément « %s » manquant — Vérifiez votre installation de GStreamer."

msgid "File location is set to NULL, please set it to a valid filename"
msgstr ""
"L’emplacement du fichier est inconnu (NULL), veuillez choisir un nom de "
"fichier valide"

msgid "Digitalzoom element couldn't be created"
msgstr "L’élément Digitalzoom n’a pu être créé"

msgid "Subpicture format was not configured before data flow"
msgstr "Le format de sous-image n’était pas configuré avant le flux de données"

msgid "Failed to get fragment URL."
msgstr "Échec de la récupération de l’URL de fragment."

msgid "Internal data stream error."
msgstr "Erreur interne de flux de données."

msgid "Couldn't download fragments"
msgstr "Impossible de télécharger les fragments"

msgid "No file name specified for writing."
msgstr "Aucun nom de fichier indiqué en écriture."

#, c-format
msgid "Given file name \"%s\" can't be converted to local file name encoding."
msgstr ""
"Le nom de fichier indiqué « %s » ne peut pas être converti dans l’encodage "
"local au système de fichier."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Impossible d’ouvrir le fichier « %s » en écriture."

#, c-format
msgid "Device \"%s\" does not exist."
msgstr "Le périphérique « %s » n’existe pas."

#, c-format
msgid "Could not open frontend device \"%s\"."
msgstr "Impossible d’ouvrir le périphérique frontal « %s »."

#, c-format
msgid "Could not get settings from frontend device \"%s\"."
msgstr "Impossible d’obtenir les paramètres du périphérique frontal « %s »."

#, c-format
msgid "Cannot enumerate delivery systems from frontend device \"%s\"."
msgstr ""
"Impossible d'énumérer les systèmes d’émission du périphérique frontal « %s »."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Impossible d’ouvrir le fichier « %s » en lecture."

msgid "Couldn't find DVB channel configuration file"
msgstr "Impossible de trouver le fichier de configuration de canal DVB"

#, c-format
msgid "Couldn't load DVB channel configuration file: %s"
msgstr "Impossible de charger le fichier de configuration de canal DVB : %s"

#, c-format
msgid "Couldn't find details for DVB channel %s"
msgstr "Impossible de trouver des informations sur le canal DVB %s"

#, fuzzy, c-format
msgid "No properties for the DVB channel %s"
msgstr "Impossible de trouver des informations sur le canal DVB %s"

#, fuzzy, c-format
msgid "Failed to set properties for the DVB channel %s"
msgstr "Impossible de trouver des informations sur le canal DVB %s"

#, fuzzy, c-format
msgid "Couldn't find DVB channel configuration file: %s"
msgstr "Impossible de trouver le fichier de configuration de canal DVB"

msgid "DVB channel configuration file doesn't contain any channels"
msgstr "Le fichier de configuration de canal DVB ne contient aucun canal"

#~ msgid "default GStreamer sound events audiosink"
#~ msgstr "récepteur audio GStreamer par défaut pour les événements sonores"

#~ msgid ""
#~ "GStreamer can play audio using any number of output elements. Some "
#~ "possible choices are osssink, pulsesink and alsasink. The audiosink can "
#~ "be a partial pipeline instead of just one element."
#~ msgstr ""
#~ "GStreamer peut lire des sons depuis un nombre quelconque d’éléments en "
#~ "entrée. Les choix possibles sont osssink, pulsesink et alsasink. Le "
#~ "source audio peut être un pipeline partiel au lieu d’un élément unique."

#~ msgid "description for default GStreamer sound events audiosink"
#~ msgstr ""
#~ "description du récepteur audio GStreamer par défaut pour les événements "
#~ "sonores"

#~ msgid "Describes the selected audiosink element."
#~ msgstr "Décrit le récepteur audio sélectionné."

#~ msgid "default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr ""
#~ "récepteur audio GStreamer par défaut pour les confèrences audiovisuelles"

#~ msgid ""
#~ "description for default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr ""
#~ "description du récepteur audio GStreamer par défaut pour les confèrences "
#~ "audiovisuelles"

#~ msgid "default GStreamer audiosink for Music and Movies"
#~ msgstr "récepteur audio GStreamer par défaut pour la musique et les films"

#~ msgid "description for default GStreamer audiosink for Music and Movies"
#~ msgstr ""
#~ "description du récepteur audio GStreamer par défaut pour la musique et "
#~ "les films"

#~ msgid "default GStreamer videosink"
#~ msgstr "récepteur vidéo GStreamer par défaut"

#~ msgid ""
#~ "GStreamer can play video using any number of output elements. Some "
#~ "possible choices are xvimagesink, ximagesink, sdlvideosink and aasink. "
#~ "The videosink can be a partial pipeline instead of just one element."
#~ msgstr ""
#~ "GStreamer peut lire une vidéo depuis un nombre quelconque d’éléments en "
#~ "entrée. Les choix possibles sont xvimagesink, ximagesink, sdlvideosink et "
#~ "aasink. Le source vidéo peut être un pipeline partiel au lieu d’un "
#~ "élément unique."

#~ msgid "description for default GStreamer videosink"
#~ msgstr "description du récepteur vidéo GStreamer par défaut"

#~ msgid "Describes the selected videosink element."
#~ msgstr "Décrit le récepteur vidéo sélectionné."

#~ msgid "default GStreamer audiosrc"
#~ msgstr "source audio GStreamer par défaut"

#~ msgid ""
#~ "GStreamer can record audio using any number of input elements. Some "
#~ "possible choices are osssrc, pulsesrc and alsasrc. The audio source can "
#~ "be a partial pipeline instead of just one element."
#~ msgstr ""
#~ "GStreamer peut enregistrer des sons depuis un nombre quelconque "
#~ "d’éléments en entrée. Les choix possibles sont osssrc, pulsesrc et "
#~ "alsasrc. Le source audio peut être un pipeline partiel au lieu d’un "
#~ "élément unique."

#~ msgid "description for default GStreamer audiosrc"
#~ msgstr "description de la source audio GStreamer par défaut"

#~ msgid "Describes the selected audiosrc element."
#~ msgstr "Décrit la source audio sélectionnée."

#~ msgid "default GStreamer videosrc"
#~ msgstr "source vidéo GStreamer par défaut"

#~ msgid ""
#~ "GStreamer can record video from any number of input elements. Some "
#~ "possible choices are v4lsrc, v4l2src and videotestsrc. The video source "
#~ "can be a partial pipeline instead of just one element."
#~ msgstr ""
#~ "GStreamer peut enregistrer une vidéo depuis un nombre quelconque "
#~ "d’éléments en entrée. Les choix possibles sont v4lsrc, v4l2src et "
#~ "videotestsrc. Le source vidéo peut être un pipeline partiel au lieu d’un "
#~ "élément unique."

#~ msgid "description for default GStreamer videosrc"
#~ msgstr "description de la source vidéo GStreamer par défaut"

#~ msgid "Describes the selected videosrc element."
#~ msgstr "Décrit la source vidéo sélectionnée."

#~ msgid "default GStreamer visualization"
#~ msgstr "aperçu GStreamer par défaut"

#~ msgid ""
#~ "GStreamer can put visualization plugins in a pipeline to transform audio "
#~ "streams in video frames. Some possible choices are goom, goom2k1 and "
#~ "synaesthesia. The visualization plugin can be a partial pipeline instead "
#~ "of just one element."
#~ msgstr ""
#~ "GStreamer peut mettre les extensions d’aperçu dans un pipeline pour "
#~ "transformer les flux audios en frames vidéo. Les choix possibles sont "
#~ "goom, goom2k1 et synaesthesia. L’extension d’aperçu peut être un pipeline "
#~ "partiel au lieu d’un élément unique."

#~ msgid "description for default GStreamer visualization"
#~ msgstr "description de l’aperçu GStreamer par défaut"

#~ msgid "Describes the selected visualization element."
#~ msgstr "Décrit l’élément d’aperçu sélectionné."
