# Brazilian Portuguese translation of gst-plugins-base.
# Copyright (C) 2008-2016 Free Software Foundation, Inc.
# This file is distributed under the same license as the gst-plugins-base package.
# Fabrício Godoy <skarllot@gmail.com>, 2008-2016.
#
# PCM -> PCM
# buffering -> preenchendo buffer
# sink -> consumidor
#
msgid ""
msgstr ""
"Project-Id-Version: gst-plugins-base-1.7.90\n"
"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
"POT-Creation-Date: 2016-06-09 11:16+0300\n"
"PO-Revision-Date: 2016-05-06 16:47-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 "Could not open device for playback in mono mode."
msgstr "Não foi possível abrir o dispositivo para reprodução em mono."

msgid "Could not open device for playback in stereo mode."
msgstr "Não foi possível abrir o dispositivo para reprodução em estéreo."

#, c-format
msgid "Could not open device for playback in %d-channel mode."
msgstr "Não foi possível abrir o dispositivo para reprodução com %d canais."

msgid ""
"Could not open audio device for playback. Device is being used by another "
"application."
msgstr ""
"Não foi possível abrir o dispositivo de áudio para reprodução. O dispositivo "
"está sendo usado por outro aplicativo."

msgid "Could not open audio device for playback."
msgstr "Não foi possível abrir o dispositivo de áudio para reprodução."

msgid "Error outputting to audio device. The device has been disconnected."
msgstr ""
"Erro de saída para o dispositivo de áudio. O dispositivo foi desconectado."

msgid "Could not open device for recording in mono mode."
msgstr "Não foi possível abrir o dispositivo para gravação em mono."

msgid "Could not open device for recording in stereo mode."
msgstr "Não foi possível abrir o dispositivo para gravação em estéreo."

#, c-format
msgid "Could not open device for recording in %d-channel mode"
msgstr "Não foi possível abrir o dispositivo para gravação com %d canais."

msgid ""
"Could not open audio device for recording. Device is being used by another "
"application."
msgstr ""
"Não foi possível abrir o dispositivo de áudio para gravação. O dispositivo "
"está sendo usado por outro aplicativo."

msgid "Could not open audio device for recording."
msgstr "Não foi possível abrir o dispositivo de áudio para gravação."

msgid "Error recording from audio device. The device has been disconnected."
msgstr ""
"Erro de gravação para o dispositivo de áudio. O dispositivo foi desconectado."

msgid "Could not open CD device for reading."
msgstr "Não foi possível abrir o dispositivo de CD para leitura."

msgid "Could not seek CD."
msgstr "Não foi possível buscar no CD."

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

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

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

msgid "Could not determine type of stream"
msgstr "Não foi possível determinar o tipo de fluxo"

msgid "This appears to be a text file"
msgstr "Este parece ser um arquivo de texto"

msgid "Could not create \"uridecodebin\" element."
msgstr "Não foi possível criar o elemento \"uridecodebin\"."

#, c-format
msgid "Both autovideosink and %s elements are missing."
msgstr "Os elementos autovideosink e %s estão faltando."

msgid "The autovideosink element is missing."
msgstr "O elemento autovideosink está faltando."

#, c-format
msgid "Configured videosink %s is not working."
msgstr "O videosink configurado %s não está funcionando."

#, c-format
msgid "Both autovideosink and %s elements are not working."
msgstr "Os elementos autovideosink e %s não estão funcionando."

msgid "The autovideosink element is not working."
msgstr "O elemento autovideosink não está funcionando."

msgid "Custom text sink element is not usable."
msgstr "O elemento consumidor personalizado de texto não é utilizável."

msgid "No volume control found"
msgstr "Nenhum controle de volume encontrado"

#, c-format
msgid "Both autoaudiosink and %s elements are missing."
msgstr "Os elementos autoaudiosink e %s estão faltando."

msgid "The autoaudiosink element is missing."
msgstr "O elemento autoaudiosink não está faltando."

#, c-format
msgid "Configured audiosink %s is not working."
msgstr "O audiosink configurado %s não está funcionando."

#, c-format
msgid "Both autoaudiosink and %s elements are not working."
msgstr "Os elementos autoaudiosink e %s não estão funcionando."

msgid "The autoaudiosink element is not working."
msgstr "O elemento autoaudiosink não está funcionando."

msgid "Can't play a text file without video or visualizations."
msgstr ""
"Não é possível reproduzir um arquivo de texto sem vídeo ou visualização."

#, c-format
msgid "No decoder available for type '%s'."
msgstr "Decodificador não disponível para o tipo \"%s\"."

msgid "No URI specified to play from."
msgstr "Nenhum URI especificado para reprodução."

#, c-format
msgid "Invalid URI \"%s\"."
msgstr "O URI \"%s\" é inválido."

msgid "This stream type cannot be played yet."
msgstr "Este tipo de fluxo ainda não pode ser reproduzido."

#, c-format
msgid "No URI handler implemented for \"%s\"."
msgstr "Nenhum manipulador para o URI \"%s\" foi implementado."

msgid "Source element is invalid."
msgstr "O elemente de origem é inválido."

#, c-format
msgid "Error while sending data to \"%s:%d\"."
msgstr "Erro ao enviar dados para \"%s:%d\"."

msgid "Can't record audio fast enough"
msgstr "Não é possível gravar o áudio rápido suficiente"

msgid "This CD has no audio tracks"
msgstr "Este CD não tem trilhas de áudio"

msgid "ID3 tag"
msgstr "Etiqueta ID3"

msgid "APE tag"
msgstr "Etiqueta APE"

msgid "ICY internet radio"
msgstr "Rádio on-line ICY"

msgid "Apple Lossless Audio (ALAC)"
msgstr "Áudio Sem Perdas da Apple (ALAC)"

msgid "Free Lossless Audio Codec (FLAC)"
msgstr "Codec Livre de Áudio Sem Perdas (FLAC)"

msgid "Lossless True Audio (TTA)"
msgstr "Áudio Real Sem Perdas (TTA)"

msgid "Windows Media Speech"
msgstr "Mídia de Voz do Windows (WMS)"

msgid "CYUV Lossless"
msgstr "CYUV Sem Perdas"

msgid "FFMpeg v1"
msgstr "FFMpeg v1"

msgid "Lossless MSZH"
msgstr "MSZH Sem Perdas"

msgid "Run-length encoding"
msgstr "Codificação Run-length"

msgid "Timed Text"
msgstr "Texto Temporizado"

msgid "Subtitle"
msgstr "Legenda"

msgid "MPL2 subtitle format"
msgstr "Formato de legendas MPL2"

msgid "DKS subtitle format"
msgstr "Formato de legendas DKS"

msgid "QTtext subtitle format"
msgstr "Formato de legendas QTtext"

msgid "Sami subtitle format"
msgstr "Formato de legendas Sami"

msgid "TMPlayer subtitle format"
msgstr "Formato de legendas TMPlayer"

msgid "Kate subtitle format"
msgstr "Formato de legendas Kate"

msgid "Uncompressed video"
msgstr "Vídeo sem compressão"

msgid "Uncompressed gray"
msgstr "Arquivo monocromático sem compressão"

#, c-format
msgid "Uncompressed packed YUV %s"
msgstr "YUV %s empacotado sem compressão"

#, c-format
msgid "Uncompressed semi-planar YUV %s"
msgstr "YUV %s semi-plano sem compressão"

#, c-format
msgid "Uncompressed planar YUV %s"
msgstr "YUV %s plano sem compressão"

#, c-format
msgid "Uncompressed palettized %d-bit %s"
msgstr "%2$s de %1$d bits sem compressão com paletas"

#, c-format
msgid "Uncompressed %d-bit %s"
msgstr "%2$s de %1$d bits sem compressão"

#, c-format
msgid "DivX MPEG-4 Version %d"
msgstr "DivX MPEG-4 Versão %d"

msgid "Uncompressed audio"
msgstr "Áudio sem compressão"

#, c-format
msgid "Raw %d-bit %s audio"
msgstr "Áudio Raw de %d bits %s"

msgid "Audio CD source"
msgstr "Origem: CD de áudio"

msgid "DVD source"
msgstr "Origem: DVD"

msgid "Real Time Streaming Protocol (RTSP) source"
msgstr "Origem: Protocolo de Fluxo Contínuo em Tempo Real (RTSP)"

msgid "Microsoft Media Server (MMS) protocol source"
msgstr "Origem: protocolo do Servidor de Mídia da Microsoft (MMS)"

#, c-format
msgid "%s protocol source"
msgstr "Origem: protocolo %s"

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

#, c-format
msgid "%s audio RTP depayloader"
msgstr "decodificador de áudio RTP %s"

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

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

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

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

#, c-format
msgid "%s audio RTP payloader"
msgstr "codificador de áudio RTP %s"

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

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

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

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

msgid "Unknown source element"
msgstr "Elemento de origem desconhecida"

msgid "Unknown sink element"
msgstr "Elemento consumidor desconhecido"

msgid "Unknown element"
msgstr "Elemento desconhecido"

msgid "Unknown decoder element"
msgstr "Elemento decodificador desconhecido"

msgid "Unknown encoder element"
msgstr "Elemento codificador desconhecido"

msgid "Plugin or element of unknown type"
msgstr "Elemento ou plug-in de tipo desconhecido"

msgid "Failed to read tag: not enough data"
msgstr "Falha ao ler etiqueta: dados insuficientes"

msgid "track ID"
msgstr "ident. da trilha"

msgid "MusicBrainz track ID"
msgstr "ident. da trilha no MusicBrainz"

msgid "artist ID"
msgstr "ident. do artista"

msgid "MusicBrainz artist ID"
msgstr "ident. do artista no MusicBrainz"

msgid "album ID"
msgstr "ident. do álbum"

msgid "MusicBrainz album ID"
msgstr "ident. do álbum no MusicBrainz"

msgid "album artist ID"
msgstr "ident. do artista do álbum"

msgid "MusicBrainz album artist ID"
msgstr "ident. do artista do álbum no MusicBrainz"

msgid "track TRM ID"
msgstr "ident. da trilha TRM"

msgid "MusicBrainz TRM ID"
msgstr "ident. da trilha TRM no MusicBrainz"

msgid "capturing shutter speed"
msgstr "velocidade do obturador ao capturar"

msgid "Shutter speed used when capturing an image, in seconds"
msgstr "Velocidade do obturador utilizada ao capturar uma imagem, em segundos"

msgid "capturing focal ratio"
msgstr "taxa focal ao capturar"

msgid "Focal ratio (f-number) used when capturing the image"
msgstr "Taxa focal utilizada ao capturar a imagem, f-number"

msgid "capturing focal length"
msgstr "distância focal ao capturar"

msgid "Focal length of the lens used capturing the image, in mm"
msgstr "Distância focal das lentes utilizada ao capturar a imagem, em mm"

msgid "capturing digital zoom ratio"
msgstr "taxa de zoom digital ao capturar"

msgid "Digital zoom ratio used when capturing an image"
msgstr "Taxa de zoom digital utilizada ao capturar uma imagem"

msgid "capturing iso speed"
msgstr "velocidade ISO ao capturar"

msgid "The ISO speed used when capturing an image"
msgstr "A velocidade ISO utilizada ao capturar uma imagem"

msgid "capturing exposure program"
msgstr "programa de exposição ao capturar"

msgid "The exposure program used when capturing an image"
msgstr "O programa de exposição utilizado ao capturar uma imagem"

msgid "capturing exposure mode"
msgstr "modo de exposição ao capturar"

msgid "The exposure mode used when capturing an image"
msgstr "O modo de exposição utilizado ao capturar uma imagem"

msgid "capturing exposure compensation"
msgstr "equilíbrio de exposição ao capturar"

msgid "The exposure compensation used when capturing an image"
msgstr "O equilíbrio de exposição utilizado ao capturar uma imagem"

msgid "capturing scene capture type"
msgstr "tipo de captura de cena ao capturar"

msgid "The scene capture mode used when capturing an image"
msgstr "O modo de captura de cena utilizado ao capturar uma imagem"

msgid "capturing gain adjustment"
msgstr "ajuste de ganho ao capturar"

msgid "The overall gain adjustment applied on an image"
msgstr "O ajuste de ganho geral aplicado na imagem"

msgid "capturing white balance"
msgstr "balanço de branco ao capturar"

msgid "The white balance mode set when capturing an image"
msgstr "O modo de balanço de branco definido ao capturar uma imagem"

msgid "capturing contrast"
msgstr "contraste ao capturar"

msgid "The direction of contrast processing applied when capturing an image"
msgstr ""
"O procedimento de processamento de contraste aplicado ao capturar uma imagem"

msgid "capturing saturation"
msgstr "saturação ao capturar"

msgid "The direction of saturation processing applied when capturing an image"
msgstr ""
"O procedimento de processamento de saturação aplicado ao capturar uma imagem"

msgid "capturing sharpness"
msgstr "nitidez ao capturar"

msgid "The direction of sharpness processing applied when capturing an image"
msgstr ""
"O procedimento de processamento de nitidez aplicado ao capturar uma imagem"

msgid "capturing flash fired"
msgstr "disparar flash ao capturar"

msgid "If the flash fired while capturing an image"
msgstr "Define se o flash é disparado ao capturar uma imagem"

msgid "capturing flash mode"
msgstr "modo de flash ao capturar"

msgid "The selected flash mode while capturing an image"
msgstr "O modo de flash selecionado ao capturar uma imagem"

msgid "capturing metering mode"
msgstr "modo de medição de luz ao capturar"

msgid ""
"The metering mode used while determining exposure for capturing an image"
msgstr ""
"O modo de medição de luz utilizado ao determinar a exposição para captura de "
"uma imagem"

msgid "capturing source"
msgstr "fonte ao capturar"

msgid "The source or type of device used for the capture"
msgstr "A fonte ou tipo de dispositivo utilizado para a captura"

msgid "image horizontal ppi"
msgstr "PPI horizontal da imagem"

msgid "Media (image/video) intended horizontal pixel density in ppi"
msgstr ""
"Densidade de pixels horizontais desejado para a mídia (imagem/vídeo), em PPI"

msgid "image vertical ppi"
msgstr "PPI vertical da imagem"

msgid "Media (image/video) intended vertical pixel density in ppi"
msgstr ""
"Densidade de pixels verticais desejado para a mídia (imagem/vídeo), em PPI"

msgid "ID3v2 frame"
msgstr "quadro ID3v2"

msgid "unparsed id3v2 tag frame"
msgstr "quadro com etiqueta ID3v2 sem análise"

msgid "musical-key"
msgstr "acorde musical"

msgid "Initial key in which the sound starts"
msgstr "Nota ou acorde inicial da música"

msgid "Print version information and exit"
msgstr "Exibe informações de versão e sai"

msgid ""
"Don't exit after showing the initial device list, but wait for devices to "
"added/removed."
msgstr ""
"Não sair após exibir a lista inicial de dispositivos, mas sim, esperar por "
"dispositivos serem adicionados ou removidos."

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

msgid "Buffering..."
msgstr "Preenchendo buffer..."

msgid "Clock lost, selecting a new one\n"
msgstr "Temporizador perdido, selecionando um novo\n"

msgid "Reached end of play list."
msgstr "A lista de reprodução terminou."

msgid "Paused"
msgstr "Pausado"

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

#, c-format
msgid "About to finish, preparing next title: %s"
msgstr "Quase terminando, preparando a próxima faixa: %s"

#, c-format
msgid "Playback rate: %.2f"
msgstr "Taxa de reprodução: %.2f"

#, c-format
msgid "Could not change playback rate to %.2f"
msgstr "Não foi possível alterar a taxa de reprodução para %.2f"

msgid "space"
msgstr "espaço"

msgid "pause/unpause"
msgstr "pausar/cancelar"

msgid "q or ESC"
msgstr "q ou ESC"

msgid "quit"
msgstr "sair"

msgid "> or n"
msgstr "> ou n"

msgid "play next"
msgstr "reproduzir próxima"

msgid "< or b"
msgstr "< ou b"

msgid "play previous"
msgstr "reproduzir anterior"

msgid "seek forward"
msgstr "buscar à frente"

msgid "seek backward"
msgstr "buscar para trás"

msgid "volume up"
msgstr "aumentar volume"

msgid "volume down"
msgstr "diminuir volume"

msgid "increase playback rate"
msgstr "aumentar taxa de reprodução"

msgid "decrease playback rate"
msgstr "diminuir taxa de reprodução"

msgid "change playback direction"
msgstr "alterar direção de reprodução"

msgid "enable/disable trick modes"
msgstr "ativar/desativar modos avançados"

msgid "change audio track"
msgstr "alterar a trilha de áudio"

msgid "change video track"
msgstr "alterar a trilha de vídeo"

msgid "change subtitle track"
msgstr "alterar a trilha de legenda"

msgid "seek to beginning"
msgstr "pular para o começo"

msgid "show keyboard shortcuts"
msgstr "exibir atalhos de teclado"

msgid "Interactive mode - keyboard controls:"
msgstr "Modo interativo - teclas de comando:"

#  Flag: verbose
msgid "Output status information and property notifications"
msgstr "Exibe informações de status e notificações de propriedade"

#  Flag: flags
msgid "Control playback behaviour setting playbin 'flags' property"
msgstr ""
"Controla o comportamento de reprodução definindo a propriedade \"flags\" do "
"Playbin"

#  Flag: videosink
msgid "Video sink to use (default is autovideosink)"
msgstr "Define o elemento consumidor de vídeo (predefinido para autovideosink)"

#  Flag: audiosink
msgid "Audio sink to use (default is autoaudiosink)"
msgstr "Define o elemento consumidor de áudio (predefinido para autoaudiosink)"

#  Flag: gapless
msgid "Enable gapless playback"
msgstr "Ativar reprodução sem intervalos"

#  Flag: shuffle
msgid "Shuffle playlist"
msgstr "Embaralhar lista de reprodução"

#  Flag: no-interactive
msgid "Disable interactive control via the keyboard"
msgstr "Desativar controle interativo via teclado"

#  Flag: volume
msgid "Volume"
msgstr "Volume"

#  Flag: playlist
msgid "Playlist file containing input media files"
msgstr "Arquivo de lista de reprodução que contém arquivos de mídia de entrada"

#  Flag: quiet
msgid "Do not print any output (apart from errors)"
msgstr "Não exibir nenhuma saída (além dos erros)"

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

msgid "You must provide at least one filename or URI to play."
msgstr "Você deve fornecer ao menos um nome de arquivo ou URI para reproduzir."

msgid "Press 'k' to see a list of keyboard shortcuts.\n"
msgstr "Pressione \"k\" para ver a lista de atalhos do teclado.\n"

#~ msgid "A %s plugin is required to play this stream, but not installed."
#~ msgstr ""
#~ "O plug-in %s é necessário para reproduzir este fluxo, mas não está "
#~ "instalado."

#~ msgid "Uncompressed %s YUV %s"
#~ msgstr "%2$s YUV %1$s sem compressão"

#~ msgid "Master"
#~ msgstr "Principal"

#~ msgid "Bass"
#~ msgstr "Grave"

#~ msgid "Treble"
#~ msgstr "Agudo"

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

#~ msgid "Synth"
#~ msgstr "Sintetizador"

#~ msgid "Line-in"
#~ msgstr "Entrada de linha"

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

#~ msgid "Microphone"
#~ msgstr "Microfone"

#~ msgid "PC Speaker"
#~ msgstr "Alto-falante do PC"

#~ msgid "Playback"
#~ msgstr "Reprodução"

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

#~ msgid "Could not open vfs file \"%s\" for writing: %s."
#~ msgstr "Não foi possível abrir o arquivo VFS \"%s\" para escrita: %s."

#~ msgid "No filename given"
#~ msgstr "Não foi fornecido um nome de arquivo"

#~ msgid "Could not close vfs file \"%s\"."
#~ msgstr "Não foi possível fechar o arquivo VFS \"%s\"."

#~ msgid "Error while writing to file \"%s\"."
#~ msgstr "Erro ao gravar no arquivo \"%s\"."

#~ msgid "Invalid subtitle URI \"%s\", subtitles disabled."
#~ msgstr "O URI \"%s\" para legenda é inválido, legendas desabilitadas."

#~ msgid "RTSP streams cannot be played yet."
#~ msgstr "Os fluxos RTSP ainda não podem ser reproduzidos."

#~ 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 ""
#~ "Apenas um fluxo de legendas foi detectado. Ou você está carregando um "
#~ "arquivo de legenda ou algum outro tipo de arquivo de texto, ou o arquivo "
#~ "de mídia não é reconhecido."

#~ msgid ""
#~ "You do not have a decoder installed to handle this file. You might need "
#~ "to install the necessary plugins."
#~ msgstr ""
#~ "Você não tem um decodificador instalado para manipular este arquivo. Você "
#~ "deveria instalar os plug-ins necessários."

#~ msgid "This is not a media file"
#~ msgstr "Este não é um arquivo de mídia"

#~ msgid "A subtitle stream was detected, but no video stream."
#~ msgstr "Um fluxo de legenda foi detectado, mas nenhum fluxo de vídeo."

#~ msgid "Both autovideosink and xvimagesink elements are missing."
#~ msgstr "Os elementos autovideosink e xvimagesink estão faltando."

#~ msgid "Both autoaudiosink and alsasink elements are missing."
#~ msgstr "Os elementos autoaudiosink e alsasink estão faltando."

#~ msgid "Error while sending gdp header data to \"%s:%d\"."
#~ msgstr "Erro ao enviar o cabeçalho de dados GDP para \"%s:%d\"."

#~ msgid "Error while sending gdp payload data to \"%s:%d\"."
#~ msgstr "Erro ao enviar codificação de dados GDP para \"%s:%d\"."

#~ msgid "Connection to %s:%d refused."
#~ msgstr "A conexão para %s:%d foi recusada."

#~ msgid "Uncompressed planar YVU 4:2:0"
#~ msgstr "YVU 4:2:0 plano sem compressão"

#~ msgid "Uncompressed packed YUV 4:1:0"
#~ msgstr "YUV 4:1:0 empacotado sem compressão"

#~ msgid "Uncompressed packed YVU 4:1:0"
#~ msgstr "YVU 4:1:0 empacotado sem compressão"

#~ msgid "Uncompressed packed YUV 4:1:1"
#~ msgstr "YUV 4:1:1 empacotado sem compressão"

#~ msgid "Uncompressed packed YUV 4:4:4"
#~ msgstr "YUV 4:4:4 empacotado sem compressão"

#~ msgid "Uncompressed planar YUV 4:2:2"
#~ msgstr "YUV 4:2:2 plano sem compressão"

#~ msgid "Uncompressed planar YUV 4:1:1"
#~ msgstr "YUV 4:1:1 plano sem compressão"

#~ msgid "Uncompressed black and white Y-plane"
#~ msgstr "Plano Y em preto e branco sem compressão"

#~ msgid "Raw PCM audio"
#~ msgstr "Áudio PCM Raw"

#~ msgid "Raw %d-bit floating-point audio"
#~ msgstr "Áudio Raw de ponto-flutuante de %d bits"

#~ msgid "Raw floating-point audio"
#~ msgstr "Áudio Raw de ponto-flutuante"

#~ msgid "No device specified."
#~ msgstr "Nenhum dispositivo especificado."

#~ msgid "Device \"%s\" does not exist."
#~ msgstr "O dispositivo \"%s\" não existe."

#~ msgid "Device \"%s\" is already being used."
#~ msgstr "O dispositivo \"%s\" já está sendo usado."

#~ msgid "Could not open device \"%s\" for reading and writing."
#~ msgstr "Não foi possível abrir o dispositivo \"%s\" para leitura e escrita."

#~ msgid "Could not create \"decodebin2\" element."
#~ msgstr "Não foi possível criar o elemento \"decodebin2\"."

#~ msgid "Could not create \"queue2\" element."
#~ msgstr "Não foi possível criar o elemento \"queue2\"."

#~ msgid "Could not create \"typefind\" element."
#~ msgstr "Não foi possível criar o elemento \"typefind\"."

#~ msgid "Can't display both text subtitles and subpictures."
#~ msgstr "Não é possível reproduzir legendas de texto e subimagens."

#~ msgid "No Temp directory specified."
#~ msgstr "Nenhum diretório temporário especificado."

#~ msgid "Could not create temp file \"%s\"."
#~ msgstr "Não foi possível criar o arquivo temporário \"%s\"."

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

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

#~ msgid "No file name specified."
#~ msgstr "Não foi especificado um nome de arquivo."
