Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

override fun merge( file1: File, file2: File, commandRunner: CommandRunner,…

  1. 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.

  2. Assistant

    Entendi o problema que você está enfrentando com a duplicação de audioStreams devido às diferentes implementações de Streams (como mediainfo e ffmpeg). 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 é:

    1. Normalizar os Streams: Transformar cada Map<String, String> em uma classe de dados (data class) com campos padronizados.
    2. Definir Critérios de Unicidade: Decidir quais campos identificam exclusivamente um stream (por exemplo, index, codec, language, etc.).
    3. Usar uma Coleção que Evite Duplicatas: Utilizar um Set para armazenar os streams normalizados, garantindo que streams duplicados não sejam adicionados.

    Passo a Passo Detalhado

    1. Defina uma Classe de Dados para Normalizar os Streams

    Crie uma data class que 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
        }
    }
    
    1. Função de Conversão para Normalizar os Maps

    Crie uma função que converte um Map<String, String> em um objeto AudioStream, 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)
    }
    
    1. Modificar a Função merge para Utilizar a Normalização e Deduplicação

    Atualize sua função merge para usar a AudioStream e um Set para 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
        )
    }
    
    1. Atualizar a Função createCheckbox para Utilizar AudioStream

    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") }
    }
    
    1. Atualizar o userNotifier.selectAudioStreams para Trabalhar com AudioStream

    Certifique-se de que o método selectAudioStreams aceite e processe listas de AudioStream em vez de listas de Map<String, String>. Caso contrário, adapte-o conforme necessário.

    Considerações Adicionais

    • Flexibilidade na Igualdade: A implementação de equals e hashCode na AudioStream define 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 equals e hashCode seja 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 um Map com 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.