# Hungarian translation for gst-plugins-bad.
# Copyright (C) 2007, 2008, 2009, 2012, 2014, 2015, 2017 Free Software Foundation, Inc.
# This file is distributed under the same license as the gst-plugins-bad package.
#
# Gabor Kelemen <kelemeng@gnome.hu>, 2007, 2008, 2009, 2012.
# Balázs Úr <urbalazs@gmail.com>, 2014, 2015, 2017.
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-bad 1.10.0\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2017-05-04 15:09+0300\n"
"PO-Revision-Date: 2017-03-19 00:53+0100\n"
"Last-Translator: Balázs Úr <urbalazs@gmail.com>\n"
"Language-Team: Hungarian <translation-team-hu@lists.sourceforge.net>\n"
"Language: hu\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: Lokalize 1.2\n"
"Plural-Forms:  nplurals=2; plural=(n != 1);\n"

msgid "failed to draw pattern"
msgstr "a minta rajzolása meghiúsult"

msgid "A GL error occured"
msgstr "GL hiba történt"

msgid "format wasn't negotiated before get function"
msgstr "a formátum nem lett egyeztetve a függvény lekérése előtt"

msgid "OpenCV failed to load template image"
msgstr "Az OpenCV-nek nem sikerült betöltenie a sablonképet"

msgid "Could not read title information for DVD."
msgstr "Nem lehet címinformációkat olvasni a DVD-ről."

#, c-format
msgid "Failed to open DVD device '%s'."
msgstr "Nem nyitható meg a DVD eszköz („%s”)."

msgid "Failed to set PGC based seeking."
msgstr "A PGC-alapú keresés beállítása meghiúsult."

msgid ""
"Could not read DVD. This may be because the DVD is encrypted and a DVD "
"decryption library is not installed."
msgstr ""
"Nem olvasható a DVD. Ezt az okozhatja, hogy a DVD titkosított, és a DVD-"
"visszafejtő programkönyvtár nincs telepítve."

msgid "Could not read DVD."
msgstr "Nem olvasható a DVD."

msgid "This file contains no playable streams."
msgstr "Ez a fájl nem tartalmaz lejátszható folyamokat."

msgid "Could not open sndfile stream for reading."
msgstr "A hangfájl folyam nem nyitható meg olvasásra."

msgid "Generated file has a larger preroll time than its streams duration"
msgstr ""
"Az előállított fájlnak nagyobb előtekerési ideje van, mint a folyamának "
"időtartama"

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr "Hiányzó „%s” elem - ellenőrizze a GStreamer telepítését."

msgid "File location is set to NULL, please set it to a valid filename"
msgstr ""
"A fájl helye NULL értékre lett állítva, kérjük állítsa be egy érvényes "
"fájlnévre"

msgid "Digitalzoom element couldn't be created"
msgstr "A digitális nagyítás elemet nem sikerült létrehozni"

msgid "Subpicture format was not configured before data flow"
msgstr "A részkép formátuma nem lett beállítva az adatfolyam előtt"

msgid "Failed to get fragment URL."
msgstr "Nem sikerült lekérni a töredék URL-t."

msgid "Couldn't download fragments"
msgstr "Nem sikerült letölteni a töredékeket"

msgid "Internal data stream error."
msgstr "Belső adatfolyamhiba."

#, c-format
msgid "Device \"%s\" does not exist."
msgstr "Az eszköz („%s”) nem létezik."

#, c-format
msgid "Could not open frontend device \"%s\"."
msgstr "Nem nyitható meg az előtéteszköz („%s”)."

#, c-format
msgid "Could not get settings from frontend device \"%s\"."
msgstr "Nem kérhetők le a beállítások az előtéteszköztől („%s”)."

#, c-format
msgid "Cannot enumerate delivery systems from frontend device \"%s\"."
msgstr ""
"Nem lehet felsorolni a szállító rendszereket a(z) „%s” előtéteszköztől."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "A fájl („%s”) nem nyitható meg olvasásra."

msgid "Couldn't find channel configuration file"
msgstr "Nem található csatorna beállítófájl"

#, c-format
msgid "Couldn't load channel configuration file: '%s'"
msgstr "Nem sikerült betölteni a csatorna beállítófájlt: „%s”"

#, c-format
msgid "Couldn't find details for channel '%s'"
msgstr "Nem találhatók a(z) „%s” csatorna részletei"

#, c-format
msgid "No properties for channel '%s'"
msgstr "Nincsenek tulajdonságok a(z) „%s” csatornához"

#, c-format
msgid "Failed to set properties for channel '%s'"
msgstr "Nem sikerült beállítani a(z) „%s” csatorna tulajdonságait"

#, c-format
msgid "Couldn't find channel configuration file: '%s'"
msgstr "Nem található csatorna beállítófájl: „%s”"

msgid "Channel configuration file doesn't contain any channels"
msgstr "A csatorna beállítófájl nem tartalmaz egyetlen csatornát sem"

#~ msgid "Could not establish connection to sndio"
#~ msgstr "Nem hozható létre kapcsolat az sndio programmal"

#~ msgid "Failed to query sndio capabilities"
#~ msgstr "Nem sikerült lekérdezni az sndio képességeit"

#~ msgid "Could not configure sndio"
#~ msgstr "Nem sikerült az sndio beállítása"

#~ msgid "Could not start sndio"
#~ msgstr "Nem sikerült az sndio indítása"

#~ msgid "No file name specified for writing."
#~ msgstr "Nincs megadva fájlnév az íráshoz."

#~ msgid ""
#~ "Given file name \"%s\" can't be converted to local file name encoding."
#~ msgstr ""
#~ "A kapott „%s” fájlnevet nem lehet átalakítani a helyi fájlnév kódolásra."

#~ msgid "Could not open file \"%s\" for writing."
#~ msgstr "A fájl („%s”) nem nyitható meg írásra."
