# translation of sk.po to Slovak
# Slovak translation of gstreamer.
# Copyright (C) 2004, 2005 gstreamer's COPYRIGHT HOLDER
# This file is put in the public domain.
#
# Peter Tuhársky <tuharsky@misbb.sk>, 2007, 2008, 2009, 2010.
msgid ""
msgstr ""
"Project-Id-Version: gstreamer 0.10.30.3\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2012-09-14 00:33+0100\n"
"PO-Revision-Date: 2010-11-08 16:13+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%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
"X-Generator: KBabel 1.11.4\n"
"X-Poedit-Language: Slovak\n"
"X-Poedit-Country: SLOVAKIA\n"

msgid "Print the GStreamer version"
msgstr "Vypísať verziu GStreamer"

msgid "Make all warnings fatal"
msgstr "Chápať všetky varovania ako závažné"

msgid "Print available debug categories and exit"
msgstr "Vypísať dostupné ladiace kategórie a skončiť"

msgid ""
"Default debug level from 1 (only error) to 5 (anything) or 0 for no output"
msgstr ""
"Predvolená úroveň ladenia od 1 (len chyby) po 5 (všetko) alebo 0 (bez "
"výstupu)"

msgid "LEVEL"
msgstr "ÚROVEŇ"

msgid ""
"Comma-separated list of category_name:level pairs to set specific levels for "
"the individual categories. Example: GST_AUTOPLUG:5,GST_ELEMENT_*:3"
msgstr ""
"Čiarkami oddelený zoznam dvojíc názov_kategórie:úroveň pre nastavenie "
"špecifických úrovní pre jednotlivé kategórie. Príklad: GST_AUTOPLUG:5,"
"GST_ELEMENT_*:3"

msgid "LIST"
msgstr "ZOZNAM"

msgid "Disable colored debugging output"
msgstr "Zakázať farebný ladiaci výstup"

msgid "Disable debugging"
msgstr "Zakázať ladenie"

msgid "Enable verbose plugin loading diagnostics"
msgstr "Povoliť podrobnú diagnostiku načítavania zásuvných modulov"

msgid "Colon-separated paths containing plugins"
msgstr "Dvojbodkou oddelené cesty, ktoré obsahujú zásuvné moduly"

msgid "PATHS"
msgstr "CESTY"

msgid ""
"Comma-separated list of plugins to preload in addition to the list stored in "
"environment variable GST_PLUGIN_PATH"
msgstr ""
"Čiarkami oddelený zoznam zásuvných modulov, ktoré sa majú prednačítať popri "
"zozname, ktorý je uložený v premennej prostredia GST_PLUGIN_PATH"

msgid "PLUGINS"
msgstr "ZÁSUVNÉ MODULY"

msgid "Disable trapping of segmentation faults during plugin loading"
msgstr "Zakázať zachytávanie chýb segmentácie počas načítania zásuvného modulu"

msgid "Disable updating the registry"
msgstr "Zakázať aktualizáciu registrov"

msgid "Disable spawning a helper process while scanning the registry"
msgstr "Zakázať vytváranie pomocných procesov počas skenovania registrov"

msgid "GStreamer Options"
msgstr "Možnosti pre GStreamer"

msgid "Show GStreamer Options"
msgstr "Zobraziť možnosti pre GStreamer"

msgid "Unknown option"
msgstr "Neznáma možnosť"

msgid "GStreamer encountered a general core library error."
msgstr "GStreamer narazil na všeobecnú chybu hlavnej knižnice."

msgid ""
"GStreamer developers were too lazy to assign an error code to this error."
msgstr ""
"Vývojári GStreamer boli príliš leniví na to, aby tejto chybe priradili kód. "
"Ohláste prosím túto chybu."

msgid "Internal GStreamer error: code not implemented."
msgstr ""
"Vnútorná chyba GStreamer: kód nebol implementovaný. Ohláste prosím túto "
"chybu."

msgid ""
"GStreamer error: state change failed and some element failed to post a "
"proper error message with the reason for the failure."
msgstr ""
"Chyba GStreamer: zlyhala zmena stavu a niektorý prvok nedokázal poslať "
"patričné hlásenie o chybe s dôvodom zlyhania."

msgid "Internal GStreamer error: pad problem."
msgstr ""
"Vnútorná chyba GStreamer: problém pri vyplňovaní. Ohláste prosím túto chybu."

msgid "Internal GStreamer error: thread problem."
msgstr ""
"Vnútorná chyba GStreamer: problém s vláknami. Ohláste prosím túto chybu."

#, fuzzy
msgid "GStreamer error: negotiation problem."
msgstr ""
"Vnútorná chyba GStreamer: problém pri vyjednávaní. Ohláste prosím túto chybu."

msgid "Internal GStreamer error: event problem."
msgstr ""
"Vnútorná chyba GStreamer: problém s udalosťami. Ohláste prosím túto chybu."

msgid "Internal GStreamer error: seek problem."
msgstr ""
"Vnútorná chyba GStreamer: problém s nastavením pozície. Ohláste prosím túto "
"chybu."

msgid "Internal GStreamer error: caps problem."
msgstr ""
"Vnútorná chyba GStreamer: problém schopností. Ohláste prosím túto chybu."

msgid "Internal GStreamer error: tag problem."
msgstr ""
"Vnútorná chyba GStreamer: problém so značkami. Ohláste prosím túto chybu."

msgid "Your GStreamer installation is missing a plug-in."
msgstr "Vašej inštalácii GStreamer chýba zásuvný modul."

#, fuzzy
msgid "GStreamer error: clock problem."
msgstr ""
"Vnútorná chyba GStreamer: problém s časovaním. Ohláste prosím túto chybu."

msgid ""
"This application is trying to use GStreamer functionality that has been "
"disabled."
msgstr ""
"Táto aplikácia sa pokúša použiť takú funkcionalitu GStreamer, ktorá je "
"vypnutá."

msgid "GStreamer encountered a general supporting library error."
msgstr "GStreamer narazil na všeobecnú chybu podpornej knižnice."

msgid "Could not initialize supporting library."
msgstr "Nepodarilo sa inicializovať podpornú knižnicu."

msgid "Could not close supporting library."
msgstr "Nepodarilo sa zatvoriť podpornú knižnicu."

msgid "Could not configure supporting library."
msgstr "Nepodarilo sa nastaviť podpornú knižnicu."

msgid "Encoding error."
msgstr "Chyba pri kódovaní."

msgid "GStreamer encountered a general resource error."
msgstr "GStreamer narazil na všeobecnú chybu zdrojov."

msgid "Resource not found."
msgstr "Zdroj sa nenašiel."

msgid "Resource busy or not available."
msgstr "Zdroj sa používa alebo nie je k dispozícii."

msgid "Could not open resource for reading."
msgstr "Nepodarilo sa otvoriť zdroj na čítanie."

msgid "Could not open resource for writing."
msgstr "Nepodarilo sa otvoriť zdroj na zápis."

msgid "Could not open resource for reading and writing."
msgstr "Nepodarilo sa otvoriť zdroj na čítanie a zápis."

msgid "Could not close resource."
msgstr "Nepodarilo sa zatvoriť zdroj."

msgid "Could not read from resource."
msgstr "Nepodarilo sa čítať zo zdroja."

msgid "Could not write to resource."
msgstr "Nepodarilo sa zapisovať na zdroj."

msgid "Could not perform seek on resource."
msgstr "Nepodarilo sa nastaviť pozíciu na zdroji."

msgid "Could not synchronize on resource."
msgstr "Nepodarilo sa synchronizovať so zdrojom."

msgid "Could not get/set settings from/on resource."
msgstr "Nepodarilo sa získať/upraviť nastavenia zdroja."

msgid "No space left on the resource."
msgstr "Na zdroji už nezostalo miesto."

msgid "GStreamer encountered a general stream error."
msgstr "GStreamer narazil na všeobecnú chybu prúdu údajov."

msgid "Element doesn't implement handling of this stream. Please file a bug."
msgstr ""
"Prvok neimplementuje obsluhu tohoto prúdu údajov. Ohláste prosím tuto chybu."

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

msgid "The stream is of a different type than handled by this element."
msgstr ""
"Tento prúd údajov je odlišného typu, než je schopný obslúžiť tento prvok."

msgid "There is no codec present that can handle the stream's type."
msgstr ""
"Nie je k dispozícii žiadny kodek, ktorý by dokázal obslúžiť tento typ prúdu "
"údajov."

msgid "Could not decode stream."
msgstr "Nepodarilo sa dekódovať prúd údajov."

msgid "Could not encode stream."
msgstr "Nepodarilo sa zakódovať prúd údajov."

msgid "Could not demultiplex stream."
msgstr "Nepodarilo sa demultiplexovať prúd údajov."

msgid "Could not multiplex stream."
msgstr "Nepodarilo sa multiplexovať prúd údajov."

msgid "The stream is in the wrong format."
msgstr "Tento prúd údajov je v nesprávnom formáte."

msgid "The stream is encrypted and decryption is not supported."
msgstr "Tento prúd údajov je šifrovaný a dešifrovanie nie je podporované"

msgid ""
"The stream is encrypted and can't be decrypted because no suitable key has "
"been supplied."
msgstr ""
"Tento prúd údajov je šifrovaný a nedá sa dešifrovať, pretože nie je k "
"dispozícii vhodný kľúč."

#, c-format
msgid "No error message for domain %s."
msgstr "Žiadna chybová správa pre doménu %s."

#, c-format
msgid "No standard error message for domain %s and code %d."
msgstr "Žiadna štandardná chybová správa pre doménu %s a kód %d."

msgid "Selected clock cannot be used in pipeline."
msgstr "Vybraný časovač sa nedá použiť v rúre."

msgid "title"
msgstr "názov"

msgid "commonly used title"
msgstr "často používaný názov"

msgid "title sortname"
msgstr "názov/triedenie"

msgid "commonly used title for sorting purposes"
msgstr "často používaný názov, na účely triedenia"

msgid "artist"
msgstr "umelec"

msgid "person(s) responsible for the recording"
msgstr "osoby zodpovedné za nahrávku"

msgid "artist sortname"
msgstr "umelec/triedenie"

msgid "person(s) responsible for the recording for sorting purposes"
msgstr "osoby zodpovedné za nahrávku, na účely triedenia"

msgid "album"
msgstr "album"

msgid "album containing this data"
msgstr "album obsahujúci tieto údaje"

msgid "album sortname"
msgstr "album/triedenie"

msgid "album containing this data for sorting purposes"
msgstr "album obsahujúci tieto údaje, na účely triedenia"

msgid "album artist"
msgstr "umelec albumu"

msgid "The artist of the entire album, as it should be displayed"
msgstr "Umelec celého albumu, ako sa má zobraziť"

msgid "album artist sortname"
msgstr "meno umelca albumu pre triedenie"

msgid "The artist of the entire album, as it should be sorted"
msgstr "Umelec celého albumu, ako sa má zoradiť"

msgid "date"
msgstr "dátum"

msgid "date the data was created (as a GDate structure)"
msgstr "dátum, kedy boli tieto údaje vytvorené (ako štruktúra GDate)"

msgid "datetime"
msgstr "dátum a čas"

msgid "date and time the data was created (as a GstDateTime structure)"
msgstr ""
"dátum a čas, kedy boli tieto údaje vytvorené (ako štruktúra GstDateTime)"

msgid "genre"
msgstr "žáner"

msgid "genre this data belongs to"
msgstr "žáner, do ktorého patria tieto údaje"

msgid "comment"
msgstr "poznámka"

msgid "free text commenting the data"
msgstr "voľný text komentujúci údaje"

msgid "extended comment"
msgstr "rozšírená poznámka"

msgid "free text commenting the data in key=value or key[en]=comment form"
msgstr ""
"vyčistiť text poznámky ku údajom vo formáte key=value alebo key[en]=comment "

msgid "track number"
msgstr "číslo stopy"

msgid "track number inside a collection"
msgstr "číslo stopy v rámci zbierky"

msgid "track count"
msgstr "počet stôp"

msgid "count of tracks inside collection this track belongs to"
msgstr "počet stôp v zbierke, do ktorej patrí táto stopa"

msgid "disc number"
msgstr "číslo disku"

msgid "disc number inside a collection"
msgstr "číslo disku v rámci zbierky"

msgid "disc count"
msgstr "počet diskov"

msgid "count of discs inside collection this disc belongs to"
msgstr "počet diskov v rámci zbierky, do ktorej tento disk patrí"

msgid "location"
msgstr "umiestnenie"

msgid ""
"Origin of media as a URI (location, where the original of the file or stream "
"is hosted)"
msgstr ""
"Zdroj média, ako napríklad URI (miesto, kde je uložený originál tohto súboru "
"alebo prúdu údajov)"

msgid "homepage"
msgstr "domovská stránka"

msgid "Homepage for this media (i.e. artist or movie homepage)"
msgstr "Domovská stránka tohto média (napr. umelca, alebo filmu)"

msgid "description"
msgstr "popis"

msgid "short text describing the content of the data"
msgstr "krátky text popisujúci obsah údajov"

msgid "version"
msgstr "verzia"

msgid "version of this data"
msgstr "verzia týchto údajov"

msgid "ISRC"
msgstr "ISRC"

msgid "International Standard Recording Code - see http://www.ifpi.org/isrc/"
msgstr "International Standard Recording Code - viz http://www.ifpi.org/isrc/"

msgid "organization"
msgstr "organizácia"

msgid "copyright"
msgstr "copyright"

msgid "copyright notice of the data"
msgstr "poznámka o autorských právach k údajom"

msgid "copyright uri"
msgstr "uri pre copyright"

msgid "URI to the copyright notice of the data"
msgstr "URI pre poznámku o autorských právach údajov"

#, fuzzy
msgid "encoded by"
msgstr "kodér"

msgid "name of the encoding person or organization"
msgstr ""

msgid "contact"
msgstr "kontakt"

msgid "contact information"
msgstr "kontaktné informácie"

msgid "license"
msgstr "licencia"

msgid "license of data"
msgstr "licencia údajov"

msgid "license uri"
msgstr "URI licencie"

msgid "URI to the license of the data"
msgstr "URI ku licencii týchto údajov"

msgid "performer"
msgstr "výkonný umelec"

msgid "person(s) performing"
msgstr "vystupujúce osoby "

msgid "composer"
msgstr "skladateľ"

msgid "person(s) who composed the recording"
msgstr "osoby zodpovedné za skladbu nahrávky"

msgid "duration"
msgstr "trvanie"

msgid "length in GStreamer time units (nanoseconds)"
msgstr "dĺžka v jednotkách času GStreamer (nanosekundách)"

msgid "codec"
msgstr "kodek"

msgid "codec the data is stored in"
msgstr "kodek, v ktorom sú údaje uložené"

msgid "video codec"
msgstr "video kodek"

msgid "codec the video data is stored in"
msgstr "kodek, v ktorom sú video údaje uložené"

msgid "audio codec"
msgstr "zvukový kodek"

msgid "codec the audio data is stored in"
msgstr "kodek, v ktorom sú zvukové údaje uložené"

msgid "subtitle codec"
msgstr "kodek pre titulky"

msgid "codec the subtitle data is stored in"
msgstr "kodek pre titulky sa nachádza v"

msgid "container format"
msgstr "formát kontajneru"

msgid "container format the data is stored in"
msgstr "formát kontajneru, v ktorom sú uložené dáta"

msgid "bitrate"
msgstr "Bitová rýchlosť"

msgid "exact or average bitrate in bits/s"
msgstr "presná alebo priemerná bitová rýchlosť v bitoch/s"

msgid "nominal bitrate"
msgstr "nominálna bitová rýchlosť"

msgid "nominal bitrate in bits/s"
msgstr "nominálna bitová rýchlosť v bitoch/s"

msgid "minimum bitrate"
msgstr "minimálna bitová rýchlosť"

msgid "minimum bitrate in bits/s"
msgstr "minimálna bitová rýchlosť v bitoch/s"

msgid "maximum bitrate"
msgstr "maximálna bitová rýchlosť"

msgid "maximum bitrate in bits/s"
msgstr "maximálna bitová rýchlosť v bitoch/s"

msgid "encoder"
msgstr "kodér"

msgid "encoder used to encode this stream"
msgstr "kodér používaný pre kódovanie tohoto prúdu údajov"

msgid "encoder version"
msgstr "verzia kodéru"

msgid "version of the encoder used to encode this stream"
msgstr "verzia kodéru používaného pre kódovanie tohto prúdu"

msgid "serial"
msgstr "sériové"

msgid "serial number of track"
msgstr "sériové číslo stopy"

msgid "replaygain track gain"
msgstr "prehrávací zisk stopy"

msgid "track gain in db"
msgstr "zisk stopy v db"

msgid "replaygain track peak"
msgstr "špička prehrávacieho zisku stopy"

msgid "peak of the track"
msgstr "špička stopy"

msgid "replaygain album gain"
msgstr "prehrávací zisk albumu"

msgid "album gain in db"
msgstr "zisk albumu v db"

msgid "replaygain album peak"
msgstr "špička prehrávacieho zisku albumu"

msgid "peak of the album"
msgstr "špička albumu"

msgid "replaygain reference level"
msgstr "referenčná úroveň prehrávacieho zisku stopy"

msgid "reference level of track and album gain values"
msgstr "Referenčná úroveň zisku pre stopu a pre album"

msgid "language code"
msgstr "jazykový kód"

#, fuzzy
msgid "language code for this stream, conforming to ISO-639-1 or ISO-639-2"
msgstr "jazykový kód pre tento prúd údajov, v súlade s ISO-639-1"

#, fuzzy
msgid "language name"
msgstr "jazykový kód"

msgid "freeform name of the language this stream is in"
msgstr ""

msgid "image"
msgstr "obrázok"

msgid "image related to this stream"
msgstr "obrázok zodpovedajúci k tomuto prúdu údajov"

#. TRANSLATORS: 'preview image' = image that shows a preview of the full image
msgid "preview image"
msgstr "ukážka obrázku"

msgid "preview image related to this stream"
msgstr "ukážka obrázku zodpovedajúca tomuto prúdu údajov"

msgid "attachment"
msgstr "príloha"

msgid "file attached to this stream"
msgstr "súbor pripojený ku tomuto prúdu údajov"

msgid "beats per minute"
msgstr "úderov za minútu"

msgid "number of beats per minute in audio"
msgstr "počet úderov za minútu, vo zvuku"

msgid "keywords"
msgstr "kľúčové slová"

msgid "comma separated keywords describing the content"
msgstr "kľúčové slová, opisujúce obsah, oddelené čiarkou"

msgid "geo location name"
msgstr "geografická poloha"

msgid ""
"human readable descriptive location of where the media has been recorded or "
"produced"
msgstr ""
"opis miesta, v ľudskej reči, kde boli tieto médiá nahraté alebo produkované"

msgid "geo location latitude"
msgstr "zemepisná šírka"

msgid ""
"geo latitude location of where the media has been recorded or produced in "
"degrees according to WGS84 (zero at the equator, negative values for "
"southern latitudes)"
msgstr ""
"zemepisná šírka miesta, kde boli tieto médiá nahraté alebo produkované, v "
"stupňoch podľa WGS84 (0 pre rovník, záporné hodnoty pre južné šírky)"

msgid "geo location longitude"
msgstr "zemepisná dĺžka"

msgid ""
"geo longitude location of where the media has been recorded or produced in "
"degrees according to WGS84 (zero at the prime meridian in Greenwich/UK,  "
"negative values for western longitudes)"
msgstr ""
"zemepisná dĺžka miesta, kde boli tieto médiá nahraté alebo produkované, v "
"stupňoch podľa WGS84 (0 pre nultý poludník v Greenwich/UK, záporné hodnoty "
"pre západné dĺžky)"

msgid "geo location elevation"
msgstr "zemepisná nadmorská výška"

msgid ""
"geo elevation of where the media has been recorded or produced in meters "
"according to WGS84 (zero is average sea level)"
msgstr ""
"zemepisná nadmorská výška  miesta, kde boli tieto médiá nahraté alebo "
"produkované, v metroch podľa WGS84 (0 je priemerná hladina mora)"

msgid "geo location country"
msgstr "zemepisná poloha krajina"

msgid "country (english name) where the media has been recorded or produced"
msgstr "krajina (v angličtine), kde bolo toto médium nahraté alebo produkované"

msgid "geo location city"
msgstr "zemepisná poloha mesto"

msgid "city (english name) where the media has been recorded or produced"
msgstr "mesto (v angličtine), kde bolo toto médium nahraté alebo produkované"

msgid "geo location sublocation"
msgstr "zemepisná poloha upresnenie"

msgid ""
"a location whithin a city where the media has been produced or created (e.g. "
"the neighborhood)"
msgstr ""
"umiestnenie v rámci mesta, kde bolo toto médium vyprodukované alebo "
"vytvorené (napr. v susedstve)"

msgid "geo location horizontal error"
msgstr "geografická poloha vodorovná odchýlka"

msgid "expected error of the horizontal positioning measures (in meters)"
msgstr "očakávaná odchýlka vodorovného umiestnenia (v metroch)"

msgid "geo location movement speed"
msgstr "zemepisná poloha rýchlosť pohybu"

msgid ""
"movement speed of the capturing device while performing the capture in m/s"
msgstr "rýchlosť pohybu zachytávajúceho zariadenia počas zachytávania v m/s"

msgid "geo location movement direction"
msgstr "zemepisná poloha smer pohybu"

msgid ""
"indicates the movement direction of the device performing the capture of a "
"media. It is represented as degrees in floating point representation, 0 "
"means the geographic north, and increases clockwise"
msgstr ""
"ukazuje smer pohybu zariadenia, ktoré vykonávalo zachytávanie média. Je "
"reprezentovaný ako stupne v neceločíselnej reprezentácii, 0 znamená "
"geografický sever, a zvyšuje sa v smere hodinových ručičiek"

msgid "geo location capture direction"
msgstr "zemepisná poloha smer zachytávania"

msgid ""
"indicates the direction the device is pointing to when capturing  a media. "
"It is represented as degrees in floating point  representation, 0 means the "
"geographic north, and increases clockwise"
msgstr ""
"ukazuje smer, kam zariadenie smerovalo počas zachytávania média. Je "
"reprezentovaný ako stupne v neceločíselnej reprezentácii, 0 znamená "
"geografický sever, a zvyšuje sa v smere hodinových ručičiek"

#. TRANSLATORS: 'show name' = 'TV/radio/podcast show name' here
msgid "show name"
msgstr "názov šou"

msgid "Name of the tv/podcast/series show the media is from"
msgstr "Názov tv/podcast/seriálovej šou z ktorého pochádza toto médium"

#. TRANSLATORS: 'show sortname' = 'TV/radio/podcast show name as used for sorting purposes' here
msgid "show sortname"
msgstr "názov šou pre triedenie"

msgid ""
"Name of the tv/podcast/series show the media is from, for sorting purposes"
msgstr ""
"Názov tv/podcast/seriálovej šou z ktorého pochádza toto médium, pre účely "
"triedenia"

msgid "episode number"
msgstr "číslo epizódy"

msgid "The episode number in the season the media is part of"
msgstr "Číslo epizódy v tomto období, ktorého súčasťou je toto médium"

msgid "season number"
msgstr "číslo obdobia"

msgid "The season number of the show the media is part of"
msgstr "Číslo obdobia tejto šou, ktorej súčasťou je toto médium"

msgid "lyrics"
msgstr "text"

msgid "The lyrics of the media, commonly used for songs"
msgstr "Text tohto média, zvyčajne sa používa pri piesňach"

msgid "composer sortname"
msgstr "meno skladateľa pre triedenie"

msgid "person(s) who composed the recording, for sorting purposes"
msgstr "osoby zodpovedné za nahrávku, na účely triedenia"

msgid "grouping"
msgstr "zoskupovanie"

msgid ""
"Groups related media that spans multiple tracks, like the different pieces "
"of a concerto. It is a higher level than a track, but lower than an album"
msgstr ""
"Zoskupí súvisiace médiá, ktoré zaberajú viacero stôp, ako napríklad rôzne "
"časti koncertu. Toto je vyššia úroveň než stopa, ale nižšia než album."

msgid "user rating"
msgstr "hodnotenie používateľa"

msgid ""
"Rating attributed by a user. The higher the rank, the more the user likes "
"this media"
msgstr ""
"Hodnotenie podľa používateľa. Čím vyššie, tým viac sa toto médium páči."

msgid "device manufacturer"
msgstr "výrobca zariadenia"

msgid "Manufacturer of the device used to create this media"
msgstr "Výrobca zariadenia použitého na vytvorenie tohto média"

msgid "device model"
msgstr "model zariadenia"

msgid "Model of the device used to create this media"
msgstr "Model zariadenia použitého na vytvorenie tohto média"

msgid "application name"
msgstr "názov aplikácie"

msgid "Application used to create the media"
msgstr "Aplikácia použitá pri tvorbe tohto média"

msgid "application data"
msgstr "dáta aplikácie"

msgid "Arbitrary application data to be serialized into the media"
msgstr "Ľubovoľné údaje aplikácie, ktoré sa majú serializovať do média"

msgid "image orientation"
msgstr "orientácia obrázku"

msgid "How the image should be rotated or flipped before display"
msgstr "Ako má byť obrázok otočený alebo prevrátený pred jeho zobrazením"

msgid ", "
msgstr ", "

#, c-format
msgid "ERROR: from element %s: %s\n"
msgstr "CHYBA: od prvku %s: %s\n"

#, c-format
msgid ""
"Additional debug info:\n"
"%s\n"
msgstr ""
"Prídavné ladiace informácie:\n"
"%s\n"

#, c-format
msgid "specified empty bin \"%s\", not allowed"
msgstr "bol zadaný prázdny zásobník \"%s\", čo nie je dovolené"

#, c-format
msgid "no bin \"%s\", skipping"
msgstr "neexistuje zásobník \"%s\", preskakujem"

#, c-format
msgid "no property \"%s\" in element \"%s\""
msgstr "neexistuje vlastnosť \"%s\" v prvku \"%s\""

#, c-format
msgid "could not set property \"%s\" in element \"%s\" to \"%s\""
msgstr "nepodarilo sa nastaviť vlastnosť \"%s\" v prvku \"%s\" na \"%s\""

#, c-format
msgid "could not link %s to %s"
msgstr "nepodarilo sa pripojiť %s ku %s"

#, c-format
msgid "no element \"%s\""
msgstr "prvok \"%s\" neexistuje"

#, c-format
msgid "could not parse caps \"%s\""
msgstr "nepodarilo sa analyzovať schopnosti \"%s\""

msgid "link without source element"
msgstr "pripojenie bez zdrojového prvku"

msgid "link without sink element"
msgstr "odkaz bez prvku sink"

#, c-format
msgid "no source element for URI \"%s\""
msgstr "neexistuje zdrojový prvok pre URI \"%s\""

#, c-format
msgid "no element to link URI \"%s\" to"
msgstr "neexistuje prvok, ku ktorému sa má pripojiť URI \"%s\""

#, c-format
msgid "no sink element for URI \"%s\""
msgstr "neexistuje prvok sink pre URI \"%s\""

#, c-format
msgid "could not link sink element for URI \"%s\""
msgstr "nepodarilo sa pripojiť prvok sink pre URI \"%s\""

msgid "empty pipeline not allowed"
msgstr "prázdna rúra sa nepripúšťa"

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

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

msgid "A lot of buffers are being dropped."
msgstr "Veľa vyrovnávacej pamäte sa zahadzuje."

msgid "Internal data flow problem."
msgstr "Vnútorný problém v toku údajov."

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

msgid "Filter caps"
msgstr "Filtrovať schopnosti"

msgid ""
"Restrict the possible allowed capabilities (NULL means ANY). Setting this "
"property takes a reference to the supplied GstCaps object."
msgstr ""
"Obmedziť možné povolené schopnosti (NULL znamená ĽUBOVOĽNÉ). Nastavenie "
"tejto vlastnosti berie referenciu na zadaný objekt GstCaps."

msgid "No file name specified for writing."
msgstr "Nebol určený názov 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."

#, c-format
msgid "Error closing file \"%s\"."
msgstr "Chyba pri zatváraní súboru \"%s\"."

#, c-format
msgid "Error while seeking in file \"%s\"."
msgstr "Chyba pri nastavovaní pozície v súbore \"%s\"."

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

msgid "No file name specified for reading."
msgstr "Nebol určený názov súboru pre čítanie."

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

#, c-format
msgid "Could not get info on \"%s\"."
msgstr "Nepodarilo sa získať informácie o \"%s\"."

#, c-format
msgid "\"%s\" is a directory."
msgstr "\"%s\" je adresár."

#, c-format
msgid "File \"%s\" is a socket."
msgstr "Súbor \"%s\" je zásuvka."

msgid "Failed after iterations as requested."
msgstr "Zlyhanie po vykonaní požadovaných iterácií."

msgid "No Temp directory specified."
msgstr "Nebol určený dočasný priečinok (Temp)."

#, c-format
msgid "Could not create temp file \"%s\"."
msgstr "Nepodarilo sa získať informácie o \"%s\"."

msgid "Error while writing to download file."
msgstr "Chyba pri zápise do sťahovaného súboru."

msgid "caps"
msgstr "schopnosti"

msgid "detected capabilities in stream"
msgstr "zistené schopnosti v prúde údajov"

msgid "minimum"
msgstr "minimum"

msgid "force caps"
msgstr "vynútiť veľké písmená"

msgid "force caps without doing a typefind"
msgstr "vynútiť veľké písmená bez kontroly"

msgid "Stream contains no data."
msgstr "Prúd neobsahuje údaje."

msgid "Implemented Interfaces:\n"
msgstr "Implementované rozhrania:\n"

msgid "readable"
msgstr "čitateľné"

msgid "writable"
msgstr "zapisovateľné"

msgid "controllable"
msgstr "ovládateľné"

msgid "changeable in NULL, READY, PAUSED or PLAYING state"
msgstr ""

msgid "changeable only in NULL, READY or PAUSED state"
msgstr ""

msgid "changeable only in NULL or READY state"
msgstr ""

msgid "Blacklisted files:"
msgstr "Zakázané súbory:"

msgid "Total count: "
msgstr "Celkový počet:"

#, c-format
msgid "%d blacklisted file"
msgid_plural "%d blacklisted files"
msgstr[0] "%d zakázaný súbor"
msgstr[1] "%d zakázané súbory"
msgstr[2] "%d zakázaných súborov"

#, c-format
msgid "%d plugin"
msgid_plural "%d plugins"
msgstr[0] "%d zásuvný modul"
msgstr[1] "%d zásuvné moduly"
msgstr[2] "%d zásuvných modulov"

#, c-format
msgid "%d blacklist entry"
msgid_plural "%d blacklist entries"
msgstr[0] "%d zakázaná položka"
msgstr[1] "%d zakázané položky"
msgstr[2] "%d zakázaných položiek"

#, c-format
msgid "%d feature"
msgid_plural "%d features"
msgstr[0] "%d funkcia"
msgstr[1] "%d funkcie"
msgstr[2] "%d funkcií"

msgid "Print all elements"
msgstr "Vypísať všetky prvky"

msgid "Print list of blacklisted files"
msgstr "Vytlačiť zoznam zakázaných súborov"

msgid ""
"Print a machine-parsable list of features the specified plugin or all "
"plugins provide.\n"
"                                       Useful in connection with external "
"automatic plugin installation mechanisms"
msgstr ""
"Vypísať taký zoznam možností tohto zásuvného modulu, ktorý sa dá spracovať "
"automaticky.\n"
"                                       Je to užitočné v spojitosti s "
"vonkajšími automatickými mechanizmami inštalácie zásuvných modulov"

msgid "List the plugin contents"
msgstr "Vypísať zoznam zásuvných modulov"

msgid "Check if the specified element or plugin exists"
msgstr ""

msgid ""
"When checking if an element or plugin exists, also check that its version is "
"at least the version specified"
msgstr ""

msgid "Print supported URI schemes, with the elements that implement them"
msgstr ""
"Zobraziť podporované URI schémy, spolu s prvkami ktoré ich implementujú"

#, c-format
msgid "Could not load plugin file: %s\n"
msgstr "Nepodarilo sa načítať súbor zásuvného modulu: %s\n"

#, c-format
msgid "No such element or plugin '%s'\n"
msgstr "Takýto prvok alebo zásuvný modul neexistuje '%s'\n"

msgid "Index statistics"
msgstr ""

#, c-format
msgid "Got message #%u from element \"%s\" (%s): "
msgstr "Dostal som správu #%u od prvku \"%s\" (%s):"

#, c-format
msgid "Got message #%u from pad \"%s:%s\" (%s): "
msgstr "Dostal som správu #%u od padu \"%s:%s\" (%s):"

#, c-format
msgid "Got message #%u from object \"%s\" (%s): "
msgstr "Dostal som správu #%u od objektu \"%s\" (%s):"

#, c-format
msgid "Got message #%u (%s): "
msgstr "Dostal som správu #%u (%s):"

#, c-format
msgid "Got EOS from element \"%s\".\n"
msgstr "Dostal som EOS od prvku \"%s\".\n"

#, c-format
msgid "FOUND TAG      : found by element \"%s\".\n"
msgstr "NAŠLA SA ZNAČKA    : našiel ju prvok \"%s\".\n"

#, c-format
msgid "FOUND TAG      : found by pad \"%s:%s\".\n"
msgstr "NAŠLA SA ZNAČKA    : našiel ju pad \"%s:%s\".\n"

#, c-format
msgid "FOUND TAG      : found by object \"%s\".\n"
msgstr "NAŠLA SA ZNAČKA    : našiel ju objekt \"%s\".\n"

msgid "FOUND TAG\n"
msgstr "NAŠLA SA ZNAČKA\n"

#, fuzzy, c-format
msgid "FOUND TOC      : found by element \"%s\".\n"
msgstr "NAŠLA SA ZNAČKA    : našiel ju prvok \"%s\".\n"

#, fuzzy, c-format
msgid "FOUND TOC      : found by object \"%s\".\n"
msgstr "NAŠLA SA ZNAČKA    : našiel ju objekt \"%s\".\n"

#, fuzzy
msgid "FOUND TOC\n"
msgstr "NAŠLA SA ZNAČKA\n"

#, c-format
msgid ""
"INFO:\n"
"%s\n"
msgstr ""
"INFO:\n"
"%s\n"

#, c-format
msgid "WARNING: from element %s: %s\n"
msgstr "VAROVANIE: z prvku %s: %s\n"

msgid "Prerolled, waiting for buffering to finish...\n"
msgstr "Predčítané, čakám na dokončenie napĺňania vyrovnávacej pamäte...\n"

msgid "buffering..."
msgstr "Ukladám do vyrovnávacej pamäte..."

msgid "Done buffering, setting pipeline to PLAYING ...\n"
msgstr "Vyrovnávacia pamäť je naplnená, nastavujem rúru na PREHRÁVA ...\n"

msgid "Buffering, setting pipeline to PAUSED ...\n"
msgstr "Napĺňa sa vyrovnávacia pamäť, nastavujem rúru na POZASTAVENÚ ...\n"

msgid "Redistribute latency...\n"
msgstr "Predistribuovať latenciu...\n"

#, c-format
msgid "Setting state to %s as requested by %s...\n"
msgstr "Nastavujem stav na %s ako požaduje %s...\n"

msgid "Interrupt: Stopping pipeline ...\n"
msgstr "Prerušenie: Zastavujem rúru ...\n"

#, fuzzy, c-format
msgid "Missing element: %s\n"
msgstr "prvok \"%s\" neexistuje"

msgid "Output tags (also known as metadata)"
msgstr "Vypísať značky (známe tiež ako metadáta)"

msgid "Output TOC (chapters and editions)"
msgstr ""

msgid "Output status information and property notifications"
msgstr "Vypísať informácie o stave a upozornenia o vlastnostiach"

msgid "Do not print any progress information"
msgstr "Nevypisovať informácie o stave"

msgid "Output messages"
msgstr "Vypísať správy"

msgid "Do not output status information of TYPE"
msgstr "Nevypisovať informácie o stave TYPU"

msgid "TYPE1,TYPE2,..."
msgstr "TYP1,TYP2,..."

msgid "Do not install a fault handler"
msgstr "Neinštalovať obsluhu výnimiek"

msgid "Force EOS on sources before shutting the pipeline down"
msgstr "Vynútiť EOS na zdrojoch pred vypnutím rúry"

msgid "Gather and print index statistics"
msgstr ""

#, c-format
msgid "ERROR: pipeline could not be constructed: %s.\n"
msgstr "CHYBA: nepodarilo sa vytvoriť rúru: %s.\n"

msgid "ERROR: pipeline could not be constructed.\n"
msgstr "CHYBA: nepodarilo sa vytvoriť rúru.\n"

#, c-format
msgid "WARNING: erroneous pipeline: %s\n"
msgstr "VAROVANIE: chybná rúra: %s\n"

msgid "ERROR: the 'pipeline' element wasn't found.\n"
msgstr "CHYBA: prvok 'rúra' sa nenašiel.\n"

msgid "Setting pipeline to PAUSED ...\n"
msgstr "Nastavujem rúru na POZASTAVENÚ ...\n"

# On strike?
msgid "ERROR: Pipeline doesn't want to pause.\n"
msgstr "CHYBA: Rúra sa nechce pozastaviť.\n"

msgid "Pipeline is live and does not need PREROLL ...\n"
msgstr "Rúra je živá a nepotrebuje PREROLL ...\n"

msgid "Pipeline is PREROLLING ...\n"
msgstr "Rúra je v stave PREROLLING ...\n"

# On strike?
msgid "ERROR: pipeline doesn't want to preroll.\n"
msgstr "CHYBA: rúra nechce prerollovať.\n"

msgid "Pipeline is PREROLLED ...\n"
msgstr "Rúra je v stave PREROLLED ...\n"

msgid "Setting pipeline to PLAYING ...\n"
msgstr "Nastavujem rúru na PREHRÁVA ...\n"

# On strike?
msgid "ERROR: pipeline doesn't want to play.\n"
msgstr "CHYBA: Rúra nechce hrať.\n"

msgid "EOS on shutdown enabled -- Forcing EOS on the pipeline\n"
msgstr "EOS pri vypnutí je povolený -- Vynucujem EOS pre rúru\n"

#, fuzzy
msgid "EOS on shutdown enabled -- waiting for EOS after Error\n"
msgstr "EOS pri vypnutí je povolený -- Vynucujem EOS pre rúru\n"

msgid "Waiting for EOS...\n"
msgstr "Čakám na EOS...\n"

msgid "EOS received - stopping pipeline...\n"
msgstr "Prijatý EOS - zastavujem rúru ...\n"

#, fuzzy
msgid "Interrupt while waiting for EOS - stopping pipeline...\n"
msgstr "Prerušenie: Zastavujem rúru ...\n"

msgid "An error happened while waiting for EOS\n"
msgstr "Počas čakania na EOS nastala chyba\n"

msgid "Execution ended after %"
msgstr "Vykonávanie skončilo po %"

msgid "Setting pipeline to READY ...\n"
msgstr "Nastavujem rúru na PRIPRAVENÚ ...\n"

msgid "Setting pipeline to NULL ...\n"
msgstr "Nastavujem rúru na NULOVÚ ...\n"

msgid "Freeing pipeline ...\n"
msgstr "Uvoľňujem rúru ...\n"

#~ msgid "Print alloc trace (if enabled at compile time)"
#~ msgstr "Vypisovať stopu alokácie (ak je to povolené pri kompilácii)"

#~ msgid "Usage: gst-xmllaunch <file.xml> [ element.property=value ... ]\n"
#~ msgstr ""
#~ "Použitie: gst-xmllaunch <súbor.xml> [ prvk.vlastnosť=hodnota ... ]\n"

#~ msgid "ERROR: parse of xml file '%s' failed.\n"
#~ msgstr "CHYBA: zlyhala analýza xml súboru '%s'.\n"

#~ msgid "ERROR: no toplevel pipeline element in file '%s'.\n"
#~ msgstr "CHYBA: v súbore '%s' chýba prvok rúry najvyššej úrovne.\n"

#~ msgid "WARNING: only one toplevel element is supported at this time.\n"
#~ msgstr ""
#~ "VAROVANIE: v súčasnosti je podporovaný iba jeden prvok najvyššej úrovne.\n"

#~ msgid "ERROR: could not parse command line argument %d: %s.\n"
#~ msgstr ""
#~ "CHYBA: nepodarilo sa analyzovať argument príkazového riadku %d: %s.\n"

#~ msgid "WARNING: element named '%s' not found.\n"
#~ msgstr "VAROVANIE: prvok s názvom '%s' sa nenašiel.\n"

#~ msgid "Save xml representation of pipeline to FILE and exit"
#~ msgstr "Uložiť reprezentáciu rúry v xml do SÚBORU a skončiť"

#~ msgid "FILE"
#~ msgstr "SÚBOR"

#~ msgid "Do not install signal handlers for SIGUSR1 and SIGUSR2"
#~ msgstr "Neinštalovať obsluhu signálov SIGUSR1 a SIGUSR2"

#~ msgid "Error writing registry cache to %s: %s"
#~ msgstr "Chyba pri zápise vyrovnávacej pamäte registrov do %s: %s"

#~ msgid "Error re-scanning registry %s: %s"
#~ msgstr "Chyba pri opätovnom skenovaní registrov %s: %s"

#~ msgid "Error re-scanning registry %s"
#~ msgstr "Chyba pri opätovnom skenovaní registrov %s"

#~ msgid "Internal GStreamer error: state change failed."
#~ msgstr ""
#~ "Vnútorná chyba GStreamer: nepodarilo sa zmeniť stav. Ohláste prosím túto "
#~ "chybu."

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

#~ msgid "File descriptor \"%d\" is not valid."
#~ msgstr "Popisovač súboru \"%d\" nie je platný."

#~ msgid "FREEING pipeline ...\n"
#~ msgstr "UVOĽŇUJEM rúru ...\n"

#~ msgid "original location of file as a URI"
#~ msgstr "pôvodné umiestnenie súboru ako URI"
