# Brazilian Portuguese translation of gst-plugins-bad.
# This file is distributed under the same license as the gst-plugins-bad package.
# Copyright (C) 2007-2016 Free Software Foundation, Inc.
# Raphael Higino <In memorian>, 2007.
# Fabrício Godoy <skarllot@gmail.com>, 2008-2016.
#
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-bad-1.7.2\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2016-07-06 11:51+0300\n"
"PO-Revision-Date: 2016-05-06 16:02-0300\n"
"Last-Translator: Fabrício Godoy <skarllot@gmail.com>\n"
"Language-Team: Brazilian Portuguese <ldpbr-translation@lists.sourceforge."
"net>\n"
"Language: pt_BR\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 "failed to draw pattern"
msgstr ""

msgid "A GL error occured"
msgstr ""

msgid "format wasn't negotiated before get function"
msgstr "O formato não foi negociado antes da chamada da função"

msgid "OpenCV failed to load template image"
msgstr "O OpenCV falhou ao carregar a imagem modelo"

msgid "Could not read title information for DVD."
msgstr "Não foi possível ler as informações de título do DVD."

#, c-format
msgid "Failed to open DVD device '%s'."
msgstr "Falha ao abrir o dispositivo de DVD \"%s\"."

msgid "Failed to set PGC based seeking."
msgstr "Falha ao definir busca baseada em PGC."

msgid ""
"Could not read DVD. This may be because the DVD is encrypted and a DVD "
"decryption library is not installed."
msgstr ""
"Não foi possível ler o DVD. O motivo pode ser que o DVD está criptografado "
"ou uma biblioteca de descriptografia não está instalada."

msgid "Could not read DVD."
msgstr "Não foi possível ler o DVD."

msgid "This file contains no playable streams."
msgstr "Este arquivo não contém fluxos reproduzíveis."

msgid "Could not open sndfile stream for reading."
msgstr "Não foi possível abrir o fluxo sndfile para leitura."

msgid "Could not establish connection to sndio"
msgstr "Não foi possível estabelecer a conexão para sndio"

msgid "Failed to query sndio capabilities"
msgstr "Falha ao consultar os recursos de sndio"

msgid "Could not configure sndio"
msgstr "Não foi possível configurar o sndio"

msgid "Could not start sndio"
msgstr "Não foi possível iniciar o sndio"

msgid "Internal data flow error."
msgstr "Erro interno de fluxo de dados."

msgid "Generated file has a larger preroll time than its streams duration"
msgstr ""
"O arquivo gerado tem um tempo de preparação maior que a sua duração de fluxo"

#, c-format
msgid "Missing element '%s' - check your GStreamer installation."
msgstr ""
"O elemento \"%s\" está faltando, verifique a sua instalação do GStreamer."

msgid "File location is set to NULL, please set it to a valid filename"
msgstr ""
"A localização do arquivo está NULA, favor definir um nome de arquivo válido"

msgid "Digitalzoom element couldn't be created"
msgstr "O elemento Digitalzoom não pôde ser criado"

msgid "Subpicture format was not configured before data flow"
msgstr "O formato de subimagem não foi configurado antes do fluxo de dados"

msgid "Failed to get fragment URL."
msgstr "Falha ao obter um fragmento de URL."

msgid "Internal data stream error."
msgstr "Erro interno de fluxo de dados."

msgid "Couldn't download fragments"
msgstr "Não foi possível baixar os fragmentos"

msgid "No file name specified for writing."
msgstr "Nenhum nome de arquivo especificado para gravação."

#, c-format
msgid "Given file name \"%s\" can't be converted to local file name encoding."
msgstr ""
"O nome de arquivo fornecido \"%s\" não pode ser convertido para a "
"codificação de nome de arquivo local."

#, c-format
msgid "Could not open file \"%s\" for writing."
msgstr "Não foi possível abrir o arquivo \"%s\" para gravação."

#, c-format
msgid "Device \"%s\" does not exist."
msgstr "O dispositivo \"%s\" não existe."

#, c-format
msgid "Could not open frontend device \"%s\"."
msgstr "Não foi possível abrir o dispositivo de interface \"%s\"."

#, c-format
msgid "Could not get settings from frontend device \"%s\"."
msgstr ""
"Não foi possível obter as configurações do dispositivo de interface \"%s\"."

#, c-format
msgid "Cannot enumerate delivery systems from frontend device \"%s\"."
msgstr ""
"Não foi possível listar os sistemas de entrega do dispositivo de interface "
"\"%s\"."

#, c-format
msgid "Could not open file \"%s\" for reading."
msgstr "Não foi possível abrir o arquivo \"%s\" para leitura."

msgid "Couldn't find DVB channel configuration file"
msgstr "Não foi possível encontrar o arquivo de configuração de canal DVB"

#, c-format
msgid "Couldn't load DVB channel configuration file: %s"
msgstr "Não foi possível carregar o arquivo de configuração de canal DVB: %s"

#, c-format
msgid "Couldn't find details for DVB channel %s"
msgstr "Não foi possível encontrar detalhes para o canal DVB %s"

#, fuzzy, c-format
msgid "No properties for the DVB channel %s"
msgstr "Não foi possível encontrar detalhes para o canal DVB %s"

#, fuzzy, c-format
msgid "Failed to set properties for the DVB channel %s"
msgstr "Não foi possível encontrar detalhes para o canal DVB %s"

#, fuzzy, c-format
msgid "Couldn't find DVB channel configuration file: %s"
msgstr "Não foi possível encontrar o arquivo de configuração de canal DVB"

msgid "DVB channel configuration file doesn't contain any channels"
msgstr "O arquivo de configuração de canal DVB não contém nenhum canal"

#~ msgid "default GStreamer sound events audiosink"
#~ msgstr "audiosink do GStreamer pré-definido para eventos de som"

#~ msgid ""
#~ "GStreamer can play audio using any number of output elements. Some "
#~ "possible choices are osssink, pulsesink and alsasink. The audiosink can "
#~ "be a partial pipeline instead of just one element."
#~ msgstr ""
#~ "O GStreamer pode reproduzir áudio utilizando qualquer quantidade de "
#~ "elementos de saída. Algumas das opções possíveis são osssink, pulsesink e "
#~ "alsasink. O audiosink pode ser uma fila de processamento parcial em vez "
#~ "de apenas um elemento."

#~ msgid "description for default GStreamer sound events audiosink"
#~ msgstr ""
#~ "descrição para o audiosink do GStreamer pré-definido para eventos de som"

#~ msgid "Describes the selected audiosink element."
#~ msgstr "Descreve o elemento audiosink selecionado."

#~ msgid "default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr ""
#~ "audiosink do GStreamer pré-definido para Conferência de Áudio e Vídeo"

#~ msgid ""
#~ "description for default GStreamer audiosink for Audio/Video Conferencing"
#~ msgstr ""
#~ "descrição do audiosink do GStreamer pré-definido para Conferência de "
#~ "Áudio e Vídeo"

#~ msgid "default GStreamer audiosink for Music and Movies"
#~ msgstr "audiosink do GStreamer pré-definido para Músicas e Filmes"

#~ msgid "description for default GStreamer audiosink for Music and Movies"
#~ msgstr ""
#~ "descrição para o audiosink do GStreamer pré-definido para Músicas e Filmes"

#~ msgid "default GStreamer videosink"
#~ msgstr "videosink do GStreamer pré-definido"

#~ msgid ""
#~ "GStreamer can play video using any number of output elements. Some "
#~ "possible choices are xvimagesink, ximagesink, sdlvideosink and aasink. "
#~ "The videosink can be a partial pipeline instead of just one element."
#~ msgstr ""
#~ "O GStreamer pode reproduzir vídeo utilizando qualquer quantidade de "
#~ "elementos de saída. Algumas das opções possíveis são xvimagesink, "
#~ "ximagesink, sdlvideosink e aasink. O videosink pode ser uma fila de "
#~ "processamento parcial em vez de apenas um elemento."

#~ msgid "description for default GStreamer videosink"
#~ msgstr "descrição para o videosink do GStreamer pré-definido"

#~ msgid "Describes the selected videosink element."
#~ msgstr "Descreve o elemento videosink selecionado."

#~ msgid "default GStreamer audiosrc"
#~ msgstr "audiosrc do GStreamer pré-definido"

#~ msgid ""
#~ "GStreamer can record audio using any number of input elements. Some "
#~ "possible choices are osssrc, pulsesrc and alsasrc. The audio source can "
#~ "be a partial pipeline instead of just one element."
#~ msgstr ""
#~ "O GStreamer pode gravar áudio utilizando qualquer quantidade de elementos "
#~ "de entrada. Algumas das opções possíveis são osssrc, pulsesrc e alsasrc. "
#~ "A fonte de áudio pode ser uma fila de processamento parcial em vez de "
#~ "apenas um elemento."

#~ msgid "description for default GStreamer audiosrc"
#~ msgstr "descrição para o audiosrc do GStreamer pré-definido"

#~ msgid "Describes the selected audiosrc element."
#~ msgstr "Descreve o elemento audiosrc selecionado."

#~ msgid "default GStreamer videosrc"
#~ msgstr "videosrc do GStreamer pré-definido"

#~ msgid ""
#~ "GStreamer can record video from any number of input elements. Some "
#~ "possible choices are v4lsrc, v4l2src and videotestsrc. The video source "
#~ "can be a partial pipeline instead of just one element."
#~ msgstr ""
#~ "O GStreamer pode gravar vídeo de qualquer quantidade de elementos de "
#~ "entrada. Algumas das opções possíveis são v4lsrc, v4l2src e videotestsrc. "
#~ "A fonte de vídeo pode ser uma fila de processamento parcial em vez de "
#~ "apenas um elemento."

#~ msgid "description for default GStreamer videosrc"
#~ msgstr "descrição para o videosrc do GStreamer pré-definido"

#~ msgid "Describes the selected videosrc element."
#~ msgstr "Descreve o elemento videosrc selecionado."

#~ msgid "default GStreamer visualization"
#~ msgstr "visualização do GStreamer pré-definida"

#~ msgid ""
#~ "GStreamer can put visualization plugins in a pipeline to transform audio "
#~ "streams in video frames. Some possible choices are goom, goom2k1 and "
#~ "synaesthesia. The visualization plugin can be a partial pipeline instead "
#~ "of just one element."
#~ msgstr ""
#~ "O GStreamer pode colocar plugins de visualização numa fila de "
#~ "processamento para transformar fluxos de áudio em quadros de vídeo. "
#~ "Algumas das opções possíveis são goom, goom2k1 e synaesthesia. O plugin "
#~ "de visualização pode ser uma fila de processamento parcial em vez de "
#~ "apenas um elemento."

#~ msgid "description for default GStreamer visualization"
#~ msgstr "descrição da visualização do GStreamer pré-definida"

#~ msgid "Describes the selected visualization element."
#~ msgstr "Descreve o elemento de visualização selecionado."

#~ msgid "Couldn't get the Manifest's URI"
#~ msgstr "Não foi possível obter a URI do manifesto"

#~ msgid "Could not write to file \"%s\"."
#~ msgstr "Não foi possível gravar no arquivo \"%s\"."
