Recherche avancée

Sur d’autres sites (3735)

• Using ffmpeg to convert voice recording captured by HTML5

  8 juillet 2014, par user3789242

  I’m building an HTML5 voice recording software with visualizer.I want the user when recording the voice, and after uploading the file as wave in a blob (server-side), the user should be able to select the audio format of that file using ffmpeg. what I Have achieved so far is uploading the file as wave.what I still want to do is :

  • On the server
  • side pick your preferable web programming framework
  • The web programming framework accepts the upload and stores the file on the server
  • The web programming framework runs a ffmpeg (command line) which processes the file
  • The user can download the processed file

  here is my code so far :

  // variables
  
  var leftchannel = [];
  
  var rightchannel = [];
  
  var recorder = null;
  
  var recording = false;
  
  var recordingLength = 0;
  
  var volume = null;
  
  var audioInput = null;
  
  var sampleRate = 44100;
  
  var audioContext = null;
  
  var context = null;
  
  var outputString;
  
  
  
  
  
  
  
  if (!navigator.getUserMedia)
  
      navigator.getUserMedia = navigator.getUserMedia ||
  
      navigator.webkitGetUserMedia ||
  
      navigator.mozGetUserMedia ||
  
      navigator.msGetUserMedia;
  
  
  
  if (navigator.getUserMedia) {
  
      navigator.getUserMedia({
  
          audio: true
  
      }, success, function (e) {
  
          alert('Error capturing audio.');
  
      });
  
  } else alert('getUserMedia not supported in this browser.');
  
  
  
  
  
  
  
  function getVal(value) {
  
  
  
      // if R is pressed, we start recording
  
      if (value == "record") {
  
          recording = true;
  
          // reset the buffers for the new recording
  
          leftchannel.length = rightchannel.length = 0;
  
          recordingLength = 0;
  
          document.getElementById('output').innerHTML = "Recording now...";
  
  
  
          // if S is pressed, we stop the recording and package the WAV file
  
      } else if (value == "stop") {
  
  
  
          // we stop recording
  
          recording = false;
  
          document.getElementById('output').innerHTML = "Building wav file...";
  
  
  
          // we flat the left and right channels down
  
          var leftBuffer = mergeBuffers(leftchannel, recordingLength);
  
          var rightBuffer = mergeBuffers(rightchannel, recordingLength);
  
          // we interleave both channels together
  
          var interleaved = interleave(leftBuffer, rightBuffer);
  
  
  
  
  
  
  
          var buffer = new ArrayBuffer(44 + interleaved.length * 2);
  
          var view = new DataView(buffer);
  
  
  
          // RIFF chunk descriptor
  
          writeUTFBytes(view, 0, 'RIFF');
  
          view.setUint32(4, 44 + interleaved.length * 2, true);
  
          writeUTFBytes(view, 8, 'WAVE');
  
          // FMT sub-chunk
  
          writeUTFBytes(view, 12, 'fmt ');
  
          view.setUint32(16, 16, true);
  
          view.setUint16(20, 1, true);
  
          // stereo (2 channels)
  
          view.setUint16(22, 2, true);
  
          view.setUint32(24, sampleRate, true);
  
          view.setUint32(28, sampleRate * 4, true);
  
          view.setUint16(32, 4, true);
  
          view.setUint16(34, 16, true);
  
          // data sub-chunk
  
          writeUTFBytes(view, 36, 'data');
  
          view.setUint32(40, interleaved.length * 2, true);
  
  
  
  
  
          var lng = interleaved.length;
  
          var index = 44;
  
          var volume = 1;
  
          for (var i = 0; i < lng; i++) {
  
              view.setInt16(index, interleaved[i] * (0x7FFF * volume), true);
  
              index += 2;
  
          }
  
  
  
          var blob = new Blob([view], {
  
              type: 'audio/wav'
  
          });
  
  
  
          // let's save it locally
  
  
  
          document.getElementById('output').innerHTML = 'Handing off the file now...';
  
          var url = (window.URL || window.webkitURL).createObjectURL(blob);
  
  
  
          var li = document.createElement('li');
  
          var au = document.createElement('audio');
  
          var hf = document.createElement('a');
  
  
  
          au.controls = true;
  
          au.src = url;
  
          hf.href = url;
  
          hf.download = 'audio_recording_' + new Date().getTime() + '.wav';
  
          hf.innerHTML = hf.download;
  
          li.appendChild(au);
  
          li.appendChild(hf);
  
          recordingList.appendChild(li);
  
  
  
      }
  
  }
  
  
  
  
  
  function success(e) {
  
  
  
      audioContext = window.AudioContext || window.webkitAudioContext;
  
      context = new audioContext();
  
  
  
  
  
      volume = context.createGain();
  
  
  
      // creates an audio node from the microphone incoming stream(source)
  
      source = context.createMediaStreamSource(e);
  
  
  
      // connect the stream(source) to the gain node
  
      source.connect(volume);
  
  
  
      var bufferSize = 2048;
  
  
  
      recorder = context.createScriptProcessor(bufferSize, 2, 2);
  
  
  
      //node for the visualizer
  
      analyser = context.createAnalyser();
  
      analyser.smoothingTimeConstant = 0.3;
  
      analyser.fftSize = 512;
  
  
  
      splitter = context.createChannelSplitter();
  
      //when recording happens
  
      recorder.onaudioprocess = function (e) {
  
  
  
          if (!recording) return;
  
          var left = e.inputBuffer.getChannelData(0);
  
          var right = e.inputBuffer.getChannelData(1);
  
  
  
          leftchannel.push(new Float32Array(left));
  
          rightchannel.push(new Float32Array(right));
  
          recordingLength += bufferSize;
  
  
  
          // get the average for the first channel
  
          var array = new Uint8Array(analyser.frequencyBinCount);
  
          analyser.getByteFrequencyData(array);
  
  
  
          var c = document.getElementById("myCanvas");
  
          var ctx = c.getContext("2d");
  
          // clear the current state
  
          ctx.clearRect(0, 0, 1000, 325);
  
          var gradient = ctx.createLinearGradient(0, 0, 0, 300);
  
          gradient.addColorStop(1, '#000000');
  
          gradient.addColorStop(0.75, '#ff0000');
  
          gradient.addColorStop(0.25, '#ffff00');
  
          gradient.addColorStop(0, '#ffffff');
  
          // set the fill style
  
          ctx.fillStyle = gradient;
  
          drawSpectrum(array);
  
  
  
          function drawSpectrum(array) {
  
              for (var i = 0; i < (array.length); i++) {
  
                  var value = array[i];
  
                  ctx.fillRect(i * 5, 325 - value, 3, 325);
  
              }
  
  
  
          }
  
      }
  
  
  
      function getAverageVolume(array) {
  
          var values = 0;
  
          var average;
  
  
  
          var length = array.length;
  
  
  
          // get all the frequency amplitudes
  
          for (var i = 0; i < length; i++) {
  
              values += array[i];
  
          }
  
  
  
          average = values / length;
  
          return average;
  
      }
  
  
  
      // we connect the recorder(node to destination(speakers))
  
      volume.connect(splitter);
  
      splitter.connect(analyser, 0, 0);
  
  
  
      analyser.connect(recorder);
  
      recorder.connect(context.destination);
  
  
  
  }
  
  
  
  
  
  
  
  
  
  function mergeBuffers(channelBuffer, recordingLength) {
  
      var result = new Float32Array(recordingLength);
  
      var offset = 0;
  
      var lng = channelBuffer.length;
  
      for (var i = 0; i < lng; i++) {
  
          var buffer = channelBuffer[i];
  
          result.set(buffer, offset);
  
          offset += buffer.length;
  
      }
  
      return result;
  
  }
  
  
  
  function interleave(leftChannel, rightChannel) {
  
      var length = leftChannel.length + rightChannel.length;
  
      var result = new Float32Array(length);
  
  
  
      var inputIndex = 0;
  
  
  
      for (var index = 0; index < length;) {
  
          result[index++] = leftChannel[inputIndex];
  
          result[index++] = rightChannel[inputIndex];
  
          inputIndex++;
  
      }
  
      return result;
  
  }
  
  
  
  
  
  function writeUTFBytes(view, offset, string) {
  
      var lng = string.length;
  
      for (var i = 0; i < lng; i++) {
  
  
  
          view.setUint8(offset + i, string.charCodeAt(i));
  
      }
  
  }

• ffmpeg issue with Jupyter notebook

  16 novembre 2022, par Nanda

  I am trying to extract frames from a video file using ffmpeg in Python. I installed ffmpeg using Homebrew and ffmpeg-python on the Anaconda-Navigator. Yet when I call ffmpeg on Jupyter notebook as follows

  


  !ffmpeg -i "$file" "$rootdir"/"$folder_name"/frame%04d.png


  


  I get an error saying

  


  zsh:1: command not found: ffmpeg


  


  I clearly see ffmpeg in my usr/local/bin. Can someone please assist me in sorting this ? I am able to use ffmpeg in Google Colab, though.

  


• Evolution of Multimedia Fiefdoms

  1er octobre 2014, par Multimedia Mike — General

  I want to examine how multimedia fiefdoms have risen and fallen through the years.

  
  
  

  Back in the day, the multimedia fiefdoms were built around the formats put forth by competing companies : there was Microsoft/WMV, Apple/MOV, and Real/RM as the big contenders. On2 always wanted to be a player in this arena but could never quite catch a break. A few brave contenders held the line for open source and also for the power users who desired one application that could handle everything (my original motivation for wanting to get into multimedia hacking).

  The computer desktop was the battleground for internet-based media stream. Whatever happened to those days ? Actually, if memory serves, Flash-based video streaming stepped on all of them.

  Over the last 6-7 years, the battleground has expanded to cover mobile devices, where Flash’s impact has… lessened. During this time, multimedia technology pretty well standardized on a particular stack, namely, the MPEG (MP4/H.264/AAC) stack.

  The belligerents in this war tried for years to effectively penetrate new territory, namely, the living room where the television lived. This had been slowgoing for years due to various user interface and content issues, but steadily improved.

  Last April, Amazon announced their entry into the set-top box market with the Fire TV. That was when it suddenly crystallized for me that the multimedia ecosystem has radically shifted. Now, the multimedia fiefdoms revolve around access to content via streaming services.

  Off the top of my head, here are some of the fiefdoms these days (fiefdoms I have experience using) :

  • Netflix (subscription streaming)
  • Amazon (subscription, rental, and purchased streaming)
  • Hulu Plus (subscription streaming)
  • Apple (rental and purchased media)

  I checked some results on Can I Stream.It ? (which I refer to often) and found a bunch more streaming fiefdoms such as Google (both Play and YouTube, which are separate services), Sony, Xbox 360, Crackle, Redbox Instant, Vudu, Target Ticket, Epix, Sony, SnagFilms, and XFINITY StreamPix. And surely, these are probably just services available in the United States ; I know other geographical regions have their own fiefdoms.

  What happened ?

  When I got into multimedia hacking, there were all these disparate, competing ecosystems. As a consumer, I didn’t care where the media came from, I just wanted to play it. That’s what inspired me to work on open source multimedia projects. Now I realize that I have the same problem 10-15 years later : there are multiple competing ecosystems. I might subscribe to fiefdoms X and Y, but am frustrated to learn that something I’d like to watch is only available through fiefdom Z. Very few of these fiefdoms can be penetrated using open source technology.

  I’m not really sure about the point about this whole post. Multimedia technology seems really standardized these days. But that’s probably just my perspective because I have spent way too long focusing on a few areas of multimedia technology such as audio and video coding. It’s interesting that all these services probably leverage the same limited number of codecs. Their differentiation comes from the catalog of content that each is able to license for streaming. There are different problems to solve in the multimedia arena now.