# Danish translation of gst-plugins-bad.
# Copyright (C) 2015 Mogens Jaeger og Joe Hansen.
# This file is distributed under the same license as the gst-plugins-bad package.
# Mogens Jaeger <mogens@jaeger.tf>, 2007.
# Joe Hansen <joedalton2@yahoo.dk>, 2008, 2009, 2011, 2013, 2014, 2015.
#
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-bad-1.6.0\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2016-11-01 17:49+0200\n"
"PO-Revision-Date: 2015-12-05 11:28+0200\n"
"Last-Translator: Joe Hansen <joedalton2@yahoo.dk>\n"
"Language-Team: Danish <dansk@dansk-gruppen.dk>\n"
"Language: da\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 blev ikke forhandlet før hent funktion"

msgid "OpenCV failed to load template image"
msgstr "OpenCV mislykkedes i at indlæse skabelonaftryk"

msgid "Could not read title information for DVD."
msgstr "Kunne ikke læse titelinformation for dvd."

#, c-format
msgid "Failed to open DVD device '%s'."
msgstr "Kunne ikke åbne dvd-enhed »%s«."

msgid "Failed to set PGC based seeking."
msgstr "Kunne ikke indstille PGC-baseret søgning."

msgid ""
"Could not read DVD. This may be because the DVD is encrypted and a DVD "
"decryption library is not installed."
msgstr ""
"Kunne ikke læse dvd. Dette kan være fordi dvd'en er krypteret og et dvd-"
"dekrypteringsbibliotek ikke er installeret."

msgid "Could not read DVD."
msgstr "Kunne ikke læse dvd."

msgid "This file contains no playable streams."
msgstr "Denne fil indeholder ingen spilbare strømme."

msgid "Could not open sndfile stream for reading."
msgstr "Kunne ikke åbne sndfile-strøm for læsning."

msgid "Could not establish connection to sndio"
msgstr "Kunne ikke etablere forbindelse til sndio"

msgid "Failed to query sndio capabilities"
msgstr "Kunne ikke forespørge sndio-funktioner"

msgid "Could not configure sndio"
msgstr "Kunne ikke konfigurere"

msgid "Could not start sndio"
msgstr "Kunne ikke starte sndio"

# pre-roll. The name of an online video commercial that appears prior to an online video,
# http://en.wiktionary.org/wiki/preroll
msgid "Generated file has a larger preroll time than its streams duration"
msgstr "Oprettet fil har en længere preroll-tid end strømmens varighed"

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr "Manglende element »%s« - kontroller din GStreamer-installation."

msgid "File location is set to NULL, please set it to a valid filename"
msgstr "Filplacering er sat til NULL, sæt den venligst til et gyldigt filnavn"

msgid "Digitalzoom element couldn't be created"
msgstr "Digitalzoom-element kunne ikke oprettes"

msgid "Subpicture format was not configured before data flow"
msgstr "Format for underbillede blev ikke konfigureret før datastrøm"

msgid "Failed to get fragment URL."
msgstr "Kunne ikke indhente fragmentadresse."

msgid "Couldn't download fragments"
msgstr "Kunne ikke hente fragmenter"

msgid "Internal data stream error."
msgstr "Intern datastrømfejl."

msgid "No file name specified for writing."
msgstr "Intet filnavn er angivet til skrivning."

#, c-format
msgid "Given file name \"%s\" can't be converted to local file name encoding."
msgstr ""
"Det angivne filnavn »%s« kan ikke konverteres til en lokal filnavnskodning."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Kunne ikke åbne filen »%s« til skrivning."

#, c-format
msgid "Device \"%s\" does not exist."
msgstr "Enheden »%s« eksisterer ikke."

#, c-format
msgid "Could not open frontend device \"%s\"."
msgstr "Kunne ikke åbne forende-enheden »%s«."

#, c-format
msgid "Could not get settings from frontend device \"%s\"."
msgstr "Kunne ikke hente indstillinger fra forende-enheden »%s«."

#, c-format
msgid "Cannot enumerate delivery systems from frontend device \"%s\"."
msgstr "Kunne opregne leveringssystemer fra forende-enheden »%s«."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Kunne ikke åbne filen »%s« for læsning."

#, fuzzy
msgid "Couldn't find channel configuration file"
msgstr "Kunne ikke finde DVB-kanalens konfigurationsfil"

#, fuzzy, c-format
msgid "Couldn't load channel configuration file: '%s'"
msgstr "Kunne ikke indlæse DVB-kanalens konfigurationsfil: %s"

#, fuzzy, c-format
msgid "Couldn't find details for channel '%s'"
msgstr "Kunne ikke finde detaljer for DVB-kanalen %s"

#, fuzzy, c-format
msgid "No properties for channel '%s'"
msgstr "Kunne ikke finde detaljer for DVB-kanalen %s"

#, fuzzy, c-format
msgid "Failed to set properties for channel '%s'"
msgstr "Kunne ikke finde detaljer for DVB-kanalen %s"

#, fuzzy, c-format
msgid "Couldn't find channel configuration file: '%s'"
msgstr "Kunne ikke finde DVB-kanalens konfigurationsfil"

#, fuzzy
msgid "Channel configuration file doesn't contain any channels"
msgstr "DVB-kanalens konfigurationsfil indeholder ikke nogen kanaler"

#~ msgid "Internal data flow error."
#~ msgstr "Intern datastrømfejl."

#~ msgid "default GStreamer sound events audiosink"
#~ msgstr "standardlydkanal for GStreamers lydhændelser"

#~ 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 kan afspille lyd via et antal udgangselementer. Nogle mulige "
#~ "valg er osssink, pulsesink og alsasink. Lydudgangen kan være en delvis "
#~ "datakanal i stedet for bare et element."

#~ msgid "description for default GStreamer sound events audiosink"
#~ msgstr "beskrivelse af standardlydkanal for GStreamers lydhændelser"

#~ msgid "Describes the selected audiosink element."
#~ msgstr "Beskriver det valge lydkanalelement."

#~ msgid "default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr "standardlydkanal til GStreamers lyd/video-konference"

#~ msgid ""
#~ "description for default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr ""
#~ "beskrivelse for standardlydkanal til GStreamers lyd/video-konference"

#~ msgid "default GStreamer audiosink for Music and Movies"
#~ msgstr "standardlydkanal til GStreamers musik og film"

#~ msgid "description for default GStreamer audiosink for Music and Movies"
#~ msgstr "beskrivelse for standardlydkanal til GStreamers musik og film"

#~ msgid "default GStreamer videosink"
#~ msgstr "standardlydkanal for GStreamer"

#~ 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 kan afspille video via et antal udgangselementer. Nogle mulige "
#~ "valg er xvimagesink, ximagesink, sdlvideosink og aasink. Videoudgangen "
#~ "kan være en delvis datakanal i stedet for bare et element."

#~ msgid "description for default GStreamer videosink"
#~ msgstr "beskrivelse for standardvideokanal for GStreamer"

#~ msgid "Describes the selected videosink element."
#~ msgstr "Beskriver den valgte videokanalselement."

#~ msgid "default GStreamer audiosrc"
#~ msgstr "standardlydoptagelse for GStreamer"

#~ 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 kan optage lyd via et antal indgangselementer. Nogle mulige "
#~ "valg er osssrc, pulsesrc og alsasrc. Lydkilden kan være en delvis "
#~ "datakanal i stedet for bare et element."

#~ msgid "description for default GStreamer audiosrc"
#~ msgstr "beskrivelse for standardlydoptagelsen til GStreamer"

#~ msgid "Describes the selected audiosrc element."
#~ msgstr "Beskriver det valgte lydoptagelseselement."

#~ msgid "default GStreamer videosrc"
#~ msgstr "standardvideooptager for GStreamer"

#~ 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 kan optage video via et antal indgangselementer. Nogle mulige "
#~ "valg er v4lsrc, v4l2src og videotestsrc. Videokilden kan være en delvis "
#~ "datakanal i stedet for bare et element."

#~ msgid "description for default GStreamer videosrc"
#~ msgstr "beskrivelse for standardvideooptageren til GStreamer"

#~ msgid "Describes the selected videosrc element."
#~ msgstr "Beskriver det valgte videooptagerelement."

#~ msgid "default GStreamer visualization"
#~ msgstr "Standardvisualisering for GStreamer"

#~ 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 kan placere visualiseringsudvidelsesmoduler i en datakanal for "
#~ "at transformere lydstrømme i videobilleder. Nogle mulige valg er goom, "
#~ "goom2k1 og synaesthesia. Visualiseringsudvidelsesmodulerne kan være en "
#~ "delvis datakanal i stedet for bare et element."

#~ msgid "description for default GStreamer visualization"
#~ msgstr "beskrivelse for standardvisualisering til GStreamer"

#~ msgid "Describes the selected visualization element."
#~ msgstr "Beskriver det valgte visualiseringselement."

#~ msgid "Couldn't get the Manifest's URI"
#~ msgstr "Kunne ikke indhente Manifestens adresse"

#~ msgid "Could not write to file \"%s\"."
#~ msgstr "Kunne ikke skrive til fil »%s«."
