override fun merge( file1: File, file2: File, commandRunner: CommandRunner,…
- User
override fun merge( file1: File, file2: File, commandRunner: CommandRunner, userNotifier: UserNotifier, streamsImplementations: Set, ) { val videoFile = if (file1.length() >= file2.length()) file1 else file2 val audioStreams1 = mutableSetOf<Map<String, String>>() val audioStreams2 = mutableSetOf<Map<String, String>>()
streamsImplementations.forEach { streamImplementation -> streamImplementation.getAudioStreams(file1).forEach { audioStream -> audioStreams1.add(audioStream) } streamImplementation.getAudioStreams(file2).forEach { audioStream -> audioStreams2.add(audioStream) } } val selectedAudioStreams = userNotifier.selectAudioStreams(audioStreams1.toList(), audioStreams2.toList(), file1, file2) val ffmpegCommand = buildFfmpegCommand(videoFile, selectedAudioStreams) commandRunner.runCommand(ffmpegCommand, streamsImplementations.first().getDuration(videoFile)) }estou com um problema nessa função. estou tendo duplicação dos audioStreams dentro das listas, pq estou usando 2 implementações de Streams. cada uma retorna alguns valores de List<Map<String,String>> diferente, pq algumas informações estão presentes em ambas e outras só tem em uma dessas implementações. a diferença fica para os valores dentro dos Maps, onde a chave, geralmente, é diferente.
as informações relevantes que eu quero são
private fun createCheckbox(stream: Map<String, String>): JCheckBox { val language = stream["language"] ?: stream["tags.language"] ?: stream["Title"] ?: stream["Language"] ?: "Unknown" val codec = stream["codec_name"] ?: stream["Format"] ?: "Unknown" val sampleRate = stream["sample_rate"] ?: stream["SamplingRate"] ?: "Unknown" val channels = stream["channels"] ?: stream["Channels"] ?: "Unknown" val bitrate = stream["bit_rate"] ?: stream["tags.BPS"] ?: stream["tags.BPS-eng"] ?: stream["SamplesPerFrame"] ?: "Unknown"
val checkboxText = "${messages.getString("idioma")}: $language | " + "${messages.getString("codec")}: $codec | " + "${messages.getString("taxa_amostragem")}: $sampleRate Hz | " + "${ messages.getString("canais") }: $channels | " + "${messages.getString("taxa_bits")}: $bitrate" return JCheckBox("Stream ${stream["index"]} - $checkboxText").also { logger.info("createCheckbox\n$it") } }só para que seja criado uma lista dos 2 arquivos com seus streams e seus metadados, mas sem duplicação de streams, o principal motivo é que algumas informações uma das implementações (mediainfo) consegue pegar o "Title" do Stream de áudio, enquanto a outra (ffmpeg) não.
- Assistant
Entendi o problema que você está enfrentando com a duplicação de
audioStreamsdevido às diferentes implementações deStreams(comomediainfoeffmpeg). A duplicação ocorre porque cada implementação retorna informações ligeiramente diferentes sobre os mesmos streams, resultando em entradas duplicadas com chaves diferentes nos mapas.Para resolver esse problema, você pode adotar uma abordagem de normalização e deduplicação dos streams antes de adicioná-los à lista final. A ideia é:
- Normalizar os Streams: Transformar cada
Map<String, String>em uma classe de dados (data class) com campos padronizados. - Definir Critérios de Unicidade: Decidir quais campos identificam exclusivamente um stream (por exemplo,
index,codec,language, etc.). - Usar uma Coleção que Evite Duplicatas: Utilizar um
Setpara armazenar os streams normalizados, garantindo que streams duplicados não sejam adicionados.
Passo a Passo Detalhado
- Defina uma Classe de Dados para Normalizar os Streams
Crie uma
data classque represente de forma padronizada um stream de áudio. Isso facilitará a comparação e manipulação dos streams.data class AudioStream( val index: String, val language: String, val codec: String, val sampleRate: String, val channels: String, val bitrate: String ) { // Define critérios de igualdade baseados nos campos que identificam unicamente um stream override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is AudioStream) return false return index == other.index && codec == other.codec && sampleRate == other.sampleRate && channels == other.channels } override fun hashCode(): Int { var result = index.hashCode() result = 31 * result + codec.hashCode() result = 31 * result + sampleRate.hashCode() result = 31 * result + channels.hashCode() return result } }- Função de Conversão para Normalizar os Maps
Crie uma função que converte um
Map<String, String>em um objetoAudioStream, priorizando certos campos conforme necessário.fun Map<String, String>.toAudioStream(): AudioStream { val index = this["index"] ?: "Unknown" val language = this["language"] ?: this["tags.language"] ?: this["Title"] ?: this["Language"] ?: "Unknown" val codec = this["codec_name"] ?: this["Format"] ?: "Unknown" val sampleRate = this["sample_rate"] ?: this["SamplingRate"] ?: "Unknown" val channels = this["channels"] ?: this["Channels"] ?: "Unknown" val bitrate = this["bit_rate"] ?: this["tags.BPS"] ?: this["tags.BPS-eng"] ?: this["SamplesPerFrame"] ?: "Unknown" return AudioStream(index, language, codec, sampleRate, channels, bitrate) }- Modificar a Função
mergepara Utilizar a Normalização e Deduplicação
Atualize sua função
mergepara usar aAudioStreame umSetpara evitar duplicações.override fun merge( file1: File, file2: File, commandRunner: CommandRunner, userNotifier: UserNotifier, streamsImplementations: Set<Streams> ) { val videoFile = if (file1.length() >= file2.length()) file1 else file2 // Use sets para manter a unicidade dos streams val audioStreamsSet1 = mutableSetOf<AudioStream>() val audioStreamsSet2 = mutableSetOf<AudioStream>() streamsImplementations.forEach { streamImplementation -> streamImplementation.getAudioStreams(file1).forEach { audioStreamMap -> audioStreamsSet1.add(audioStreamMap.toAudioStream()) } streamImplementation.getAudioStreams(file2).forEach { audioStreamMap -> audioStreamsSet2.add(audioStreamMap.toAudioStream()) } } // Converta os sets de AudioStream de volta para listas de Map, se necessário val uniqueAudioStreams1 = audioStreamsSet1.map { it.toMap() } val uniqueAudioStreams2 = audioStreamsSet2.map { it.toMap() } val selectedAudioStreams = userNotifier.selectAudioStreams( uniqueAudioStreams1, uniqueAudioStreams2, file1, file2 ) val ffmpegCommand = buildFfmpegCommand(videoFile, selectedAudioStreams) commandRunner.runCommand(ffmpegCommand, streamsImplementations.first().getDuration(videoFile)) } // Extensão para converter AudioStream de volta para Map, se necessário fun AudioStream.toMap(): Map<String, String> { return mapOf( "index" to index, "language" to language, "codec_name" to codec, "sample_rate" to sampleRate, "channels" to channels, "bit_rate" to bitrate ) }- Atualizar a Função
createCheckboxpara UtilizarAudioStream
Ajuste a criação dos checkboxes para trabalhar com a nova estrutura
AudioStream.private fun createCheckbox(stream: AudioStream): JCheckBox { val checkboxText = "${messages.getString("idioma")}: ${stream.language} | " + "${messages.getString("codec")}: ${stream.codec} | " + "${messages.getString("taxa_amostragem")}: ${stream.sampleRate} Hz | " + "${messages.getString("canais")}: ${stream.channels} | " + "${messages.getString("taxa_bits")}: ${stream.bitrate}" return JCheckBox("Stream ${stream.index} - $checkboxText").also { logger.info("createCheckbox\n$it") } }- Atualizar o
userNotifier.selectAudioStreamspara Trabalhar comAudioStream
Certifique-se de que o método
selectAudioStreamsaceite e processe listas deAudioStreamem vez de listas deMap<String, String>. Caso contrário, adapte-o conforme necessário.Considerações Adicionais
-
Flexibilidade na Igualdade: A implementação de
equalsehashCodenaAudioStreamdefine o que constitui um stream único. Você pode ajustar esses métodos dependendo dos critérios que considera relevantes para identificar streams duplicados. -
Prioridade de Dados: Se houver dados conflitantes entre as diferentes implementações, você pode decidir qual implementação tem prioridade ou como combinar os dados.
-
Performance: Usar sets para deduplicação é eficiente, mas certifique-se de que a implementação de
equalsehashCodeseja adequada para o volume de dados que você está manipulando.
Alternativa: Uso de Mapas com Chaves Compostas
Se preferir não criar uma
data class, você pode usar umMapcom chaves compostas que representem a unicidade de um stream. Por exemplo:val audioStreamsMap1 = mutableMapOf<String, Map<String, String>>() streamsImplementations.forEach { streamImplementation -> streamImplementation.getAudioStreams(file1).forEach { audioStreamMap -> val key = "${audioStreamMap["index"]}_${audioStreamMap["codec_name"]}_${audioStreamMap["sample_rate"]}_${audioStreamMap["channels"]}" audioStreamsMap1.putIfAbsent(key, audioStreamMap) } } val uniqueAudioStreams1 = audioStreamsMap1.values.toList()Repita o mesmo para
file2. Essa abordagem cria uma chave única baseada nos campos que você considera relevantes, evitando a adição de streams duplicados.Conclusão
A chave para resolver a duplicação é normalizar os dados e definir critérios claros de unicidade para identificar e remover streams redundantes. Ao seguir os passos acima, você deve conseguir eliminar a duplicação de streams e manter apenas as informações relevantes provenientes de ambas as implementações de
Streams. - Normalizar os Streams: Transformar cada