public int header_out(Packet op) { csBuffer opb=new csBuffer(); opb.writeinit(); if(pack(opb)!=0) return OV_EIMPL; op.packet_base = new byte[opb.bytes()]; op.packet=0; op.bytes=opb.bytes(); Array.Copy(opb.buf(), 0, op.packet_base, 0, op.bytes); op.b_o_s=0; op.e_o_s=0; op.granulepos=0; return 0; }
public int packetout(Packet op) { /* The last part of decode. We have the stream broken into packet segments. Now we need to group them into packets (or return the out of sync markers) */ int ptr=lacing_returned; if(lacing_packet<=ptr) { return(0); } if((lacing_vals[ptr]&0x400)!=0) { /* We lost sync here; let the app know */ lacing_returned++; /* we need to tell the codec there's a gap; it might need to handle previous packet dependencies. */ packetno++; return(-1); } /* Gather the whole packet. We'll have no holes or a partial packet */ { int size=lacing_vals[ptr]&0xff; int bytes=0; op.packet_base=body_data; op.packet=body_returned; op.e_o_s=lacing_vals[ptr]&0x200; /* last packet of the stream? */ op.b_o_s=lacing_vals[ptr]&0x100; /* first packet of the stream? */ bytes+=size; while(size==255) { int val=lacing_vals[++ptr]; size=val&0xff; if((val&0x200)!=0)op.e_o_s=0x200; bytes+=size; } op.packetno=packetno; op.granulepos=granule_vals[ptr]; op.bytes=bytes; //System.out.println(this+" # body_returned="+body_returned); body_returned+=bytes; //System.out.println(this+"## body_returned="+body_returned); lacing_returned=ptr+1; } packetno++; return(1); }
// uses the local ogg_stream storage in vf; this is important for // non-streaming input sources public int fetch_headers(Info vi, Comment vc, int[] serialno, Page og_ptr, VorbisFileInstance instance) { //System.err.println("fetch_headers"); Page og=new Page(); Packet op=new Packet(); int ret; if(og_ptr==null) { ret = get_next_page(og, CHUNKSIZE, instance); if(ret==OV_EREAD)return OV_EREAD; if(ret<0) return OV_ENOTVORBIS; og_ptr=og; } if(serialno!=null)serialno[0]=og_ptr.serialno(); instance.os.init(og_ptr.serialno()); // extract the initial header from the first page and verify that the // Ogg bitstream is in fact Vorbis data vi.init(); vc.init(); int i=0; while(i<3) { instance.os.pagein(og_ptr); while(i<3) { int result = instance.os.packetout(op); if(result==0)break; if(result==-1) { Console.Error.WriteLine("Corrupt header in logical bitstream."); //goto bail_header; vi.clear(); vc.clear(); instance.os.clear(); return -1; } if(vi.synthesis_headerin(vc, op)!=0) { Console.Error.WriteLine("Illegal header in logical bitstream."); //goto bail_header; vi.clear(); vc.clear(); instance.os.clear(); return -1; } i++; } if(i<3) if(get_next_page(og_ptr, 1, instance)<0) { Console.Error.WriteLine("Missing header in logical bitstream."); //goto bail_header; vi.clear(); vc.clear(); instance.os.clear(); return -1; } } return 0; }
/* submit data to the internal buffer of the framing engine */ public int packetin(Packet op) { int lacing_val=op.bytes/255+1; if(body_returned!=0) { /* advance packet data according to the body_returned pointer. We had to keep it around to return a pointer into the buffer last call */ body_fill-=body_returned; if(body_fill!=0) { Array.Copy(body_data, body_returned, body_data, 0, body_fill); } body_returned=0; } /* make sure we have the buffer storage */ body_expand(op.bytes); lacing_expand(lacing_val); /* Copy in the submitted packet. Yes, the copy is a waste; this is the liability of overly clean abstraction for the time being. It will actually be fairly easy to eliminate the extra copy in the future */ Array.Copy(op.packet_base, op.packet, body_data, body_fill, op.bytes); body_fill+=op.bytes; //System.out.println("add: "+body_fill); /* Store lacing vals for this packet */ int j; for(j=0;j<lacing_val-1;j++) { lacing_vals[lacing_fill+j]=255; granule_vals[lacing_fill+j]=granulepos; } lacing_vals[lacing_fill+j]=(op.bytes)%255; granulepos=granule_vals[lacing_fill+j]=op.granulepos; /* flag the first segment as the beginning of the packet */ lacing_vals[lacing_fill]|= 0x100; lacing_fill+=lacing_val; /* for the sake of completeness */ packetno++; if(op.e_o_s!=0)e_o_s=1; return(0); }
public int PacketIn(csogg.Packet p) { throw new NotImplementedException(); }
public int PacketIn(csogg.Packet pp) { Theora.ogg_packet op = new Theora.ogg_packet(); op.bytes = new IntPtr(pp.bytes); op.b_o_s = new IntPtr(pp.b_o_s); op.e_o_s = new IntPtr(pp.e_o_s); op.granulepos = pp.granulepos; op.packet = Marshal.UnsafeAddrOfPinnedArrayElement(pp.packet_base, pp.packet); op.packetno = pp.packetno; if (!HeadersRead) { int r = Theora.th_decode_headerin(ref info, ref comment, ref setup, ref op); if (r == 0) { Console.WriteLine("header complete"); width = (int)info.frame_width; height = (int)info.frame_height; Data = new byte[width * height * 3]; Console.WriteLine(width.ToString() + "x" + height.ToString()); HeadersRead = true; decode = Theora.th_decode_alloc(ref info, setup); if (decode == IntPtr.Zero) { throw new Exception("decode"); } } else { return(0); } } ogg_int64_t granpos = 0; int i; if (Theora.th_decode_packetin(decode, ref op, ref granpos) == 0) { //Console.WriteLine("frame complete"+granpos.ToString()); Theora.th_ycbcr_buffer picture = new Theora.th_ycbcr_buffer(); i = Theora.th_decode_ycbcr_out(decode, ref picture); if (i != 0) { throw new Exception("picture"); } float xfactor1 = (float)picture.plane1.width / (float)picture.plane0.width; float yfactor1 = (float)picture.plane1.height / (float)picture.plane0.height; float xfactor2 = (float)picture.plane2.width / (float)picture.plane0.width; float yfactor2 = (float)picture.plane2.height / (float)picture.plane0.height; if (ConvertToRGB) { for (int y = 0; y < picture.plane0.height; ++y) { for (int x = 0; x < picture.plane0.width; ++x) { float Y = Marshal.ReadByte(picture.plane0.data, y * picture.plane0.stride + x); float Cb = Marshal.ReadByte(picture.plane1.data, (int)((float)y * yfactor1 * (float)picture.plane1.stride + (float)x * xfactor1)); float Cr = Marshal.ReadByte(picture.plane2.data, (int)((float)y * yfactor2 * (float)picture.plane2.stride + (float)x * xfactor2)); int R = (int)(Y + 1.402f * (Cr - 128.0f)); int G = (int)(Y - 0.34414f * (Cb - 128.0f) - 0.71414f * (Cr - 128.0f)); int B = (int)(Y + 1.772f * (Cb - 128.0f)); R = Clamp(R, 255, 0); G = Clamp(G, 255, 0); B = Clamp(B, 255, 0); Data[y * width * 3 + x * 3] = (byte)B; Data[y * width * 3 + x * 3 + 1] = (byte)G; Data[y * width * 3 + x * 3 + 2] = (byte)R; //w.WriteLine(R.ToString()+" "+G.ToString()+" "+B.ToString()); } } } else { for (int y = 0; y < picture.plane0.height; ++y) { for (int x = 0; x < picture.plane0.width; ++x) { byte Y = Marshal.ReadByte(picture.plane0.data, y * picture.plane0.stride + x); byte Cb = Marshal.ReadByte(picture.plane1.data, (int)((float)y * yfactor1 * (float)picture.plane1.stride + (float)x * xfactor1)); byte Cr = Marshal.ReadByte(picture.plane2.data, (int)((float)y * yfactor2 * (float)picture.plane2.stride + (float)x * xfactor2)); Data[y * width * 3 + x * 3] = (byte)Y; Data[y * width * 3 + x * 3 + 1] = (byte)Cb; Data[y * width * 3 + x * 3 + 2] = (byte)Cr; //w.WriteLine(R.ToString()+" "+G.ToString()+" "+B.ToString()); } } } //w.Close(); //f.Close(); frame++; return(1); } return(0); }
public int synthesis(Packet op) { Info vi=vd.vi; // first things first. Make sure decode is ready // ripcord(); opb.readinit(op.packet_base, op.packet, op.bytes); // Check the packet type if(opb.read(1)!=0) { // Oops. This is not an audio data packet return(-1); } // read our mode and pre/post windowsize int _mode=opb.read(vd.modebits); if(_mode==-1)return(-1); mode=_mode; W=vi.mode_param[mode].blockflag; if(W!=0) { lW=opb.read(1); nW=opb.read(1); if(nW==-1) return(-1); } else { lW=0; nW=0; } // more setup granulepos=op.granulepos; sequence=op.packetno-3; // first block is third packet eofflag=op.e_o_s; // alloc pcm passback storage pcmend=vi.blocksizes[W]; //pcm=alloc(vi.channels); if(pcm.Length<vi.channels) { pcm=new float[vi.channels][]; } for(int i=0;i<vi.channels;i++) { if(pcm[i]==null || pcm[i].Length<pcmend) { pcm[i]=new float[pcmend]; //pcm[i]=alloc(pcmend); } else { for(int j=0;j<pcmend;j++){ pcm[i][j]=0; } } } // unpack_header enforces range checking int type=vi.map_type[vi.mode_param[mode].mapping]; return(FuncMapping.mapping_P[type].inverse(this, vd.mode[mode])); }
// fetch and process a packet. Handles the case where we're at a // bitstream boundary and dumps the decoding machine. If the decoding // machine is unloaded, it loads it. It also keeps pcm_offset up to // date (seek and read both use this. seek uses a special hack with // readp). // // return: -1) hole in the data (lost packet) // 0) need more date (only if readp==0)/eof // 1) got a packet int process_packet(int readp) { Page og=new Page(); // handle one packet. Try to fetch it from current stream state // extract packets from page while(true) { // process a packet if we can. If the machine isn't loaded, // neither is a page if(decode_ready) { Packet op=new Packet(); int result=os.packetout(op); long granulepos; // if(result==-1)return(-1); // hole in the data. For now, swallow // and go. We'll need to add a real // error code in a bit. if(result>0) { // got a packet. process it granulepos=op.granulepos; if(vb.synthesis(op)==0) { // lazy check for lazy // header handling. The // header packets aren't // audio, so if/when we // submit them, // vorbis_synthesis will // reject them // suck in the synthesis data and track bitrate { int oldsamples=vd.synthesis_pcmout(null, null); vd.synthesis_blockin(vb); samptrack+=vd.synthesis_pcmout(null, null)-oldsamples; bittrack+=op.bytes*8; } // update the pcm offset. if(granulepos!=-1 && op.e_o_s==0) { int link=(skable?current_link:0); int samples; // this packet has a pcm_offset on it (the last packet // completed on a page carries the offset) After processing // (above), we know the pcm position of the *last* sample // ready to be returned. Find the offset of the *first* // // As an aside, this trick is inaccurate if we begin // reading anew right at the last page; the end-of-stream // granulepos declares the last frame in the stream, and the // last packet of the last page may be a partial frame. // So, we need a previous granulepos from an in-sequence page // to have a reference point. Thus the !op.e_o_s clause above samples=vd.synthesis_pcmout(null, null); granulepos-=samples; for(int i=0;i<link;i++) { granulepos+=pcmlengths[i]; } pcm_offset=granulepos; } return(1); } } } if(readp==0)return(0); if(get_next_page(og,-1)<0)return(0); // eof. leave unitialized // bitrate tracking; add the header's bytes here, the body bytes // are done by packet above bittrack+=og.header_len*8; // has our decoding just traversed a bitstream boundary? if(decode_ready) { if(current_serialno!=og.serialno()) { decode_clear(); } } // Do we need to load a new machine before submitting the page? // This is different in the seekable and non-seekable cases. // // In the seekable case, we already have all the header // information loaded and cached; we just initialize the machine // with it and continue on our merry way. // // In the non-seekable (streaming) case, we'll only be at a // boundary if we just left the previous logical bitstream and // we're now nominally at the header of the next bitstream if(!decode_ready) { int i; if(skable) { current_serialno=og.serialno(); // match the serialno to bitstream section. We use this rather than // offset positions to avoid problems near logical bitstream // boundaries for(i=0;i<links;i++) { if(serialnos[i]==current_serialno)break; } if(i==links)return(-1); // sign of a bogus stream. error out, // leave machine uninitialized current_link=i; os.init(current_serialno); os.reset(); } else { // we're streaming // fetch the three header packets, build the info struct int[] foo = new int[1]; int ret=fetch_headers(vi[0], vc[0], foo, og); current_serialno=foo[0]; if(ret!=0)return ret; current_link++; i=0; } make_decode_ready(); } os.pagein(og); } }
// static void v_writestring(csBuffer o, byte[] s){ // int i=0; // while(s[i]!=0){ // o.write(s[i++],8); // } // } // static void v_readstring(csBuffer o, byte[] buf, int bytes){ // int i=0 // while(bytes--!=0){ // buf[i++]=o.read(8); // } // } // private csBuffer opb_blocksize=new csBuffer(); public int blocksize(Packet op) { //codec_setup_info *ci=vi->codec_setup; csBuffer opb=new csBuffer(); // synchronized(opb_blocksize){ int mode; opb.readinit(op.packet_base, op.packet, op.bytes); /* Check the packet type */ if(opb.read(1)!=0) { /* Oops. This is not an audio data packet */ return(OV_ENOTAUDIO); } { int modebits=0; int v=modes; while(v>1) { modebits++; v = (int)((uint)v >> 1); } /* read our mode and pre/post windowsize */ mode=opb.read(modebits); } if(mode==-1)return(OV_EBADPACKET); return(blocksizes[mode_param[mode].blockflag]); // } }
// The Vorbis header is in three packets; the initial small packet in // the first page that identifies basic parameters, a second packet // with bitstream comments and a third packet that holds the // codebook. public int synthesis_headerin(Comment vc, Packet op) { csBuffer opb=new csBuffer(); if(op!=null) { opb.readinit(op.packet_base, op.packet, op.bytes); // Which of the three types of header is this? // Also verify header-ness, vorbis { byte[] buffer=new byte[6]; int packtype=opb.read(8); //memset(buffer,0,6); opb.read(buffer,6); if(buffer[0]!='v' || buffer[1]!='o' || buffer[2]!='r' || buffer[3]!='b' || buffer[4]!='i' || buffer[5]!='s') { // not a vorbis header return(-1); } switch(packtype) { case 0x01: // least significant *bit* is read first if(op.b_o_s==0) { // Not the initial packet return(-1); } if(rate!=0) { // previously initialized info header return(-1); } return(unpack_info(opb)); case 0x03: // least significant *bit* is read first if(rate==0) { // um... we didn't get the initial header return(-1); } return(vc.unpack(opb)); case 0x05: // least significant *bit* is read first if(rate==0 || vc.vendor==null) { // um... we didn;t get the initial header or comments yet return(-1); } return(unpack_books(opb)); default: // Not a valid vorbis header type //return(-1); break; } } } return(-1); }
/// <summary> /// Decodes a stream of Ogg Vorbis data into wav file format. /// </summary> /// <returns> /// A MemoryStream with the entire decoded stream. /// </returns> /// <param name='input'> /// Ogg Vorbis data to be decoded /// </param> /// <param name='output'> /// <para>Stream to write wav data.</para> /// <para>If writeWavHeader is true then this stream must be seekable.</para> /// </param> /// <param name='writeWavHeader'> /// Write wav header in the beginning of the returned stream. /// </param> public static void DecodeStream(Stream input, Stream output, bool writeWavHeader) { int convsize = 4096 * 2; byte[] convbuffer = new byte[convsize]; // take 8k out of the data segment, not the stack long start = output.Position; DebugWriter s_err = new DebugWriter(); if (writeWavHeader && !output.CanSeek) throw new ArgumentException("To write wav header, the output stream must be seekable.", "output"); if (writeWavHeader) output.Seek(HEADER_SIZE, SeekOrigin.Current); // reserve place for WAV header 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 int bytes = 0; // Decode setup oy.init(); // Now we can read pages // we repeat if the bitstream is chained while (true) { 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); bytes = input.Read(oy.data, index, 4096); 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 s_err.WriteLine("Input does not appear to be an Ogg bitstream."); } // 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 s_err.WriteLine("Error reading first page of Ogg bitstream data."); } if (os.packetout(op) != 1) { // no page? must not be vorbis s_err.WriteLine("Error reading initial header packet."); } if (vi.synthesis_headerin(vc, op) < 0) { // error case; not a vorbis header s_err.WriteLine("This Ogg bitstream does not contain Vorbis audio data."); } // 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. s_err.WriteLine("Corrupt secondary header. Exiting."); } vi.synthesis_headerin(vc, op); i++; } } } // no harm in not checking before adding more index = oy.buffer(4096); bytes = input.Read(oy.data, index, 4096); if (bytes == 0 && i < 2) { s_err.WriteLine("End of file before finding all Vorbis headers!"); } 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 < vc.user_comments.Length; j++) { if (ptr [j] == null) break; s_err.WriteLine(vc.getComment(j)); } s_err.WriteLine("\nBitstream is " + vi.channels + " channel, " + vi.rate + "Hz"); s_err.WriteLine("Encoded by: " + vc.getVendor() + "\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 s_err.WriteLine("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]; bool 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.0); // 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; convbuffer [ptr] = (byte)(val); convbuffer [ptr + 1] = (byte)((uint)val >> 8); ptr += 2 * (vi.channels); } } if (clipflag) { //s_err.WriteLine("Clipping in frame "+vd.sequence); } output.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); bytes = input.Read(oy.data, index, 4096); 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(); s_err.WriteLine("Done."); if (writeWavHeader) { long end = output.Position; int length = (int)(end - (start + HEADER_SIZE)); output.Seek(start, SeekOrigin.Begin); WriteHeader(output, length, vi.rate, (ushort)16, (ushort)vi.channels); output.Seek(end, SeekOrigin.Begin); } }
public AudioSample OggToWav(Stream ogg, float volume, float pitch) { AudioSample sample = new AudioSample(); TextWriter s_err = new StringWriter(); Stream input = null; MemoryStream output = null; input = ogg; output = new MemoryStream(); SyncState oy = new SyncState(); StreamState os = new StreamState(); Page og = new Page(); Packet op = new Packet(); Info vi = new Info(); Comment vc = new Comment(); DspState vd = new DspState(); Block vb = new Block(vd); byte[] buffer; int bytes = 0; oy.init(); while (true) { int eos = 0; int index = oy.buffer(4096); buffer = oy.data; try { bytes = input.Read(buffer, index, 4096); } catch (Exception e) { s_err.WriteLine(e); } oy.wrote(bytes); if (oy.pageout(og) != 1) { if (bytes < 4096) break; s_err.WriteLine("Input does not appear to be an Ogg bitstream."); } os.init(og.serialno()); vi.init(); vc.init(); if (os.pagein(og) < 0) { s_err.WriteLine("Error reading first page of Ogg bitstream data."); } if (os.packetout(op) != 1) { s_err.WriteLine("Error reading initial header packet."); } if (vi.synthesis_headerin(vc, op) < 0) { s_err.WriteLine("This Ogg bitstream does not contain Vorbis audio data."); } int i = 0; while (i < 2) { while (i < 2) { int result = oy.pageout(og); if (result == 0) break; if (result == 1) { os.pagein(og); while (i < 2) { result = os.packetout(op); if (result == 0) break; vi.synthesis_headerin(vc, op); i++; } } } index = oy.buffer(4096); buffer = oy.data; try { bytes = input.Read(buffer, index, 4096); } catch (Exception e) { s_err.WriteLine(e); } oy.wrote(bytes); } sample.Channels = vi.channels; sample.Rate = (int)((float)vi.rate * pitch); convsize = 4096 / vi.channels; vd.synthesis_init(vi); vb.init(vd); float[][][] _pcm = new float[1][][]; int[] _index = new int[vi.channels]; while (eos == 0) { while (eos == 0) { int result = oy.pageout(og); if (result == 0) break; if (result != -1) { os.pagein(og); while (true) { result = os.packetout(op); if (result == 0) break; if (result != -1) { int samples; if (vb.synthesis(op) == 0) { vd.synthesis_blockin(vb); } while ((samples = vd.synthesis_pcmout(_pcm, _index)) > 0) { float[][] pcm = _pcm[0]; int bout = (samples < convsize ? samples : convsize); for (i = 0; i < vi.channels; i++) { int ptr = i * 2; int mono = _index[i]; for (int j = 0; j < bout; j++) { int val = (int)(pcm[i][mono + j] * 32767.0); if (val > 32767) { val = 32767; } if (val < -32768) { val = -32768; } val = (int)((float)val * volume); if (val < 0) val = val | 0x8000; convbuffer[ptr] = (byte)(val); convbuffer[ptr + 1] = (byte)((uint)val >> 8); ptr += 2 * (vi.channels); } } output.Write(convbuffer, 0, 2 * vi.channels * bout); 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) { s_err.WriteLine(e); } oy.wrote(bytes); if (bytes == 0) eos = 1; } } os.clear(); vb.clear(); vd.clear(); vi.clear(); break; } oy.clear(); input.Close(); sample.Pcm = output.ToArray(); return sample; }
Stream DecodeStream( Stream input, bool skipWavHeader ) { int convsize = 4096 * 2; byte [] convbuffer = new byte [ convsize ]; Stream output = new MemoryStream (); if ( !skipWavHeader ) output.Seek ( HEADER_SIZE, SeekOrigin.Begin ); SyncState oy = new SyncState (); StreamState os = new StreamState (); Page og = new Page (); Packet op = new Packet (); Info vi = new Info (); Comment vc = new Comment (); DspState vd = new DspState (); Block vb = new Block ( vd ); byte [] buffer; int bytes = 0; oy.init (); while ( true ) { int eos = 0; int index = oy.buffer ( 4096 ); buffer = oy.data; bytes = input.Read ( buffer, index, 4096 ); oy.wrote ( bytes ); if ( oy.pageout ( og ) != 1 ) { if ( bytes < 4096 ) break; throw new Exception ( "Input does not appear to be an Ogg bitstream." ); } os.init ( og.serialno () ); vi.init (); vc.init (); if ( os.pagein ( og ) < 0 ) { throw new Exception ( "Error reading first page of Ogg bitstream data." ); } if ( os.packetout ( op ) != 1 ) { throw new Exception ( "Error reading initial header packet." ); } if ( vi.synthesis_headerin ( vc, op ) < 0 ) { throw new Exception ( "This Ogg bitstream does not contain Vorbis audio data." ); } int i = 0; while ( i < 2 ) { while ( i < 2 ) { int result = oy.pageout ( og ); if ( result == 0 ) break; if ( result == 1 ) { os.pagein ( og ); while ( i < 2 ) { result = os.packetout ( op ); if ( result == 0 ) break; if ( result == -1 ) { throw new Exception ( "Corrupt secondary header. Exiting." ); } vi.synthesis_headerin ( vc, op ); i++; } } } index = oy.buffer ( 4096 ); buffer = oy.data; bytes = input.Read ( buffer, index, 4096 ); if ( bytes == 0 && i < 2 ) { throw new Exception ( "End of file before finding all Vorbis headers!" ); } oy.wrote ( bytes ); } { byte [] [] ptr = vc.user_comments; for ( int j = 0; j < vc.user_comments.Length; j++ ) { if ( ptr [ j ] == null ) break; } } convsize = 4096 / vi.channels; vd.synthesis_init ( vi ); vb.init ( vd ); float [] [] [] _pcm = new float [ 1 ] [][]; int [] _index = new int [ vi.channels ]; while ( eos == 0 ) { while ( eos == 0 ) { int result = oy.pageout ( og ); if ( result == 0 ) break; if ( result == -1 ) throw new Exception ( "Corrupt or missing data in bitstream; continuing..." ); else { os.pagein ( og ); while ( true ) { result = os.packetout ( op ); if ( result == 0 ) break; if ( result == -1 ) { } else { int samples; if ( vb.synthesis ( op ) == 0 ) { vd.synthesis_blockin ( vb ); } while ( ( samples = vd.synthesis_pcmout ( _pcm, _index ) ) > 0 ) { float [] [] pcm = _pcm [ 0 ]; bool clipflag = false; int bout = ( samples < convsize ? samples : convsize ); for ( i = 0; i < vi.channels; i++ ) { int ptr = i * 2; int mono = _index [ i ]; for ( int j = 0; j < bout; j++ ) { int val = ( int ) ( pcm [ i ] [ mono + j ] * 32767.0 ); if ( val > 32767 ) { val = 32767; clipflag = true; } if ( val < -32768 ) { val = -32768; clipflag = true; } if ( val < 0 ) val = val | 0x8000; convbuffer [ ptr ] = ( byte ) ( val ); convbuffer [ ptr + 1 ] = ( byte ) ( ( uint ) val >> 8 ); ptr += 2 * ( vi.channels ); } } if ( clipflag ) { } output.Write ( convbuffer, 0, 2 * vi.channels * bout ); vd.synthesis_read ( bout ); } } } if ( og.eos () != 0 ) eos = 1; } } if ( eos == 0 ) { index = oy.buffer ( 4096 ); buffer = oy.data; bytes = input.Read ( buffer, index, 4096 ); oy.wrote ( bytes ); if ( bytes == 0 ) eos = 1; } } os.clear (); vb.clear (); vd.clear (); vi.clear (); } oy.clear (); output.Seek ( 0, SeekOrigin.Begin ); if ( !skipWavHeader ) { WriteHeader ( output, ( int ) ( output.Length - HEADER_SIZE ), vi.rate, ( ushort ) 16, ( ushort ) vi.channels ); output.Seek ( 0, SeekOrigin.Begin ); } return output; }