protected bool ReadImageInfoMain(BinaryReader br)
        {
            bool isComposite = false;
            // Read image type:
            UInt32 dword = br.ReadUInt32();

            if (dword == 0x100)
            {
                isComposite = true;
                Trace.WriteLine("Found a composite image");
                //Logger.LogMessage(MsgLevel.DEBUG, "Found a composite image");
                Debug.WriteLine("Found a composite image");
                dword = br.ReadUInt32();
            }
            else if (dword == 0x0)
            {
                Trace.WriteLine(string.Format("Found end of composite image ({0})", _imageNumber));
                // Logger.LogMessage(MsgLevel.DEBUG, string.Format("Found end of composite image ({0})", _imageNumber));
                Debug.WriteLine(string.Format("Found end of composite image ({0})", _imageNumber));
                _imageNumber = 0;
                return(false);
            }

            switch (dword)
            {
            case 0x01: _imageType = AoWImageType.Type01_Picture08_0x01;             break;

            case 0x02: _imageType = AoWImageType.Type02_RLESprite08_0x02;   break;

            case 0x03: _imageType = AoWImageType.Type03_Sprite08_0x03;              break;

            case 0x10: _imageType = AoWImageType.Type16_Picture16_0x10;             break;

            case 0x11: _imageType = AoWImageType.Type17_RLESprite16_0x11;   break;

            case 0x12: _imageType = AoWImageType.Type18_TransparentRLESprite16_0x12; break;

            case 0x16: _imageType = AoWImageType.Type22_Sprite16_0x16;              break;

            default:
                throw new Exception(string.Format("Found unsupported type of image (0x{0:X})", dword));
            }

            // Read record format:
            byte subId = br.ReadByte();

            switch (subId)
            {
            // convert subtype 1 to 2
            case 1: _subType = AoWImageSubType.SubType02; break;

            case 2: _subType = AoWImageSubType.SubType02; break;

            case 3: _subType = AoWImageSubType.SubType03; break;

            default:
                throw new Exception(string.Format("Found unsupported subtype (0x{0:X}) of image {1}", subId, _imageNumber));
            }

            // Read bitmap filename:
            dword = br.ReadUInt32();
            StringBuilder strb = new StringBuilder();

            for (UInt32 i = 0; i < dword; ++i)
            {
                strb.Append((char)br.ReadSByte());
            }
            _name = strb.ToString();

            // Read image size:
            _cX = br.ReadInt32();
            _cY = br.ReadInt32();

            // Read image offset:
            _xShift = br.ReadInt32();
            _yShift = br.ReadInt32();

            // Read instance number:
            _instanceNumber = br.ReadInt32();

            /*Logger.LogMessage(MsgLevel.DEBUG,
             *      string.Format("Image {0}({1}): '{2}', {3}, sub {4}, {5}x{6}", _imageNumber, _instanceNumber, _name, _imageType, subId, _cX, _cY));*/
            Debug.WriteLine(string.Format("Image {0}({1}): '{2}', {3}, sub {4}, {5}x{6}", _imageNumber, _instanceNumber, _name, _imageType, subId, _cX, _cY));

            // Read LoadMode byte:
            dword = br.ReadByte();
            switch (dword)
            {
            case 0: _loadMode = AoWLoadMode.lmInstant; break;

            case 1: _loadMode = AoWLoadMode.lmWhenUsed; break;

            case 2: _loadMode = AoWLoadMode.lmOnDemand; break;

            case 3: _loadMode = AoWLoadMode.lmWhenReferenced; break;

            default: _loadMode = AoWLoadMode.lmWhenUsed; break;
            }

            // Read image data size:
            _imageDataSize = br.ReadInt32();
            if (_imageDataSize < 0)
            {
                throw new Exception(string.Format("Invalid data size of image {0})", _imageNumber));
            }

            // Read image data offset:
            // Not here if InfoByte is 1
            if (subId != 1)
            {
                dword = br.ReadUInt32();                 // I think I'll not use it
            }
            // Read image size again:
            dword = br.ReadUInt32();
            //Debug.Assert((int)dword == _cX + _xShift);
            dword = br.ReadUInt32();
            //Debug.Assert((int)dword == _cY + _yShift);

            if (Is8bpp())
            {
                // Read unknownB byte:
                dword = br.ReadByte();
                Trace.WriteLine(string.Format("unknownB (0x{0:X})of image {1}", dword, _imageNumber));

                if (_subType == AoWImageSubType.SubType03)
                {
                    // Read unknownC int:
                    dword = br.ReadUInt32();
                    Trace.WriteLine(string.Format("unknownC (0x{0:X})of image {1}", dword, _imageNumber));
                    // Read unknownD int:
                    dword = br.ReadUInt32();
                    Trace.WriteLine(string.Format("unknownD (0x{0:X})of image {1}", dword, _imageNumber));
                }
            }
            else
            {
                if (_subType == AoWImageSubType.SubType03)
                {
                    // Read drawMode:
                    UInt32 drawMode = br.ReadUInt32();
                    // Read blendValue:
                    _blendValue = br.ReadInt32();

                    UInt32 showMode  = drawMode & 0x000000FF;
                    UInt32 blendMode = (drawMode & 0x0000FF00) >> 8;
                    switch (showMode)
                    {
                    case 0x0: _showMode = AoWShowMode.smOpaque; break;

                    case 0x1: _showMode = AoWShowMode.smTransparent; break;

                    case 0x2: _showMode = AoWShowMode.smBlended; break;

                    default:
                        throw new Exception(string.Format("Invalid ShowMode 0x{0:X} of image {1})", showMode, _imageNumber));
                    }
                    switch (blendMode)
                    {
                    case 0x0: _blendMode = AoWBlendMode.bmUser; break;

                    case 0x1: _blendMode = AoWBlendMode.bmAlpha; break;

                    case 0x2: _blendMode = AoWBlendMode.bmBrighten; break;

                    case 0x3: _blendMode = AoWBlendMode.bmIntensity; break;

                    case 0x4: _blendMode = AoWBlendMode.bmShadow; break;

                    case 0x5: _blendMode = AoWBlendMode.bmLinearAlpha; break;
                    }
                }
            }
            if (Is8bpp())
            {
                // Read palette index
                if (subId != 1)
                {
                    _numPalette = br.ReadInt32();
                }
            }
            else
            {
                // Read pixelFormat:
                dword = br.ReadUInt32();
                if (dword != 0x56509310u)
                {
                    throw new Exception(string.Format("Invalid PixelFormat 0x{0:X} of image {1})", dword, _imageNumber));
                }
            }

            // See if there should be a bounding box present.
            switch (_imageType)
            {
            case AoWImageType.Type02_RLESprite08_0x02:
            case AoWImageType.Type03_Sprite08_0x03:
            case AoWImageType.Type17_RLESprite16_0x11:
            case AoWImageType.Type18_TransparentRLESprite16_0x12:
            case AoWImageType.Type22_Sprite16_0x16:
            {
                // Read bounding box:
                Int32 bbWidth   = br.ReadInt32();
                Int32 bbHeight  = br.ReadInt32();
                Int32 bbXOffset = br.ReadInt32();
                Int32 bbYOffset = br.ReadInt32();
                _boundingBox.Set(bbYOffset, bbXOffset, bbWidth + bbXOffset - 1, bbHeight + bbYOffset - 1);

                // Read background colour
                _originalBackgroundColour = br.ReadUInt32();                                 //RGB565 or index
            }
            break;
            }

            // See if there should be clip_x
            switch (_imageType)
            {
            case AoWImageType.Type02_RLESprite08_0x02:
                // Read clip_x, seem useless, set to 0
                dword = br.ReadUInt32();
                Trace.WriteLine(string.Format("clip_x (0x{0:X})of image {1}", dword, _imageNumber));
                break;

            case AoWImageType.Type17_RLESprite16_0x11:
            case AoWImageType.Type18_TransparentRLESprite16_0x12:
            {
                dword = br.ReadUInt32();
                switch (dword)
                {
                case 0: _clipXHack = AoWClipXHack.None; break;

                //case AoW1Constants.clip_X_Structure:	_clipXHack = AoWClipXHack.AsStructure; break;
                //case AoW1Constants.clip_X_Mountain:	_clipXHack = AoWClipXHack.AsMountain; break;
                case AoW1Constants.clip_X_Item:                 _clipXHack = AoWClipXHack.AsItem; break;

                case AoW1Constants.clip_X_ShieldsM:             _clipXHack = AoWClipXHack.AsShieldsM; break;

                case AoW1Constants.clip_X_TCMap:                _clipXHack = AoWClipXHack.AsTCMap; break;

                default:
                    _clipXHack = AoWClipXHack.None;
                    // Logger.LogMessage( MsgLevel.DEBUG, string.Format("unknown clip_x (0x{0:X8})of image {1}", dword, _imageNumber));
                    Debug.WriteLine(string.Format("unknown clip_x (0x{0:X8})of image {1}", dword, _imageNumber));
                    break;
                }
            }
            break;
            }

            // Read image data if subtype == 1
            if (subId == 1)
            {
                List <ColorPalette> palettes = null;
                if (Is8bpp())
                {
                    // I think there should be the palette
                    palettes = new List <ColorPalette>();
                    palettes.Add(AoW1Header.ReadPalette(br));
                }
                ReadImageData(br, palettes);
            }

            if (isComposite)
            {
                // read composite images
                // read info data
                AoW1Bitmap elem = null;
                while (true)
                {
                    elem             = new AoW1Bitmap();
                    elem.ImageNumber = _imageNumber;
                    if (!elem.ReadImageInfoMain(br))
                    {
                        // End composite section
                        Debug.Assert(elem.ImageNumber == 0);
                        break;
                    }
                    _subImageList.Add(elem);
                }
            }

            return(true);
        }         // end ReadImageInfo