Packing and Unpacking BITS from a SHORT

Question

Hello everyone,
I am have six pieces of data packed into a 16bit short value and I am wondering if my code to pack and unpack the short looks right to everyone else. The six smaller values that I am pulling out of the short are of the length (in order) 2+2+3+3+3+3 bits . My approach to unpacking the short is applying a bitmask to isolate just the sub-value I want, then using the bitwise-left shift ( << operator) to move that value to the 0-position in the short, then casting the value to a byte for use in my program. The code to do that looks something like this:
public final short maskValue1 = Short.parseShort("0000000000000011", 2);
public final short maskValue2 = Short.parseShort("0000000000001100", 2);
public final short maskValue3 = Short.parseShort("0000000001110000", 2);
public final short maskValue4 = Short.parseShort("0000001110000000", 2);
public final short maskValue5 = Short.parseShort("0001110000000000", 2);
public final short maskValue6 = Short.parseShort("111000000000000", 2);
     public void unpackEncodedMap(short map, byte[] outMap) {
          outMap[0] = (byte)((map & maskValue1) << 14);
          outMap[1] = (byte)((map & maskValue2) << 12);
          outMap[2] = (byte)((map & maskValue3) << 9);
          outMap[3] = (byte)((map & maskValue4) << 6);
          outMap[4] = (byte)((map & maskValue5) << 3);
          outMap[5] = (byte)(map & maskValue6);
The approach I use to encode the short value involves taking my input byte array and casting each into a short. Then I use the bitwise-right shift operator ( >> ) to move the bit value into the appropriate position. To apply the next byte-value I bitwise-OR the previous value onto the new mask. The values in the byte-array are assured not to be greater then their sub-value bit lengths ... so the downcast is all right. Here is my code to do the packing:
     public short encodeMap(byte[] mymap) {
          short out = (short)(((short)mymap[0]) >> 2);
          out = (short)((out | ((short)mymap[1])) >> 2);
          out = (short)((out | ((short)mymap[2])) >> 3);
          out = (short)((out | ((short)mymap[3])) >> 3);
          out = (short)((out | ((short)mymap[4])) >> 3);
          out = (short)(out | ((short)mymap[5]));
          return out;
Thanks for looking at my functions and point out any inconsistencies. I feel like there is something I am not seeing in my code. Thanks!

Answer 1

Well...thanks for the one-line answer :) yes, in the sense that it compiles and runs, but I am not sure if there is a problem with my logic or not.My program is acting strange and I am trying to isolate my problem, I think the problem might be in my pack/unpack methods.... possibly in my bit-math.