예제 #1
0
파일: Ogg.java 프로젝트: eerock/libgdx
 protected int read(byte[] buffer) {
   if (input == null) {
     input = new OggInputStream(file.read());
     setup(input.getChannels(), input.getSampleRate());
   }
   return input.read(buffer);
 }
예제 #2
0
파일: Ogg.java 프로젝트: eerock/libgdx
    public Sound(OpenALAudio audio, FileHandle file) {
      super(audio);

      OggInputStream input = new OggInputStream(file.read());
      ByteArrayOutputStream output = new ByteArrayOutputStream(4096);
      byte[] buffer = new byte[2048];
      while (!input.atEnd()) {
        int length = input.read(buffer);
        if (length == -1) break;
        output.write(buffer, 0, length);
      }
      setup(output.toByteArray(), input.getChannels(), input.getSampleRate());
    }
예제 #3
0
파일: Ogg.java 프로젝트: eerock/libgdx
 protected void reset() {
   if (input == null) return;
   input.close();
   input = null;
 }
예제 #4
0
  /**
   * Get the data out of an OGG file
   *
   * @param input The input stream from which to read the OGG file
   * @return The data describing the OGG thats been read
   * @throws IOException Indicaites a failure to read the OGG file
   */
  @Nonnull
  public OggData getData(@Nullable InputStream input) throws IOException {
    if (input == null) {
      throw new IOException("Failed to read OGG, source does not exist?");
    }
    ByteArrayOutputStream dataout = new ByteArrayOutputStream();

    //		SyncState oy = new SyncState(); // sync and verify incoming physical bitstream
    //		StreamState os = new StreamState(); // take physical pages, weld into a logical stream of
    // packets
    //		Page og = new Page(); // one Ogg bitstream page.  Vorbis packets are inside
    //		Packet op = new Packet(); // one raw packet of data for decode
    //
    //		Info vi = new Info(); // struct that stores all the static vorbis bitstream settings
    //		Comment vc = new Comment(); // struct that stores all the bitstream user comments
    //		DspState vd = new DspState(); // central working state for the packet->PCM decoder
    //		Block vb = new Block(vd); // local working space for packet->PCM decode
    //
    //		byte[] buffer;
    //		int bytes = 0;
    //
    //		boolean bigEndian = ByteOrder.nativeOrder().equals(ByteOrder.BIG_ENDIAN);
    //		// Decode setup
    //
    //		oy.initialize(); // Now we can read pages
    //
    //		while (true) { // we repeat if the bitstream is chained
    //			int eos = 0;
    //
    //			// grab some data at the head of the stream.  We want the first page
    //			// (which is guaranteed to be small and only contain the Vorbis
    //			// stream initial header) We need the first page to get the stream
    //			// serialno.
    //
    //			// submit a 4k block to libvorbis' Ogg layer
    //			int index = oy.buffer(4096);
    //
    //			buffer = oy.data;
    //			try {
    //				bytes = input.read(buffer, index, 4096);
    //			} catch (Exception e) {
    //				Log.error("Failure reading in vorbis");
    //				Log.error(e);
    //				System.exit(0);
    //			}
    //			oy.wrote(bytes);
    //
    //			// Get the first page.
    //			if (oy.pageout(og) != 1) {
    //				// have we simply run out of data?  If so, we're done.
    //				if (bytes < 4096)
    //					break;
    //
    //				// error case.  Must not be Vorbis data
    //				Log.error("Input does not appear to be an Ogg bitstream.");
    //				System.exit(0);
    //			}
    //
    //			// Get the serial number and set up the rest of decode.
    //			// serialno first; use it to set up a logical stream
    //			os.initialize(og.serialno());
    //
    //			// extract the initial header from the first page and verify that the
    //			// Ogg bitstream is in fact Vorbis data
    //
    //			// I handle the initial header first instead of just having the code
    //			// read all three Vorbis headers at once because reading the initial
    //			// header is an easy way to identify a Vorbis bitstream and it's
    //			// useful to see that functionality seperated out.
    //
    //			vi.initialize();
    //			vc.initialize();
    //			if (os.pagein(og) < 0) {
    //				// error; stream version mismatch perhaps
    //				Log.error("Error reading first page of Ogg bitstream data.");
    //				System.exit(0);
    //			}
    //
    //			if (os.packetout(op) != 1) {
    //				// no page? must not be vorbis
    //				Log.error("Error reading initial header packet.");
    //				System.exit(0);
    //			}
    //
    //			if (vi.synthesis_headerin(vc, op) < 0) {
    //				// error case; not a vorbis header
    //				Log.error("This Ogg bitstream does not contain Vorbis audio data.");
    //				System.exit(0);
    //			}
    //
    //			// At this point, we're sure we're Vorbis.  We've set up the logical
    //			// (Ogg) bitstream decoder.  Get the comment and codebook headers and
    //			// set up the Vorbis decoder
    //
    //			// The next two packets in order are the comment and codebook headers.
    //			// They're likely large and may span multiple pages.  Thus we reead
    //			// and submit data until we get our two pacakets, watching that no
    //			// pages are missing.  If a page is missing, error out; losing a
    //			// header page is the only place where missing data is fatal. */
    //
    //			int i = 0;
    //			while (i < 2) {
    //				while (i < 2) {
    //
    //					int result = oy.pageout(og);
    //					if (result == 0)
    //						break; // Need more data
    //					// Don't complain about missing or corrupt data yet.  We'll
    //					// catch it at the packet output phase
    //
    //					if (result == 1) {
    //						os.pagein(og); // we can ignore any errors here
    //						// as they'll also become apparent
    //						// at packetout
    //						while (i < 2) {
    //							result = os.packetout(op);
    //							if (result == 0)
    //								break;
    //							if (result == -1) {
    //								// Uh oh; data at some point was corrupted or missing!
    //								// We can't tolerate that in a header.  Die.
    //								Log.error("Corrupt secondary header.  Exiting.");
    //								System.exit(0);
    //							}
    //							vi.synthesis_headerin(vc, op);
    //							i++;
    //						}
    //					}
    //				}
    //				// no harm in not checking before adding more
    //				index = oy.buffer(4096);
    //				buffer = oy.data;
    //				try {
    //					bytes = input.read(buffer, index, 4096);
    //				} catch (Exception e) {
    //					Log.error("Failed to read Vorbis: ");
    //					Log.error(e);
    //					System.exit(0);
    //				}
    //				if (bytes == 0 && i < 2) {
    //					Log.error("End of file before finding all Vorbis headers!");
    //					System.exit(0);
    //				}
    //				oy.wrote(bytes);
    //			}
    //
    //			convsize = 4096 / vi.channels;
    //
    //			// OK, got and parsed all three headers. Initialize the Vorbis
    //			//  packet->PCM decoder.
    //			vd.synthesis_init(vi); // central decode state
    //			vb.initialize(vd); // local state for most of the decode
    //			// so multiple block decodes can
    //			// proceed in parallel.  We could initialize
    //			// multiple vorbis_block structures
    //			// for vd here
    //
    //			float[][][] _pcm = new float[1][][];
    //			int[] _index = new int[vi.channels];
    //			// The rest is just a straight decode loop until end of stream
    //			while (eos == 0) {
    //				while (eos == 0) {
    //
    //					int result = oy.pageout(og);
    //					if (result == 0)
    //						break; // need more data
    //					if (result == -1) { // missing or corrupt data at this page position
    //						Log.error("Corrupt or missing data in bitstream; continuing...");
    //					} else {
    //						os.pagein(og); // can safely ignore errors at
    //						// this point
    //						while (true) {
    //							result = os.packetout(op);
    //
    //							if (result == 0)
    //								break; // need more data
    //							if (result == -1) { // missing or corrupt data at this page position
    //								// no reason to complain; already complained above
    //							} else {
    //								// we have a packet.  Decode it
    //								int samples;
    //								if (vb.synthesis(op) == 0) { // test for success!
    //									vd.synthesis_blockin(vb);
    //								}
    //
    //								// **pcm is a multichannel float vector.  In stereo, for
    //								// example, pcm[0] is left, and pcm[1] is right.  samples is
    //								// the size of each channel.  Convert the float values
    //								// (-1.<=range<=1.) to whatever PCM format and write it out
    //
    //								while ((samples = vd.synthesis_pcmout(_pcm,
    //										_index)) > 0) {
    //									float[][] pcm = _pcm[0];
    //									//boolean clipflag = false;
    //									int bout = (samples < convsize ? samples
    //											: convsize);
    //
    //									// convert floats to 16 bit signed ints (host order) and
    //									// interleave
    //									for (i = 0; i < vi.channels; i++) {
    //										int ptr = i * 2;
    //										//int ptr=i;
    //										int mono = _index[i];
    //										for (int j = 0; j < bout; j++) {
    //											int val = (int) (pcm[i][mono + j] * 32767.);
    //											//			      short val=(short)(pcm[i][mono+j]*32767.);
    //											//			      int val=(int)Math.round(pcm[i][mono+j]*32767.);
    //											// might as well guard against clipping
    //											if (val > 32767) {
    //												val = 32767;
    //												//clipflag = true;
    //											}
    //											if (val < -32768) {
    //												val = -32768;
    //												//clipflag = true;
    //											}
    //											if (val < 0)
    //												val = val | 0x8000;
    //
    //											if (bigEndian) {
    //												convbuffer[ptr] = (byte) (val >>> 8);
    //												convbuffer[ptr + 1] = (byte) (val);
    //											} else {
    //												convbuffer[ptr] = (byte) (val);
    //												convbuffer[ptr + 1] = (byte) (val >>> 8);
    //											}
    //											ptr += 2 * (vi.channels);
    //										}
    //									}
    //
    //									dataout.write(convbuffer, 0, 2 * vi.channels * bout);
    //
    //									vd.synthesis_read(bout); // tell libvorbis how
    //									// many samples we
    //									// actually consumed
    //								}
    //							}
    //						}
    //						if (og.eos() != 0)
    //							eos = 1;
    //					}
    //				}
    //				if (eos == 0) {
    //					index = oy.buffer(4096);
    //					if (index >= 0) {
    //						buffer = oy.data;
    //						try {
    //							bytes = input.read(buffer, index, 4096);
    //						} catch (Exception e) {
    //							Log.error("Failure during vorbis decoding");
    //							Log.error(e);
    //							return null;
    //						}
    //					} else {
    //						bytes = 0;
    //					}
    //					oy.wrote(bytes);
    //					if (bytes == 0)
    //						eos = 1;
    //				}
    //			}
    //
    //			// clean up this logical bitstream; before exit we see if we're
    //			// followed by another [chained]
    //
    //			os.clear();
    //
    //			// ogg_page and ogg_packet structs always point to storage in
    //			// libvorbis.  They're never freed or manipulated directly
    //
    //			vb.clear();
    //			vd.clear();
    //			vi.clear(); // must be called last
    //		}
    //
    //		// OK, clean up the framer
    //		oy.clear();
    //		OggData ogg = new OggData();
    //		ogg.channels = vi.channels;
    //		ogg.rate = vi.rate;

    OggInputStream oggInput = new OggInputStream(input);

    // boolean done = false;
    while (!oggInput.atEnd()) {
      dataout.write(oggInput.read());
    }

    OggData ogg = new OggData();
    ogg.channels = oggInput.getChannels();
    ogg.rate = oggInput.getRate();

    byte[] data = dataout.toByteArray();
    ogg.data = ByteBuffer.allocateDirect(data.length);
    ogg.data.put(data);
    ogg.data.rewind();

    return ogg;
  }