| Frames | No Frames |
1: /* Audio file format 2: Copyright (C) 2005 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package javax.sound.sampled; 40: 41: import java.util.Collections; 42: import java.util.HashMap; 43: import java.util.Map; 44: 45: /** 46: * This describes an audio file, including information about its length, 47: * the format of the audio data, and other things. 48: * @since 1.3 49: */ 50: public class AudioFileFormat 51: { 52: /** 53: * An instance of this type describes a standard audio file format. 54: * @since 1.3 55: */ 56: public static class Type 57: { 58: // This is kind of goofy since there are multiple extensions for 59: // some of these. 60: 61: /** The AIFC format. */ 62: public static final Type AIFC = new Type("AIFC", "aifc"); 63: 64: /** The AIFF format. */ 65: public static final Type AIFF = new Type("AIFF", "aiff"); 66: 67: /** The AU format. */ 68: public static final Type AU = new Type("AU", "au"); 69: 70: /** The SND format. */ 71: public static final Type SND = new Type("SND", "snd"); 72: 73: /** The WAVE format. */ 74: public static final Type WAVE = new Type ("WAVE", "wav"); 75: 76: private String name; 77: private String extension; 78: 79: /** 80: * Create a new Type given its name and file extension. 81: * The file extension does not include the ".". 82: * @param name the type's name 83: * @param extension the file extension 84: */ 85: public Type(String name, String extension) 86: { 87: this.name = name; 88: this.extension = extension; 89: } 90: 91: public final boolean equals(Object o) 92: { 93: if (! (o instanceof Type)) 94: return false; 95: Type other = (Type) o; 96: return name.equals(other.name) && extension.equals(other.extension); 97: } 98: 99: public final int hashCode() 100: { 101: return name.hashCode() + extension.hashCode(); 102: } 103: 104: /** 105: * Return the extension associated with this Type. 106: */ 107: public String getExtension() 108: { 109: return extension; 110: } 111: 112: /** 113: * Return the name of this Type. 114: */ 115: public final String toString() 116: { 117: return name; 118: } 119: } 120: 121: private int byteLength; 122: private AudioFormat format; 123: private Type type; 124: private int frameLength; 125: private Map<String, Object> properties; 126: 127: /** 128: * Create a new AudioFileFormat given the type, the format, and the 129: * frame length. The new object will have an unspecified byte length, 130: * and an empty properties map. 131: * @param type the type 132: * @param fmt the format 133: * @param frameLen the frame length 134: */ 135: public AudioFileFormat(Type type, AudioFormat fmt, int frameLen) 136: { 137: this.byteLength = AudioSystem.NOT_SPECIFIED; 138: this.format = fmt; 139: this.type = type; 140: this.frameLength = frameLen; 141: this.properties = Collections.<String, Object> emptyMap(); 142: } 143: 144: /** 145: * Create a new AudioFileFormat given the type, the format, the 146: * frame length, and some properties. The new object will have an 147: * unspecified byte length. A copy of the properties argument will 148: * be made, so changes to the map passed in will not affect the 149: * new AudioFileFormat. 150: * @param type the type 151: * @param fmt the format 152: * @param frameLen the frame length 153: * @param properties the properties 154: */ 155: public AudioFileFormat(Type type, AudioFormat fmt, int frameLen, 156: Map<String, Object> properties) 157: { 158: this.byteLength = AudioSystem.NOT_SPECIFIED; 159: this.format = fmt; 160: this.type = type; 161: this.frameLength = frameLen; 162: this.properties = Collections.unmodifiableMap(new HashMap<String, Object>(properties)); 163: } 164: 165: /** 166: * Create a new AudioFileFormat given the type, the byte length, the format, 167: * and the frame length. The new object will have an empty properties map. 168: * @param type the type 169: * @param byteLen the byte length 170: * @param fmt the format 171: * @param frameLen the frame length 172: */ 173: protected AudioFileFormat(Type type, int byteLen, AudioFormat fmt, 174: int frameLen) 175: { 176: this.byteLength = byteLen; 177: this.format = fmt; 178: this.type = type; 179: this.frameLength = frameLen; 180: this.properties = Collections.<String, Object> emptyMap(); 181: } 182: 183: /** 184: * Return the byte length of this file format. 185: */ 186: public int getByteLength() 187: { 188: return byteLength; 189: } 190: 191: /** 192: * Return the AudioFormat associated with this file format. 193: */ 194: public AudioFormat getFormat() 195: { 196: return format; 197: } 198: 199: /** 200: * Return the frame length of this file format. 201: */ 202: public int getFrameLength() 203: { 204: return frameLength; 205: } 206: 207: /** 208: * Return the value of a property defined in this format. 209: * @param key the property name 210: * @return the value of the property, or null if the property is not defined 211: */ 212: public Object getProperty(String key) 213: { 214: return properties.get(key); 215: } 216: 217: /** 218: * Return the Type associated with this file format. 219: */ 220: public Type getType() 221: { 222: return type; 223: } 224: 225: /** 226: * Return the properties associated with this format, as a Map. 227: * The returned Map is unmodifiable. 228: */ 229: public Map<String, Object> properties() 230: { 231: return properties; 232: } 233: 234: /** 235: * Return a description of this AudioFileFormat. 236: */ 237: public String toString() 238: { 239: return ("byteLength=" + byteLength + "; format=" + format 240: + "; type=" + type + "; frameLength=" + frameLength); 241: } 242: }