# translation of sk.po to
# Czech translations of gst-plugins.
# Copyright (C) 2004 gst-plugins' COPYRIGHT HOLDER
# This file is put in the public domain.
# Peter Tuhársky <tuharsky@misbb.sk>, 2007, 2008.
#
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-bad 0.10.8.3\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2009-08-11 17:42+0100\n"
"PO-Revision-Date: 2008-11-04 09:39+0100\n"
"Last-Translator: Peter Tuhársky <tuharsky@misbb.sk>\n"
"Language-Team: Slovak <sk-i18n@lists.linux.sk>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%"
"10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
"X-Poedit-Language: Slovak\n"
"X-Poedit-Country: SLOVAKIA\n"

msgid "Could not read title information for DVD."
msgstr "Nepodarilo sa prečítať titulok DVD."

#, c-format
msgid "Failed to open DVD device '%s'."
msgstr "Nepodarilo sa otvoriť zariadenie DVD '%s'."

msgid "Failed to set PGC based seeking."
msgstr ""

msgid "Internal clock error."
msgstr "Vnútorná chyba časovača."

msgid "Internal data flow error."
msgstr "Vnútorná chyba prúdu údajov."

msgid "No file name specified for writing."
msgstr "Nebolo zadané žiadne meno súboru pre zápis."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Nepodarilo sa otvoriť súbor \"%s\" pre zápis."

msgid "Internal data stream error."
msgstr "Vnútorná chyba prúdu údajov."

#, c-format
msgid "Could not write to file \"%s\"."
msgstr "Nepodarilo sa zapísať do súboru \"%s\"."

#, c-format
msgid "Device \"%s\" does not exist."
msgstr "Zariadenie \"%s\" neexistuje."

#, c-format
msgid "Could not open frontend device \"%s\"."
msgstr "Nepodarilo sa otvoriť ovládacie zariadenie \"%s\"."

#, c-format
msgid "Could not get settings from frontend device \"%s\"."
msgstr "Nepodarilo sa získať nastavenia od zariadenia \"%s\"."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Nepodarilo sa otvoriť súbor \"%s\" na čítanie."

msgid "Could not open audio device for mixer control handling."
msgstr "Nepodarilo sa otvoriť zvukové zariadenie pre obsluhu ovládania mixéra."

msgid ""
"Could not open audio device for mixer control handling. This version of the "
"Open Sound System is not supported by this element."
msgstr ""
"Nepodarilo sa otvoriť zvukové zariadenie pre obsluhu ovládania mixéra. Táto "
"verzia Open Sound System nie je podporovaná týmto prvkom."

msgid "Volume"
msgstr ""

#, fuzzy
msgid "Master"
msgstr "Rýchla"

msgid "Front"
msgstr "Predné"

msgid "Rear"
msgstr "Zadné"

msgid "Headphones"
msgstr "Slúchadlá"

#, fuzzy
msgid "Center"
msgstr "Stredné / LFE"

msgid "LFE"
msgstr ""

#, fuzzy
msgid "Surround"
msgstr "Surround"

msgid "Side"
msgstr "Postranné"

msgid "Built-in Speaker"
msgstr ""

msgid "AUX 1 Out"
msgstr ""

msgid "AUX 2 Out"
msgstr ""

msgid "AUX Out"
msgstr ""

msgid "Bass"
msgstr ""

msgid "Treble"
msgstr ""

msgid "3D Depth"
msgstr ""

msgid "3D Center"
msgstr ""

msgid "3D Enhance"
msgstr ""

#, fuzzy
msgid "Telephone"
msgstr "Slúchadlá"

msgid "Microphone"
msgstr "Mikrofón"

msgid "Line Out"
msgstr ""

#, fuzzy
msgid "Line In"
msgstr "Linkový vstup"

msgid "Internal CD"
msgstr ""

msgid "Video In"
msgstr ""

msgid "AUX 1 In"
msgstr ""

msgid "AUX 2 In"
msgstr ""

msgid "AUX In"
msgstr ""

msgid "PCM"
msgstr "PCM"

msgid "Record Gain"
msgstr ""

msgid "Output Gain"
msgstr ""

#, fuzzy
msgid "Microphone Boost"
msgstr "Mikrofón"

msgid "Loopback"
msgstr ""

msgid "Diagnostic"
msgstr ""

msgid "Bass Boost"
msgstr ""

msgid "Playback Ports"
msgstr ""

msgid "Input"
msgstr "Vstup"

msgid "Record Source"
msgstr ""

msgid "Monitor Source"
msgstr ""

msgid "Keyboard Beep"
msgstr ""

msgid "Monitor"
msgstr ""

msgid "Simulate Stereo"
msgstr ""

msgid "Stereo"
msgstr "Stereo"

#, fuzzy
msgid "Surround Sound"
msgstr "Surround"

#, fuzzy
msgid "Microphone Gain"
msgstr "Mikrofón"

msgid "Speaker Source"
msgstr ""

#, fuzzy
msgid "Microphone Source"
msgstr "Mikrofón"

msgid "Jack"
msgstr ""

msgid "Center / LFE"
msgstr "Stredné / LFE"

#, fuzzy
msgid "Stereo Mix"
msgstr "Stereo"

msgid "Mono Mix"
msgstr ""

#, fuzzy
msgid "Input Mix"
msgstr "Vstup mix"

msgid "SPDIF In"
msgstr ""

msgid "SPDIF Out"
msgstr ""

#, fuzzy
msgid "Microphone 1"
msgstr "Mikrofón"

#, fuzzy
msgid "Microphone 2"
msgstr "Mikrofón"

msgid "Digital Out"
msgstr ""

msgid "Digital In"
msgstr ""

msgid "HDMI"
msgstr ""

msgid "Modem"
msgstr ""

msgid "Handset"
msgstr ""

msgid "Other"
msgstr ""

msgid "None"
msgstr ""

msgid "On"
msgstr "Zap"

msgid "Off"
msgstr "Vyp"

msgid "Mute"
msgstr ""

msgid "Fast"
msgstr "Rýchla"

msgid "Very Low"
msgstr ""

msgid "Low"
msgstr "Nízka"

msgid "Medium"
msgstr "Stredná"

msgid "High"
msgstr "Vysoká"

#, fuzzy
msgid "Very High"
msgstr "Veľmi vysoká"

msgid "Production"
msgstr "Produkčná"

#, fuzzy
msgid "Front Panel Microphone"
msgstr "Mikrofón predného panelu"

#, fuzzy
msgid "Front Panel Line In"
msgstr "Linkový vstup na prednom paneli"

#, fuzzy
msgid "Front Panel Headphones"
msgstr "Slúchadlá na prednom paneli"

#, fuzzy
msgid "Front Panel Line Out"
msgstr "Linkový vstup na prednom paneli"

#, fuzzy
msgid "Green Connector"
msgstr "Zelený konektor"

#, fuzzy
msgid "Pink Connector"
msgstr "Ružový konektor"

#, fuzzy
msgid "Blue Connector"
msgstr "Modrý konektor"

#, fuzzy
msgid "White Connector"
msgstr "Biely konektor"

#, fuzzy
msgid "Black Connector"
msgstr "Čierny konektor"

#, fuzzy
msgid "Gray Connector"
msgstr "Šedý konektor"

#, fuzzy
msgid "Orange Connector"
msgstr "Oranžový konektor"

#, fuzzy
msgid "Red Connector"
msgstr "Červený konektor"

#, fuzzy
msgid "Yellow Connector"
msgstr "Žltý konektor"

#, fuzzy
msgid "Green Front Panel Connector"
msgstr "Zelený konektor na prednom paneli"

#, fuzzy
msgid "Pink Front Panel Connector"
msgstr "Ružový konektor na prednom paneli"

#, fuzzy
msgid "Blue Front Panel Connector"
msgstr "Modrý konektor na prednom paneli"

#, fuzzy
msgid "White Front Panel Connector"
msgstr "Biely konektor na prednom paneli"

#, fuzzy
msgid "Black Front Panel Connector"
msgstr "Čierny konektor na prednom paneli"

#, fuzzy
msgid "Gray Front Panel Connector"
msgstr "Šedý konektor na prednom paneli"

#, fuzzy
msgid "Orange Front Panel Connector"
msgstr "Oranžový konektor na prednom paneli"

#, fuzzy
msgid "Red Front Panel Connector"
msgstr "Červený konektor na prednom paneli"

#, fuzzy
msgid "Yellow Front Panel Connector"
msgstr "Žltý konektor na prednom paneli"

msgid "Spread Output"
msgstr ""

msgid "Downmix"
msgstr ""

#, fuzzy
msgid "Virtual Mixer Input"
msgstr "Vstup virtuálneho mixéra"

#, fuzzy
msgid "Virtual Mixer Output"
msgstr "Výstup virtuálneho mixéra"

#, fuzzy
msgid "Virtual Mixer Channels"
msgstr "Vstup virtuálneho mixéra"

#, c-format
msgid "%s Function"
msgstr ""

#, c-format
msgid "%s %d"
msgstr ""

msgid ""
"Could not open audio device for playback. Device is being used by another "
"application."
msgstr ""
"Nepodarilo sa otvoriť zvukové zariadenie v režime prehrávania. Zariadenie už "
"používa iná aplikácia."

msgid ""
"Could not open audio device for playback. You don't have permission to open "
"the device."
msgstr ""
"Nepodarilo sa otvoriť zvukové zariadenie v režime prehrávania. Nemáte "
"oprávnenie na otvorenie tohto zariadenia."

msgid "Could not open audio device for playback."
msgstr "Nepodarilo sa otvoriť zvukové zariadenie v režime prehrávania."

msgid ""
"Could not open audio device for playback. This version of the Open Sound "
"System is not supported by this element."
msgstr ""
"Nepodarilo sa otvoriť zvukové zariadenie v režime prehrávania. Túto verziu "
"Open Sound System nepodporuje tento prvok."

msgid "Playback is not supported by this audio device."
msgstr "Toto zvukové zariadenie nepodporuje prehrávanie."

msgid "Audio playback error."
msgstr "Chyba prehrávania zvuku."

msgid "Recording is not supported by this audio device."
msgstr "Toto zvukové zariadenie nepodporuje záznam."

msgid "Error recording from audio device."
msgstr "Chyba pri zázname zo zvukového zariadenia."

#~ msgid "Failed to configure TwoLAME encoder. Check your encoding parameters."
#~ msgstr ""
#~ "Nepodarilo sa nakonfigurovať TwoLAME enkodér. Skontrolujte parametre "
#~ "kódovania."

#~ msgid ""
#~ "The requested bitrate %d kbit/s for property '%s' is not allowed. The "
#~ "bitrate was changed to %d kbit/s."
#~ msgstr ""
#~ "Požadovaná bitová rýchlosť %d kbit/s pre vlastnosť '%s' nie je povolená. "
#~ "Rýchlosť bola zmenená na %d kbit/s."

#~ msgid "PCM 1"
#~ msgstr "PCM 1"

#~ msgid "PCM 2"
#~ msgstr "PCM 2"

#~ msgid "PCM 3"
#~ msgstr "PCM 3"

#~ msgid "PCM 4"
#~ msgstr "PCM 4"

#~ msgid "Green connector function"
#~ msgstr "Funkcia zeleného konektora"

#~ msgid "Green front panel connector function"
#~ msgstr "Funkcia zeleného konektora na prednom paneli"

#~ msgid "Pink connector function"
#~ msgstr "Funkcia ružového konektora"

#~ msgid "Pink front panel connector function"
#~ msgstr "Funkcia ružového konektora na prednom paneli"

#~ msgid "Blue connector function"
#~ msgstr "Funkcia modrého konektora"

#~ msgid "Blue front panel connector function"
#~ msgstr "Funkcia modrého konektora na prednom paneli"

#~ msgid "Orange connector function"
#~ msgstr "Funkcia oranžového konektora"

#~ msgid "Orange front panel connector function"
#~ msgstr "Funkcia oranžového konektora na prednom paneli"

#~ msgid "Black connector function"
#~ msgstr "Funkcia čierneho konektora"

#~ msgid "Black front panel connector function"
#~ msgstr "Funkcia čierneho konektora na prednom paneli"

#~ msgid "Gray connector function"
#~ msgstr "Funkcia šedého konektora"

#~ msgid "Gray front panel connector function"
#~ msgstr "Funkcia šedého konektora na prednom paneli"

#~ msgid "White connector function"
#~ msgstr "Funkcia bieleho konektora"

#~ msgid "White front panel connector function"
#~ msgstr "Funkcia bieleho konektora na prednom paneli"

#~ msgid "Red connector function"
#~ msgstr "Funkcia červeného konektora"

#~ msgid "Red front panel connector function"
#~ msgstr "Funkcia červeného konektora na prednom paneli"

#~ msgid "Yellow connector function"
#~ msgstr "Funkcia žltého konektora"

#~ msgid "Yellow front panel connector function"
#~ msgstr "Funkcia žltého konektora na prednom paneli"

#~ msgid "Virtual mixer channel configuration"
#~ msgstr "Konfigurácia kanálov virtuálneho mixéra"
