public SendFileOperation(string filename, WriteCallback callback)
        {
            this.filename = filename;
            this.callback = callback;

            Length = -1;
        }

        public SendFileOperation(string filename, WriteCallback callback)
        {
            this.file = new FileStream (file_name, FileMode.Open, FileAccess.Read)
            this.callback = callback;

            file_length = (int) file.Length;
            ReadFile ();
        }

        public SendFileOperation(string filename, long size, WriteCallback callback)
        {
            this.filename = filename;
            this.callback = callback;

            // TODO: async.  Don't think there is a good reason to do any locking here.
            file_length = file.Length;
        }

        public WriteFileOperation(FileStream file, WriteCallback callback)
        {
            this.file = file;
            this.callback = callback;

            file_length = (int) file.Length;
            ReadFile ();
        }

        public SendFileOperation(FileStream file, WriteCallback callback)
        {
            this.file = file;
            this.callback = callback;

            // TODO: async.  Don't think there is a good reason to do any locking here.
            file_length = file.Length;
        }

        /// <summary>Initializes a new instance of the <see cref="WriteBuffer"/> class.</summary>
        /// <param name="write">The method that is called when the buffer needs to be emptied.</param>
        /// <param name="bufferSize">The size of the buffer in bytes.</param>
        /// <exception cref="ArgumentNullException"><paramref name="write"/> equals <c>null</c>.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="bufferSize"/> is 0 or negative.</exception>
        public WriteBuffer(WriteCallback write, int bufferSize)
            : base(bufferSize)
        {
            if (write == null)
            {
                throw new ArgumentNullException(nameof(write));
            }

            this.write = write;
            this.writeAsync = (b, o, c, t) => ThrowInvalidAsyncOperationException();
        }

 internal WriteLineHelper(bool lineWrap, WriteCallback wlc, WriteCallback wc, DisplayCells displayCells)
 {
     if (wlc == null)
     {
         throw PSTraceSource.NewArgumentNullException("wlc");
     }
     if (displayCells == null)
     {
         throw PSTraceSource.NewArgumentNullException("displayCells");
     }
     this._displayCells = displayCells;
     this.writeLineCall = wlc;
     this.writeCall = (wc != null) ? wc : wlc;
     this.lineWrap = lineWrap;
 }

        public FlacWriter(Stream output, int bitDepth, int channels, int sampleRate)
        {
            stream = output;
            writer = new BinaryWriter(stream);

            inputBitDepth = bitDepth;
            inputChannels = channels;
            inputSampleRate = sampleRate;

            context = FLAC__stream_encoder_new();

            if (context == IntPtr.Zero)
                throw new ApplicationException("FLAC: Could not initialize stream encoder!");

            Check(
                FLAC__stream_encoder_set_channels(context, channels),
                "set channels");

            Check(
                FLAC__stream_encoder_set_bits_per_sample(context, bitDepth),
                "set bits per sample");

            Check(
                FLAC__stream_encoder_set_sample_rate(context, sampleRate),
                "set sample rate");

            Check(
                FLAC__stream_encoder_set_compression_level(context, 5),
                "set compression level");

            //Check(
            //    FLAC__stream_encoder_set_blocksize(context, 8192),
            //    "set block size");

            write = new WriteCallback(Write);
            seek = new SeekCallback(Seek);
            tell = new TellCallback(Tell);

            if (FLAC__stream_encoder_init_stream(context,
                                                 write, seek, tell,
                                                 null, IntPtr.Zero) != 0)
                throw new ApplicationException("FLAC: Could not open stream for writing!");
        }

        public FlacReader(string input, WavWriter output)
        {
            if (output == null)
                throw new ArgumentNullException("WavWriter");

            stream = File.OpenRead(input);
            reader = new BinaryReader(stream);
            writer = output;

            context = FLAC__stream_decoder_new();

            if (context == IntPtr.Zero)
                throw new ApplicationException("FLAC: Could not initialize stream decoder!");

            write = new WriteCallback(Write);
            metadata = new MetadataCallback(Metadata);
            error = new ErrorCallback(Error);

            if (FLAC__stream_decoder_init_file(context,
                                               input, write, metadata, error,
                                               IntPtr.Zero) != 0)
                throw new ApplicationException("FLAC: Could not open stream for reading!");
        }

        public void SendFinalChunk(WriteCallback callback)
        {
            EnsureMetadata ();

            if (!chunk_encode || final_chunk_sent)
                return;

            final_chunk_sent = true;

            var bytes = new List<ByteBuffer> ();

            WriteChunk (bytes, 0, true);

            var write_bytes = new SendBytesOperation (bytes, callback);
            QueueWriteOperation (write_bytes);
        }

 static extern int FLAC__stream_encoder_init_stream(IntPtr context, WriteCallback write, SeekCallback seek, TellCallback tell, MetadataCallback metadata, IntPtr userData);

 public WriteOperation(int index, WriteCallback callback)
 {
     this.index = index;
     this.callback = callback;
 }

        private void FinishWrite()
        {
            WriteCallback callback = write_callback;

            write_data = null;
            write_callback = null;

            callback ();
        }

        private void FinishSendFile()
        {
            WriteCallback callback = write_callback;
            write_callback = null;

            send_file.Close ();
            send_file = null;

            send_file_count = 0;
            send_file_offset = 0;

            callback ();
        }

        public void Write(IList<ArraySegment<byte>> data, WriteCallback callback)
        {
            CheckCanWrite ();

            write_data = data;
            write_callback = callback;

            EnableWriting ();
        }

        public void SendFile(string file, WriteCallback callback)
        {
            CheckCanRead ();

            write_callback = callback;

            send_file = new FileStream (file, FileMode.Open, FileAccess.Read);
            send_file_offset = 0;
            send_file_count = send_file.Length;

            EnableWriting ();
        }

 public void Write(byte[] data, WriteCallback callback)
 {
     var writeDelegate = new WriteDelegate(Write);
     var asyncState = new HidAsyncState(writeDelegate, callback);
     writeDelegate.BeginInvoke(data, EndWrite, asyncState);
 }

        /// <summary>
        /// Starts writing specified data to source stream.
        /// </summary>
        /// <param name="data">Data what to write to source stream.</param>
        /// <param name="callback">Callback to be callled if write completes.</param>
        /// <exception cref="ArgumentNullException">Raised when <b>data</b> is null.</exception>
        /// <exception cref="InvalidOperationException">Raised when there already is pending write operation.</exception>
        public void BeginWrite(byte[] data,WriteCallback callback)
        {
            if(data == null){
                throw new ArgumentNullException("data");
            }

            BeginWrite(data,0,data.Length,callback);
        }

        private void SetupIOEntry(ushort port, ReadCallback read, WriteCallback write)
        {
            var entry = new IOEntry {Read = read, Write = write};

            ioPorts.Add(port, entry);
        }

        public void SendBufferedOps(WriteCallback callback)
        {
            if (write_ops != null) {
                IWriteOperation [] ops = write_ops.ToArray ();

                for (int i = 0; i < ops.Length; i++) {
                    SocketStream.QueueWriteOperation (ops [i]);
                }
                write_ops.Clear ();
            }

            SocketStream.QueueWriteOperation (new NopWriteOperation (callback));
        }