# Galician translations for gstreamer package.
# This file is put in the public domain.
# Francisco Diéguez <frandieguez@ubuntu.com>, 2011.
#
msgid ""
msgstr ""
"Project-Id-Version: gstreamer 0.10.32.2\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2013-07-29 13:29+0200\n"
"PO-Revision-Date: 2011-09-05 12:49+0200\n"
"Last-Translator: Fran Dieguez <frandieguez@ubuntu.com>\n"
"Language-Team: Galician <proxecto@trasno.net>\n"
"Language: gl_ES\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 "Print the GStreamer version"
msgstr "Imprimir a versión de GStreamer"

msgid "Make all warnings fatal"
msgstr "Facer todas as advertencias fatais"

msgid "Print available debug categories and exit"
msgstr "Imprimir as categorías de depuración dispoñíbeis e saír"

msgid ""
"Default debug level from 1 (only error) to 5 (anything) or 0 for no output"
msgstr ""
"Nivel de depuración por omisión desde 1 (só erro) até 5 (todo) ou 0 sen saída"

msgid "LEVEL"
msgstr "NIVEL"

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 ""
"Lista de pares nome_categoría:nivel separados por comas para estabelecer "
"niveis específicos para as categorías individuais. Exemplo: GST_AUTOPLUG:5,"
"GST_ELEMENT_*:3"

msgid "LIST"
msgstr "LISTA"

msgid "Disable colored debugging output"
msgstr "Desactivar a coloración da saída depurada"

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

msgid "Disable debugging"
msgstr "Desactivar depuración"

msgid "Enable verbose plugin loading diagnostics"
msgstr "Activar a saída detallada do diagnóstico de carga de engadidos"

msgid "Colon-separated paths containing plugins"
msgstr "Rutas separadas por punto e coma contendo os engadidos"

msgid "PATHS"
msgstr "RUTAS"

msgid ""
"Comma-separated list of plugins to preload in addition to the list stored in "
"environment variable GST_PLUGIN_PATH"
msgstr ""
"Lista de engadidos para precargar separados por comas ademais da lista "
"almacenada na variábel de contorno GST_PLUGIN_PATH"

msgid "PLUGINS"
msgstr "COMPLEMENTOS"

msgid "Disable trapping of segmentation faults during plugin loading"
msgstr ""
"Desactivar a captura de fallos de segmentación durante a carga de engadidos"

msgid "Disable updating the registry"
msgstr "Desactivar a actualización do rexistro"

msgid "Disable spawning a helper process while scanning the registry"
msgstr "Desactivar o lanzamento dun proceso de axuda ao escanear o rexistro"

msgid "GStreamer Options"
msgstr "Opcións de GStreamer"

msgid "Show GStreamer Options"
msgstr "Mostrar as opcións de GStreamer"

msgid "Unknown option"
msgstr "Opción descoñecida"

msgid "GStreamer encountered a general core library error."
msgstr "GStreamer encontrou un erro xeral no núcleo da biblioteca."

msgid ""
"GStreamer developers were too lazy to assign an error code to this error."
msgstr ""
"Os desenvolvedores de GStreamer foron demasiado vagos para engadir un código "
"de erro a este erro."

msgid "Internal GStreamer error: code not implemented."
msgstr "Erro interno de GStreamer: código non implementado."

msgid ""
"GStreamer error: state change failed and some element failed to post a "
"proper error message with the reason for the failure."
msgstr ""
"Produciuse un erro de GStreamer: produciuse un fallo durante o cambio de "
"estado e algún elemento fracasou ao publicar a mensaxe de erro "
"correspondente co motivo do fallo."

msgid "Internal GStreamer error: pad problem."
msgstr "Erro interno de GStreamer: problema de desprazamento."

msgid "Internal GStreamer error: thread problem."
msgstr "Erro interno de GStreamer: problema cos fíos"

#, fuzzy
msgid "GStreamer error: negotiation problem."
msgstr "Erro interno de GStreamer: problema de negociación."

msgid "Internal GStreamer error: event problem."
msgstr "Erro interno de GStreamer: problema cos eventos."

msgid "Internal GStreamer error: seek problem."
msgstr "Erro interno de GStreamer: problema coa busca."

msgid "Internal GStreamer error: caps problem."
msgstr "Erro interno de GStreamer: probema coas capacidades."

msgid "Internal GStreamer error: tag problem."
msgstr "Erro interno de GStreamer: problema coas etiquetas."

msgid "Your GStreamer installation is missing a plug-in."
msgstr "Á súa instalación de GStreamer fáltalle un engadido."

#, fuzzy
msgid "GStreamer error: clock problem."
msgstr "Erro interno de GStreamer: problema de reloxo."

msgid ""
"This application is trying to use GStreamer functionality that has been "
"disabled."
msgstr ""
"Este aplicativo está tentando usar unha funcionalidade de GStreamer que foi "
"deshabilitada."

msgid "GStreamer encountered a general supporting library error."
msgstr "GStreamer atopou un erro de compatibilidade xeral na biblioteca."

msgid "Could not initialize supporting library."
msgstr "Nonon foi posíbel iniciar a biblioteca de compatibilidade."

msgid "Could not close supporting library."
msgstr "Non foi posíbel pehar a biblioteca de asistencia."

msgid "Could not configure supporting library."
msgstr "Non foi posíbel configurar a biblioteca de asistencia."

msgid "Encoding error."
msgstr "Erro de codificación."

msgid "GStreamer encountered a general resource error."
msgstr "GStreamer encontrou un erro xeral de recurso."

msgid "Resource not found."
msgstr "Recurso non encontrado."

msgid "Resource busy or not available."
msgstr "O recurso está ocupado ou non dispoñíbel."

msgid "Could not open resource for reading."
msgstr "Non foi posíbel abrir o recurso para a súa lectura."

msgid "Could not open resource for writing."
msgstr "Non foi posíbel abrir o recurso para a súa escritura."

msgid "Could not open resource for reading and writing."
msgstr "Non foi posíbel abrir o recurso para a súa lectura ou escritura."

msgid "Could not close resource."
msgstr "Non foi posíbel pechar o recurso."

msgid "Could not read from resource."
msgstr "Non foi posíbel ler desde o recurso."

msgid "Could not write to resource."
msgstr "Non foi posíbel escribir no recurso."

msgid "Could not perform seek on resource."
msgstr "Non foi posíbel realizar unha busca no recurso."

msgid "Could not synchronize on resource."
msgstr "Non foi posíbel sincronizar o recurso."

msgid "Could not get/set settings from/on resource."
msgstr "Non foi posíbel obter/estabelecer a configuración de/en o recurso."

msgid "No space left on the resource."
msgstr "Non queda espacio dispoñíbel no recurso."

msgid "GStreamer encountered a general stream error."
msgstr "GStreamer encontrou un erro xeral de fluxo."

msgid "Element doesn't implement handling of this stream. Please file a bug."
msgstr ""
"O elemento non implementa un manexador deste fluxo. Por favor, complete o "
"informe e erro."

msgid "Could not determine type of stream."
msgstr "Non foi posíbel determinar o tipo de fluxo."

msgid "The stream is of a different type than handled by this element."
msgstr "O fluxo é dun tipo diferente que o manexado por este elemento."

msgid "There is no codec present that can handle the stream's type."
msgstr "Non hai un códec dispoñíbel que poida manexar este tipo de fluxo."

msgid "Could not decode stream."
msgstr "Non foi posíbel descodificar o fluxo."

msgid "Could not encode stream."
msgstr "Non foi posíbel codificar o fluxo."

msgid "Could not demultiplex stream."
msgstr "Non foi posíbel demultiplexar o fluxo."

msgid "Could not multiplex stream."
msgstr "Non foi posíbel multiplexar o fluxo."

msgid "The stream is in the wrong format."
msgstr "O fluxo está no formato incorrecto."

msgid "The stream is encrypted and decryption is not supported."
msgstr "O fluxo está cifrado e o descrifrado non é posíbel."

msgid ""
"The stream is encrypted and can't be decrypted because no suitable key has "
"been supplied."
msgstr ""
"O fluxo está cifrado e non é posíbel descifralo porque non se forneceu a "
"chave axeitada."

#, c-format
msgid "No error message for domain %s."
msgstr "Non hai unha mensaxe de erro para o dominio %s."

#, c-format
msgid "No standard error message for domain %s and code %d."
msgstr "Non hai unha mensaxe de erro estándar par ao dominio %s e código %d."

msgid "Selected clock cannot be used in pipeline."
msgstr "Non é posíbel usar o reloxo seleccionado na canalización."

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

msgid "title"
msgstr "título"

msgid "commonly used title"
msgstr "título usado de forma común"

msgid "title sortname"
msgstr "nome de ordenación do título"

msgid "commonly used title for sorting purposes"
msgstr "título usado comunmente para propósitos de ordenamento"

msgid "artist"
msgstr "artista"

msgid "person(s) responsible for the recording"
msgstr "persoa(s) responsábel(eis) da gravación"

msgid "artist sortname"
msgstr "nome de ordenación do artista"

msgid "person(s) responsible for the recording for sorting purposes"
msgstr "persoa(s) responsábel(eis) da gravación para propósitos de ordenamento"

msgid "album"
msgstr "álbume"

msgid "album containing this data"
msgstr "o álbum que conten estes datos"

msgid "album sortname"
msgstr "nome de ordenación do álbume"

msgid "album containing this data for sorting purposes"
msgstr "o álbum que conten estes datos para propósitos de ordenamento"

msgid "album artist"
msgstr "artista do álbume"

msgid "The artist of the entire album, as it should be displayed"
msgstr "O artista do álbum enteiro, como se debería mostrar"

msgid "album artist sortname"
msgstr "nome de ordenación do artista do álbume"

msgid "The artist of the entire album, as it should be sorted"
msgstr "O artista do álbum enteiro, como se debería ordenar"

msgid "date"
msgstr "data"

msgid "date the data was created (as a GDate structure)"
msgstr "data na que se crearon os datos (como estrutura GDate)"

msgid "datetime"
msgstr "data e hora"

msgid "date and time the data was created (as a GstDateTime structure)"
msgstr "data e hora na que se crearon os datos (como estrutura GstDateTime)"

msgid "genre"
msgstr "xénero"

msgid "genre this data belongs to"
msgstr "xénero ao que pertencen estes datos"

msgid "comment"
msgstr "comentario"

msgid "free text commenting the data"
msgstr "comentario de texto sobre os datos"

msgid "extended comment"
msgstr "comentario estendido"

msgid "free text commenting the data in key=value or key[en]=comment form"
msgstr ""
"texto libre comentando os datos como key=valor ou key[gl]=formulario de "
"comentario"

msgid "track number"
msgstr "número de pista"

msgid "track number inside a collection"
msgstr "número de pista nunha colección"

msgid "track count"
msgstr "número de pistas"

msgid "count of tracks inside collection this track belongs to"
msgstr "número de pistas na colección á que pertence a pista"

msgid "disc number"
msgstr "número de disco"

msgid "disc number inside a collection"
msgstr "número do disco dentro dunha colección"

msgid "disc count"
msgstr "número de discos"

msgid "count of discs inside collection this disc belongs to"
msgstr "número de discos na colección á que pertence o disco"

msgid "location"
msgstr "localización"

msgid ""
"Origin of media as a URI (location, where the original of the file or stream "
"is hosted)"
msgstr ""
"Orixe do medio como un URI (localización, onde está aloxado o ficheiro ou "
"fluxo orixinal)"

msgid "homepage"
msgstr "sitio web"

msgid "Homepage for this media (i.e. artist or movie homepage)"
msgstr ""
"Páxina principal para este medio (p.ex. páxina principal do artista ou filme)"

msgid "description"
msgstr "descrición"

msgid "short text describing the content of the data"
msgstr "texto curto describindo o contido dos datos"

msgid "version"
msgstr "versión"

msgid "version of this data"
msgstr "versión destes datos"

msgid "ISRC"
msgstr "ISRC"

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

msgid "organization"
msgstr "organización"

msgid "copyright"
msgstr "copyright"

msgid "copyright notice of the data"
msgstr "nota de dereitos de autoría dos datos"

msgid "copyright uri"
msgstr "URI aos dereitos de autor"

msgid "URI to the copyright notice of the data"
msgstr "URI á nota de dereitos de autoría dos datos"

msgid "encoded by"
msgstr "codificado por"

msgid "name of the encoding person or organization"
msgstr "nome da persoa ou organización codificadora"

msgid "contact"
msgstr "contacto"

msgid "contact information"
msgstr "información de contacto"

msgid "license"
msgstr "licenza"

msgid "license of data"
msgstr "licenza dos datos"

msgid "license uri"
msgstr "URI á licenza"

msgid "URI to the license of the data"
msgstr "URI á licenza dos datos"

msgid "performer"
msgstr "intérprete"

msgid "person(s) performing"
msgstr "persoa(s) interpretando"

msgid "composer"
msgstr "compositor"

msgid "person(s) who composed the recording"
msgstr "persoa(s) que compuxeron a gravación"

msgid "duration"
msgstr "duración"

msgid "length in GStreamer time units (nanoseconds)"
msgstr "duración en unidades de tempo GStreamer (nanosegundos)"

msgid "codec"
msgstr "códec"

msgid "codec the data is stored in"
msgstr "códec no que se almacenan os datos"

msgid "video codec"
msgstr "códec de vídeo"

msgid "codec the video data is stored in"
msgstr "códec no que se almacenan os datos do vídeo"

msgid "audio codec"
msgstr "códec de son"

msgid "codec the audio data is stored in"
msgstr "códec no que se almacenan os datos do son"

msgid "subtitle codec"
msgstr "códec do subtitulo"

msgid "codec the subtitle data is stored in"
msgstr "códec no que se almacenan os datos dos subtítulos"

msgid "container format"
msgstr "formato do contedor"

msgid "container format the data is stored in"
msgstr "formato do contedor no que se almacenan os datos"

msgid "bitrate"
msgstr "taxa de bits"

msgid "exact or average bitrate in bits/s"
msgstr "taxa de bits exacta ou promedio en bits/s"

msgid "nominal bitrate"
msgstr "taxa de bits nominal"

msgid "nominal bitrate in bits/s"
msgstr "taxa de bits nominal en bits/s"

msgid "minimum bitrate"
msgstr "taxa de bits mínima"

msgid "minimum bitrate in bits/s"
msgstr "taxa mínima de bits en bits/s"

msgid "maximum bitrate"
msgstr "taxa de bits máxima"

msgid "maximum bitrate in bits/s"
msgstr "taxa máxima de bits en bits/s"

msgid "encoder"
msgstr "codificador"

msgid "encoder used to encode this stream"
msgstr "codificador usado para codificar este fluxo"

msgid "encoder version"
msgstr "versión do codificador"

msgid "version of the encoder used to encode this stream"
msgstr "versión do codificador usado para codificar este fluxo"

msgid "serial"
msgstr "serie"

msgid "serial number of track"
msgstr "número de serie da pista"

msgid "replaygain track gain"
msgstr "ganancia da pista (ReplayGain)"

msgid "track gain in db"
msgstr "ganancia da pista en dB"

msgid "replaygain track peak"
msgstr "pico da pista (ReplayGain)"

msgid "peak of the track"
msgstr "pico da pista"

msgid "replaygain album gain"
msgstr "ganancia do álbum (ReplayGain)"

msgid "album gain in db"
msgstr "ganancia do álbum en dB"

msgid "replaygain album peak"
msgstr "pico do álbum (ReplayGain)"

msgid "peak of the album"
msgstr "pico do álbum"

msgid "replaygain reference level"
msgstr "nivel de referencia (ReplayGain)"

msgid "reference level of track and album gain values"
msgstr "valor do nivel de referencia da ganancia da pista e do álbum"

msgid "language code"
msgstr "código de idioma"

#, fuzzy
msgid "language code for this stream, conforming to ISO-639-1 or ISO-639-2"
msgstr "código de idioma para este fluxo, axustándose a ISO-639-1"

#, fuzzy
msgid "language name"
msgstr "código de idioma"

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

msgid "image"
msgstr "imaxe"

msgid "image related to this stream"
msgstr "imaxe relacionada con este fluxo"

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

msgid "preview image related to this stream"
msgstr "vista previa da imaxe relacionada con este fluxo"

msgid "attachment"
msgstr "anexo"

msgid "file attached to this stream"
msgstr "ficheiro anexo a este fluxo"

msgid "beats per minute"
msgstr "golpes por minuto (bpm)"

msgid "number of beats per minute in audio"
msgstr "número de golpes por minuto (bpm) no son"

msgid "keywords"
msgstr "palabras chave"

msgid "comma separated keywords describing the content"
msgstr "palabras clave separadas por comas describindo o contido"

msgid "geo location name"
msgstr "nome da xeolocalización"

msgid ""
"human readable descriptive location of where the media has been recorded or "
"produced"
msgstr ""
"descrición da localización entendíbel por humanos de onde foi gravado ou "
"producido o medio"

msgid "geo location latitude"
msgstr "latitude da xeolocalización"

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 ""
"latitude xeográfica onde foi gravado ou producido o medio, en graos conforme "
"a WGS84 (cero é o ecuador, valores negativos para latitudes meridionais)"

msgid "geo location longitude"
msgstr "lonxitude da xeolocalización"

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 ""
"lonxitude xeográfica onde foi gravado ou producido o medio, en graos "
"conforme a WGS84 (cero é o primeiro meridiano en Greenwich/GB, valores "
"negativos para lonxitudes occidentais)"

msgid "geo location elevation"
msgstr "elevación da xeolocalización"

msgid ""
"geo elevation of where the media has been recorded or produced in meters "
"according to WGS84 (zero is average sea level)"
msgstr ""
"elevación xeográfica onde foi gravado ou producido o medio, en graos "
"conforme a WGS84 (cero é o nivel medio do mar)"

msgid "geo location country"
msgstr "país da xeolocalización"

msgid "country (english name) where the media has been recorded or produced"
msgstr "país (nome en inglés) onde foi gravado ou producido o medio"

msgid "geo location city"
msgstr "cidade da xeolocalización"

msgid "city (english name) where the media has been recorded or produced"
msgstr "cidade (nome en inglés) onde foi gravado ou producido o medio"

msgid "geo location sublocation"
msgstr "sublocalización da xeolocalización"

#, fuzzy
msgid ""
"a location within a city where the media has been produced or created (e.g. "
"the neighborhood)"
msgstr ""
"unha localización nunha cidade onde foi gravado ou producido o medio (p.ex. "
"o barrio)"

msgid "geo location horizontal error"
msgstr "erro horizontal de xeolocalización"

msgid "expected error of the horizontal positioning measures (in meters)"
msgstr "erro esperado das medidas de posicionamento horizontal (en metros)"

msgid "geo location movement speed"
msgstr "velocidade de movemento da xeolocalización"

msgid ""
"movement speed of the capturing device while performing the capture in m/s"
msgstr ""
"velocidade de movemento do dispositivo de captura mentres realiza a captura, "
"en m/s"

msgid "geo location movement direction"
msgstr "dirección de movemento da xeolocalización"

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 ""
"indica a dirección do movemento do dispositivo que realiza a captura dun "
"medio. Representase en graos ou nunha representación en coma flotante, 0 "
"corresponde ao norte xeográfico e incrementa de forma horaria."

msgid "geo location capture direction"
msgstr "dirección de captura da xeolocalización"

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 ""
"indica a dirección na que apunta o dispositivo que realiza a captura dun "
"medio. Representase en graos ou nunha representación en coma flotante, 0 "
"corresponde ao norte xeográfico e incrementa de forma horaria."

#. TRANSLATORS: 'show name' = 'TV/radio/podcast show name' here
msgid "show name"
msgstr "nome do programa"

msgid "Name of the tv/podcast/series show the media is from"
msgstr "Nome do programa/podcast/serie"

#. TRANSLATORS: 'show sortname' = 'TV/radio/podcast show name as used for sorting purposes' here
msgid "show sortname"
msgstr "nome de ordenación do programa"

msgid ""
"Name of the tv/podcast/series show the media is from, for sorting purposes"
msgstr "Nome do programa/podcast/serie, para propósitos de ordenación"

msgid "episode number"
msgstr "número de episodio"

msgid "The episode number in the season the media is part of"
msgstr "O número do capítulo na tempada"

msgid "season number"
msgstr "número de tempada"

msgid "The season number of the show the media is part of"
msgstr "O número de tempada do programa"

msgid "lyrics"
msgstr "letras"

msgid "The lyrics of the media, commonly used for songs"
msgstr "As letras do ficheiro multimedia, xeralmente usado para cancións"

msgid "composer sortname"
msgstr "nome curto do compositor"

msgid "person(s) who composed the recording, for sorting purposes"
msgstr "pesoa(s) que compuxeron a gravación, para propósitos de ordenamento"

msgid "grouping"
msgstr "agrupación"

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 ""
"Agrupa temas relacionados que se expanden varias pistas, como as diferentes "
"partes dun concerto. É un nivel máis alto que o dunha pista, pero máis baixo "
"que o dun álbum."

msgid "user rating"
msgstr "puntuación do usuario"

msgid ""
"Rating attributed by a user. The higher the rank, the more the user likes "
"this media"
msgstr ""
"Puntuación atribuída por un usuario. Canto maior sexa a puntuación mais lle "
"gustará ao usuario."

msgid "device manufacturer"
msgstr "fabricante do dispositivo"

msgid "Manufacturer of the device used to create this media"
msgstr "Fabricante do dispositivo usado para crear este medio"

msgid "device model"
msgstr "modelo do dispositivo"

msgid "Model of the device used to create this media"
msgstr "Modelo do dispositivo usado para crear este medio"

msgid "application name"
msgstr "nome do aplicativo"

msgid "Application used to create the media"
msgstr "Aplicativo usado para crear o medio"

msgid "application data"
msgstr "datos do aplicativo"

msgid "Arbitrary application data to be serialized into the media"
msgstr "Datos arbitrarios do aplicativo para serializalos no medio"

msgid "image orientation"
msgstr "orientación da imaxe"

msgid "How the image should be rotated or flipped before display"
msgstr "Como se debería rotar ou voltear a imaxe antes de mostrala"

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 "ERRO: do elemento %s: %s\n"

#, c-format
msgid ""
"Additional debug info:\n"
"%s\n"
msgstr ""
"Información adicional de depuración:\n"
"%s\n"

#, c-format
msgid "specified empty bin \"%s\", not allowed"
msgstr "o binario especificado «%s» está baleiro, non está permitido"

#, c-format
msgid "no bin \"%s\", skipping"
msgstr "non existe o binario «%s», omitindo"

#, c-format
msgid "no property \"%s\" in element \"%s\""
msgstr "non hai unha propiedade «%s» no elemento «%s»"

#, c-format
msgid "could not set property \"%s\" in element \"%s\" to \"%s\""
msgstr "non foi posíbel estabelecer a propiedade «%s» no elemento «%s» a «%s»"

#, c-format
msgid "could not link %s to %s"
msgstr "non foi posíbel ligar %s a %s"

#, c-format
msgid "no element \"%s\""
msgstr "non hai un elemento «%s»"

#, c-format
msgid "could not parse caps \"%s\""
msgstr "non foi posíbel analizar as capacidades «%s»"

msgid "link without source element"
msgstr "ligazón sen elemento orixe"

msgid "link without sink element"
msgstr "ligazón sen elemento sumidoiro"

#, c-format
msgid "no source element for URI \"%s\""
msgstr "non existe un elemento orixe para o URI «%s»"

#, c-format
msgid "no element to link URI \"%s\" to"
msgstr "non existe un elemento co que ligar o URI «%s»"

#, c-format
msgid "no sink element for URI \"%s\""
msgstr "non existe o elemento sumidoiro para o URI «%s»"

#, c-format
msgid "could not link sink element for URI \"%s\""
msgstr "non foi posíbel ligar o elemento sumidoiro para o URI «%s»"

msgid "empty pipeline not allowed"
msgstr "non se permite unha canalización baleira"

msgid "A lot of buffers are being dropped."
msgstr "Estanse a desbotar moitos búferes."

msgid "Internal data flow problem."
msgstr "Hai un problema no fluxo interno de datos."

msgid "Internal data stream error."
msgstr "Produciuse un erro no fluxo interno de datos."

msgid "Internal data flow error."
msgstr "Produciuse un erro no fluxo interno de datos."

msgid "Internal clock error."
msgstr "Produciuse un erro no reloxo interno."

msgid "Failed to map buffer."
msgstr ""

msgid "Filter caps"
msgstr "Filtro de capacidades"

msgid ""
"Restrict the possible allowed capabilities (NULL means ANY). Setting this "
"property takes a reference to the supplied GstCaps object."
msgstr ""
"Restrinxir as posíbeis capacidades permitidas (NULL significa CALQUERA). Ao "
"estabelecer esta propiedade obtense unha referencia do obxecto GstCaps "
"fornecido."

msgid "No file name specified for writing."
msgstr "Non se especificou un nome de ficheiro para escritura."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Non foi posíbel abrir «%s» para escribir."

#, c-format
msgid "Error closing file \"%s\"."
msgstr "Produciuse un erro ao pechar o ficheiro «%s»."

#, c-format
msgid "Error while seeking in file \"%s\"."
msgstr "Produciuse un erro ao buscar no ficheiro «%s»."

#, c-format
msgid "Error while writing to file \"%s\"."
msgstr "Produciuse un erro ao escribir no ficheiro «%s»."

msgid "No file name specified for reading."
msgstr "Non se especificou un nome de ficheiro para a lectura."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Non foi posíbel abrir o ficheiro «%s» para ler."

#, c-format
msgid "Could not get info on \"%s\"."
msgstr "Non foi posíbel obter a información de «%s»."

#, c-format
msgid "\"%s\" is a directory."
msgstr "«%s» é un directorio."

#, c-format
msgid "File \"%s\" is a socket."
msgstr "O ficheiro «%s» é un socket."

msgid "Failed after iterations as requested."
msgstr "Produciuse un fallo despois das iteracións que se solicitaron."

msgid "No Temp directory specified."
msgstr "Non se especificou un directorio temporal."

#, c-format
msgid "Could not create temp file \"%s\"."
msgstr "Non foi posíbel crear o ficheiro temporal «%s»."

msgid "Error while writing to download file."
msgstr "Produciuse un erro de escritura ao descargar o ficheiro."

msgid "caps"
msgstr "capacidades"

msgid "detected capabilities in stream"
msgstr "capacidades detectadas no fluxo"

msgid "minimum"
msgstr "mínimo"

msgid "force caps"
msgstr "forzar as capacidades"

msgid "force caps without doing a typefind"
msgstr "forzar as capacidades sen facer un «typefind»"

msgid "Stream contains no data."
msgstr "O fluxo non contén datos."

msgid "Implemented Interfaces:\n"
msgstr "Interfaces implementadas:\n"

msgid "readable"
msgstr "lexíbel"

msgid "writable"
msgstr "escribíbel"

msgid "controllable"
msgstr "controlábel"

msgid "changeable in NULL, READY, PAUSED or PLAYING state"
msgstr "intercambiábel entre os estados NULL, READY, PAUSED ou PLAYING"

msgid "changeable only in NULL, READY or PAUSED state"
msgstr "intercambiábel só entre os estados NULL, READY ou PAUSED"

msgid "changeable only in NULL or READY state"
msgstr "intercambiábel só entre os estados NULL ou READY"

msgid "Blacklisted files:"
msgstr "Ficheiros na lista negra:"

msgid "Total count: "
msgstr "Contía total: "

#, c-format
msgid "%d blacklisted file"
msgid_plural "%d blacklisted files"
msgstr[0] "%d ficheiro na lista negra"
msgstr[1] "%d ficheiros na lista negra"

#, c-format
msgid "%d plugin"
msgid_plural "%d plugins"
msgstr[0] "%d engadido"
msgstr[1] "%d engadidos"

#, c-format
msgid "%d blacklist entry"
msgid_plural "%d blacklist entries"
msgstr[0] "%d entrada na lista negra"
msgstr[1] "%d entradas na lista negra"

#, c-format
msgid "%d feature"
msgid_plural "%d features"
msgstr[0] "%d característica"
msgstr[1] "%d características"

msgid "Print all elements"
msgstr "Imprimir todos os elementos"

msgid "Print list of blacklisted files"
msgstr "Imprimir lista dos ficheiros na lista negra"

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 ""
"Imprimir unha lista de características analizábeis por unha máquina do "
"engadido especificado ou fornecer todos os engadidos.\n"
"                                       Útil xunto con mecanismos de "
"instalación externa automática de engadidos."

msgid "List the plugin contents"
msgstr "Listar o contido do engadido"

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 "Imprimir os esquemas URI admitidos, cos elementos que os implementan"

#, c-format
msgid "Could not load plugin file: %s\n"
msgstr "Non foi posíbel cargar o ficheiro do engadido: %s\n"

#, c-format
msgid "No such element or plugin '%s'\n"
msgstr "Non existe o elemento ou engadido «%s»\n"

msgid "Index statistics"
msgstr "Estatísticas do índice"

#, c-format
msgid "Got message #%u from element \"%s\" (%s): "
msgstr "Obtívose a mensaxe nº %u do elemento «%s» (%s): "

#, c-format
msgid "Got message #%u from pad \"%s:%s\" (%s): "
msgstr "Obtívose a mensaxe nº %u da cela «%s:%s» (%s): "

#, c-format
msgid "Got message #%u from object \"%s\" (%s): "
msgstr "Obtívose a mensaxe nº %u do obxecto «%s» (%s): "

#, c-format
msgid "Got message #%u (%s): "
msgstr "Obtívose a mensaxe num. %u (%s): "

#, c-format
msgid "Got EOS from element \"%s\".\n"
msgstr "Obtívose un EOS do elemento «%s».\n"

#, c-format
msgid "FOUND TAG      : found by element \"%s\".\n"
msgstr "ATOPADA ETIQUETA      : atopada polo elemento «%s».\n"

#, c-format
msgid "FOUND TAG      : found by pad \"%s:%s\".\n"
msgstr "ATOPADA ETIQUETA      : atopada pola cela «%s:%s».\n"

#, c-format
msgid "FOUND TAG      : found by object \"%s\".\n"
msgstr "ETIQUETA ENCONTRADA      : encontrada polo obxecto «%s».\n"

msgid "FOUND TAG\n"
msgstr "ETIQUETA ENCONTRADA\n"

#, fuzzy, c-format
msgid "FOUND TOC      : found by element \"%s\".\n"
msgstr "ATOPADA ETIQUETA      : atopada polo elemento «%s».\n"

#, fuzzy, c-format
msgid "FOUND TOC      : found by object \"%s\".\n"
msgstr "ETIQUETA ENCONTRADA      : encontrada polo obxecto «%s».\n"

#, fuzzy
msgid "FOUND TOC\n"
msgstr "ETIQUETA ENCONTRADA\n"

#, c-format
msgid ""
"INFO:\n"
"%s\n"
msgstr ""
"INFORMACIÓN:\n"
"%s\n"

#, c-format
msgid "WARNING: from element %s: %s\n"
msgstr "AVISO: do elemento %s: %s\n"

msgid "Prerolled, waiting for buffering to finish...\n"
msgstr "Preparado, agardando a encher o búfer para rematar…\n"

#, fuzzy
msgid "Prerolled, waiting for progress to finish...\n"
msgstr "Preparado, agardando a encher o búfer para rematar…\n"

msgid "buffering..."
msgstr "almacenando no búfer…"

msgid "Done buffering, setting pipeline to PLAYING ...\n"
msgstr ""
"Rematouse de almacenar no búfer, estabelecendo a canalización para "
"REPRODUCIR...\n"

msgid "Buffering, setting pipeline to PAUSED ...\n"
msgstr "Almacenando no búfer, estabelecendo a canalización a PAUSADA...\n"

msgid "Redistribute latency...\n"
msgstr "Redistribuír latencia...\n"

#, c-format
msgid "Setting state to %s as requested by %s...\n"
msgstr "Estabelecendo o estado a %s segundo foi solicitado por %s...\n"

msgid "Interrupt: Stopping pipeline ...\n"
msgstr "Interromper: parando a canalización …\n"

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

#, fuzzy, c-format
msgid "Missing element: %s\n"
msgstr "non hai un elemento «%s»"

#, fuzzy, c-format
msgid "Got context from element '%s': %s\n"
msgstr "AVISO: do elemento %s: %s\n"

msgid "Output tags (also known as metadata)"
msgstr "Etiquetas de saída (tamén coñecido como metadatos)"

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

msgid "Output status information and property notifications"
msgstr "Información do estado da saída e notificacións das propiedades"

msgid "Do not print any progress information"
msgstr "Non mostrar ningunha información de progreso"

msgid "Output messages"
msgstr "Mensaxes de saída"

msgid "Do not output status information of TYPE"
msgstr "Non sacar a saída da información de estado do TIPO"

msgid "TYPE1,TYPE2,..."
msgstr "TIPO1,TIPO2,…"

msgid "Do not install a fault handler"
msgstr "Non instalar un manexador predeterminado"

msgid "Force EOS on sources before shutting the pipeline down"
msgstr "Forzar EOS nas orixes antes de pechar a canalización"

msgid "Gather and print index statistics"
msgstr "Obter e imprimir as estatísticas do índice"

#, c-format
msgid "ERROR: pipeline could not be constructed: %s.\n"
msgstr "ERRO: non foi posíbel construír a canalización: %s.\n"

msgid "ERROR: pipeline could not be constructed.\n"
msgstr "ERRO: non foi posíbel construír a canalización.\n"

#, c-format
msgid "WARNING: erroneous pipeline: %s\n"
msgstr "AVISO: canalización errónea: %s\n"

msgid "ERROR: the 'pipeline' element wasn't found.\n"
msgstr "ERRO: o elemento «canalización» non foi atopado.\n"

msgid "Setting pipeline to PAUSED ...\n"
msgstr "Estabelecendo a tubería a PAUSA...\n"

msgid "ERROR: Pipeline doesn't want to pause.\n"
msgstr "ERROR: A tubería non quere pausarse.\n"

msgid "Pipeline is live and does not need PREROLL ...\n"
msgstr "A tubería está viva e non necesita PREPARARSE...\n"

msgid "Pipeline is PREROLLING ...\n"
msgstr "A tubería está PREPARÁNDOSE...\n"

msgid "ERROR: pipeline doesn't want to preroll.\n"
msgstr "ERRO: a tubería non quere prepararse.\n"

msgid "Pipeline is PREROLLED ...\n"
msgstr "A tubería está PREPARADA...\n"

msgid "Setting pipeline to PLAYING ...\n"
msgstr "Estabelecendo a tubería a REPRODUCINDO.\n"

msgid "ERROR: pipeline doesn't want to play.\n"
msgstr "ERRO: a tubería non quere reproducirse.\n"

msgid "EOS on shutdown enabled -- Forcing EOS on the pipeline\n"
msgstr "EOS ao apagar activado; Forzando EOS na tubería\n"

#, fuzzy
msgid "EOS on shutdown enabled -- waiting for EOS after Error\n"
msgstr "EOS ao apagar activado; Forzando EOS na tubería\n"

msgid "Waiting for EOS...\n"
msgstr "Agardando pola EOS...\n"

msgid "EOS received - stopping pipeline...\n"
msgstr "EOS recibido: detendo a tubería...\n"

#, fuzzy
msgid "Interrupt while waiting for EOS - stopping pipeline...\n"
msgstr "Interromper: parando a canalización …\n"

msgid "An error happened while waiting for EOS\n"
msgstr "Produciuse un erro ao esperar a EOS\n"

msgid "Execution ended after %"
msgstr "A execución rematou despois de %"

msgid "Setting pipeline to READY ...\n"
msgstr "Estabelecendo a tubería a PREPARADO...\n"

msgid "Setting pipeline to NULL ...\n"
msgstr "Estabelecendo a tubería a NULL...\n"

msgid "Freeing pipeline ...\n"
msgstr "Liberando a tubería...\n"

#~ msgid "Print alloc trace (if enabled at compile time)"
#~ msgstr "Imprimir a traza de asignacións (se foi activada ao compilar)"

#~ msgid "Usage: gst-xmllaunch <file.xml> [ element.property=value ... ]\n"
#~ msgstr ""
#~ "Uso: gst-xmllaunch <ficheiro.xml> [ propiedade.do.elemento=valor … ]\n"

#~ msgid "ERROR: parse of xml file '%s' failed.\n"
#~ msgstr "ERRO: non foi posíbel analizar o ficheiro xml «%s».\n"

#~ msgid "ERROR: no toplevel pipeline element in file '%s'.\n"
#~ msgstr ""
#~ "ERRO: non existe o elemento de nivel superior da canalización no ficheiro "
#~ "«%s».\n"

#~ msgid "WARNING: only one toplevel element is supported at this time.\n"
#~ msgstr "AVISO: neste momento só se admite un elemento de nivel superior.\n"

#~ msgid "ERROR: could not parse command line argument %d: %s.\n"
#~ msgstr ""
#~ "ERRO: non foi posíbel analizar o argumento %d da liña de ordes: %s.\n"

#~ msgid "WARNING: element named '%s' not found.\n"
#~ msgstr "AVISO: non se atopou o elemento nomeado «%s».\n"

#~ msgid "Save xml representation of pipeline to FILE and exit"
#~ msgstr "Gardar a representación xml da canalización a un FICHEIRO e saír"

#~ msgid "FILE"
#~ msgstr "FICHEIRO"

#~ msgid "Do not install signal handlers for SIGUSR1 and SIGUSR2"
#~ msgstr "Non instalar os manexadores de sinais para SIGUSR1 e SIGUSR2"
