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  *
  31  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  32  */
  33 public class Frame {
  34
  35         /** The MPEG audio version. */
  36         public enum MpegAudioVersion {
  37
  38                 /** Verstion 2.5. */
  39                 VERSION_2_5,
  40
  41                 /** Reserved. */
  42                 RESERVED,
  43
  44                 /** Version 2. */
  45                 VERSION_2,
  46
  47                 /** Version 1. */
  48                 VERSION_1
  49
  50         }
  51
  52         /** The MPEG layer description. */
  53         public enum LayerDescription {
  54
  55                 /** Reserved. */
  56                 RESERVED,
  57
  58                 /** Layer III. */
  59                 LAYER_3,
  60
  61                 /** Layer II. */
  62                 LAYER_2,
  63
  64                 /** Layer I. */
  65                 LAYER_1
  66
  67         }
  68
  69         /** The channel mode. */
  70         public enum ChannelMode {
  71
  72                 /* Stereo. */
  73                 STEREO,
  74
  75                 /** Joint stereo. */
  76                 JOINT_STEREO,
  77
  78                 /** Dual-channel stereo. */
  79                 DUAL_CHANNEL,
  80
  81                 /** Single channel, aka mono. */
  82                 SINGLE_CHANNEL
  83
  84         }
  85
  86         /** Mode of emphasis. */
  87         public enum Emphasis {
  88
  89                 /** No emphasis. */
  90                 NONE,
  91
  92                 /** 50/15 ms. */
  93                 _50_15_MS,
  94
  95                 /** Reserved. */
  96                 RESERVED,
  97
  98                 /** CCIT J.17. */
  99                 CCIT_J_17
 100
 101         }
 102
 103         /** Bitrate table. */
 104         private static final Supplier<Map<MpegAudioVersion, Map<LayerDescription, Map<Integer, Integer>>>> bitrateSupplier = Suppliers.memoize(new Supplier<Map<MpegAudioVersion, Map<LayerDescription, Map<Integer, Integer>>>>() {
 105
 106                 @Override
 107                 public Map<MpegAudioVersion, Map<LayerDescription, Map<Integer, Integer>>> get() {
 108                         ImmutableMap.Builder<MpegAudioVersion, Map<LayerDescription, Map<Integer, Integer>>> mpegAudioVersionMapBuilder = ImmutableMap.builder();
 109
 110                         /* MPEG 1. */
 111                         ImmutableMap.Builder<LayerDescription, Map<Integer, Integer>> mpeg1Builder = ImmutableMap.builder();
 112
 113                         /* Layer 1. */
 114                         ImmutableMap.Builder<Integer, Integer> bitrates = ImmutableMap.builder();
 115                         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);
 116                         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);
 117                         mpeg1Builder.put(LayerDescription.LAYER_1, bitrates.build());
 118
 119                         /* MPEG 1, Layer 2 bitrates. */
 120                         bitrates = ImmutableMap.builder();
 121                         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);
 122                         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);
 123                         mpeg1Builder.put(LayerDescription.LAYER_2, bitrates.build());
 124
 125                         /* MPEG 1, Layer 3 bitrates. */
 126                         bitrates = ImmutableMap.builder();
 127                         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);
 128                         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);
 129                         mpeg1Builder.put(LayerDescription.LAYER_3, bitrates.build());
 130                         mpegAudioVersionMapBuilder.put(MpegAudioVersion.VERSION_1, mpeg1Builder.build());
 131
 132                         /* MPEG 2 & 2.5. */
 133                         ImmutableBiMap.Builder<LayerDescription, Map<Integer, Integer>> mpeg2Builder = ImmutableBiMap.builder();
 134
 135                         /* Layer 1. */
 136                         bitrates = ImmutableMap.builder();
 137                         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);
 138                         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);
 139                         mpeg2Builder.put(LayerDescription.LAYER_1, bitrates.build());
 140
 141                         /* Layer 2 & 3. */
 142                         bitrates = ImmutableMap.builder();
 143                         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);
 144                         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);
 145                         mpeg2Builder.put(LayerDescription.LAYER_2, bitrates.build());
 146                         mpeg2Builder.put(LayerDescription.LAYER_3, bitrates.build());
 147
 148                         mpegAudioVersionMapBuilder.put(MpegAudioVersion.VERSION_2, mpeg2Builder.build());
 149                         mpegAudioVersionMapBuilder.put(MpegAudioVersion.VERSION_2_5, mpeg2Builder.build());
 150
 151                         return mpegAudioVersionMapBuilder.build();
 152                 }
 153         });
 154
 155         /** Sampling rate table. */
 156         private static final Supplier<Map<MpegAudioVersion, Map<Integer, Integer>>> samplingRateSupplier = Suppliers.memoize(new Supplier<Map<MpegAudioVersion, Map<Integer, Integer>>>() {
 157
 158                 @Override
 159                 public Map<MpegAudioVersion, Map<Integer, Integer>> get() {
 160                         ImmutableMap.Builder<MpegAudioVersion, Map<Integer, Integer>> mpegAudioVersions = ImmutableMap.builder();
 161
 162                         /* MPEG 1. */
 163                         ImmutableMap.Builder<Integer, Integer> samplingRates = ImmutableMap.builder();
 164                         samplingRates.put(0, 44100).put(1, 48000).put(2, 32000).put(3, 0);
 165                         mpegAudioVersions.put(MpegAudioVersion.VERSION_1, samplingRates.build());
 166
 167                         /* MPEG 2. */
 168                         samplingRates = ImmutableMap.builder();
 169                         samplingRates.put(0, 22050).put(1, 24000).put(2, 16000).put(3, 0);
 170                         mpegAudioVersions.put(MpegAudioVersion.VERSION_2, samplingRates.build());
 171
 172                         /* MPEG 2.5. */
 173                         samplingRates = ImmutableMap.builder();
 174                         samplingRates.put(0, 11025).put(1, 12000).put(2, 8000).put(3, 0);
 175                         mpegAudioVersions.put(MpegAudioVersion.VERSION_2_5, samplingRates.build());
 176
 177                         return mpegAudioVersions.build();
 178                 }
 179         });
 180
 181         /** The decoded MPEG audio version ID. */
 182         private final int mpegAudioVersionId;
 183
 184         /** The decoded layer description. */
 185         private final int layerDescription;
 186
 187         /** The decoded protection bit. */
 188         private final int protectionBit;
 189
 190         /** The decoded bitrate index. */
 191         private final int bitrateIndex;
 192
 193         /** The deocded sampling rate frequency index. */
 194         private final int samplingRateFrequencyIndex;
 195
 196         /** The decoded padding bit. */
 197         private final int paddingBit;
 198
 199         /** The decoded private bit. */
 200         private final int privateBit;
 201
 202         /** The decoded channel mode. */
 203         private final int channelMode;
 204
 205         /** The deocded mode extension. */
 206         private final int modeExtension;
 207
 208         /** The decoded copyright bit. */
 209         private final int copyright;
 210
 211         /** The deocded original bit. */
 212         private final int original;
 213
 214         /** The decoded emphasis mode. */
 215         private final int emphasis;
 216
 217         private Frame(int mpegAudioVersionId, int layerDescription, int protectionBit, int bitrateIndex, int samplingRateFrequencyIndex, int paddingBit, int privateBit, int channelMode, int modeExtension, int copyright, int original, int emphasis) {
 218                 this.mpegAudioVersionId = mpegAudioVersionId;
 219                 this.layerDescription = layerDescription;
 220                 this.protectionBit = protectionBit;
 221                 this.bitrateIndex = bitrateIndex;
 222                 this.samplingRateFrequencyIndex = samplingRateFrequencyIndex;
 223                 this.paddingBit = paddingBit;
 224                 this.privateBit = privateBit;
 225                 this.channelMode = channelMode;
 226                 this.modeExtension = modeExtension;
 227                 this.copyright = copyright;
 228                 this.original = original;
 229                 this.emphasis = emphasis;
 230         }
 231
 232         //
 233         // ACCESSORS
 234         //
 235
 236         public MpegAudioVersion mpegAudioVersion() {
 237                 return MpegAudioVersion.values()[mpegAudioVersionId];
 238         }
 239
 240         public LayerDescription layerDescription() {
 241                 return LayerDescription.values()[layerDescription];
 242         }
 243
 244         public boolean protectionBit() {
 245                 return protectionBit != 0;
 246         }
 247
 248         public int bitrate() {
 249                 return bitrateSupplier.get().get(mpegAudioVersion()).get(layerDescription()).get(bitrateIndex);
 250         }
 251
 252         public int samplingRate() {
 253                 return samplingRateSupplier.get().get(mpegAudioVersion()).get(samplingRateFrequencyIndex);
 254         }
 255
 256         public boolean paddingBit() {
 257                 return paddingBit != 0;
 258         }
 259
 260         public boolean privateBit() {
 261                 return privateBit != 0;
 262         }
 263
 264         public ChannelMode channelMode() {
 265                 return ChannelMode.values()[channelMode];
 266         }
 267
 268         /* TODO - mode extension. */
 269
 270         public boolean copyrightBit() {
 271                 return copyright != 0;
 272         }
 273
 274         public boolean originalBit() {
 275                 return original != 0;
 276         }
 277
 278         public Emphasis emphasis() {
 279                 return Emphasis.values()[emphasis];
 280         }
 281
 282         //
 283         // STATIC METHODS
 284         //
 285
 286         public static boolean isFrame(byte[] buffer, int offset, int length) {
 287                 return (((buffer[offset] & 0xff) == 0xff) && ((buffer[offset + 1] & 0xe0) == 0xe0));
 288         }
 289
 290         public static Optional<Frame> create(byte[] buffer, int offset, int length) {
 291                 if (isFrame(buffer, offset, length)) {
 292                         int mpegAudioVersionId = (buffer[offset + 1] & 0x18) >>> 3;
 293                         int layerDescription = (buffer[offset + 1] & 0x06) >>> 1;
 294                         int protectionBit = buffer[offset + 1] & 0x01;
 295                         int bitrateIndex = (buffer[offset + 2] & 0xf0) >>> 4;
 296                         int samplingRateFrequencyIndex = (buffer[offset + 2] & 0x0c) >>> 2;
 297                         int paddingBit = (buffer[offset + 2] & 0x02) >>> 1;
 298                         int privateBit = buffer[offset + 2] & 0x01;
 299                         int channelMode = (buffer[offset + 3] & 0xc0) >> 6;
 300                         int modeExtension = (buffer[offset + 3] & 0x60) >> 4;
 301                         int copyright = (buffer[offset + 3] & 0x08) >> 3;
 302                         int original = (buffer[offset + 3] & 0x04) >> 2;
 303                         int emphasis = buffer[offset + 3] & 0x03;
 304                         return Optional.of(new Frame(mpegAudioVersionId, layerDescription, protectionBit, bitrateIndex, samplingRateFrequencyIndex, paddingBit, privateBit, channelMode, modeExtension, copyright, original, emphasis));
 305                 }
 306                 return Optional.absent();
 307         }
 308
 309 }