# Translation of gstreamer to Croatian.
# This file is put in the public domain.
# Tomislav Krznar <tomislav.krznar@gmail.com>, 2012.
#
msgid ""
msgstr ""
"Project-Id-Version: gstreamer 0.10.32.2\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2016-03-24 11:24+0200\n"
"PO-Revision-Date: 2012-05-25 16:47+0200\n"
"Last-Translator: Tomislav Krznar <tomislav.krznar@gmail.com>\n"
"Language-Team: Croatian <lokalizacija@linux.hr>\n"
"Language: \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 "Ispiši inačicu GStreamera"

msgid "Make all warnings fatal"
msgstr "Učini sva upozorenja fatalnim"

msgid "Print available debug categories and exit"
msgstr "Ispiši dostupne kategorije debugiranja i izađi"

#, fuzzy
msgid ""
"Default debug level from 1 (only error) to 9 (anything) or 0 for no output"
msgstr ""
"Zadana razina debugiranja od 1 (samo greške) do 5 (sve) ili 0 bez ispisa"

msgid "LEVEL"
msgstr "RAZINA"

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 ""
"Popis zarezom odvojenih parova category_name:level za postavljanje posebnih "
"razina za pojedine kategorije. Primjer: GST_AUTOPLUG:5,GST_ELEMENT_*:3"

msgid "LIST"
msgstr "POPIS"

msgid "Disable colored debugging output"
msgstr "Onemogući obojani ispis debugiranja"

msgid ""
"Changes coloring mode of the debug log. Possible modes: off, on, disable, "
"auto, unix"
msgstr ""

msgid "Disable debugging"
msgstr "Onemogući debugiranje"

msgid "Enable verbose plugin loading diagnostics"
msgstr "Omogući opširnu dijagnozu učitavanja priključaka"

msgid "Colon-separated paths containing plugins"
msgstr "Dvotočkom odvojene putanje koje sadržavaju priključke"

msgid "PATHS"
msgstr "PUTANJE"

msgid ""
"Comma-separated list of plugins to preload in addition to the list stored in "
"environment variable GST_PLUGIN_PATH"
msgstr ""
"Zarezima odvojen popis priključaka koji će se učitati uz popis spremljen u "
"varijablu okoline GST_PLUGIN_PATH"

msgid "PLUGINS"
msgstr "PRIKLJUČCI"

msgid "Disable trapping of segmentation faults during plugin loading"
msgstr "Onemogući hvatanje segmentacijskih grešaka pri učitavanju priključaka"

msgid "Disable updating the registry"
msgstr "Onemogući ažuriranje registra"

msgid "Disable spawning a helper process while scanning the registry"
msgstr "Onemogući stvaranje pomoćnog procesa pri pretraživanju registra"

msgid "GStreamer Options"
msgstr "GStreamer opcije"

msgid "Show GStreamer Options"
msgstr "Prikaži GStreamer opcije"

msgid "Unknown option"
msgstr "Nepoznata opcija"

msgid "GStreamer encountered a general core library error."
msgstr "GStreamer je naišao na opću grešku osnovne biblioteke."

msgid ""
"GStreamer developers were too lazy to assign an error code to this error."
msgstr "Razvijatelji GStreamera su bili prelijeni da pridruže kod ovoj grešci."

msgid "Internal GStreamer error: code not implemented."
msgstr "Interna GStreamer greška: kod nije implementiran."

msgid ""
"GStreamer error: state change failed and some element failed to post a "
"proper error message with the reason for the failure."
msgstr ""
"GStreamer greška: nije uspjela promjena stanja i neki element nije uspio "
"poslati ispravnu poruku greške s razlogom neuspjeha."

msgid "Internal GStreamer error: pad problem."
msgstr "Interna GStreamer greška: problem podloge."

msgid "Internal GStreamer error: thread problem."
msgstr "Interna GStreamer greška: problem dretve."

#, fuzzy
msgid "GStreamer error: negotiation problem."
msgstr "Interna GStreamer greška: problem pregovaranja."

msgid "Internal GStreamer error: event problem."
msgstr "Interna GStreamer greška: problem događaja."

msgid "Internal GStreamer error: seek problem."
msgstr "Interna GStreamer greška: problem traženja."

msgid "Internal GStreamer error: caps problem."
msgstr "Interna GStreamer greška: problem mogućnosti."

msgid "Internal GStreamer error: tag problem."
msgstr "Interna GStreamer greška: problem oznake."

msgid "Your GStreamer installation is missing a plug-in."
msgstr "Vašoj GStreamer instalaciji nedostaje priključak."

#, fuzzy
msgid "GStreamer error: clock problem."
msgstr "Interna GStreamer greška: problem takta."

msgid ""
"This application is trying to use GStreamer functionality that has been "
"disabled."
msgstr "Ovaj program pokušava koristiti onemogućenu GStreamer mogućnost."

msgid "GStreamer encountered a general supporting library error."
msgstr "GStreamer je naišao na opću grešku pomoćne biblioteke."

msgid "Could not initialize supporting library."
msgstr "Ne mogu inicijalizirati pomoćnu biblioteku."

msgid "Could not close supporting library."
msgstr "Ne mogu zatvoriti pomoćnu biblioteku."

msgid "Could not configure supporting library."
msgstr "Ne mogu konfigurirati pomoćnu biblioteku."

msgid "Encoding error."
msgstr "Greška kodiranja."

msgid "GStreamer encountered a general resource error."
msgstr "GStreamer je naišao na opću grešku resursa."

msgid "Resource not found."
msgstr "Resurs nije pronađen."

msgid "Resource busy or not available."
msgstr "Resurs je zauzet ili nedostupan."

msgid "Could not open resource for reading."
msgstr "Ne mogu otvoriti resurs za čitanje."

msgid "Could not open resource for writing."
msgstr "Ne mogu otvoriti resurs za pisanje."

msgid "Could not open resource for reading and writing."
msgstr "Ne mogu otvoriti resurs za čitanje i pisanje."

msgid "Could not close resource."
msgstr "Ne mogu zatvoriti resurs."

msgid "Could not read from resource."
msgstr "Ne mogu čitati iz resursa."

msgid "Could not write to resource."
msgstr "Ne mogu pisati u resurs."

msgid "Could not perform seek on resource."
msgstr "Ne mogu izvršiti traženje na resursu."

msgid "Could not synchronize on resource."
msgstr "Ne mogu sinkronizirati na resursu."

msgid "Could not get/set settings from/on resource."
msgstr "Ne mogu dohvatiti/postaviti postavke resursa."

msgid "No space left on the resource."
msgstr "Nema više prostora na resursu."

#, fuzzy
msgid "Not authorized to access resource."
msgstr "Nema više prostora na resursu."

msgid "GStreamer encountered a general stream error."
msgstr "GStreamer je naišao na opću grešku toka podataka."

msgid "Element doesn't implement handling of this stream. Please file a bug."
msgstr ""
"Element ne implementira upravljanje ovim tokom podataka. Molim prijavite "
"grešku."

msgid "Could not determine type of stream."
msgstr "Ne mogu odrediti vrstu toka podataka."

msgid "The stream is of a different type than handled by this element."
msgstr ""
"Tok podataka je različite vrste od onoga kojim može upravljati ovaj element."

msgid "There is no codec present that can handle the stream's type."
msgstr "Nije prisutan kodek koji može upravljati ovom vrstom toka podataka."

msgid "Could not decode stream."
msgstr "Ne mogu dekodirati tok podataka."

msgid "Could not encode stream."
msgstr "Ne mogu kodirati tok podataka."

msgid "Could not demultiplex stream."
msgstr "Ne mogu demultipleksirati tok podataka."

msgid "Could not multiplex stream."
msgstr "Ne mogu multipleksirati tok podataka."

msgid "The stream is in the wrong format."
msgstr "Tok podataka je u krivom obliku."

msgid "The stream is encrypted and decryption is not supported."
msgstr "Tok podataka je šifriran i dešifriranje nije podržano."

msgid ""
"The stream is encrypted and can't be decrypted because no suitable key has "
"been supplied."
msgstr ""
"Tok podataka je šifriran i ne može se dešifrirati jer nije naveden "
"odgovarajući ključ."

#, c-format
msgid "No error message for domain %s."
msgstr "Nema poruke o grešci za domenu %s."

#, c-format
msgid "No standard error message for domain %s and code %d."
msgstr "Nema standardne poruke o grešci za domenu %s i kod %d."

msgid "Selected clock cannot be used in pipeline."
msgstr "Odabrani takt se ne može koristiti u cjevovodu."

#, c-format
msgid "Error writing registry cache to %s: %s"
msgstr ""

msgid "title"
msgstr "naslov"

msgid "commonly used title"
msgstr "uobičajeno korišteni naslov"

msgid "title sortname"
msgstr "naslov (razvrstavanje)"

msgid "commonly used title for sorting purposes"
msgstr "uobičajeno korišteni naslov (koristi se za razvrstavanje)"

msgid "artist"
msgstr "izvođač"

msgid "person(s) responsible for the recording"
msgstr "osoba odgovorna za snimku"

msgid "artist sortname"
msgstr "izvođač (razvrstavanje)"

msgid "person(s) responsible for the recording for sorting purposes"
msgstr "osoba odgovorna za snimku (koristi se za razvrstavanje)"

msgid "album"
msgstr "album"

msgid "album containing this data"
msgstr "album koji sadrži ove podatke"

msgid "album sortname"
msgstr "album (razvrstavanje)"

msgid "album containing this data for sorting purposes"
msgstr "album koji sadrži ove podatke (koristi se za razvrstavanje)"

msgid "album artist"
msgstr "izvođač albuma"

msgid "The artist of the entire album, as it should be displayed"
msgstr "Izvođač cijelog albuma (koristi se za prikaz)"

msgid "album artist sortname"
msgstr "izvođač albuma (razvrstavanje)"

msgid "The artist of the entire album, as it should be sorted"
msgstr "Izvođač cijelog albuma (koristi se za razvrstavanje)"

msgid "date"
msgstr "datum"

msgid "date the data was created (as a GDate structure)"
msgstr "datum stvaranja podataka (u obliku GDate strukture)"

msgid "datetime"
msgstr "datumvrijeme"

msgid "date and time the data was created (as a GstDateTime structure)"
msgstr "datum i vrijeme stvaranja podataka (u obliku GstDateTime strukture)"

msgid "genre"
msgstr "žanr"

msgid "genre this data belongs to"
msgstr "žanr kojem pripadaju podaci"

msgid "comment"
msgstr "komentar"

msgid "free text commenting the data"
msgstr "slobodan tekst koji opisuje podatke"

msgid "extended comment"
msgstr "prošireni komentar"

msgid "free text commenting the data in key=value or key[en]=comment form"
msgstr ""
"slobodan tekst koji opisuje podatke u obliku ključ=vrijednost ili "
"ključ[en]=komentar"

msgid "track number"
msgstr "broj pjesme"

msgid "track number inside a collection"
msgstr "broj pjesme u kolekciji"

msgid "track count"
msgstr "broj pjesama"

msgid "count of tracks inside collection this track belongs to"
msgstr "broj pjesama u kolekciji kojoj pripada ova pjesma"

msgid "disc number"
msgstr "broj diska"

msgid "disc number inside a collection"
msgstr "broj diska u kolekciji"

msgid "disc count"
msgstr "broj diskova"

msgid "count of discs inside collection this disc belongs to"
msgstr "broj diskova u kolekciji kojoj pripada ovaj disk"

msgid "location"
msgstr "mjesto"

msgid ""
"Origin of media as a URI (location, where the original of the file or stream "
"is hosted)"
msgstr ""
"Podrijetlo medija kao URI (mjesto, gdje se nalazi izvor datoteke ili toka "
"podataka)"

msgid "homepage"
msgstr "početna stranica"

msgid "Homepage for this media (i.e. artist or movie homepage)"
msgstr ""
"Početna stranica ovog medija (npr. početna stranica izvođača ili filma)"

msgid "description"
msgstr "opis"

msgid "short text describing the content of the data"
msgstr "kratak tekst koji opisuje sadržaj podataka"

msgid "version"
msgstr "inačica"

msgid "version of this data"
msgstr "inačica ovih podataka"

msgid "ISRC"
msgstr "ISRC"

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

msgid "organization"
msgstr "organizacija"

msgid "copyright"
msgstr "copyright"

msgid "copyright notice of the data"
msgstr "napomena o autorskim pravima podataka"

msgid "copyright uri"
msgstr "copyright uri"

msgid "URI to the copyright notice of the data"
msgstr "URI za napomenu o autorskim pravima podataka"

msgid "encoded by"
msgstr "kodirao"

msgid "name of the encoding person or organization"
msgstr "ime osobe ili organizacije koja je kodirala"

msgid "contact"
msgstr "kontakt"

msgid "contact information"
msgstr "informacije o kontaktu"

msgid "license"
msgstr "licenca"

msgid "license of data"
msgstr "licenca podataka"

msgid "license uri"
msgstr "uri licence"

msgid "URI to the license of the data"
msgstr "URI za licencu podataka"

msgid "performer"
msgstr "izvođač"

msgid "person(s) performing"
msgstr "osoba koja izvodi"

msgid "composer"
msgstr "skladatelj"

msgid "person(s) who composed the recording"
msgstr "osoba koja je skladala snimku"

msgid "conductor"
msgstr ""

msgid "conductor/performer refinement"
msgstr ""

msgid "duration"
msgstr "trajanje"

msgid "length in GStreamer time units (nanoseconds)"
msgstr "duljina u GStreamer vremenskim jedinicama (nanosekunde)"

msgid "codec"
msgstr "kodek"

msgid "codec the data is stored in"
msgstr "kodek u kojem su spremljeni podaci"

msgid "video codec"
msgstr "video kodek"

msgid "codec the video data is stored in"
msgstr "kodek u kojem su spremljeni video podaci"

msgid "audio codec"
msgstr "audio kodek"

msgid "codec the audio data is stored in"
msgstr "kodek u kojem su spremljeni audio podaci"

msgid "subtitle codec"
msgstr "kodek titlova"

msgid "codec the subtitle data is stored in"
msgstr "kodek u kojem su spremljeni podaci o titlovima"

msgid "container format"
msgstr "oblik spremnika"

msgid "container format the data is stored in"
msgstr "oblik spremnika u kojem su spremljeni podaci"

msgid "bitrate"
msgstr "brzina"

msgid "exact or average bitrate in bits/s"
msgstr "točna ili prosječna brzina u bitovima po sekundi"

msgid "nominal bitrate"
msgstr "nazivna brzina"

msgid "nominal bitrate in bits/s"
msgstr "nazivna brzina u bitovima po sekundi"

msgid "minimum bitrate"
msgstr "najmanja brzina"

msgid "minimum bitrate in bits/s"
msgstr "najmanja brzina u bitovima po sekundi"

msgid "maximum bitrate"
msgstr "najveća brzina"

msgid "maximum bitrate in bits/s"
msgstr "najveća brzina u bitovima po sekundi"

msgid "encoder"
msgstr "koder"

msgid "encoder used to encode this stream"
msgstr "koder korišten za kodiranje ovog toka podataka"

msgid "encoder version"
msgstr "inačica kodera"

msgid "version of the encoder used to encode this stream"
msgstr "inačica kodera korištenog za kodiranje ovog toka podataka"

msgid "serial"
msgstr "serijski broj"

msgid "serial number of track"
msgstr "serijski broj pjesme"

msgid "replaygain track gain"
msgstr "pojačanje reprodukcije pjesme"

msgid "track gain in db"
msgstr "pojačanje pjesme u decibelima"

msgid "replaygain track peak"
msgstr "vršno pojačanje reprodukcije pjesme"

msgid "peak of the track"
msgstr "najveća vrijednost pojačanja pjesme"

msgid "replaygain album gain"
msgstr "pojačanje reprodukcije albuma"

msgid "album gain in db"
msgstr "pojačanje albuma u decibelima"

msgid "replaygain album peak"
msgstr "vršno pojačanje reprodukcije albuma"

msgid "peak of the album"
msgstr "najveća vrijednost pojačanja albuma"

msgid "replaygain reference level"
msgstr "referentna razina pojačanja reprodukcije"

msgid "reference level of track and album gain values"
msgstr "referentna razina vrijednosti pojačanja pjesme i albuma"

msgid "language code"
msgstr "jezični kod"

#, fuzzy
msgid "language code for this stream, conforming to ISO-639-1 or ISO-639-2"
msgstr "jezični kod za ovaj tok podataka, kompatibilan s ISO-639-1"

#, fuzzy
msgid "language name"
msgstr "jezični kod"

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

msgid "image"
msgstr "slika"

msgid "image related to this stream"
msgstr "slika povezana s ovim tokom podataka"

#. TRANSLATORS: 'preview image' = image that shows a preview of the full image
msgid "preview image"
msgstr "pregledna slika"

msgid "preview image related to this stream"
msgstr "pregledna slika povezana s ovim tokom podataka"

msgid "attachment"
msgstr "prilog"

msgid "file attached to this stream"
msgstr "datoteka priložena ovom toku podataka"

msgid "beats per minute"
msgstr "otkucaja u minuti"

msgid "number of beats per minute in audio"
msgstr "broj otkucaja u minuti zvučnog zapisa"

msgid "keywords"
msgstr "ključne riječi"

msgid "comma separated keywords describing the content"
msgstr "zarezima odvojene ključne riječi koje opisuju sadržaj"

msgid "geo location name"
msgstr "geolokacijsko ime"

msgid ""
"human readable descriptive location of where the media has been recorded or "
"produced"
msgstr "ljudima čitljivo opisno mjesto gdje medij snimljen ili produciran"

msgid "geo location latitude"
msgstr "geolokacijska zemljopisna širina"

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 ""
"zemljopisna širina mjesta gdje je medij snimljen ili produciran, u "
"stupnjevima prema WGS84 (nula na ekvatoru, negativne vrijednosti za južnu "
"polutku)"

msgid "geo location longitude"
msgstr "geolokacijska zemljopisna dužina"

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 ""
"zemljopisna dužina mjesta gdje je medij snimljen ili produciran, u "
"stupnjevima prema WGS84 (nula na nultom meridijanu Greenwich/UK, negativne "
"vrijednosti za zapadne dužine)"

msgid "geo location elevation"
msgstr "geolokacijska visina"

msgid ""
"geo elevation of where the media has been recorded or produced in meters "
"according to WGS84 (zero is average sea level)"
msgstr ""
"nadmorska visina mjesta gdje je medij snimljen ili produciran, u metrima "
"prema WGS84 (nula je prosječna razina mora)"

msgid "geo location country"
msgstr "geolokacijska država"

msgid "country (english name) where the media has been recorded or produced"
msgstr "država (englesko ime) gdje je medij snimljen ili produciran"

msgid "geo location city"
msgstr "geolokacijski grad"

msgid "city (english name) where the media has been recorded or produced"
msgstr "grad (englesko ime) gdje je medij snimljen ili produciran"

msgid "geo location sublocation"
msgstr "geolokacijska podlokacija"

#, fuzzy
msgid ""
"a location within a city where the media has been produced or created (e.g. "
"the neighborhood)"
msgstr ""
"mjesto u gradu gdje je medij snimljen ili produciran (npr. gradska četvrt)"

msgid "geo location horizontal error"
msgstr "geolokacijska vodoravna greška"

msgid "expected error of the horizontal positioning measures (in meters)"
msgstr "očekivana greška mjere vodoravnog položaja (u metrima)"

msgid "geo location movement speed"
msgstr "geolokacijska brzina pomicanja"

msgid ""
"movement speed of the capturing device while performing the capture in m/s"
msgstr "brzina pomicanja uređaja za snimanje pri snimanju, u m/s"

msgid "geo location movement direction"
msgstr "geolokacijski smjer pomicanja"

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 ""
"označava smjer pomicanja uređaja koji snima medij. Prikazan je u stupnjevima "
"u prikazu s decimalnim zarezom, 0 označava zemljopisni sjever i povećava se "
"u smjeru kazaljke na satu"

msgid "geo location capture direction"
msgstr "geolokacijski smjer snimanja"

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 ""
"označava usmjerenje uređaja koji snima medij. Prikazan je u stupnjevima u "
"prikazu s decimalnim zarezom, 0 označava zemljopisni sjever i povećava se u "
"smjeru kazaljke na satu"

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

msgid "Name of the tv/podcast/series show the media is from"
msgstr "Ime serije ili tv/podcast emisije iz koje je medij"

#. TRANSLATORS: 'show sortname' = 'TV/radio/podcast show name as used for sorting purposes' here
msgid "show sortname"
msgstr "ime emisije (razvrstavanje)"

msgid ""
"Name of the tv/podcast/series show the media is from, for sorting purposes"
msgstr ""
"Ime serije ili tv/podcast emisije iz koje je medij (koristi se za "
"razvrstavanje)"

msgid "episode number"
msgstr "broj epizode"

msgid "The episode number in the season the media is part of"
msgstr "Broj epizode u sezoni iz koje je medij"

msgid "season number"
msgstr "broj sezone"

msgid "The season number of the show the media is part of"
msgstr "Broj sezone emisije iz koje je medij"

msgid "lyrics"
msgstr "tekstovi"

msgid "The lyrics of the media, commonly used for songs"
msgstr "Tekstovi medija, najčešće korišteno u pjesmama"

msgid "composer sortname"
msgstr "skladatelj (razvrstavanje)"

msgid "person(s) who composed the recording, for sorting purposes"
msgstr "osoba koja je skladala snimku (koristi se za razvrstavanje)"

msgid "grouping"
msgstr "grupiranje"

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 ""
"Grupira povezane medije koji se protežu kroz više pjesama, kao npr. "
"različiti stavci koncerta. To je viša razina od pjesme, ali niža od albuma"

msgid "user rating"
msgstr "korisnička ocjena"

msgid ""
"Rating attributed by a user. The higher the rank, the more the user likes "
"this media"
msgstr ""
"Ocjena koju je dodijelio korisnik. Što je veća, korisniku se više sviđa medij"

msgid "device manufacturer"
msgstr "proizvođač uređaja"

msgid "Manufacturer of the device used to create this media"
msgstr "Proizvođač uređaja kojim je napravljen medij"

msgid "device model"
msgstr "model uređaja"

msgid "Model of the device used to create this media"
msgstr "Model uređaja korišten za izradu medija"

msgid "application name"
msgstr "ime programa"

msgid "Application used to create the media"
msgstr "Program korišten za izradu medija"

msgid "application data"
msgstr "programski podaci"

msgid "Arbitrary application data to be serialized into the media"
msgstr "Proizvoljni programski podaci uključeni u medij"

msgid "image orientation"
msgstr "orijentacija slike"

msgid "How the image should be rotated or flipped before display"
msgstr "Kako se slika treba okrenuti ili zrcaliti prije prikaza"

msgid "publisher"
msgstr ""

msgid "Name of the label or publisher"
msgstr ""

msgid "interpreted-by"
msgstr ""

msgid "Information about the people behind a remix and similar interpretations"
msgstr ""

msgid "midi-base-note"
msgstr ""

msgid "Midi note number of the audio track."
msgstr ""

msgid "private-data"
msgstr ""

msgid "Private data"
msgstr ""

msgid ", "
msgstr ", "

#, c-format
msgid "No URI handler for the %s protocol found"
msgstr ""

#, c-format
msgid "URI scheme '%s' not supported"
msgstr ""

#, c-format
msgid "ERROR: from element %s: %s\n"
msgstr "GREŠKA: iz elementa %s: %s\n"

#, c-format
msgid ""
"Additional debug info:\n"
"%s\n"
msgstr ""
"Dodatne informacije za debugiranje:\n"
"%s\n"

#, c-format
msgid "link has no source [sink=%s@%p]"
msgstr ""

#, c-format
msgid "link has no sink [source=%s@%p]"
msgstr ""

#, c-format
msgid "no property \"%s\" in element \"%s\""
msgstr "nema svojstva „%s” u elementu „%s”"

#, c-format
msgid "could not set property \"%s\" in element \"%s\" to \"%s\""
msgstr "ne mogu postaviti svojstvo „%s” u elementu „%s” u „%s”"

msgid "Delayed linking failed."
msgstr ""

#, c-format
msgid "could not link %s to %s"
msgstr "ne mogu povezati %s na %s"

#, c-format
msgid "no element \"%s\""
msgstr "nema elementa „%s”"

#, c-format
msgid "unexpected reference \"%s\" - ignoring"
msgstr ""

#, c-format
msgid "unexpected pad-reference \"%s\" - ignoring"
msgstr ""

#, c-format
msgid "could not parse caps \"%s\""
msgstr "ne mogu analizirati mogućnost „%s”"

#, c-format
msgid "no sink element for URI \"%s\""
msgstr "nema prijamnog elementa za URI „%s”"

#, c-format
msgid "no source element for URI \"%s\""
msgstr "nema izvornog elementa za URI „%s”"

msgid "syntax error"
msgstr ""

msgid "bin"
msgstr ""

#, c-format
msgid "specified empty bin \"%s\", not allowed"
msgstr ""

#, fuzzy, c-format
msgid "no bin \"%s\", unpacking elements"
msgstr "nema svojstva „%s” u elementu „%s”"

msgid "empty pipeline not allowed"
msgstr "prazan cjevovod nije dozvoljen"

msgid "A lot of buffers are being dropped."
msgstr "Mnogo međuspremnika je ispušteno."

msgid "Internal data flow problem."
msgstr "Problem unutrašnjeg toka podataka."

msgid "Internal data stream error."
msgstr "Greška unutrašnjeg toka podataka."

msgid "Internal data flow error."
msgstr "Greška unutrašnjeg toka podataka."

msgid "Internal clock error."
msgstr "Greška unutrašnjeg takta."

msgid "Failed to map buffer."
msgstr ""

msgid "Filter caps"
msgstr "Filtriraj mogućnosti"

msgid ""
"Restrict the possible allowed capabilities (NULL means ANY). Setting this "
"property takes a reference to the supplied GstCaps object."
msgstr ""
"Ograniči dozvoljene mogućnosti (NULL znači ANY). Postavljanje ovog svojstva "
"prosljeđuje referencu navedenom GstCaps objektu."

msgid "Caps Change Mode"
msgstr ""

msgid "Filter caps change behaviour"
msgstr ""

msgid "No Temp directory specified."
msgstr "Nije naveden privremeni direktorij."

#, c-format
msgid "Could not create temp file \"%s\"."
msgstr "Ne mogu napraviti privremenu datoteku „%s”."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Ne mogu otvoriti datoteku „%s” za čitanje."

msgid "Error while writing to download file."
msgstr "Greška pri pisanju u preuzetu datoteku."

msgid "No file name specified for writing."
msgstr "Nije navedena datoteka za pisanje."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Ne mogu otvoriti datoteku „%s” za pisanje."

#, c-format
msgid "Error closing file \"%s\"."
msgstr "Greška zatvaranja datoteke „%s”."

#, c-format
msgid "Error while seeking in file \"%s\"."
msgstr "Greška pri traženju u datoteci „%s”."

#, c-format
msgid "Error while writing to file \"%s\"."
msgstr "Greška pri pisanju u datoteku „%s”."

msgid "No file name specified for reading."
msgstr "Nije navedena datoteka za čitanje."

#, c-format
msgid "Could not get info on \"%s\"."
msgstr "Ne mogu dobiti podatke o „%s”."

#, c-format
msgid "\"%s\" is a directory."
msgstr "„%s” je direktorij."

#, c-format
msgid "File \"%s\" is a socket."
msgstr "Datoteka „%s” je utičnica."

msgid "Failed after iterations as requested."
msgstr "Neuspjeh nakon iteracija kao što je traženo."

msgid "caps"
msgstr "mogućnosti"

msgid "detected capabilities in stream"
msgstr "otkrivene mogućnosti u nizu podataka"

msgid "minimum"
msgstr "najmanje"

msgid "force caps"
msgstr "prisili mogućnosti"

msgid "force caps without doing a typefind"
msgstr "prisiljava mogućnosti bez traženja vrste"

#, fuzzy
msgid "Stream doesn't contain enough data."
msgstr "Tok podataka ne sadrži podatke."

msgid "Stream contains no data."
msgstr "Tok podataka ne sadrži podatke."

msgid "Implemented Interfaces:\n"
msgstr "Implementirana sučelja:\n"

msgid "readable"
msgstr "čitljivo"

msgid "writable"
msgstr "zapisivo"

msgid "deprecated"
msgstr ""

msgid "controllable"
msgstr "upravljivo"

msgid "changeable in NULL, READY, PAUSED or PLAYING state"
msgstr "promjenjivo u stanja NULL, READY, PAUSED ili PLAYING"

msgid "changeable only in NULL, READY or PAUSED state"
msgstr "promjenjivo samo u stanja NULL, READY ili PAUSED"

msgid "changeable only in NULL or READY state"
msgstr "promjenjivo samo u stanja NULL ili READY"

msgid "Blacklisted files:"
msgstr "Zabranjene datoteke:"

msgid "Total count: "
msgstr "Ukupan broj: "

#, c-format
msgid "%d blacklisted file"
msgid_plural "%d blacklisted files"
msgstr[0] "%d zabranjena datoteka"
msgstr[1] "%d zabranjene datoteke"
msgstr[2] "%d zabranjenih datoteka"

#, c-format
msgid "%d plugin"
msgid_plural "%d plugins"
msgstr[0] "%d priključak"
msgstr[1] "%d priključka"
msgstr[2] "%d priključaka"

#, c-format
msgid "%d blacklist entry"
msgid_plural "%d blacklist entries"
msgstr[0] "%d stavka popisa zabrana"
msgstr[1] "%d stavke popisa zabrana"
msgstr[2] "%d stavki popisa zabrana"

#, c-format
msgid "%d feature"
msgid_plural "%d features"
msgstr[0] "%d značajka"
msgstr[1] "%d značajke"
msgstr[2] "%d značajki"

msgid "Print all elements"
msgstr "Ispiši sve elemente"

msgid "Print list of blacklisted files"
msgstr "Ispiši popis zabranjenih datoteka"

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 ""
"Ispiši strojno čitljiv popis značajki navedenog priključka ili svih "
"priključaka.\n"
"                                Korisno pri povezivanju s vanjskim "
"mehanizmima automatske instalacije priključaka"

msgid "List the plugin contents"
msgstr "Ispiši sadržaj priključka"

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 "Ispiši podržane URI sheme, s elementima koji ih implementiraju"

#, c-format
msgid "Could not load plugin file: %s\n"
msgstr "Ne mogu učitati datoteku priključka: %s\n"

#, c-format
msgid "No such element or plugin '%s'\n"
msgstr "Nema takvog elementa ili priključka „%s”\n"

msgid "Index statistics"
msgstr "Statistike indeksa"

#, c-format
msgid "Got message #%u from element \"%s\" (%s): "
msgstr "Dobio poruku #%u iz elementa „%s” (%s): "

#, c-format
msgid "Got message #%u from pad \"%s:%s\" (%s): "
msgstr "Dobio poruku #%u iz podloge „%s:%s” (%s): "

#, c-format
msgid "Got message #%u from object \"%s\" (%s): "
msgstr "Dobio poruku #%u iz objekta „%s” (%s): "

#, c-format
msgid "Got message #%u (%s): "
msgstr "Dobio poruku #%u (%s): "

#, c-format
msgid "Got EOS from element \"%s\".\n"
msgstr "Dobio EOS iz elementa „%s”.\n"

#, c-format
msgid "FOUND TAG      : found by element \"%s\".\n"
msgstr "PRONAĐENA OZNAKA: pronašao element „%s”.\n"

#, c-format
msgid "FOUND TAG      : found by pad \"%s:%s\".\n"
msgstr "PRONAĐENA OZNAKA: pronašla podloga „%s:%s”.\n"

#, c-format
msgid "FOUND TAG      : found by object \"%s\".\n"
msgstr "PRONAĐENA OZNAKA: pronašao objekt „%s”.\n"

msgid "FOUND TAG\n"
msgstr "PRONAĐENA OZNAKA\n"

#, fuzzy, c-format
msgid "FOUND TOC      : found by element \"%s\".\n"
msgstr "PRONAĐENA OZNAKA: pronašao element „%s”.\n"

#, fuzzy, c-format
msgid "FOUND TOC      : found by object \"%s\".\n"
msgstr "PRONAĐENA OZNAKA: pronašao objekt „%s”.\n"

#, fuzzy
msgid "FOUND TOC\n"
msgstr "PRONAĐENA OZNAKA\n"

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

#, c-format
msgid "WARNING: from element %s: %s\n"
msgstr "UPOZORENJE: iz elementa %s: %s\n"

msgid "Prerolled, waiting for buffering to finish...\n"
msgstr ""

msgid "Prerolled, waiting for progress to finish...\n"
msgstr ""

msgid "buffering..."
msgstr "spremam u međuspremnik..."

msgid "Done buffering, setting pipeline to PLAYING ...\n"
msgstr "Gotovo spremanje u međuspremnik, postavljam cjevovod u PLAYING ...\n"

msgid "Buffering, setting pipeline to PAUSED ...\n"
msgstr "Spremam u međuspremnik, postavljam cjevovod u PAUSED ...\n"

msgid "Redistribute latency...\n"
msgstr "Preraspodjeljujem kašnjenje...\n"

#, c-format
msgid "Setting state to %s as requested by %s...\n"
msgstr "Postavljam stanje u %s kao što traži %s...\n"

msgid "Interrupt: Stopping pipeline ...\n"
msgstr "Prekid: Zaustavljam cjevovod ...\n"

#, c-format
msgid "Progress: (%s) %s\n"
msgstr ""

#, fuzzy, c-format
msgid "Missing element: %s\n"
msgstr "nema elementa „%s”"

#, fuzzy, c-format
msgid "Got context from element '%s': %s=%s\n"
msgstr "UPOZORENJE: iz elementa %s: %s\n"

msgid "Output tags (also known as metadata)"
msgstr "Izlazne oznake (poznate i kao metapodaci)"

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

msgid "Output status information and property notifications"
msgstr "Informacije o izlaznom stanju i obavijesti o svojstvima"

msgid "Do not print any progress information"
msgstr "Ne ispisuj informacije o napretku"

msgid "Output messages"
msgstr "Izlazne poruke"

msgid ""
"Do not output status information for the specified property if verbose "
"output is enabled (can be used multiple times)"
msgstr ""

msgid "PROPERTY-NAME"
msgstr ""

msgid "Do not install a fault handler"
msgstr "Nemoj instalirati rukovatelj grešaka"

msgid "Force EOS on sources before shutting the pipeline down"
msgstr "Prisili EOS na izvorima prije zatvaranja cjevovoda"

msgid "Gather and print index statistics"
msgstr "Skupi i ispiši statistike indeksa"

#, c-format
msgid "ERROR: pipeline could not be constructed: %s.\n"
msgstr "GREŠKA: ne mogu napraviti cjevovod: %s.\n"

msgid "ERROR: pipeline could not be constructed.\n"
msgstr "GREŠKA: ne mogu napraviti cjevovod.\n"

#, c-format
msgid "WARNING: erroneous pipeline: %s\n"
msgstr "UPOZORENJE: cjevovod sklon greškama: %s\n"

msgid "ERROR: the 'pipeline' element wasn't found.\n"
msgstr "GREŠKA: cjevovodni („pipeline”) element nije pronađen.\n"

msgid "Setting pipeline to PAUSED ...\n"
msgstr "Postavljam cjevovod u PAUSED ...\n"

msgid "ERROR: Pipeline doesn't want to pause.\n"
msgstr "GREŠKA: Cjevovod ne želi pauzirati.\n"

msgid "Pipeline is live and does not need PREROLL ...\n"
msgstr "Cjevovod je živ i ne traži PREROLL ...\n"

msgid "Pipeline is PREROLLING ...\n"
msgstr ""

msgid "ERROR: pipeline doesn't want to preroll.\n"
msgstr ""

msgid "Pipeline is PREROLLED ...\n"
msgstr ""

msgid "Setting pipeline to PLAYING ...\n"
msgstr "Postavljam cjevovod u PLAYING ...\n"

msgid "ERROR: pipeline doesn't want to play.\n"
msgstr "GREŠKA: cjevovod ne želi reproducirati.\n"

msgid "EOS on shutdown enabled -- Forcing EOS on the pipeline\n"
msgstr "EOS pri zatvaranju omogućen -- Prisiljavam EOS na cjevovodu\n"

#, fuzzy
msgid "EOS on shutdown enabled -- waiting for EOS after Error\n"
msgstr "EOS pri zatvaranju omogućen -- Prisiljavam EOS na cjevovodu\n"

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

msgid "EOS received - stopping pipeline...\n"
msgstr "EOS primljen - zaustavljam cjevovod...\n"

#, fuzzy
msgid "Interrupt while waiting for EOS - stopping pipeline...\n"
msgstr "Prekid: Zaustavljam cjevovod ...\n"

msgid "An error happened while waiting for EOS\n"
msgstr "Dogodila se greška pri čekanju EOS-a\n"

msgid "Execution ended after %"
msgstr "Izvršavanje završilo nakon %"

msgid "Setting pipeline to READY ...\n"
msgstr "Postavljam cjevovod u READY ...\n"

msgid "Setting pipeline to NULL ...\n"
msgstr "Postavljam cjevovod u NULL ...\n"

msgid "Freeing pipeline ...\n"
msgstr "Oslobađam cjevovod ...\n"

#~ msgid "Do not output status information of TYPE"
#~ msgstr "Ne ispisuj informacije navedene VRSTE o izlaznom stanju"

#~ msgid "TYPE1,TYPE2,..."
#~ msgstr "VRSTA1,VRSTA2,..."

#~ msgid "link without source element"
#~ msgstr "veza bez izvornog elementa"

#~ msgid "link without sink element"
#~ msgstr "veza bez prijamnog elementa"

#~ msgid "no element to link URI \"%s\" to"
#~ msgstr "nema elementa na koji će se povezati URI „%s”"

#~ msgid "could not link sink element for URI \"%s\""
#~ msgstr "ne mogu povezati prijamni element za URI „%s”"

#~ msgid "maximum"
#~ msgstr "najviše"

#~ msgid "Usage: gst-xmllaunch <file.xml> [ element.property=value ... ]\n"
#~ msgstr ""
#~ "Uporaba: gst-xmllaunch <datoteka.xml> [ element."
#~ "svojstvo=vrijednost ... ]\n"

#~ msgid "ERROR: parse of xml file '%s' failed.\n"
#~ msgstr "GREŠKA: analiza xml datoteke „%s” nije uspjela.\n"

#~ msgid "ERROR: no toplevel pipeline element in file '%s'.\n"
#~ msgstr "GREŠKA: ne postoji vršni element cjevovoda u datoteci „%s”.\n"

#~ msgid "WARNING: only one toplevel element is supported at this time.\n"
#~ msgstr "UPOZORENJE: trenutno je podržan samo jedan vršni element.\n"

#~ msgid "ERROR: could not parse command line argument %d: %s.\n"
#~ msgstr "GREŠKA: ne mogu analizirati argument naredbenog retka %d: %s.\n"

#~ msgid "WARNING: element named '%s' not found.\n"
#~ msgstr "UPOZORENJE: element „%s” nije pronađen.\n"

#~ msgid "Save xml representation of pipeline to FILE and exit"
#~ msgstr "Spremi xml prikaz cjevovoda u DATOTEKU i izađi"

#~ msgid "FILE"
#~ msgstr "DATOTEKA"

#~ msgid "Do not install signal handlers for SIGUSR1 and SIGUSR2"
#~ msgstr "Nemoj instalirati rukovatelj signala za SIGUSR1 i SIGUSR2"

#~ msgid "Print alloc trace (if enabled at compile time)"
#~ msgstr "Ispiši alloc praćenje (ako je omogućeno pri kompajliranju)"
