public PRStream(PRStream stream, PdfDictionary newDic) {
     reader = stream.reader;
     offset = stream.offset;
     length = stream.Length;
     compressed = stream.compressed;
     compressionLevel = stream.compressionLevel;
     streamBytes = stream.streamBytes;
     bytes = stream.bytes;
     objNum = stream.objNum;
     objGen = stream.objGen;
     if (newDic != null)
         Merge(newDic);
     else
         Merge(stream);
 }

 /** Sets the contents of the page.
 * @param content the new page content
 * @param pageNum the page number. 1 is the first
 * @since   2.1.3   (the method already existed without param compressionLevel)
 */
 virtual public void SetPageContent(int pageNum, byte[] content, int compressionLevel) {
     PdfDictionary page = GetPageN(pageNum);
     if (page == null)
         return;
     PdfObject contents = page.Get(PdfName.CONTENTS);
     freeXref = -1;
     KillXref(contents);
     if (freeXref == -1) {
         xrefObj.Add(null);
         freeXref = xrefObj.Count - 1;
     }
     page.Put(PdfName.CONTENTS, new PRIndirectReference(this, freeXref));
     xrefObj[freeXref] = new PRStream(this, content, compressionLevel);
 }

 internal ByteStore(PRStream str)
 {
     md5 = HashAlgorithm.Create("MD5");
     ByteBuffer bb = new ByteBuffer();
     int level = 100;
     SerObject(str, level, bb);
     this.b = bb.ToByteArray();
     md5 = null;
 }

 internal ByteStore(PRStream str, Dictionary<RefKey, int> serialized)
 {
     ByteBuffer bb = new ByteBuffer();
     int level = 100;
     SerObject(str, level, bb, serialized);
     this.b = bb.ToByteArray();
     hash = CalculateHash(this.b);
 }

        /**
        * Translate a PRStream to a PdfStream. The data part copies itself.
        */
        protected PdfStream CopyStream(PRStream inp)
        {
            PRStream outp = new PRStream(inp, null);

            foreach (PdfName key in inp.Keys) {
                PdfObject value = inp.Get(key);
                outp.Put(key, CopyObject(value));
            }

            return outp;
        }

 /**
  * Creates a PdfImage object.
  * @param stream a PRStream
  * @param colorSpaceDic a color space dictionary
  * @throws IOException
  */
 public PdfImageObject(PRStream stream, PdfDictionary colorSpaceDic)
     : this(stream, PdfReader.GetStreamBytesRaw(stream), colorSpaceDic)
 {
 }

 /** Get the content from a stream as it is without applying any filter.
 * @param stream the stream
 * @throws IOException on error
 * @return the stream content
 */    
 public static byte[] GetStreamBytesRaw(PRStream stream) {
     RandomAccessFileOrArray rf = stream.Reader.SafeFile;
     try {
         rf.ReOpen();
         return GetStreamBytesRaw(stream, rf);
     }
     finally {
         try{rf.Close();}catch{}
     }
 }

        private void UpdateImageStream(PRStream imageStream, byte[] newData) {
            PdfImage image = new PdfImage(Image.GetInstance(newData), "", null);

            if (imageStream.Contains(PdfName.SMASK)) {
                image.Put(PdfName.SMASK, imageStream.Get(PdfName.SMASK));
            }

            if (imageStream.Contains(PdfName.MASK)) {
                image.Put(PdfName.MASK, imageStream.Get(PdfName.MASK));
            }

            if (imageStream.Contains(PdfName.SMASKINDATA)) {
                image.Put(PdfName.SMASKINDATA, imageStream.Get(PdfName.SMASKINDATA));
            }

            imageStream.Clear();
            imageStream.PutAll(image);
            imageStream.SetDataRaw(image.GetBytes());
        }

 internal ByteStore(PRStream str)
 {
     md5 = new MD5CryptoServiceProvider();
     ByteBuffer bb = new ByteBuffer();
     int level = 100;
     SerObject(str, level, bb);
     this.b = bb.ToByteArray();
     md5 = null;
 }

 /**
  * Creates a PdfImage object.
  * @param stream a PRStream
  * @throws IOException
  */
 public PdfImageObject(PRStream stream) : this(stream, iTextSharp.text.pdf.PdfReader.GetStreamBytesRaw(stream), null) {
 }

 /// <summary>
 /// Parses a stream object and removes OCGs. </summary>
 /// <param name="stream">	a stream object </param>
 /// <param name="resources">	the resources dictionary of that object (containing info about the OCGs) </param>
 public virtual void Parse(PRStream stream, PdfDictionary resources) {
     baos = new MemoryStream();
     properties = resources.GetAsDict(PdfName.PROPERTIES);
     xobj = new HashSet2<PdfName>();
     PdfDictionary xobjects = resources.GetAsDict(PdfName.XOBJECT);
     if (xobjects != null) {
         // remove XObject (form or image) that belong to an OCG that needs to be removed
         foreach (PdfName name in xobjects.Keys) {
             PRStream xobject = (PRStream) xobjects.GetAsStream(name);
             PdfDictionary oc = xobject.GetAsDict(PdfName.OC);
             if (oc != null) {
                 PdfString ocname = oc.GetAsString(PdfName.NAME);
                 if (ocname != null && ocgs.Contains(ocname.ToString())) {
                     xobj.Add(name);
                 }
             }
         }
         foreach (PdfName name in xobj) {
             xobjects.Remove(name);
         }
     }
     // parse the content stream
     byte[] contentBytes = PdfReader.GetStreamBytes(stream);
     PRTokeniser tokeniser = new PRTokeniser(new RandomAccessFileOrArray(contentBytes));
     PdfContentParser ps = new PdfContentParser(tokeniser);
     List<PdfObject> operands = new List<PdfObject>();
     while (ps.Parse(operands).Count > 0) {
         PdfLiteral @operator = (PdfLiteral) operands[operands.Count - 1];
         ProcessOperator(this, @operator, operands);
     }
     baos.Flush();
     baos.Close();
     stream.SetData(baos.GetBuffer());
 }

 protected internal PdfObject ReadOneObjStm(PRStream stream, int idx) {
     int first = stream.GetAsNumber(PdfName.FIRST).IntValue;
     byte[] b = GetStreamBytes(stream, tokens.File);
     PRTokeniser saveTokens = tokens;
     tokens = new PRTokeniser(b);
     try {
         int address = 0;
         bool ok = true;
         ++idx;
         for (int k = 0; k < idx; ++k) {
             ok = tokens.NextToken();
             if (!ok)
                 break;
             if (tokens.TokenType != PRTokeniser.TK_NUMBER) {
                 ok = false;
                 break;
             }
             ok = tokens.NextToken();
             if (!ok)
                 break;
             if (tokens.TokenType != PRTokeniser.TK_NUMBER) {
                 ok = false;
                 break;
             }
             address = tokens.IntValue + first;
         }
         if (!ok)
             throw new InvalidPdfException(MessageLocalization.GetComposedMessage("error.reading.objstm"));
         tokens.Seek(address);
         return ReadPRObject();
     }
     finally {
         tokens = saveTokens;
     }
 }

 /** Get the content from a stream applying the required filters.
 * @param stream the stream
 * @param file the location where the stream is
 * @throws IOException on error
 * @return the stream content
 */    
 public static byte[] GetStreamBytes(PRStream stream, RandomAccessFileOrArray file) {
     PdfObject filter = GetPdfObjectRelease(stream.Get(PdfName.FILTER));
     byte[] b = GetStreamBytesRaw(stream, file);
     ArrayList filters = new ArrayList();
     if (filter != null) {
         if (filter.IsName())
             filters.Add(filter);
         else if (filter.IsArray())
             filters = ((PdfArray)filter).ArrayList;
     }
     ArrayList dp = new ArrayList();
     PdfObject dpo = GetPdfObjectRelease(stream.Get(PdfName.DECODEPARMS));
     if (dpo == null || (!dpo.IsDictionary() && !dpo.IsArray()))
         dpo = GetPdfObjectRelease(stream.Get(PdfName.DP));
     if (dpo != null) {
         if (dpo.IsDictionary())
             dp.Add(dpo);
         else if (dpo.IsArray())
             dp = ((PdfArray)dpo).ArrayList;
     }
     String name;
     for (int j = 0; j < filters.Count; ++j) {
         name = ((PdfName)GetPdfObjectRelease((PdfObject)filters[j])).ToString();
         if (name.Equals("/FlateDecode") || name.Equals("/Fl")) {
             b = FlateDecode(b);
             PdfObject dicParam = null;
             if (j < dp.Count) {
                 dicParam = (PdfObject)dp[j];
                 b = DecodePredictor(b, dicParam);
             }
         }
         else if (name.Equals("/ASCIIHexDecode") || name.Equals("/AHx"))
             b = ASCIIHexDecode(b);
         else if (name.Equals("/ASCII85Decode") || name.Equals("/A85"))
             b = ASCII85Decode(b);
         else if (name.Equals("/LZWDecode")) {
             b = LZWDecode(b);
             PdfObject dicParam = null;
             if (j < dp.Count) {
                 dicParam = (PdfObject)dp[j];
                 b = DecodePredictor(b, dicParam);
             }
         }
         else if (name.Equals("/Crypt")) {
         }
         else
             throw new UnsupportedPdfException(MessageLocalization.GetComposedMessage("the.filter.1.is.not.supported", name));
     }
     return b;
 }

 /** Get the content from a stream applying the required filters.
  * @param stream the stream
  * @param file the location where the stream is
  * @throws IOException on error
  * @return the stream content
  */
 public static byte[] GetStreamBytes(PRStream stream, RandomAccessFileOrArray file) {
     byte[] b = GetStreamBytesRaw(stream, file);
     return DecodeBytes(b, stream);
 }

 private void CheckPRStreamLength(PRStream stream) {
     int fileLength = tokens.Length;
     int start = stream.Offset;
     bool calc = false;
     int streamLength = 0;
     PdfObject obj = GetPdfObjectRelease(stream.Get(PdfName.LENGTH));
     if (obj != null && obj.Type == PdfObject.NUMBER) {
         streamLength = ((PdfNumber)obj).IntValue;
         if (streamLength + start > fileLength - 20)
             calc = true;
         else {
             tokens.Seek(start + streamLength);
             String line = tokens.ReadString(20);
             if (!line.StartsWith("\nendstream") &&
             !line.StartsWith("\r\nendstream") &&
             !line.StartsWith("\rendstream") &&
             !line.StartsWith("endstream"))
                 calc = true;
         }
     }
     else
         calc = true;
     if (calc) {
         byte[] tline = new byte[16];
         tokens.Seek(start);
         while (true) {
             int pos = tokens.FilePointer;
             if (!tokens.ReadLineSegment(tline))
                 break;
             if (Equalsn(tline, endstream)) {
                 streamLength = pos - start;
                 break;
             }
             if (Equalsn(tline, endobj)) {
                 tokens.Seek(pos - 16);
                 String s = tokens.ReadString(16);
                 int index = s.IndexOf("endstream");
                 if (index >= 0)
                     pos = pos - 16 + index;
                 streamLength = pos - start;
                 break;
             }
         }
     }
     stream.Length = streamLength;
 }

 protected internal static PdfObject DuplicatePdfObject(PdfObject original, PdfReader newReader) {
     if (original == null)
         return null;
     switch (original.Type) {
         case PdfObject.DICTIONARY: {
             return DuplicatePdfDictionary((PdfDictionary)original, null, newReader);
         }
         case PdfObject.STREAM: {
             PRStream org = (PRStream)original;
             PRStream stream = new PRStream(org, null, newReader);
             DuplicatePdfDictionary(org, stream, newReader);
             return stream;
         }
         case PdfObject.ARRAY: {
             PdfArray arr = new PdfArray();
             for (ListIterator<PdfObject> it = ((PdfArray)original).GetListIterator(); it.HasNext();) {
                 arr.Add(DuplicatePdfObject((PdfObject)it.Next(), newReader));
             }
             return arr;
         }
         case PdfObject.INDIRECT: {
             PRIndirectReference org = (PRIndirectReference)original;
             return new PRIndirectReference(newReader, org.Number, org.Generation);
         }
         default:
             return original;
     }
 }

 /**
 * Translate a PRStream to a PdfStream. The data part copies itself.
 */
 protected PdfStream CopyStream(PRStream inp) {
     PRStream outp = new PRStream(inp, null);
     
     foreach (PdfName key in inp.Keys) {
         PdfObject value = inp.Get(key);
         parentObjects[value] = inp;
         PdfObject res = CopyObject(value);
         if ((res != null) && !(res is PdfNull))
             outp.Put(key, res);
     }
     
     return outp;
 }

		virtual protected internal PdfObject ReadOneObjStm (PRStream stream, int idx) {
            int first = stream.GetAsNumber(PdfName.FIRST).IntValue;
            byte[] b = GetStreamBytes(stream, tokens.File);
            PRTokeniser saveTokens = tokens;
            tokens = new PRTokeniser(new RandomAccessFileOrArray(new RandomAccessSourceFactory().CreateSource(b)));
            try {
				int address = 0;
                bool ok = true;
                ++idx;
                for (int k = 0; k < idx; ++k) {
                    ok = tokens.NextToken();
                    if (!ok)
                        break;
                    if (tokens.TokenType != PRTokeniser.TokType.NUMBER) {
                        ok = false;
                        break;
                    }
                    ok = tokens.NextToken();
                    if (!ok)
                        break;
                    if (tokens.TokenType != PRTokeniser.TokType.NUMBER) {
                        ok = false;
                        break;
                    }
                    address = tokens.IntValue + first;
                }
                if (!ok)
                    throw new InvalidPdfException(MessageLocalization.GetComposedMessage("error.reading.objstm"));
                tokens.Seek(address);
                tokens.NextToken();
                PdfObject obj;
                if (tokens.TokenType == PRTokeniser.TokType.NUMBER) {
                    obj = new PdfNumber(tokens.StringValue);
                }
                else {
                    tokens.Seek(address);
                    obj = ReadPRObject();
                }
                return obj;
            }
            finally {
                tokens = saveTokens;
            }
        }

 /**
 * Gets the content stream of a page as a PdfStream object.
 * @param   pageNumber          the page of which you want the stream
 * @param   compressionLevel    the compression level you want to apply to the stream
 * @return  a PdfStream object
 * @since   2.1.3 (the method already existed without param compressionLevel)
 */
 internal PdfStream GetFormXObject(int pageNumber, int compressionLevel) {
     PdfDictionary page = reader.GetPageNRelease(pageNumber);
     PdfObject contents = PdfReader.GetPdfObjectRelease(page.Get(PdfName.CONTENTS));
     PdfDictionary dic = new PdfDictionary();
     byte[] bout = null;
     if (contents != null) {
         if (contents.IsStream())
             dic.Merge((PRStream)contents);
         else
             bout = reader.GetPageContent(pageNumber, file);
     }
     else
         bout = new byte[0];
     dic.Put(PdfName.RESOURCES, PdfReader.GetPdfObjectRelease(page.Get(PdfName.RESOURCES)));
     dic.Put(PdfName.TYPE, PdfName.XOBJECT);
     dic.Put(PdfName.SUBTYPE, PdfName.FORM);
     PdfImportedPage impPage = importedPages[pageNumber];
     dic.Put(PdfName.BBOX, new PdfRectangle(impPage.BoundingBox));
     PdfArray matrix = impPage.Matrix;
     if (matrix == null)
         dic.Put(PdfName.MATRIX, IDENTITYMATRIX);
     else
         dic.Put(PdfName.MATRIX, matrix);
     dic.Put(PdfName.FORMTYPE, ONE);
     PRStream stream;
     if (bout == null) {
         stream = new PRStream((PRStream)contents, dic);
     }
     else {
         stream = new PRStream(reader, bout);
         stream.Merge(dic);
     }
     return stream;
 }

 virtual protected internal void ReadObjStm(PRStream stream, IntHashtable map) {
     if (stream == null) return;
     int first = stream.GetAsNumber(PdfName.FIRST).IntValue;
     int n = stream.GetAsNumber(PdfName.N).IntValue;
     byte[] b = GetStreamBytes(stream, tokens.File);
     PRTokeniser saveTokens = tokens;
     tokens = new PRTokeniser(new RandomAccessFileOrArray(new RandomAccessSourceFactory().CreateSource(b)));
     try {
         int[] address = new int[n];
         int[] objNumber = new int[n];
         bool ok = true;
         for (int k = 0; k < n; ++k) {
             ok = tokens.NextToken();
             if (!ok)
                 break;
             if (tokens.TokenType != PRTokeniser.TokType.NUMBER) {
                 ok = false;
                 break;
             }
             objNumber[k] = tokens.IntValue;
             ok = tokens.NextToken();
             if (!ok)
                 break;
             if (tokens.TokenType != PRTokeniser.TokType.NUMBER) {
                 ok = false;
                 break;
             }
             address[k] = tokens.IntValue + first;
         }
         if (!ok)
             throw new InvalidPdfException(MessageLocalization.GetComposedMessage("error.reading.objstm"));
         for (int k = 0; k < n; ++k) {
             if (map.ContainsKey(k)) {
                 tokens.Seek(address[k]);
                 tokens.NextToken();
                 PdfObject obj;
                 if (tokens.TokenType == PRTokeniser.TokType.NUMBER) {
             	    obj = new PdfNumber(tokens.StringValue);
                 }
                 else {
             	    tokens.Seek(address[k]);
             	    obj = ReadPRObject();
                 }
                 xrefObj[objNumber[k]] = obj;
             }
         }            
     }
     finally {
         tokens = saveTokens;
     }
 }