void MediaPlayer(bool isWav = false) {
    
    // Generamos el media descriptor
    String mediapath = "";
    File32 file;
    mediapath = FILE_LAST_DIR + "_files.lst";
    if(!file.open(mediapath.c_str(), O_RDONLY))
    {
      LAST_MESSAGE = "Error opening file list";
      return;
    }
    // else
    // {
    //   // Llenamos la playlist
    //   // fillMediaDescriptor(file, isWav);
    // }

    // Setup
    // Configuramos el amplificador de salida
    kitStream.setPAPower(ACTIVE_AMP);
    kitStream.setVolume(MAIN_VOL / 100);

    // Configuración de la fuente de audio
    AudioSourceSDFAT source(sdf);
    source.setPath(FILE_LAST_DIR.c_str());
    source.setFileFilter(isWav ? "*.wav" : "*.mp3");
    // Configuración del decodificador
    MP3DecoderHelix decoderMP3;
    WAVDecoder decoderWAV;
    MetaDataFilterDecoder metadatafilter(decoderMP3);
    metadatafilter.addNotifyAudioChange(kitStream);
    //metadatafilter.begin();

    // Usamos un puntero a la clase base común
    // AudioDecoder decoderMP3;
    // AudioDecoder decoderWAV;
    //AudioDecoder *decoder = isWav ? static_cast<AudioDecoder*>(&decoderWAV) : static_cast<AudioDecoder*>(&metadatafilter);

    // Configuración del reproductor
    AudioPlayer player;
    player.setAudioSource(source);
    player.setOutput(kitStream);
    if (isWav)
    {
      player.setDecoder(decoderWAV); // Usamos el puntero al decodificador WAV
    }
    else
    {
      player.setDecoder(metadatafilter); // Usamos el puntero al decodificador MP3
    }

    //player.setDecoder(*decoder); // Usamos el puntero al decodificador
    player.setVolume(1);
    player.setBufferSize(512 * 1024); // Buffer de 512 KB
    player.setAutoNext(false);

    // Configuración del ecualizador
    audio_tools::Equalizer3Bands eq(kitStream);
    audio_tools::ConfigEqualizer3Bands cfg_eq;
    //audio_tools::ConfigEqualizer3Bands cfg_eq = eq.defaultConfig();
    cfg_eq.gain_low = EQ_LOW;
    cfg_eq.gain_medium = EQ_MID;
    cfg_eq.gain_high = EQ_HIGH;
    eq.addNotifyAudioChange(kitStream);
    eq.begin(cfg_eq);

    // decoder->setOutput(eq);
    // decoder->addNotifyAudioChange(kitStream);
    // decoder->begin();

    if (isWav)
    {
      decoderWAV.addNotifyAudioChange(kitStream);
      //decoderWAV.begin();

      player.setAudioSource(source);
      player.setOutput(eq);
      player.setDecoder(decoderWAV);
      decoderWAV.begin();
    }
    else
    {
      decoderMP3.addNotifyAudioChange(kitStream);
      // decoderMP3.begin();

      player.setAudioSource(source);
      player.setOutput(eq);
      player.setDecoder(metadatafilter);
      decoderMP3.begin();
    }


    // Inicialización del reproductor
    //player.addNotifyAudioChange(decoder);
    if (!player.begin()) {
        logln("Error player initialization");
        STOP = true;
        PLAY = false;
        return;
    }

    // Variables del bucle

    // Esto lo hacemos para capturar el fichero seleccionado
    source.selectStream(PATH_FILE_TO_LOAD.c_str()); // Seleccionamos el archivo actual
    source.setIndex(findIDByLastField(file, FILE_LOAD.c_str()) - 1); // Buscamos el índice del archivo actual

    // Cogemos mas info e inicializamos variables
    size_t fileSize = getStreamfileSize(PATH_FILE_TO_LOAD);
    size_t fileread = 0;
    int bitRateRead = isWav ? decoderWAV.audioInfoEx().byte_rate : decoderMP3.audioInfoEx().bitrate;
    int totalFilesIdx = source.size();
    int currentIdx = source.index(); // El índice actual del archivo
    int stateStreamplayer = 0;
    unsigned long lastUpdate = millis();
    unsigned long twiceRWDTime = millis();
    int last_blockSelected = 0;
    bool was_pressed_wd = false;
    //
    TOTAL_BLOCKS = totalFilesIdx + 1;
    BLOCK_SELECTED = currentIdx + 1; // Para mostrar el bloque seleccionado en la pantalla

    // Esto lo hacemos para coger el sampling rate del PLAYER
    sample_rate_t srd = player.audioInfo().sample_rate;
    hmi.writeString("tape.lblFreq.txt=\"" + String(int(srd/1000)) + "KHz\"" );   
    // Esto lo hacemos para poder abrir el block browser sin haber pulsado PLAY.
    hmi.writeString("tape.BBOK.val=1");
    // Actualización inicial de indicadores
    updateIndicators(totalFilesIdx, source.index() + 1, fileSize, bitRateRead, source.toStr());

    // Bucle principal
    while (!EJECT && !REC) 
    {
        // Actualizamos el volumen y el ecualizador si es necesario
        kitStream.setVolume(MAIN_VOL / 100);
        if (EQ_CHANGE) {
            EQ_CHANGE = false;
            cfg_eq.gain_low = EQ_LOW;
            cfg_eq.gain_medium = EQ_MID;
            cfg_eq.gain_high = EQ_HIGH;
            eq.begin(cfg_eq);
        }
        // Estados del reproductor
        switch (stateStreamplayer) {
            case 0: // Esperando reproducción
                if (PLAY) 
                {
                    player.begin(currentIdx); // Iniciamos el reproductor
                    stateStreamplayer = 1;
                    tapeAnimationON();
                }
                break;

            case 1: // Reproduciendo
                fileread += player.copy();
                if (fileSize > 0) {
                    PROGRESS_BAR_TOTAL_VALUE = (fileread * 100) / fileSize;
                }
 
                // Actualizamos indicadores cada 4 segundos
                if (millis() - lastUpdate > 2000) 
                {
                    updateIndicators(totalFilesIdx, source.index()+1, fileSize, bitRateRead, source.toStr());
                    lastUpdate = millis();
                }

                // Verificamos si se terminó el archivo
                // if (fileread >= fileSize) 
                // {
                //     if (!disable_auto_media_stop)
                //     {
                //       stateStreamplayer = 4; // Auto-stop      
                //     }
                // }

                if (STOP) 
                {
                  stateStreamplayer = 0;
                  fileread = 0;
                  tapeAnimationOFF();
                }    
                
                if (PAUSE) 
                {
                  stateStreamplayer = 2; // Pausa
                  tapeAnimationOFF();
                  PLAY=false;
                  PAUSE=false;
                }  
                break;

            case 2: // PAUSE
                if (PAUSE || PLAY)
                {
                  stateStreamplayer = 1; // Reproduciendo
                  tapeAnimationON();
                  PAUSE = false;
                }
                else if (STOP)
                {
                  stateStreamplayer = 0;
                  fileread = 0;
                  tapeAnimationOFF();
                }
                break;
            
            case 4: // Auto-stop
                tapeAnimationOFF();
                stateStreamplayer = 0;
                PLAY = false;
                STOP = true;
                break;                
            
            default:
                break;
        }

        // Control de avance/retroceso
        if ((FFWIND || RWIND) && !was_pressed_wd) 
        {
            rewindAnimation(FFWIND ? 1 : -1);
            if (FFWIND) 
            {
              player.next();
            } 
            else
            {
              if (millis() - twiceRWDTime > 5000)
              {
                // Empiezo desde el principio
                player.begin(source.index());
                twiceRWDTime = millis();
              }
              else
              {
                // Si pulso rapido en los proximos segundos               
                player.previous();
              }
            }

            // delay(250);
            currentIdx = source.index();
            player.begin(currentIdx);
            delay(250);
            fileSize = getStreamfileSize(source.toStr());

            if (isWav)
            {

              if (decoderWAV.audioInfo().bits_per_sample == 8)
              {
                // Cambiamos el sampling rate a 22KHz para el kitStream
                //                
                hmi.writeString("tape.wavind.txt=\"WAV8\"");
              }
              else
              {
                if (OUT_TO_WAV)
                {
                  hmi.writeString("tape.wavind.txt=\"WAV\"");
                }
                else
                {
                  hmi.writeString("tape.wavind.txt=\"\"");
                }
              }              
            }
       
            // Esto lo hacemos para coger el sampling rate
            sample_rate_t srd = player.audioInfo().sample_rate;
            hmi.writeString("tape.lblFreq.txt=\"" + String(int(srd/1000)) + "KHz\"" );            

            if ((source.index() > (source.size()-1)))
            {
              if(disable_auto_media_stop) 
              {
                source.selectStream(0);
                //source.setIndex(0);
                currentIdx = 0;
                player.begin(); // Reiniciar el reproductor
              } 
              else if (!disable_auto_media_stop && (source.index() > (source.size()-1))) 
              {
                source.selectStream(0);  
                //source.setIndex(0);            
                currentIdx = 0;
                player.begin(); // Reiniciar el reproductor
                player.stop(); // Detener el reproductor
                fileSize = getStreamfileSize(source.toStr());
                STOP=true;
                PLAY=false;
              } 
            }   
            FFWIND = RWIND = false;
            fileread = 0;
            //
            updateIndicators(totalFilesIdx, source.index() + 1, fileSize, bitRateRead, source.toStr());
        }
        else
        {
          was_pressed_wd = false;
          //
          KEEP_FFWIND = false;
          KEEP_RWIND = false;
          //
          FFWIND = false;
          RWIND = false;
        }
   
        if (KEEP_FFWIND || KEEP_RWIND) 
        {
            if (KEEP_FFWIND)
            {
              // Avance rapido
              fileread += player.copy(5 * DEFAULT_BUFFER_SIZE);
            }
            else
            {
              // Retroceso rapido
              if (fileread > (5 * DEFAULT_BUFFER_SIZE))
              {
                fileread = player.copy(fileread - (5 * DEFAULT_BUFFER_SIZE));
              }
            }

            if (fileSize > 0) 
            {
              PROGRESS_BAR_TOTAL_VALUE = (fileread * 100) / fileSize;
            }
            //
            // Esto se usa para evitar entrar en FFWD o RWD despues de una pulsacion prolongada (y soltar)
            was_pressed_wd = true;
         }
        // Seleccion de pista
        if (UPDATE)
        {
          // Si el bloque seleccionado es válido y no es el último
          if (BLOCK_SELECTED > 0 && (BLOCK_SELECTED <= (totalFilesIdx+1))) {
              // Reproducir el bloque seleccionado
              //source.selectStream((FILE_LAST_DIR + findLastFieldByID(file,BLOCK_SELECTED)).c_str());
              source.setIndex(BLOCK_SELECTED); // Buscamos el índice del archivo actual
              currentIdx = source.index() - 1; // Buscamos el índice del archivo actual
          } else {
              // Reproducir desde el principio
              currentIdx = 0;
              source.selectStream(0);
          }  
          // Actualizamos de manera inmediata
          //

          player.begin(currentIdx); // Iniciamos el reproductor      
          delay(250);
            
          fileSize = getStreamfileSize(source.toStr());

          // Esto lo hacemos para coger el sampling rate
          sample_rate_t srd = player.audioInfo().sample_rate;
          hmi.writeString("tape.lblFreq.txt=\"" + String(int(srd/1000)) + "KHz\"" );    
          bitRateRead = isWav ? decoderWAV.audioInfoEx().byte_rate : decoderMP3.audioInfoEx().bitrate;
          updateIndicators(totalFilesIdx, source.index() + 1, fileSize, bitRateRead, source.toStr());  
          //                
          UPDATE = false;                
        }

        if (BB_OPEN || BB_UPDATE)
        {
          last_blockSelected = BLOCK_SELECTED;
          //
          hmi.openBlockMediaBrowser(source);
          //delay(25);
          hmi.openBlockMediaBrowser(source);
          BB_OPEN = false;
          BB_UPDATE = false; 
        }

        if (UPDATE_HMI)
        {
          if (BLOCK_SELECTED > 0 && BLOCK_SELECTED <= TOTAL_BLOCKS)
          {
              // Actualizamos la pantalla HMI con el nombre del archivo actual
              //source.selectStream((FILE_LAST_DIR + myMediaDescriptor[BLOCK_SELECTED-1].name).c_str());
              // Cogemos el indice que empieza desde 0 ..
              source.setIndex(BLOCK_SELECTED - 1); // Buscamos el índice del archivo actual
              currentIdx = source.index();

              // logln("Update HMI");
              // logln("------------------------------");
              // logln("Block selected: " + String(BLOCK_SELECTED));
              // logln("source index: " + String(source.index()));

              // Inicializamos el player con ese indice
              player.begin(currentIdx); // Iniciamos el reproductor

              // Cogemos informacion del fichero
              delay(250);
              fileSize = getStreamfileSize(source.toStr());
              
              // Esto lo hacemos para coger el sampling rate
              sample_rate_t srd = player.audioInfo().sample_rate;
              hmi.writeString("tape.lblFreq.txt=\"" + String(int(srd/1000)) + "KHz\"" );                         
              // Actualizamos HMI
              updateIndicators(totalFilesIdx, source.index()+1, fileSize, bitRateRead, source.toStr());  

              #ifdef DEBUGMODE
                  logln("Update HMI: " + String(BLOCK_SELECTED) + " - " + String(totalFilesIdx));
                  logln("Current IDX: " + String(currentIdx));
                  logln("Current file: " + String(source.toStr()));
                  logln("Current file size: " + String(fileSize) + " bytes");
                  logln("Current file bitrate: " + String(bitRateRead) + " bps");
                  logln("Current file index: " + String(source.index()));
                  logln("Current file name: " + String(myMediaDescriptor[BLOCK_SELECTED-1].name));
                  logln("Current file path: " + String(myMediaDescriptor[BLOCK_SELECTED-1].path));
                  logln("Current file ID: " + String(myMediaDescriptor[BLOCK_SELECTED-1].ID));
              #endif                    
          }
          else
          {
            BLOCK_SELECTED = last_blockSelected;
          }

          UPDATE_HMI = false;
        }        
   
   }

    // Finalización
    tapeAnimationOFF();
    player.end();
    eq.end();
    //decoder->end();
    decoderMP3.end();
    decoderWAV.end(); 
    source.end();
    file.close();
}