libjava/classpath/gnu/javax/sound/sampled/gstreamer/io/GstAudioFileReader.java

   1 /*GstAudioFileReader -- GNU Classpath GStreamer AudioFileReader.
   2  Copyright (C) 2007 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 package gnu.javax.sound.sampled.gstreamer.io;
  39
  40 import gnu.java.lang.CPStringBuilder;
  41
  42 import gnu.javax.sound.sampled.gstreamer.GStreamerMixer;
  43
  44 import java.io.BufferedInputStream;
  45 import java.io.File;
  46 import java.io.FileInputStream;
  47 import java.io.IOException;
  48 import java.io.InputStream;
  49 import java.net.URL;
  50 import javax.sound.sampled.AudioFileFormat;
  51 import javax.sound.sampled.AudioFormat;
  52 import javax.sound.sampled.AudioInputStream;
  53 import javax.sound.sampled.AudioSystem;
  54 import javax.sound.sampled.UnsupportedAudioFileException;
  55 import javax.sound.sampled.spi.AudioFileReader;
  56
  57 /**
  58  * An implementation of a general AudioFileReader. Uses GStreamer to
  59  * parse and retrieve informations about the file passed as input.
  60  *
  61  * @author Mario Torre <neugens@limasoftware.net>
  62  */
  63 public class GstAudioFileReader
  64     extends AudioFileReader
  65 {
  66   @Override
  67   public AudioFileFormat getAudioFileFormat(File file)
  68       throws UnsupportedAudioFileException, IOException
  69   {
  70     CPStringBuilder name = new CPStringBuilder(file.getName());
  71     String _name = name.substring(name.lastIndexOf(".") + 1);
  72
  73     return getAudioFileFormat(
  74                new BufferedInputStream(new FileInputStream(file)), _name);
  75   }
  76
  77   @Override
  78   public AudioFileFormat getAudioFileFormat(InputStream is)
  79       throws UnsupportedAudioFileException, IOException
  80   {
  81     return getAudioFileFormat(is, null);
  82   }
  83
  84   private AudioFileFormat getAudioFileFormat(InputStream is, String extension)
  85     throws UnsupportedAudioFileException
  86     {
  87       AudioFormat format = null;
  88       try
  89         {
  90           format = GstAudioFileReaderNativePeer.getAudioFormat(is);
  91         }
  92       catch (Exception e)
  93         {
  94           UnsupportedAudioFileException ex =
  95             new UnsupportedAudioFileException("Unsupported encoding.");
  96
  97           ex.initCause(ex.getCause());
  98           throw ex;
  99         }
 100
 101       if (format == null)
 102         throw new UnsupportedAudioFileException("Unsupported encoding.");
 103
 104       String name = format.getProperty(GStreamerMixer.GST_DECODER).toString();
 105
 106       if (extension == null)
 107         {
 108           extension =
 109             format.getProperty(GStreamerMixer.GST_FILE_EXTENSION).toString();
 110         }
 111
 112       AudioFileFormat.Type type =
 113         new AudioFileFormat.Type(name, extension);
 114
 115       // TODO: we should calculate this in some way. We don't need it, but
 116       // application may want to use this data.
 117       return new AudioFileFormat(type, format, AudioSystem.NOT_SPECIFIED);
 118     }
 119
 120   @Override
 121   public AudioFileFormat getAudioFileFormat(URL url)
 122       throws UnsupportedAudioFileException, IOException
 123   {
 124     return getAudioFileFormat(new BufferedInputStream(url.openStream()));
 125   }
 126
 127   @Override
 128   public AudioInputStream getAudioInputStream(File file)
 129       throws UnsupportedAudioFileException, IOException
 130   {
 131     InputStream stream = new FileInputStream(file);
 132     long length = file.length();
 133
 134     AudioFormat format = null;
 135
 136     try
 137       {
 138         format = GstAudioFileReaderNativePeer.getAudioFormat(file);
 139       }
 140     catch (Exception e)
 141       {
 142         UnsupportedAudioFileException ex =
 143           new UnsupportedAudioFileException("Unsupported encoding.");
 144
 145         ex.initCause(ex.getCause());
 146         throw ex;
 147       }
 148
 149     // get the header size
 150     if (format == null)
 151       throw new UnsupportedAudioFileException("Unsupported encoding.");
 152
 153     return new AudioInputStream(stream, format, length);
 154   }
 155
 156   @Override
 157   public AudioInputStream getAudioInputStream(InputStream is)
 158       throws UnsupportedAudioFileException, IOException
 159   {
 160     AudioFormat format = null;
 161
 162     try
 163       {
 164         format = GstAudioFileReaderNativePeer.getAudioFormat(is);
 165       }
 166     catch (Exception e)
 167       {
 168         // TODO Auto-generated catch block
 169         e.printStackTrace();
 170       }
 171
 172     // get the header size
 173     if (format == null)
 174       throw new UnsupportedAudioFileException("Unsupported encoding.");
 175
 176     return new AudioInputStream(is, format, AudioSystem.NOT_SPECIFIED);
 177   }
 178
 179   @Override
 180   public AudioInputStream getAudioInputStream(URL url)
 181       throws UnsupportedAudioFileException, IOException
 182   {
 183     return getAudioInputStream(new BufferedInputStream(url.openStream()));
 184   }
 185 }