# Norwegian bokmaal translation of gst-utils.
# This file is put in the public domain.
#
# Kjartan Maraas <kmaraas@gnome.org>, 2004-2007.
# Johnny A. Solbu <johnny@solbu.net>, 2012-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-02-19 10:32+0200\n"
"PO-Revision-Date: 2015-12-22 21:08+0100\n"
"Last-Translator: Johnny A. Solbu <johnny@solbu.net>\n"
"Language-Team: Norwegian Bokmaal <i18n-nb@lister.ping.uio.no>\n"
"Language: nb_NO\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 1.6.9\n"

msgid "format wasn't negotiated before get function"
msgstr "formatet ble ikke forhandlet før get-funksjon"

msgid "OpenCV failed to load template image"
msgstr "OpenCV kunne ikke laste mal-bilde"

msgid "Could not read title information for DVD."
msgstr "Kunne ikke lese tittelinformasjonen til DVD-en."

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

msgid "Failed to set PGC based seeking."
msgstr "Kunne ikke sette PGC-basert søking."

msgid ""
"Could not read DVD. This may be because the DVD is encrypted and a DVD "
"decryption library is not installed."
msgstr ""
"Kunne ikke lese DVD-en. Dette kan være fordi DVD-en er kryptert DVD-"
"dekrypteringsbiblioteket ikke er installert."

msgid "Could not read DVD."
msgstr "Kunne ikke lese DVD-en."

msgid "This file contains no playable streams."
msgstr "Denne filen inneholder ingen spillbare strømmer."

msgid "Could not open sndfile stream for reading."
msgstr "Kunne ikke åpne sndfile for lesing."

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

msgid "Failed to query sndio capabilities"
msgstr "Spørring etter tilgjengelige egenskaper i sndio feilet"

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

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

msgid "Internal data flow error."
msgstr "Intern feil i datastrøm."

msgid "Generated file has a larger preroll time than its streams duration"
msgstr "Genererte filen har en større preroll tid enn strømmens varighet"

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

msgid "File location is set to NULL, please set it to a valid filename"
msgstr ""
"Filplassering er satt til NULL, vennligst sett den til et gyldig filnavn"

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

msgid "Subpicture format was not configured before data flow"
msgstr "Underbildeformat er ikke konfigurert før dataflyt"

msgid "Failed to get fragment URL."
msgstr "Klarte ikke å hente fragment-nettadresse."

msgid "Internal data stream error."
msgstr "Intern feil i datastrøm."

msgid "Couldn't download fragments"
msgstr "Kunne ikke laste ned fragmenter"

msgid "No file name specified for writing."
msgstr "Ingen filnavn oppgitt for skriving."

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

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

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

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

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

#, c-format
msgid "Cannot enumerate delivery systems from frontend device \"%s\"."
msgstr "Kan ikke nummerere leveringssystemer fra frontenhet «%s»."

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

msgid "Couldn't find DVB channel configuration file"
msgstr "Kunne ikke finne DVB-kanal-konfigurasjonsfil"

#, c-format
msgid "Couldn't load DVB channel configuration file: %s"
msgstr "Kunne ikke finne DVB-kanalkonfigurasjonsfil: %s"

msgid "DVB channel configuration file doesn't contain any channels"
msgstr "DVB-kanalkonfigurasjonsfilen inneholder ingen kanaler"

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

#~ msgid "default GStreamer sound events audiosink"
#~ msgstr "standard GStreamer lydhendelser-audiosink"

#~ 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 spille av lyd ved hjelp av en rekke utgangselementer. Noen "
#~ "mulige valg er osssink, pulsesink og alsasink. Audiosinken kan være en "
#~ "delvis kommandokø i stedet for bare ett element."

#~ msgid "description for default GStreamer sound events audiosink"
#~ msgstr "beskrivelse for standard GStreamer lydhendelser-audiosink"

#~ msgid "Describes the selected audiosink element."
#~ msgstr "beskriver standard audiosinkelement."

#~ msgid "default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr "Standard GStreamer-audiosink for Lyd/Video-konferanser"

#~ msgid ""
#~ "description for default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr "beskrivelse for standard GStreamer-audiosink for musikk og filmer"

#~ msgid "default GStreamer audiosink for Music and Movies"
#~ msgstr "standard GStreamer-audiosink for musikk og filmer"

#~ msgid "description for default GStreamer audiosink for Music and Movies"
#~ msgstr "beskrivelse for standard GStreamer-audiosink for musikk og filmer"

#~ msgid "default GStreamer videosink"
#~ msgstr "standard GStreamer-videosink"

#~ 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 spille video ved hjelp av en rekke utgangselementer. Noen "
#~ "mulige valg er xvimagesink, ximagesink, sdlvideosink og aasink. "
#~ "Videosinken kan være en delvis kommandokø i stedet for bare ett element."

#~ msgid "description for default GStreamer videosink"
#~ msgstr "beskrivelse for standard GStreamer-videosink"

#~ msgid "Describes the selected videosink element."
#~ msgstr "Beskriver det valgte videosink-element."

#~ msgid "default GStreamer audiosrc"
#~ msgstr "standard GStreamer-audiosrc"

#~ 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 ta opp lyd ved hjelp av en rekke dataobjekter. Noen mulige "
#~ "valg er osssrc, pulsesrc og alsasrc. Lydkilden kan være en delvis "
#~ "kommandokø i stedet for bare ett element."

#~ msgid "description for default GStreamer audiosrc"
#~ msgstr "beskrivelse for standard GStreamer-audiosrc"

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

#~ msgid "default GStreamer videosrc"
#~ msgstr "standard GStreamer-videosrc"

#~ 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 ta opp video fra en rekke dataobjekter. Noen mulige valg er "
#~ "v4lsrc, v4l2src og videotestsrc. Videokilden kan være en delvis "
#~ "kommandokø i stedet for bare ett element."

#~ msgid "description for default GStreamer videosrc"
#~ msgstr "beskrivelse for standard GStreamer-videosrc"

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

#~ 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 sette visualiseringsplugins i en rørledning til å forvandle "
#~ "lydstrømmer i videobilder. Noen mulige valg er goom, goom2k1 og "
#~ "synaesthesia. Visualiseringsplugin kan være en delvis kommandokø i stedet "
#~ "for bare ett element."

#~ msgid "description for default GStreamer visualization"
#~ msgstr "beskrivelse for standard GStreamer-visualisering"

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

#~ msgid "Couldn't get the Manifest's URI"
#~ msgstr "Kunne ikke hente Manifest-nettadressen."

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