# Translation of gst-plugins-bad to Croatian.
# This file is put in the public domain.
#
# Tomislav Krznar <tomislav.krznar@gmail.com>, 2012.
# Božidar Putanec <bozidarp@yahoo.com>, 2016.
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-bad-1.12.0\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2017-07-14 13:33+0300\n"
"PO-Revision-Date: 2017-05-04 16:35-0700\n"
"Last-Translator: Božidar Putanec <bozidarp@yahoo.com>\n"
"Language-Team: Croatian <lokalizacija@linux.hr>\n"
"Language: hr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
"X-Generator: Poedit 1.8.7.1\n"

msgid "failed to draw pattern"
msgstr "crtanje uzorka nije uspjelo"

msgid "A GL error occured"
msgstr "Dogodila se GL greška"

msgid "format wasn't negotiated before get function"
msgstr "format nije bio dogovoren prije ‘get’ funkcije"

msgid "OpenCV failed to load template image"
msgstr "OpenCV nije uspio učitati predložak slike"

msgid "Could not read title information for DVD."
msgstr "Iz naslova se ne mogu pročitati informacije o DVD-u"

#, c-format
msgid "Failed to open DVD device '%s'."
msgstr "Nije uspjelo otvoriti DVD uređaj ‘%s’."

msgid "Failed to set PGC based seeking."
msgstr "Pretraga temeljena na PGC-u nije uspjela."

msgid ""
"Could not read DVD. This may be because the DVD is encrypted and a DVD "
"decryption library is not installed."
msgstr ""
"DVD nije moguće pročitati. DVD je možda kriptiran, a biblioteka za "
"dekriptiranje DVD-a nije instalirana."

msgid "Could not read DVD."
msgstr "DVD nije moguće pročitati."

msgid "This file contains no playable streams."
msgstr ""
"Ova datoteka ne sadrži nijedan upotrebljivi stream (tok podataka koji bi se "
"mogao reproducirati)."

msgid "Could not open sndfile stream for reading."
msgstr "‘sndfile’ stream (tok podataka) nije moguće otvoriti za čitanje."

msgid "Generated file has a larger preroll time than its streams duration"
msgstr ""
"U generiranoj datoteci priprema (preroll vrijeme) je duža od ukupnog "
"trajanja streama (toka podataka)"

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr "Nedostaje element ‘%s’ - provjerite vašu GStreamer instalaciju."

msgid "File location is set to NULL, please set it to a valid filename"
msgstr "Lokacija datoteke je prazna (NULL); navedite valjani naziv datoteke"

msgid "Digitalzoom element couldn't be created"
msgstr "Nije moguće napraviti (kreirati) element za Digitalzoom"

msgid "Subpicture format was not configured before data flow"
msgstr ""
"Format podslike (subpicture) nije bio konfiguriran prije protoka podataka"

msgid "Failed to get fragment URL."
msgstr "Nije uspjelo dobiti fragmente adrese URL-a."

msgid "Couldn't download fragments"
msgstr "Nije moguće preuzeti fragmente"

msgid "Internal data stream error."
msgstr "Interna greška toka (stream) podataka."

#, c-format
msgid "Device \"%s\" does not exist."
msgstr "Uređaj „%s“ ne postoji."

# http://whatis.techtarget.com/definition/front-end
#, c-format
msgid "Could not open frontend device \"%s\"."
msgstr "Sučelje (frontend) uređaja „%s“ nije moguće otvoriti."

#, c-format
msgid "Could not get settings from frontend device \"%s\"."
msgstr "Od sučelja (frontend) uređaja „%s“ nije moguće dobiti postavke."

#, c-format
msgid "Cannot enumerate delivery systems from frontend device \"%s\"."
msgstr ""
"Dostavne sustave nije moguće nabrojati iz sučelja (frontend) uređaja „%s“."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Datoteku „%s“ nije moguće otvoriti za čitanje."

msgid "Couldn't find channel configuration file"
msgstr "Konfiguracijska datoteka kanala nije pronađena"

#, c-format
msgid "Couldn't load channel configuration file: '%s'"
msgstr "Neuspjeh pri učitavanju konfiguracijske datoteke kanala: ‘%s’"

#, c-format
msgid "Couldn't find details for channel '%s'"
msgstr "Pojedinosti za kanal ‘%s’ nisu nađene"

#, c-format
msgid "No properties for channel '%s'"
msgstr "Svojstva za kanal ‘%s’ nisu nađena"

#, c-format
msgid "Failed to set properties for channel '%s'"
msgstr "Nije uspjelo postaviti svojstva za kanal ‘%s’"

#, c-format
msgid "Couldn't find channel configuration file: '%s'"
msgstr "Nije nađena konfiguracijska datoteka kanala: ‘%s’"

msgid "Channel configuration file doesn't contain any channels"
msgstr "Konfiguracijska datoteka za kanala ne sadrži niti jedan kanal"

#~ msgid "Could not establish connection to sndio"
#~ msgstr "Spajanje na ‘sndio’ nije moguće uspostaviti"

#~ msgid "Failed to query sndio capabilities"
#~ msgstr "Nije uspjelo ispitati ‘sndio’ mogućnosti"

#~ msgid "Could not configure sndio"
#~ msgstr "‘sndio’ nije moguće konfigurirati"

#~ msgid "Could not start sndio"
#~ msgstr "‘sndio’ nije moguće pokrenuti"

#~ msgid "No file name specified for writing."
#~ msgstr "Nedostaje naziv (nema ga) datoteke za pisanje."

#~ msgid ""
#~ "Given file name \"%s\" can't be converted to local file name encoding."
#~ msgstr ""
#~ "Naziv datoteke „%s“ ne može se pretvoriti u lokalno kodirane naziva "
#~ "datoteka."

#~ msgid "Could not open file \"%s\" for writing."
#~ msgstr "Datoteku „%s“ nije moguće otvoriti za pisanje."

#~ msgid "Internal data flow error."
#~ msgstr "Interna greška u protoku podataka."

#~ msgid "Could not write to file \"%s\"."
#~ msgstr "Ne mogu pisati u datoteku „%s”."
