/// <summary>Reads the /Order in the /D entry and initialized the parent-child hierarchy.</summary>
private void ReadOrderFromDictionary(PdfLayer parent, PdfArray orderArray, IDictionary <PdfIndirectReference
, PdfLayer> layerMap)
{
for (int i = 0; i < orderArray.Size(); i++)
{
PdfObject item = orderArray.Get(i);
if (item.GetObjectType() == PdfObject.DICTIONARY)
{
PdfLayer layer = layerMap.Get(item.GetIndirectReference());
if (layer != null)
{
layers.Add(layer);
layer.onPanel = true;
if (parent != null)
{
parent.AddChild(layer);
}
if (i + 1 < orderArray.Size() && orderArray.Get(i + 1).GetObjectType() == PdfObject.ARRAY)
{
PdfArray nextArray = orderArray.GetAsArray(i + 1);
if (nextArray.Size() > 0 && nextArray.Get(0).GetObjectType() != PdfObject.STRING)
{
ReadOrderFromDictionary(layer, orderArray.GetAsArray(i + 1), layerMap);
i++;
}
}
}
}
else
{
if (item.GetObjectType() == PdfObject.ARRAY)
{
PdfArray subArray = (PdfArray)item;
if (subArray.IsEmpty())
{
continue;
}
PdfObject firstObj = subArray.Get(0);
if (firstObj.GetObjectType() == PdfObject.STRING)
{
PdfLayer titleLayer = PdfLayer.CreateTitleSilent(((PdfString)firstObj).ToUnicodeString(), GetDocument());
titleLayer.onPanel = true;
layers.Add(titleLayer);
if (parent != null)
{
parent.AddChild(titleLayer);
}
ReadOrderFromDictionary(titleLayer, new PdfArray(subArray.SubList(1, subArray.Size())), layerMap);
}
else
{
ReadOrderFromDictionary(parent, subArray, layerMap);
}
}
}
}
}
/// <summary>
/// Identifies the type of the image that is stored in the bytes of this
/// <see cref="PdfImageXObject"/>
/// .
/// Note that this has nothing to do with the original type of the image. For instance, the return value
/// of this method will never be
/// <see cref="iText.IO.Image.ImageType.PNG"/>
/// as we loose this information when converting a
/// PNG image into something that can be put into a PDF file.
/// The possible values are:
/// <see cref="iText.IO.Image.ImageType.JPEG"/>
/// ,
/// <see cref="iText.IO.Image.ImageType.JPEG2000"/>
/// ,
/// <see cref="iText.IO.Image.ImageType.JBIG2"/>
/// ,
/// <see cref="iText.IO.Image.ImageType.TIFF"/>
/// ,
/// <see cref="iText.IO.Image.ImageType.PNG"/>
/// </summary>
/// <returns>the identified type of image</returns>
public virtual ImageType IdentifyImageType()
{
PdfObject filter = GetPdfObject().Get(PdfName.Filter);
PdfArray filters = new PdfArray();
if (filter != null)
{
if (filter.GetObjectType() == PdfObject.NAME)
{
filters.Add(filter);
}
else
{
if (filter.GetObjectType() == PdfObject.ARRAY)
{
filters = ((PdfArray)filter);
}
}
}
for (int i = filters.Size() - 1; i >= 0; i--)
{
PdfName filterName = (PdfName)filters.Get(i);
if (PdfName.DCTDecode.Equals(filterName))
{
return(ImageType.JPEG);
}
else
{
if (PdfName.JBIG2Decode.Equals(filterName))
{
return(ImageType.JBIG2);
}
else
{
if (PdfName.JPXDecode.Equals(filterName))
{
return(ImageType.JPEG2000);
}
}
}
}
// None of the previous types match
PdfObject colorspace = GetPdfObject().Get(PdfName.ColorSpace);
PrepareAndFindColorspace(colorspace);
if (pngColorType < 0)
{
return(ImageType.TIFF);
}
else
{
return(ImageType.PNG);
}
}
/// <summary>
/// Identifies the type of the image that is stored in the bytes of this
/// <see cref="PdfImageXObject"/>
/// .
/// Note that this has nothing to do with the original type of the image. For instance, the return value
/// of this method will never be
/// <see cref="iText.IO.Image.ImageType.PNG"/>
/// as we loose this information when converting a
/// PNG image into something that can be put into a PDF file.
/// The possible values are:
/// <see cref="iText.IO.Image.ImageType.JPEG"/>
/// ,
/// <see cref="iText.IO.Image.ImageType.JPEG2000"/>
/// ,
/// <see cref="iText.IO.Image.ImageType.JBIG2"/>
/// ,
/// <see cref="iText.IO.Image.ImageType.TIFF"/>
/// ,
/// <see cref="iText.IO.Image.ImageType.PNG"/>
/// </summary>
/// <returns>the identified type of image</returns>
public virtual ImageType IdentifyImageType()
{
PdfObject filter = GetPdfObject().Get(PdfName.Filter);
PdfArray filters = new PdfArray();
if (filter != null)
{
if (filter.GetObjectType() == PdfObject.NAME)
{
filters.Add(filter);
}
else
{
if (filter.GetObjectType() == PdfObject.ARRAY)
{
filters = ((PdfArray)filter);
}
}
}
for (int i = filters.Size() - 1; i >= 0; i--)
{
PdfName filterName = (PdfName)filters.Get(i);
if (PdfName.DCTDecode.Equals(filterName))
{
return(ImageType.JPEG);
}
else
{
if (PdfName.JBIG2Decode.Equals(filterName))
{
return(ImageType.JBIG2);
}
else
{
if (PdfName.JPXDecode.Equals(filterName))
{
return(ImageType.JPEG2000);
}
}
}
}
// None of the previous types match
ImagePdfBytesInfo imageInfo = new ImagePdfBytesInfo(this);
if (imageInfo.GetPngColorType() < 0)
{
return(ImageType.TIFF);
}
else
{
return(ImageType.PNG);
}
}
/// <summary>
/// In case an object is an array, a dictionary or a stream,
/// we need to loop over the entries and process them one by one.
/// </summary>
/// <param name="obj">the object to examine</param>
protected internal void LoopOver(PdfObject obj)
{
switch (obj.GetObjectType())
{
case PdfObject.ARRAY: {
PdfArray array = (PdfArray)obj;
for (int i = 0; i < array.Size(); i++)
{
Process(array.Get(i));
}
break;
}
case PdfObject.DICTIONARY:
case PdfObject.STREAM: {
PdfDictionary dict = (PdfDictionary)obj;
if (PdfName.Pages.Equals(dict.Get(PdfName.Type)))
{
break;
}
foreach (PdfName name in dict.KeySet())
{
Process(dict.Get(name));
}
break;
}
}
}
/// <summary>
/// This method checks the requirements that must be fulfilled by a COS
/// object in a PDF/A document.
/// </summary>
/// <param name="obj">the COS object that must be checked</param>
public virtual void CheckPdfObject(PdfObject obj)
{
switch (obj.GetObjectType())
{
case PdfObject.NUMBER: {
CheckPdfNumber((PdfNumber)obj);
break;
}
case PdfObject.STREAM: {
CheckPdfStream((PdfStream)obj);
break;
}
case PdfObject.STRING: {
CheckPdfString((PdfString)obj);
break;
}
case PdfObject.DICTIONARY: {
PdfDictionary dict = (PdfDictionary)obj;
PdfName type = dict.GetAsName(PdfName.Type);
if (PdfName.Filespec.Equals(type))
{
CheckFileSpec(dict);
}
break;
}
}
}
public virtual PdfUserProperty.ValueType GetValueType()
{
PdfObject valObj = GetPdfObject().Get(PdfName.V);
if (valObj == null)
{
return(PdfUserProperty.ValueType.UNKNOWN);
}
switch (valObj.GetObjectType())
{
case PdfObject.BOOLEAN: {
return(PdfUserProperty.ValueType.BOOLEAN);
}
case PdfObject.NUMBER: {
return(PdfUserProperty.ValueType.NUMBER);
}
case PdfObject.STRING: {
return(PdfUserProperty.ValueType.TEXT);
}
default: {
return(PdfUserProperty.ValueType.UNKNOWN);
}
}
}
public virtual void CheckPdfObject(PdfObject obj)
{
switch (obj.GetObjectType())
{
case PdfObject.NUMBER: {
CheckPdfNumber((PdfNumber)obj);
break;
}
case PdfObject.STREAM: {
PdfStream stream = (PdfStream)obj;
//form xObjects, annotation appearance streams, patterns and type3 glyphs may have their own resources dictionary
CheckResources(stream.GetAsDictionary(PdfName.Resources));
CheckPdfStream(stream);
break;
}
case PdfObject.STRING: {
CheckPdfString((PdfString)obj);
break;
}
case PdfObject.DICTIONARY: {
PdfDictionary dict = (PdfDictionary)obj;
PdfName type = dict.GetAsName(PdfName.Type);
if (PdfName.Filespec.Equals(type))
{
CheckFileSpec(dict);
}
break;
}
}
}
private static int GetNumberOrDefault(PdfDictionary dict, PdfName key, int defaultInt)
{
int result = defaultInt;
PdfObject obj = dict.Get(key);
if (obj != null && obj.GetObjectType() == PdfObject.NUMBER)
{
result = ((PdfNumber)obj).IntValue();
}
return(result);
}
/// <summary>Adds new attribute by given name and value.</summary>
/// <remarks>Adds new attribute by given name and value. If required attribute is present, value of the attribute can't be null.
/// </remarks>
/// <param name="name"/>
/// <param name="valueObject"/>
/// <param name="required"/>
internal virtual void AddAttribute(String name, PdfObject valueObject, bool required)
{
if (valueObject == null)
{
if (required)
{
throw new AttributeNotFoundException(name);
}
return;
}
String valueString = null;
if (valueObject.GetObjectType() == PdfObject.BOOLEAN)
{
valueString = ((PdfBoolean)(valueObject)).GetValue() ? "yes" : "no";
}
else
{
if (valueObject.GetObjectType() == PdfObject.NAME)
{
valueString = ((PdfName)(valueObject)).GetValue();
}
else
{
if (valueObject.GetObjectType() == PdfObject.NUMBER)
{
valueString = ((PdfNumber)(valueObject)).GetValue().ToString();
}
else
{
if (valueObject.GetObjectType() == PdfObject.STRING)
{
valueString = ((PdfString)(valueObject)).GetValue();
}
}
}
}
attributes.Add(new AttributeObject(name, valueString));
}
private void IfKidIsStructElementAddToList(PdfObject kid, IList <IPdfStructElem> kids)
{
if (kid.IsFlushed())
{
kids.Add(null);
}
else
{
if (kid.GetObjectType() == PdfObject.DICTIONARY && PdfStructElem.IsStructElem((PdfDictionary)kid))
{
kids.Add(new PdfStructElem((PdfDictionary)kid));
}
}
}
protected internal override void CheckContentStreamObject(PdfObject @object)
{
byte type = @object.GetObjectType();
switch (type)
{
case PdfObject.NAME: {
CheckPdfName((PdfName)@object);
break;
}
case PdfObject.STRING: {
CheckPdfString((PdfString)@object);
break;
}
case PdfObject.NUMBER: {
CheckPdfNumber((PdfNumber)@object);
break;
}
case PdfObject.ARRAY: {
PdfArray array = (PdfArray)@object;
CheckPdfArray(array);
foreach (PdfObject obj in array)
{
CheckContentStreamObject(obj);
}
break;
}
case PdfObject.DICTIONARY: {
PdfDictionary dictionary = (PdfDictionary)@object;
CheckPdfDictionary(dictionary);
foreach (PdfName name in dictionary.KeySet())
{
CheckPdfName(name);
CheckPdfObject(dictionary.Get(name, false));
}
foreach (PdfObject obj in dictionary.Values())
{
CheckContentStreamObject(obj);
}
break;
}
}
}
/// <summary>
/// This method checks the requirements that must be fulfilled by a COS
/// object in a PDF/A document.
/// </summary>
/// <param name="obj">the COS object that must be checked</param>
public virtual void CheckPdfObject(PdfObject obj)
{
switch (obj.GetObjectType())
{
case PdfObject.NAME: {
CheckPdfName((PdfName)obj);
break;
}
case PdfObject.NUMBER: {
CheckPdfNumber((PdfNumber)obj);
break;
}
case PdfObject.STRING: {
CheckPdfString((PdfString)obj);
break;
}
case PdfObject.ARRAY: {
PdfArray array = (PdfArray)obj;
CheckPdfArray(array);
CheckArrayRecursively(array);
break;
}
case PdfObject.DICTIONARY: {
PdfDictionary dict = (PdfDictionary)obj;
PdfName type = dict.GetAsName(PdfName.Type);
if (PdfName.Filespec.Equals(type))
{
CheckFileSpec(dict);
}
CheckPdfDictionary(dict);
CheckDictionaryRecursively(dict);
break;
}
case PdfObject.STREAM: {
PdfStream stream = (PdfStream)obj;
CheckPdfStream(stream);
CheckDictionaryRecursively(stream);
break;
}
}
}
private IPdfStructElem ConvertPdfObjectToIPdfStructElem(PdfObject obj)
{
if (obj.IsIndirectReference())
{
obj = ((PdfIndirectReference)obj).GetRefersTo();
}
IPdfStructElem elem = null;
switch (obj.GetObjectType())
{
case PdfObject.DICTIONARY: {
PdfDictionary d = (PdfDictionary)obj;
if (IsStructElem(d))
{
elem = new iText.Kernel.Pdf.Tagging.PdfStructElem(d);
}
else
{
if (PdfName.MCR.Equals(d.GetAsName(PdfName.Type)))
{
elem = new PdfMcrDictionary(d, this);
}
else
{
if (PdfName.OBJR.Equals(d.GetAsName(PdfName.Type)))
{
elem = new PdfObjRef(d, this);
}
}
}
break;
}
case PdfObject.NUMBER: {
elem = new PdfMcrNumber((PdfNumber)obj, this);
break;
}
default: {
break;
}
}
return(elem);
}
/// <summary>Reads an array.</summary>
/// <remarks>Reads an array. The tokeniser must be positioned past the "[" token.</remarks>
/// <returns>an array</returns>
/// <exception cref="System.IO.IOException">on error</exception>
public virtual PdfArray ReadArray()
{
PdfArray array = new PdfArray();
while (true)
{
PdfObject obj = ReadObject();
if (!obj.IsArray() && tokeniser.GetTokenType() == PdfTokenizer.TokenType.EndArray)
{
break;
}
if (tokeniser.GetTokenType() == PdfTokenizer.TokenType.EndDic && obj.GetObjectType() != PdfObject.DICTIONARY
)
{
tokeniser.ThrowError(PdfException.UnexpectedGtGt);
}
array.Add(obj);
}
return(array);
}
/// <param name="in">Input byte array.</param>
/// <param name="decodeParams">PdfDictionary of decodeParams.</param>
/// <returns>a byte array</returns>
public static byte[] DecodePredictor(byte[] @in, PdfObject decodeParams)
{
if (decodeParams == null || decodeParams.GetObjectType() != PdfObject.DICTIONARY)
{
return(@in);
}
PdfDictionary dic = (PdfDictionary)decodeParams;
PdfObject obj = dic.Get(PdfName.Predictor);
if (obj == null || obj.GetObjectType() != PdfObject.NUMBER)
{
return(@in);
}
int predictor = ((PdfNumber)obj).IntValue();
if (predictor < 10 && predictor != 2)
{
return(@in);
}
int width = 1;
obj = dic.Get(PdfName.Columns);
if (obj != null && obj.GetObjectType() == PdfObject.NUMBER)
{
width = ((PdfNumber)obj).IntValue();
}
int colors = 1;
obj = dic.Get(PdfName.Colors);
if (obj != null && obj.GetObjectType() == PdfObject.NUMBER)
{
colors = ((PdfNumber)obj).IntValue();
}
int bpc = 8;
obj = dic.Get(PdfName.BitsPerComponent);
if (obj != null && obj.GetObjectType() == PdfObject.NUMBER)
{
bpc = ((PdfNumber)obj).IntValue();
}
BinaryReader dataStream = new BinaryReader(new MemoryStream(@in));
MemoryStream fout = new MemoryStream(@in.Length);
int bytesPerPixel = colors * bpc / 8;
int bytesPerRow = (colors * width * bpc + 7) / 8;
byte[] curr = new byte[bytesPerRow];
byte[] prior = new byte[bytesPerRow];
if (predictor == 2)
{
if (bpc == 8)
{
int numRows = @in.Length / bytesPerRow;
for (int row = 0; row < numRows; row++)
{
int rowStart = row * bytesPerRow;
for (int col = bytesPerPixel; col < bytesPerRow; col++)
{
@in[rowStart + col] = (byte)(@in[rowStart + col] + @in[rowStart + col - bytesPerPixel]);
}
}
}
return(@in);
}
// Decode the (sub)image row-by-row
while (true)
{
// Read the filter type byte and a row of data
int filter;
try {
filter = dataStream.Read();
if (filter < 0)
{
return(fout.ToArray());
}
dataStream.ReadFully(curr, 0, bytesPerRow);
}
catch (Exception) {
return(fout.ToArray());
}
switch (filter)
{
case 0: {
//PNG_FILTER_NONE
break;
}
case 1: {
//PNG_FILTER_SUB
for (int i = bytesPerPixel; i < bytesPerRow; i++)
{
curr[i] += curr[i - bytesPerPixel];
}
break;
}
case 2: {
//PNG_FILTER_UP
for (int i = 0; i < bytesPerRow; i++)
{
curr[i] += prior[i];
}
break;
}
case 3: {
//PNG_FILTER_AVERAGE
for (int i = 0; i < bytesPerPixel; i++)
{
curr[i] += (byte)(prior[i] / 2);
}
for (int i = bytesPerPixel; i < bytesPerRow; i++)
{
curr[i] += (byte)(((curr[i - bytesPerPixel] & 0xff) + (prior[i] & 0xff)) / 2);
}
break;
}
case 4: {
//PNG_FILTER_PAETH
for (int i = 0; i < bytesPerPixel; i++)
{
curr[i] += prior[i];
}
for (int i = bytesPerPixel; i < bytesPerRow; i++)
{
int a = curr[i - bytesPerPixel] & 0xff;
int b = prior[i] & 0xff;
int c = prior[i - bytesPerPixel] & 0xff;
int p = a + b - c;
int pa = Math.Abs(p - a);
int pb = Math.Abs(p - b);
int pc = Math.Abs(p - c);
int ret;
if (pa <= pb && pa <= pc)
{
ret = a;
}
else
{
if (pb <= pc)
{
ret = b;
}
else
{
ret = c;
}
}
curr[i] += (byte)ret;
}
break;
}
default: {
// Error -- unknown filter type
throw new PdfException(PdfException.PngFilterUnknown);
}
}
try {
fout.Write(curr);
}
catch (System.IO.IOException) {
// Never happens
System.Diagnostics.Debug.Assert(true, "Happens!");
}
// Swap curr and prior
byte[] tmp = prior;
prior = curr;
curr = tmp;
}
}
