internal DcmPresContext(byte pcid, DicomUID abstractSyntax, DicomTransferSyntax transferSyntax, DcmPresContextResult result) {
			_pcid = pcid;
			_result = result;
			_abstract = abstractSyntax;
			_transfers = new List<DicomTransferSyntax>();
			_transfers.Add(transferSyntax);
		}

		internal override uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options) {
			uint length = 4 + 4;
			length += Dataset.CalculateWriteLength(syntax, options & ~DicomWriteOptions.CalculateGroupLengths);
			if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequenceItem))
				length += 4 + 4; // Sequence Item Delimitation Item
			return length;
		}

 public DcmDataset(long streamPosition, uint lengthInStream, DicomTransferSyntax transferSyntax)
 {
     _streamPosition = streamPosition;
     _streamLength = lengthInStream;
     _transferSyntax = transferSyntax;
     _items = new SortedList<DicomTag, DcmItem>(new DicomTagComparer());
 }

		public static bool HasCodec(DicomTransferSyntax ts) {
			if (ts == DicomTransferSyntax.ImplicitVRLittleEndian ||
				ts == DicomTransferSyntax.ExplicitVRLittleEndian ||
				ts == DicomTransferSyntax.ExplicitVRBigEndian)
				return true;
			if (_codecs == null)
				return false;
			return _codecs.ContainsKey(ts);
		}

		public static IDcmCodec GetCodec(DicomTransferSyntax ts) {
			if (_codecs == null)
				RegisterCodecs();
			Type cType;
			if (_codecs.TryGetValue(ts, out cType)) {
				return (IDcmCodec)Activator.CreateInstance(cType);
			}
			throw new DicomCodecException("No registered codec for transfer syntax!");
		}

 public override uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options)
 {
     uint length = 0;
     length += 4; // element tag
     if (syntax.IsExplicitVR) {
         length += 2; // vr
         length += 6; // length
     } else {
         length += 4; // length
     }
     foreach (DcmItemSequenceItem item in SequenceItems) {
         length += item.CalculateWriteLength(syntax, options);
     }
     if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequence))
         length += 4 + 4; // Sequence Delimitation Item
     return length;
 }

 public abstract uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options);

        public void ChangeTransferSyntax(DicomTransferSyntax newTransferSyntax, DcmCodecParameters parameters)
        {
            DicomTransferSyntax oldTransferSyntax = InternalTransferSyntax;

            if (oldTransferSyntax == newTransferSyntax)
                return;

            if (oldTransferSyntax.IsEncapsulated && newTransferSyntax.IsEncapsulated) {
                ChangeTransferSyntax(DicomTransferSyntax.ExplicitVRLittleEndian, parameters);
                oldTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
            }

            if (Contains(DicomTags.PixelData)) {
                DcmPixelData oldPixelData = new DcmPixelData(this);
                DcmPixelData newPixelData = new DcmPixelData(newTransferSyntax, oldPixelData);

                if (oldTransferSyntax.IsEncapsulated) {
                    IDcmCodec codec = DicomCodec.GetCodec(oldTransferSyntax);
                    codec.Decode(this, oldPixelData, newPixelData, parameters);
                }
                else if (newTransferSyntax.IsEncapsulated) {
                    IDcmCodec codec = DicomCodec.GetCodec(newTransferSyntax);
                    codec.Encode(this, oldPixelData, newPixelData, parameters);
                }
                else {
                    for (int i = 0; i < oldPixelData.NumberOfFrames; i++) {
                        byte[] data = oldPixelData.GetFrameDataU8(i);
                        newPixelData.AddFrame(data);
                    }
                }

                newPixelData.UpdateDataset(this);
            }

            SetInternalTransferSyntax(newTransferSyntax);
        }

 protected DcmJpegCodec(DicomTransferSyntax transferSyntax, DcmJpegParameters defaultParameters = null)
 {
     _transferSyntax = transferSyntax;
     _defaultParameters = defaultParameters ?? new DcmJpegParameters();
 }

 public uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options)
 {
     uint length = 0;
     ushort group = 0xffff;
     foreach (DcmItem item in _items.Values) {
         if (item.Tag.Element == 0x0000)
             continue;
         if (item.Tag.Group != group) {
             group = item.Tag.Group;
             if (Flags.IsSet(options, DicomWriteOptions.CalculateGroupLengths)) {
                 if (syntax.IsExplicitVR)
                     length += 4 + 2 + 2 + 4;
                 else
                     length += 4 + 4 + 4;
             }
         }
         length += item.CalculateWriteLength(syntax, options);
     }
     return length;
 }

 public void RemoveTransfer(DicomTransferSyntax ts)
 {
     if (_transfers.Contains(ts))
         _transfers.Remove(ts);
 }

 /// <summary>
 /// Removes a Transfer Syntax from the specified Presentation Context.
 /// </summary>
 /// <param name="pcid">Presentation Context ID</param>
 /// <param name="ts">Transfer Syntax</param>
 public void RemoveTransferSyntax(byte pcid, DicomTransferSyntax ts)
 {
     GetPresentationContext(pcid).RemoveTransfer(ts);
 }

		/// <summary>
		/// Changes transfer syntax of dataset and updates file meta information
		/// </summary>
		/// <param name="ts">New transfer syntax</param>
		/// <param name="parameters">Encode/Decode params</param>
		public void ChangeTransferSytnax(DicomTransferSyntax ts, DcmCodecParameters parameters) {
			Dataset.ChangeTransferSyntax(ts, parameters);
			FileMetaInfo.TransferSyntax = ts;
		}

 public void AddTransfer(DicomTransferSyntax ts)
 {
     if (!_transfers.Contains(ts))
         _transfers.Add(ts);
 }

		public static bool IsImageCompression(DicomTransferSyntax tx) {
			return  tx != DicomTransferSyntax.ImplicitVRLittleEndian &&
					tx != DicomTransferSyntax.ExplicitVRLittleEndian &&
					tx != DicomTransferSyntax.ExplicitVRBigEndian &&
					tx != DicomTransferSyntax.DeflatedExplicitVRLittleEndian;
		}

        private DicomReadStatus ParseSequenceItemDataset(DicomTransferSyntax syntax, long len, out DcmDataset dataset, DicomReadOptions options)
        {
            long pos = _stream.Position;

            dataset = new DcmDataset(pos, (uint)len, syntax);

            Stream stream = (len != UndefinedLength) ? new SegmentStream(_stream, _stream.Position, _len) : _stream;

            DicomStreamReader idsr = new DicomStreamReader(stream);
            idsr.Dataset = dataset;
            idsr.Encoding = _encoding;
            if (len != UndefinedLength)
                idsr.PositionOffset = dataset.StreamPosition;

            DicomReadStatus status = idsr.Read(null, options);

            if (status != DicomReadStatus.Success) {
                _stream.Seek(pos, SeekOrigin.Begin);
                dataset = null;
            }
            else {
                if (len == UndefinedLength) {
                    // rewind delimitation item tag
                    _stream.Seek(-4, SeekOrigin.Current);

                    len = _stream.Position - pos;
                }

                _remain -= len;
                _bytes += len;
                _read += len;
            }

            return status;
        }

        private DicomReadStatus InsertSequenceItem(DicomReadOptions options)
        {
            if (_tag.Equals(DicomTags.Item)) {
                if (_len != UndefinedLength && _len > _remain)
                    return NeedMoreData(_len);

                if (_sds.Count > _sqs.Count)
                    _sds.Pop();

                DcmItemSequenceItem si = new DcmItemSequenceItem(_pos, _len);

                if (_len != UndefinedLength || (_stream.CanSeek && Flags.IsSet(options, DicomReadOptions.AllowSeekingForContext))) {
                    if (_len == UndefinedLength)
                        options |= DicomReadOptions.SequenceItemOnly;

                    DcmDataset ds = null;
                    DicomReadStatus status = ParseSequenceItemDataset(TransferSyntax, _len, out ds, options);

                    if (status != DicomReadStatus.Success) {
                        Dicom.Debug.Log.Warn("Unknown error while attempting to read sequence item.  Trying again with alternate encodings.");

                        DicomTransferSyntax[] syntaxes = null;
                        if (TransferSyntax == DicomTransferSyntax.ExplicitVRBigEndian)
                            syntaxes = new DicomTransferSyntax[] { DicomTransferSyntax.ImplicitVRLittleEndian, DicomTransferSyntax.ExplicitVRLittleEndian };
                        else if (TransferSyntax.IsExplicitVR)
                            syntaxes = new DicomTransferSyntax[] { DicomTransferSyntax.ImplicitVRLittleEndian, DicomTransferSyntax.ExplicitVRBigEndian };
                        else
                            syntaxes = new DicomTransferSyntax[] { DicomTransferSyntax.ExplicitVRLittleEndian, DicomTransferSyntax.ExplicitVRBigEndian };

                        foreach (DicomTransferSyntax tx in syntaxes) {
                            status = ParseSequenceItemDataset(tx, _len, out ds, options);
                            if (status == DicomReadStatus.Success)
                                break;
                        }
                    }

                    if (status != DicomReadStatus.Success)
                        return DicomReadStatus.UnknownError;

                    si.Dataset = ds;

                    if (_len == UndefinedLength) {
                        if (8 > _remain) {
                            // need more data?
                            _sds.Push(ds);
                        }
                        else {
                            // skip delimitation item
                            _stream.Seek(8, SeekOrigin.Current);
                            _remain -= 8;
                            _bytes += 8;
                            _read += 8;
                        }
                    }
                }
                else {
                    DcmDataset ds = new DcmDataset(_pos + 8, _len, TransferSyntax);
                    _sds.Push(ds);
                }

                _sqs.Peek().AddSequenceItem(si);
            }
            else if (_tag == DicomTags.ItemDelimitationItem) {
                if (_sds.Count == _sqs.Count)
                    _sds.Pop();
            }
            else if (_tag == DicomTags.SequenceDelimitationItem) {
                if (_sds.Count == _sqs.Count)
                    _sds.Pop();
                _sqs.Pop();
            }
            return DicomReadStatus.Success;
        }

 public void AddPresentationContext(byte pcid, DicomUID abstractSyntax, DicomTransferSyntax transferSyntax, DcmPresContextResult result)
 {
     _presContexts.Add(pcid, new DcmPresContext(pcid, abstractSyntax, transferSyntax, result));
 }

 /// <summary>
 /// Finds the Presentation Context with the specified Abstract Syntax and Transfer Syntax.
 /// </summary>
 /// <param name="abstractSyntax">Abstract Syntax</param>
 /// <param name="transferSyntax">Transfer Syntax</param>
 /// <returns>Presentation Context ID</returns>
 public byte FindAcceptedAbstractSyntaxWithTransferSyntax(DicomUID abstractSyntax, DicomTransferSyntax trasferSyntax)
 {
     foreach (DcmPresContext ctx in _presContexts.Values) {
         if (ctx.Result == DcmPresContextResult.Accept && ctx.AbstractSyntax == abstractSyntax && ctx.HasTransfer(trasferSyntax))
             return ctx.ID;
     }
     return 0;
 }

 public uint CalculateGroupWriteLength(ushort group, DicomTransferSyntax syntax, DicomWriteOptions options)
 {
     uint length = 0;
     foreach (DcmItem item in _items.Values) {
         if (item.Tag.Group < group || item.Tag.Element == 0x0000)
             continue;
         if (item.Tag.Group > group)
             return length;
         length += item.CalculateWriteLength(syntax, options);
     }
     return length;
 }