src/Ryujinx.Graphics.Texture/Astc/BitStream128.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

using Ryujinx.Common.Utilities;
using System;
using System.Diagnostics;

namespace Ryujinx.Graphics.Texture.Astc
{
    public struct BitStream128
    {
#pragma warning disable IDE0044 // Make field readonly
        private Buffer16 _data;
#pragma warning restore IDE0044
        public int BitsLeft { get; set; }

        public BitStream128(Buffer16 data)
        {
            _data = data;
            BitsLeft = 128;
        }

        public int ReadBits(int bitCount)
        {
            Debug.Assert(bitCount < 32);

            if (bitCount == 0)
            {
                return 0;
            }

            int mask = (1 << bitCount) - 1;
            int value = _data.As<int>() & mask;

            Span<ulong> span = _data.AsSpan<ulong>();

            ulong carry = span[1] << (64 - bitCount);
            span[0] = (span[0] >> bitCount) | carry;
            span[1] >>= bitCount;

            BitsLeft -= bitCount;

            return value;
        }

        public void WriteBits(int value, int bitCount)
        {
            Debug.Assert(bitCount < 32);

            if (bitCount == 0)
            {
                return;
            }

            ulong maskedValue = (uint)(value & ((1 << bitCount) - 1));

            Span<ulong> span = _data.AsSpan<ulong>();

            if (BitsLeft < 64)
            {
                ulong lowMask = maskedValue << BitsLeft;
                span[0] |= lowMask;
            }

            if (BitsLeft + bitCount > 64)
            {
                if (BitsLeft > 64)
                {
                    span[1] |= maskedValue << (BitsLeft - 64);
                }
                else
                {
                    span[1] |= maskedValue >> (64 - BitsLeft);
                }
            }

            BitsLeft += bitCount;
        }
    }
}