durée d'un fichier mp3

Question

Quel est le moyen le plus simple de déterminer la longueur (en secondes) d'un fichier mp3 donné, sans utiliser de bibliothèques externes ? (source python très appréciée)

Answer 1

Vous pouvez utiliser pymad . C'est une bibliothèque externe, mais ne tombez pas dans le piège Not Invented Here. Une raison particulière pour laquelle vous ne voulez pas de bibliothèques externes?

import mad

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

Vous avez découvert ici .

-

Si vous ne voulez vraiment pas utiliser une bibliothèque externe, consultez ici et vérifiez comment il l'a fait. Attention: c'est compliqué.

Answer 2

Pour les abonnés Google, voici quelques bibliothèques supplémentaires:

mpg321 -t

ffmpeg -i

midentify (mplayer essentiellement) voir Utiliser mplayer pour déterminer la longueur de fichier audio / vidéo

mencoder (transmettez-lui des paramètres invalides, il va cracher un message d'erreur mais aussi vous donner des informations sur le fichier en question, ex $ mencoder inputfile.mp3 -o faux)

programme mediainfo http://mediainfo.sourceforge.net/fr

exiftool

le fichier " linux " commande

mp3info

sox

refs: https://superuser.com/questions/36871/linux-command- line-utility-to-Determine-mp3-bit

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

durée du fichier mp3 en millisecondes

(faisant de ce wiki un wiki à ajouter).

et les bibliothèques: .net: naudio, java: jlayer, c: libmad

Salut!

Answer 3

  

    

Simple, analyser le blob binaire MP3 pour calculer quelque chose, en Python

  

Cela ressemble à un joli défi de taille. Je ne connais pas Python, mais voici du code que j'ai refactoré à partir d'un autre programme que j'ai déjà essayé d'écrire.

Remarque: c'est en C ++ (désolé, c'est ce que j'ai). En outre, il ne gérera que les fichiers MPEG 1 Audio Layer 3 à débit binaire constant. Cela devrait couvrir le plus possible, mais je ne peux donner aucune garantie quant à son efficacité dans toutes les situations. Espérons que cela fait ce que vous voulez, et espérons que le refactoriser dans Python sera plus facile que de le faire à partir de zéro.

// 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

utilisez simplement mutagène

$pip install mutagen

utilisez-le dans un shell python:

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

Answer 5

Jetez également un œil à audioread (certaines distributions Linux, y compris ubuntu, proposent des packages), https://github.com/ sampsyo / audioread

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

Answer 6

Vous pouvez compter le nombre d'images dans le fichier. Chaque image a un code de début, bien que je ne me souvienne pas de la valeur exacte du code de départ et que je n'ai pas de spécifications MPEG. Chaque image a une certaine longueur, environ 40 ms pour la couche II de MPEG1.

Cette méthode fonctionne pour les fichiers CBR (débit binaire constant). Le fonctionnement des fichiers VBR est une histoire complètement différente.

À partir du document ci-dessous:

Pour la couche I, remplissez la formule suivante:

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

Pour la couche II & amp; Les fichiers III utilisent cette formule:

FrameLengthInBytes = 144 * BitRate / SampleRate + Padding

Informations sur l'en-tête de trame MPEG Audio