| public GetFieldDefaulted ( TiffTag tag ) : BitMiracle.LibTiff.Classic.FieldValue[] | ||
| tag | TiffTag | The tag. |
| return | BitMiracle.LibTiff.Classic.FieldValue[] | |
public FieldValue[] GetFieldDefaulted(TiffTag tag)
{
TiffDirectory td = m_dir;
FieldValue[] result = GetField(tag);
if (result != null)
return result;
switch (tag)
{
case TiffTag.SUBFILETYPE:
result = new FieldValue[1];
result[0].Set(td.td_subfiletype);
break;
case TiffTag.BITSPERSAMPLE:
result = new FieldValue[1];
result[0].Set(td.td_bitspersample);
break;
case TiffTag.THRESHHOLDING:
result = new FieldValue[1];
result[0].Set(td.td_threshholding);
break;
case TiffTag.FILLORDER:
result = new FieldValue[1];
result[0].Set(td.td_fillorder);
break;
case TiffTag.ORIENTATION:
result = new FieldValue[1];
result[0].Set(td.td_orientation);
break;
case TiffTag.SAMPLESPERPIXEL:
result = new FieldValue[1];
result[0].Set(td.td_samplesperpixel);
break;
case TiffTag.ROWSPERSTRIP:
result = new FieldValue[1];
result[0].Set(td.td_rowsperstrip);
break;
case TiffTag.MINSAMPLEVALUE:
result = new FieldValue[1];
result[0].Set(td.td_minsamplevalue);
break;
case TiffTag.MAXSAMPLEVALUE:
result = new FieldValue[1];
result[0].Set(td.td_maxsamplevalue);
break;
case TiffTag.PLANARCONFIG:
result = new FieldValue[1];
result[0].Set(td.td_planarconfig);
break;
case TiffTag.RESOLUTIONUNIT:
result = new FieldValue[1];
result[0].Set(td.td_resolutionunit);
break;
case TiffTag.PREDICTOR:
CodecWithPredictor sp = m_currentCodec as CodecWithPredictor;
if (sp != null)
{
result = new FieldValue[1];
result[0].Set(sp.GetPredictorValue());
}
break;
case TiffTag.DOTRANGE:
result = new FieldValue[2];
result[0].Set(0);
result[1].Set((1 << td.td_bitspersample) - 1);
break;
case TiffTag.INKSET:
result = new FieldValue[1];
result[0].Set(InkSet.CMYK);
break;
case TiffTag.NUMBEROFINKS:
result = new FieldValue[1];
result[0].Set(4);
break;
case TiffTag.EXTRASAMPLES:
result = new FieldValue[2];
result[0].Set(td.td_extrasamples);
result[1].Set(td.td_sampleinfo);
break;
case TiffTag.MATTEING:
result = new FieldValue[1];
result[0].Set((td.td_extrasamples == 1 && td.td_sampleinfo[0] == ExtraSample.ASSOCALPHA));
break;
case TiffTag.TILEDEPTH:
result = new FieldValue[1];
result[0].Set(td.td_tiledepth);
break;
case TiffTag.DATATYPE:
result = new FieldValue[1];
result[0].Set(td.td_sampleformat - 1);
break;
case TiffTag.SAMPLEFORMAT:
result = new FieldValue[1];
result[0].Set(td.td_sampleformat);
break;
case TiffTag.IMAGEDEPTH:
result = new FieldValue[1];
result[0].Set(td.td_imagedepth);
break;
case TiffTag.YCBCRCOEFFICIENTS:
{
// defaults are from CCIR Recommendation 601-1
float[] ycbcrcoeffs = new float[3];
ycbcrcoeffs[0] = 0.299f;
ycbcrcoeffs[1] = 0.587f;
ycbcrcoeffs[2] = 0.114f;
result = new FieldValue[1];
result[0].Set(ycbcrcoeffs);
break;
}
case TiffTag.YCBCRSUBSAMPLING:
result = new FieldValue[2];
result[0].Set(td.td_ycbcrsubsampling[0]);
result[1].Set(td.td_ycbcrsubsampling[1]);
break;
case TiffTag.YCBCRPOSITIONING:
result = new FieldValue[1];
result[0].Set(td.td_ycbcrpositioning);
break;
case TiffTag.WHITEPOINT:
{
// TIFF 6.0 specification tells that it is no default value for the
// WhitePoint, but AdobePhotoshop TIFF Technical Note tells that it
// should be CIE D50.
float[] whitepoint = new float[2];
whitepoint[0] = D50_X0 / (D50_X0 + D50_Y0 + D50_Z0);
whitepoint[1] = D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0);
result = new FieldValue[1];
result[0].Set(whitepoint);
break;
}
case TiffTag.TRANSFERFUNCTION:
if (td.td_transferfunction[0] == null && !defaultTransferFunction(td))
{
ErrorExt(this, m_clientdata, m_name, "No space for \"TransferFunction\" tag");
return null;
}
result = new FieldValue[3];
result[0].Set(td.td_transferfunction[0]);
if (td.td_samplesperpixel - td.td_extrasamples > 1)
{
result[1].Set(td.td_transferfunction[1]);
result[2].Set(td.td_transferfunction[2]);
}
break;
case TiffTag.REFERENCEBLACKWHITE:
if (td.td_refblackwhite == null)
defaultRefBlackWhite(td);
result = new FieldValue[1];
result[0].Set(td.td_refblackwhite);
break;
}
return result;
}
public bool Copy(Tiff inImage, Tiff outImage)
{
int width = 0;
FieldValue[] result = inImage.GetField(TiffTag.IMAGEWIDTH);
if (result != null)
{
width = result[0].ToInt();
outImage.SetField(TiffTag.IMAGEWIDTH, width);
}
int length = 0;
result = inImage.GetField(TiffTag.IMAGELENGTH);
if (result != null)
{
length = result[0].ToInt();
outImage.SetField(TiffTag.IMAGELENGTH, length);
}
short bitspersample = 1;
result = inImage.GetField(TiffTag.BITSPERSAMPLE);
if (result != null)
{
bitspersample = result[0].ToShort();
outImage.SetField(TiffTag.BITSPERSAMPLE, bitspersample);
}
short samplesperpixel = 1;
result = inImage.GetField(TiffTag.SAMPLESPERPIXEL);
if (result != null)
{
samplesperpixel = result[0].ToShort();
outImage.SetField(TiffTag.SAMPLESPERPIXEL, samplesperpixel);
}
if (m_compression != (Compression)(-1))
outImage.SetField(TiffTag.COMPRESSION, m_compression);
else
{
result = inImage.GetField(TiffTag.COMPRESSION);
if (result != null)
{
m_compression = (Compression)result[0].ToInt();
outImage.SetField(TiffTag.COMPRESSION, m_compression);
}
}
result = inImage.GetFieldDefaulted(TiffTag.COMPRESSION);
Compression input_compression = (Compression)result[0].ToInt();
result = inImage.GetFieldDefaulted(TiffTag.PHOTOMETRIC);
Photometric input_photometric = (Photometric)result[0].ToShort();
if (input_compression == Compression.JPEG)
{
/* Force conversion to RGB */
inImage.SetField(TiffTag.JPEGCOLORMODE, JpegColorMode.RGB);
}
else if (input_photometric == Photometric.YCBCR)
{
/* Otherwise, can't handle subsampled input */
result = inImage.GetFieldDefaulted(TiffTag.YCBCRSUBSAMPLING);
short subsamplinghor = result[0].ToShort();
short subsamplingver = result[1].ToShort();
if (subsamplinghor != 1 || subsamplingver != 1)
{
Console.Error.WriteLine("tiffcp: {0}: Can't copy/convert subsampled image.", inImage.FileName());
return false;
}
}
if (m_compression == Compression.JPEG)
{
if (input_photometric == Photometric.RGB && m_jpegcolormode == JpegColorMode.RGB)
outImage.SetField(TiffTag.PHOTOMETRIC, Photometric.YCBCR);
else
outImage.SetField(TiffTag.PHOTOMETRIC, input_photometric);
}
else if (m_compression == Compression.SGILOG || m_compression == Compression.SGILOG24)
{
outImage.SetField(TiffTag.PHOTOMETRIC, samplesperpixel == 1 ? Photometric.LOGL : Photometric.LOGLUV);
}
else
{
if (input_compression != Compression.JPEG)
copyTag(inImage, outImage, TiffTag.PHOTOMETRIC, 1, TiffType.SHORT);
}
if (m_fillorder != 0)
outImage.SetField(TiffTag.FILLORDER, m_fillorder);
else
copyTag(inImage, outImage, TiffTag.FILLORDER, 1, TiffType.SHORT);
/*
* Will copy `Orientation' tag from input image
*/
result = inImage.GetFieldDefaulted(TiffTag.ORIENTATION);
m_orientation = (Orientation)result[0].ToByte();
switch (m_orientation)
{
case Orientation.BOTRIGHT:
case Orientation.RIGHTBOT:
Tiff.Warning(inImage.FileName(), "using bottom-left orientation");
m_orientation = Orientation.BOTLEFT;
break;
case Orientation.LEFTBOT:
case Orientation.BOTLEFT:
break;
case Orientation.TOPRIGHT:
case Orientation.RIGHTTOP:
default:
Tiff.Warning(inImage.FileName(), "using top-left orientation");
m_orientation = Orientation.TOPLEFT;
break;
case Orientation.LEFTTOP:
case Orientation.TOPLEFT:
break;
}
outImage.SetField(TiffTag.ORIENTATION, m_orientation);
/*
* Choose tiles/strip for the output image according to
* the command line arguments (-tiles, -strips) and the
* structure of the input image.
*/
if (m_outtiled == -1)
{
if (inImage.IsTiled())
m_outtiled = 1;
else
m_outtiled = 0;
}
if (m_outtiled != 0)
{
/*
* Setup output file's tile width&height. If either
* is not specified, use either the value from the
* input image or, if nothing is defined, use the
* library default.
*/
if (m_tilewidth == -1)
{
result = inImage.GetFieldDefaulted(TiffTag.TILEWIDTH);
if (result != null)
m_tilewidth = result[0].ToInt();
}
if (m_tilelength == -1)
{
result = inImage.GetFieldDefaulted(TiffTag.TILELENGTH);
if (result != null)
m_tilelength = result[0].ToInt();
}
outImage.DefaultTileSize(ref m_tilewidth, ref m_tilelength);
outImage.SetField(TiffTag.TILEWIDTH, m_tilewidth);
outImage.SetField(TiffTag.TILELENGTH, m_tilelength);
}
else
{
/*
* RowsPerStrip is left unspecified: use either the
* value from the input image or, if nothing is defined,
* use the library default.
*/
if (m_rowsperstrip == 0)
{
result = inImage.GetField(TiffTag.ROWSPERSTRIP);
if (result == null)
m_rowsperstrip = outImage.DefaultStripSize(m_rowsperstrip);
else
m_rowsperstrip = result[0].ToInt();
if (m_rowsperstrip > length && m_rowsperstrip != -1)
m_rowsperstrip = length;
}
else if (m_rowsperstrip == -1)
m_rowsperstrip = length;
outImage.SetField(TiffTag.ROWSPERSTRIP, m_rowsperstrip);
}
if (m_config != PlanarConfig.UNKNOWN)
outImage.SetField(TiffTag.PLANARCONFIG, m_config);
else
{
result = inImage.GetField(TiffTag.PLANARCONFIG);
if (result != null)
{
m_config = (PlanarConfig)result[0].ToShort();
outImage.SetField(TiffTag.PLANARCONFIG, m_config);
}
}
if (samplesperpixel <= 4)
copyTag(inImage, outImage, TiffTag.TRANSFERFUNCTION, 4, TiffType.SHORT);
copyTag(inImage, outImage, TiffTag.COLORMAP, 4, TiffType.SHORT);
/* SMinSampleValue & SMaxSampleValue */
switch (m_compression)
{
case Compression.JPEG:
outImage.SetField(TiffTag.JPEGQUALITY, m_quality);
outImage.SetField(TiffTag.JPEGCOLORMODE, m_jpegcolormode);
break;
case Compression.LZW:
case Compression.ADOBE_DEFLATE:
case Compression.DEFLATE:
if (m_predictor != -1)
outImage.SetField(TiffTag.PREDICTOR, m_predictor);
else
{
result = inImage.GetField(TiffTag.PREDICTOR);
if (result != null)
{
m_predictor = result[0].ToShort();
outImage.SetField(TiffTag.PREDICTOR, m_predictor);
}
}
break;
case Compression.CCITTFAX3:
case Compression.CCITTFAX4:
if (m_compression == Compression.CCITTFAX3)
{
if (m_g3opts != Group3Opt.UNKNOWN)
outImage.SetField(TiffTag.GROUP3OPTIONS, m_g3opts);
else
{
result = inImage.GetField(TiffTag.GROUP3OPTIONS);
if (result != null)
{
m_g3opts = (Group3Opt)result[0].ToShort();
outImage.SetField(TiffTag.GROUP3OPTIONS, m_g3opts);
}
}
}
else
copyTag(inImage, outImage, TiffTag.GROUP4OPTIONS, 1, TiffType.LONG);
copyTag(inImage, outImage, TiffTag.BADFAXLINES, 1, TiffType.LONG);
copyTag(inImage, outImage, TiffTag.CLEANFAXDATA, 1, TiffType.LONG);
copyTag(inImage, outImage, TiffTag.CONSECUTIVEBADFAXLINES, 1, TiffType.LONG);
copyTag(inImage, outImage, TiffTag.FAXRECVPARAMS, 1, TiffType.LONG);
copyTag(inImage, outImage, TiffTag.FAXRECVTIME, 1, TiffType.LONG);
copyTag(inImage, outImage, TiffTag.FAXSUBADDRESS, 1, TiffType.ASCII);
break;
}
result = inImage.GetField(TiffTag.ICCPROFILE);
if (result != null)
outImage.SetField(TiffTag.ICCPROFILE, result[0], result[1]);
result = inImage.GetField(TiffTag.NUMBEROFINKS);
if (result != null)
{
short ninks = result[0].ToShort();
outImage.SetField(TiffTag.NUMBEROFINKS, ninks);
result = inImage.GetField(TiffTag.INKNAMES);
if (result != null)
{
string inknames = result[0].ToString();
string[] parts = inknames.Split(new char[] { '\0' });
int inknameslen = 0;
foreach (string part in parts)
inknameslen += part.Length + 1;
outImage.SetField(TiffTag.INKNAMES, inknameslen, inknames);
}
}
result = inImage.GetField(TiffTag.PAGENUMBER);
if (m_pageInSeq == 1)
{
if (m_pageNum < 0)
{
/* only one input file */
if (result != null)
outImage.SetField(TiffTag.PAGENUMBER, result[0], result[1]);
}
else
{
outImage.SetField(TiffTag.PAGENUMBER, m_pageNum++, 0);
}
}
else
{
if (result != null)
{
if (m_pageNum < 0)
{
/* only one input file */
outImage.SetField(TiffTag.PAGENUMBER, result[0], result[1]);
}
else
{
outImage.SetField(TiffTag.PAGENUMBER, m_pageNum++, 0);
}
}
}
int NTAGS = g_tags.Length;
for (int i = 0; i < NTAGS; i++)
{
tagToCopy p = g_tags[i];
copyTag(inImage, outImage, p.tag, p.count, p.type);
}
return pickFuncAndCopy(inImage, outImage, bitspersample, samplesperpixel, length, width);
}