El archivo de video descomprimido no funciona en Java

Básicamente comprimo video usando la clase de compresor personalizada en Java. He reunido mis fragmentos de código completos aquí. Mi problema real es que el video generado [A.mp4] del conjunto de bytes descomprimido no se está ejecutando. De hecho, obtuve este código de clase de compresor a través de Internet. Como soy nuevo en la plataforma Java, estoy luchando por resolver este problema. ¿Podría alguien ayudarme en esto?

public class CompressionTest
{
    public static void main(String[] args)
    {
        Compressor compressor = new Compressor();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        FileInputStream fis=null;
        File file=null;

        try
        {
            URL uri=CompressionTest.class.getResource("/Files/Video.mp4");
            file=new File(uri.getPath());
            fis = new FileInputStream(file);
        } 
        catch ( FileNotFoundException fnfe )
        {
            System.out.println( "Unable to open input file");
        }

        try 
        {

            byte[] videoBytes = getBytesFromFile(file);

            System.out.println("CompressionVideoToCompress is: '" +videoBytes + "'");

            byte[] bytesCompressed = compressor.compress(videoBytes);

            System.out.println("bytesCompressed is: '" +bytesCompressed+ "'");

            byte[] bytesDecompressed=compressor.decompress(bytesCompressed);

            System.out.println("bytesDecompressed is: '" +bytesDecompressed+ "'");

            FileOutputStream out = new FileOutputStream("A.mp4");
            out.write(bytesDecompressed,0,bytesDecompressed.length-1);
            out.close();

        } 
        catch (IOException e) 
        {
            // TODO Auto-generated catch block
            System.out.println("bytesCompressed is: '");
        }


    }

    public static byte[] getBytesFromFile(File file) throws IOException 
    {
        InputStream is = new FileInputStream(file);

        // Get the size of the file
        long length = file.length();

        // You cannot create an array using a long type.
        // It needs to be an int type.
        // Before converting to an int type, check
        // to ensure that file is not larger than Integer.MAX_VALUE.
        if (length > Integer.MAX_VALUE) {
            // File is too large
        }

        // Create the byte array to hold the data
        byte[] bytes = new byte[1064];

        // Read in the bytes
        int offset = 0;
        int numRead = 0;
        while (offset < bytes.length
               && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0)
        {
            offset += numRead;
        }

        // Ensure all the bytes have been read in
        if (offset < bytes.length) {
            throw new IOException("Could not completely read file "+file.getName());
        }

        // Close the input stream and return bytes
        is.close();
        return bytes;
    }
}

class Compressor
{
    public Compressor()
    {}

    public byte[] compress(byte[] bytesToCompress)
    {        
        Deflater deflater = new Deflater();
        deflater.setInput(bytesToCompress);
        deflater.finish();

        byte[] bytesCompressed = new byte[Short.MAX_VALUE];

        int numberOfBytesAfterCompression = deflater.deflate(bytesCompressed);

        byte[] returnValues = new byte[numberOfBytesAfterCompression];

        System.arraycopy
        (
            bytesCompressed,
            0,
            returnValues,
            0,
            numberOfBytesAfterCompression
        );

        return returnValues;
    }

    public byte[] decompress(byte[] bytesToDecompress)
    {
        Inflater inflater = new Inflater();

        int numberOfBytesToDecompress = bytesToDecompress.length;

        inflater.setInput
        (
            bytesToDecompress,
            0,
            numberOfBytesToDecompress
        );

        int compressionFactorMaxLikely = 3;

        int bufferSizeInBytes =
            numberOfBytesToDecompress
            * compressionFactorMaxLikely;

        byte[] bytesDecompressed = new byte[bufferSizeInBytes];

        byte[] returnValues = null;

        try
        {
            int numberOfBytesAfterDecompression = inflater.inflate(bytesDecompressed);

            returnValues = new byte[numberOfBytesAfterDecompression];

            System.arraycopy
            (
                bytesDecompressed,
                0,
                returnValues,
                0,
                numberOfBytesAfterDecompression
            );            
        }
        catch (DataFormatException dfe)
        {
            dfe.printStackTrace();
        }

        inflater.end();

        return returnValues;
    }
}
Respuesta 1

He probado su código al comprimir y descomprimir un archivo TXT simple. El código está roto , ya que el archivo comprimido, cuando no está comprimido, es diferente del original.

Dé por sentado que el código está roto al menos en la getBytesFromFilefunción. Su lógica es complicada y problemática, ya que solo permite archivos de hasta 1064 de longitud y la comprobación (arrojar IOExceptioncuando se lee un archivo más largo) no funciona en absoluto. El archivo se lee solo parcialmente y no se produce ninguna excepción.

Lo que está tratando de lograr (compresión / descompresión de archivos) se puede hacer de esta manera. Lo he probado y funciona, solo necesitas esta biblioteca .

import java.io.*;
import java.util.zip.*;
import org.apache.commons.io.IOUtils; // <-- get this from http://commons.apache.org/io/index.html

public class CompressionTest2 {

    public static void main(String[] args) throws IOException {
        File input = new File("input.txt");
        File output = new File("output.bin");
        Compression.compress(input, output);
        File input2 = new File("input2.txt");
        Compression.decompress(output, input2);
        // At this point, input.txt and input2.txt should be equal
    }

}

class Compression {

    public static void compress(File input, File output) throws IOException {
        FileInputStream fis = new FileInputStream(input);
        FileOutputStream fos = new FileOutputStream(output);
        GZIPOutputStream gzipStream = new GZIPOutputStream(fos);
        IOUtils.copy(fis, gzipStream);
        gzipStream.close();
        fis.close();
        fos.close();
    }

    public static void decompress(File input, File output) throws IOException {
        FileInputStream fis = new FileInputStream(input);
        FileOutputStream fos = new FileOutputStream(output);
        GZIPInputStream gzipStream = new GZIPInputStream(fis);
        IOUtils.copy(gzipStream, fos);
        gzipStream.close();
        fis.close();
        fos.close();
    }

}

Este código no proviene de "fuentes confiables y / u oficiales" pero al menos funciona. :)

Además, para obtener más respuestas, ajuste el título indicando su problema real: sus archivos comprimidos no se descomprimen de la manera correcta. No hay cosas de 'video' aquí. Además, comprimir un .mp4archivo no es un logro (la relación de compresión probablemente sea de alrededor del 99,99%).

Respuesta: 2

No puedo cargar Java Runtime Environment cuando inicio SQLWorkbenchJ.app. Estoy en macOS Catalina 10.15.2, e instalé la aplicación con brew cask install sqlworkbenchj. Tengo JDK 8 de ...

Tengo una página jsp con una lista de nombres de aplicaciones con casillas de verificación para cada aplicación, y también hay un botón para guardar. Lo que necesito lograr es que necesito guardar estos valores marcados en db y ...

¿Puede alguien proporcionarme un ejemplo simple para configurar un archivo de flujo en un procesador Nifi personalizado para que la carga se pueda enviar a través del procesador PublishKafka? Tengo un protocolo de mensajería heredado ...

Estoy usando un XPage como agente (XAgent) que hace una llamada SSJS en algunas clases de Java almacenadas como elementos de diseño de Java. Quiero que los procesos que instiga XPage estén en el contexto de ...