1. Código para enviar MP3 mediante HTTP

El siguiente ejemplo en Java muestra cómo enviar un archivo MP3 a un servidor mediante una solicitud HTTP POST, utilizando la biblioteca Apache HttpClient para la transferencia multipart.

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class EnvioMp3PorHttp {
    public static void transferirMp3(String rutaLocal, String endpoint) {
        CloseableHttpClient clienteHttp = null;
        CloseableHttpResponse respuestaHttp = null;
        try {
            clienteHttp = HttpClients.createDefault();
            HttpPost peticion = new HttpPost(endpoint);
            FileBody archivoAdjunto = new FileBody(new File(rutaLocal));
            HttpEntity entidad = MultipartEntityBuilder.create()
                    .addPart("datos", archivoAdjunto)
                    .build();
            peticion.setEntity(entidad);
            respuestaHttp = clienteHttp.execute(peticion);
            System.out.println("Encabezado token: " + respuestaHttp.getFirstHeader("token"));
            HttpEntity cuerpoRespuesta = respuestaHttp.getEntity();
            if (cuerpoRespuesta != null) {
                System.out.println("Tamaño de respuesta: " + cuerpoRespuesta.getContentLength());
                System.out.println("Contenido: " + EntityUtils.toString(cuerpoRespuesta, Charset.forName("UTF-8")));
            }
            EntityUtils.consume(cuerpoRespuesta);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (respuestaHttp != null) respuestaHttp.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            try {
                if (clienteHttp != null) clienteHttp.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    public static void main(String[] argumentos) {
        EnvioMp3PorHttp.transferirMp3("D:\\audio\\grabacion.mp3", "http://localhost:9030/api/mp3");
    }
}

2. Código para grabar audio y guardarlo como archivo MP3

Este fragmento de Java utiliza la API de Sonido de Java para capturar audio desde el micrófono y guardarlo en un archivo MP3. Se controla el inicio y fin de la grabación mediante entradas del usuario.

import java.io.File;
import java.util.Scanner;
import javax.sound.sampled.AudioFileFormat;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.TargetDataLine;

public class GrabadoraAudio {
    private AudioFormat formato;
    private TargetDataLine lineaEntrada;

    public static void main(String[] argumentos) {
        new GrabadoraAudio();
    }

    public GrabadoraAudio() {
        System.out.println("Presione 'i' para iniciar, 'f' para finalizar");
        Scanner teclado = new Scanner(System.in);
        String comando = teclado.next();
        long tiempoInicio = System.currentTimeMillis();
        if (comando.equals("i")) {
            iniciarCaptura();
        }
        Scanner teclado2 = new Scanner(System.in);
        String comando2 = teclado2.next();
        if (comando2.equals("f")) {
            lineaEntrada.stop();
            lineaEntrada.close();
        }
        System.out.println("Duración: " + (System.currentTimeMillis() - tiempoInicio) / 1000 + " segundos");
    }

    private void iniciarCaptura() {
        try {
            formato = configurarFormato();
            DataLine.Info infoLinea = new DataLine.Info(TargetDataLine.class, formato);
            lineaEntrada = (TargetDataLine) AudioSystem.getLine(infoLinea);
            new HiloGrabacion().start();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    private AudioFormat configurarFormato() {
        float tasaMuestreo = 16000F;
        int bitsPorMuestra = 16;
        int canales = 1;
        boolean conSigno = true;
        boolean bigEndian = false;
        return new AudioFormat(tasaMuestreo, bitsPorMuestra, canales, conSigno, bigEndian);
    }

    class HiloGrabacion extends Thread {
        public void run() {
            AudioFileFormat.Type tipoArchivo = AudioFileFormat.Type.WAVE;
            File archivoSalida = new File("grabacion.mp3");
            try {
                lineaEntrada.open(formato);
                lineaEntrada.start();
                AudioSystem.write(new AudioInputStream(lineaEntrada), tipoArchivo, archivoSalida);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

3. Proceso para recibir y guardar MP3 meidante HTTP

Al recibir un archivo MP3 a través de HTTP, el enfoque principal es identificar los límites del contenido para extraer los datos binarios y almacenarlos como un archivo .mp3 válido. Esto implica analizar la estrcutura del archivo MP3 para determinar dónde comienza y termina el contenido real.

Existen dos escenarios comunes al trabajar con archivos MP3: archivos de música estándar y archivos grabados directamente. Los archivos de música pueden incluir encabezados de metadatos (como etiquetas ID3) o no, pero generalmente comienzan con un byte de inicio de trama (0xFF) y pueden terminar con un bloque de etiqeuta TAG de 128 bytes (0x54, 0x41, 0x47). Para estos archivos, se puede recortar cualquier información adicional al final sin afectar la reproducción.

En el caso de archivos MP3 generados por grabación de audio, la estructura suele ser más simple. Tras el análisis, se observa que estos archivos a menudo comienzan con una secuencia doble de saltos de línea (0x0D, 0x0A, 0x0D, 0x0A) y terminan con un salto de línea simple (0x0D, 0x0A). Para procesarlos, se extrae la sección entre estos delimitadores y se guarda como archivo MP3.

Este método permite manejar tanto MP3 de música como de grabación al enfocarse en patrones de bytes específicos para la extracción, garantizando la integridad del archivo guardado.