How do you pack three 4 bit signed integers (so 5 bits) into a single 16 bit integer?

Question

I want to pack 3 signed 4 bit integers (4 bits data, 1 bit sign bit) into one 16 bit integer, but I have no idea how to do it or where to start :(

I need this to represent a position in a 3D grid in as little data as possible (Since with higher grid sizes, it REALLY adds up). If it helps, I'm using GLM (OpenGL Mathematics Library, So I have access to functions such as glm::sign())

If possible, please give me the code to pack and unpack it.

Thankyou

Maybe this will set you on your way : https://en.cppreference.com/w/cpp/language/bit_field... well might be tricky too : https://stackoverflow.com/questions/28091060/sizeof-pragma-packed-bitfield-struct-array — Pepijn Kramer, Aug 25 '21 at 17:00
@PepijnKramer: Bit-fields are not generally suitable for packing and unpacking bits, because the C standard does not define the order they are packed into storage units, the storage units used for them, or whether they straddle storage units or are padded. They can be used for this purpose when using a specific compiler that documents the necessary behaviors, but it is not generally portable code. Proper methods for bit-packing simply use shifts and bitwise operators. — Eric Postpischil, Aug 25 '21 at 17:03
@Eric, yeah I just found out that it's implementation specific. — Pepijn Kramer, Aug 25 '21 at 17:04
Bit shifting and masking. Unpacking looks like `n & 0b11111`, `(n >> 5) & 0b11111`, etc. — Shawn, Aug 25 '21 at 17:06
Do you want twos-complement, sign-magnitude, or something else? — Nate Eldredge, Aug 25 '21 at 17:18
@NateEldredge I need to pack 3 positions into as little data as possible, since the memory footprint increases rapidly as the size of a 3D volume increases — Samuel Wesley, Aug 25 '21 at 17:26
@PepijnKramer Yes, I want to use shifts and bitwise operations, I just dont know how to do it well, I just need packing and unpacking code — Samuel Wesley, Aug 25 '21 at 17:27
duplicates: [How to pack data in binary format in c++](https://stackoverflow.com/q/8887364/995714), [Bit Manipulation to store multiple values in one int C++](https://stackoverflow.com/q/43769622/995714) — phuclv, Aug 26 '21 at 02:10

score 11 · Answer 1 · answered Aug 25 '21 at 18:17

struct s {
   int16_t x : 5;
   int16_t y : 5;
   int16_t z : 5;
};
static_assert (sizeof(s) == sizeof(int16_t));

The packing and unpacking is automatic: just use it like any other struct. E.g. given s val;, val.x=-17; packs and foo(val.z); unpacks.

This is fine for when you want to cram stuff together for use within the program itself, but not for documented interchange such as file formats, since (as comments have noted) how it packs is implementation defined.

Furthermore, the static_assert will ensure it really did what you intended, using only one word for all the fields. All compilers I've ever heard of for conventional platforms will pack as expected.

3Dave · Accepted Answer · 2021-08-26T02:05:17.567

@JDługosz 's answer is great if you're on a platform that supports that struct syntax. However, you mention OpenGL.

Here's a version that will work in a shader.

Basically, test the sign in a platform-agnostic way, set a bit for that (1 for negative, 0 for positive), add the lower four bits of the int you want to pack, then shift the result over by five bits to make room for the next value.

Since you're dealing with values from -15 to +15, you can simplify things a bit. Rather than checking the sign, just add a constant to the value to force it to be positive. (Though, I'd recommend adding an assert on the packing side to make sure that input values will actually fit within 4 bits.) When unpacking, subtract that constant.

TL;DR: Convert your input into a positive integer, grab the lower 5 bits, and mask/shift/add.

int pack3 (int a, int b, int c)
{
    a = (a + 16) & 0x1F;
    b = (b + 16) & 0x1F;
    c = (c + 16) & 0x1F;

    return (a << 10) | (b << 5) | c;
}

void unpack3 (int p, int &a, int &b, int &c)
{ 
  // The 3 mask & subtraction ops could be done in one step on P, but
  // I left them separate here for something resembling clarity. 
  c = (p & 0x1f) - 16;
  b = ((p >> 5) & 0x1f) - 16;
  a = ((p >> 10) & 0x1f) - 16;
}

For a shader implementation, unpack3() will need to replace & references with inout or equivalent for your shader model & language.

See it working with a test driver here.

@SamuelWesley I was thinking about this some more. If you've only got 5 bits available on each axis, you *might* be better off just creating an array to hold everything. 32*32*32 = 32k; pretty small relatively speaking. Sample that in your shader rather than worrying about this sort of calculation & packing. — 3Dave, Aug 27 '21 at 16:36

How do you pack three 4 bit signed integers (so 5 bits) into a single 16 bit integer?

2 Answers2