1 /*
   2  * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.media.sound;
  27 
  28 import java.io.BufferedOutputStream;
  29 import java.io.ByteArrayInputStream;
  30 import java.io.ByteArrayOutputStream;
  31 import java.io.DataOutputStream;
  32 import java.io.File;
  33 import java.io.FileOutputStream;
  34 import java.io.IOException;
  35 import java.io.InputStream;
  36 import java.io.OutputStream;
  37 import java.io.RandomAccessFile;
  38 import java.io.SequenceInputStream;
  39 import java.util.Objects;
  40 
  41 import javax.sound.sampled.AudioFileFormat;
  42 import javax.sound.sampled.AudioFormat;
  43 import javax.sound.sampled.AudioInputStream;
  44 import javax.sound.sampled.AudioSystem;
  45 
  46 //$$fb this class is buggy. Should be replaced in future.
  47 
  48 /**
  49  * AIFF file writer.
  50  *
  51  * @author Jan Borgersen
  52  */
  53 public final class AiffFileWriter extends SunFileWriter {
  54 
  55     /**
  56      * Constructs a new AiffFileWriter object.
  57      */
  58     public AiffFileWriter() {
  59         super(new AudioFileFormat.Type[]{AudioFileFormat.Type.AIFF});
  60     }
  61 

  62     // METHODS TO IMPLEMENT AudioFileWriter
  63 
  64     @Override
  65     public AudioFileFormat.Type[] getAudioFileTypes(AudioInputStream stream) {
  66 
  67         AudioFileFormat.Type[] filetypes = new AudioFileFormat.Type[types.length];
  68         System.arraycopy(types, 0, filetypes, 0, types.length);
  69 
  70         // make sure we can write this stream
  71         AudioFormat format = stream.getFormat();
  72         AudioFormat.Encoding encoding = format.getEncoding();
  73 
  74         if( (AudioFormat.Encoding.ALAW.equals(encoding)) ||
  75             (AudioFormat.Encoding.ULAW.equals(encoding)) ||
  76             (AudioFormat.Encoding.PCM_SIGNED.equals(encoding)) ||
  77             (AudioFormat.Encoding.PCM_UNSIGNED.equals(encoding)) ) {
  78 
  79             return filetypes;
  80         }
  81 
  82         return new AudioFileFormat.Type[0];
  83     }
  84 

  85     @Override
  86     public int write(AudioInputStream stream, AudioFileFormat.Type fileType, OutputStream out) throws IOException {
  87         Objects.requireNonNull(stream);
  88         Objects.requireNonNull(fileType);
  89         Objects.requireNonNull(out);
  90 
  91         //$$fb the following check must come first ! Otherwise
  92         // the next frame length check may throw an IOException and
  93         // interrupt iterating File Writers. (see bug 4351296)
  94 
  95         // throws IllegalArgumentException if not supported
  96         AiffFileFormat aiffFileFormat = (AiffFileFormat)getAudioFileFormat(fileType, stream);
  97 
  98         // we must know the total data length to calculate the file length
  99         if( stream.getFrameLength() == AudioSystem.NOT_SPECIFIED ) {
 100             throw new IOException("stream length not specified");
 101         }
 102 
 103         return writeAiffFile(stream, aiffFileFormat, out);

 104     }
 105 

 106     @Override
 107     public int write(AudioInputStream stream, AudioFileFormat.Type fileType, File out) throws IOException {
 108         Objects.requireNonNull(stream);
 109         Objects.requireNonNull(fileType);
 110         Objects.requireNonNull(out);
 111 
 112         // throws IllegalArgumentException if not supported
 113         AiffFileFormat aiffFileFormat = (AiffFileFormat)getAudioFileFormat(fileType, stream);
 114 
 115         // first write the file without worrying about length fields
 116         FileOutputStream fos = new FileOutputStream( out );     // throws IOException
 117         BufferedOutputStream bos = new BufferedOutputStream( fos, bisBufferSize );
 118         int bytesWritten = writeAiffFile(stream, aiffFileFormat, bos );
 119         bos.close();
 120 
 121         // now, if length fields were not specified, calculate them,
 122         // open as a random access file, write the appropriate fields,
 123         // close again....
 124         if( aiffFileFormat.getByteLength()== AudioSystem.NOT_SPECIFIED ) {
 125 
 126             // $$kk: 10.22.99: jan: please either implement this or throw an exception!
 127             // $$fb: 2001-07-13: done. Fixes Bug 4479981
 128             int ssndBlockSize           = (aiffFileFormat.getFormat().getChannels() * aiffFileFormat.getFormat().getSampleSizeInBits());
 129 
 130             int aiffLength=bytesWritten;
 131             int ssndChunkSize=aiffLength-aiffFileFormat.getHeaderSize()+16;
 132             long dataSize=ssndChunkSize-16;
 133             int numFrames=(int) (dataSize*8/ssndBlockSize);
 134 
 135             RandomAccessFile raf=new RandomAccessFile(out, "rw");
 136             // skip FORM magic
 137             raf.skipBytes(4);
 138             raf.writeInt(aiffLength-8);
 139             // skip aiff2 magic, fver chunk, comm magic, comm size, channel count,
 140             raf.skipBytes(4+aiffFileFormat.getFverChunkSize()+4+4+2);
 141             // write frame count
 142             raf.writeInt(numFrames);
 143             // skip sample size, samplerate, SSND magic
 144             raf.skipBytes(2+10+4);
 145             raf.writeInt(ssndChunkSize-8);
 146             // that's all
 147             raf.close();
 148         }
 149 
 150         return bytesWritten;
 151     }
 152 
 153 
 154     // -----------------------------------------------------------------------
 155 
 156     /**
 157      * Returns the AudioFileFormat describing the file that will be written from this AudioInputStream.
 158      * Throws IllegalArgumentException if not supported.
 159      */
 160     private AudioFileFormat getAudioFileFormat(AudioFileFormat.Type type, AudioInputStream stream) {
 161         if (!isFileTypeSupported(type, stream)) {
 162             throw new IllegalArgumentException("File type " + type + " not supported.");
 163         }
 164 
 165         AudioFormat format = null;
 166         AiffFileFormat fileFormat = null;
 167         AudioFormat.Encoding encoding = AudioFormat.Encoding.PCM_SIGNED;
 168 
 169         AudioFormat streamFormat = stream.getFormat();
 170         AudioFormat.Encoding streamEncoding = streamFormat.getEncoding();
 171 


 172         int sampleSizeInBits;



 173         int fileSize;
 174         boolean convert8to16 = false;
 175 
 176         if( (AudioFormat.Encoding.ALAW.equals(streamEncoding)) ||
 177             (AudioFormat.Encoding.ULAW.equals(streamEncoding)) ) {
 178 
 179             if( streamFormat.getSampleSizeInBits()==8 ) {
 180 
 181                 encoding = AudioFormat.Encoding.PCM_SIGNED;
 182                 sampleSizeInBits=16;
 183                 convert8to16 = true;
 184 
 185             } else {
 186 
 187                 // can't convert non-8-bit ALAW,ULAW
 188                 throw new IllegalArgumentException("Encoding " + streamEncoding + " supported only for 8-bit data.");
 189             }
 190         } else if ( streamFormat.getSampleSizeInBits()==8 ) {
 191 
 192             encoding = AudioFormat.Encoding.PCM_UNSIGNED;
 193             sampleSizeInBits=8;
 194 
 195         } else {
 196 
 197             encoding = AudioFormat.Encoding.PCM_SIGNED;
 198             sampleSizeInBits=streamFormat.getSampleSizeInBits();
 199         }
 200 
 201 
 202         format = new AudioFormat( encoding,
 203                                   streamFormat.getSampleRate(),
 204                                   sampleSizeInBits,
 205                                   streamFormat.getChannels(),
 206                                   streamFormat.getFrameSize(),
 207                                   streamFormat.getFrameRate(),
 208                                   true);        // AIFF is big endian
 209 
 210 
 211         if( stream.getFrameLength()!=AudioSystem.NOT_SPECIFIED ) {
 212             if( convert8to16 ) {
 213                 fileSize = (int)stream.getFrameLength()*streamFormat.getFrameSize()*2 + AiffFileFormat.AIFF_HEADERSIZE;
 214             } else {
 215                 fileSize = (int)stream.getFrameLength()*streamFormat.getFrameSize() + AiffFileFormat.AIFF_HEADERSIZE;
 216             }
 217         } else {
 218             fileSize = AudioSystem.NOT_SPECIFIED;
 219         }
 220 
 221         fileFormat = new AiffFileFormat( AudioFileFormat.Type.AIFF,
 222                                          fileSize,
 223                                          format,
 224                                          (int)stream.getFrameLength() );
 225 
 226         return fileFormat;
 227     }
 228 

 229     private int writeAiffFile(InputStream in, AiffFileFormat aiffFileFormat, OutputStream out) throws IOException {
 230 
 231         int bytesRead = 0;
 232         int bytesWritten = 0;
 233         InputStream fileStream = getFileStream(aiffFileFormat, in);
 234         byte buffer[] = new byte[bisBufferSize];
 235         int maxLength = aiffFileFormat.getByteLength();
 236 
 237         while( (bytesRead = fileStream.read( buffer )) >= 0 ) {
 238             if (maxLength>0) {
 239                 if( bytesRead < maxLength ) {
 240                     out.write( buffer, 0, bytesRead );
 241                     bytesWritten += bytesRead;
 242                     maxLength -= bytesRead;
 243                 } else {
 244                     out.write( buffer, 0, maxLength );
 245                     bytesWritten += maxLength;
 246                     maxLength = 0;
 247                     break;
 248                 }
 249 
 250             } else {
 251                 out.write( buffer, 0, bytesRead );
 252                 bytesWritten += bytesRead;
 253             }
 254         }
 255 
 256         return bytesWritten;
 257     }
 258 
 259     private InputStream getFileStream(AiffFileFormat aiffFileFormat, InputStream audioStream) throws IOException  {
 260 
 261         // private method ... assumes aiffFileFormat is a supported file format
 262 
 263         AudioFormat format = aiffFileFormat.getFormat();
 264         AudioFormat streamFormat = null;
 265         AudioFormat.Encoding encoding = null;
 266 
 267         //$$fb a little bit nicer handling of constants


 268         int headerSize          = aiffFileFormat.getHeaderSize();

 269         //int fverChunkSize       = 0;
 270         int fverChunkSize       = aiffFileFormat.getFverChunkSize();

 271         int commChunkSize       = aiffFileFormat.getCommChunkSize();
 272         int aiffLength          = -1;
 273         int ssndChunkSize       = -1;

 274         int ssndOffset                  = aiffFileFormat.getSsndChunkOffset();
 275         short channels = (short) format.getChannels();
 276         short sampleSize = (short) format.getSampleSizeInBits();
 277         int ssndBlockSize = channels * ((sampleSize + 7) / 8);
 278         int numFrames = aiffFileFormat.getFrameLength();
 279         long dataSize = -1;
 280         if( numFrames != AudioSystem.NOT_SPECIFIED) {
 281             dataSize = (long) numFrames * ssndBlockSize;
 282             ssndChunkSize = (int)dataSize + 16;
 283             aiffLength = (int)dataSize+headerSize;
 284         }
 285         float sampleFramesPerSecond = format.getSampleRate();
 286         int compCode = AiffFileFormat.AIFC_PCM;
 287 
 288         byte header[] = null;
 289         ByteArrayInputStream headerStream = null;
 290         ByteArrayOutputStream baos = null;
 291         DataOutputStream dos = null;
 292         SequenceInputStream aiffStream = null;
 293         InputStream codedAudioStream = audioStream;
 294 
 295         // if we need to do any format conversion, do it here....
 296 
 297         if( audioStream instanceof AudioInputStream ) {
 298 
 299             streamFormat = ((AudioInputStream)audioStream).getFormat();
 300             encoding = streamFormat.getEncoding();
 301 
 302 
 303             // $$jb: Note that AIFF samples are ALWAYS signed
 304             if( (AudioFormat.Encoding.PCM_UNSIGNED.equals(encoding)) ||
 305                 ( (AudioFormat.Encoding.PCM_SIGNED.equals(encoding)) && !streamFormat.isBigEndian() ) ) {
 306 
 307                 // plug in the transcoder to convert to PCM_SIGNED. big endian
 308                 codedAudioStream = AudioSystem.getAudioInputStream( new AudioFormat (
 309                                                                                      AudioFormat.Encoding.PCM_SIGNED,
 310                                                                                      streamFormat.getSampleRate(),
 311                                                                                      streamFormat.getSampleSizeInBits(),
 312                                                                                      streamFormat.getChannels(),
 313                                                                                      streamFormat.getFrameSize(),
 314                                                                                      streamFormat.getFrameRate(),
 315                                                                                      true ),
 316                                                                     (AudioInputStream)audioStream );
 317 
 318             } else if( (AudioFormat.Encoding.ULAW.equals(encoding)) ||
 319                        (AudioFormat.Encoding.ALAW.equals(encoding)) ) {
 320 
 321                 if( streamFormat.getSampleSizeInBits() != 8 ) {
 322                     throw new IllegalArgumentException("unsupported encoding");
 323                 }
 324 
 325                                 //$$fb 2001-07-13: this is probably not what we want:
 326                                 //     writing PCM when ULAW/ALAW is requested. AIFC is able to write ULAW !
 327 
 328                                 // plug in the transcoder to convert to PCM_SIGNED_BIG_ENDIAN
 329                 codedAudioStream = AudioSystem.getAudioInputStream( new AudioFormat (
 330                                                                                      AudioFormat.Encoding.PCM_SIGNED,
 331                                                                                      streamFormat.getSampleRate(),
 332                                                                                      streamFormat.getSampleSizeInBits() * 2,
 333                                                                                      streamFormat.getChannels(),
 334                                                                                      streamFormat.getFrameSize() * 2,
 335                                                                                      streamFormat.getFrameRate(),
 336                                                                                      true ),
 337                                                                     (AudioInputStream)audioStream );
 338             }
 339         }
 340 
 341 
 342         // Now create an AIFF stream header...
 343         baos = new ByteArrayOutputStream();
 344         dos = new DataOutputStream(baos);
 345 
 346         // Write the outer FORM chunk
 347         dos.writeInt(AiffFileFormat.AIFF_MAGIC);
 348         dos.writeInt( (aiffLength-8) );
 349         dos.writeInt(AiffFileFormat.AIFF_MAGIC2);
 350 
 351         // Write a FVER chunk - only for AIFC
 352         //dos.writeInt(FVER_MAGIC);
 353         //dos.writeInt( (fverChunkSize-8) );
 354         //dos.writeInt(FVER_TIMESTAMP);
 355 
 356         // Write a COMM chunk
 357         dos.writeInt(AiffFileFormat.COMM_MAGIC);
 358         dos.writeInt( (commChunkSize-8) );
 359         dos.writeShort(channels);
 360         dos.writeInt(numFrames);
 361         dos.writeShort(sampleSize);
 362         write_ieee_extended(dos, sampleFramesPerSecond);   // 10 bytes
 363 
 364         //Only for AIFC
 365         //dos.writeInt(compCode);
 366         //dos.writeInt(compCode);
 367         //dos.writeShort(0);
 368 
 369         // Write the SSND chunk header
 370         dos.writeInt(AiffFileFormat.SSND_MAGIC);
 371         dos.writeInt( (ssndChunkSize-8) );
 372         // ssndOffset and ssndBlockSize set to 0 upon
 373         // recommendation in "Sound Manager" chapter in
 374         // "Inside Macintosh Sound", pp 2-87  (from Babu)
 375         dos.writeInt(0);        // ssndOffset
 376         dos.writeInt(0);        // ssndBlockSize
 377 
 378         // Concat this with the audioStream and return it
 379 
 380         dos.close();
 381         header = baos.toByteArray();
 382         headerStream = new ByteArrayInputStream( header );
 383 
 384         aiffStream = new SequenceInputStream(headerStream,
 385                             new NoCloseInputStream(codedAudioStream));
 386 
 387         return aiffStream;
 388 
 389     }
 390 



 391     // HELPER METHODS
 392 
 393     private static final int DOUBLE_MANTISSA_LENGTH = 52;
 394     private static final int DOUBLE_EXPONENT_LENGTH = 11;
 395     private static final long DOUBLE_SIGN_MASK     = 0x8000000000000000L;
 396     private static final long DOUBLE_EXPONENT_MASK = 0x7FF0000000000000L;
 397     private static final long DOUBLE_MANTISSA_MASK = 0x000FFFFFFFFFFFFFL;
 398     private static final int DOUBLE_EXPONENT_OFFSET = 1023;
 399 
 400     private static final int EXTENDED_EXPONENT_OFFSET = 16383;
 401     private static final int EXTENDED_MANTISSA_LENGTH = 63;
 402     private static final int EXTENDED_EXPONENT_LENGTH = 15;
 403     private static final long EXTENDED_INTEGER_MASK = 0x8000000000000000L;
 404 
 405     /**
 406      * Extended precision IEEE floating-point conversion routine.
 407      * @argument DataOutputStream
 408      * @argument double
 409      * @exception IOException
 410      */
 411     private void write_ieee_extended(DataOutputStream dos, float f) throws IOException {
 412         /* The special cases NaN, Infinity and Zero are ignored, since
 413            they do not represent useful sample rates anyway.
 414            Denormalized number aren't handled, too. Below, there is a cast
 415            from float to double. We hope that in this conversion,
 416            numbers are normalized. Numbers that cannot be normalized are
 417            ignored, too, as they, too, do not represent useful sample rates. */
 418         long doubleBits = Double.doubleToLongBits((double) f);
 419 
 420         long sign = (doubleBits & DOUBLE_SIGN_MASK)
 421             >> (DOUBLE_EXPONENT_LENGTH + DOUBLE_MANTISSA_LENGTH);
 422         long doubleExponent = (doubleBits & DOUBLE_EXPONENT_MASK)
 423             >> DOUBLE_MANTISSA_LENGTH;
 424         long doubleMantissa = doubleBits & DOUBLE_MANTISSA_MASK;
 425 
 426         long extendedExponent = doubleExponent - DOUBLE_EXPONENT_OFFSET
 427             + EXTENDED_EXPONENT_OFFSET;
 428         long extendedMantissa = doubleMantissa
 429             << (EXTENDED_MANTISSA_LENGTH - DOUBLE_MANTISSA_LENGTH);
 430         long extendedSign = sign << EXTENDED_EXPONENT_LENGTH;
 431         short extendedBits79To64 = (short) (extendedSign | extendedExponent);
 432         long extendedBits63To0 = EXTENDED_INTEGER_MASK | extendedMantissa;
 433 
 434         dos.writeShort(extendedBits79To64);
 435         dos.writeLong(extendedBits63To0);
 436     }


 437 }
--- EOF ---