Recherche avancée

Sur d’autres sites (6367)

• Trying to convert an mp3 file to a Numpy Array, and ffmpeg just hangs

  5 juillet 2016, par Rich

  I’m working on a music classification methodology with Scikit-learn, and the first step in that process is converting a music file to a numpy array.

  After unsuccessfully trying to call ffmpeg from a python script, I decided to simply pipe the file in directly :

  FFMPEG_BIN = "ffmpeg"
  
  cwd = (os.getcwd())
  
  dcwd = (cwd + "/temp")
  
  if not os.path.exists(dcwd): os.makedirs(dcwd)
  
  
  
  folder_path = sys.argv[1]
  
  f = open("test.txt","a")
  
  
  
  for f in glob.glob(os.path.join(folder_path, "*.mp3")):
  
      ff = f.replace("./", "/")
  
      print("Name: " + ff)
  
      aa = (cwd + ff)
  
  
  
      command = [ FFMPEG_BIN,
  
          '-i',  aa,
  
          '-f', 's16le',
  
          '-acodec', 'pcm_s16le',
  
          '-ar', '22000', # ouput will have 44100 Hz
  
          '-ac', '1', # stereo (set to '1' for mono)
  
          '-']
  
  
  
      pipe = sp.Popen(command, stdout=sp.PIPE, bufsize=10**8)
  
      raw_audio = pipe.proc.stdout.read(88200*4)
  
      audio_array = numpy.fromstring(raw_audio, dtype="int16")
  
      print (str(audio_array))
  
      f.write(audio_array + "\n")

  The problem is, when I run the file, it starts ffmpeg and then does nothing :

  [mp3 @ 0x1446540] Estimating duration from bitrate, this may be inaccurate
  
  Input #0, mp3, from '/home/don/Code/Projects/MC/Music/Spaz.mp3':
  
    Metadata:
  
      title           : Spaz
  
      album           : Seeing souns
  
      artist          : N*E*R*D
  
      genre           : Hip-Hop
  
      encoder         : Audiograbber 1.83.01, LAME dll 3.96, 320 Kbit/s, Joint Stereo, Normal quality
  
      track           : 5/12
  
      date            : 2008
  
    Duration: 00:03:50.58, start: 0.000000, bitrate: 320 kb/s
  
      Stream #0:0: Audio: mp3, 44100 Hz, stereo, s16p, 320 kb/s
  
  Output #0, s16le, to 'pipe:':
  
    Metadata:
  
      title           : Spaz
  
      album           : Seeing souns
  
      artist          : N*E*R*D
  
      genre           : Hip-Hop
  
      date            : 2008
  
      track           : 5/12
  
      encoder         : Lavf56.4.101
  
      Stream #0:0: Audio: pcm_s16le, 22000 Hz, mono, s16, 352 kb/s
  
      Metadata:
  
        encoder         : Lavc56.1.100 pcm_s16le
  
  Stream mapping:
  
    Stream #0:0 -> #0:0 (mp3 (native) -> pcm_s16le (native))
  
  Press [q] to stop, [?] for help

  It just sits there, hanging, for far longer than the song is. What am I doing wrong here ?,

• Song name under video

  2 septembre 2020, par ottpeter

  I'm trying to write the song name under the video with ffmpeg. My mp3 files are running in a loop like this :
-stream_loop -1 -i music.txt
My workaround would be to write an SRT file with timecodes, a script would determine when next song is comming, and I would repeat this, let's say, a 1000 times (time codes adjusted), then I would get song names for a month for example. (this would be done before ffmpeg is started)
Obviously this is not optimal, especially because I can't loop the SRT file as well, because of the timecode. It would be better to do this with a filter complex.

  


  Is there a way to know the name of the mp3 that is currently playing, in ffmpeg ?

  


• How to estimate in Node audio bitrate, bytes, duration without ffmpeg

  6 mai 2016, par loretoparisi

  Supposed to not have access to ffmpeg I need a simple way to calculate the bitrate of an audio (or video) file given media length (bytes) and duration (seconds), i.e. the function

  bitrate = MediaInfo.bitrate(bytes, duration);

  Also I need to do the opposite, so that given approximate media bitrate and length I need calculate the duration :

  duration = MediaInfo.duration(bytes, bitrate);

  So, this is my attempt, inspired by bitrate node module :

  var console = {
  
      log: function(s) {
  
        document.getElementById("console").innerHTML += s + "<br />"
  
      }
  
  }
  
  
  
  /**
  
   * Get media file info
  
   * @see https://www.npmjs.com/package/bitrate
  
   * * @author Loreto Parisi (loretoparisi at gmail dot com)
  
   */
  
  var MediaInfo = {
  
  
  
      /** unit divisors */
  
      DIVISORS : {
  
        bps: 0.125,
  
        kbps: 125,
  
        mbps: 125000,
  
        Bps: 1,
  
        KBps: 1000,
  
        MBps: 1000000
  
      },
  
  
  
      /**
  
       * Calcuate approximate bitrate
  
       * @param bytes integer media length in bytes
  
       * @param seconds float media duration
  
       * @param format string: bps|kbps|Bps|KBps|MBps
  
       * @param pos integer decimal approximation
  
      */
  
      bitrate : function(bytes, seconds, format, pos) {
  
              if (typeof format !== 'string') throw new TypeError('Expected \'format\' to be a string')
  
              format = format.replace('/', 'p')
  
  
  
        var divisor = this.DIVISORS[format];
  
              if (!divisor) throw new Error('\'format\' is an invalid string')
  
        var bitrate = bytes / seconds / divisor;
  
        pos=pos||4;
  
  
  
        return (Math.round(bitrate * Math.pow(10,pos)) / Math.pow(10,pos) );
  
  
  
      },
  
  
  
      /**
  
       * Calcuate media bytes
  
       * @param bitrate float media bitrate per seconds
  
       * @param seconds float media duration
  
       * @param format string: bps|kbps|Bps|KBps|MBps
  
       * @param pos integer decimal approximation
  
      */
  
      bytes : function(bitrate, seconds, format) {
  
         if (typeof format !== 'string') throw new TypeError('Expected \'format\' to be a string')
  
         format = format.replace('/', 'p')
  
  
  
         var divisor = this.DIVISORS[format];
  
         if (!divisor) throw new Error('\'format\' is an invalid string')
  
         var bytes = bitrate * seconds * divisor;
  
  
  
         return ( Math.round(bytes) );
  
  
  
       }, //bytes
  
  
  
      /**
  
       * Calcuate approximate duration
  
       * @param bytes integer media length in bytes
  
       * @param bitrate float media bitrate per seconds
  
       * @param format string: bps|kbps|Bps|KBps|MBps
  
       * @param pos integer decimal approximation
  
      */
  
      duration : function(bytes, bitrate, format, pos) {
  
        if (typeof format !== 'string') throw new TypeError('Expected \'format\' to be a string')
  
              format = format.replace('/', 'p')
  
  
  
        var divisor = this.DIVISORS[format];
  
        if (!divisor) throw new Error('\'format\' is an invalid string')
  
        var seconds = bytes / bitrate / divisor;
  
        pos=pos||4;
  
  
  
        return (Math.round(seconds * Math.pow(10,pos)) / Math.pow(10,pos) );
  
      }
  
    } //MediaInfo
  
  
  
  // example of usage
  
    var bytes = 57511; // media file size in bytes
  
    var seconds = 20.35 // media file duration in seconds
  
  
  
    // calculate media bitrate given media length and duration
  
    var kilobitsPerSecond = MediaInfo.bitrate(bytes, seconds, 'kbps', 3) // => 326.3
  
    var bitsPerSecond = MediaInfo.bitrate(bytes, seconds, 'bps', 3) // => 326279
  
    var BytesPerSecond = MediaInfo.bitrate(bytes, seconds, 'Bps', 3) // => 40785
  
  
  
    // inverse: calculate media duration given media length and bitrate
  
    var duration = MediaInfo.duration(bytes, kilobitsPerSecond, 'kbps', 3);
  
    
  
    // estimated bytes length given bitrate and duration
  
    var estimatedBytes = MediaInfo.bytes(kilobitsPerSecond, duration, 'kbps', 3);
  
  
  
    var data = {
  
        bytes : bytes,
  
        seconds : seconds,
  
        kilobitsPerSecond : kilobitsPerSecond + " kb/s",
  
        bitsPerSecond : bitsPerSecond + " b/s",
  
        BytesPerSecond : BytesPerSecond + " B/s",
  
        duration : duration,
  
       estimatedBytes : estimatedBytes
  
    }
  
  
  
    console.log( JSON.stringify(data, null, 2) );

  <div></div>

  The result media info are

  {
  
    "bytes": 57511,
  
    "seconds": 20.35,
  
    "kilobitsPerSecond": "22.609 kb/s",
  
    "bitsPerSecond": "22608.747 b/s",
  
    "BytesPerSecond": "2826.093 B/s",
  
    "duration": 20.35,
  
    "estimatedBytes": 57512
  
  }

  while ffmpeg gives

  Duration: 00:00:20.35, start: 0.000000, bitrate: 22 kb/s
  
      Stream #0:0(eng): Audio: aac (mp4a / 0x6134706D), 8000 Hz, mono, fltp, 16 kb/s (default)

  Of course, the problem here is the assumption that I have a fixed bitrate when calculating the duration. But, is there any other way without having ffprobe or lame in node ?

  Note. A good options, where the media file has ID3 tagging, is to use the JSMediaTags node module that supports ID3 and MP4 tagging for media files and works both in the browser that in node :

  var jsmediatags = require("jsmediatags");
  
  jsmediatags.read("./music-file.mp3", {
  
    onSuccess: function(tag) {
  
      console.log(tag);
  
    },
  
    onError: function(error) {
  
      console.log(':(', error.type, error.info);
  
    }
  
  });

  This will not work for streaming media files or for files coming from direct audio sources of course.