Recherche avancée

Sur d’autres sites (4997)

• Best way to stream FFMPEG conversion to HTML5 video element ?

  4 août 2021, par SamTheFam

  Context

  


  Me and my friend are currently working on a media player desktop application using Electron (which implements website code into a desktop application). For the video element we are using the HTML5 video element, and loading a video from the user's local machine. Most browsers only support MP4, OGG, and WebM (Mozilla Specification), but we would like to support more formats to make it applicable to more users. For this reason, we decided to use the FFMPEG video converter. As FFMPEG takes some time to convert videos, we would like to have a streaming implementation that converts the video while playing the HTML5 video.

  


  The Problem

  


  The problem is that we cannot figure out the best way to stream our video whilst it is converting to another format. The primary issue is that we are unsure how we can implement skipping in the video, where we convert that specfic point if skipped to.

  


  For further clarification of the issue, if a user provided a .mkv file, we would start the FFMPEG conversion to .mp4, and would convert enough for the video to start playing. While the video is being watched, FFMPEG would continue converting before the user has reached that point in the video. If a user wanted to skip through the video, we would need a way to fast-forward the conversion to a specific point in the video, thus allowing the user to watch that section of the video, if it has not already been converted.

  


  Ideally we would like the conversion to be faster than the playback of the video, but if this has a cost in quality, we would prefer to make it optional to the end user.

  


  The first solution that came to our heads was to convert small sections of the video, and produce many small (3-5 second) videos, that would be loaded into the video element respectively. The issue here is that the video element takes quite a lot of time to load new source files and as a result make an awful user experience, with the video going black every x seconds.

  


  Another possible solution we stumbled accross was mentioned here. If we were to implement this, we would start a HTTP server on the user's local machine. The issue we had with this is that it could be a rather bloated solution and could be tedious to maintain. Along with this, it would likely slow down the start time for the application, and the runtime as well.

  


  Thank you in advance, we look forward to your responses.

  


• on('progress') not working - node.js ytdl-core fluent-ffmpeg

  9 juillet 2018, par TheBandolero

  So i’m playing with this libraries ytdl-core and fluent-ffmpeg, and basically i got to this function by modifying some examples to fit what i wanted.

  everything works fine except for the second on('progress', progress => ....) call. The first one works as expected, but the second one looks like it isn’t even reached, since Console.log() inside the second on('progress'....) isn’t logging anything at all.

  Also console doesn’t show any errors throughout the whole function, and the outcome is the expected without any problem, except for the second on('progress') issue.

  I can’t figure out what the problem is, so I hope somebody with more experience can point the problem out to me, since it’s getting quite frustrating now...

  function descargarVideoHD(link) {
  
          ytdl.getInfo(link, (err, info) => {
  
              if (err) throw err;
  
  
  
              $('li:contains(' + link + ') .progress').css("visibility", "visible");
  
  
  
              var longitudEnTiempo = parseInt(info.length_seconds);
  
              let id = ytdl.getURLVideoID(link);
  
              var titulo = limpiarTituloDelVideo(info.title);
  
  
  
              let stream = ytdl(id, {
  
                  quality: 'highestaudio',
  
                  //filter: 'audioonly',
  
              });
  
  
  
              //var audioOutput = path.resolve(__dirname, 'audio_' + titulo + '.mp4');
  
              var mainOutput = path.resolve(__dirname, titulo + '.mp4');
  
              var renameFileName = titulo + '.mp4';
  
  
  
              var audioOutput = path.resolve(__dirname, titulo + '.mp3');
  
  
  
              ffmpeg(stream)
  
                  //.audioBitrate(128)
  
                  .audioBitrate(256)
  
                  .save(`${__dirname}/${titulo}.mp3`)
  
                  .on('progress', (p) => {
  
                      //readline.cursorTo(process.stdout, 0);
  
                      //process.stdout.write(`${p.targetSize}kb downloaded`);
  
                      var hmsA = p.timemark;
  
                      var aA = hmsA.split(':');
  
                      var secondsA = parseInt((+aA[0]) * 60 * 60 + (+aA[1]) * 60 + (+aA[2]));
  
                      var porcentageA = (((secondsA / longitudEnTiempo) * 100) / 2).toFixed(2);
  
                      $('li:contains(' + link + ') .progress .determinate').css("width", porcentageA + "%");
  
                      //console.log(titulo + ' procesado al ' + porcentage + '%');
  
                  })
  
                  .on('end', () => {
  
                      ffmpeg()
  
                          .input(ytdl(link, {
  
                              filter: format => {
  
                                  return format.container === 'mp4' && !format.audioEncoding;
  
                              }
  
                          }))
  
                          .videoCodec('copy')
  
                          .input(audioOutput)
  
                          .audioCodec('copy')
  
                          .save(mainOutput)
  
                          .on('error', console.error)
  
                          .on('progress', progress => {
  
                              console.log('Dentro de OnProgress...');
  
                              var hms = progress.timemark;
  
                              console.log('Timemark: ' + hms);
  
                              var a = hms.split(':');
  
                              var seconds = parseInt((+a[0]) * 60 * 60 + (+a[1]) * 60 + (+a[2]));
  
                              console.log('Segundos: ' + seconds);
  
                              var porcentage = ((((seconds / longitudEnTiempo) * 100) / 2) + 50).toFixed(2);
  
                              console.log('Procesado al ' + porcentage + '%');
  
                              $('li:contains(' + link + ') .progress .determinate').css("width", porcentage + "%");
  
                          }).on('end', () => {
  
                              fs.unlink(audioOutput, err => {
  
                                  if (err) {
  
                                      console.error(err);
  
                                  }
  
                                  else {
  
                                      $('li:contains(' + link + ') .progress .determinate').css("width", "100%");
  
                                      $('li:contains(' + link + ') .secondary-content.material-icons').text('done');
  
                                      $('li:contains(' + link + ') .secondary-content.material-icons').addClass('text-green');
  
                                      /* $('li:contains(' + link + ')').remove();
  
                                      var indexItem = listaEnlacesYoutube.indexOf(link);
  
                                      listaEnlacesYoutube.splice(indexItem, 1); */
  
                                  }
  
                              });
  
                          });
  
                  });
  
          });
  
      }

• Wav file conversion/resampling options in C#

  7 juin 2021, par oceansmoving

  Background :

  


  Trying to convert various wav files to a format that is accepted by the game CS:GO.
So as you can see below in the source code for a VB application that is successfully doing this (https://github.com/SilentSys/SLAM/blob/master/SLAM/Form1.vb), it's supposed to be :

  


  

  • Mono

  


  • 16 Bit

  


  • 22050hz

  


  


      Private Sub FFMPEG_ConvertAndTrim(inpath As String, outpath As String, samplerate As Integer, channels As Integer, starttrim As Double, length As Double, volume As Double)
        Dim convert As New FFMpegConverter()
        convert.ExtractFFmpeg()

        Dim trimstring As String
        If length > 0 Then
            trimstring = String.Format("-ss {0} -t {1} ", starttrim.ToString("F5", Globalization.CultureInfo.InvariantCulture), length.ToString("F5", Globalization.CultureInfo.InvariantCulture))
        End If

        Dim command As String = String.Format("-i ""{0}"" -n -f wav -flags bitexact -map_metadata -1 -vn -acodec pcm_s16le -ar {1} -ac {2} {3}-af ""volume={4}"" ""{5}""", Path.GetFullPath(inpath), samplerate, channels, trimstring, volume.ToString("F5", Globalization.CultureInfo.InvariantCulture), Path.GetFullPath(outpath))
        convert.Invoke(command)
    End Sub


  


  Now, the thing is I have very little experience with VB, and as it is C# I am trying to learn I don't want this to be a showstopper.

  


  I have been able, in various ways to convert files that seem to be the correct format and can be played by normal media players, but is not accepted by the game, like the files converted with VB.

  


  The different methods I've been trying without success :

  


              int outRate = 22050;


  


              using (var reader = new MediaFoundationReader(inFile))
            {
                var outFormat = new WaveFormat(outRate, 1);
                using (var resampler = new WaveFormatConversionStream(outFormat, reader))
                {
                    WaveFileWriter.CreateWaveFile(outFile, resampler);
                }
            }


  


  Next one gives me an error that everyone is referring to the LT version of the package to solve, that in turn requires license...

  


              var ffMpeg = new FFMpegConverter();

            String args = $"-i '{@inFile}' -n -f wav -flags bitexact -map_metadata -1 -vn -acodec pcm_s16le -ar {outRate} -ac 1 '{@outFile}'";
            ffMpeg.Invoke(args);


  


  Another

  


          using (WaveFileReader reader = new WaveFileReader(inFile))
            {
                var outFormat = new WaveFormat(outRate, 1);
                using (var resampler = new MediaFoundationResampler(reader, outFormat))
                {
                    WaveFileWriter.CreateWaveFile(outFile, resampler);
                }
            }


  


  Another

  


                      FileStream fileStream = new FileStream(inFile, FileMode.Open);
                    WaveFormat waveFormat = new WaveFormat(22050, 16, 1);
                    var reader = new RawSourceWaveStream(fileStream, waveFormat);
                    using (WaveStream convertedStream = WaveFormatConversionStream.CreatePcmStream(reader))
                    {
                        WaveFileWriter.CreateWaveFile(outFile, convertedStream);
                    }
                    fileStream.Close();