durata di un file mp3

Question

Qual è il modo più semplice per determinare la lunghezza (in secondi) di un determinato file mp3, senza usare librerie esterne ? (fonte Python molto apprezzata)

Answer 1

Puoi utilizzare pymad . È una libreria esterna, ma non cadere nella trappola Non inventato qui. Qualche motivo particolare per cui non vuoi biblioteche esterne?

import mad

mf = mad.MadFile("foo.mp3")
track_length_in_milliseconds = mf.total_time()    

Spottato qui .

-

Se davvero non vuoi usare una biblioteca esterna, dai un'occhiata qui e controlla come lo ha fatto. Attenzione: è complicato.

Answer 2

Per l'amor di follower di Google, ecco alcune altre librerie esterne:

mpg321 -t

ffmpeg -i

midentify (sostanzialmente mplayer) vedi Uso di mplayer per determinare la lunghezza del file audio / video

mencoder (passa parametri non validi, emetterà un messaggio di errore ma ti darà anche informazioni sul file in questione, ad esempio $ mencoder inputfile.mp3 -o fake)

programma mediainfo http://mediainfo.sourceforge.net/en

exiftool

il file " linux " comando

mp3info

sox

arbitri: https://superuser.com/questions/36871/linux-command- line-utility-per-stabilire-mp3-bitrate

http://www.ruby-forum.com/topic/139468

lunghezza mp3 in millisecondi

(rendendolo una wiki per gli altri da aggiungere).

e libs: .net: naudio, java: jlayer, c: libmad

Cheers!

Answer 3

  

    

Semplice, analizzare BLOB binario MP3 per calcolare qualcosa, in Python

  

Sembra un ordine piuttosto alto. Non conosco Python, ma ecco del codice che ho refactored da un altro programma che una volta ho provato a scrivere.

Nota: è in C ++ (scusa, è quello che ho). Inoltre, così com'è, gestirà solo i file MPEG 1 Audio Layer 3 a velocità in bit costante. Che dovrebbe coprire la maggior parte, ma non posso fornire alcuna garanzia su come funziona in tutte le situazioni. Spero che questo faccia quello che vuoi, e spero che il refactoring in Python sia più facile che farlo da zero.

// determines the duration, in seconds, of an MP3;
// assumes MPEG 1 (not 2 or 2.5) Audio Layer 3 (not 1 or 2)
// constant bit rate (not variable)

#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;

//Bitrates, assuming MPEG 1 Audio Layer 3
const int bitrates[16] = {
         0,  32000,  40000,  48000,  56000,  64000,  80000,   96000,
    112000, 128000, 160000, 192000, 224000, 256000, 320000,       0
  };


//Intel processors are little-endian;
//search Google or see: http://en.wikipedia.org/wiki/Endian
int reverse(int i)
{
    int toReturn = 0;
    toReturn |= ((i & 0x000000FF) << 24);
    toReturn |= ((i & 0x0000FF00) << 8);
    toReturn |= ((i & 0x00FF0000) >> 8);
    toReturn |= ((i & 0xFF000000) >> 24);
    return toReturn;
}

//In short, data in ID3v2 tags are stored as
//"syncsafe integers". This is so the tag info
//isn't mistaken for audio data, and attempted to
//be "played". For more info, have fun Googling it.
int syncsafe(int i)
{
 int toReturn = 0;
 toReturn |= ((i & 0x7F000000) >> 24);
 toReturn |= ((i & 0x007F0000) >>  9);
 toReturn |= ((i & 0x00007F00) <<  6);
 toReturn |= ((i & 0x0000007F) << 21);
 return toReturn;     
}

//How much room does ID3 version 1 tag info
//take up at the end of this file (if any)?
int id3v1size(ifstream& infile)
{
   streampos savePos = infile.tellg(); 

   //get to 128 bytes from file end
   infile.seekg(0, ios::end);
   streampos length = infile.tellg() - (streampos)128;
   infile.seekg(length);

   int size;
   char buffer[3] = {0};
   infile.read(buffer, 3);
   if( buffer[0] == 'T' && buffer[1] == 'A' && buffer[2] == 'G' )
     size = 128; //found tag data
   else
     size = 0; //nothing there

   infile.seekg(savePos);

   return size;

}

//how much room does ID3 version 2 tag info
//take up at the beginning of this file (if any)
int id3v2size(ifstream& infile)
{
   streampos savePos = infile.tellg(); 
   infile.seekg(0, ios::beg);

   char buffer[6] = {0};
   infile.read(buffer, 6);
   if( buffer[0] != 'I' || buffer[1] != 'D' || buffer[2] != '3' )
   {   
       //no tag data
       infile.seekg(savePos);
       return 0;
   }

   int size = 0;
   infile.read(reinterpret_cast<char*>(&size), sizeof(size));
   size = syncsafe(size);

   infile.seekg(savePos);
   //"size" doesn't include the 10 byte ID3v2 header
   return size + 10;
}

int main(int argCount, char* argValues[])
{
  //you'll have to change this
  ifstream infile("C:/Music/Bush - Comedown.mp3", ios::binary);

  if(!infile.is_open())
  {
   infile.close();
   cout << "Error opening file" << endl;
   system("PAUSE");
   return 0;
  }

  //determine beginning and end of primary frame data (not ID3 tags)
  infile.seekg(0, ios::end);
  streampos dataEnd = infile.tellg();

  infile.seekg(0, ios::beg);
  streampos dataBegin = 0;

  dataEnd -= id3v1size(infile);
  dataBegin += id3v2size(infile);

  infile.seekg(dataBegin,ios::beg);

  //determine bitrate based on header for first frame of audio data
  int headerBytes = 0;
  infile.read(reinterpret_cast<char*>(&headerBytes),sizeof(headerBytes));

  headerBytes = reverse(headerBytes);
  int bitrate = bitrates[(int)((headerBytes >> 12) & 0xF)];

  //calculate duration, in seconds
  int duration = (dataEnd - dataBegin)/(bitrate/8);

  infile.close();

  //print duration in minutes : seconds
  cout << duration/60 << ":" << duration%60 << endl;

  system("PAUSE");
  return 0;
}

Answer 4

usa semplicemente mutagen

$pip install mutagen

usalo nella shell di Python:

from mutagen.mp3 import MP3
audio = MP3(file_path)
print audio.info.length

Answer 5

Dai un'occhiata anche a audioread (alcune distribuzioni Linux tra cui Ubuntu hanno pacchetti), https://github.com/ sampsyo / audioread

audio = audioread.audio_open('/path/to/mp3')
print audio.channels, audio.samplerate, audio.duration

Answer 6

È possibile contare il numero di frame nel file. Ogni frame ha un codice iniziale, anche se non riesco a ricordare il valore esatto del codice iniziale e non ho specifiche MPEG in giro. Ogni fotogramma ha una certa lunghezza, circa 40 ms per il livello II di MPEG1.

Questo metodo funziona per i file CBR (Constant Bit Rate), come funzionano i file VBR è una storia completamente diversa.

Dal documento seguente:

Per il livello I ci archivia questa formula:

FrameLengthInBytes = (12 * BitRate / SampleRate + Padding) * 4

Per Layer II & amp; I file III utilizzano questa formula:

FrameLengthInBytes = 144 * BitRate / SampleRate + Padding

Informazioni sull'intestazione del frame audio MPEG