# Swedish translation for gst-plugins-bad.
# Copyright (C) 2007-2015 Free Software Foundation, Inc.
# This file is distributed under the same license as the gst-plugins-bad package.
# Daniel Nylander <po@danielnylander.se>, 2007, 2008, 2009.
# Sebastian Rasmussen <sebras@gmail.com>, 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-29 15:49+0200\n"
"PO-Revision-Date: 2015-11-01 00:48+0100\n"
"Last-Translator: Sebastian Rasmussen <sebras@gmail.com>\n"
"Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
"Language: sv\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"
"X-Generator: Poedit 1.8.6\n"

msgid "failed to draw pattern"
msgstr ""

msgid "A GL error occured"
msgstr ""

msgid "format wasn't negotiated before get function"
msgstr "formatet förhandlades inte fram innan hämtfunktionen"

msgid "OpenCV failed to load template image"
msgstr "OpenCV misslyckades med att läsa in mallbild"

msgid "Could not read title information for DVD."
msgstr "Kunde inte läsa titelinformation för dvd."

#, c-format
msgid "Failed to open DVD device '%s'."
msgstr "Misslyckades med att öppna dvd-enheten \"%s\"."

msgid "Failed to set PGC based seeking."
msgstr "Misslyckades med att ställa in PGC-baserad spolning."

msgid ""
"Could not read DVD. This may be because the DVD is encrypted and a DVD "
"decryption library is not installed."
msgstr ""
"Kunde ej läsa dvd. Detta kan vara på grund av att dvd:n är krypterad och ett "
"DVD avkrypteringsbibliotek inte är installerat."

msgid "Could not read DVD."
msgstr "Kunde inte läsa dvd."

msgid "This file contains no playable streams."
msgstr "Den här filen innehåller inga spelbara strömmar."

msgid "Could not open sndfile stream for reading."
msgstr "Kunde inte öppna sndfile-ström för läsning."

msgid "Could not establish connection to sndio"
msgstr "Kunde ej etablera uppkoppling till sndio"

msgid "Failed to query sndio capabilities"
msgstr "Misslyckades att fråga om sndio-förmågor"

msgid "Could not configure sndio"
msgstr "Kunde inte konfigurera sndio"

msgid "Could not start sndio"
msgstr "Kunde ej starta sndio"

msgid "Generated file has a larger preroll time than its streams duration"
msgstr "Den genererade filen har en längre förrullningstid än dess strömlängd"

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr "Saknar element \"%s\" - kontrollera din GStreamer-installation."

msgid "File location is set to NULL, please set it to a valid filename"
msgstr ""
"Filposition är satt till NULL, vänligen sätt den till ett giltigt filnamn"

msgid "Digitalzoom element couldn't be created"
msgstr "Elementet Digitalzoom kunde inte skapas"

msgid "Subpicture format was not configured before data flow"
msgstr "Delbildsformat var inte konfigurerat före dataflöde"

msgid "Failed to get fragment URL."
msgstr "Misslyckades att hämta fragment-URL"

msgid "Couldn't download fragments"
msgstr "Kunde ej ladda ner fragment"

msgid "Internal data stream error."
msgstr "Internt fel i dataström."

msgid "No file name specified for writing."
msgstr "Inget filnamn angavs för skrivning."

#, c-format
msgid "Given file name \"%s\" can't be converted to local file name encoding."
msgstr "Angivet filnamn \"%s\" kan ej konverteras till lokal filnamnskodning."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Kunde inte öppna filen \"%s\" för skrivning."

#, c-format
msgid "Device \"%s\" does not exist."
msgstr "Enheten \"%s\" finns inte."

#, c-format
msgid "Could not open frontend device \"%s\"."
msgstr "Kunde inte öppna framändsenheten \"%s\"."

#, c-format
msgid "Could not get settings from frontend device \"%s\"."
msgstr "Kunde inte få inställningar från framändsenheten \"%s\"."

#, c-format
msgid "Cannot enumerate delivery systems from frontend device \"%s\"."
msgstr "Kan ej lista leveranssystem från framändsenheten \"%s\"."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Kunde inte öppna filen \"%s\" för läsning."

#, fuzzy
msgid "Couldn't find channel configuration file"
msgstr "Kunde ej hitta konfigurationsfil för DVB-kanal"

#, fuzzy, c-format
msgid "Couldn't load channel configuration file: '%s'"
msgstr "Kunde ej ladda konfigurationsfil för DVB-kanal: %s"

#, fuzzy, c-format
msgid "Couldn't find details for channel '%s'"
msgstr "Kunde ej hitta detaljer för DVB-kanal %s"

#, fuzzy, c-format
msgid "No properties for channel '%s'"
msgstr "Kunde ej hitta detaljer för DVB-kanal %s"

#, fuzzy, c-format
msgid "Failed to set properties for channel '%s'"
msgstr "Misslyckades med att öppna dvd-enheten \"%s\"."

#, fuzzy, c-format
msgid "Couldn't find channel configuration file: '%s'"
msgstr "Kunde ej hitta konfigurationsfil för DVB-kanal"

#, fuzzy
msgid "Channel configuration file doesn't contain any channels"
msgstr "Konfigurationsfil för DVB-kanal innehåller inga kanaler"

#~ msgid "default GStreamer sound events audiosink"
#~ msgstr "standard GStreamer-ljudutgång för ljudhä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 spela upp ljud via ett antal utgångselement. Några möjliga "
#~ "val är osssink, pulsesink och alsasink. Ljudutgången kan vara en "
#~ "delrörledning istället för bara ett element."

#~ msgid "description for default GStreamer sound events audiosink"
#~ msgstr "beskrivning för standard GStreamer-ljudutgång för ljudhändelser"

#~ msgid "Describes the selected audiosink element."
#~ msgstr "Beskriver det valda ljudutgångselementet."

#~ msgid "default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr "standard GStreamer-ljudutgång för ljud/video-konferenser"

#~ msgid ""
#~ "description for default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr ""
#~ "beskrivning för standard GStreamer-ljudutgång för ljud/video-konferenser"

#~ msgid "default GStreamer audiosink for Music and Movies"
#~ msgstr "standard GStreamer-ljudutgång för musik och filmer"

#~ msgid "description for default GStreamer audiosink for Music and Movies"
#~ msgstr "beskrivning för standard GStreamer-ljudutgång för musik och filmer"

#~ msgid "default GStreamer videosink"
#~ msgstr "standard GStreamer-videoutgång"

#~ 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 spela upp video via ett antal utgångselement. Några möjliga "
#~ "val är xvimagesink, ximagesink, sdlvideosink och aasink. Videoutgången "
#~ "kan vara en delrörledning istället för bara ett element."

#~ msgid "description for default GStreamer videosink"
#~ msgstr "beskrivning för standard GStreamer-videoutgång"

#~ msgid "Describes the selected videosink element."
#~ msgstr "Beskriver det valda videoutgångselementet."

#~ msgid "default GStreamer audiosrc"
#~ msgstr "standard GStreamer-ljudkälla"

#~ 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 spela in ljud från ett antal ingångselement. Några möjliga "
#~ "val är osssrc, pulsesrc och alsasrc. Ljudkällan kan vara en delrörledning "
#~ "istället för bara ett element."

#~ msgid "description for default GStreamer audiosrc"
#~ msgstr "beskrivning för standard GStreamer-ljudkälla"

#~ msgid "Describes the selected audiosrc element."
#~ msgstr "Beskriver det valda ljudkällselementet."

#~ msgid "default GStreamer videosrc"
#~ msgstr "standard GStreamer-videokälla"

#~ 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 spela in video från ett antal ingångselement. Några möjliga "
#~ "val är v4lsrc, v4l2src och videotestsrc. Videokällan kan vara en "
#~ "delrörledning istället för bara ett element."

#~ msgid "description for default GStreamer videosrc"
#~ msgstr "beskrivning för standard GStreamer-videokälla"

#~ msgid "Describes the selected videosrc element."
#~ msgstr "Beskriver det valda videokällselementet."

#~ msgid "default GStreamer visualization"
#~ msgstr "standard GStreamer-visualisering"

#~ 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 lägga in insticksmoduler för visualisering i en pipeline "
#~ "för att transformera ljudströmmar till videobilder. Några möjliga val är "
#~ "goom, goom2k1 och synaesthesia. Visualiseringsinsticksmodulen kan vara en "
#~ "delrörledning istället för bara ett element."

#~ msgid "description for default GStreamer visualization"
#~ msgstr "beskrivning för standard GStreamer-visualisering"

#~ msgid "Describes the selected visualization element."
#~ msgstr "Beskriver det valda visualiseringselementet."

#~ msgid "Internal data flow error."
#~ msgstr "Internt fel i dataflöde."

#~ msgid "Couldn't get the Manifest's URI"
#~ msgstr "Kunde ej hämta manifestets URI"

#~ msgid "Could not write to file \"%s\"."
#~ msgstr "Kunde inte skriva till filen \"%s\"."
