BitMiracle.LibTiff.Classic.Tiff.NumberOfTiles C# (CSharp) Method

        public int NumberOfTiles()
        {
            int dx = m_dir.td_tilewidth;
            if (dx == -1)
                dx = m_dir.td_imagewidth;

            int dy = m_dir.td_tilelength;
            if (dy == -1)
                dy = m_dir.td_imagelength;

            int dz = m_dir.td_tiledepth;
            if (dz == -1)
                dz = m_dir.td_imagedepth;

            int ntiles;
            if (dx == 0 || dy == 0 || dz == 0)
            {
                ntiles = 0;
            }
            else
            {
                ntiles = multiply(
                    multiply(howMany(m_dir.td_imagewidth, dx), howMany(m_dir.td_imagelength, dy), "NumberOfTiles"),
                    howMany(m_dir.td_imagedepth, dz), "NumberOfTiles");
            }

            if (m_dir.td_planarconfig == PlanarConfig.SEPARATE)
                ntiles = multiply(ntiles, m_dir.td_samplesperpixel, "NumberOfTiles");

            return ntiles;
        }

        /*
        This function scans the input TIFF file for pages.  It attempts
        to determine which IFD's of the TIFF file contain image document
        pages.  For each, it gathers some information that has to do
        with the output of the PDF document as a whole.  
        */
        private void read_tiff_init(Tiff input)
        {
            short directorycount = input.NumberOfDirectories();
            m_tiff_pages = new T2P_PAGE [directorycount];
            for (int p = 0; p < directorycount; p++)
                m_tiff_pages[p] = new T2P_PAGE();

            FieldValue[] result = null;

            for (short i = 0; i < directorycount; i++)
            {
                int subfiletype = 0;

                if (!input.SetDirectory(i))
                {
                    Tiff.Error(Tiff2PdfConstants.TIFF2PDF_MODULE, 
                        "Can't set directory {0} of input file {1}", i, input.FileName());
                    return;
                }

                result = input.GetField(TiffTag.PAGENUMBER);
                if (result != null)
                {
                    short pagen = result[0].ToShort();
                    short paged = result[1].ToShort();

                    if ((pagen > paged) && (paged != 0))
                        m_tiff_pages[m_tiff_pagecount].page_number = paged;
                    else
                        m_tiff_pages[m_tiff_pagecount].page_number = pagen;
                }
                else
                {
                    result = input.GetField(TiffTag.SUBFILETYPE);
                    if (result != null)
                    {
                        subfiletype = result[0].ToInt();
                        if ((((FileType)subfiletype & FileType.PAGE) == 0) && (subfiletype != 0))
                            continue;
                    }
                    else
                    {
                        result = input.GetField(TiffTag.OSUBFILETYPE);
                        if (result != null)
                        {
                            subfiletype = result[0].ToInt();
                            if (((OFileType)subfiletype != OFileType.IMAGE) && ((OFileType)subfiletype != OFileType.PAGE) && (subfiletype != 0))
                                continue;
                        }
                    }

                    m_tiff_pages[m_tiff_pagecount].page_number = m_tiff_pagecount;
                }

                m_tiff_pages[m_tiff_pagecount].page_directory = i;

                if (input.IsTiled())
                    m_tiff_pages[m_tiff_pagecount].page_tilecount = input.NumberOfTiles();
                
                m_tiff_pagecount++;
            }

            IComparer myComparer = new cmp_t2p_page();
            Array.Sort(m_tiff_pages, myComparer);

            for (short i = 0; i < m_tiff_pagecount; i++)
            {
                m_pdf_xrefcount += 5;
                input.SetDirectory(m_tiff_pages[i].page_directory);

                result = input.GetField(TiffTag.PHOTOMETRIC);
                if ((result != null && ((Photometric)result[0].ToInt() == Photometric.PALETTE)) || input.GetField(TiffTag.INDEXED) != null)
                {
                    m_tiff_pages[i].page_extra++;
                    m_pdf_xrefcount++;
                }

                result = input.GetField(TiffTag.COMPRESSION);
                if (result != null)
                {
                    Compression xuint16 = (Compression)result[0].ToInt();
                    if ((xuint16 == Compression.DEFLATE || xuint16 == Compression.ADOBE_DEFLATE) 
                        && ((m_tiff_pages[i].page_tilecount != 0) || input.NumberOfStrips() == 1) 
                        && !m_pdf_nopassthrough)
                    {
                        if (m_pdf_minorversion < 2)
                            m_pdf_minorversion = 2;
                    }
                }

                result = input.GetField(TiffTag.TRANSFERFUNCTION);
                if (result != null)
                {
                    m_tiff_transferfunction[0] = result[0].GetBytes();
                    m_tiff_transferfunction[1] = result[1].GetBytes();
                    m_tiff_transferfunction[2] = result[2].GetBytes();

                    if (m_tiff_transferfunction[1] != m_tiff_transferfunction[0])
                    {
                        m_tiff_transferfunctioncount = 3;
                        m_tiff_pages[i].page_extra += 4;
                        m_pdf_xrefcount += 4;
                    }
                    else
                    {
                        m_tiff_transferfunctioncount = 1;
                        m_tiff_pages[i].page_extra += 2;
                        m_pdf_xrefcount += 2;
                    }

                    if (m_pdf_minorversion < 2)
                        m_pdf_minorversion = 2;
                }
                else
                {
                    m_tiff_transferfunctioncount = 0;
                }

                result = input.GetField(TiffTag.ICCPROFILE);
                if (result != null)
                {
                    m_tiff_iccprofilelength = result[0].ToInt();
                    m_tiff_iccprofile = result[1].ToByteArray();

                    m_tiff_pages[i].page_extra++;
                    m_pdf_xrefcount++;
                    if (m_pdf_minorversion < 3)
                        m_pdf_minorversion = 3;
                }

                //m_tiff_tiles[i].tiles_tilecount = m_tiff_pages[i].page_tilecount;

                result = input.GetField(TiffTag.PLANARCONFIG);
                if (result != null && ((PlanarConfig)result[0].ToShort() == PlanarConfig.SEPARATE))
                {
                    result = input.GetField(TiffTag.SAMPLESPERPIXEL);
                    int xuint16 = result[0].ToInt();
                    m_tiff_pages[i].page_tilecount /= xuint16;
                }

                if (m_tiff_pages[i].page_tilecount > 0)
                {
                    m_pdf_xrefcount += (m_tiff_pages[i].page_tilecount - 1) * 2;
                    result = input.GetField(TiffTag.TILEWIDTH);
                    m_tiff_pages[i].tiles_tilewidth = result[0].ToInt();

                    input.GetField(TiffTag.TILELENGTH);
                    m_tiff_pages[i].tiles_tilelength = result[0].ToInt();

                    m_tiff_pages[i].tiles_tiles = new T2P_TILE[m_tiff_pages[i].page_tilecount];
                    for (int idx = 0; idx < m_tiff_pages[i].page_tilecount; idx++)
                        m_tiff_pages[i].tiles_tiles[idx] = new T2P_TILE();
                }
            }
        }