GARbro-mirror/Experimental/Unity/Vorbis.cs

//! \file       Vorbis.cs
//! \date       Fri Apr 07 21:07:30 2017
//! \brief      partial libvorbis port.
//
// Only parts crucial for FSB5 decoding got implemented.
// Parts that are not used in FSB5 decoder are left out completely or commented out.
//
// Copyright (C) 2017 by morkt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// -----------------------------------------------------------------------------
//
// libvorbis Copyright (c) 2002-2008 Xiph.org Foundation
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// - Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// - Neither the name of the Xiph.org Foundation nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace GameRes.Formats.Vorbis
{
    // struct vorbis_info
    // https://xiph.org/vorbis/doc/libvorbis/vorbis_info.html
    class VorbisInfo
    {
        public int  Version;
        public int  Channels;
        public int  Rate;
        public int  BitrateUpper;
        public int  BitrateNominal;
        public int  BitrateLower;

        public CodecSetupInfo CodecSetup = new CodecSetupInfo();

        const int TransormB = 1;
        const int WindowB = 1;
        const int TimeB = 1;
        const int FloorB = 2;
        const int ResB = 3;
        const int MapB = 1;

        Func<OggBitStream, VorbisInfoFloor>[] FloorMethods;

        public VorbisInfo ()
        {
            FloorMethods = new Func<OggBitStream, VorbisInfoFloor>[] {
                UnpackFloor0,
                UnpackFloor1
            };
        }

        // https://xiph.org/vorbis/doc/libvorbis/vorbis_synthesis_headerin.html
        public void SynthesisHeaderin (VorbisComment vc, OggPacket op)
        {
            using (var input = new OggBitStream (op))
            {
                int packtype = input.ReadUInt8();
                var buf = input.ReadBytes (6);
                if (!buf.AsciiEqual ("vorbis"))
                    throw new InvalidDataException ("Not an Ogg/Vorbis stream.");
                switch (packtype)
                {
                case 1:
                    if (!op.BoS)
                        throw InvalidHeader();
                    if (Rate != 0)
                        throw InvalidHeader();
                    UnpackInfo (input);
                    break;

                case 3:
                    if (0 == Rate)
                        throw InvalidHeader();
                    vc.UnpackComment (input);
                    break;

                case 5:
                    if (0 == Rate || null == vc.Vendor)
                        throw InvalidHeader();
                    UnpackBooks (input);
                    break;

                default:
                    throw InvalidHeader();
                }
            }
        }

        internal static int iLog (uint num)
        {
            int bits = 0;
            while (num != 0)
            {
                ++bits;
                num >>= 1;
            }
            return bits;
        }

        internal static int CountBits (uint num)
        {
            int bits = 0;
            if (num != 0)
                --num;
            while (num != 0)
            {
                ++bits;
                num >>= 1;
            }
            return bits;
        }

        /// <summary>
        /// Count number of bits set in <paramref name="num"/>.
        /// </summary>
        internal static int CountSetBits (uint num)
        {
            int bits = 0;
            while (num != 0)
            {
                bits += (int)num & 1;
                num >>= 1;
            }
            return bits;
        }

        // https://www.xiph.org/vorbis/doc/libvorbis/vorbis_packet_blocksize.html
        public int PacketBlockSize (OggPacket op)
        {
            using (var input = new OggBitStream (op))
            {
                // Check the packet type
                if (input.ReadBits (1) != 0)
                    throw new InvalidDataException ("Not an audio data packet.");

                int modebits = 0;
                for (int v = CodecSetup.Modes; v > 1; v >>= 1)
                {
                    modebits++;
                }

                // read our mode and pre/post windowsize
                int mode = input.ReadBits (modebits);

                if (-1 == mode)
                    throw new InvalidDataException ("Invalid Ogg/Vorbis packet.");

                return CodecSetup.BlockSizes[CodecSetup.ModeParam[mode].BlockFlag];
            }
        }

        void UnpackInfo (OggBitStream input)
        {
            Version = input.ReadInt32();
            if (Version != 0)
                throw new InvalidDataException ("Invalid Vorbis encoder version.");
            Channels = input.ReadUInt8();
            Rate = input.ReadInt32();

            BitrateUpper = input.ReadInt32();
            BitrateNominal = input.ReadInt32();
            BitrateLower = input.ReadInt32();

            CodecSetup.BlockSizes[0] = 1 << input.ReadBits (4);
            CodecSetup.BlockSizes[1] = 1 << input.ReadBits (4);

            if (input.ReadBits (1) != 1)
                throw InvalidHeader();
        }

        void UnpackBooks (OggBitStream input)
        {
            // codebooks
            CodecSetup.Books = input.ReadUInt8() + 1;
            if (CodecSetup.Books <= 0)
                throw InvalidHeader();

            for (int i = 0; i < CodecSetup.Books; ++i)
            {
                var param = StaticBookUnpack (input);
                if (null == param)
                    throw InvalidHeader();
                CodecSetup.BookParam[i] = param;
            }

            // time backend settings; hooks are unused
            int times = input.ReadBits (6) + 1;
            if (times <= 0)
                throw InvalidHeader();
            for (int i = 0; i < times; ++i)
            {
                int test = input.ReadBits (16);
                if (test < 0 || test >= TimeB)
                    throw InvalidHeader();
            }

            // floor backend settings
            CodecSetup.Floors = input.ReadBits (6) + 1;
            if (CodecSetup.Floors <= 0)
                throw InvalidHeader();
            for (int i = 0; i < CodecSetup.Floors; i++)
            {
                int floor_type = input.ReadBits (16);
                if (floor_type < 0 || floor_type >= FloorB)
                    throw InvalidHeader();
                CodecSetup.FloorType[i] = floor_type;
                var param = FloorMethods[floor_type] (input);
                if (null == param)
                    throw InvalidHeader();
                CodecSetup.FloorParam[i] = param;
            }

            // residue backend settings
            CodecSetup.Residues = input.ReadBits (6) + 1;
            if (CodecSetup.Residues <= 0)
                throw InvalidHeader();
            for (int i = 0; i < CodecSetup.Residues; ++i)
            {
                int residue_type = input.ReadBits (16);
                if (residue_type < 0 || residue_type >= ResB)
                    throw InvalidHeader();
                CodecSetup.ResidueType[i] = residue_type;
                var param = UnpackResidue (input);
                if (null == param)
                    throw InvalidHeader();
                CodecSetup.ResidueParam[i] = param;
            }

            // map backend settings
            CodecSetup.Maps = input.ReadBits (6) + 1;
            if (CodecSetup.Maps <= 0)
                throw InvalidHeader();
            for (int i = 0; i < CodecSetup.Maps; ++i)
            {
                int map_type = input.ReadBits (16);
                if (map_type < 0 || map_type >= MapB)
                    throw InvalidHeader();
                CodecSetup.MapType[i] = map_type;
                var param = UnpackMapping (input);
                if (null == param)
                    throw InvalidHeader();
                CodecSetup.MapParam[i] = param;
            }

            // mode settings
            CodecSetup.Modes = input.ReadBits (6) + 1;
            if (CodecSetup.Modes <= 0)
                throw InvalidHeader();
            for (int i = 0; i < CodecSetup.Modes; ++i)
            {
                CodecSetup.ModeParam[i].BlockFlag = input.ReadBits (1);
                CodecSetup.ModeParam[i].WindowType = input.ReadBits (16);
                CodecSetup.ModeParam[i].TransformType = input.ReadBits (16);
                CodecSetup.ModeParam[i].Mapping = input.ReadBits (8);

                if (CodecSetup.ModeParam[i].WindowType >= WindowB ||
                    CodecSetup.ModeParam[i].TransformType >= WindowB ||
                    CodecSetup.ModeParam[i].Mapping >= CodecSetup.Maps ||
                    CodecSetup.ModeParam[i].Mapping < 0)
                    throw InvalidHeader();
            }
            if (input.ReadBits (1) != 1)
                throw InvalidHeader();
        }

        StaticCodebook StaticBookUnpack (OggBitStream input)
        {
            // make sure alignment is correct
            if (input.ReadBits (24) != 0x564342)
                return null;

            var s = new StaticCodebook();

            // first the basic parameters
            s.dim = input.ReadBits (16);
            s.entries = input.ReadBits (24);
            if (-1 == s.entries)
                return null;

            if (iLog ((uint)s.dim) + iLog ((uint)s.entries) > 24)
                return null;

            // codeword ordering.... length ordered or unordered?
            switch (input.ReadBits (1))
            {
            case 0:
                // allocated but unused entries?
                int unused = input.ReadBits (1);
                // unordered
                s.lengthlist = new byte[s.entries];

                // allocated but unused entries?
                if (unused > 0)
                {
                    // yes, unused entries
                    for(int i = 0; i < s.entries; ++i)
                    {
                        if (input.ReadBits (1) > 0)
                        {
                            int num = input.ReadBits (5);
                            if (-1 == num)
                                return null;
                            s.lengthlist[i] = (byte)(num+1);
                        }
                        else
                            s.lengthlist[i] = 0;
                    }
                }
                else
                {
                    // all entries used; no tagging
                    for (int i = 0; i < s.entries; ++i)
                    {
                        int num = input.ReadBits (5);
                        if (-1 == num)
                            return null;
                        s.lengthlist[i] = (byte)(num+1);
                    }
                }
                break;

            case 1: // ordered
                int length = input.ReadBits (5) + 1;
                if (0 == length)
                    return null;
                s.lengthlist = new byte[s.entries];

                for (int i = 0; i < s.entries; )
                {
                    int num = input.ReadBits (iLog ((uint)(s.entries-i)));
                    if (-1 == num || length > 32 || num > s.entries-i
                        || (num > 0 && ((num-1) >> (length-1)) > 1))
                        return null;
                    for (int j = 0; j < num; ++j, ++i)
                        s.lengthlist[i] = (byte)length;
                    length++;
                }
                break;

            default:
                return null;
            }

            // Do we have a mapping to unpack?
            switch((s.maptype = input.ReadBits (4)))
            {
            case 0: // no mapping
                break;

            case 1: case 2:
                // implicitly populated value mapping
                // explicitly populated value mapping

                s.q_min = input.ReadInt32();
                s.q_delta = input.ReadInt32();
                s.q_quant = input.ReadBits (4) + 1;
                s.q_sequencep = input.ReadBits (1);
                if (-1 == s.q_sequencep)
                    return null;
                int quantvals = 0;
                switch (s.maptype)
                {
                case 1:
                    quantvals = s.dim == 0 ? 0 : s.Maptype1Quantvals();
                    break;
                case 2:
                    quantvals = s.entries * s.dim;
                    break;
                }

                // quantized values
                s.quantlist = new int[quantvals];
                for (int i = 0; i < quantvals; ++i)
                    s.quantlist[i] = input.ReadBits (s.q_quant);

                if (quantvals > 0 && s.quantlist[quantvals-1] == -1)
                    return null;
                break;

            default: // EOF
                return null;
            }

            // all set
            return s;
        }

        VorbisInfoFloor UnpackFloor0 (OggBitStream input)
        {
            var info = new VorbisInfoFloor();
            int order = input.ReadBits (8);
            int rate = input.ReadBits (16);
            int barkmap = input.ReadBits (16);
            int ampbits = input.ReadBits (6);
            int ampdB = input.ReadBits (8);
            int numbooks = input.ReadBits (4) + 1;

            if (order < 1 || rate < 1 || barkmap < 1 || numbooks < 1)
                return null;

            for (int j = 0; j < numbooks; ++j)
            {
                int books = input.ReadByte();
                if (books < 0 || books >= CodecSetup.Books)
                    return null;
            }
            return info;
        }

        VorbisInfoFloor UnpackFloor1 (OggBitStream input)
        {
            int max_class = -1;

            var info = new VorbisInfoFloor();
            // read partitions
            int partitions = input.ReadBits (5); // only 0 to 31 legal
            var partition_class = new int[partitions];
            for (int j = 0; j < partitions; ++j)
            {
                partition_class[j] = input.ReadBits (4); // only 0 to 15 legal
                if (partition_class[j] < 0)
                    return null;
                if (max_class < partition_class[j])
                    max_class = partition_class[j];
            }

            // read partition classes
            var class_dim = new int[max_class+1];
            for (int j = 0; j < max_class+1; ++j)
            {
                class_dim[j] = input.ReadBits (3) + 1; // 1 to 8
                int class_subs = input.ReadBits (2); // 0,1,2,3 bits
                if (class_subs < 0)
                    return null;
                if (class_subs > 0)
                    input.ReadBits (8); // class_book
                for (int k = 0; k < (1 << class_subs); ++k)
                {
                    int class_subbook = input.ReadBits (8) - 1; // info.class_subbook[j][k]
                }
            }

            // read the post list
            int mult = input.ReadBits (2) + 1;     // only 1,2,3,4 legal now
            int rangebits = input.ReadBits (4);
            if (rangebits < 0)
                return null;

            int count = 0;
//            var postlist = new int[VorbisInfoFloor.Posit + 2];
            for (int j = 0, k = 0; j < partitions; ++j)
            {
                count += class_dim[partition_class[j]];
                if (count > VorbisInfoFloor.Posit)
                    return null;
                for (; k < count; ++k)
                {
                    int t = input.ReadBits (rangebits);
                    if (t < 0 || t >= (1 << rangebits))
                        return null;
//                    postlist[k+2] = t;
                }
            }
//            postlist[0] = 0;
//            postlist[1] = 1<<rangebits;

            // don't allow repeated values in post list as they'd result in
            // zero-length segments
            /*
            var indices = Enumerable.Range (0, count+2).OrderBy (i => postlist[i]).ToArray();
            for (int j = 1; j < count+2; j++)
                if(postlist[indices[j-1]] == postlist[indices[j]])
                    return null;
            */
            return info;
        }

        object UnpackResidue (OggBitStream input)
        {
            var info = new VorbisInfoResidue();

            info.begin = input.ReadBits (24);
            info.end = input.ReadBits (24);
            info.grouping = input.ReadBits (24) + 1;
            info.partitions = input.ReadBits (6) + 1;
            info.groupbook = input.ReadBits (8);

            // check for premature EOP
            if (info.groupbook < 0)
                return null;

            int acc = 0;
            for (int j = 0; j < info.partitions; ++j)
            {
                int cascade = input.ReadBits (3);
                int cflag = input.ReadBits (1);
                if (cflag < 0)
                    return null;
                if (cflag > 0)
                {
                    int c = input.ReadBits (5);
                    if (c < 0)
                        return null;
                    cascade |= c << 3;
                }
                // info.secondstages[j] = cascade;

                acc += CountSetBits ((uint)cascade);
            }
            for (int j = 0; j < acc; ++j)
            {
                int book = input.ReadBits (8);
                if (book < 0)
                    return null;
                if (book >= CodecSetup.Books)
                    return null;
//                if (CodecSetup.book_param[book].maptype == 0) return null;
//                info.booklist[j] = book;
            }
            if (info.groupbook >= CodecSetup.Books)
                return null;

            /*
            int entries = CodecSetup.book_param[info.groupbook].entries;
            int dim = CodecSetup.book_param[info.groupbook].dim;
            int partvals = 1;
            if (dim < 1)
                return null;
            while (dim > 0)
            {
                partvals *= info.partitions;
                if (partvals > entries)
                    return null;
                dim--;
            }
            info.partvals = partvals;
            */
            return info;
        }

        VorbisInfoMapping UnpackMapping (OggBitStream input)
        {
            var info = new VorbisInfoMapping();

            int b = input.ReadBits (1);
            if (b < 0)
                return null;
            if (b > 0)
            {
                info.submaps = input.ReadBits (4) + 1;
                if (info.submaps <= 0)
                    return null;
            }
            else
                info.submaps = 1;

            b = input.ReadBits (1);
            if (b < 0)
                return null;
            if (b > 0)
            {
                info.coupling_steps = input.ReadBits (8) + 1;
                if (info.coupling_steps <= 0)
                    return null;
                for (int i = 0; i < info.coupling_steps; ++i)
                {
                    int bits = CountBits ((uint)Channels);
                    int testM = input.ReadBits (bits);
                    int testA = input.ReadBits (bits);
                    if (testM < 0 || testA < 0 || testM == testA
                        || testM >= Channels || testA >= Channels)
                        return null;
                }
            }

            if (input.ReadBits (2) != 0)
                return null;

            if (info.submaps > 1)
            {
                for (int i = 0; i < Channels; ++i)
                {
                    int chmuxlist = input.ReadBits (4);
                    if (chmuxlist >= info.submaps || chmuxlist < 0)
                        return null;
                }
            }
            for (int i = 0; i < info.submaps; ++i)
            {
                input.ReadByte(); // time submap unused
                int floorsubmap = input.ReadByte();
                if (floorsubmap >= CodecSetup.Floors || floorsubmap < 0)
                    return null;
                int residuesubmap = input.ReadByte();
                if (residuesubmap >= CodecSetup.Residues || residuesubmap < 0)
                    return null;
            }
            return info;
        }

        internal static InvalidDataException InvalidHeader ()
        {
            return new InvalidDataException ("Invalid header in Ogg/Vorbis stream.");
        }
    }

    // struct vorbis_comment
    // https://xiph.org/vorbis/doc/libvorbis/vorbis_comment.html
    class VorbisComment
    {
        public List<byte[]> Comments;
        public byte[]       Vendor;

        internal static readonly byte[] EncodeVendorString = Encoding.UTF8.GetBytes ("mørkt GARbro 20170407");

        public VorbisComment ()
        {
            Comments = new List<byte[]>();
        }

        // https://xiph.org/vorbis/doc/libvorbis/vorbis_commentheader_out.html
        public void HeaderOut (OggPacket packet)
        {
            using (var buf = new MemoryStream())
            using (var output = new BinaryWriter (buf))
            {
                // preamble
                output.Write ((byte)3);
                output.Write ("vorbis".ToCharArray());

                // vendor
                output.Write (EncodeVendorString.Length);
                output.Write (EncodeVendorString);

                // comments
                output.Write (Comments.Count);
                foreach (var comment in Comments)
                {
                    if (comment != null && comment.Length > 0)
                    {
                        output.Write (comment.Length);
                        output.Write (comment);
                    }
                    else
                    {
                        output.Write (0);
                    }
                }
                output.Write ((byte)1);
                output.Flush();

                packet.SetPacket (1, buf.ToArray());
                packet.BoS = false;
                packet.EoS = false;
                packet.GranulePos = 0;
            }
        }

        internal void UnpackComment (OggBitStream input)
        {
            int vendor_len = input.ReadInt32();
            if (vendor_len < 0)
                throw VorbisInfo.InvalidHeader();
            var vendor = input.ReadBytes (vendor_len);

            int count = input.ReadInt32();
            if (count < 0)
                throw VorbisInfo.InvalidHeader();

            var comments = new List<byte[]> (count);
            for (int i = 0; i < count; ++i)
            {
                int len = input.ReadInt32();
                if (len < 0)
                    throw VorbisInfo.InvalidHeader();
                var bytes = input.ReadBytes (len);
                comments.Add (bytes);
            }
            if (input.ReadBits (1) != 1)
                throw VorbisInfo.InvalidHeader();

            this.Vendor = vendor;
            this.Comments = comments;
        }
    }

    // codec_setup_info
    class CodecSetupInfo
    {
        public int[]    BlockSizes = new int[2];

        public int      Modes;
        public int      Maps;
        public int      Floors;
        public int      Residues;
        public int      Books;

        internal VorbisInfoMode[]   ModeParam = new VorbisInfoMode[64];
        internal int[]              ResidueType = new int[64];
        internal object[]           ResidueParam = new object[64];
        internal int[]              FloorType = new int[64];
        internal object[]           FloorParam = new object[64];
        internal int[]              MapType = new int[64];
        internal VorbisInfoMapping[] MapParam = new VorbisInfoMapping[64];
        internal StaticCodebook[]   BookParam = new StaticCodebook[256];
    }

    // struct vorbis_info_mode
    struct VorbisInfoMode
    {
        public int  BlockFlag;
        public int  WindowType;
        public int  TransformType;
        public int  Mapping;
    }

    // struct static_codebook
    class StaticCodebook
    {
        public int      dim;        // codebook dimensions (elements per vector)
        public int      entries;    // codebook entries
        public byte[]   lengthlist; // codeword lengths in bits

        // mapping ***************************************************************
        public int      maptype;    // 0=none
                                    // 1=implicitly populated values from map column
                                    // 2=listed arbitrary values

        // The below does a linear, single monotonic sequence mapping.
        public int      q_min;      // packed 32 bit float; quant value 0 maps to minval
        public int      q_delta;    // packed 32 bit float; val 1 - val 0 == delta
        public int      q_quant;    // bits: 0 < quant <= 16
        public int      q_sequencep; // bitflag

        public int[]    quantlist;  // map == 1: (int)(entries^(1/dim)) element column map
                                    // map == 2: list of dim*entries quantized entry vals

        internal int Maptype1Quantvals ()
        {
            int vals = (int)Math.Floor (Math.Pow ((float)entries, 1.0f / dim));

            // the above *should* be reliable, but we'll not assume that FP is
            // ever reliable when bitstream sync is at stake; verify via integer
            // means that vals really is the greatest value of dim for which
            // vals^b->bim <= b->entries.
            // treat the above as an initial guess
            for (;;)
            {
                int acc = 1;
                int acc1 = 1;
                for (int i = 0; i < dim; ++i)
                {
                    acc *= vals;
                    acc1 *= vals+1;
                }
                if (acc <= entries && acc1 > entries)
                    break;
                if (acc > entries)
                    vals--;
                else
                    vals++;
            }
            return vals;
        }
    }

    class VorbisInfoMapping
    {
        public int  submaps;
        public int  coupling_steps;
    }

    class VorbisInfoFloor
    {
        public const int Posit = 63;
    }

    class VorbisInfoResidue
    {
        public int  begin;
        public int  end;
        public int  grouping;
        public int  partitions;
        public int  groupbook;
    }
}