Save This Page
Home » openjdk-7 » com.sun.media » sound » [javadoc | source]
    1   /*
    2    * Copyright (c) 2007, 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   package com.sun.media.sound;
   26   
   27   import java.io.ByteArrayInputStream;
   28   import java.io.DataInputStream;
   29   import java.io.File;
   30   import java.io.IOException;
   31   import java.io.InputStream;
   32   import java.io.OutputStream;
   33   import java.io.RandomAccessFile;
   34   import java.util.Collection;
   35   
   36   /**
   37    * This class is a pointer to a binary array either in memory or on disk.
   38    *
   39    * @author Karl Helgason
   40    */
   41   public class ModelByteBuffer {
   42   
   43       private ModelByteBuffer root = this;
   44       private File file;
   45       private long fileoffset;
   46       private byte[] buffer;
   47       private long offset;
   48       private final long len;
   49   
   50       private class RandomFileInputStream extends InputStream {
   51   
   52           private RandomAccessFile raf;
   53           private long left;
   54           private long mark = 0;
   55           private long markleft = 0;
   56   
   57           public RandomFileInputStream() throws IOException {
   58               raf = new RandomAccessFile(root.file, "r");
   59               raf.seek(root.fileoffset + arrayOffset());
   60               left = capacity();
   61           }
   62   
   63           public int available() throws IOException {
   64               if (left > Integer.MAX_VALUE)
   65                   return Integer.MAX_VALUE;
   66               return (int)left;
   67           }
   68   
   69           public synchronized void mark(int readlimit) {
   70               try {
   71                   mark = raf.getFilePointer();
   72                   markleft = left;
   73               } catch (IOException e) {
   74                   //e.printStackTrace();
   75               }
   76           }
   77   
   78           public boolean markSupported() {
   79               return true;
   80           }
   81   
   82           public synchronized void reset() throws IOException {
   83               raf.seek(mark);
   84               left = markleft;
   85           }
   86   
   87           public long skip(long n) throws IOException {
   88               if( n < 0)
   89                   return 0;
   90               if (n > left)
   91                   n = left;
   92               long p = raf.getFilePointer();
   93               raf.seek(p + n);
   94               left -= n;
   95               return n;
   96           }
   97   
   98           public int read(byte b[], int off, int len) throws IOException {
   99               if (len > left)
  100                   len = (int)left;
  101               if (left == 0)
  102                   return -1;
  103               len = raf.read(b, off, len);
  104               if (len == -1)
  105                   return -1;
  106               left -= len;
  107               return len;
  108           }
  109   
  110           public int read(byte[] b) throws IOException {
  111               int len = b.length;
  112               if (len > left)
  113                   len = (int)left;
  114               if (left == 0)
  115                   return -1;
  116               len = raf.read(b, 0, len);
  117               if (len == -1)
  118                   return -1;
  119               left -= len;
  120               return len;
  121           }
  122   
  123           public int read() throws IOException {
  124               if (left == 0)
  125                   return -1;
  126               int b = raf.read();
  127               if (b == -1)
  128                   return -1;
  129               left--;
  130               return b;
  131           }
  132   
  133           public void close() throws IOException {
  134               raf.close();
  135           }
  136       }
  137   
  138       private ModelByteBuffer(ModelByteBuffer parent,
  139               long beginIndex, long endIndex, boolean independent) {
  140           this.root = parent.root;
  141           this.offset = 0;
  142           long parent_len = parent.len;
  143           if (beginIndex < 0)
  144               beginIndex = 0;
  145           if (beginIndex > parent_len)
  146               beginIndex = parent_len;
  147           if (endIndex < 0)
  148               endIndex = 0;
  149           if (endIndex > parent_len)
  150               endIndex = parent_len;
  151           if (beginIndex > endIndex)
  152               beginIndex = endIndex;
  153           offset = beginIndex;
  154           len = endIndex - beginIndex;
  155           if (independent) {
  156               buffer = root.buffer;
  157               if (root.file != null) {
  158                   file = root.file;
  159                   fileoffset = root.fileoffset + arrayOffset();
  160                   offset = 0;
  161               } else
  162                   offset = arrayOffset();
  163               root = this;
  164           }
  165       }
  166   
  167       public ModelByteBuffer(byte[] buffer) {
  168           this.buffer = buffer;
  169           this.offset = 0;
  170           this.len = buffer.length;
  171       }
  172   
  173       public ModelByteBuffer(byte[] buffer, int offset, int len) {
  174           this.buffer = buffer;
  175           this.offset = offset;
  176           this.len = len;
  177       }
  178   
  179       public ModelByteBuffer(File file) {
  180           this.file = file;
  181           this.fileoffset = 0;
  182           this.len = file.length();
  183       }
  184   
  185       public ModelByteBuffer(File file, long offset, long len) {
  186           this.file = file;
  187           this.fileoffset = offset;
  188           this.len = len;
  189       }
  190   
  191       public void writeTo(OutputStream out) throws IOException {
  192           if (root.file != null && root.buffer == null) {
  193               InputStream is = getInputStream();
  194               byte[] buff = new byte[1024];
  195               int ret;
  196               while ((ret = is.read(buff)) != -1)
  197                   out.write(buff, 0, ret);
  198           } else
  199               out.write(array(), (int) arrayOffset(), (int) capacity());
  200       }
  201   
  202       public InputStream getInputStream() {
  203           if (root.file != null && root.buffer == null) {
  204               try {
  205                   return new RandomFileInputStream();
  206               } catch (IOException e) {
  207                   //e.printStackTrace();
  208                   return null;
  209               }
  210           }
  211           return new ByteArrayInputStream(array(),
  212                   (int)arrayOffset(), (int)capacity());
  213       }
  214   
  215       public ModelByteBuffer subbuffer(long beginIndex) {
  216           return subbuffer(beginIndex, capacity());
  217       }
  218   
  219       public ModelByteBuffer subbuffer(long beginIndex, long endIndex) {
  220           return subbuffer(beginIndex, endIndex, false);
  221       }
  222   
  223       public ModelByteBuffer subbuffer(long beginIndex, long endIndex,
  224               boolean independent) {
  225           return new ModelByteBuffer(this, beginIndex, endIndex, independent);
  226       }
  227   
  228       public byte[] array() {
  229           return root.buffer;
  230       }
  231   
  232       public long arrayOffset() {
  233           if (root != this)
  234               return root.arrayOffset() + offset;
  235           return offset;
  236       }
  237   
  238       public long capacity() {
  239           return len;
  240       }
  241   
  242       public ModelByteBuffer getRoot() {
  243           return root;
  244       }
  245   
  246       public File getFile() {
  247           return file;
  248       }
  249   
  250       public long getFilePointer() {
  251           return fileoffset;
  252       }
  253   
  254       public static void loadAll(Collection<ModelByteBuffer> col)
  255               throws IOException {
  256           File selfile = null;
  257           RandomAccessFile raf = null;
  258           try {
  259               for (ModelByteBuffer mbuff : col) {
  260                   mbuff = mbuff.root;
  261                   if (mbuff.file == null)
  262                       continue;
  263                   if (mbuff.buffer != null)
  264                       continue;
  265                   if (selfile == null || !selfile.equals(mbuff.file)) {
  266                       if (raf != null) {
  267                           raf.close();
  268                           raf = null;
  269                       }
  270                       selfile = mbuff.file;
  271                       raf = new RandomAccessFile(mbuff.file, "r");
  272                   }
  273                   raf.seek(mbuff.fileoffset);
  274                   byte[] buffer = new byte[(int) mbuff.capacity()];
  275   
  276                   int read = 0;
  277                   int avail = buffer.length;
  278                   while (read != avail) {
  279                       if (avail - read > 65536) {
  280                           raf.readFully(buffer, read, 65536);
  281                           read += 65536;
  282                       } else {
  283                           raf.readFully(buffer, read, avail - read);
  284                           read = avail;
  285                       }
  286   
  287                   }
  288   
  289                   mbuff.buffer = buffer;
  290                   mbuff.offset = 0;
  291               }
  292           } finally {
  293               if (raf != null)
  294                   raf.close();
  295           }
  296       }
  297   
  298       public void load() throws IOException {
  299           if (root != this) {
  300               root.load();
  301               return;
  302           }
  303           if (buffer != null)
  304               return;
  305           if (file == null) {
  306               throw new IllegalStateException(
  307                       "No file associated with this ByteBuffer!");
  308           }
  309   
  310           DataInputStream is = new DataInputStream(getInputStream());
  311           buffer = new byte[(int) capacity()];
  312           offset = 0;
  313           is.readFully(buffer);
  314           is.close();
  315   
  316       }
  317   
  318       public void unload() {
  319           if (root != this) {
  320               root.unload();
  321               return;
  322           }
  323           if (file == null) {
  324               throw new IllegalStateException(
  325                       "No file associated with this ByteBuffer!");
  326           }
  327           root.buffer = null;
  328       }
  329   }

Save This Page
Home » openjdk-7 » com.sun.media » sound » [javadoc | source]