# Czech translation of gstreamer.
# Copyright (C) 2004, 2005, 2007, 2008 gstreamer's COPYRIGHT HOLDER
# Copyright (C) 2004, 2005, 2007, 2008 Miloslav Trmac <mitr@volny.cz>
# This file is put in the public domain.
# Miloslav Trmac <mitr@volny.cz>, 2004, 2005, 2007, 2008.
#
msgid ""
msgstr ""
"Project-Id-Version: gstreamer 0.10.20.3\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2011-09-29 14:55+0200\n"
"PO-Revision-Date: 2008-10-12 12:12+0200\n"
"Last-Translator: Miloslav Trmac <mitr@volny.cz>\n"
"Language-Team: Czech <translation-team-cs@lists.sourceforge.net>\n"
"Language: cs\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"

msgid "Print the GStreamer version"
msgstr "Vypsat verzi GStreamer"

msgid "Make all warnings fatal"
msgstr "Chápat všechna varování jako fatální"

msgid "Print available debug categories and exit"
msgstr "Vypsat dostupné kategorie ladění a skončit"

msgid ""
"Default debug level from 1 (only error) to 5 (anything) or 0 for no output"
msgstr ""
"Implicitní úroveň ladění od 1 (jen chyby) do 5 (vše) nebo 0 pro žádný výstup"

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 ""
"Čárkami oddělený seznam dvojic název_kategorie:úroveň pro nastavení "
"konkrétních úrovní pro jednotlivé kategorie. Příklad: GST_AUTOPLUG:5,"
"GST_ELEMENT_*:3"

msgid "LIST"
msgstr "SEZNAM"

msgid "Disable colored debugging output"
msgstr "Zakázat obarvený ladicí výstup"

msgid "Disable debugging"
msgstr "Zakázat ladění"

msgid "Enable verbose plugin loading diagnostics"
msgstr "Povolit podrobnou diagnostiku načítání modulů"

msgid "Colon-separated paths containing plugins"
msgstr "Dvojtečkou oddělené cesty obsahující 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 ""
"Čárkami oddělený seznam modulů, které přednačíst kromě seznamu uloženém v "
"proměnné prostředí GST_PLUGIN_PATH"

msgid "PLUGINS"
msgstr "MODULY"

msgid "Disable trapping of segmentation faults during plugin loading"
msgstr "Zakázat zachycování porušení segmentace při načítání modulů"

msgid "Disable updating the registry"
msgstr "Zakázat aktualizaci registru"

#, fuzzy
msgid "Disable spawning a helper process while scanning the registry"
msgstr "Zakázat používání fork() při prohledávání registru"

msgid "GStreamer Options"
msgstr "Přepínače GStreameru"

msgid "Show GStreamer Options"
msgstr "Zobrazit přepínače GStreameru"

msgid "Unknown option"
msgstr "Neznámý přepínač"

msgid "GStreamer encountered a general core library error."
msgstr "V GStreamer došlo k obecné chybě hlavní knihovny."

msgid ""
"GStreamer developers were too lazy to assign an error code to this error."
msgstr ""
"Vývojáři GStreameru byli příliš líní na to, aby této chybě přiřadili kód."

msgid "Internal GStreamer error: code not implemented."
msgstr "Interní chyba GStreameru: kód neimplementován."

msgid ""
"GStreamer error: state change failed and some element failed to post a "
"proper error message with the reason for the failure."
msgstr ""

msgid "Internal GStreamer error: pad problem."
msgstr "Interní chyba GStreameru: problém při vyplňování."

msgid "Internal GStreamer error: thread problem."
msgstr "Interní chyba GStreameru: problém s vlákny."

msgid "Internal GStreamer error: negotiation problem."
msgstr "Interní chyba GStreameru: problém při vyjednávání."

msgid "Internal GStreamer error: event problem."
msgstr "Interní chyba GStreameru: problém s událostmi."

msgid "Internal GStreamer error: seek problem."
msgstr "Interní chyba GStreameru: problém s posunem."

msgid "Internal GStreamer error: caps problem."
msgstr "Interní chyba GStreameru: problém se schopnostmi."

msgid "Internal GStreamer error: tag problem."
msgstr "Interní chyba GStreameru: problém s tagy."

msgid "Your GStreamer installation is missing a plug-in."
msgstr "Vaší instalaci GStreameru chybí modul."

msgid "Internal GStreamer error: clock problem."
msgstr "Interní chyba GStreameru: problém s hodinami."

msgid ""
"This application is trying to use GStreamer functionality that has been "
"disabled."
msgstr ""
"Tato aplikace se pokouší používat funkce GStreameru, které byly zakázány."

msgid "GStreamer encountered a general supporting library error."
msgstr "V GStreamer došlo k chybě obecné podpůrné knihovny."

msgid "Could not initialize supporting library."
msgstr "Nemohu inicializovat podpůrnou knihovnu."

msgid "Could not close supporting library."
msgstr "Nemohu zavřít podpůrou knihovnu."

msgid "Could not configure supporting library."
msgstr "Nemohu nastavit podpůrou knihovnu."

msgid "Encoding error."
msgstr ""

msgid "GStreamer encountered a general resource error."
msgstr "V GStreameru došlo k obecné chybě zdrojů."

msgid "Resource not found."
msgstr "Zdroj nenalezen."

msgid "Resource busy or not available."
msgstr "Zdroj se používá nebo není k dispozici."

msgid "Could not open resource for reading."
msgstr "Nemohu otevřít zdroj pro čtení."

msgid "Could not open resource for writing."
msgstr "Nemohu otevřít zdroj pro zápis."

msgid "Could not open resource for reading and writing."
msgstr "Nemohu otevřít zdroj pro čtení a zápis."

msgid "Could not close resource."
msgstr "Nemohu zavřít zdroj."

msgid "Could not read from resource."
msgstr "Nemohu číst ze zdroje."

msgid "Could not write to resource."
msgstr "Nemohu zapisovat do zdroje."

msgid "Could not perform seek on resource."
msgstr "Nemohu se posunovat ve zdroji."

msgid "Could not synchronize on resource."
msgstr "Nemohu se synchronizovat se zdrojem."

msgid "Could not get/set settings from/on resource."
msgstr "Nemohu získat/změnit nastavení zdroje."

msgid "No space left on the resource."
msgstr "Ve zdroji nezbývá místo."

msgid "GStreamer encountered a general stream error."
msgstr "V GStreameru došlo k obecné chybě proudu."

msgid "Element doesn't implement handling of this stream. Please file a bug."
msgstr ""
"Element neimplementuje obsluhu tohoto proudu. Ohlaste prosím tuto chybu."

msgid "Could not determine type of stream."
msgstr "Nemohu zjistit typ proudu."

msgid "The stream is of a different type than handled by this element."
msgstr "Proud je jiného typu, než který tento element obsluhuje."

msgid "There is no codec present that can handle the stream's type."
msgstr "Není přítomen žádný kodek, který umí obsloužit typ tohoto proudu."

msgid "Could not decode stream."
msgstr "Nemohu dekódovat proud."

msgid "Could not encode stream."
msgstr "Nemohu kódovat proud."

msgid "Could not demultiplex stream."
msgstr "Nemohu demultiplexovat proud."

msgid "Could not multiplex stream."
msgstr "Nemohu multiplexovat proud."

msgid "The stream is in the wrong format."
msgstr "Proud je ve špatném formátu."

msgid "The stream is encrypted and decryption is not supported."
msgstr "Proud je zašifrován a dešifrování není podporováno."

msgid ""
"The stream is encrypted and can't be decrypted because no suitable key has "
"been supplied."
msgstr ""
"Proud je zašifrován a nelze jej dešifrovát, protože nebyl dodán vhodný klíč."

#, c-format
msgid "No error message for domain %s."
msgstr "Pro doménu %s není zpráva o chybě."

#, c-format
msgid "No standard error message for domain %s and code %d."
msgstr "Pro doménu %s a kód %d není standardní zpráva o chybě."

msgid "Selected clock cannot be used in pipeline."
msgstr "Vybrané hodiny nelze použít v rouře."

msgid "title"
msgstr "název"

msgid "commonly used title"
msgstr "obecně používaný název"

msgid "title sortname"
msgstr "název pro řazení"

msgid "commonly used title for sorting purposes"
msgstr "obecně používaný název pro řazení"

msgid "artist"
msgstr "umělec"

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

msgid "artist sortname"
msgstr "umělec pro řazení"

msgid "person(s) responsible for the recording for sorting purposes"
msgstr "osoby odpovědné za nahrávku pro řazení"

msgid "album"
msgstr "album"

msgid "album containing this data"
msgstr "album obsahující tato data"

msgid "album sortname"
msgstr "album pro řazení"

msgid "album containing this data for sorting purposes"
msgstr "album obsahující tato data pro řazení"

#, fuzzy
msgid "album artist"
msgstr "umělec"

msgid "The artist of the entire album, as it should be displayed"
msgstr ""

#, fuzzy
msgid "album artist sortname"
msgstr "umělec pro řazení"

msgid "The artist of the entire album, as it should be sorted"
msgstr ""

msgid "date"
msgstr "datum"

msgid "date the data was created (as a GDate structure)"
msgstr "datum, kdy byla data vytvořena (jako struktura GDate)"

#, fuzzy
msgid "datetime"
msgstr "datum"

#, fuzzy
msgid "date and time the data was created (as a GstDateTime structure)"
msgstr "datum, kdy byla data vytvořena (jako struktura GDate)"

msgid "genre"
msgstr "žánr"

msgid "genre this data belongs to"
msgstr "žánr, do kterého tato data patří"

msgid "comment"
msgstr "poznámka"

msgid "free text commenting the data"
msgstr "volný text komentující data"

msgid "extended comment"
msgstr "rozšířená poznámka"

msgid "free text commenting the data in key=value or key[en]=comment form"
msgstr ""
"volný text komentující data ve tvaru klíč=hodnota nebo klíč[cs]=poznámka"

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

msgid "track number inside a collection"
msgstr "číslo stopy v souboru"

msgid "track count"
msgstr "počet stop"

msgid "count of tracks inside collection this track belongs to"
msgstr "počet stop v souboru, do kterého tato stopa patří"

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

msgid "disc number inside a collection"
msgstr "číslo disku v souboru"

msgid "disc count"
msgstr "počet disků"

msgid "count of discs inside collection this disc belongs to"
msgstr "počet disků v souboru, do kterého tento disk patří"

msgid "location"
msgstr "umístění"

msgid ""
"Origin of media as a URI (location, where the original of the file or stream "
"is hosted)"
msgstr ""
"Původ média jako URI (umístění, kde je nabízen originál souboru nebo proudu)"

#, fuzzy
msgid "homepage"
msgstr "obrázek"

msgid "Homepage for this media (i.e. artist or movie homepage)"
msgstr ""

msgid "description"
msgstr "popis"

msgid "short text describing the content of the data"
msgstr "krátký text popisující obsah dat"

msgid "version"
msgstr "verze"

msgid "version of this data"
msgstr "verze těchto dat"

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 "organizace"

msgid "copyright"
msgstr "copyright"

msgid "copyright notice of the data"
msgstr "oznámení o copyrightu dat"

msgid "copyright uri"
msgstr "uri copyrightu"

msgid "URI to the copyright notice of the data"
msgstr "URI oznámení o copyrightu dat"

#, 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í informace"

msgid "license"
msgstr "licence"

msgid "license of data"
msgstr "licence dat"

msgid "license uri"
msgstr "uri licence"

msgid "URI to the license of the data"
msgstr "URI licence dat"

msgid "performer"
msgstr "výkonný umělec"

msgid "person(s) performing"
msgstr "vystupující osoby "

msgid "composer"
msgstr "skladatel"

msgid "person(s) who composed the recording"
msgstr "osoby, které složily nahrávku"

msgid "duration"
msgstr "trvání"

msgid "length in GStreamer time units (nanoseconds)"
msgstr "délka v jednotkách času GStreamer (nanosekundách)"

msgid "codec"
msgstr "kodek"

msgid "codec the data is stored in"
msgstr "kodek, ve kterém jsou uložena data"

msgid "video codec"
msgstr "kodek videa"

msgid "codec the video data is stored in"
msgstr "kodek, ve kterém jsou uložena data videa"

msgid "audio codec"
msgstr "kodek zvuku"

msgid "codec the audio data is stored in"
msgstr "kodek, ve kterém jsou uložena data zvuku"

#, fuzzy
msgid "subtitle codec"
msgstr "kodek videa"

#, fuzzy
msgid "codec the subtitle data is stored in"
msgstr "kodek, ve kterém jsou uložena data videa"

#, fuzzy
msgid "container format"
msgstr "kontaktní informace"

#, fuzzy
msgid "container format the data is stored in"
msgstr "kodek, ve kterém jsou uložena data"

msgid "bitrate"
msgstr "bitrate"

msgid "exact or average bitrate in bits/s"
msgstr "přesná nebo průměrná bitrate v bitech/s"

msgid "nominal bitrate"
msgstr "nominální bitrate"

msgid "nominal bitrate in bits/s"
msgstr "nominální bitrate v bitech/s"

msgid "minimum bitrate"
msgstr "minimální bitrate"

msgid "minimum bitrate in bits/s"
msgstr "minimální bitrate v bitech/s"

msgid "maximum bitrate"
msgstr "maximální bitrate"

msgid "maximum bitrate in bits/s"
msgstr "maximální bitrate v bitech/s"

msgid "encoder"
msgstr "kodér"

msgid "encoder used to encode this stream"
msgstr "kodér používaný pro kódování tohoto proudu"

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

msgid "version of the encoder used to encode this stream"
msgstr "verze kodéru používaného pro kódování tohoto proudu"

msgid "serial"
msgstr "sériové"

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

msgid "replaygain track gain"
msgstr "replaygain zisk přehrávání stopy"

msgid "track gain in db"
msgstr "zisk přehrávání stopy v db"

msgid "replaygain track peak"
msgstr "replaygain vrchol stopy"

msgid "peak of the track"
msgstr "vrchol stopy"

msgid "replaygain album gain"
msgstr "replaygain zisk alba"

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

msgid "replaygain album peak"
msgstr "replaygain vrchol alba"

msgid "peak of the album"
msgstr "vrchol alba"

msgid "replaygain reference level"
msgstr "referenční úroveň replaygain"

msgid "reference level of track and album gain values"
msgstr "referenční úroveň hodnot zisku stopy a alba"

msgid "language code"
msgstr "kód jazyka"

msgid "language code for this stream, conforming to ISO-639-1"
msgstr "kód jazyka pro tento proud, splňující ISO-639-1"

msgid "image"
msgstr "obrázek"

msgid "image related to this stream"
msgstr "obrázek související s tímto proudem"

#. TRANSLATORS: 'preview image' = image that shows a preview of the full image
msgid "preview image"
msgstr "obrázek náhledu"

msgid "preview image related to this stream"
msgstr "obrázek náhledu související s tímto proudem"

msgid "attachment"
msgstr "příloha"

msgid "file attached to this stream"
msgstr "soubor připojený k tomuto proudu"

msgid "beats per minute"
msgstr "taktů za minutu"

msgid "number of beats per minute in audio"
msgstr "počet taktů ve zvuku za minutu"

msgid "keywords"
msgstr "klíčová slova"

msgid "comma separated keywords describing the content"
msgstr "čarkami oddělená klíčová slova popisující obsah"

msgid "geo location name"
msgstr "název místa"

#, fuzzy
msgid ""
"human readable descriptive location of where the media has been recorded or "
"produced"
msgstr ""
"popisné místo čitelné člověkem nebo kde bylo médium nahráno nebo vytvořeno"

msgid "geo location latitude"
msgstr "zeměpisná šířka místa"

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 ""
"zeměpisná šířka místa, kde bylo médium nahráno nebo vytvořeno, ve stupních "
"podle WGS84 (nula na rovníku, záporné hodnoty pro jižní polokouli)"

msgid "geo location longitude"
msgstr "zeměpisná délka místa"

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 ""
"zeměpisná délka místa, kde bylo médium nahráno nebo vytvořeno, ve stupních "
"podle WGS84 (nula na hlavním poledníku v Greenwichi, záporné hodnoty pro "
"západní polokouli)"

msgid "geo location elevation"
msgstr "zeměpisná výška místa"

msgid ""
"geo elevation of where the media has been recorded or produced in meters "
"according to WGS84 (zero is average sea level)"
msgstr ""
"zeměpisná výška místa, kde bylo médium nahráno nebo vytvořeno, v metrech "
"podle WGS84 (nula je průměrná hladina moře)"

#, fuzzy
msgid "geo location country"
msgstr "zeměpisná délka místa"

#, fuzzy
msgid "country (english name) where the media has been recorded or produced"
msgstr ""
"popisné místo čitelné člověkem nebo kde bylo médium nahráno nebo vytvořeno"

#, fuzzy
msgid "geo location city"
msgstr "zeměpisná šířka místa"

#, fuzzy
msgid "city (english name) where the media has been recorded or produced"
msgstr ""
"popisné místo čitelné člověkem nebo kde bylo médium nahráno nebo vytvořeno"

#, fuzzy
msgid "geo location sublocation"
msgstr "zeměpisná výška místa"

msgid ""
"a location whithin a city where the media has been produced or created (e.g. "
"the neighborhood)"
msgstr ""

#, fuzzy
msgid "geo location horizontal error"
msgstr "název místa"

msgid "expected error of the horizontal positioning measures (in meters)"
msgstr ""

#, fuzzy
msgid "geo location movement speed"
msgstr "zeměpisná délka místa"

msgid ""
"movement speed of the capturing device while performing the capture in m/s"
msgstr ""

#, fuzzy
msgid "geo location movement direction"
msgstr "zeměpisná výška místa"

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 ""

#, fuzzy
msgid "geo location capture direction"
msgstr "zeměpisná výška místa"

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 ""

#. TRANSLATORS: 'show name' = 'TV/radio/podcast show name' here
msgid "show name"
msgstr ""

msgid "Name of the tv/podcast/series show the media is from"
msgstr ""

#. TRANSLATORS: 'show sortname' = 'TV/radio/podcast show name as used for sorting purposes' here
#, fuzzy
msgid "show sortname"
msgstr "umělec pro řazení"

msgid ""
"Name of the tv/podcast/series show the media is from, for sorting purposes"
msgstr ""

#, fuzzy
msgid "episode number"
msgstr "číslo disku"

msgid "The episode number in the season the media is part of"
msgstr ""

#, fuzzy
msgid "season number"
msgstr "číslo disku"

msgid "The season number of the show the media is part of"
msgstr ""

#, fuzzy
msgid "lyrics"
msgstr "licence"

msgid "The lyrics of the media, commonly used for songs"
msgstr ""

#, fuzzy
msgid "composer sortname"
msgstr "název pro řazení"

#, fuzzy
msgid "person(s) who composed the recording, for sorting purposes"
msgstr "osoby odpovědné za nahrávku pro řazení"

msgid "grouping"
msgstr ""

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 ""

#, fuzzy
msgid "user rating"
msgstr "trvání"

msgid ""
"Rating attributed by a user. The higher the rank, the more the user likes "
"this media"
msgstr ""

msgid "device manufacturer"
msgstr ""

#, fuzzy
msgid "Manufacturer of the device used to create this media"
msgstr "verze kodéru používaného pro kódování tohoto proudu"

msgid "device model"
msgstr ""

#, fuzzy
msgid "Model of the device used to create this media"
msgstr "verze kodéru používaného pro kódování tohoto proudu"

#, fuzzy
msgid "application name"
msgstr "název místa"

#, fuzzy
msgid "Application used to create the media"
msgstr "verze kodéru používaného pro kódování tohoto proudu"

msgid "application data"
msgstr ""

msgid "Arbitrary application data to be serialized into the media"
msgstr ""

msgid "image orientation"
msgstr ""

msgid "How the image should be rotated or flipped before display"
msgstr ""

msgid ", "
msgstr ", "

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

#, c-format
msgid ""
"Additional debug info:\n"
"%s\n"
msgstr ""
"Přídavné ladicí informace:\n"
"%s\n"

#, c-format
msgid "specified empty bin \"%s\", not allowed"
msgstr "zadán prázdný zásobník \"%s\", nedovoleno"

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

#, c-format
msgid "no property \"%s\" in element \"%s\""
msgstr "v elementu \"%2$s\" není vlastnost \"%1$s\""

#, c-format
msgid "could not set property \"%s\" in element \"%s\" to \"%s\""
msgstr "nemohu nastavit vlastnost \"%s\" v elementu \"%s\" na \"%s\""

#, c-format
msgid "could not link %s to %s"
msgstr "nemohu připojit %s k %s"

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

#, c-format
msgid "could not parse caps \"%s\""
msgstr "nemohu zpracovat schopnosti \"%s\""

msgid "link without source element"
msgstr "propojení bez elementu zdroje"

msgid "link without sink element"
msgstr "propojení bez elementu spotřebiče"

#, c-format
msgid "no source element for URI \"%s\""
msgstr "neexistuje element zdroje pro URI \"%s\""

#, c-format
msgid "no element to link URI \"%s\" to"
msgstr "neexistuje element, ke kterému připojit URI \"%s\""

#, c-format
msgid "no sink element for URI \"%s\""
msgstr "neexistuje element spotřebiče pro URI \"%s\""

#, c-format
msgid "could not link sink element for URI \"%s\""
msgstr "nemohu připojit element spotřebiče pro URI \"%s\""

msgid "empty pipeline not allowed"
msgstr "prázdná roura není povolena"

msgid "Internal clock error."
msgstr "Interní chyba hodin."

msgid "Internal data flow error."
msgstr "Interní chyba toku dat."

msgid "A lot of buffers are being dropped."
msgstr ""

msgid "Internal data flow problem."
msgstr "Interní problém toku dat."

msgid "Internal data stream error."
msgstr "Interní chyba proudu dat."

msgid "Filter caps"
msgstr "Filtrovat schopnosti"

msgid ""
"Restrict the possible allowed capabilities (NULL means ANY). Setting this "
"property takes a reference to the supplied GstCaps object."
msgstr ""
"Omezit povolené schopnosti (NULL znamená VŠECHNY). Nastavení této vlastnosti "
"bere odkaz na zadaný objekt GstCaps."

msgid "No file name specified for writing."
msgstr "Nezadán název souboru pro zápis."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Nemohu otevřít soubor \"%s\" pro zápis."

#, c-format
msgid "Error closing file \"%s\"."
msgstr "Chyba při zavírání souboru \"%s\"."

#, c-format
msgid "Error while seeking in file \"%s\"."
msgstr "Chyba při posunu v souboru \"%s\"."

#, c-format
msgid "Error while writing to file \"%s\"."
msgstr "Chyba při zápisu do souboru \"%s\"."

msgid "No file name specified for reading."
msgstr "Nezadán název souboru pro čtení."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Nemohu otevřít soubor \"%s\" pro čtení."

#, c-format
msgid "Could not get info on \"%s\"."
msgstr "Nemohu získat informace o \"%s\"."

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

#, c-format
msgid "File \"%s\" is a socket."
msgstr "Soubor \"%s\" je socket."

msgid "Failed after iterations as requested."
msgstr "Selhání po iteracích podle požadavku."

msgid "No Temp directory specified."
msgstr ""

#, fuzzy, c-format
msgid "Could not create temp file \"%s\"."
msgstr "Nemohu získat informace o \"%s\"."

#, fuzzy
msgid "Error while writing to download file."
msgstr "Chyba při zápisu do souboru \"%s\"."

msgid "caps"
msgstr "schopnosti"

msgid "detected capabilities in stream"
msgstr "detekované schopnosti v proudu"

msgid "minimum"
msgstr "minimum"

msgid "maximum"
msgstr "maximum"

msgid "force caps"
msgstr "vynutit schopnosti"

msgid "force caps without doing a typefind"
msgstr "vynutit schopnosti bez hledání typu"

msgid "Stream contains no data."
msgstr "Proud neobsahuje žádná data."

msgid "Implemented Interfaces:\n"
msgstr "Implementovaná rozhraní:\n"

msgid "readable"
msgstr "lze číst"

msgid "writable"
msgstr "lze zapisovat"

msgid "controllable"
msgstr "lze ovládat"

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 ""

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

#, c-format
msgid "%d blacklisted file"
msgid_plural "%d blacklisted files"
msgstr[0] ""
msgstr[1] ""
msgstr[2] ""

#, c-format
msgid "%d plugin"
msgid_plural "%d plugins"
msgstr[0] "%d modul"
msgstr[1] "%d moduly"
msgstr[2] "%d modulů"

#, c-format
msgid "%d blacklist entry"
msgid_plural "%d blacklist entries"
msgstr[0] ""
msgstr[1] ""
msgstr[2] ""

#, c-format
msgid "%d feature"
msgid_plural "%d features"
msgstr[0] "%d funkce"
msgstr[1] "%d funkce"
msgstr[2] "%d funkcí"

msgid "Print all elements"
msgstr "Vypsat všechny elementy"

msgid "Print list of blacklisted files"
msgstr ""

#, fuzzy
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 ""
"Vypsat strojem zpracovatelný seznam funkcí, které poskytuje zadaný modul.\n"
"                                       Užitečné spolu s externími mechanismy "
"pro automatickou instlaci modulů"

msgid "List the plugin contents"
msgstr ""

msgid "Print supported URI schemes, with the elements that implement them"
msgstr ""

#, c-format
msgid "Could not load plugin file: %s\n"
msgstr "Nemohu načíst soubor modulu: %s\n"

#, c-format
msgid "No such element or plugin '%s'\n"
msgstr "Element nebo modul '%s' neexistuje\n"

msgid "Index statistics"
msgstr ""

#, fuzzy, c-format
msgid "Got message #%u from element \"%s\" (%s): "
msgstr "Dostal jsem zprávu elementu \"%s\" (%s): "

#, fuzzy, c-format
msgid "Got message #%u from pad \"%s:%s\" (%s): "
msgstr "Dostal jsem zprávu elementu \"%s\" (%s): "

#, fuzzy, c-format
msgid "Got message #%u from object \"%s\" (%s): "
msgstr "Dostal jsem zprávu elementu \"%s\" (%s): "

#, fuzzy, c-format
msgid "Got message #%u (%s): "
msgstr "Dostal jsem zprávu elementu \"%s\" (%s): "

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

#, c-format
msgid "FOUND TAG      : found by element \"%s\".\n"
msgstr "NALEZEN TAG    : nalezen elementem \"%s\".\n"

#, fuzzy, c-format
msgid "FOUND TAG      : found by pad \"%s:%s\".\n"
msgstr "NALEZEN TAG    : nalezen elementem \"%s\".\n"

#, fuzzy, c-format
msgid "FOUND TAG      : found by object \"%s\".\n"
msgstr "NALEZEN TAG    : nalezen elementem \"%s\".\n"

msgid "FOUND TAG\n"
msgstr ""

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

#, c-format
msgid "WARNING: from element %s: %s\n"
msgstr "VAROVÁNÍ: od elementu %s: %s\n"

msgid "Prerolled, waiting for buffering to finish...\n"
msgstr "Předtočeno, čekám na dokončení ukládání do vyrovnávácí paměti...\n"

#, fuzzy
msgid "buffering..."
msgstr "ukládám do vyrovnávací paměti... %d  \n"

msgid "Done buffering, setting pipeline to PLAYING ...\n"
msgstr ""
"Ukládání do vyrovnávací paměti hotovo, nastavuji rouru na PŘEHRÁVÁ ...\n"

msgid "Buffering, setting pipeline to PAUSED ...\n"
msgstr ""
"Ukládám do vyrovnávací paměti hotovo, nastavuji rouru na POZASTAVENA ...\n"

msgid "Redistribute latency...\n"
msgstr ""

#, c-format
msgid "Setting state to %s as requested by %s...\n"
msgstr ""

msgid "Interrupt: Stopping pipeline ...\n"
msgstr "Přerušení: Zastavuji rouru ...\n"

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

msgid "Output tags (also known as metadata)"
msgstr "Vypsat tagy (také známé jako metadata)"

msgid "Output status information and property notifications"
msgstr "Vypsat informace o stavu a upozornění na vlastnosti"

#, fuzzy
msgid "Do not print any progress information"
msgstr "Nevypisovat informace o stavu s TYPEM"

msgid "Output messages"
msgstr "Zprávy výstupu"

msgid "Do not output status information of TYPE"
msgstr "Nevypisovat informace o stavu s TYPEM"

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

msgid "Do not install a fault handler"
msgstr "Neinstalovat obsluhu výjimek"

msgid "Print alloc trace (if enabled at compile time)"
msgstr "Vypisovat stopu alokace (je-li povoleno při kompilaci)"

msgid "Force EOS on sources before shutting the pipeline down"
msgstr ""

msgid "Gather and print index statistics"
msgstr ""

#, c-format
msgid "ERROR: pipeline could not be constructed: %s.\n"
msgstr "CHYBA: nelze vytvořit rouru: %s.\n"

msgid "ERROR: pipeline could not be constructed.\n"
msgstr "CHYBA: nelze vytvořit rouru.\n"

#, c-format
msgid "WARNING: erroneous pipeline: %s\n"
msgstr "VAROVÁNÍ: chybná roura: %s\n"

msgid "ERROR: the 'pipeline' element wasn't found.\n"
msgstr "CHYBA: element 'pipeline' nebyl nalezen.\n"

msgid "Setting pipeline to PAUSED ...\n"
msgstr "Nastavuji rouru na POZASTAVENA ...\n"

# On strike?
msgid "ERROR: Pipeline doesn't want to pause.\n"
msgstr "CHYBA: Roura nechce pozastavit.\n"

msgid "Pipeline is live and does not need PREROLL ...\n"
msgstr "Roura žije a nepotřebuje PŘEDTOČENÍ ...\n"

msgid "Pipeline is PREROLLING ...\n"
msgstr "Roura se PŘEDTÁČÍ ...\n"

# On strike?
msgid "ERROR: pipeline doesn't want to preroll.\n"
msgstr "CHYBA: roura nechce předtáčet.\n"

msgid "Pipeline is PREROLLED ...\n"
msgstr "Roura je PŘEDTOČENA ...\n"

msgid "Setting pipeline to PLAYING ...\n"
msgstr "Nastavuji rouro na PŘEHRÁVÁ ...\n"

# On strike?
msgid "ERROR: pipeline doesn't want to play.\n"
msgstr "CHYBA: roura nechce hrát.\n"

msgid "EOS on shutdown enabled -- Forcing EOS on the pipeline\n"
msgstr ""

msgid "Waiting for EOS...\n"
msgstr ""

#, fuzzy
msgid "EOS received - stopping pipeline...\n"
msgstr "Přerušení: Zastavuji rouru ...\n"

msgid "An error happened while waiting for EOS\n"
msgstr ""

msgid "Execution ended after %"
msgstr "Provádění skončilo po %"

msgid "Setting pipeline to READY ...\n"
msgstr "Nastavuji rouru na PŘIPRAVENA ...\n"

msgid "Setting pipeline to NULL ...\n"
msgstr "Nastavuji rouru na NULL ...\n"

#, fuzzy
msgid "Freeing pipeline ...\n"
msgstr "Nastavuji rouru na NULL ...\n"

#~ msgid "Usage: gst-xmllaunch <file.xml> [ element.property=value ... ]\n"
#~ msgstr ""
#~ "Použití: gst-xmllaunch <soubor.xml> [ element.vlastnost=hodnota ... ]\n"

#~ msgid "ERROR: parse of xml file '%s' failed.\n"
#~ msgstr "CHYBA: zpracovávání xml souboru '%s' selhalo.\n"

#~ msgid "ERROR: no toplevel pipeline element in file '%s'.\n"
#~ msgstr "CHYBA: v souboru '%s' není element nejvyšší úrovně pipeline.\n"

#, fuzzy
#~ msgid "WARNING: only one toplevel element is supported at this time.\n"
#~ msgstr ""
#~ "VAROVÁNÍ: v současné době je podporován jen jeden element nejvyšší úrovně."

#~ msgid "ERROR: could not parse command line argument %d: %s.\n"
#~ msgstr "CHYBA: nemohu zpracovat argument %d na příkazovém řádku: %s.\n"

#~ msgid "WARNING: element named '%s' not found.\n"
#~ msgstr "VAROVÁNÍ: element nazvaný '%s' nenalezen.\n"

#~ msgid "Save xml representation of pipeline to FILE and exit"
#~ msgstr "Uložit reprezentaci roury v xml do SOUBORu a skončit"

#~ msgid "FILE"
#~ msgstr "SOUBOR"

#, fuzzy
#~ msgid "Do not install signal handlers for SIGUSR1 and SIGUSR2"
#~ msgstr "Neinstalovat obsluhu výjimek"

#~ msgid "Error writing registry cache to %s: %s"
#~ msgstr "Chyba při zapisování cache registru do %s: %s"

#~ msgid "Error re-scanning registry %s: %s"
#~ msgstr "Chyba při opětovném prohledávání registru %s: %s"

#~ msgid "Error re-scanning registry %s"
#~ msgstr "Chyba při opětovném prohledávání registru %s"

#~ msgid "Internal GStreamer error: state change failed."
#~ msgstr "Interní chyba GStreameru: změna stavu selhala."

#~ msgid "Error while writing to file descriptor \"%d\"."
#~ msgstr "Chyba při zápisu do deksriptoru souboru \"%d\"."

#~ msgid "File descriptor \"%d\" is not valid."
#~ msgstr "Deskriptor souboru \"%d\" není platný."

#~ msgid "FREEING pipeline ...\n"
#~ msgstr "UVOLŇUJI rouru ...\n"

#~ msgid "original location of file as a URI"
#~ msgstr "původní umístění souboru jako URI"

#~ msgid "Disable accelerated CPU instructions"
#~ msgstr "Zakázat akcelerované instrukce CPU"

#~ msgid "SCHEDULER"
#~ msgstr "PLÁNOVAČ"

#~ msgid "Registry to use"
#~ msgstr "Registr, který používat"

#~ msgid "REGISTRY"
#~ msgstr "REGISTR"

#~ msgid "path list for loading plugins (separated by '%s')"
#~ msgstr "seznam cest pro načítání modulů (oddělený '%s')"

#~ msgid "Scheduler to use (default is '%s')"
#~ msgstr "Plánovač, který používat (implicitní je '%s')"

#~ msgid "There is no element present to handle the stream's mime type %s."
#~ msgstr "Není přítomen žádý element pro obsloužení proudu s typem mime %s."

#~ msgid ""
#~ "Execution ended after %s iterations (sum %s ns, average %s ns, min %s ns, "
#~ "max %s ns).\n"
#~ msgstr ""
#~ "Provádění skončilo po %s iteracích (celkem %s ns, průměr %s ns, min %s "
#~ "ns, max %s ns).\n"

#~ msgid "Number of times to iterate pipeline"
#~ msgstr "Kolikrát iterovat rouru"

#~ msgid "         Trying to run anyway.\n"
#~ msgstr "         Přesto se ji pokouším spustit.\n"

#~ msgid "Added plugin %s with %d %s.\n"
#~ msgstr "Přidán modul %s s %d %s.\n"

#~ msgid "Added path   %s to %s \n"
#~ msgstr "Přidána cesta %s do %s \n"

#~ msgid "Rebuilding %s (%s) ...\n"
#~ msgstr "Znovu sestavuji %s (%s) ...\n"

#~ msgid "Trying to load %s ...\n"
#~ msgstr "Pokouším se načíst %s ...\n"

#~ msgid "Error loading %s\n"
#~ msgstr "Chyba při načítání %s\n"

#~ msgid "Loaded %d plugins with %d %s.\n"
#~ msgstr "Načteno %d modulů s %d %s.\n"
