Package com.jcraft.jogg

Examples of com.jcraft.jogg.StreamState


          int ret = buffer_data(oy);
          if (ret <= 0)
            break;
          while (oy.pageout(og) > 0)
          {
            StreamState test = new StreamState();

            /* is this a mandated initial header? If not, stop parsing */
            if (og.bos() == 0)
            {
              /* don't leak the page; get it into the appropriate stream */
              queue_page(og);
              stateflag = 1;
              break;
            }

            test.init(og.serialno());
            test.pagein(og);
            test.packetout(op);
           
            /* identify the codec: try theora */
            if (ENABLE_VIDEO && theora_p == 0 && ti.decodeHeader(tc, op) >= 0)
            {
              /* it is theora */
              to = test;
              theora_p = 1;
            } else if (ENABLE_AUDIO && vorbis_p == 0 && vi.synthesis_headerin(vc, op) >= 0)
            {
              /* it is vorbis */
              vo = test;
              //memcpy(&vo,&test,sizeof(test));
              vorbis_p = 1;
            } else
            {
              /* whatever it is, we don't care about it */
              test.clear();
            }
          }
          /* fall through to non-bos page parsing */
        }

 
View Full Code Here


    /**
     * Initializes all the jOrbis and jOgg vars that are used for song playback.
     */
    private void init_jorbis() {
        oggSyncState_ = new SyncState();
        oggStreamState_ = new StreamState();
        oggPage_ = new Page();
        oggPacket_ = new Packet();
        vorbisInfo = new Info();
        vorbisComment = new Comment();
        vorbisDspState = new DspState();
View Full Code Here

    /**
     * Initializes all the jOrbis and jOgg vars that are used for song playback.
     */
    private void init_jorbis() {
        oggSyncState_ = new SyncState();
        oggStreamState_ = new StreamState();
        oggPage_ = new Page();
        oggPacket_ = new Packet();
        vorbisInfo = new Info();
        vorbisComment = new Comment();
        vorbisDspState = new DspState();
View Full Code Here

            else
                log.error( "Input is not an Ogg bitstream." );
            return;
        }
        state.serial = og.serialno();
        state.os = new StreamState();
        state.os.init( state.serial );

        state.vi = new Info();
        state.vi.init();
View Full Code Here

    /*
     * Taken from the JOrbis Player
     */
    private void initJOrbis(){
        oy=new SyncState();
        os=new StreamState();
        og=new Page();
        op=new Packet();
     
        vi=new Info();
        vc=new Comment();
View Full Code Here

                System.err.println(e);
            }
        }

        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;

        // Decode setup

        oy.init(); // 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) {
                System.err.println(e);
                System.exit(-1);
            }
            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
                System.err.println("Input does not appear to be an Ogg bitstream.");
                System.exit(1);
            }

            // Get the serial number and set up the rest of decode.
            // serialno first; use it to set up a logical stream
            os.init(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.init();
            vc.init();
            if (os.pagein(og) < 0) {
                // error; stream version mismatch perhaps
                System.err.println("Error reading first page of Ogg bitstream data.");
                System.exit(1);
            }

            if (os.packetout(op) != 1) {
                // no page? must not be vorbis
                System.err.println("Error reading initial header packet.");
                System.exit(1);
            }

            if (vi.synthesis_headerin(vc, op) < 0) {
                // error case; not a vorbis header
                System.err
                        .println("This Ogg bitstream does not contain Vorbis audio data.");
                System.exit(1);
            }

            // 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.
                                System.err.println("Corrupt secondary header.  Exiting.");
                                System.exit(1);
                            }
                            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) {
                    System.err.println(e);
                    System.exit(1);
                }
                if (bytes == 0 && i < 2) {
                    System.err.println("End of file before finding all Vorbis headers!");
                    System.exit(1);
                }
                oy.wrote(bytes);
            }

            // Throw the comments plus a few lines about the bitstream we're
            // decoding
            {
                byte[][] ptr = vc.user_comments;
                for (int j = 0; j < ptr.length; j++) {
                    if (ptr[j] == null)
                        break;
                    System.err.println(new String(ptr[j], 0, ptr[j].length - 1));
                }
                System.err.println("\nBitstream is " + vi.channels + " channel, " + vi.rate
                        + "Hz");
                System.err.println("Encoded by: "
                        + new String(vc.vendor, 0, vc.vendor.length - 1) + "\n");
            }

            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.init(vd); // local state for most of the decode
            // so multiple block decodes can
            // proceed in parallel.  We could init
            // 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
                        System.err
                                .println("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];
                                    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;
                                            }
                                            if (val < -32768) {
                                                val = -32768;
                                            }
                                            if (val < 0)
                                                val = val | 0x8000;
                                            convbuffer[ptr] = (byte) (val);
                                            convbuffer[ptr + 1] = (byte) (val >>> 8);
                                            ptr += 2 * (vi.channels);
                                        }
                                    }

                                    System.out.write(convbuffer, 0, 2 * vi.channels * bout);

                                    // tell libvorbis how
                                    // many samples we
                                    // actually consumed
                                    vd.synthesis_read(bout);
                                }
                            }
                        }
                        if (og.eos() != 0)
                            eos = 1;
                    }
                }
                if (eos == 0) {
                    index = oy.buffer(4096);
                    buffer = oy.data;
                    try {
                        bytes = input.read(buffer, index, 4096);
                    }
                    catch (Exception e) {
                        System.err.println(e);
                        System.exit(1);
                    }
                    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();
View Full Code Here

  /*
   * Taken from the JOrbis Player
   */
  private void initJOrbis(){
      oy=new SyncState();
      os=new StreamState();
      og=new Page();
      op=new Packet();
   
      vi=new Info();
      vc=new Comment();
View Full Code Here

    }
  }
 
  private void init_jorbis() {
    this.oy = new SyncState();
    this.os = new StreamState();
    this.og = new Page();
    this.op = new Packet();
   
    this.vi = new Info();
    this.vc = new Comment();
View Full Code Here

TOP

Related Classes of com.jcraft.jogg.StreamState

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.