mp3scan.d

   1 /*
   2  * MPEG Audio Layer III decoder
   3  * Copyright (c) 2001, 2002 Fabrice Bellard,
   4  *           (c) 2007 Martin J. Fiedler
   5  *
   6  * D conversion by Ketmar // Invisible Vector
   7  *
   8  * This file is a stripped-down version of the MPEG Audio decoder from
   9  * the FFmpeg libavcodec library.
  10  *
  11  * FFmpeg and minimp3 are free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * FFmpeg and minimp3 are distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with FFmpeg; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24  */
  25 module iv.mp3scan /*is aliced*/;
  26 import iv.alice;
  27
  28
  29 // ////////////////////////////////////////////////////////////////////////// //
  30 enum Mp3Max {
  31   FrameSize = 1152, // maxinum frame size
  32   Channels = 2,
  33 }
  34
  35 enum Mp3Mode {
  36   Stereo = 0,
  37   JStereo = 1,
  38   Dual = 2,
  39   Mono = 3,
  40 }
  41
  42
  43 // ////////////////////////////////////////////////////////////////////////// //
  44 struct Mp3Info {
  45   uint sampleRate;
  46   ubyte channels;
  47   ulong samples;
  48   Mp3Mode mode;
  49   uint bitrate;
  50   long id3v1ofs;
  51   uint id3v1size;
  52   long id3v2ofs;
  53   uint id3v2size;
  54
  55   static struct Index { ulong fpos; ulong samples; } // samples done before this frame (*multiplied* by channels)
  56   Index[] index; // WARNING: DON'T STORE SLICES OF IT!
  57
  58   @property bool valid () const pure nothrow @safe @nogc { return (sampleRate != 0); }
  59   @property bool hasID3v1 () const pure nothrow @safe @nogc { return (id3v1size == 128); }
  60   @property bool hasID3v2 () const pure nothrow @safe @nogc { return (id3v2size > 10); }
  61 }
  62
  63
  64 Mp3Info mp3Scan(bool buildIndex=false, RDG) (scope RDG rdg) if (is(typeof({
  65   ubyte[2] buf;
  66   int rd = rdg(buf[]);
  67 }))) {
  68   Mp3Info info;
  69   bool eofhit;
  70   ubyte[4096] inbuf;
  71   uint inbufpos, inbufused;
  72   Mp3Ctx s;
  73   uint headersCount;
  74   ulong bytesRead = 0;
  75
  76   ulong streamOfs () { pragma(inline, true); return bytesRead-inbufused+inbufpos; }
  77
  78   void fillInputBuffer () {
  79     if (inbufpos < inbufused) {
  80       import core.stdc.string : memmove;
  81       if (inbufused-inbufpos >= 1800) return; // no need to get more data
  82       if (inbufpos > 0) memmove(inbuf.ptr, inbuf.ptr+inbufpos, inbufused-inbufpos);
  83       inbufused -= inbufpos;
  84       inbufpos = 0;
  85     } else {
  86       inbufpos = inbufused = 0;
  87     }
  88     // read more bytes
  89     while (!eofhit && inbufused < inbuf.length) {
  90       int rd = rdg(inbuf[inbufused..$]);
  91       if (rd <= 0) {
  92         eofhit = true;
  93       } else {
  94         bytesRead += rd;
  95         inbufused += rd;
  96       }
  97     }
  98   }
  99
 100   bool skipBytes (uint count) {
 101     while (!eofhit && count > 0) {
 102       auto left = inbufused-inbufpos;
 103       if (left == 0) {
 104         fillInputBuffer();
 105       } else {
 106         if (left <= count) {
 107           // eat whole buffer
 108           inbufused = inbufpos = 0;
 109           count -= left;
 110         } else {
 111           // eat buffer part
 112           inbufpos += count;
 113           count = 0;
 114         }
 115       }
 116     }
 117     return (count == 0);
 118   }
 119
 120   // now skip frames
 121   while (!eofhit) {
 122     fillInputBuffer();
 123     auto left = inbufused-inbufpos;
 124     if (left < Mp3HeaderSize) break;
 125     // check for tags
 126     // check for ID3v2
 127     if (info.id3v2size == 0 && left >= 10 && inbuf.ptr[inbufpos+0] == 'I' && inbuf.ptr[inbufpos+1] == 'D' && inbuf.ptr[inbufpos+2] == '3' && inbuf.ptr[inbufpos+3] != 0xff && inbuf.ptr[inbufpos+4] != 0xff &&
 128         ((inbuf.ptr[inbufpos+6]|inbuf.ptr[inbufpos+7]|inbuf.ptr[inbufpos+8]|inbuf.ptr[inbufpos+9])&0x80) == 0) { // see ID3v2 specs
 129       // get tag size
 130       uint sz = (inbuf.ptr[inbufpos+9]|(inbuf.ptr[inbufpos+8]<<7)|(inbuf.ptr[inbufpos+7]<<14)|(inbuf.ptr[inbufpos+6]<<21))+10;
 131       if (sz > 10) {
 132         info.id3v2ofs = streamOfs;
 133         info.id3v2size = sz;
 134       }
 135       // skip `sz` bytes, it's a tag
 136       skipBytes(sz);
 137       continue;
 138     }
 139     // check for ID3v1
 140     if (info.id3v1size == 0 && left >= 3 && inbuf.ptr[inbufpos+0] == 'T' && inbuf.ptr[inbufpos+1] == 'A' && inbuf.ptr[inbufpos+2] == 'G') {
 141       // this may be ID3v1, just skip 128 bytes
 142       info.id3v1ofs = streamOfs;
 143       info.id3v1size = 128;
 144       skipBytes(128);
 145       continue;
 146     }
 147     int res = mp3SkipFrame(s, inbuf.ptr+inbufpos, left); // return bytes used in buffer or -1
 148     debug(mp3scan_verbose) { import core.stdc.stdio : printf; printf("FRAME: res=%d; valid=%u; frame_size=%d; samples=%d (%u) read=%u (inbufpos=%u; inbufused=%u)\n", res, (s.valid ? 1 : 0), s.frame_size, s.sample_count, headersCount, cast(uint)bytesRead, inbufpos, inbufused); }
 149     if (res < 0) {
 150       // no frame found in the buffer, get more data
 151       // but left at least Mp3HeaderSize old bytes
 152       assert(inbufused >= Mp3HeaderSize);
 153       inbufpos = inbufused-Mp3HeaderSize;
 154     } else if (!s.valid) {
 155       // got header, but there is not enough data for it
 156       inbufpos += (res > Mp3HeaderSize ? res-Mp3HeaderSize : 1); // move to header
 157     } else {
 158       // got valid frame
 159       static if (buildIndex) {
 160         auto optr = info.index.ptr;
 161         info.index ~= info.Index(streamOfs, info.samples);
 162         if (info.index.ptr !is optr) {
 163           import core.memory : GC;
 164           if (info.index.ptr is GC.addrOf(info.index.ptr)) GC.setAttr(info.index.ptr, GC.BlkAttr.NO_INTERIOR);
 165           //GC.collect(); // somehow this fixes amper
 166         }
 167       }
 168       inbufpos += res; // move past frame
 169       if (++headersCount == 0) headersCount = uint.max;
 170       if (!info.valid) {
 171         // if first found frame is invalid... consider the whole file invalid
 172         if (s.sample_rate < 1024 || s.sample_rate > 96000) break;
 173         if (s.nb_channels < 1 || s.nb_channels > 2) break;
 174         info.sampleRate = s.sample_rate;
 175         info.channels = cast(ubyte)s.nb_channels;
 176         info.mode = cast(Mp3Mode)s.mode;
 177         info.bitrate = s.bit_rate;
 178       }
 179       info.samples += s.sample_count*s.nb_channels;
 180     }
 181   }
 182   debug(mp3scan_verbose) { import core.stdc.stdio : printf, fflush, stdout; printf("%u\n", headersCount); fflush(stdout); }
 183   if (headersCount < 6) info = info.init;
 184   return info;
 185 }
 186
 187
 188 // ////////////////////////////////////////////////////////////////////////// //
 189 private nothrow @nogc {
 190
 191
 192 // ////////////////////////////////////////////////////////////////////////// //
 193 struct Mp3Ctx {
 194   int frame_size;
 195   int error_protection;
 196   int sample_rate;
 197   int sample_rate_index;
 198   int bit_rate;
 199   int nb_channels;
 200   int sample_count;
 201   int mode;
 202   int mode_ext;
 203   int lsf;
 204   uint last_header; //&0xffff0c00u;
 205   bool valid;
 206 }
 207
 208
 209 // ////////////////////////////////////////////////////////////////////////// //
 210 enum Mp3HeaderSize = 4;
 211
 212
 213 // ////////////////////////////////////////////////////////////////////////// //
 214 bool mp3CheckHeader (uint header) pure @safe {
 215   // header
 216   if ((header&0xffe00000u) != 0xffe00000u) return false;
 217   // layer check
 218   if ((header&(3<<17)) != (1<<17)) return false;
 219   // bit rate
 220   if ((header&(0xf<<12)) == 0xf<<12) return false;
 221   // frequency
 222   if ((header&(3<<10)) == 3<<10) return false;
 223   // seems to be acceptable
 224   return true;
 225 }
 226
 227
 228 bool mp3DecodeHeader (ref Mp3Ctx s, uint header) @trusted {
 229   static immutable ushort[15][2] mp3_bitrate_tab = [
 230     [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 ],
 231     [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160]
 232   ];
 233
 234   static immutable ushort[3] mp3_freq_tab = [ 44100, 48000, 32000 ];
 235
 236   static immutable short[4][4] sampleCount = [
 237     [0, 576, 1152, 384], // v2.5
 238     [0, 0, 0, 0], // reserved
 239     [0, 576, 1152, 384], // v2
 240     [0, 1152, 1152, 384], // v1
 241   ];
 242   ubyte mpid = (header>>19)&0x03;
 243   ubyte layer = (header>>17)&0x03;
 244
 245   s.sample_count = sampleCount.ptr[mpid].ptr[layer];
 246
 247   int sample_rate, frame_size, mpeg25, padding;
 248   int sample_rate_index, bitrate_index;
 249   if (header&(1<<20)) {
 250     s.lsf = (header&(1<<19) ? 0 : 1);
 251     mpeg25 = 0;
 252   } else {
 253     s.lsf = 1;
 254     mpeg25 = 1;
 255   }
 256
 257   sample_rate_index = (header>>10)&3;
 258   sample_rate = mp3_freq_tab[sample_rate_index]>>(s.lsf+mpeg25);
 259   sample_rate_index += 3*(s.lsf+mpeg25);
 260   s.sample_rate_index = sample_rate_index;
 261   s.error_protection = ((header>>16)&1)^1;
 262   s.sample_rate = sample_rate;
 263
 264   bitrate_index = (header>>12)&0xf;
 265   padding = (header>>9)&1;
 266   s.mode = (header>>6)&3;
 267   s.mode_ext = (header>>4)&3;
 268   s.nb_channels = (s.mode == Mp3Mode.Mono ? 1 : 2);
 269
 270   if (bitrate_index == 0) return false; // no frame size computed, signal it
 271   frame_size = mp3_bitrate_tab[s.lsf][bitrate_index];
 272   s.bit_rate = frame_size*1000;
 273   s.frame_size = (frame_size*144000)/(sample_rate<<s.lsf)+padding;
 274   return true;
 275 }
 276
 277
 278 // return bytes used in `buf` or -1 if no header was found
 279 // will set `s.valid` if fully valid header was skipped
 280 // i.e. if it returned something that is not -1, and s.valid == false,
 281 // it means that frame header is ok at the given offset, but there is
 282 // no data to skip the full header; so caller may read more data and
 283 // restart from that offset.
 284 int mp3SkipFrame (ref Mp3Ctx s, const(void)* buff, int bufsize) @trusted {
 285   auto buf = cast(const(ubyte)*)buff;
 286   s.valid = false;
 287   int bufleft = bufsize;
 288   while (bufleft >= Mp3HeaderSize) {
 289     uint header = (buf[0]<<24)|(buf[1]<<16)|(buf[2]<<8)|buf[3];
 290     if (mp3CheckHeader(header)) {
 291       if (s.last_header == 0 || (header&0xffff0c00u) == s.last_header) {
 292         if (mp3DecodeHeader(s, header)) {
 293           if (s.frame_size <= 0 || s.frame_size > bufleft) {
 294             // incomplete frame
 295             s.valid = false;
 296           } else {
 297             s.valid = true;
 298             bufleft -= s.frame_size;
 299             s.last_header = header&0xffff0c00u;
 300             //s.frame_size += extra_bytes;
 301           }
 302           return bufsize-bufleft;
 303         }
 304       }
 305     }
 306     ++buf;
 307     --bufleft;
 308   }
 309   return -1;
 310 }
 311
 312 }
 313
 314
 315 // ////////////////////////////////////////////////////////////////////////// //
 316 /+
 317 import iv.cmdcon;
 318 import iv.vfs;
 319
 320 void main (string[] args) {
 321   if (args.length == 1) args ~= "melodie_128.mp3";
 322
 323   auto fl = VFile(args[1]);
 324
 325   auto info = mp3Scan!true((void[] buf) {
 326     auto rd = fl.rawRead(buf[]);
 327     return cast(uint)rd.length;
 328   });
 329   //conwriteln(fl.tell);
 330
 331   if (!info.valid) {
 332     conwriteln("invalid MP3 file!");
 333   } else {
 334     conwriteln("sample rate: ", info.sampleRate, " Hz");
 335     conwriteln("channels   : ", info.channels);
 336     conwriteln("samples    : ", info.samples);
 337     conwriteln("mode       : ", info.mode);
 338     conwriteln("bitrate    : ", info.bitrate/1000, " kbps");
 339     auto seconds = info.samples/info.sampleRate;
 340     conwritefln!"time: %2s:%02s"(seconds/60, seconds%60);
 341     if (info.index.length) conwriteln(info.index.length, " index entries");
 342     foreach (immutable idx, const ref i; info.index) {
 343       if (idx > 4) break;
 344       conwriteln(idx, ": ", i);
 345     }
 346   }
 347 }
 348 +/