public static IByteBuffer YbrFull422ToRgb(IByteBuffer data)
        {
            byte[] oldPixels = data.Data;
            byte[] newPixels = new byte[(oldPixels.Length / 4) * 2 * 3];

            unchecked
            {
                int y1, y2, cb, cr;
                for (int n = 0, p = 0; n < oldPixels.Length;)
                {
                    y1 = oldPixels[n++];
                    y2 = oldPixels[n++];
                    cb = oldPixels[n++];
                    cr = oldPixels[n++];

                    newPixels[p++] = (byte)(y1 + 1.4020 * (cr - 128) + 0.5);
                    newPixels[p++] = (byte)(y1 - 0.3441 * (cb - 128) - 0.7141 * (cr - 128) + 0.5);
                    newPixels[p++] = (byte)(y1 + 1.7720 * (cb - 128) + 0.5);

                    newPixels[p++] = (byte)(y2 + 1.4020 * (cr - 128) + 0.5);
                    newPixels[p++] = (byte)(y2 - 0.3441 * (cb - 128) - 0.7141 * (cr - 128) + 0.5);
                    newPixels[p++] = (byte)(y2 + 1.7720 * (cb - 128) + 0.5);
                }
            }

            return new MemoryByteBuffer(newPixels);
        }

 public DuplicatedByteBuffer(IByteBuffer source)
     : base(source.MaxCapacity)
 {
     var asDuplicate = source as DuplicatedByteBuffer;
     this.buffer = asDuplicate != null ? asDuplicate.buffer : source;
     this.SetIndex(source.ReaderIndex, source.WriterIndex);
 }

        public SlicedByteBuffer(IByteBuffer buffer, int index, int length)
            : base(length)
        {
            if (index < 0 || index > buffer.Capacity - length)
            {
                throw new ArgumentOutOfRangeException("index", buffer + ".slice(" + index + ", " + length + ')');
            }

            var slicedByteBuf = buffer as SlicedByteBuffer;
            if (slicedByteBuf != null)
            {
                this.buffer = slicedByteBuf.buffer;
                this.adjustment = slicedByteBuf.adjustment + index;
            }
            else if (buffer is DuplicatedByteBuffer)
            {
                this.buffer = buffer.Unwrap();
                this.adjustment = index;
            }
            else
            {
                this.buffer = buffer;
                this.adjustment = index;
            }
            this.length = length;

            this.SetWriterIndex(length);
        }

        int IEventHandler.Peek(BufferedSocket bufferedSocket, IByteBuffer msg, ref EndPoint ep)
        {
            Contract.Requires(ep != null);
            //Contract.Requires(bufferedSocket != null);

            return default(int);
        }

 public DicomReaderEventArgs(long position, DicomTag tag, DicomVR vr, IByteBuffer data)
 {
     Position = position;
     Tag = tag;
     VR = vr;
     Data = data;
 }

        internal static void WriteStringToBuffer(IByteBuffer buffer, string input)
        {
            int typeBytes = Encoding.UTF8.GetByteCount(input);

            buffer.WriteByte(typeBytes);
            buffer.WriteBytes(Encoding.UTF8.GetBytes(input));
        }

 protected static IByteBuffer ToLeakAwareBuffer(IByteBuffer buf)
 {
     IResourceLeak leak;
     switch (ResourceLeakDetector.Level)
     {
         case ResourceLeakDetector.DetectionLevel.Simple:
             leak = AbstractByteBuffer.LeakDetector.Open(buf);
             if (leak != null)
             {
                 buf = new SimpleLeakAwareByteBuffer(buf, leak);
             }
             break;
         case ResourceLeakDetector.DetectionLevel.Advanced:
         case ResourceLeakDetector.DetectionLevel.Paranoid:
             leak = AbstractByteBuffer.LeakDetector.Open(buf);
             if (leak != null)
             {
                 buf = new AdvancedLeakAwareByteBuffer(buf, leak);
             }
             break;
         case ResourceLeakDetector.DetectionLevel.Disabled:
             break;
         default:
             throw new ArgumentOutOfRangeException();
     }
     return buf;
 }

        public static async Task ReadBytesAsync(this Stream stream, IByteBuffer buffer, int offset, int count, CancellationToken cancellationToken)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            if (offset < 0 || offset > buffer.Length)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (count < 0 || offset + count > buffer.Length)
            {
                throw new ArgumentOutOfRangeException("count");
            }

            while (count > 0)
            {
                var backingBytes = buffer.AccessBackingBytes(offset);
                var bytesToRead = Math.Min(count, backingBytes.Count);
                var bytesRead = await stream.ReadAsync(backingBytes.Array, backingBytes.Offset, bytesToRead, cancellationToken).ConfigureAwait(false);
                if (bytesRead == 0)
                {
                    throw new EndOfStreamException();
                }
                offset += bytesRead;
                count -= bytesRead;
            }
        }

 protected internal sealed override void Decode(IChannelHandlerContext context, IByteBuffer input, List<object> output)
 {
     object decode = this.Decode(context, input);
     if (decode != null)
     {
         output.Add(decode);
     }
 }

 static IByteBuffer UnwrapIfNeeded(IByteBuffer buf)
 {
     if (buf is AdvancedLeakAwareByteBuffer || buf is SimpleLeakAwareByteBuffer)
     {
         return buf.Unwrap();
     }
     return buf;
 }

        // constructors
        /// <summary>
        /// Initializes a new instance of the <see cref="LazyBsonDocument"/> class.
        /// </summary>
        /// <param name="slice">The slice.</param>
        /// <exception cref="System.ArgumentNullException">slice</exception>
        /// <exception cref="System.ArgumentException">LazyBsonDocument cannot be used with an IByteBuffer that needs disposing.</exception>
        public LazyBsonDocument(IByteBuffer slice)
        {
            if (slice == null)
            {
                throw new ArgumentNullException("slice");
            }

            _slice = slice;
        }

        // constructors
        /// <summary>
        /// Initializes a new instance of the <see cref="RawBsonArray"/> class.
        /// </summary>
        /// <param name="slice">The slice.</param>
        /// <exception cref="System.ArgumentNullException">slice</exception>
        /// <exception cref="System.ArgumentException">RawBsonArray cannot be used with an IByteBuffer that needs disposing.</exception>
        public RawBsonArray(IByteBuffer slice)
        {
            if (slice == null)
            {
                throw new ArgumentNullException("slice");
            }

            _slice = slice;
        }

 /// <summary>
 ///  Returns {@code true} if and only if the two specified buffers are
 ///  identical to each other as described in {@link ByteBuf#equals(Object)}.
 ///  This method is useful when implementing a new buffer type.
 /// </summary>
 public static bool Equals(IByteBuffer bufferA, IByteBuffer bufferB)
 {
     int aLen = bufferA.ReadableBytes;
     if (aLen != bufferB.ReadableBytes)
     {
         return false;
     }
     return Equals(bufferA, bufferA.ReaderIndex, bufferB, bufferB.ReaderIndex, aLen);
 }

 public static async Task WriteBufferAsync(this Stream stream, IByteBuffer buffer, int offset, int count, CancellationToken cancellationToken)
 {
     while (count > 0)
     {
         var backingBytes = buffer.AccessBackingBytes(offset);
         var bytesToWrite = Math.Min(count, backingBytes.Count - backingBytes.Offset);
         await stream.WriteAsync(backingBytes.Array, backingBytes.Offset, bytesToWrite, cancellationToken);
         offset += bytesToWrite;
         count -= bytesToWrite;
     }
 }

        // constructors
        /// <summary>
        /// Initializes a new instance of the <see cref="ByteBufferStream"/> class.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <param name="ownsBuffer">Whether the stream owns the buffer and should Dispose it when done.</param>
        public ByteBufferStream(IByteBuffer buffer, bool ownsBuffer = false)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }

            _buffer = buffer;
            _ownsBuffer = ownsBuffer;
            _length = buffer.Length;
        }

 public void sendBlock(IByteBuffer data, Response response)
 {
     int sendId = getNextId();
     IByteBuffer message = ByteBufferManager.Instance.GetObj();
     int pos = data.getReadPos();
     message.writeByte(data.readByte());
     message.writeInt(sendId);
     message.writeByteBuffer(data, data.available());
     data.setReadPos(pos);
     responses[sendId] = response;
     con.send(message);
 }

 public void Return(IByteBuffer byteBuffer)
 {
     if (byteBuffer is ByteBufferSlab)
     {
         _manager.Return(byteBuffer as ByteBufferSlab);
         return;
     }
     if (byteBuffer is TrackedByteBufferArray)
     {
         _allocated--;
     }
 }

 public void OnElement(IByteSource source, DicomTag tag, DicomVR vr, IByteBuffer data)
 {
     _log.Log(
         _level,
         "{marker:x8}: {padding}{tag} {vrCode} {tagDictionaryEntryName} [{size}]",
         source.Marker,
         _pad,
         tag,
         vr.Code,
         tag.DictionaryEntry.Name,
         data.Size);
 }

        public SwappedByteBuffer(IByteBuffer buf)
        {
            Contract.Requires(buf != null);

            this.buf = buf;
            if (buf.Order == ByteOrder.BigEndian)
            {
                this.Order = ByteOrder.LittleEndian;
            }
            else
            {
                this.Order = ByteOrder.BigEndian;
            }
        }

		/// <summary>
		/// Convert 24 bits pixels from planar (RRR...GGG...BBB...) to interleaved (RGB)
		/// </summary>
		/// <param name="data">Pixels data in planar format (RRR...GGG...BBB...)</param>
		/// <returns>Pixels data in interleaved format (RGB)</returns>
		public static IByteBuffer PlanarToInterleaved24(IByteBuffer data) {
			byte[] oldPixels = data.Data;
			byte[] newPixels = new byte[oldPixels.Length];
			int pixelCount = newPixels.Length / 3;

			unchecked {
				for (int n = 0; n < pixelCount; n++) {
					newPixels[(n * 3) + 0] = oldPixels[n + (pixelCount * 0)];
					newPixels[(n * 3) + 1] = oldPixels[n + (pixelCount * 1)];
					newPixels[(n * 3) + 2] = oldPixels[n + (pixelCount * 2)];
				}
			}
			
			return new MemoryByteBuffer(newPixels);
		}