def METHOD_NAME(self, index=1, subimage=0):
    #
    # setup tile descriptors for a given subimage
    stream = [
        "Data Object Store %06d" % index,
        "Resolution %04d" % subimage,
        "Subimage 0000 Header",
    ]
    fp = self.ole.openstream(stream)
    # skip prefix
    fp.read(28)
    # header stream
    s = fp.read(36)
    size = i32(s, 4), i32(s, 8)
    # tilecount = i32(s, 12)
    tilesize = i32(s, 16), i32(s, 20)
    # channels = i32(s, 24)
    offset = i32(s, 28)
    length = i32(s, 32)
    if size != self.size:
        raise IOError("subimage mismatch")
    # get tile descriptors
    fp.seek(28 + offset)
    s = fp.read(i32(s, 12) * length)
    x = y = 0
    xsize, ysize = size
    xtile, ytile = tilesize
    self.tile = []
    for i in range(0, len(s), length):
        compression = i32(s, i + 8)
        if compression == 0:
            self.tile.append(
                (
                    "raw",
                    (x, y, x + xtile, y + ytile),
                    i32(s, i) + 28,
                    (self.rawmode),
                )
            )
        elif compression == 1:
            # FIXME: the fill decoder is not implemented
            self.tile.append(
                (
                    "fill",
                    (x, y, x + xtile, y + ytile),
                    i32(s, i) + 28,
                    (self.rawmode, s[12:16]),
                )
            )
        elif compression == 2:
            internal_color_conversion = i8(s[14])
            jpeg_tables = i8(s[15])
            rawmode = self.rawmode
            if internal_color_conversion:
                # The image is stored as usual (usually YCbCr).
                if rawmode == "RGBA":
                    # For "RGBA", data is stored as YCbCrA based on
                    # negative RGB. The following trick works around
                    # this problem :
                    jpegmode, rawmode = "YCbCrK", "CMYK"
                else:
                    jpegmode = None  # let the decoder decide
            else:
                # The image is stored as defined by rawmode
                jpegmode = rawmode
            self.tile.append(
                (
                    "jpeg",
                    (x, y, x + xtile, y + ytile),
                    i32(s, i) + 28,
                    (rawmode, jpegmode),
                )
            )
            # FIXME: jpeg tables are tile dependent; the prefix
            # data must be placed in the tile descriptor itself!
            if jpeg_tables:
                self.tile_prefix = self.jpeg[jpeg_tables]
        else:
            raise IOError("unknown/invalid compression")
        x = x + xtile
        if x >= xsize:
            x, y = 0, y + ytile
            if y >= ysize:
                break  # isn't really required
    self.stream = stream
    self.fp = None