# Italian translation for gst-plugins-base package of GStreamer project.
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 GStreamer team
# This file is distributed under the same license as the gst-plugins-base package.
# Luca Ferretti <elle.uca@infinito.it>, 2004, 2005, 2006, 2007, 2008, 2009, 2010.
#
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-base 0.10.28.2\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2017-02-23 15:14+0200\n"
"PO-Revision-Date: 2010-04-28 14:27+0200\n"
"Last-Translator: Luca Ferretti <elle.uca@infinito.it>\n"
"Language-Team: Italian <tp@lists.linux.it>\n"
"Language: it\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

msgid "Could not open device for playback in mono mode."
msgstr "Impossibile aprire il device per la riproduzione in modalità mono."

msgid "Could not open device for playback in stereo mode."
msgstr "Impossibile aprire il device per la riproduzione in modalità stereo."

#, c-format
msgid "Could not open device for playback in %d-channel mode."
msgstr ""
"Impossibile aprire il device per la riproduzione in modalità %d-canali."

msgid ""
"Could not open audio device for playback. Device is being used by another "
"application."
msgstr ""
"Impossibile aprire il device audio per la riproduzione. Il device è "
"utilizzato da un'altra applicazione."

msgid "Could not open audio device for playback."
msgstr "Impossibile aprire il device audio per la riproduzione."

msgid "Error outputting to audio device. The device has been disconnected."
msgstr ""

msgid "Could not open device for recording in mono mode."
msgstr "Impossibile aprire il device per la registrazione in modalità mono."

msgid "Could not open device for recording in stereo mode."
msgstr "Impossibile aprire il device per la registrazione in modalità stereo."

#, c-format
msgid "Could not open device for recording in %d-channel mode"
msgstr ""
"Impossibile aprire il device per la registrazione in modalità %d-canali."

msgid ""
"Could not open audio device for recording. Device is being used by another "
"application."
msgstr ""
"Impossibile aprire il device audio per la registrazione. Il device è "
"utilizzato da un'altra applicazione."

msgid "Could not open audio device for recording."
msgstr "Impossibile aprire il device audio per la registrazione."

msgid "Error recording from audio device. The device has been disconnected."
msgstr ""

msgid "Could not open CD device for reading."
msgstr "Impossibile aprire il device CD in lettura."

# seek --> posizionamento (come in glib/gio)
msgid "Could not seek CD."
msgstr "Impossibile effettuare il posizionamento nel CD."

msgid "Could not read CD."
msgstr "Impossibile leggere il CD."

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr ""
"Risulta mancante l'elemento «%s» - verificare la propria installazione di "
"GStreamer."

msgid "Could not determine type of stream"
msgstr "Impossibile determinare il tipo di stream"

msgid "This appears to be a text file"
msgstr "Questo sembra essere un file di testo"

#, fuzzy
msgid "Could not create \"uridecodebin\" element."
msgstr "Impossibile creare l'elemento «decodebin»."

#, fuzzy
msgid "Could not create \"decodebin3\" element."
msgstr "Impossibile creare l'elemento «decodebin»."

#, fuzzy
msgid "Could not create \"urisourcebin\" element."
msgstr "Impossibile creare l'elemento «decodebin»."

#, c-format
msgid "Both autovideosink and %s elements are missing."
msgstr "Risultano mancanti entrambi gli elementi «autovideosink» e «%s»."

msgid "The autovideosink element is missing."
msgstr "Risulta mancante l'elemento «autovideosink»."

#, c-format
msgid "Configured videosink %s is not working."
msgstr "L'elemento videosink «%s» non è operativo."

#, c-format
msgid "Both autovideosink and %s elements are not working."
msgstr "Entrambi gli elementi «autovideosink» e «%s» non sono operativi."

msgid "The autovideosink element is not working."
msgstr "L'elemento «autovideosink» non è operativo."

msgid "Custom text sink element is not usable."
msgstr "L'elemento sink di testo personalizzato non è utilizzabile."

msgid "No volume control found"
msgstr "Non è stato trovato alcun controllo del volume"

#, c-format
msgid "Both autoaudiosink and %s elements are missing."
msgstr "Risultano mancanti entrambi gli elementi «autoaudiosink» e «%s»."

msgid "The autoaudiosink element is missing."
msgstr "Risulta mancante l'elemento «autoaudiosink»."

#, c-format
msgid "Configured audiosink %s is not working."
msgstr "L'elemento audiosink «%s» non è operativo."

#, c-format
msgid "Both autoaudiosink and %s elements are not working."
msgstr "Entrambi gli elementi «autoaudiosink» e «%s» non sono operativi."

msgid "The autoaudiosink element is not working."
msgstr "L'elemento «autoaudiosink» non è operativo."

msgid "Can't play a text file without video or visualizations."
msgstr "Impossibile riprodurre un file di testo senza video o visualizzazioni."

#, c-format
msgid "No decoder available for type '%s'."
msgstr "Nessun decoder disponibile per il tipo «%s»."

msgid "No URI specified to play from."
msgstr "Non è stato specificato alcun URI da cui riprodurre."

#, c-format
msgid "Invalid URI \"%s\"."
msgstr "URI «%s» non valido."

msgid "This stream type cannot be played yet."
msgstr "Non è ancora possibile riprodurre questo tipo di stream."

#, c-format
msgid "No URI handler implemented for \"%s\"."
msgstr "Nessun gestore di URI implementato per «%s»."

msgid "Source element is invalid."
msgstr "L'elemento sorgente non è valido."

#, c-format
msgid "Error while sending data to \"%s:%d\"."
msgstr "Errore durante l'invio dei dati a \"%s:%d\"."

# una parafrasi, ma mi pare non perda...  -Luca
msgid "Can't record audio fast enough"
msgstr "Impossibile registrare l'audio a velocità adeguata"

msgid "This CD has no audio tracks"
msgstr "Questo CD non presenta alcuna traccia audio"

msgid "ID3 tag"
msgstr "Tag ID3"

msgid "APE tag"
msgstr "Tag APE"

msgid "ICY internet radio"
msgstr "Radio internet ICY"

msgid "Apple Lossless Audio (ALAC)"
msgstr "ALAC (Apple Lossless Audio)"

msgid "Free Lossless Audio Codec (FLAC)"
msgstr "FLAC (Free Lossless Audio Codec)"

msgid "Lossless True Audio (TTA)"
msgstr "TTA (Lossless True Audio)"

msgid "Windows Media Speech"
msgstr "Windows Media Speech"

msgid "CYUV Lossless"
msgstr "CYUV senza perdita"

msgid "FFMpeg v1"
msgstr "FFMpeg v1"

msgid "Lossless MSZH"
msgstr "MSZH senza perdita"

# cfr http://en.wikipedia.org/wiki/Run_length_encoding
msgid "Run-length encoding"
msgstr "RLE (Run-Length Encoding)"

msgid "Timed Text"
msgstr ""

msgid "Subtitle"
msgstr ""

#, fuzzy
msgid "MPL2 subtitle format"
msgstr "Sottotitoli formato TMPlayer"

# grazie San Google
#, fuzzy
msgid "DKS subtitle format"
msgstr "Sottotitoli formato SAMI"

#, fuzzy
msgid "QTtext subtitle format"
msgstr "Sottotitoli formato Kate"

# grazie San Google
msgid "Sami subtitle format"
msgstr "Sottotitoli formato SAMI"

msgid "TMPlayer subtitle format"
msgstr "Sottotitoli formato TMPlayer"

msgid "Kate subtitle format"
msgstr "Sottotitoli formato Kate"

#, fuzzy
msgid "WebVTT subtitle format"
msgstr "Sottotitoli formato Kate"

#, fuzzy
msgid "Uncompressed video"
msgstr "YUV non compresso"

# non ho trovato info utili...
# Copiato il messaggio originale solo per arrivare a 100 per cento
#, fuzzy
msgid "Uncompressed gray"
msgstr "Uncompressed Gray Image"

#, fuzzy, c-format
msgid "Uncompressed packed YUV %s"
msgstr "YUV 4:2:2 packed non compresso"

# cfr http://en.wikipedia.org/wiki/YUV
#     http://support.microsoft.com/kb/281188/it
#     http://support.microsoft.com/kb/294880/it (traduz automatica) :-(
#     http://www.benis.it/dvd/agg3.htm
#
# Dal secondo e terzo, evinco YUV compresso o planare sarebbero
# buone abbreviazioni, ma tengo planare/packed + compresso/noncompresso
#, fuzzy, c-format
msgid "Uncompressed semi-planar YUV %s"
msgstr "YUV 4:2:0 planare non compresso"

# cfr http://en.wikipedia.org/wiki/YUV
#     http://support.microsoft.com/kb/281188/it
#     http://support.microsoft.com/kb/294880/it (traduz automatica) :-(
#     http://www.benis.it/dvd/agg3.htm
#
# Dal secondo e terzo, evinco YUV compresso o planare sarebbero
# buone abbreviazioni, ma tengo planare/packed + compresso/noncompresso
#, fuzzy, c-format
msgid "Uncompressed planar YUV %s"
msgstr "YUV 4:2:0 planare non compresso"

# %s è qualcosa come gli YUV dei precedenti
#
# Non so perché, ma senza X$ non lo dava buono....
#, fuzzy, c-format
msgid "Uncompressed palettized %d-bit %s"
msgstr "%2$s %1$d-bit con tavolozza non compresso"

# %s è qualcosa come gli YUV dei precedenti
#
# Non so perché, ma senza X$ non lo dava buono....
#, fuzzy, c-format
msgid "Uncompressed %d-bit %s"
msgstr "%2$s %1$d-bit con tavolozza non compresso"

# o MPEG-4 DivX ?
#, c-format
msgid "DivX MPEG-4 Version %d"
msgstr "DivX MPEG-4 versione %d"

#, fuzzy
msgid "Uncompressed audio"
msgstr "YUV non compresso"

# o audio grezzo ?
#, fuzzy, c-format
msgid "Raw %d-bit %s audio"
msgstr "Audio raw PCM %d-bit"

msgid "Audio CD source"
msgstr "Sorgente CD audio"

msgid "DVD source"
msgstr "Sorgente DVD"

msgid "Real Time Streaming Protocol (RTSP) source"
msgstr "Sorgente RTSP (Real Time Streaming Protocol)"

msgid "Microsoft Media Server (MMS) protocol source"
msgstr "Sorgente protocollo MMS (Microsoft Media Server)"

#, c-format
msgid "%s protocol source"
msgstr "Sorgente protocollo %s"

#, c-format
msgid "%s video RTP depayloader"
msgstr "Depayloader RTP %s video"

#, c-format
msgid "%s audio RTP depayloader"
msgstr "Depayloader RTP %s audio"

#, c-format
msgid "%s RTP depayloader"
msgstr "Depayloader RTP %s"

#, c-format
msgid "%s demuxer"
msgstr "Demuxer %s"

#, c-format
msgid "%s decoder"
msgstr "Decoder %s"

#, c-format
msgid "%s video RTP payloader"
msgstr "Payloader RTP %s video"

#, c-format
msgid "%s audio RTP payloader"
msgstr "Payloader RTP %s audio"

#, c-format
msgid "%s RTP payloader"
msgstr "Payloader RTP %s"

#, c-format
msgid "%s muxer"
msgstr "Muxer %s"

#, c-format
msgid "%s encoder"
msgstr "Encoder %s"

#, c-format
msgid "GStreamer element %s"
msgstr "Elemento GStreamer %s"

msgid "Unknown source element"
msgstr "Elemento sorgente sconosciuto"

msgid "Unknown sink element"
msgstr "Elemento sink sconosciuto"

msgid "Unknown element"
msgstr "Elemento sconosciuto"

msgid "Unknown decoder element"
msgstr "Elemendo di decodifica sconosciuto"

msgid "Unknown encoder element"
msgstr "Elemento di codifica sconosciuto"

msgid "Plugin or element of unknown type"
msgstr "Plugin o elemento di tipo sconosciuto"

# dati non sufficienti... mah
msgid "Failed to read tag: not enough data"
msgstr "Lettura del tag non riuscita: non abbastanza dati"

msgid "track ID"
msgstr "ID traccia"

msgid "MusicBrainz track ID"
msgstr "ID MusicBrainz della traccia"

msgid "artist ID"
msgstr "ID artista"

msgid "MusicBrainz artist ID"
msgstr "ID MusicBrainz dell'artista"

msgid "album ID"
msgstr "ID album"

msgid "MusicBrainz album ID"
msgstr "ID MusicBrainz dell'album"

msgid "album artist ID"
msgstr "ID artista dell'album"

msgid "MusicBrainz album artist ID"
msgstr "ID MusicBrainz dell'artista dell'album"

msgid "track TRM ID"
msgstr "ID TRM della traccia"

msgid "MusicBrainz TRM ID"
msgstr "ID MusicBrainz del TRM"

msgid "capturing shutter speed"
msgstr ""

msgid "Shutter speed used when capturing an image, in seconds"
msgstr ""

msgid "capturing focal ratio"
msgstr ""

msgid "Focal ratio (f-number) used when capturing the image"
msgstr ""

msgid "capturing focal length"
msgstr ""

msgid "Focal length of the lens used capturing the image, in mm"
msgstr ""

msgid "capturing 35 mm equivalent focal length"
msgstr ""

msgid ""
"35 mm equivalent focal length of the lens used capturing the image, in mm"
msgstr ""

msgid "capturing digital zoom ratio"
msgstr ""

msgid "Digital zoom ratio used when capturing an image"
msgstr ""

msgid "capturing iso speed"
msgstr ""

msgid "The ISO speed used when capturing an image"
msgstr ""

msgid "capturing exposure program"
msgstr ""

msgid "The exposure program used when capturing an image"
msgstr ""

msgid "capturing exposure mode"
msgstr ""

msgid "The exposure mode used when capturing an image"
msgstr ""

msgid "capturing exposure compensation"
msgstr ""

msgid "The exposure compensation used when capturing an image"
msgstr ""

msgid "capturing scene capture type"
msgstr ""

msgid "The scene capture mode used when capturing an image"
msgstr ""

msgid "capturing gain adjustment"
msgstr ""

msgid "The overall gain adjustment applied on an image"
msgstr ""

msgid "capturing white balance"
msgstr ""

msgid "The white balance mode set when capturing an image"
msgstr ""

msgid "capturing contrast"
msgstr ""

msgid "The direction of contrast processing applied when capturing an image"
msgstr ""

msgid "capturing saturation"
msgstr ""

msgid "The direction of saturation processing applied when capturing an image"
msgstr ""

msgid "capturing sharpness"
msgstr ""

msgid "The direction of sharpness processing applied when capturing an image"
msgstr ""

msgid "capturing flash fired"
msgstr ""

msgid "If the flash fired while capturing an image"
msgstr ""

msgid "capturing flash mode"
msgstr ""

msgid "The selected flash mode while capturing an image"
msgstr ""

msgid "capturing metering mode"
msgstr ""

msgid ""
"The metering mode used while determining exposure for capturing an image"
msgstr ""

msgid "capturing source"
msgstr ""

msgid "The source or type of device used for the capture"
msgstr ""

msgid "image horizontal ppi"
msgstr ""

msgid "Media (image/video) intended horizontal pixel density in ppi"
msgstr ""

msgid "image vertical ppi"
msgstr ""

msgid "Media (image/video) intended vertical pixel density in ppi"
msgstr ""

msgid "ID3v2 frame"
msgstr ""

msgid "unparsed id3v2 tag frame"
msgstr ""

msgid "musical-key"
msgstr ""

msgid "Initial key in which the sound starts"
msgstr ""

msgid "Print version information and exit"
msgstr ""

msgid ""
"Don't exit after showing the initial device list, but wait for devices to "
"added/removed."
msgstr ""

#, c-format
msgid "Volume: %.0f%%"
msgstr ""

msgid "Buffering..."
msgstr ""

msgid "Clock lost, selecting a new one\n"
msgstr ""

msgid "Reached end of play list."
msgstr ""

msgid "Paused"
msgstr ""

#, c-format
msgid "Now playing %s\n"
msgstr ""

#, c-format
msgid "About to finish, preparing next title: %s"
msgstr ""

#, c-format
msgid "Playback rate: %.2f"
msgstr ""

#, fuzzy, c-format
msgid "Could not change playback rate to %.2f"
msgstr "Impossibile aprire il device per la riproduzione in modalità stereo."

msgid "space"
msgstr ""

msgid "pause/unpause"
msgstr ""

msgid "q or ESC"
msgstr ""

msgid "quit"
msgstr ""

msgid "> or n"
msgstr ""

msgid "play next"
msgstr ""

msgid "< or b"
msgstr ""

msgid "play previous"
msgstr ""

msgid "seek forward"
msgstr ""

msgid "seek backward"
msgstr ""

msgid "volume up"
msgstr ""

msgid "volume down"
msgstr ""

msgid "increase playback rate"
msgstr ""

msgid "decrease playback rate"
msgstr ""

msgid "change playback direction"
msgstr ""

msgid "enable/disable trick modes"
msgstr ""

#, fuzzy
msgid "change audio track"
msgstr "Questo CD non presenta alcuna traccia audio"

msgid "change video track"
msgstr ""

#, fuzzy
msgid "change subtitle track"
msgstr "Sottotitoli formato Kate"

msgid "seek to beginning"
msgstr ""

msgid "show keyboard shortcuts"
msgstr ""

msgid "Interactive mode - keyboard controls:"
msgstr ""

msgid "Output status information and property notifications"
msgstr ""

msgid "Control playback behaviour setting playbin 'flags' property"
msgstr ""

msgid "Video sink to use (default is autovideosink)"
msgstr ""

msgid "Audio sink to use (default is autoaudiosink)"
msgstr ""

msgid "Enable gapless playback"
msgstr ""

msgid "Shuffle playlist"
msgstr ""

msgid "Disable interactive control via the keyboard"
msgstr ""

msgid "Volume"
msgstr ""

msgid "Playlist file containing input media files"
msgstr ""

msgid "Do not print any output (apart from errors)"
msgstr ""

#, c-format
msgid "Usage: %s FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ..."
msgstr ""

msgid "You must provide at least one filename or URI to play."
msgstr ""

msgid "Press 'k' to see a list of keyboard shortcuts.\n"
msgstr ""

#~ msgid "Internal data stream error."
#~ msgstr "Errore interno nel flusso di dati."

#~ msgid "A %s plugin is required to play this stream, but not installed."
#~ msgstr ""
#~ "Per riprodurre questo stream è richiesto un plugin %s, che però non "
#~ "risulta installato. "

#, fuzzy
#~ msgid "Uncompressed %s YUV %s"
#~ msgstr "YUV non compresso"

#~ msgid "Master"
#~ msgstr "Principale"

#~ msgid "Bass"
#~ msgstr "Bassi"

#~ msgid "Treble"
#~ msgstr "Acuti"

#~ msgid "PCM"
#~ msgstr "PCM"

#~ msgid "Synth"
#~ msgstr "Sintetiz"

#~ msgid "Line-in"
#~ msgstr "Linea in"

#~ msgid "CD"
#~ msgstr "CD"

#~ msgid "Microphone"
#~ msgstr "Microfono"

#~ msgid "PC Speaker"
#~ msgstr "Altoparlanti PC"

#~ msgid "Playback"
#~ msgstr "Riproduzione"

#~ msgid "Capture"
#~ msgstr "Cattura"

#~ msgid "Connection to %s:%d refused."
#~ msgstr "Connessione a %s:%d rifiutata."

#~ msgid "Uncompressed planar YVU 4:2:0"
#~ msgstr "YVU 4:2:0 planare non compresso"

#~ msgid "Uncompressed packed YUV 4:1:0"
#~ msgstr "YUV 4:1:0 packed non compresso"

#~ msgid "Uncompressed packed YVU 4:1:0"
#~ msgstr "YVU 4:1:0 packed non compresso"

#~ msgid "Uncompressed packed YUV 4:1:1"
#~ msgstr "YUV 4:1:1 packed non compresso"

#~ msgid "Uncompressed packed YUV 4:4:4"
#~ msgstr "YUV 4:4:4 packed non compresso"

#~ msgid "Uncompressed planar YUV 4:2:2"
#~ msgstr "YUV 4:2:2 planare non compresso"

#~ msgid "Uncompressed planar YUV 4:1:1"
#~ msgstr "YUV 4:1:1 planare non compresso"

#~ msgid "Uncompressed black and white Y-plane"
#~ msgstr "Bianco e nero Y-plane non compresso"

#~ msgid "Raw PCM audio"
#~ msgstr "Audio raw PCM"

#~ msgid "Raw %d-bit floating-point audio"
#~ msgstr "Audio raw floating-point %d-bit"

#~ msgid "Raw floating-point audio"
#~ msgstr "Audio raw floating-point"

#~ msgid "Could not open vfs file \"%s\" for writing: %s."
#~ msgstr "Impossibile aprire il file vfs «%s» in scrittura: %s."

#~ msgid "No filename given"
#~ msgstr "Nessun nome di file fornito"

#~ msgid "Could not close vfs file \"%s\"."
#~ msgstr "Impossibile chiudere il file vfs «%s»."

#~ msgid "Error while writing to file \"%s\"."
#~ msgstr "Errore durante la scrittura sul file «%s»."

#~ msgid "Invalid subtitle URI \"%s\", subtitles disabled."
#~ msgstr "URI dei sottotitoli «%s» non valido, sottotitoli disabilitati."

#~ msgid "RTSP streams cannot be played yet."
#~ msgstr "Non è ancora possibile riprodurre gli stream RTSP."

#~ msgid ""
#~ "Only a subtitle stream was detected. Either you are loading a subtitle "
#~ "file or some other type of text file, or the media file was not "
#~ "recognized."
#~ msgstr ""
#~ "È stato rilevato unicamente uno stream di sottotitoli. Ciò significa che "
#~ "si sta caricando un file di sottotitoli o un altro tipo di file di testo, "
#~ "oppure che il file multimediale non è stato riconosciuto."

#~ msgid ""
#~ "You do not have a decoder installed to handle this file. You might need "
#~ "to install the necessary plugins."
#~ msgstr ""
#~ "Non risulta installato alcun decoder in grado di gestire questo file. "
#~ "Potrebbe essere necessario installare gli opportuni plugin."

#~ msgid "This is not a media file"
#~ msgstr "Questo non è un file multimediale"

#~ msgid "A subtitle stream was detected, but no video stream."
#~ msgstr ""
#~ "È stato rilevato uno stream di sottotitoli, ma nessuno stream video."

#~ msgid "Both autovideosink and xvimagesink elements are missing."
#~ msgstr ""
#~ "Risultano mancanti entrambi gli elementi «autovideosink» e «xvimagesink»."

#~ msgid "Both autoaudiosink and alsasink elements are missing."
#~ msgstr ""
#~ "Risultano mancanti entrambi gli elementi «autoaudiosink» e «alsasink»."

#~ msgid "No device specified."
#~ msgstr "Nessun device specificato."

#~ msgid "Device \"%s\" does not exist."
#~ msgstr "Il device «%s» non esiste."

#~ msgid "Device \"%s\" is already being used."
#~ msgstr "Il device «%s» è già in uso."

#~ msgid "Could not open device \"%s\" for reading and writing."
#~ msgstr "Impossibile aprire il device «%s» in lettura e scrittura."

#~ msgid "Error while sending gdp header data to \"%s:%d\"."
#~ msgstr "Errore durante l'invio di dati header gdp a \"%s:%d\"."

#~ msgid "Error while sending gdp payload data to \"%s:%d\"."
#~ msgstr "Errore durante l'invio di dati payload gdp a \"%s:%d\"."
