/**
   * Toma un archivo de audio en formato WAV, obtiene el raw audio y le aplica la compresión de
   * acuerdo a las características indicadas, devolviendo el conjunto de buffers que contienen el
   * audio comprimido.
   *
   * @param audioOriginal Archivo de audio en formato WAV
   * @param formatoObjetivo Propiedades del audio comprimido. Debe ser de tipo <code>FormatoCodecGst
   *     </code>
   * @return Los buffers con el audio comprimido
   * @throws AudioException Si ocurre un error durante el procesamiento
   * @see CodificadorAudio
   * @see FormatoCodecGst
   * @see Pipeline
   * @see Element
   */
  public synchronized BuffersAudio codificar(File audioOriginal, FormatoCodec formatoObjetivo)
      throws AudioException {

    FormatoCodecGst formatoObjetivoGst = (FormatoCodecGst) formatoObjetivo;
    FormatoRawAudioGst formatoRawAudioGst =
        (FormatoRawAudioGst) formatoObjetivoGst.getFormatoRawAudio();

    // El pipeline de gstreamer para codificación está formado por:
    // filesrc | wavparse | audioresample | audioconvert | capsfilter | element(codificador) |
    // appsink
    this.pipeline = new Pipeline("pipeline");
    Bus bus = this.pipeline.getBus();
    this.audioException = null;

    // definición de elementos
    FileSrc filesrc = (FileSrc) ElementFactory.make("filesrc", "source");
    filesrc.setLocation(audioOriginal);
    // System.out.println(filesrc.get("location"));
    Element demuxer = ElementFactory.make("wavparse", "fileDecoder");
    Element ident = ElementFactory.make("identity", "ident");
    Element audioconvert = ElementFactory.make("audioconvert", "audio converter");
    Element audioresample = ElementFactory.make("audioresample", "audio resampler");
    Element capsfilterreq = ElementFactory.make("capsfilter", "capsfiltereq");

    capsfilterreq.setCaps(formatoObjetivoGst.getCapsNecesarios());

    Element codaudio = ElementFactory.make(formatoObjetivoGst.getGstCodificador(), "codaudio");

    // seleccion de propiedades de codec
    PropiedadesCodificador pc = formatoObjetivoGst.getPropiedadesCodec();
    int numeroPropiedades = pc.getNumeroPropiedades();

    String[] nombrePropiedades = pc.getNombrePropiedades();
    for (int i = 0; i < numeroPropiedades; i++) {

      codaudio.set(nombrePropiedades[i], pc.getValorPropiedad(nombrePropiedades[i]));
    }

    AppSink appsink = (AppSink) ElementFactory.make("appsink", "appsink");
    appsink.set("emit-signals", true);
    appsink.set("sync", false);

    // creación del pipeline
    this.pipeline.addMany(
        filesrc, demuxer, ident, audioresample, audioconvert, capsfilterreq, codaudio, appsink);
    Element.linkMany(filesrc, demuxer);
    Element.linkMany(ident, audioresample, audioconvert, capsfilterreq, codaudio, appsink);

    // añadir listeners
    // enlace dinámico para el decodificador del fichero
    CodificadorAudioGst.SignalPadAdded signalPadAdded =
        new CodificadorAudioGst.SignalPadAdded(ident);
    demuxer.connect(signalPadAdded);

    // manejo del flujo de bytes en el pipeline
    CodificadorAudioGst.NewBufferSignal newBufferSignal =
        new CodificadorAudioGst.NewBufferSignal(appsink);
    appsink.connect(newBufferSignal);

    // fin de stream
    bus.connect(new CodificadorAudioGst.SignalBusEos());
    // error en el procesamient
    bus.connect(new CodificadorAudioGst.SignalBusError());

    // inicio la codificación
    this.pipeline.play();

    // esperar el fin de la codificación
    this.semaforo.acquireUninterruptibly();

    formatoObjetivoGst.setCapsCodificacion(newBufferSignal.capsCodificacion);
    formatoRawAudioGst.setCapsRawAudio(signalPadAdded.caps);

    newBufferSignal.buffersAudio.setFormatoCodec(formatoObjetivoGst);

    this.pipeline.dispose();

    if (this.audioException != null) throw this.audioException;

    return newBufferSignal.buffersAudio;
  }
  /**
   * Toma un cojunto de buffers de audio y le aplica el proceso de descompresión generando un
   * archivo en formato WAV con el resultado de la descompresión.
   *
   * @param targetFile El archivo de audio WAV que contendrá el audio descomprimido
   * @param audioCodificado Los buffers de audio comprimido. Las propiedades de audio que deben
   *     obtenerse mediante un objeto tipo <code>FormatoCodecGst</code>
   * @return El archivo de audio WAV que contendrá el audio descomprimido
   * @throws AudioException Si ocurre un error durante el procesamiento
   * @see BuffersAudio
   * @see FormatoCodecGst
   * @see Pipeline
   * @see Element
   */
  public synchronized File decodificar(File targetFile, BuffersAudio audioCodificado)
      throws AudioException {

    FormatoCodecGst formatoOrigenGst = (FormatoCodecGst) audioCodificado.getFormatoCodec();
    FormatoRawAudioGst formatoRawAudioGst =
        (FormatoRawAudioGst) formatoOrigenGst.getFormatoRawAudio();
    // El pipeline de gstreamer para decodificación está formado por:
    // appsrc | capsfilter | element(decodifcador) | audioconvert | audioresample | capsfilter |
    // wavenc | filesink
    this.pipeline = new Pipeline("pipeline");
    Bus bus = this.pipeline.getBus();
    this.audioException = null;

    // definición de elementos
    AppSrc appsrc = (AppSrc) ElementFactory.make("appsrc", "appsrc");
    Element capsfilterin = ElementFactory.make("capsfilter", "capsfilterint");

    capsfilterin.setCaps(formatoOrigenGst.getCapsCodificacion());

    Element decodaudio = ElementFactory.make(formatoOrigenGst.getGstDecodificador(), "decodaudio");

    Element audioconvert = ElementFactory.make("audioconvert", "audioconvert");
    Element audioresample = ElementFactory.make("audioresample", "audioresample");
    Element muxer = ElementFactory.make("wavenc", "fileEncoder");
    Element filesink = ElementFactory.make("filesink", "filesink");
    filesink.set("location", targetFile);
    Element capsfilterout = ElementFactory.make("capsfilter", "capsfilterout");
    capsfilterout.setCaps(formatoRawAudioGst.getCapsRawAudio());

    this.pipeline.addMany(
        appsrc,
        capsfilterin,
        decodaudio,
        audioconvert,
        audioresample,
        capsfilterout,
        muxer,
        filesink);
    Element.linkMany(
        appsrc,
        capsfilterin,
        decodaudio,
        audioconvert,
        audioresample,
        capsfilterout,
        muxer,
        filesink);

    // manejo del flujo de bytes en el pipeline
    CodificadorAudioGst.NeedDataSignal needDataSignal =
        new CodificadorAudioGst.NeedDataSignal(appsrc, audioCodificado);
    appsrc.connect(needDataSignal);

    // añadir listeners
    bus.connect(new CodificadorAudioGst.SignalBusEos());
    bus.connect(new CodificadorAudioGst.SignalBusError());

    // inicio de la decodificación
    this.pipeline.play();
    // esperar el fin de la decodificación
    this.semaforo.acquireUninterruptibly();

    this.pipeline.dispose();
    if (this.audioException != null) throw this.audioException;
    return targetFile;
  }