el tiempo de duración de un archivo mp3

Question

¿Cuál es la forma más sencilla para determinar la duración (en segundos) de un archivo mp3, sin el uso fuera de las bibliotecas?(fuente de python muy apreciado)

Answer 1

Puede utilizar pymad.Es una biblioteca externa, pero no te dejes engañar por la No Inventado Aquí trampa.La razón que usted no quiere que ninguna de librerías externas?

import mad

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

Manchado aquí.

--

Si usted realmente no desea utilizar una biblioteca externa, tiene una mirada aquí y comprobar cómo se ha hecho.Advertencia:es complicado.

Answer 2

Para los seguidores de google' bien, aquí hay un par más externa libs:

mpg321 -t

ffmpeg -i

midentify (mplayer, básicamente) ver Uso de mplayer para determinar la longitud de audio/archivo de vídeo

mencoder (pass válido params, va a escupir un mensaje de error, pero también dará información sobre el archivo en cuestión, ex $ mencoder inputfile.mp3 -o falso)

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

exiftool

el linux "archivo" comando

mp3info

sox

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

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

mp3 duración en milisegundos

(haciendo de este un wiki para que los demás agregar).

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

Saludos!

Answer 3

Simple, analizar MP3 blob binario para calcular algo, en Python

Eso suena como una tarea bastante alto.No sé Python, pero aquí está el código que me ha refactorizado desde otro programa una vez traté de escribir.

Nota: Es en C++ (lo siento, es lo que tengo).También, como es, sólo manejar constante tasa de bits MPEG 1 Audio Layer 3 archivos.Que debe cubrir la mayoría, pero no puedo dar ninguna garantía en cuanto a este trabajo en todas las situaciones.Esperemos que este hace lo que quiere, y esperemos que refactorización de código en Python es más fácil que hacerlo desde cero.

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

simplemente use mutagen

$pip install mutagen

uso en python shell:

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

Answer 5

También echa un vistazo a audioread (algunas distribuciones de linux como ubuntu han paquetes), https://github.com/sampsyo/audioread

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

Answer 6

Usted puede contar el número de fotogramas en el archivo.Cada marco tiene un código de inicio, aunque no puedo recordar el valor exacto del código de inicio y no tengo MPEG especificaciones de diseño alrededor.Cada fotograma tiene una cierta longitud, alrededor de 40 ms para MPEG1 layer II.

Este método funciona para la RBC-archivos (Tasa de Bits Constante), ¿cómo VBR-archivos de trabajo es una historia completamente diferente.

Desde el siguiente documento:

Para la Capa I de los archivos de nosotros esta fórmula:

FrameLengthInBytes = (12 * Velocidad De Bit / Velocidad De Muestreo + Relleno) * 4

Para la Capa II y III de archivos, utilice esta fórmula:

FrameLengthInBytes = 144 * Velocidad De Bit / Velocidad De Muestreo + Relleno

La información acerca de MPEG Audio Encabezado de Marco