# Lithuanian translation for gstreamer.
# Copyright (C) 2010 Free Software Foundation
# This file is distributed under the same license as the gstreamer package.
# Aurimas Černius <aurisc4@gmail.com>, 2010.
# Žygimantas Beručka <uid0@akl.lt>, 2010.
msgid ""
msgstr ""
"Project-Id-Version: gstreamer 0.10.29.2\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2011-09-29 14:55+0200\n"
"PO-Revision-Date: 2010-07-16 00:50+0300\n"
"Last-Translator: Žygimantas Beručka <uid0@akl.lt>\n"
"Language-Team: Lithuanian <komp_lt@konferencijos.lt>\n"
"Language: lt\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"
"%100<10 || n%100>=20) ? 1 : 2);\n"
"X-Generator: Virtaal 0.6.1\n"

msgid "Print the GStreamer version"
msgstr "Išvesti GStreamer versiją"

msgid "Make all warnings fatal"
msgstr "Padaryti visus įspėjimus lemtingais"

msgid "Print available debug categories and exit"
msgstr "Išvesti prieinamas derinimo kategorijas ir išeiti"

msgid ""
"Default debug level from 1 (only error) to 5 (anything) or 0 for no output"
msgstr ""
"Numatytasis derinimo lygis nuo 1 (tik klaidos) iki 5 (bet kas) arba 0 – "
"jokios išvesties"

msgid "LEVEL"
msgstr "LYGIS"

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 ""
"Kableliais skiriamas category_name:level porų sąrašas, nustatantis "
"konkrečius lygius paskiroms kategorijoms. Pavyzdys: GST_AUTOPLUG:5,"
"GST_ELEMENT_*:3"

msgid "LIST"
msgstr "SĄRAŠAS"

msgid "Disable colored debugging output"
msgstr "Išjungti spalvotą derinimo išvestį"

msgid "Disable debugging"
msgstr "Išjungti derinimą"

msgid "Enable verbose plugin loading diagnostics"
msgstr "Įjungti informatyvią įskiepių įkėlimo diagnostiką"

msgid "Colon-separated paths containing plugins"
msgstr "Dvitaškiais skiriami keliai, kur yra įskiepių"

msgid "PATHS"
msgstr "KELIAI"

msgid ""
"Comma-separated list of plugins to preload in addition to the list stored in "
"environment variable GST_PLUGIN_PATH"
msgstr ""
"Kableliais skiriamas sąrašas įskiepių, įkeltinų papildomai prie "
"GST_PLUGIN_PATH aplinkos kintamajame saugomo sąrašo"

msgid "PLUGINS"
msgstr "ĮSKIEPIAI"

msgid "Disable trapping of segmentation faults during plugin loading"
msgstr "Išjungti segmentavimo klaidų gaudymą įskiepių įkėlimo metu"

msgid "Disable updating the registry"
msgstr "Išjungti registro atnaujinimą"

msgid "Disable spawning a helper process while scanning the registry"
msgstr "Išjungti pagalbinio proceso paleidimą skenuojant registrą"

msgid "GStreamer Options"
msgstr "GStreamer parinktys"

msgid "Show GStreamer Options"
msgstr "Rodyti GStreamer parinktis"

msgid "Unknown option"
msgstr "Nežinoma parinktis"

msgid "GStreamer encountered a general core library error."
msgstr "GStreamer susidūrė su bendrąją pagrindinės bibliotekos klaida."

msgid ""
"GStreamer developers were too lazy to assign an error code to this error."
msgstr "GStreamer kūrėjai nepasivargino priskirti šiai klaidai klaidos kodo."

msgid "Internal GStreamer error: code not implemented."
msgstr "Vidinė GStreamer klaida: kodas nerealizuotas."

msgid ""
"GStreamer error: state change failed and some element failed to post a "
"proper error message with the reason for the failure."
msgstr ""
"GStreamer klaida: nepavyko pakeisti būsenos ir kažkuriam elementui nepavyko "
"išvesti tinkamo klaidos pranešimo su nesėkmės priežastimi."

msgid "Internal GStreamer error: pad problem."
msgstr "Vidinė GStreamer klaida: pagrindo klaida."

msgid "Internal GStreamer error: thread problem."
msgstr "Vidinė GStreamer klaida: gijos problema."

msgid "Internal GStreamer error: negotiation problem."
msgstr "Vidinė GStreamer klaida: derybų problema."

msgid "Internal GStreamer error: event problem."
msgstr "Vidinė GStreamer klaida: įvykio problema."

msgid "Internal GStreamer error: seek problem."
msgstr "Vidinė GStreamer klaida: ieškojimo klaida."

msgid "Internal GStreamer error: caps problem."
msgstr "Vidinė GStreamer klaida: galimybių problema."

msgid "Internal GStreamer error: tag problem."
msgstr "Vidinė GStreamer klaida: žymos problema."

msgid "Your GStreamer installation is missing a plug-in."
msgstr "Jūsų įdiegtame GStreamer trūksta įskiepio."

msgid "Internal GStreamer error: clock problem."
msgstr "Vidinė GStreamer klaida: laikrodžio problema."

msgid ""
"This application is trying to use GStreamer functionality that has been "
"disabled."
msgstr "Ši programa bando naudoti GStreamer funkcijas, kurios buvo išjungtos."

msgid "GStreamer encountered a general supporting library error."
msgstr "GStreamer aptiko bendrąją palaikančiosios bibliotekos klaidą."

msgid "Could not initialize supporting library."
msgstr "Nepavyko inicializuoti palaikančiosios bibliotekos."

msgid "Could not close supporting library."
msgstr "Nepavyko užverti palaikančiosios bibliotekos."

msgid "Could not configure supporting library."
msgstr "Nepavyko sukonfigūruoti palaikančiosios bibliotekos."

msgid "Encoding error."
msgstr ""

msgid "GStreamer encountered a general resource error."
msgstr "GStreamer aptiko bendrąją ištekliaus klaidą."

msgid "Resource not found."
msgstr "Išteklius nerastas."

msgid "Resource busy or not available."
msgstr "Išteklius užimtas arba neprieinamas."

msgid "Could not open resource for reading."
msgstr "Nepavyko atverti ištekliaus skaitymui."

msgid "Could not open resource for writing."
msgstr "Nepavyko atverti ištekliaus rašymui."

msgid "Could not open resource for reading and writing."
msgstr "Nepavyko atverti ištekliaus skaitymui ir rašymui."

msgid "Could not close resource."
msgstr "Nepavyko užverti ištekliaus."

msgid "Could not read from resource."
msgstr "Nepavyko skaityti iš ištekliaus."

msgid "Could not write to resource."
msgstr "Nepavyko rašyti į išteklių."

msgid "Could not perform seek on resource."
msgstr "Nepavyko atlikti paieškos ištekliuje."

msgid "Could not synchronize on resource."
msgstr "Nepavyko sinchronizuoti su ištekliumi."

msgid "Could not get/set settings from/on resource."
msgstr "Nepavyko gauti/nustatyti ištekliaus parametrų."

msgid "No space left on the resource."
msgstr "Ištekliuje nebėra vietos."

msgid "GStreamer encountered a general stream error."
msgstr "GStreamer aptiko bendrąją srauto klaidą."

msgid "Element doesn't implement handling of this stream. Please file a bug."
msgstr ""
"Elementas nesukuria srauto apdorojimo galimybės. Praneškite apie klaidą."

msgid "Could not determine type of stream."
msgstr "Nepavyko aptikti srauto tipo."

msgid "The stream is of a different type than handled by this element."
msgstr "Srautas yra kitokio tipo negu šis elementas gali apdoroti."

msgid "There is no codec present that can handle the stream's type."
msgstr "Nėra kodeko, galinčio apdoroti šio tipo srautą."

msgid "Could not decode stream."
msgstr "Nepavyko dekoduoti srauto."

msgid "Could not encode stream."
msgstr "Nepavyko koduoti srauto."

msgid "Could not demultiplex stream."
msgstr "Nepavyko išretinti srauto."

msgid "Could not multiplex stream."
msgstr "Nepavyko sutankinti srauto."

msgid "The stream is in the wrong format."
msgstr "Srautas yra neteisingo formato."

msgid "The stream is encrypted and decryption is not supported."
msgstr "Srautas yra šifruotas, o iššifravimo galimybė nepalaikoma."

msgid ""
"The stream is encrypted and can't be decrypted because no suitable key has "
"been supplied."
msgstr ""
"Srautas yra šifruotas ir negali būti iššifruotas, kadangi nebuvo pateiktas "
"tinkamas raktas."

#, c-format
msgid "No error message for domain %s."
msgstr "Nėra klaidos pranešimo sričiai %s."

#, c-format
msgid "No standard error message for domain %s and code %d."
msgstr "Nėra standartinio klaidos pranešimo sričiai %s ir kodui %d."

msgid "Selected clock cannot be used in pipeline."
msgstr "Pasirinktas laikrodis negali būti naudojamas konvejeryje."

msgid "title"
msgstr "pavadinimas"

msgid "commonly used title"
msgstr "bendrai naudojamas pavadinimas"

msgid "title sortname"
msgstr "pavadinimo rikiuojamas pavadinimas"

msgid "commonly used title for sorting purposes"
msgstr "bendrai naudojamas pavadinimas rikiavimo reikmėms"

msgid "artist"
msgstr "atlikėjas"

msgid "person(s) responsible for the recording"
msgstr "asmuo (-enys), atsakingi už įrašą"

msgid "artist sortname"
msgstr "atlikėjo rikiuojamas pavadinimas"

msgid "person(s) responsible for the recording for sorting purposes"
msgstr "asmuo (-enys), atsakingi už įrašą rikiavimo reikmėms"

msgid "album"
msgstr "albumas"

msgid "album containing this data"
msgstr "albumas su šiais duomenimis"

msgid "album sortname"
msgstr "albumo rikiuojamas pavadinimas"

msgid "album containing this data for sorting purposes"
msgstr "albumas su šiais duomenimis rikiavimo reikmėms"

msgid "album artist"
msgstr "albumo atlikėjas"

msgid "The artist of the entire album, as it should be displayed"
msgstr "Viso albumo atlikėjas, koks turi būti rodomas"

msgid "album artist sortname"
msgstr "albumo atlikėjo rikiuojamas pavadinimas"

msgid "The artist of the entire album, as it should be sorted"
msgstr "Viso albumo atlikėjas, koks turėtų būti rikiuojamas"

msgid "date"
msgstr "data"

msgid "date the data was created (as a GDate structure)"
msgstr "data, kada duomenys buvo sukurti (kaip GDate struktūra)"

#, fuzzy
msgid "datetime"
msgstr "data"

#, fuzzy
msgid "date and time the data was created (as a GstDateTime structure)"
msgstr "data, kada duomenys buvo sukurti (kaip GDate struktūra)"

msgid "genre"
msgstr "žanras"

msgid "genre this data belongs to"
msgstr "žanras, kuriam priskiriami šie duomenys"

msgid "comment"
msgstr "komentaras"

msgid "free text commenting the data"
msgstr "laisvas tekstas, apibūdinantis duomenis"

msgid "extended comment"
msgstr "išplėstinis komentaras"

msgid "free text commenting the data in key=value or key[en]=comment form"
msgstr ""
"laisvas tekstas, apibūdinantis duomenis raktas=reikšmė arba raktas[en]"
"=komentaras forma"

msgid "track number"
msgstr "takelio numeris"

msgid "track number inside a collection"
msgstr "takelio numeris kolekcijoje"

msgid "track count"
msgstr "takelių skaičius"

msgid "count of tracks inside collection this track belongs to"
msgstr "takelių skaičius kolekcijoje, kuriai priklauso šis takelis"

msgid "disc number"
msgstr "disko numeris"

msgid "disc number inside a collection"
msgstr "disko numeris kolekcijoje"

msgid "disc count"
msgstr "diskų skaičius"

msgid "count of discs inside collection this disc belongs to"
msgstr "diskų skaičius kolekcijoje, kuriai priklauso šis diskas"

msgid "location"
msgstr "vieta"

msgid ""
"Origin of media as a URI (location, where the original of the file or stream "
"is hosted)"
msgstr ""
"Medijos šaltinis kaip URI (vieta, kur patalpintas originalus failas arba "
"srautas)"

msgid "homepage"
msgstr "svetainė"

msgid "Homepage for this media (i.e. artist or movie homepage)"
msgstr "Šios medijos namų svetainė (t. y. atlikėjo arba filmo svetainė)"

msgid "description"
msgstr "aprašymas"

msgid "short text describing the content of the data"
msgstr "trumpas tekstas, aprašantis duomenų turinį"

msgid "version"
msgstr "versija"

msgid "version of this data"
msgstr "šių duomenų versija"

msgid "ISRC"
msgstr "ISRC"

msgid "International Standard Recording Code - see http://www.ifpi.org/isrc/"
msgstr ""
"Tarptautinis standartinis įrašų kodas – žiūrėkite http://www.ifpi.org/isrc/"

msgid "organization"
msgstr "organizacija"

msgid "copyright"
msgstr "autoriaus teisės"

msgid "copyright notice of the data"
msgstr "pranešimas apie duomenų autoriaus teises"

msgid "copyright uri"
msgstr "autoriaus teisių uri"

msgid "URI to the copyright notice of the data"
msgstr "URI, kur yra pranešimas apie duomenų autoriaus teises"

#, fuzzy
msgid "encoded by"
msgstr "enkoderis"

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

msgid "contact"
msgstr "kontaktai"

msgid "contact information"
msgstr "kontaktinė informacija"

msgid "license"
msgstr "licencija"

msgid "license of data"
msgstr "duomenų licencija"

msgid "license uri"
msgstr "licencijos uri"

msgid "URI to the license of the data"
msgstr "URI, kur yra duomenų licencija"

msgid "performer"
msgstr "atlikėjas"

msgid "person(s) performing"
msgstr "atliekantis (-ys) asmuo (-enys)"

msgid "composer"
msgstr "kompozitorius"

msgid "person(s) who composed the recording"
msgstr "asmuo (-enys), kuris (-ie) sukūrė įrašą"

msgid "duration"
msgstr "trukmė"

msgid "length in GStreamer time units (nanoseconds)"
msgstr "trukmė GStreamer laiko vienetais (nanosekundėmis)"

msgid "codec"
msgstr "kodekas"

msgid "codec the data is stored in"
msgstr "kodekas, kuriame laikomi duomenys"

msgid "video codec"
msgstr "vaizdo kodekas"

msgid "codec the video data is stored in"
msgstr "vaizdo kodekas, kuriame laikomi duomenys"

msgid "audio codec"
msgstr "garso kodekas"

msgid "codec the audio data is stored in"
msgstr "garso kodekas, kuriame laikomi duomenys"

msgid "subtitle codec"
msgstr "subtitrų kodekas"

msgid "codec the subtitle data is stored in"
msgstr "kodekas, kuriame laikomi subtitrų duomenys"

msgid "container format"
msgstr "konteinerio formatas"

msgid "container format the data is stored in"
msgstr "konteinerio formatas, kuriame laikomi duomenys"

msgid "bitrate"
msgstr "pralaidumas"

msgid "exact or average bitrate in bits/s"
msgstr "tikslus arba vidutinis pralaidumas bitais per sekundę"

msgid "nominal bitrate"
msgstr "nominalus pralaidumas"

msgid "nominal bitrate in bits/s"
msgstr "nominalus pralaidumas bitais per sekundę"

msgid "minimum bitrate"
msgstr "mažiausias pralaidumas"

msgid "minimum bitrate in bits/s"
msgstr "mažiausias pralaidumas bitais per sekundę"

msgid "maximum bitrate"
msgstr "didžiausias pralaidumas"

msgid "maximum bitrate in bits/s"
msgstr "didžiausias pralaidumas bitais per sekundę"

msgid "encoder"
msgstr "enkoderis"

msgid "encoder used to encode this stream"
msgstr "enkoderis, naudotas šiam srautui koduoti"

msgid "encoder version"
msgstr "enkoderio versija"

msgid "version of the encoder used to encode this stream"
msgstr "enkoderio, naudoto šiam srautui koduoti, versija"

msgid "serial"
msgstr "serija"

msgid "serial number of track"
msgstr "takelio serijos numeris"

msgid "replaygain track gain"
msgstr "replaygain takelio stiprinimas"

msgid "track gain in db"
msgstr "takelio stiprinimas decibelais"

msgid "replaygain track peak"
msgstr "replaygain takelio viršūnė"

msgid "peak of the track"
msgstr "takelio viršūnė"

msgid "replaygain album gain"
msgstr "replaygain albumo stiprinimas"

msgid "album gain in db"
msgstr "albumo stiprinimas decibelais"

msgid "replaygain album peak"
msgstr "replaygain albumo viršūnė"

msgid "peak of the album"
msgstr "albumo viršūnė"

msgid "replaygain reference level"
msgstr "replaygain santykinis lygis"

msgid "reference level of track and album gain values"
msgstr "takelio ir albumo stiprinimo reikšmių santykinis lygis"

msgid "language code"
msgstr "kalbos kodas"

msgid "language code for this stream, conforming to ISO-639-1"
msgstr "šio srauto kalbos kodas, atitinkantis ISO-639-1"

msgid "image"
msgstr "paveikslėlis"

msgid "image related to this stream"
msgstr "paveikslėlis, susietas su srautu"

#. TRANSLATORS: 'preview image' = image that shows a preview of the full image
msgid "preview image"
msgstr "peržiūros paveikslėlis"

msgid "preview image related to this stream"
msgstr "peržiūros paveikslėlis, susijęs su srautu"

msgid "attachment"
msgstr "priedas"

msgid "file attached to this stream"
msgstr "failas, pridėtas prie srauto"

msgid "beats per minute"
msgstr "taktų per minutę"

msgid "number of beats per minute in audio"
msgstr "taktų skaičius per minutę garso įraše"

msgid "keywords"
msgstr "raktažodžiai"

msgid "comma separated keywords describing the content"
msgstr "kableliais skiriami raktažodžiai, aprašantys turinį"

msgid "geo location name"
msgstr "geografinės vietos pavadinimas"

msgid ""
"human readable descriptive location of where the media has been recorded or "
"produced"
msgstr "aiškus vietovės, kurioje medija buvo įrašyta arba sukurta, aprašymas"

msgid "geo location latitude"
msgstr "geografinės vietos platuma"

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 ""
"vietovės platuma, kur medija buvo įrašyta arba sukurta, laipsniais pagal "
"WGS85 (nulis ties pusiauju, neigiamos reikšmės – pietinėms platumoms)"

msgid "geo location longitude"
msgstr "geografinės vietos ilguma"

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 ""
"vietovės ilguma, kur medija buvo įrašyta arba sukurta, laipsniais pagal "
"WGS84 (nulis ties pirmuoju meridianu Grinviče/JK, neigiamos reikšmės – "
"rytinėms ilgumoms)"

msgid "geo location elevation"
msgstr "geografinės vietos aukštuma"

msgid ""
"geo elevation of where the media has been recorded or produced in meters "
"according to WGS84 (zero is average sea level)"
msgstr ""
"aukštuma, kur medija buvo įrašyta arba sukurta, metrais pagal WGS84 (nulis – "
"vidutinis jūros lygis)"

msgid "geo location country"
msgstr "geografinė vietos šalis"

msgid "country (english name) where the media has been recorded or produced"
msgstr ""
"šalis (angliškas pavadinimas), kurioje medija buvo įrašyta arba sukurta"

msgid "geo location city"
msgstr "geografinės vietos miestas"

msgid "city (english name) where the media has been recorded or produced"
msgstr ""
"miestas (angliškas pavadinimas), kuriame medija buvo įrašyta arba sukurta"

msgid "geo location sublocation"
msgstr "geografinės vietos sublokacija"

msgid ""
"a location whithin a city where the media has been produced or created (e.g. "
"the neighborhood)"
msgstr ""
"vietove mieste, kuriame medija buvo pagaminta arba sukurta, (pvz., "
"kaimynystė)"

#, fuzzy
msgid "geo location horizontal error"
msgstr "geografinės vietos pavadinimas"

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

msgid "geo location movement speed"
msgstr "geografinės vietos judėjimo greitis"

msgid ""
"movement speed of the capturing device while performing the capture in m/s"
msgstr "įrašančio prietaiso judėjimo greitis m/s įrašinėjant"

msgid "geo location movement direction"
msgstr "geografinės vietos judėjimo kryptis"

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 ""
"nurodo mediją įrašančio prietaiso judėjimo kryptį. Ji nurodoma laipsniais "
"slankaus kablelio pavidalu, „0“ reiškia šiaurę, reikšmė didėja pagal "
"laikrodžio rodyklę"

msgid "geo location capture direction"
msgstr "geografinės vietos įrašymo kryptis"

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 ""
"nurodo kryptį, kuria nukreiptas mediją įrašantis įrenginys. Pateikiama "
"laipsniais slankaus kablelio pavidalu, „0“ reiškia geografinę šiaurę, "
"reikšmė didėja pagal laikrodžio rodyklę"

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

msgid "Name of the tv/podcast/series show the media is from"
msgstr "Tv / tinklalaidės / serialo, iš kurio yra medija, laidos pavadinimas"

#. TRANSLATORS: 'show sortname' = 'TV/radio/podcast show name as used for sorting purposes' here
msgid "show sortname"
msgstr "laidos rikiuojamas pavadinimas"

msgid ""
"Name of the tv/podcast/series show the media is from, for sorting purposes"
msgstr ""
"Tv / tinklalaidės / serialo, iš kurio yra medija, laidos pavadinimas "
"rikiavimo reikmėms"

msgid "episode number"
msgstr "epizodo numeris"

msgid "The episode number in the season the media is part of"
msgstr "Sezono, kuriam priklauso medija, epizodo numeris"

msgid "season number"
msgstr "sezono numeris"

msgid "The season number of the show the media is part of"
msgstr "Laidos sezono, kuriam priklauso medija, numeris"

msgid "lyrics"
msgstr "žodžiai"

msgid "The lyrics of the media, commonly used for songs"
msgstr "Medijos žodžiai, dažniausiai naudojama dainoms"

msgid "composer sortname"
msgstr "kompozitoriaus rikiuojamas vardas"

msgid "person(s) who composed the recording, for sorting purposes"
msgstr "asmens (-enų), kuris (-ie) sukūrė įrašą, vardas rikiavimo reikmėms"

msgid "grouping"
msgstr "grupavimas"

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 ""
"Grupuoja susijusias medijas, susidedančias iš daugelio takelių, pvz., "
"skirtingas koncerto dalis. Tai aukštesnis lygmuo nei takelis, bet žemesnis "
"nei albumas"

msgid "user rating"
msgstr "naudotojo įvertinimas"

msgid ""
"Rating attributed by a user. The higher the rank, the more the user likes "
"this media"
msgstr ""
"Naudotojo nurodytas įvertinimas. Kuo geresnis įvertinimas, tuo labiau "
"naudotojas mėgsta šią mediją"

msgid "device manufacturer"
msgstr "įrenginio gamintojas"

msgid "Manufacturer of the device used to create this media"
msgstr "Įrenginio, naudoto šiai medijai sukurti, gamintojas"

msgid "device model"
msgstr "įrenginio modelis"

msgid "Model of the device used to create this media"
msgstr "Įrenginio, naudoto šiai medijai sukurti, modelis"

#, fuzzy
msgid "application name"
msgstr "geografinės vietos pavadinimas"

#, fuzzy
msgid "Application used to create the media"
msgstr "Įrenginio, naudoto šiai medijai sukurti, modelis"

msgid "application data"
msgstr ""

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

msgid "image orientation"
msgstr "paveikslėlio orientacija"

msgid "How the image should be rotated or flipped before display"
msgstr "Kaip paveikslėlis turėtų būti pasuktas arba apverstas prieš parodymą"

msgid ", "
msgstr ", "

#, c-format
msgid "ERROR: from element %s: %s\n"
msgstr "KLAIDA: iš elemento %s: %s\n"

#, c-format
msgid ""
"Additional debug info:\n"
"%s\n"
msgstr ""
"Papildoma derinimo informacija:\n"
"%s\n"

#, c-format
msgid "specified empty bin \"%s\", not allowed"
msgstr "nurodytas tuščias dėklas „%s“, neleidžiama"

#, c-format
msgid "no bin \"%s\", skipping"
msgstr "nėra dėklo „%s“, praleidžiama"

#, c-format
msgid "no property \"%s\" in element \"%s\""
msgstr "nenurodyta savybė „%s“ elemente „%s“"

#, c-format
msgid "could not set property \"%s\" in element \"%s\" to \"%s\""
msgstr "nepavyko nustatyti savybės „%s“ elemente „%s“ į „%s“"

#, c-format
msgid "could not link %s to %s"
msgstr "nepavyko susieti %s su %s"

#, c-format
msgid "no element \"%s\""
msgstr "nėra elemento „%s“"

#, c-format
msgid "could not parse caps \"%s\""
msgstr "nepavyko perskaityti galimybių „%s“"

msgid "link without source element"
msgstr "saitas be šaltinio elemento"

msgid "link without sink element"
msgstr "saitas be išvesties elemento"

#, c-format
msgid "no source element for URI \"%s\""
msgstr "nėra šaltinio elemento URI „%s“"

#, c-format
msgid "no element to link URI \"%s\" to"
msgstr "nėra elemento, su kuriuo susieti URI „%s“"

#, c-format
msgid "no sink element for URI \"%s\""
msgstr "nėra išvesties elemento URI „%s“"

#, c-format
msgid "could not link sink element for URI \"%s\""
msgstr "nepavyko susieti išvesties elemento URI „%s“"

msgid "empty pipeline not allowed"
msgstr "tuščias konvejeris neleidžiamas"

msgid "Internal clock error."
msgstr "Vidinė laikrodžio klaida."

msgid "Internal data flow error."
msgstr "Vidinė duomenų tėkmės klaida."

msgid "A lot of buffers are being dropped."
msgstr "Atlaisvinama daug buferių."

msgid "Internal data flow problem."
msgstr "Vidinė duomenų tėkmės problema."

msgid "Internal data stream error."
msgstr "Vidinė duomenų srauto klaida."

msgid "Filter caps"
msgstr "Filtruoti galimybes"

msgid ""
"Restrict the possible allowed capabilities (NULL means ANY). Setting this "
"property takes a reference to the supplied GstCaps object."
msgstr ""
"Riboti galimas leidžiamas galimybes (NULL – BET KOKIAS). Nustatant šią "
"savybę nurodoma į pateiktą GstCaps objektą."

msgid "No file name specified for writing."
msgstr "Nenurodytas failo pavadinimas rašymui."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Nepavyko atverti failo „%s“ rašymui."

#, c-format
msgid "Error closing file \"%s\"."
msgstr "Klaida užveriant failą „%s“."

#, c-format
msgid "Error while seeking in file \"%s\"."
msgstr "Klaida ieškant faile „%s“."

#, c-format
msgid "Error while writing to file \"%s\"."
msgstr "Klaida rašant į failą „%s“."

msgid "No file name specified for reading."
msgstr "Nenurodytas failo pavadinimas skaitymui."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Nepavyko atverti failo „%s“ skaitymui."

#, c-format
msgid "Could not get info on \"%s\"."
msgstr "Nepavyko gauti duomenų apie „%s“."

#, c-format
msgid "\"%s\" is a directory."
msgstr "„%s“ yra katalogas."

#, c-format
msgid "File \"%s\" is a socket."
msgstr "Failas „%s“ yra lizdas."

msgid "Failed after iterations as requested."
msgstr "Nesėkmė po iteracijų kaip ir reikalauta."

msgid "No Temp directory specified."
msgstr "Nenurodytas laikinas katalogas."

#, c-format
msgid "Could not create temp file \"%s\"."
msgstr "Nepavyko sukurti laikino failo „%s“."

msgid "Error while writing to download file."
msgstr "Klaida rašant į atsiuntimo failą."

msgid "caps"
msgstr "galimybės"

msgid "detected capabilities in stream"
msgstr "aptiktos galimybės sraute"

msgid "minimum"
msgstr "mažiausios"

msgid "maximum"
msgstr "didžiausios"

msgid "force caps"
msgstr "reikalauti galimybių"

msgid "force caps without doing a typefind"
msgstr "priverstinai naudoti galimybes neatliekant tipo paieškos"

msgid "Stream contains no data."
msgstr "Sraute nėra duomenų."

msgid "Implemented Interfaces:\n"
msgstr "Realizuotos sąsajos:\n"

msgid "readable"
msgstr "skaitomas"

msgid "writable"
msgstr "rašomas"

msgid "controllable"
msgstr "valdomas"

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 "Failai juodajame sąraše:"

msgid "Total count: "
msgstr "Bendras skaičius:"

#, c-format
msgid "%d blacklisted file"
msgid_plural "%d blacklisted files"
msgstr[0] "%d failas juodajame sąraše"
msgstr[1] "%d failai juodajame sąraše"
msgstr[2] "%d failų juodajame sąraše"

#, c-format
msgid "%d plugin"
msgid_plural "%d plugins"
msgstr[0] "%d įskiepis"
msgstr[1] "%d įskiepiai"
msgstr[2] "%d įskiepių"

#, c-format
msgid "%d blacklist entry"
msgid_plural "%d blacklist entries"
msgstr[0] "%d juodojo sąrašo įrašas"
msgstr[1] "%d juodojo sąrašo įrašai"
msgstr[2] "%d juodojo sąrašo įrašų"

#, c-format
msgid "%d feature"
msgid_plural "%d features"
msgstr[0] "%d funkcija"
msgstr[1] "%d funkcijos"
msgstr[2] "%d funkcijų"

msgid "Print all elements"
msgstr "Išvesti visus elementus"

msgid "Print list of blacklisted files"
msgstr "Išvesti failus juodajame sąraše"

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 ""
"Išspausdinti mašininiu būdu perskaitomą sąrašą funkcijų, kurias suteikia "
"nurodytasis arba visi įskiepiai.\n"
"                                       Naudinga naudojant su išoriniais "
"automatiniais įskiepių diegimo mechanizmais"

msgid "List the plugin contents"
msgstr "Parodyti įskiepio turinį"

msgid "Print supported URI schemes, with the elements that implement them"
msgstr "Išvesti palaikomas URI schemas su jas sukuriančiais elementais"

#, c-format
msgid "Could not load plugin file: %s\n"
msgstr "Nepavyko įkelti įskiepio failo: %s\n"

#, c-format
msgid "No such element or plugin '%s'\n"
msgstr "Nėra tokio elemento arba įskiepio „%s“\n"

msgid "Index statistics"
msgstr ""

#, c-format
msgid "Got message #%u from element \"%s\" (%s): "
msgstr "Gautas pranešimas #%u iš elemento „%s“ (%s): "

#, c-format
msgid "Got message #%u from pad \"%s:%s\" (%s): "
msgstr "Gautas pranešimas #%u iš pagrindo „%s:%s“ (%s): "

#, c-format
msgid "Got message #%u from object \"%s\" (%s): "
msgstr "Gautas pranešimas #%u iš objekto „%s“ (%s): "

#, c-format
msgid "Got message #%u (%s): "
msgstr "Gautas pranešimas #%u (%s): "

#, c-format
msgid "Got EOS from element \"%s\".\n"
msgstr "Gautas EOS iš elemento „%s“.\n"

#, c-format
msgid "FOUND TAG      : found by element \"%s\".\n"
msgstr "RASTA ŽYMA      : rasta elemento „%s“.\n"

#, c-format
msgid "FOUND TAG      : found by pad \"%s:%s\".\n"
msgstr "RASTA ŽYMA      : rasta pagrindo „%s:%s“.\n"

#, c-format
msgid "FOUND TAG      : found by object \"%s\".\n"
msgstr "RASTA ŽYMA      : rasta objekto „%s“.\n"

msgid "FOUND TAG\n"
msgstr "RASTA ŽYMA\n"

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

#, c-format
msgid "WARNING: from element %s: %s\n"
msgstr "ĮSPĖJIMAS: iš elemento %s: %s\n"

msgid "Prerolled, waiting for buffering to finish...\n"
msgstr "Paruošta, laukiama kol bus sukurtas buferis...\n"

msgid "buffering..."
msgstr "kuriamas buferis..."

msgid "Done buffering, setting pipeline to PLAYING ...\n"
msgstr "Buferis sukurtas, konvejeris nustatomas GROJIMUI...\n"

msgid "Buffering, setting pipeline to PAUSED ...\n"
msgstr "Kuriamas buferis, konvejeris nustatomas į PRISTABDYTĄ...\n"

msgid "Redistribute latency...\n"
msgstr "Perskirstyti gaišties laiką...\n"

#, c-format
msgid "Setting state to %s as requested by %s...\n"
msgstr "Nustatoma būsena į %s, kaip prašė %s...\n"

msgid "Interrupt: Stopping pipeline ...\n"
msgstr "Pertraukimas: stabdomas konvejeris...\n"

#, fuzzy, c-format
msgid "Missing element: %s\n"
msgstr "nėra elemento „%s“"

msgid "Output tags (also known as metadata)"
msgstr "Išvesti žymas (dar žinomas kaip metaduomenys)"

msgid "Output status information and property notifications"
msgstr "Išvesti būsenos informaciją ir savybių pranešimus"

msgid "Do not print any progress information"
msgstr "Neišvesti jokios informacijos apie pažangą"

msgid "Output messages"
msgstr "Išvesti pranešimus"

msgid "Do not output status information of TYPE"
msgstr "Neišvesti šio TIPO būsenos informacijos"

msgid "TYPE1,TYPE2,..."
msgstr "TIPAS1,TIPAS2,..."

msgid "Do not install a fault handler"
msgstr "Neįdiegti klaidų apdorojimo posistemės"

msgid "Print alloc trace (if enabled at compile time)"
msgstr "Išvesti alloc sekimą (jei įjungta kompiliavimo metu)"

msgid "Force EOS on sources before shutting the pipeline down"
msgstr "Priverstinai naudoti EOS šaltiniuose prie išjungiant konvejerį"

msgid "Gather and print index statistics"
msgstr ""

#, c-format
msgid "ERROR: pipeline could not be constructed: %s.\n"
msgstr "KLAIDA: nepavyko sukurti konvejerio: %s.\n"

msgid "ERROR: pipeline could not be constructed.\n"
msgstr "KLAIDA: nepavyko sukurti konvejerio.\n"

#, c-format
msgid "WARNING: erroneous pipeline: %s\n"
msgstr "ĮSPĖJIMAS: klaidingas konvejeris: %s\n"

msgid "ERROR: the 'pipeline' element wasn't found.\n"
msgstr "KLAIDA: „pipeline“ elementas nerastas.\n"

msgid "Setting pipeline to PAUSED ...\n"
msgstr "Nustatomas konvejeris į PRISTABDYTĄ...\n"

msgid "ERROR: Pipeline doesn't want to pause.\n"
msgstr "KLAIDA: konvejeris nesileidžia pristabdomas.\n"

msgid "Pipeline is live and does not need PREROLL ...\n"
msgstr "Konvejeris aktyvus ir nereikalauja PARUOŠIMO...\n"

msgid "Pipeline is PREROLLING ...\n"
msgstr "Konvejeris RUOŠIAMAS...\n"

msgid "ERROR: pipeline doesn't want to preroll.\n"
msgstr "KLAIDA: konvejeris nesileidžia paruošiamas.\n"

msgid "Pipeline is PREROLLED ...\n"
msgstr "Konvejeris PARUOŠTAS...\n"

msgid "Setting pipeline to PLAYING ...\n"
msgstr "Nustatomas konvejeris į GROJAMA...\n"

msgid "ERROR: pipeline doesn't want to play.\n"
msgstr "KLAIDA: konvejeris nepradeda groti.\n"

msgid "EOS on shutdown enabled -- Forcing EOS on the pipeline\n"
msgstr "Įjungtas EOS išjungiant – priverstinai naudojama EOS konvejeryje\n"

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

msgid "EOS received - stopping pipeline...\n"
msgstr "EOS gautas – stabdomas konvejeris...\n"

msgid "An error happened while waiting for EOS\n"
msgstr "Įvyko klaida laukiant EOS\n"

msgid "Execution ended after %"
msgstr "Vykdymas baigėsi po %"

msgid "Setting pipeline to READY ...\n"
msgstr "Nustatomas konvejeris į PARUOŠTA...\n"

msgid "Setting pipeline to NULL ...\n"
msgstr "Nustatomas konvejeris į NULL...\n"

msgid "Freeing pipeline ...\n"
msgstr "Atlaisvinamas konvejeris...\n"

#~ msgid "Usage: gst-xmllaunch <file.xml> [ element.property=value ... ]\n"
#~ msgstr ""
#~ "Naudojimas: gst-xmllaunch <failas.xml> [ elementas.savybė=reikšmė ... ]\n"

#~ msgid "ERROR: parse of xml file '%s' failed.\n"
#~ msgstr "KLAIDA: nepavyko perskaityti xml failo „%s“.\n"

#~ msgid "ERROR: no toplevel pipeline element in file '%s'.\n"
#~ msgstr "KLAIDA: nėra aukščiausio lygmens konvejerio elemento faile „%s“.\n"

#~ msgid "WARNING: only one toplevel element is supported at this time.\n"
#~ msgstr ""
#~ "ĮSPĖJIMAS: šiuo metu palaikomas tik vienas aukščiausio lygmens "
#~ "elementas.\n"

#~ msgid "ERROR: could not parse command line argument %d: %s.\n"
#~ msgstr "KLAIDA: nepavyko apdoroti komandinės eilutės argumento %d: %s.\n"

#~ msgid "WARNING: element named '%s' not found.\n"
#~ msgstr "ĮSPĖJIMAS: nerastas elementas „%s“.\n"

#~ msgid "Save xml representation of pipeline to FILE and exit"
#~ msgstr "Įrašyti konvejerio xml atitikmenį į FAILĄ ir išeiti"

#~ msgid "FILE"
#~ msgstr "FAILAS"

#~ msgid "Do not install signal handlers for SIGUSR1 and SIGUSR2"
#~ msgstr ""
#~ "Neįdiegti signalų apdorojimo posistemės signalams SIGUSR1 ir SIGUSR2"
