override public void Run()
        {
            BufferChunk bc = new BufferChunk(new byte[5], 2, 3);

            if(bc.Index != 2)
            {
                throw new TestCaseException("unexpected index");
            }
        }

        /// <summary>
        /// Make sure the provided buffer might be a real Rtp Packet (version == 2)
        /// </summary>
        private void ValidateBuffer(BufferChunk buffer)
        {
            int version = buffer[VPXCC_INDEX] >> 6;

            if (version != Rtp.VERSION)
                throw new InvalidRtpPacketException(string.Format("Invalid version: {0}, current: {1}", 
                    version, Rtp.VERSION));
        }

 internal void AppendPayload(BufferChunk data)
 {
     buffer += data;
 }

        /// <summary>
        /// Broadcasts a single chunk and stores it in the frame buffer.
        /// </summary>
        /// <param name="chunk">The chunk to send</param>
        private void RtpSend(Chunk chunk, MessagePriority priority)
        {
            using(Synchronizer.Lock(this)) {
                using(MemoryStream stream = new MemoryStream((int) (this.m_Encoder.MaximumChunkSize * 2))) {
                    // Store the sequence number of non-real-time chunks so they can be NACKed.
                    // Use "++this.m_FrameSequence" so that non-real-time chunks always have a
                    // FrameSequence that is greater than 0.
                    if (priority != MessagePriority.RealTime)
                        chunk.FrameSequence = ++this.m_FrameSequence;

                    // If the chunk is not real time (or it is being resent a second time),
                    // store the chunk in the buffer so a NACK request can resend it.
                    if (chunk.FrameSequence > ulong.MinValue)
                        this.m_FrameBuffer.Insert(chunk);

                    // Buffering the chunk probably evicted other chunks from the buffer,
                    // so get the oldest frame in the buffer so receivers don't waste time
                    // sending NACKs for chunks that are no longer available.
                    chunk.OldestRecoverableFrame = this.m_FrameBuffer.OldestRecoverableFrame;
                    chunk.OldestRecoverableMessage = this.m_FrameBuffer.OldestRecoverableMessage;

                    // Serialize the chunk (which itself contains a serialized message).
                    // TODO: see whether the wire protocol can be made more efficient.
                    stream.Position = 0;
                    this.m_Encoder.EncodeChunk(stream, chunk);

                    // Prepare the frame to be sent over RTP.
                    BufferChunk buffer = new BufferChunk(stream.GetBuffer(), 0, (int) stream.Length);

                    // Send it (or drop some percentage of packets if the debug option is enabled).
                    if(DEBUG_DROP_RANDOM_FRAMES <= 0 || new Random().Next(100) >= DEBUG_DROP_RANDOM_FRAMES) {

                        Debug.WriteLine(string.Format("Sending frame #{0} ({1} bytes, message #{2}, chunk #{3} of {4}, depending on #{5}, priority {6})",
                            chunk.FrameSequence,
                            chunk.Data.Length,
                            chunk.MessageSequence,
                            chunk.ChunkSequenceInMessage + 1,
                            chunk.NumberOfChunksInMessage,
                            chunk.MessageDependency,
                            priority),
                            this.GetType().ToString());

                        try {
                            this.m_RtpSender.Send( buffer );
                        } catch( Exception ) {
                            this.Reset();
                        }
                    }

                    else {
                        Debug.WriteLine(string.Format("DEBUG: Dropping frame #{0} ({1} bytes, message #{2}, chunk #{3} of {4}, depending on #{5}, priority {6})",
                            chunk.FrameSequence,
                            chunk.Data.Length,
                            chunk.MessageSequence,
                            chunk.ChunkSequenceInMessage + 1,
                            chunk.NumberOfChunksInMessage,
                            chunk.MessageDependency,
                            priority),
                            this.GetType().ToString());
                    }
                }
            }
        }

        /// <summary>
        /// Release the BufferChunk held by this packet so it can be reused outside the scope of this packet.
        /// </summary>
        /// <returns></returns>
        internal BufferChunk ReleaseBuffer()
        {
            BufferChunk ret = buffer;
            buffer = null;

            return ret;
        }

 internal RtpPacket(BufferChunk buffer) : base(buffer){}

 /// <summary>
 /// Create a packet from an existing packet
 /// </summary>
 /// <param name="packet"></param>
 internal RtpPacketBase(RtpPacketBase packet)
 {
     buffer = packet.buffer;
 }