# Catalan translation of gst-plugins-base.
# Copyright © 2005, 2010 Free Software Foundation, Inc.
# This file is put in the public domain.
# Jordi Mallach <jordi@sindominio.net>, 2005, 2010.
# Jordi Estrada <jordi.estrada@yamaha-motor.es>, 2011.
# Gil Forcada <gforcada@gnome.org>, 2012.
#
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-base 0.10.32.2\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2012-05-13 16:19+0200\n"
"PO-Revision-Date: 2012-01-01 14:19+0100\n"
"Last-Translator: Gil Forcada <gforcada@gnome.org>\n"
"Language-Team: Catalan <ca@dodds.net>\n"
"Language: ca\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"

msgid "Could not open device for playback in mono mode."
msgstr "No s'ha pogut obrir el dispositiu per a la reproducció en mode mono."

msgid "Could not open device for playback in stereo mode."
msgstr ""
"No s'ha pogut obrir el dispositiu per a la reproducció en mode estèreo."

#, c-format
msgid "Could not open device for playback in %d-channel mode."
msgstr ""
"No s'ha pogut obrir el dispositiu per a la reproducció en mode %d-canals."

msgid ""
"Could not open audio device for playback. Device is being used by another "
"application."
msgstr ""
"No s'ha pogut obrir el dispositiu d'àudio per a la reproducció. El "
"dispositiu està en ús per una altra aplicació."

msgid "Could not open audio device for playback."
msgstr "No s'ha pogut obrir el dispositiu d'àudio per a la reproducció."

msgid "Could not open device for recording in mono mode."
msgstr "No s'ha pogut obrir el dispositiu per a l'enregistrament en mode mono."

msgid "Could not open device for recording in stereo mode."
msgstr ""
"No s'ha pogut obrir el dispositiu per a l'enregistrament en mode estèreo."

#, c-format
msgid "Could not open device for recording in %d-channel mode"
msgstr ""
"No s'ha pogut obrir el dispositiu per a l'enregistrament en mode %d-canals"

msgid ""
"Could not open audio device for recording. Device is being used by another "
"application."
msgstr ""
"No s'ha pogut obrir el dispositiu d'àudio per a l'enregistrament. El "
"dispositiu està en ús per una altra aplicació."

msgid "Could not open audio device for recording."
msgstr "No s'ha pogut obrir el dispositiu d'àudio per a l'enregistrament."

msgid "Could not open CD device for reading."
msgstr "No s'ha pogut obrir el dispositiu del CD per a la lectura."

msgid "Could not seek CD."
msgstr "No s'ha pogut cercar el CD."

msgid "Could not read CD."
msgstr "No s'ha pogut llegir el CD."

msgid "Internal data stream error."
msgstr "S'ha produït un error intern de flux de dades."

#, c-format
msgid "A %s plugin is required to play this stream, but not installed."
msgstr ""
"Es requereix un connector %s per a reproduir aquest flux, però no és "
"instaŀlat."

msgid "Could not determine type of stream"
msgstr "No s'ha pogut determinar el tipus de flux"

msgid "This appears to be a text file"
msgstr "Això sembla ser un fitxer de text"

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr "Manca l'element «%s» - comproveu la vostra instaŀlació del GStreamer."

#, c-format
msgid "Both autovideosink and %s elements are missing."
msgstr "Manquen els elements autovideosink i %s."

msgid "The autovideosink element is missing."
msgstr "Manca l'element autovideosink."

#, c-format
msgid "Configured videosink %s is not working."
msgstr "El videosink configurat %s no funciona."

#, c-format
msgid "Both autovideosink and %s elements are not working."
msgstr "Els elements autovideosink i %s no funcionen."

msgid "The autovideosink element is not working."
msgstr "L'element autovideosink no funciona."

msgid "Custom text sink element is not usable."
msgstr "L'element sortida de text personalitzat no es pot utilitzar."

msgid "No volume control found"
msgstr "No s'ha trobat un control de volum"

#, c-format
msgid "Both autoaudiosink and %s elements are missing."
msgstr "Manquen els elements autoaudiosink i %s."

msgid "The autoaudiosink element is missing."
msgstr "Manca l'element autoaudiosink."

#, c-format
msgid "Configured audiosink %s is not working."
msgstr "L'audiosink configurat %s no funciona."

#, c-format
msgid "Both autoaudiosink and %s elements are not working."
msgstr "Els elements autoaudiosink i %s no funcionen."

msgid "The autoaudiosink element is not working."
msgstr "L'element autoaudiosink no funciona."

msgid "Can't play a text file without video or visualizations."
msgstr "No es pot reproduir un fitxer de text sense vídeo o visualitzacions."

#, c-format
msgid "No decoder available for type '%s'."
msgstr "No hi ha cap descodificador disponible per al tipus «%s»."

msgid "No URI specified to play from."
msgstr "No s'ha especificat cap URI des d'on reproduir."

#, c-format
msgid "Invalid URI \"%s\"."
msgstr "L'URI «%s» no és vàlid."

msgid "This stream type cannot be played yet."
msgstr "Encara no es pot reproduir aquest tipus de flux."

#, c-format
msgid "No URI handler implemented for \"%s\"."
msgstr "No hi ha cap gestor d'URI implementat per a «%s»."

msgid "Source element is invalid."
msgstr "L'element font no és vàlid."

#, c-format
msgid "Error while sending data to \"%s:%d\"."
msgstr "S'ha produït un error en enviar dades a «%s:%d»."

msgid "This CD has no audio tracks"
msgstr "Aquest CD no té pistes d'àudio"

msgid "Can't record audio fast enough"
msgstr "No es pot enregistrar l'àudio el suficientment ràpid"

msgid "Failed to read tag: not enough data"
msgstr "No s'ha pogut llegir l'etiqueta: no hi ha dades suficients"

msgid "track ID"
msgstr "ID de la pista"

msgid "MusicBrainz track ID"
msgstr "ID de la pista al MusicBrainz"

msgid "artist ID"
msgstr "ID de l'artista"

msgid "MusicBrainz artist ID"
msgstr "ID de l'artista al MusicBrainz"

msgid "album ID"
msgstr "ID de l'àlbum"

msgid "MusicBrainz album ID"
msgstr "ID de l'àlbum al MusicBrainz"

msgid "album artist ID"
msgstr "ID de l'artista de l'àlbum"

msgid "MusicBrainz album artist ID"
msgstr "ID de l'artista de l'àlbum al MusicBrainz"

msgid "track TRM ID"
msgstr "ID TRM de la pista"

msgid "MusicBrainz TRM ID"
msgstr "ID TRM al MusicBrainz"

msgid "capturing shutter speed"
msgstr "velocitat d'obturació de la captura"

msgid "Shutter speed used when capturing an image, in seconds"
msgstr "Velocitat d'obturació utilitzat en capturar una imatge, en segons"

msgid "capturing focal ratio"
msgstr "relació focal de la captura"

msgid "Focal ratio (f-number) used when capturing the image"
msgstr "Relació focal (nombre f) utilitzat en capturar la imatge"

msgid "capturing focal length"
msgstr "longitud focal de la captura"

msgid "Focal length of the lens used capturing the image, in mm"
msgstr "Longitud focal de la lent utilitzada en capturar la imatge, en mm"

msgid "capturing digital zoom ratio"
msgstr "relació de zoom digital de la captura"

msgid "Digital zoom ratio used when capturing an image"
msgstr "Relació de zoom digital utilitzat en capturar una imatge"

msgid "capturing iso speed"
msgstr "velocitat iso de la captura"

msgid "The ISO speed used when capturing an image"
msgstr "La velocitat ISO utilitzada en capturar una imatge"

msgid "capturing exposure program"
msgstr "programa d'exposició de la captura"

msgid "The exposure program used when capturing an image"
msgstr "El programa d'exposició utilitzar en capturar una imatge"

msgid "capturing exposure mode"
msgstr "mode d'exposició de la captura"

msgid "The exposure mode used when capturing an image"
msgstr "El mode d'exposició utilitzat en capturar una imatge"

#, fuzzy
msgid "capturing exposure compensation"
msgstr "mode d'exposició de la captura"

#, fuzzy
msgid "The exposure compensation used when capturing an image"
msgstr "El mode d'exposició utilitzat en capturar una imatge"

msgid "capturing scene capture type"
msgstr "tipus de captura d'escena de la captura"

msgid "The scene capture mode used when capturing an image"
msgstr "El mode de captura d'escena utilitzat en capturar una imatge"

msgid "capturing gain adjustment"
msgstr "ajust de guany de la captura"

msgid "The overall gain adjustment applied on an image"
msgstr "L'ajust del guany general aplicat a una imatge"

msgid "capturing white balance"
msgstr "balanç de blancs de la captura"

msgid "The white balance mode set when capturing an image"
msgstr "El mode de balanç de blancs utilitzat en capturar una imatge"

msgid "capturing contrast"
msgstr "contrast de la captura"

msgid "The direction of contrast processing applied when capturing an image"
msgstr ""
"La direcció del processament del contrast aplicada en capturar una imatge"

msgid "capturing saturation"
msgstr "saturació de la captura"

msgid "The direction of saturation processing applied when capturing an image"
msgstr ""
"La direcció del processament de la saturació aplicada en capturar una imatge"

msgid "capturing sharpness"
msgstr "nitidesa de la captura"

msgid "The direction of sharpness processing applied when capturing an image"
msgstr ""
"La direcció del processament de la nitidesa aplicada en capturar una imatge"

msgid "capturing flash fired"
msgstr "flaix de la captura"

msgid "If the flash fired while capturing an image"
msgstr "Si el flaix s'ha disparat en capturar una imatge"

msgid "capturing flash mode"
msgstr "mode de flaix de la captura"

msgid "The selected flash mode while capturing an image"
msgstr "El mode de flaix seleccionat en capturar una imatge"

msgid "capturing metering mode"
msgstr "mode de mesurament de la captura"

msgid ""
"The metering mode used while determining exposure for capturing an image"
msgstr ""
"El mode de mesurament utilitzat en determinar l'exposició per a capturar una "
"imatge"

msgid "capturing source"
msgstr "font de la captura"

msgid "The source or type of device used for the capture"
msgstr "La font o tipus de dispositiu utilitzat per a la captura"

msgid "image horizontal ppi"
msgstr "ppp horitzontal de la imatge"

msgid "Media (image/video) intended horizontal pixel density in ppi"
msgstr "Densitat horitzontal de píxels del multimèdia (imatge/vídeo), en ppp"

msgid "image vertical ppi"
msgstr "ppp vertical de la imatge"

msgid "Media (image/video) intended vertical pixel density in ppi"
msgstr "Densitat vertical de píxels del multimèdia (imatge/vídeo), en ppp"

msgid "ID3v2 frame"
msgstr ""

msgid "unparsed id3v2 tag frame"
msgstr ""

msgid "ID3 tag"
msgstr "Etiqueta ID3"

msgid "APE tag"
msgstr "Etiqueta APE"

msgid "ICY internet radio"
msgstr "Emissora de ràdio per Internet ICY"

msgid "Apple Lossless Audio (ALAC)"
msgstr "Àudio sense pèrdues d'Apple (ALAC)"

msgid "Free Lossless Audio Codec (FLAC)"
msgstr "Còdec d'àudio sense pèrdues lliure (FLAC)"

msgid "Lossless True Audio (TTA)"
msgstr "Àudio sense pèrdues real (TTA)"

msgid "Windows Media Speech"
msgstr "Parla de Windows Media"

msgid "CYUV Lossless"
msgstr "CYUV sense pèrdues"

msgid "FFMpeg v1"
msgstr "FFMpeg v1"

msgid "Lossless MSZH"
msgstr "MSZH sense pèrdues"

msgid "Run-length encoding"
msgstr "Codificació Run-length"

msgid "Subtitle"
msgstr ""

#, fuzzy
msgid "MPL2 subtitle format"
msgstr "Format de subtítols TMPlayer"

#, fuzzy
msgid "DKS subtitle format"
msgstr "Format de subtítols Sami"

#, fuzzy
msgid "QTtext subtitle format"
msgstr "Format de subtítols Kate"

msgid "Sami subtitle format"
msgstr "Format de subtítols Sami"

msgid "TMPlayer subtitle format"
msgstr "Format de subtítols TMPlayer"

msgid "Kate subtitle format"
msgstr "Format de subtítols Kate"

#, fuzzy
msgid "Uncompressed video"
msgstr "YUV sense comprimir"

#, fuzzy
msgid "Uncompressed gray"
msgstr "Imatge en escala de grisos sense comprimir"

#, fuzzy, c-format
msgid "Uncompressed %s YUV %s"
msgstr "YUV sense comprimir"

#, fuzzy, c-format
msgid "Uncompressed %s%d-bit %s"
msgstr "Paletitzat %d-bit %s sense comprimir"

#, c-format
msgid "DivX MPEG-4 Version %d"
msgstr "DivX MPEG-4 versió %d"

#, fuzzy
msgid "Uncompressed audio"
msgstr "YUV sense comprimir"

#, fuzzy, c-format
msgid "Raw %d-bit %s audio"
msgstr "Àudio PCM en cru de %d-bit"

msgid "Audio CD source"
msgstr "Font de CD d'àudio"

msgid "DVD source"
msgstr "Font de DVD"

msgid "Real Time Streaming Protocol (RTSP) source"
msgstr "Font del protocol de transmissió en temps real (RTSP)"

msgid "Microsoft Media Server (MMS) protocol source"
msgstr "Font del protocol de servidor Microsoft Media (MMS)"

#, c-format
msgid "%s protocol source"
msgstr "Font del protocol %s"

#, c-format
msgid "%s video RTP depayloader"
msgstr "Descarregador de vídeo RTP %s"

#, c-format
msgid "%s audio RTP depayloader"
msgstr "Descarregador d'àudio RTP %s"

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

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

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

#, c-format
msgid "%s video RTP payloader"
msgstr "Carregador de vídeo RTP %s"

#, c-format
msgid "%s audio RTP payloader"
msgstr "Carregador d'àudio RTP %s"

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

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

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

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

msgid "Unknown source element"
msgstr "L'element de font és desconegut"

msgid "Unknown sink element"
msgstr "L'element de sortida és desconegut"

msgid "Unknown element"
msgstr "L'element és desconegut"

msgid "Unknown decoder element"
msgstr "L'element descodificador és desconegut"

msgid "Unknown encoder element"
msgstr "L'element codificador és desconegut"

msgid "Plugin or element of unknown type"
msgstr "El connector o element és de tipus desconegut"

#~ msgid "Master"
#~ msgstr "Mestre"

#~ msgid "Bass"
#~ msgstr "Baixos"

#~ msgid "Treble"
#~ msgstr "Aguts"

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

#~ msgid "Synth"
#~ msgstr "Sintetitzador"

#~ msgid "Line-in"
#~ msgstr "Línia d'entrada"

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

#~ msgid "Microphone"
#~ msgstr "Micròfon"

#~ msgid "PC Speaker"
#~ msgstr "Altaveu del PC"

#~ msgid "Playback"
#~ msgstr "Reproducció"

#~ msgid "Capture"
#~ msgstr "Captura"

#~ msgid "Could not open vfs file \"%s\" for writing: %s."
#~ msgstr "No s'ha pogut obrir el fitxer vfs «%s» per a l'escriptura: %s."

#~ msgid "No filename given"
#~ msgstr "No s'ha donat cap nom de fitxer"

#~ msgid "Could not close vfs file \"%s\"."
#~ msgstr "No s'ha pogut tancar el fitxer vfs «%s»."

#~ msgid "Error while writing to file \"%s\"."
#~ msgstr "S'ha produït un error en escriure al fitxer «%s»."

#~ msgid "Invalid subtitle URI \"%s\", subtitles disabled."
#~ msgstr "L'URI de subtítols «%s» no és vàlid, s'inhabiliten els subtítols."

#~ msgid "RTSP streams cannot be played yet."
#~ msgstr "Encara no es poden reproduir els fluxes RTSP."

#~ msgid "Could not create \"decodebin\" element."
#~ msgstr "No s'ha pogut crear l'element «decodebin»."

#~ 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 ""
#~ "Només s'ha detectat un flux de subtítols. O bé esteu carregant un fitxer "
#~ "de subtítols o qualsevol altre tipus de fitxer de text, o no s'ha "
#~ "reconegut el fitxer multimèdia."

#~ msgid ""
#~ "You do not have a decoder installed to handle this file. You might need "
#~ "to install the necessary plugins."
#~ msgstr ""
#~ "No teniu un descodificador instaŀlat per a gestionar aquest fitxer. És "
#~ "possible que necessiteu instaŀlar els connectors necessaris."

#~ msgid "This is not a media file"
#~ msgstr "Això no és un fitxer multimèdia"

#~ msgid "A subtitle stream was detected, but no video stream."
#~ msgstr "S'ha detectat un flux de subtítols, però no un flux de vídeo."

#~ msgid "Both autovideosink and xvimagesink elements are missing."
#~ msgstr "Manquen els elements autovideosink i xvimagesink."

#~ msgid "Both autoaudiosink and alsasink elements are missing."
#~ msgstr "Manquen els elements autoaudiosink i alsasink."

#~ msgid "Error while sending gdp header data to \"%s:%d\"."
#~ msgstr ""
#~ "S'ha produït un error en enviar dades de la capçalera gdp a «%s:%d»."

# Payload -> càrrega en molts àmbits. jm
#~ msgid "Error while sending gdp payload data to \"%s:%d\"."
#~ msgstr ""
#~ "S'ha produït un error en enviar la càrrega de dades de gdp a «%s:%d»."

#~ msgid "Connection to %s:%d refused."
#~ msgstr "S'ha refusat la connexió amb %s:%d."

#~ msgid "Uncompressed planar YUV 4:2:0"
#~ msgstr "YUV 4:2:0 planar sense comprimir"

#~ msgid "Uncompressed planar YVU 4:2:0"
#~ msgstr "YVU 4:2:0 planar sense comprimir"

#~ msgid "Uncompressed packed YUV 4:2:2"
#~ msgstr "YUV 4:2:2 empaquetat sense comprimir"

#~ msgid "Uncompressed packed YUV 4:1:0"
#~ msgstr "YUV 4:1:0 empaquetat sense comprimir"

#~ msgid "Uncompressed packed YVU 4:1:0"
#~ msgstr "YVU 4:1:0 empaquetat sense comprimir"

#~ msgid "Uncompressed packed YUV 4:1:1"
#~ msgstr "YUV 4:1:1 empaquetat sense comprimir"

#~ msgid "Uncompressed packed YUV 4:4:4"
#~ msgstr "YUV 4:4:4 empaquetat sense comprimir"

#~ msgid "Uncompressed planar YUV 4:2:2"
#~ msgstr "YUV 4:2:2 planar sense comprimir"

#~ msgid "Uncompressed planar YUV 4:1:1"
#~ msgstr "YUV 4:1:1 planar sense comprimir"

#~ msgid "Uncompressed black and white Y-plane"
#~ msgstr "Pla Y blanc i negre sense comprimir"

#~ msgid "Raw PCM audio"
#~ msgstr "Àudio PCM en cru"

#~ msgid "Raw %d-bit floating-point audio"
#~ msgstr "Àudio en cru de %d-bit en coma flotant"

#~ msgid "Raw floating-point audio"
#~ msgstr "Àudio en cru en coma flotant"

#~ msgid "No device specified."
#~ msgstr "No s'ha especificat un dispositiu."

#~ msgid "Device \"%s\" does not exist."
#~ msgstr "El dispositiu «%s» no existeix."

#~ msgid "Device \"%s\" is already being used."
#~ msgstr "El dispositiu «%s» ja és en ús."

#~ msgid "Could not open device \"%s\" for reading and writing."
#~ msgstr "No s'ha pogut obrir el dispositiu «%s» per a lectura o escriptura."

#~ msgid "discid"
#~ msgstr "id del disc"

#~ msgid "CDDA discid for metadata retrieval"
#~ msgstr "id del disc de CDDA per a l'obtenció de les metadades"
