# Slovak translations for gst-plugins-base.
# This file is put in the public domain.
#
# Peter Tuhársky <tuharsky@misbb.sk>, 2007, 2008, 2009, 2010, 2014, 2016.
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-base 1.7.90\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2017-02-23 15:14+0200\n"
"PO-Revision-Date: 2016-05-20 12:24+0100\n"
"Last-Translator: Peter Tuhársky <tuharsky@misbb.sk>\n"
"Language-Team: Slovak <sk-i18n@lists.linux.sk>\n"
"Language: 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==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;\\n;\n"
"X-Generator: Poedit 1.6.10\n"

msgid "Could not open device for playback in mono mode."
msgstr "Nepodarilo sa otvoriť zariadenie pre prehrávanie v režime mono."

msgid "Could not open device for playback in stereo mode."
msgstr "Nepodarilo sa otvoriť zariadenie pre prehrávanie v režime stereo."

#, c-format
msgid "Could not open device for playback in %d-channel mode."
msgstr ""
"Nepodarilo sa otvoriť zariadenie pre prehrávanie v %d-kanálovom režime."

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

msgid "Could not open audio device for playback."
msgstr "Nepodarilo sa otvoriť zvukové zariadenie pre prehrávanie."

msgid "Error outputting to audio device. The device has been disconnected."
msgstr "Chýba výstupu na zvukové zariadenie. Toto zariadenie bolo odpojené."

msgid "Could not open device for recording in mono mode."
msgstr "Nepodarilo sa otvoriť zariadenie pre nahrávanie v režime mono."

msgid "Could not open device for recording in stereo mode."
msgstr "Nepodarilo sa otvoriť zariadenie pre nahrávanie v režime stereo."

#, c-format
msgid "Could not open device for recording in %d-channel mode"
msgstr "Nepodarilo sa otvoriť zariadenie pre nahrávanie v %d-kanálovom režime."

msgid ""
"Could not open audio device for recording. Device is being used by another "
"application."
msgstr ""
"Nepodarilo sa otvoriť zvukové zariadenie pre nahrávanie. Zariadenie už "
"používa iná aplikácia."

msgid "Could not open audio device for recording."
msgstr "Nepodarilo sa otvoriť zvukové zariadenie pre nahrávanie."

msgid "Error recording from audio device. The device has been disconnected."
msgstr "Chýba záznamu zo zvukového zariadenia. Toto zariadenie bolo odpojené."

msgid "Could not open CD device for reading."
msgstr "Nepodarilo sa otvoriť zariadenie CD na čítanie."

msgid "Could not seek CD."
msgstr "Nepodarilo sa nastaviť pozíciu na CD."

msgid "Could not read CD."
msgstr "Nepodarilo sa čítať CD."

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr "Chýa prvok '%s' - skontrolujte svoju inštaláciu GStreamer."

msgid "Could not determine type of stream"
msgstr "Nepodarilo sa zistiť typ prúdu údajov"

msgid "This appears to be a text file"
msgstr "Tento súbor je asi textový"

msgid "Could not create \"uridecodebin\" element."
msgstr "Nepodarilo sa vytvoriť prvok \"uridecodebin\"."

#, fuzzy
msgid "Could not create \"decodebin3\" element."
msgstr "Nepodarilo sa vytvoriť prvok \"decodebin2\"."

#, fuzzy
msgid "Could not create \"urisourcebin\" element."
msgstr "Nepodarilo sa vytvoriť prvok \"uridecodebin\"."

#, c-format
msgid "Both autovideosink and %s elements are missing."
msgstr "Chýbajú prvky autovideosink aj %s."

msgid "The autovideosink element is missing."
msgstr "Chýba prvok autovideosink."

#, c-format
msgid "Configured videosink %s is not working."
msgstr "Nastavený videosink %s nefunguje."

#, c-format
msgid "Both autovideosink and %s elements are not working."
msgstr "Nefungujú prvky autovideosink a %s."

msgid "The autovideosink element is not working."
msgstr "Nefunguje prvok autovideosink."

msgid "Custom text sink element is not usable."
msgstr "Používateľský textový prvok sink nie je použiteľný."

msgid "No volume control found"
msgstr "Žiadny ovládač hlasitosti sa nenašiel"

#, c-format
msgid "Both autoaudiosink and %s elements are missing."
msgstr "Chýbajú prvky autoaudiosink aj %s."

msgid "The autoaudiosink element is missing."
msgstr "Chýba prvok autoaudiosink."

#, c-format
msgid "Configured audiosink %s is not working."
msgstr "Nastavený audiosink %s nefunguje."

#, c-format
msgid "Both autoaudiosink and %s elements are not working."
msgstr "Nefungujú prvky autoaudiosink aj %s."

msgid "The autoaudiosink element is not working."
msgstr "Nefunguje prvok autoaudiosink."

msgid "Can't play a text file without video or visualizations."
msgstr "Nemôžem prehrať textový súbor bez videa alebo vizualizácií."

#, c-format
msgid "No decoder available for type '%s'."
msgstr "Pre typ '%s' nie je k dispozícii dekodér."

msgid "No URI specified to play from."
msgstr "Nebolo špecifikované žiadne URI, z ktorého by sa dalo prehrávať."

#, c-format
msgid "Invalid URI \"%s\"."
msgstr "Chybné URI \"%s\"."

msgid "This stream type cannot be played yet."
msgstr "Tento typ prúdu údajov sa teraz nedá prehrávať."

#, c-format
msgid "No URI handler implemented for \"%s\"."
msgstr "Pre \"%s\" nie je implementovaná obsluha."

msgid "Source element is invalid."
msgstr "Zdrojový prvok je chybný."

#, c-format
msgid "Error while sending data to \"%s:%d\"."
msgstr "Chyba pri posielaní údajov do \"%s:%d\"."

msgid "Can't record audio fast enough"
msgstr "Zvuk sa nedá nahrávať dostatočne rýchlo"

msgid "This CD has no audio tracks"
msgstr "Toto CD nemá zvukové stopy"

msgid "ID3 tag"
msgstr "ID3 značka"

msgid "APE tag"
msgstr "APE značka"

msgid "ICY internet radio"
msgstr "Internetové rádio ICY"

msgid "Apple Lossless Audio (ALAC)"
msgstr "Bezstratový zvuk Apple (ALAC)"

msgid "Free Lossless Audio Codec (FLAC)"
msgstr "Slobodný bezstratový zvukový kodek (FLAC)"

msgid "Lossless True Audio (TTA)"
msgstr "Bezstratový verný zvuk (TTA)"

msgid "Windows Media Speech"
msgstr "Windows Media Reč"

msgid "CYUV Lossless"
msgstr "Bezstratové CYUV"

msgid "FFMpeg v1"
msgstr "FFMpeg v1"

msgid "Lossless MSZH"
msgstr "Bezstratové MSZH"

msgid "Run-length encoding"
msgstr "Kódovanie počas prehrávania"

msgid "Timed Text"
msgstr "Časovaný text"

msgid "Subtitle"
msgstr "Titulky"

msgid "MPL2 subtitle format"
msgstr "Formát titulkov MPL2"

msgid "DKS subtitle format"
msgstr "Formát titulkov DKS"

msgid "QTtext subtitle format"
msgstr "Formát titulkov QTtext"

msgid "Sami subtitle format"
msgstr "Formát titulkov sami"

msgid "TMPlayer subtitle format"
msgstr "Formát titulkov TMPlayer"

msgid "Kate subtitle format"
msgstr "Formát titulkov Kate"

#, fuzzy
msgid "WebVTT subtitle format"
msgstr "Formát titulkov Kate"

msgid "Uncompressed video"
msgstr "Nekomprimované video"

msgid "Uncompressed gray"
msgstr "Nekomprimovaný šedotónový obrázok"

#, c-format
msgid "Uncompressed packed YUV %s"
msgstr "Nekomprimovaný pakovaný YUV %s"

#, c-format
msgid "Uncompressed semi-planar YUV %s"
msgstr "Nekomprimovaný semi-planár YUV %s"

#, c-format
msgid "Uncompressed planar YUV %s"
msgstr "Nekomprimovaný planár YUV %s"

#, c-format
msgid "Uncompressed palettized %d-bit %s"
msgstr "Nekomprimovaný paletizovaný %d-bit %s"

#, c-format
msgid "Uncompressed %d-bit %s"
msgstr "Nekomprimovaný %d-bit %s"

#, c-format
msgid "DivX MPEG-4 Version %d"
msgstr "DivX MPEG-4 Verzie %d"

msgid "Uncompressed audio"
msgstr "Nekomprimovaný zvuk"

#, c-format
msgid "Raw %d-bit %s audio"
msgstr "Surový %d-bit %s zvuk"

msgid "Audio CD source"
msgstr "Zdroj zvukové CD"

msgid "DVD source"
msgstr "Zdroj DVD"

msgid "Real Time Streaming Protocol (RTSP) source"
msgstr "Zdroj Real Time Streaming Protocol (RTSP)"

msgid "Microsoft Media Server (MMS) protocol source"
msgstr "Zdroj protokolu Microsoft Media Server (MMS)"

#, c-format
msgid "%s protocol source"
msgstr "zdroj protokolu %s"

#, c-format
msgid "%s video RTP depayloader"
msgstr ""

#, c-format
msgid "%s audio RTP depayloader"
msgstr ""

#, c-format
msgid "%s RTP depayloader"
msgstr ""

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

#, c-format
msgid "%s decoder"
msgstr "%s dekodér"

#, c-format
msgid "%s video RTP payloader"
msgstr ""

#, c-format
msgid "%s audio RTP payloader"
msgstr ""

#, c-format
msgid "%s RTP payloader"
msgstr ""

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

#, c-format
msgid "%s encoder"
msgstr "%s enkodér"

#, c-format
msgid "GStreamer element %s"
msgstr "Prvok GStreamera %s"

msgid "Unknown source element"
msgstr "Neznámy zdrojový prvok"

msgid "Unknown sink element"
msgstr "Neznámy prvok sink"

msgid "Unknown element"
msgstr "Neznámy prvok"

msgid "Unknown decoder element"
msgstr "Neznámy prvok dekodéra"

msgid "Unknown encoder element"
msgstr "Neznámy prvok enkodéra"

msgid "Plugin or element of unknown type"
msgstr "Neznámy typ zásuvného modulu alebo prvku"

msgid "Failed to read tag: not enough data"
msgstr "Načítanie značky zlyhalo: málo údajov"

msgid "track ID"
msgstr "ID stopy"

msgid "MusicBrainz track ID"
msgstr "ID stopy MusicBrainz"

msgid "artist ID"
msgstr "ID umelca"

msgid "MusicBrainz artist ID"
msgstr "ID umelca MusicBrainz"

msgid "album ID"
msgstr "ID albumu"

msgid "MusicBrainz album ID"
msgstr "ID albumu MusicBrainz"

msgid "album artist ID"
msgstr "ID umelca albumu"

msgid "MusicBrainz album artist ID"
msgstr "ID umelca albumu MusicBrainz"

msgid "track TRM ID"
msgstr "ID TRM stopy"

msgid "MusicBrainz TRM ID"
msgstr "ID TRM MusicBrainz"

msgid "capturing shutter speed"
msgstr "rýchlosť uzávierky"

msgid "Shutter speed used when capturing an image, in seconds"
msgstr "Rýchlosť uzávierky použitá pri zachytávaní obrázku, v sekundách"

msgid "capturing focal ratio"
msgstr "pomer F"

msgid "Focal ratio (f-number) used when capturing the image"
msgstr "Pomer (číslo F) použitý pri zachytávaní obrázku"

msgid "capturing focal length"
msgstr "ohnisková vzdialenosť"

msgid "Focal length of the lens used capturing the image, in mm"
msgstr "Ohnisková vzdialenosť objektívu pri zachytávaní obrázku, v mm"

#, fuzzy
msgid "capturing 35 mm equivalent focal length"
msgstr "ohnisková vzdialenosť"

#, fuzzy
msgid ""
"35 mm equivalent focal length of the lens used capturing the image, in mm"
msgstr "Ohnisková vzdialenosť objektívu pri zachytávaní obrázku, v mm"

msgid "capturing digital zoom ratio"
msgstr "pomer digitálneho priblíženia"

msgid "Digital zoom ratio used when capturing an image"
msgstr "Pomer digitálneho priblíženia použitý pri zachytávaní obrázku"

msgid "capturing iso speed"
msgstr "rýchlosť ISO"

msgid "The ISO speed used when capturing an image"
msgstr "Rýchlosť ISO použitá pri zachytávaní obrázku"

msgid "capturing exposure program"
msgstr "program expozície"

msgid "The exposure program used when capturing an image"
msgstr "Program expozície použitý pri zachytávaní obrázku"

msgid "capturing exposure mode"
msgstr "režim expozície"

msgid "The exposure mode used when capturing an image"
msgstr "Režim expozície použitý pri zachytávaní obrázku"

msgid "capturing exposure compensation"
msgstr "kompenzácia expozície"

msgid "The exposure compensation used when capturing an image"
msgstr "Režim kompenzácie expozície použitý pri zachytávaní obrázku"

msgid "capturing scene capture type"
msgstr "scénický režim"

msgid "The scene capture mode used when capturing an image"
msgstr "Scénický režim použitý pri zachytávaní obrázku"

msgid "capturing gain adjustment"
msgstr "nastavenie zisku"

msgid "The overall gain adjustment applied on an image"
msgstr "Celkové nastavenie zisku aplikovaného na obrázok"

msgid "capturing white balance"
msgstr "vyváženie bielej"

msgid "The white balance mode set when capturing an image"
msgstr "Režim vyváženia bielej nastavený pri zachytávaní obrázku"

msgid "capturing contrast"
msgstr "kontrast"

msgid "The direction of contrast processing applied when capturing an image"
msgstr "Smerovanie spracovania kontrastu použitého pri zachytávaní obrázku"

msgid "capturing saturation"
msgstr "sýtosť"

msgid "The direction of saturation processing applied when capturing an image"
msgstr "Smerovanie spracovania sýtosti použitého pri zachytávaní obrázku"

msgid "capturing sharpness"
msgstr "ostrosť"

msgid "The direction of sharpness processing applied when capturing an image"
msgstr "Smerovanie spracovania ostrosti použitého pri zachytávaní obrázku"

msgid "capturing flash fired"
msgstr "blesk"

msgid "If the flash fired while capturing an image"
msgstr "Bol alebo nebol použitý blesk pri zachytávaní obrázku"

msgid "capturing flash mode"
msgstr "režim blesku"

msgid "The selected flash mode while capturing an image"
msgstr "Vybraný režim blesku pri zachytávaní obrázku"

msgid "capturing metering mode"
msgstr "meranie blesku"

msgid ""
"The metering mode used while determining exposure for capturing an image"
msgstr "Režim merania blesku pri zisťovaní expozície pre zachytenie obrázku"

msgid "capturing source"
msgstr "zdroj"

msgid "The source or type of device used for the capture"
msgstr "Zdroj alebo typ zariadenia použitý na zachytenie"

msgid "image horizontal ppi"
msgstr "vodorovné ppi obrázku"

msgid "Media (image/video) intended horizontal pixel density in ppi"
msgstr "Cieľová vodorovná hustota pixlov média (obrázku/videa) v ppi"

msgid "image vertical ppi"
msgstr "zvislé ppi obrázku"

msgid "Media (image/video) intended vertical pixel density in ppi"
msgstr "Cieľová zvislá hustota pixlov média (obrázku/videa) v ppi"

msgid "ID3v2 frame"
msgstr "ID3v2 rámec"

msgid "unparsed id3v2 tag frame"
msgstr "nespracovaný id3v2 značkovací rámec"

msgid "musical-key"
msgstr "hudobný-kľúč"

msgid "Initial key in which the sound starts"
msgstr "Úvodný kľúč v ktorom zvuk začína"

msgid "Print version information and exit"
msgstr "Zobraziť informáciu o verzii a skončiť"

msgid ""
"Don't exit after showing the initial device list, but wait for devices to "
"added/removed."
msgstr ""
"Neskončiť po zobrazení úvodného zoznamu zariadení, ale čakať na ich pridanie/"
"odstránenie."

#, c-format
msgid "Volume: %.0f%%"
msgstr "Hlasitosť: %.0f%%"

msgid "Buffering..."
msgstr "Napĺňam vyrovnávaciu pamäť..."

msgid "Clock lost, selecting a new one\n"
msgstr "Čas sa stratil, vyberá sa nový\n"

msgid "Reached end of play list."
msgstr "Dosiahli sme koniec prehrávacieho zoznamu."

msgid "Paused"
msgstr "Pozastavené"

#, c-format
msgid "Now playing %s\n"
msgstr "Hrá sa %s\n"

#, c-format
msgid "About to finish, preparing next title: %s"
msgstr "Pomaly končí, pripravuje sa ďalší titul: %s"

#, c-format
msgid "Playback rate: %.2f"
msgstr "Rýchlosť prehrávania: %.2f"

#, c-format
msgid "Could not change playback rate to %.2f"
msgstr "Nepodarilo sa zmeniť rýchlosť prehrávania na %.2f"

msgid "space"
msgstr "medzerník"

msgid "pause/unpause"
msgstr "pozastaviť/pustiť"

msgid "q or ESC"
msgstr "q alebo ESC"

msgid "quit"
msgstr "ukončiť"

msgid "> or n"
msgstr "> alebo n"

msgid "play next"
msgstr "prehrať ďalší"

msgid "< or b"
msgstr "< alebo b"

msgid "play previous"
msgstr "prehrať predchádzajúce"

msgid "seek forward"
msgstr "posunúť späť"

msgid "seek backward"
msgstr "posunúť vpred"

msgid "volume up"
msgstr "zhlasniť"

msgid "volume down"
msgstr "stíšiť"

msgid "increase playback rate"
msgstr "zvýšiť rýchlosť prehrávania"

msgid "decrease playback rate"
msgstr "znížiť rýchlosť prehrávania"

msgid "change playback direction"
msgstr "zmeniť smer prehrávania"

msgid "enable/disable trick modes"
msgstr "zapnúť/vypnúť trikové režimy"

msgid "change audio track"
msgstr "zmeniť zvukovú stopu"

msgid "change video track"
msgstr "zmeniť video stopu"

msgid "change subtitle track"
msgstr "zmeniť stopu s titulkami"

msgid "seek to beginning"
msgstr "preskočiť na začiatok"

msgid "show keyboard shortcuts"
msgstr "zobraziť klávesové skratky"

msgid "Interactive mode - keyboard controls:"
msgstr "Interaktívny režim - klávesové ovládanie:"

msgid "Output status information and property notifications"
msgstr "Zobraziť na výstupe informácie o stave a upozornenia o vlastníctve"

msgid "Control playback behaviour setting playbin 'flags' property"
msgstr ""

msgid "Video sink to use (default is autovideosink)"
msgstr "Ktorý videosink použiť (predvolený je autovideosink)"

msgid "Audio sink to use (default is autoaudiosink)"
msgstr "Ktorý audiosink použiť (predvolený je autoaudiosink)"

msgid "Enable gapless playback"
msgstr "Povoliť plynulé prehrávanie"

msgid "Shuffle playlist"
msgstr "Premiešať prehrávací zoznam"

msgid "Disable interactive control via the keyboard"
msgstr "Zakázať interaktívne ovládanie pomocou klávesnice"

msgid "Volume"
msgstr "Hlasitosť"

msgid "Playlist file containing input media files"
msgstr "Súbor s prehrávacím zoznamom obsahujúcim vstupné mediálne súbory"

msgid "Do not print any output (apart from errors)"
msgstr "Nevypisovať žiadny výstup (okrem chýb)"

#, c-format
msgid "Usage: %s FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ..."
msgstr "Použitie: %s FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ..."

msgid "You must provide at least one filename or URI to play."
msgstr "Ak chcete prehrávať, musíte zadať aspoň jeden názov súboru alebo URI."

msgid "Press 'k' to see a list of keyboard shortcuts.\n"
msgstr "Stlačením 'k' zobrazíte zoznam klávesových skratiek.\n"

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

#~ msgid "A %s plugin is required to play this stream, but not installed."
#~ msgstr ""
#~ "Na prehratie tohto prúdu údajov je vyžadovaný zásuvný modul %s, ktorý nie "
#~ "je nainštalovaný."

#~ msgid "Master"
#~ msgstr "Hlavný"

#~ msgid "Bass"
#~ msgstr "Basy"

#~ msgid "Treble"
#~ msgstr "Výšky"

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

#~ msgid "Synth"
#~ msgstr "Synth"

#~ msgid "Line-in"
#~ msgstr "Line-in"

#~ msgid "CD"
#~ msgstr "CD"

#~ msgid "Microphone"
#~ msgstr "Mikrofón"

#~ msgid "PC Speaker"
#~ msgstr "Reproduktor"

#~ msgid "Playback"
#~ msgstr "Prehrávanie"

#~ msgid "Capture"
#~ msgstr "Zachytávanie"

#~ msgid "Could not open vfs file \"%s\" for writing: %s."
#~ msgstr "Nepodarilo sa otvoriť vfs súbor \"%s\" pre zápis: %s."

#~ msgid "No filename given"
#~ msgstr "Nebol zadaný názov súboru"

#~ msgid "Could not close vfs file \"%s\"."
#~ msgstr "Nepodarilo sa zatvoriť súbor \"%s\"."

#~ msgid "Error while writing to file \"%s\"."
#~ msgstr "Chyba pri zápise do súboru \"%s\"."

#~ msgid "Invalid subtitle URI \"%s\", subtitles disabled."
#~ msgstr "Chybné URI titulkov \"%s\", titulky zakázané."

#~ msgid "RTSP streams cannot be played yet."
#~ msgstr "RTSP prúdy sa teraz nedajú prehrávať."

#~ msgid ""
#~ "Only a subtitle stream was detected. Either you are loading a subtitle "
#~ "file or some other type of text file, or the media file was not "
#~ "recognized."
#~ msgstr ""
#~ "Bol zistený iba prúd titulkov. Buď načítavate titulkový súbor alebo "
#~ "nejaký iný typ textového súboru, alebo ide o neznámy typ mediálneho "
#~ "súboru."

#~ msgid ""
#~ "You do not have a decoder installed to handle this file. You might need "
#~ "to install the necessary plugins."
#~ msgstr ""
#~ "Nemáte nainštalovaný dekodér pre tento typ súboru. Zrejme bude potrebné "
#~ "nainštalovať príslušné zásuvné moduly."

#~ msgid "This is not a media file"
#~ msgstr "Toto nie je mediálny súbor"

#~ msgid "A subtitle stream was detected, but no video stream."
#~ msgstr "Bol zistený prúd titulkov, ale bez video prúdu údajov."

#~ msgid "Both autovideosink and xvimagesink elements are missing."
#~ msgstr "Chýbajú prvky autovideosink aj xvimagesink."

#~ msgid "Both autoaudiosink and alsasink elements are missing."
#~ msgstr "Chýbajú prvky autoaudiosink aj alsasink."

#~ msgid "Error while sending gdp header data to \"%s:%d\"."
#~ msgstr "Chyba pri posielaní hlavičky gdp údajov do \"%s:%d\"."

#~ msgid "Error while sending gdp payload data to \"%s:%d\"."
#~ msgstr "Chyba pri posielaní gdp záťažových údajov do \"%s:%d\"."

#~ msgid "Connection to %s:%d refused."
#~ msgstr "Spojenie s %s:%d bolo odmietnuté."

#~ msgid "Uncompressed planar YVU 4:2:0"
#~ msgstr "Nekomprimovaný planar YVU 4:2:0"

#~ msgid "Uncompressed packed YUV 4:1:0"
#~ msgstr "Nekomprimovaný pakovaný YUV 4:1:0"

#~ msgid "Uncompressed packed YVU 4:1:0"
#~ msgstr "Nekomprimovaný pakovaný YVU 4:1:0"

#~ msgid "Uncompressed packed YUV 4:1:1"
#~ msgstr "Nekomprimovaný pakovaný YUV 4:1:1"

#~ msgid "Uncompressed packed YUV 4:4:4"
#~ msgstr "Nekomprimovaný pakovaný YUV 4:4:4"

#~ msgid "Uncompressed planar YUV 4:2:2"
#~ msgstr "Nekomprimovaný planar YUV 4:2:2"

#~ msgid "Uncompressed planar YUV 4:1:1"
#~ msgstr "Nekomprimovaný planar YUV 4:1:1"

#~ msgid "Uncompressed black and white Y-plane"
#~ msgstr "Nekomprimovaný čierno-biely Y-plane"

#~ msgid "Raw PCM audio"
#~ msgstr "Surový PCM zvuk"

#~ msgid "Raw %d-bit floating-point audio"
#~ msgstr "Surový %d-bit zvuk s pohyblivou desatinnou čiarkou"

#~ msgid "Raw floating-point audio"
#~ msgstr "Surový zvuk s pohyblivou desatinnou čiarkou"

#~ msgid "No device specified."
#~ msgstr "Nebolo zadané zariadenie."

#~ msgid "Device \"%s\" does not exist."
#~ msgstr "Zariadenie \"%s\" neexistuje."

#~ msgid "Device \"%s\" is already being used."
#~ msgstr "Zariadenie \"%s\" sa už používa."

#~ msgid "Could not open device \"%s\" for reading and writing."
#~ msgstr "Nepodarilo sa otvoriť zariadenie  \"%s\" pre čítanie a zápis."

#~ msgid "Can't display both text subtitles and subpictures."
#~ msgstr "Nemôžem zobrazovať naraz textové titulky aj podobrázky."

#~ msgid "No Temp directory specified."
#~ msgstr "Nebol zadaný dočasný adresár (Temp)."

#~ msgid "Could not create temp file \"%s\"."
#~ msgstr "Nepodarilo sa vytvoriť dočasný súbor \"%s\"."

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

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

#~ msgid "Could not create \"queue2\" element."
#~ msgstr "Nepodarilo sa vytvoriť prvok \"queue2\"."

#~ msgid "Could not create \"typefind\" element."
#~ msgstr "Nepodarilo sa vytvoriť prvok \"typefind\""

#~ msgid "No file name specified."
#~ msgstr "Nebolo zadané meno súboru."

#~ msgid "artist sortname"
#~ msgstr "katalógové meno umelca"

#~ msgid "MusicBrainz artist sortname"
#~ msgstr "katalógové meno umelca pre MusicBrainz"
