src/main/java/net/pterodactylus/sonitus/io/mp3/Frame.java

   1 /*
   2  * Sonitus - Frame.java - Copyright © 2013 David Roden
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.pterodactylus.sonitus.io.mp3;
  19
  20 import java.util.Map;
  21
  22 import com.google.common.base.Optional;
  23 import com.google.common.base.Supplier;
  24 import com.google.common.base.Suppliers;
  25 import com.google.common.collect.ImmutableBiMap;
  26 import com.google.common.collect.ImmutableMap;
  27
  28 /**
  29  * A single MPEG audio frame.
  30  * <p/>
  31  * This uses information from <a href="http://mpgedit.org/mpgedit/mpeg_format/mpeghdr.htm">mpgedit.org/mpgedit/mpeg_format/mpeghdr.htm</a>.
  32  *
  33  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  34  */
  35 public class Frame {
  36
  37         /** The MPEG audio version. */
  38         public enum MpegAudioVersion {
  39
  40                 /** Verstion 2.5. */
  41                 VERSION_2_5,
  42
  43                 /** Reserved. */
  44                 RESERVED,
  45
  46                 /** Version 2. */
  47                 VERSION_2,
  48
  49                 /** Version 1. */
  50                 VERSION_1
  51
  52         }
  53
  54         /** The MPEG layer description. */
  55         public enum LayerDescription {
  56
  57                 /** Reserved. */
  58                 RESERVED,
  59
  60                 /** Layer III. */
  61                 LAYER_3,
  62
  63                 /** Layer II. */
  64                 LAYER_2,
  65
  66                 /** Layer I. */
  67                 LAYER_1
  68
  69         }
  70
  71         /** The channel mode. */
  72         public enum ChannelMode {
  73
  74                 /* Stereo. */
  75                 STEREO,
  76
  77                 /** Joint stereo. */
  78                 JOINT_STEREO,
  79
  80                 /** Dual-channel stereo. */
  81                 DUAL_CHANNEL,
  82
  83                 /** Single channel, aka mono. */
  84                 SINGLE_CHANNEL
  85
  86         }
  87
  88         /** Mode of emphasis. */
  89         public enum Emphasis {
  90
  91                 /** No emphasis. */
  92                 NONE,
  93
  94                 /** 50/15 ms. */
  95                 _50_15_MS,
  96
  97                 /** Reserved. */
  98                 RESERVED,
  99
 100                 /** CCIT J.17. */
 101                 CCIT_J_17
 102
 103         }
 104
 105         /** Bitrate table. */
 106         private static final Supplier<Map<MpegAudioVersion, Map<LayerDescription, Map<Integer, Integer>>>> bitrateSupplier = Suppliers.memoize(new Supplier<Map<MpegAudioVersion, Map<LayerDescription, Map<Integer, Integer>>>>() {
 107
 108                 @Override
 109                 public Map<MpegAudioVersion, Map<LayerDescription, Map<Integer, Integer>>> get() {
 110                         ImmutableMap.Builder<MpegAudioVersion, Map<LayerDescription, Map<Integer, Integer>>> mpegAudioVersionMapBuilder = ImmutableMap.builder();
 111
 112                         /* MPEG 1. */
 113                         ImmutableMap.Builder<LayerDescription, Map<Integer, Integer>> mpeg1Builder = ImmutableMap.builder();
 114
 115                         /* Layer 1. */
 116                         ImmutableMap.Builder<Integer, Integer> bitrates = ImmutableMap.builder();
 117                         bitrates.put(0, 0).put(1, 32).put(2, 64).put(3, 96).put(4, 128).put(5, 160).put(6, 192).put(7, 224);
 118                         bitrates.put(8, 256).put(9, 288).put(10, 320).put(11, 352).put(12, 384).put(13, 416).put(14, 448).put(15, -1);
 119                         mpeg1Builder.put(LayerDescription.LAYER_1, bitrates.build());
 120
 121                         /* MPEG 1, Layer 2 bitrates. */
 122                         bitrates = ImmutableMap.builder();
 123                         bitrates.put(0, 0).put(1, 32).put(2, 48).put(3, 56).put(4, 64).put(5, 80).put(6, 96).put(7, 112);
 124                         bitrates.put(8, 128).put(9, 160).put(10, 192).put(11, 224).put(12, 256).put(13, 320).put(14, 384).put(15, -1);
 125                         mpeg1Builder.put(LayerDescription.LAYER_2, bitrates.build());
 126
 127                         /* MPEG 1, Layer 3 bitrates. */
 128                         bitrates = ImmutableMap.builder();
 129                         bitrates.put(0, 0).put(1, 32).put(2, 40).put(3, 48).put(4, 56).put(5, 64).put(6, 80).put(7, 96);
 130                         bitrates.put(8, 112).put(9, 128).put(10, 160).put(11, 192).put(12, 224).put(13, 256).put(14, 320).put(15, -1);
 131                         mpeg1Builder.put(LayerDescription.LAYER_3, bitrates.build());
 132                         mpegAudioVersionMapBuilder.put(MpegAudioVersion.VERSION_1, mpeg1Builder.build());
 133
 134                         /* MPEG 2 & 2.5. */
 135                         ImmutableBiMap.Builder<LayerDescription, Map<Integer, Integer>> mpeg2Builder = ImmutableBiMap.builder();
 136
 137                         /* Layer 1. */
 138                         bitrates = ImmutableMap.builder();
 139                         bitrates.put(0, 0).put(1, 32).put(2, 48).put(3, 56).put(4, 64).put(5, 80).put(6, 96).put(7, 112);
 140                         bitrates.put(8, 128).put(9, 144).put(10, 160).put(11, 176).put(12, 192).put(13, 224).put(14, 256).put(15, -1);
 141                         mpeg2Builder.put(LayerDescription.LAYER_1, bitrates.build());
 142
 143                         /* Layer 2 & 3. */
 144                         bitrates = ImmutableMap.builder();
 145                         bitrates.put(0, 0).put(1, 8).put(2, 16).put(3, 24).put(4, 32).put(5, 40).put(6, 48).put(7, 56);
 146                         bitrates.put(8, 64).put(9, 80).put(10, 96).put(11, 112).put(12, 128).put(13, 144).put(14, 160).put(15, -1);
 147                         mpeg2Builder.put(LayerDescription.LAYER_2, bitrates.build());
 148                         mpeg2Builder.put(LayerDescription.LAYER_3, bitrates.build());
 149
 150                         mpegAudioVersionMapBuilder.put(MpegAudioVersion.VERSION_2, mpeg2Builder.build());
 151                         mpegAudioVersionMapBuilder.put(MpegAudioVersion.VERSION_2_5, mpeg2Builder.build());
 152
 153                         return mpegAudioVersionMapBuilder.build();
 154                 }
 155         });
 156
 157         /** Sampling rate table. */
 158         private static final Supplier<Map<MpegAudioVersion, Map<Integer, Integer>>> samplingRateSupplier = Suppliers.memoize(new Supplier<Map<MpegAudioVersion, Map<Integer, Integer>>>() {
 159
 160                 @Override
 161                 public Map<MpegAudioVersion, Map<Integer, Integer>> get() {
 162                         ImmutableMap.Builder<MpegAudioVersion, Map<Integer, Integer>> mpegAudioVersions = ImmutableMap.builder();
 163
 164                         /* MPEG 1. */
 165                         ImmutableMap.Builder<Integer, Integer> samplingRates = ImmutableMap.builder();
 166                         samplingRates.put(0, 44100).put(1, 48000).put(2, 32000).put(3, 0);
 167                         mpegAudioVersions.put(MpegAudioVersion.VERSION_1, samplingRates.build());
 168
 169                         /* MPEG 2. */
 170                         samplingRates = ImmutableMap.builder();
 171                         samplingRates.put(0, 22050).put(1, 24000).put(2, 16000).put(3, 0);
 172                         mpegAudioVersions.put(MpegAudioVersion.VERSION_2, samplingRates.build());
 173
 174                         /* MPEG 2.5. */
 175                         samplingRates = ImmutableMap.builder();
 176                         samplingRates.put(0, 11025).put(1, 12000).put(2, 8000).put(3, 0);
 177                         mpegAudioVersions.put(MpegAudioVersion.VERSION_2_5, samplingRates.build());
 178
 179                         return mpegAudioVersions.build();
 180                 }
 181         });
 182
 183         /** The decoded MPEG audio version ID. */
 184         private final int mpegAudioVersionId;
 185
 186         /** The decoded layer description. */
 187         private final int layerDescription;
 188
 189         /** The decoded protection bit. */
 190         private final int protectionBit;
 191
 192         /** The decoded bitrate index. */
 193         private final int bitrateIndex;
 194
 195         /** The deocded sampling rate frequency index. */
 196         private final int samplingRateFrequencyIndex;
 197
 198         /** The decoded padding bit. */
 199         private final int paddingBit;
 200
 201         /** The decoded private bit. */
 202         private final int privateBit;
 203
 204         /** The decoded channel mode. */
 205         private final int channelMode;
 206
 207         /** The deocded mode extension. */
 208         private final int modeExtension;
 209
 210         /** The decoded copyright bit. */
 211         private final int copyrightBit;
 212
 213         /** The deocded original bit. */
 214         private final int originalBit;
 215
 216         /** The decoded emphasis mode. */
 217         private final int emphasis;
 218
 219         private Frame(int mpegAudioVersionId, int layerDescription, int protectionBit, int bitrateIndex, int samplingRateFrequencyIndex, int paddingBit, int privateBit, int channelMode, int modeExtension, int copyrightBit, int originalBit, int emphasis) {
 220                 this.mpegAudioVersionId = mpegAudioVersionId;
 221                 this.layerDescription = layerDescription;
 222                 this.protectionBit = protectionBit;
 223                 this.bitrateIndex = bitrateIndex;
 224                 this.samplingRateFrequencyIndex = samplingRateFrequencyIndex;
 225                 this.paddingBit = paddingBit;
 226                 this.privateBit = privateBit;
 227                 this.channelMode = channelMode;
 228                 this.modeExtension = modeExtension;
 229                 this.copyrightBit = copyrightBit;
 230                 this.originalBit = originalBit;
 231                 this.emphasis = emphasis;
 232         }
 233
 234         //
 235         // ACCESSORS
 236         //
 237
 238         public MpegAudioVersion mpegAudioVersion() {
 239                 return MpegAudioVersion.values()[mpegAudioVersionId];
 240         }
 241
 242         public LayerDescription layerDescription() {
 243                 return LayerDescription.values()[layerDescription];
 244         }
 245
 246         public boolean protectionBit() {
 247                 return protectionBit != 0;
 248         }
 249
 250         public int bitrate() {
 251                 return bitrateSupplier.get().get(mpegAudioVersion()).get(layerDescription()).get(bitrateIndex);
 252         }
 253
 254         public int samplingRate() {
 255                 return samplingRateSupplier.get().get(mpegAudioVersion()).get(samplingRateFrequencyIndex);
 256         }
 257
 258         public boolean paddingBit() {
 259                 return paddingBit != 0;
 260         }
 261
 262         public boolean privateBit() {
 263                 return privateBit != 0;
 264         }
 265
 266         public ChannelMode channelMode() {
 267                 return ChannelMode.values()[channelMode];
 268         }
 269
 270         /* TODO - mode extension. */
 271
 272         public boolean copyrightBit() {
 273                 return copyrightBit != 0;
 274         }
 275
 276         public boolean originalBit() {
 277                 return originalBit != 0;
 278         }
 279
 280         public Emphasis emphasis() {
 281                 return Emphasis.values()[emphasis];
 282         }
 283
 284         //
 285         // STATIC METHODS
 286         //
 287
 288         public static boolean isFrame(byte[] buffer, int offset, int length) {
 289                 return (((buffer[offset] & 0xff) == 0xff) && ((buffer[offset + 1] & 0xe0) == 0xe0));
 290         }
 291
 292         public static Optional<Frame> create(byte[] buffer, int offset, int length) {
 293                 if (isFrame(buffer, offset, length)) {
 294                         int mpegAudioVersionId = (buffer[offset + 1] & 0x18) >>> 3;
 295                         int layerDescription = (buffer[offset + 1] & 0x06) >>> 1;
 296                         int protectionBit = buffer[offset + 1] & 0x01;
 297                         int bitrateIndex = (buffer[offset + 2] & 0xf0) >>> 4;
 298                         int samplingRateFrequencyIndex = (buffer[offset + 2] & 0x0c) >>> 2;
 299                         int paddingBit = (buffer[offset + 2] & 0x02) >>> 1;
 300                         int privateBit = buffer[offset + 2] & 0x01;
 301                         int channelMode = (buffer[offset + 3] & 0xc0) >> 6;
 302                         int modeExtension = (buffer[offset + 3] & 0x60) >> 4;
 303                         int copyright = (buffer[offset + 3] & 0x08) >> 3;
 304                         int original = (buffer[offset + 3] & 0x04) >> 2;
 305                         int emphasis = buffer[offset + 3] & 0x03;
 306                         return Optional.of(new Frame(mpegAudioVersionId, layerDescription, protectionBit, bitrateIndex, samplingRateFrequencyIndex, paddingBit, privateBit, channelMode, modeExtension, copyright, original, emphasis));
 307                 }
 308                 return Optional.absent();
 309         }
 310
 311 }