Index: lucene/facet/src/java/org/apache/lucene/util/encoding/PackedIntEncoder.java
===================================================================
--- lucene/facet/src/java/org/apache/lucene/util/encoding/PackedIntEncoder.java	(revision 0)
+++ lucene/facet/src/java/org/apache/lucene/util/encoding/PackedIntEncoder.java	(working copy)
@@ -0,0 +1,181 @@
+package org.apache.lucene.util.encoding;
+
+import java.util.Arrays;
+
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.IntsRef;
+import org.apache.lucene.util.packed.PackedInts;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public final class PackedIntEncoder extends IntEncoder {
+
+  static final int[] MASK = new int[32];
+  static {
+    int upto = 2;
+    for(int i=1;i<32;i++) {
+      MASK[i] = upto-1;
+      upto *= 2;
+    }
+  }
+  
+
+  @Override
+  public void encode(IntsRef values, BytesRef buf) {
+    int maxValue = 0;
+    for (int i = 0; i < values.length; ++i) {
+      final int v = values.ints[values.offset + i];
+      assert v >= 0;
+      maxValue = Math.max(maxValue, v);
+    }
+    final int bitsPerValue = PackedInts.bitsRequired(maxValue);
+    buf.offset = 0;
+    buf.length = 1 + (values.length * bitsPerValue + 7) / 8;
+    if (buf.bytes.length < buf.length) {
+      buf.bytes = new byte[ArrayUtil.oversize(buf.length, 1)];
+    }
+    int leftoverBits = 8*(buf.length - 1) - (values.length * bitsPerValue);
+    assert leftoverBits < 8;
+    Arrays.fill(buf.bytes, (byte) 0);
+
+    buf.bytes[0] = (byte) ((bitsPerValue << 3) | leftoverBits);
+    /*
+    System.out.println("encode bpv=" + bitsPerValue + " leftoverBits=" + leftoverBits + " inputCount=" + values.length + " outputBytes=" + buf.length);
+    for(int i=0;i<values.length;i++) {
+      System.out.println("  v=" + values.ints[values.offset+i]);
+    }
+    */
+
+    int inputUpto = values.offset;
+    final int end = values.offset + values.length;
+    int outputUpto = 1;
+
+    int inputBitsLeft = bitsPerValue;
+    int outputBitsLeft = 8;
+
+    while (inputUpto < end) {
+      int numBitsToMove = Math.min(inputBitsLeft, outputBitsLeft);
+      //System.out.println("  cycle inputUpto=" + (inputUpto-values.offset) + " outputUpto=" + (outputUpto-1) + " inputBits=" + inputBitsLeft + " outputBits=" + outputBitsLeft + " move=" + numBitsToMove + " mask=" + Integer.toHexString(MASK[numBitsToMove]));
+      assert numBitsToMove > 0;
+      byte frag = (byte) (values.ints[inputUpto] >>> (bitsPerValue - inputBitsLeft) & MASK[numBitsToMove]);
+      // System.out.println("    frag=" + Integer.toHexString(frag & 0xff));
+      buf.bytes[outputUpto] |= frag << (8-outputBitsLeft);
+      //System.out.println("      out=" + Integer.toHexString(buf.bytes[outputUpto]&0xff));
+      inputBitsLeft -= numBitsToMove;
+      if (inputBitsLeft == 0) {
+        inputUpto++;
+        inputBitsLeft = bitsPerValue;
+        if (inputUpto < end) {
+          //System.out.println("    adv input v=" + Integer.toHexString(values.ints[inputUpto]));
+        }
+      }
+      outputBitsLeft -= numBitsToMove;
+      if (outputBitsLeft == 0) {
+        outputUpto++;
+        outputBitsLeft = 8;
+        //System.out.println("    adv output v=" + Integer.toHexString(buf.bytes[outputUpto-1]&0xff));
+      }
+    }
+  }
+
+  @Override
+  public IntDecoder createMatchingDecoder() {
+    return new IntDecoder() {
+      @Override
+      public void decode(BytesRef buf, IntsRef values) {
+        final int bitsPerValue = (buf.bytes[buf.offset]&0xff) >>> 3;
+        final int leftoverBits = buf.bytes[buf.offset] & 7;
+        //System.out.println("decode buf.offset=" + buf.offset + " bpv=" + bitsPerValue + " leftoverBits=" + leftoverBits + " inputBytes=" + buf.length + " bytes[0]=" + Integer.toHexString(buf.bytes[buf.offset] & 0xFF));
+
+        assert bitsPerValue > 0 && bitsPerValue < 32;
+        assert ((((buf.length-1) * 8) - leftoverBits) % bitsPerValue) == 0;
+
+        values.length = (((buf.length-1) * 8) - leftoverBits)/bitsPerValue;
+        if (values.ints.length < values.length) {
+          values.ints = new int[ArrayUtil.oversize(values.length, 4)];
+        }
+        values.offset = 0;
+
+        int outputUpto = 0;
+        int outputBitsLeft = bitsPerValue;
+        int inputUpto = buf.offset + 1;
+        int inputBitsLeft = 8;
+        int pending = 0;
+        byte pendingInput = buf.bytes[inputUpto];
+        
+        while (true) {
+          if (outputBitsLeft > inputBitsLeft) {
+            byte frag = (byte) (pendingInput >>> (8 - inputBitsLeft) & MASK[inputBitsLeft]);
+            pending |= (frag&0xff) << (bitsPerValue-outputBitsLeft);
+            outputBitsLeft -= inputBitsLeft;
+            inputUpto++;
+            pendingInput = buf.bytes[inputUpto];
+            inputBitsLeft = 8;
+          } else {
+            byte frag = (byte) (pendingInput >>> (8 - inputBitsLeft) & MASK[outputBitsLeft]);
+            pending |= (frag&0xff) << (bitsPerValue-outputBitsLeft);
+
+            values.ints[outputUpto++] = pending;
+            if (outputUpto == values.length) {
+              break;
+            }
+            pending = 0;
+            inputBitsLeft -= outputBitsLeft;
+            if (inputBitsLeft == 0) {
+              inputUpto++;
+              pendingInput = buf.bytes[inputUpto];
+              inputBitsLeft = 8;
+            }
+
+            outputBitsLeft = bitsPerValue;
+          }
+
+          /*
+          int numBitsToMove = Math.min(inputBitsLeft, outputBitsLeft);
+          assert numBitsToMove > 0;
+          byte frag = (byte) (pendingInput >>> (8 - inputBitsLeft) & MASK[numBitsToMove]);
+          pending |= (frag&0xff) << (bitsPerValue-outputBitsLeft);
+
+          outputBitsLeft -= numBitsToMove;
+          if (outputBitsLeft == 0) {
+            values.ints[outputUpto++] = pending;
+            if (outputUpto == values.length) {
+              break;
+            }
+            pending = 0;
+            outputBitsLeft = bitsPerValue;
+          }
+
+          inputBitsLeft -= numBitsToMove;
+          if (inputBitsLeft == 0) {
+            inputUpto++;
+            pendingInput = buf.bytes[inputUpto];
+            inputBitsLeft = 8;
+          }
+          */
+        }
+      }
+    };
+  }
+  
+  @Override
+  public String toString() {
+    return "Packed";
+  }
+}

Property changes on: lucene/facet/src/java/org/apache/lucene/util/encoding/PackedIntEncoder.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: lucene/facet/src/test/org/apache/lucene/util/encoding/EncodingTest.java
===================================================================
--- lucene/facet/src/test/org/apache/lucene/util/encoding/EncodingTest.java	(revision 1434110)
+++ lucene/facet/src/test/org/apache/lucene/util/encoding/EncodingTest.java	(working copy)
@@ -68,7 +68,11 @@
       // run 2 iterations to catch encoders/decoders which don't reset properly
       encoding(encoder, data, bytes);
       decoding(bytes, values, encoder.createMatchingDecoder());
-      assertTrue(expected.intsEquals(values));
+      assertEquals(expected.length, values.length);
+      for(int j=0;j<expected.length;j++) {
+        //System.out.println("  check values[" + j + "]: " + expected.ints[expected.offset+j]);
+        assertEquals("index=" + j, expected.ints[expected.offset+j], values.ints[values.offset+j]);
+      }
     }
   }
 
@@ -156,4 +160,8 @@
     encoderTest(new SortingIntEncoder(new UniqueValuesIntEncoder(new DGapVInt8IntEncoder())), data, uniqueSortedData);
   }
 
+  @Test
+  public void testSortingUniqueDGapPackedInt() throws Exception {
+    encoderTest(new SortingIntEncoder(new UniqueValuesIntEncoder(new DGapIntEncoder(new PackedIntEncoder()))), data, uniqueSortedData);
+  }
 }