Entropy coding for hybrid transform

Separates the entropy coding context models for 4x4, 8x8 and 16x16
ADST variants.

There is a small improvement for HD (hd/std-hd) by about 0.1-0.2%.
Results on derf/yt are about the same, probably because there is not
enough statistics.

Results may improve somewhat once the initial probability tables are
updated for the hybrid transforms which is coming soon.

Change-Id: Ic7c0c62dacc68ef551054fdb575be8b8507d32a8

diff --git a/vp8/common/default_coef_probs.h b/vp8/common/default_coef_probs.h
index 3fcacb278934c879296bfb75b06d41dd3cf5f244..717cef78bca99ad00b536b4a91f2ce1e2f79d089 100644 (file)
--- a/vp8/common/default_coef_probs.h
+++ b/vp8/common/default_coef_probs.h
@@ -253,11 +253,492 @@ static const vp8_prob default_coef_probs [BLOCK_TYPES]
     }
   }
 };
+
+#if CONFIG_HYBRIDTRANSFORM
+static const vp8_prob default_hybrid_coef_probs [BLOCK_TYPES]
+[COEF_BANDS]
+[PREV_COEF_CONTEXTS]
+[ENTROPY_NODES] = {
+  {
+    /* Block Type ( 0 ) */
+    {
+      /* Coeff Band ( 0 )*/
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 1 )*/
+      { 253, 136, 254, 255, 228, 219, 128, 128, 128, 128, 128 },
+      { 189, 129, 242, 255, 227, 213, 255, 219, 128, 128, 128 },
+      { 106, 126, 227, 252, 214, 209, 255, 255, 128, 128, 128 },
+      { 90, 116, 227, 252, 214, 209, 255, 255, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 2 )*/
+      {   1,  98, 248, 255, 236, 226, 255, 255, 128, 128, 128 },
+      { 181, 133, 238, 254, 221, 234, 255, 154, 128, 128, 128 },
+      {  78, 134, 202, 247, 198, 180, 255, 219, 128, 128, 128 },
+      {  64, 128, 202, 247, 198, 180, 255, 219, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 3 )*/
+      {   1, 185, 249, 255, 243, 255, 128, 128, 128, 128, 128 },
+      { 184, 150, 247, 255, 236, 224, 128, 128, 128, 128, 128 },
+      {  77, 110, 216, 255, 236, 230, 128, 128, 128, 128, 128 },
+      {  64, 100, 216, 255, 236, 230, 128, 128, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 4 )*/
+      {   1, 101, 251, 255, 241, 255, 128, 128, 128, 128, 128 },
+      { 170, 139, 241, 252, 236, 209, 255, 255, 128, 128, 128 },
+      {  37, 116, 196, 243, 228, 255, 255, 255, 128, 128, 128 },
+      {  28, 110, 196, 243, 228, 255, 255, 255, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 5 )*/
+      {   1, 204, 254, 255, 245, 255, 128, 128, 128, 128, 128 },
+      { 207, 160, 250, 255, 238, 128, 128, 128, 128, 128, 128 },
+      { 102, 103, 231, 255, 211, 171, 128, 128, 128, 128, 128 },
+      { 90, 90, 231, 255, 211, 171, 128, 128, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 6 )*/
+      {   1, 152, 252, 255, 240, 255, 128, 128, 128, 128, 128 },
+      { 177, 135, 243, 255, 234, 225, 128, 128, 128, 128, 128 },
+      {  80, 129, 211, 255, 194, 224, 128, 128, 128, 128, 128 },
+      {  64, 120, 211, 255, 194, 224, 128, 128, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 7 )*/
+      {   1,   1, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 246,   1, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 255, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 255, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+    }
+  },
+  {
+    /* Block Type ( 1 ) */
+    {
+      /* Coeff Band ( 0 )*/
+      { 198,  35, 237, 223, 193, 187, 162, 160, 145, 155,  62 },
+      { 131,  45, 198, 221, 172, 176, 220, 157, 252, 221,   1 },
+      {  68,  47, 146, 208, 149, 167, 221, 162, 255, 223, 128 },
+      {  48,  32, 146, 208, 149, 167, 221, 162, 255, 223, 128 },
+    },
+    {
+      /* Coeff Band ( 1 )*/
+      {   1, 149, 241, 255, 221, 224, 255, 255, 128, 128, 128 },
+      { 184, 141, 234, 253, 222, 220, 255, 199, 128, 128, 128 },
+      {  81,  99, 181, 242, 176, 190, 249, 202, 255, 255, 128 },
+      {  66,  90, 181, 242, 176, 190, 249, 202, 255, 255, 128 },
+    },
+    {
+      /* Coeff Band ( 2 )*/
+      {   1, 129, 232, 253, 214, 197, 242, 196, 255, 255, 128 },
+      {  99, 121, 210, 250, 201, 198, 255, 202, 128, 128, 128 },
+      {  23,  91, 163, 242, 170, 187, 247, 210, 255, 255, 128 },
+      {  18,  80, 163, 242, 170, 187, 247, 210, 255, 255, 128 },
+    },
+    {
+      /* Coeff Band ( 3 )*/
+      {   1, 200, 246, 255, 234, 255, 128, 128, 128, 128, 128 },
+      { 109, 178, 241, 255, 231, 245, 255, 255, 128, 128, 128 },
+      {  44, 130, 201, 253, 205, 192, 255, 255, 128, 128, 128 },
+      {  36, 120, 201, 253, 205, 192, 255, 255, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 4 )*/
+      {   1, 132, 239, 251, 219, 209, 255, 165, 128, 128, 128 },
+      {  94, 136, 225, 251, 218, 190, 255, 255, 128, 128, 128 },
+      {  22, 100, 174, 245, 186, 161, 255, 199, 128, 128, 128 },
+      {  18, 90, 174, 245, 186, 161, 255, 199, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 5 )*/
+      {   1, 182, 249, 255, 232, 235, 128, 128, 128, 128, 128 },
+      { 124, 143, 241, 255, 227, 234, 128, 128, 128, 128, 128 },
+      {  35,  77, 181, 251, 193, 211, 255, 205, 128, 128, 128 },
+      {  28,  70, 181, 251, 193, 211, 255, 205, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 6 )*/
+      {   1, 157, 247, 255, 236, 231, 255, 255, 128, 128, 128 },
+      { 121, 141, 235, 255, 225, 227, 255, 255, 128, 128, 128 },
+      {  45,  99, 188, 251, 195, 217, 255, 224, 128, 128, 128 },
+      {  40,  90, 188, 251, 195, 217, 255, 224, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 7 )*/
+      {   1,   1, 251, 255, 213, 255, 128, 128, 128, 128, 128 },
+      { 203,   1, 248, 255, 255, 128, 128, 128, 128, 128, 128 },
+      { 137,   1, 177, 255, 224, 255, 128, 128, 128, 128, 128 },
+      { 137,   1, 177, 255, 224, 255, 128, 128, 128, 128, 128 },
+    }
+  },
+  {
+    /* Block Type ( 2 ) */
+    {
+      /* Coeff Band ( 0 )*/
+      { 253,   9, 248, 251, 207, 208, 255, 192, 128, 128, 128 },
+      { 175,  13, 224, 243, 193, 185, 249, 198, 255, 255, 128 },
+      {  73,  17, 171, 221, 161, 179, 236, 167, 255, 234, 128 },
+      {  64,  17, 171, 221, 161, 179, 236, 167, 255, 234, 128 },
+    },
+    {
+      /* Coeff Band ( 1 )*/
+      {   1,  95, 247, 253, 212, 183, 255, 255, 128, 128, 128 },
+      { 239,  90, 244, 250, 211, 209, 255, 255, 128, 128, 128 },
+      { 155,  77, 195, 248, 188, 195, 255, 255, 128, 128, 128 },
+      { 140,  70, 195, 248, 188, 195, 255, 255, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 2 )*/
+      {   1,  24, 239, 251, 218, 219, 255, 205, 128, 128, 128 },
+      { 201,  51, 219, 255, 196, 186, 128, 128, 128, 128, 128 },
+      {  69,  46, 190, 239, 201, 218, 255, 228, 128, 128, 128 },
+      {  60,  40, 190, 239, 201, 218, 255, 228, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 3 )*/
+      {   1, 191, 251, 255, 255, 128, 128, 128, 128, 128, 128 },
+      { 223, 165, 249, 255, 213, 255, 128, 128, 128, 128, 128 },
+      { 141, 124, 248, 255, 255, 128, 128, 128, 128, 128, 128 },
+      { 132, 118, 248, 255, 255, 128, 128, 128, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 4 )*/
+      {   1,  16, 248, 255, 255, 128, 128, 128, 128, 128, 128 },
+      { 190,  36, 230, 255, 236, 255, 128, 128, 128, 128, 128 },
+      { 149,   1, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 149,   1, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 5 )*/
+      {   1, 226, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 247, 192, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 240, 128, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 240, 128, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 6 )*/
+      {   1, 134, 252, 255, 255, 128, 128, 128, 128, 128, 128 },
+      { 213,  62, 250, 255, 255, 128, 128, 128, 128, 128, 128 },
+      {  55,  93, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      {  48,  85, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 7 )*/
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
+    }
+  },
+  {
+    /* Block Type ( 3 ) */
+    {
+      /* Coeff Band ( 0 )*/
+      { 202,  24, 213, 235, 186, 191, 220, 160, 240, 175, 255 },
+      { 126,  38, 182, 232, 169, 184, 228, 174, 255, 187, 128 },
+      {  63,  48, 138, 219, 151, 178, 240, 170, 255, 216, 128 },
+      {  54,  40, 138, 219, 151, 178, 240, 170, 255, 216, 128 },
+    },
+    {
+      /* Coeff Band ( 1 )*/
+      {   1, 112, 230, 250, 199, 191, 247, 159, 255, 255, 128 },
+      { 166, 109, 228, 252, 211, 215, 255, 174, 128, 128, 128 },
+      {  44,  84, 162, 232, 172, 180, 245, 178, 255, 255, 128 },
+      {  32,  70, 162, 232, 172, 180, 245, 178, 255, 255, 128 },
+    },
+    {
+      /* Coeff Band ( 2 )*/
+      {   1,  52, 220, 246, 198, 199, 249, 220, 255, 255, 128 },
+      { 124,  74, 191, 243, 183, 193, 250, 221, 255, 255, 128 },
+      {  24,  71, 130, 219, 154, 170, 243, 182, 255, 255, 128 },
+      {  24,  71, 130, 219, 154, 170, 243, 182, 255, 255, 128 },
+    },
+    {
+      /* Coeff Band ( 3 )*/
+      {   1, 182, 225, 249, 219, 240, 255, 224, 128, 128, 128 },
+      { 149, 150, 226, 252, 216, 205, 255, 171, 128, 128, 128 },
+      {  28, 108, 170, 242, 183, 194, 254, 223, 255, 255, 128 },
+      {  26, 104, 170, 242, 183, 194, 254, 223, 255, 255, 128 },
+    },
+    {
+      /* Coeff Band ( 4 )*/
+      {   1,  81, 230, 252, 204, 203, 255, 192, 128, 128, 128 },
+      { 123, 102, 209, 247, 188, 196, 255, 233, 128, 128, 128 },
+      {  20,  95, 153, 243, 164, 173, 255, 203, 128, 128, 128 },
+      {  20,  95, 153, 243, 164, 173, 255, 203, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 5 )*/
+      {   1, 222, 248, 255, 216, 213, 128, 128, 128, 128, 128 },
+      { 168, 175, 246, 252, 235, 205, 255, 255, 128, 128, 128 },
+      {  47, 116, 215, 255, 211, 212, 255, 255, 128, 128, 128 },
+      {  47, 116, 215, 255, 211, 212, 255, 255, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 6 )*/
+      {   1, 121, 236, 253, 212, 214, 255, 255, 128, 128, 128 },
+      { 141,  84, 213, 252, 201, 202, 255, 219, 128, 128, 128 },
+      {  42,  80, 160, 240, 162, 185, 255, 205, 128, 128, 128 },
+      {  42,  80, 160, 240, 162, 185, 255, 205, 128, 128, 128 },
+    },
+    {
+      /* Coeff Band ( 7 )*/
+      {   1,   1, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 244,   1, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 238,   1, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+      { 238,   1, 255, 128, 128, 128, 128, 128, 128, 128, 128 },
+    }
+  }
+};
+#endif
+
+static const vp8_prob
+default_coef_probs_8x8[BLOCK_TYPES_8X8]
+[COEF_BANDS]
+[PREV_COEF_CONTEXTS]
+[ENTROPY_NODES] = {
+  {
+    /* block Type 0 */
+    {
+      /* Coeff Band 0 */
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 1 */
+      { 60, 140, 195, 255, 212, 214, 128, 128, 128, 128, 128},
+      { 75, 221, 231, 255, 203, 255, 128, 128, 128, 128, 128},
+      { 9, 212, 196, 251, 197, 207, 255, 185, 128, 128, 128},
+      { 9, 212, 196, 251, 197, 207, 255, 185, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 2 */
+      { 1, 227, 226, 255, 215, 215, 128, 128, 128, 128, 128},
+      { 5, 163, 209, 255, 212, 212, 255, 255, 128, 128, 128},
+      { 1, 133, 203, 255, 210, 220, 255, 255, 128, 128, 128},
+      { 1, 133, 203, 255, 210, 220, 255, 255, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 3 */
+      { 1, 226, 225, 255, 228, 236, 128, 128, 128, 128, 128},
+      { 6, 163, 208, 255, 224, 234, 255, 255, 128, 128, 128},
+      { 1, 122, 196, 253, 212, 248, 255, 255, 128, 128, 128},
+      { 1, 122, 196, 253, 212, 248, 255, 255, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 4 */
+      { 1, 222, 197, 254, 193, 216, 255, 236, 128, 128, 128},
+      { 7, 140, 163, 251, 195, 211, 255, 238, 128, 128, 128},
+      { 1, 91, 152, 249, 181, 197, 255, 239, 128, 128, 128},
+      { 1, 91, 152, 249, 181, 197, 255, 239, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 5 */
+      { 1, 226, 218, 255, 216, 241, 255, 255, 128, 128, 128},
+      { 6, 154, 191, 255, 218, 240, 255, 255, 128, 128, 128},
+      { 1, 110, 171, 252, 191, 204, 255, 236, 128, 128, 128},
+      { 1, 110, 171, 252, 191, 204, 255, 236, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 6 */
+      { 1, 221, 217, 255, 208, 217, 255, 232, 128, 128, 128},
+      { 11, 155, 189, 254, 203, 211, 255, 249, 128, 128, 128},
+      { 1, 110, 171, 252, 191, 204, 255, 236, 128, 128, 128},
+      { 1, 110, 171, 252, 191, 204, 255, 236, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 7 */
+      { 1, 207, 235, 255, 232, 240, 128, 128, 128, 128, 128},
+      { 58, 161, 216, 255, 229, 235, 255, 255, 128, 128, 128},
+      { 8, 133, 204, 255, 219, 231, 255, 255, 128, 128, 128},
+      { 8, 133, 204, 255, 219, 231, 255, 255, 128, 128, 128}
+    }
+  },
+  {
+    /* block Type 1 */
+    {
+      /* Coeff Band 0 */
+      { 134, 152, 233, 224, 234, 52, 255, 166, 128, 128, 128},
+      { 97, 132, 185, 234, 186, 189, 197, 171, 255, 212, 128},
+      { 84, 110, 185, 237, 182, 182, 145, 145, 255, 255, 128}
+    },
+    {
+      /* Coeff Band 1 */
+      { 1, 124, 213, 247, 192, 212, 255, 255, 128, 128, 128},
+      { 88, 111, 178, 254, 189, 211, 255, 255, 128, 128, 128},
+      { 12, 59, 129, 236, 150, 179, 239, 195, 255, 255, 128},
+      { 12, 59, 129, 236, 150, 179, 239, 195, 255, 255, 128}
+    },
+    {
+      /* Coeff Band 2 */
+      { 1, 102, 225, 255, 210, 240, 128, 128, 128, 128, 128},
+      { 110, 78, 195, 254, 200, 191, 255, 255, 128, 128, 128},
+      { 37, 63, 177, 255, 194, 195, 128, 128, 128, 128, 128},
+      { 37, 63, 177, 255, 194, 195, 128, 128, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 3 */
+      { 1, 1, 229, 255, 202, 224, 128, 128, 128, 128, 128},
+      { 150, 1, 192, 255, 206, 226, 128, 128, 128, 128, 128},
+      { 75, 1, 138, 255, 172, 228, 128, 128, 128, 128, 128},
+      { 75, 1, 138, 255, 172, 228, 128, 128, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 4 */
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 5 */
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 6 */
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 7 */
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    }
+  },
+  {
+    /* block Type 2 */
+    {
+      /* Coeff Band 0 */
+      { 11, 181, 226, 199, 183, 255, 255, 255, 128, 128, 128},
+      { 2, 147, 185, 248, 163, 180, 255, 236, 128, 128, 128},
+      { 1, 123, 157, 238, 154, 176, 255, 226, 255, 255, 128},
+      { 1, 123, 157, 238, 154, 176, 255, 226, 255, 255, 128}
+    },
+    {
+      /* Coeff Band 1 */
+      { 1, 150, 191, 246, 174, 188, 255, 235, 128, 128, 128},
+      { 1, 125, 166, 245, 165, 185, 255, 234, 128, 128, 128},
+      { 1, 79, 125, 240, 148, 179, 255, 234, 255, 255, 128},
+      { 1, 79, 125, 240, 148, 179, 255, 234, 255, 255, 128}
+    },
+    {
+      /* Coeff Band 2 */
+      { 1, 146, 184, 242, 167, 183, 255, 230, 255, 255, 128},
+      { 1, 119, 160, 239, 156, 178, 255, 231, 255, 255, 128},
+      { 1, 75, 115, 234, 142, 173, 255, 225, 255, 255, 128},
+      { 1, 75, 115, 234, 142, 173, 255, 225, 255, 255, 128}
+    },
+    {
+      /* Coeff Band 3 */
+      { 1, 150, 188, 244, 169, 183, 255, 233, 255, 255, 128},
+      { 1, 123, 162, 243, 161, 180, 255, 233, 128, 128, 128},
+      { 1, 76, 120, 238, 148, 178, 255, 230, 255, 255, 128},
+      { 1, 76, 120, 238, 148, 178, 255, 230, 255, 255, 128}
+    },
+    {
+      /* Coeff Band 4 */
+      { 1, 163, 202, 252, 188, 204, 255, 248, 128, 128, 128},
+      { 1, 136, 180, 251, 181, 201, 255, 246, 128, 128, 128},
+      { 1, 92, 146, 249, 170, 197, 255, 245, 128, 128, 128},
+      { 1, 92, 146, 249, 170, 197, 255, 245, 128, 128, 128}
+    },
+    {
+      /* Coeff Band 5 */
+      { 1, 156, 195, 249, 179, 193, 255, 241, 255, 255, 128},
+      { 1, 128, 169, 248, 171, 192, 255, 242, 255, 255, 128},
+      { 1, 84, 132, 245, 158, 187, 255, 240, 255, 255, 128},
+      { 1, 84, 132, 245, 158, 187, 255, 240, 255, 255, 128}
+    },
+    {
+      /* Coeff Band 6 */
+      { 1, 36, 71, 251, 192, 201, 255, 243, 255, 255, 128},
+      { 1, 49, 185, 250, 184, 199, 255, 242, 128, 128, 128},
+      { 1, 95, 147, 247, 168, 190, 255, 239, 255, 255, 128},
+      { 1, 95, 147, 247, 168, 190, 255, 239, 255, 255, 128}
+    },
+    {
+      /* Coeff Band 7 */
+      { 1, 19, 98, 255, 218, 222, 255, 255, 128, 128, 128},
+      { 36, 50, 210, 255, 212, 221, 255, 255, 128, 128, 128},
+      { 6, 117, 180, 254, 199, 216, 255, 251, 128, 128, 128},
+      { 6, 117, 180, 254, 199, 216, 255, 251, 128, 128, 128}
+    }
+  },
+#if CONFIG_HYBRIDTRANSFORM8X8
+  { /* block Type 3 */
+    { /* Coeff Band 0 */
+      { 192, 18, 155, 172, 145, 164, 192, 135, 246, 223, 255},
+      { 94, 29, 97, 131, 131, 153, 171, 121, 250, 190, 255},
+      { 25, 29, 63, 128, 119, 147, 168, 124, 251, 183, 255},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    },
+    { /* Coeff Band 1 */
+      { 1, 108, 192, 220, 186, 173, 255, 194, 255, 255, 128},
+      { 123, 104, 188, 221, 165, 171, 247, 180, 255, 255, 128},
+      { 23, 76, 152, 216, 154, 166, 226, 182, 255, 209, 128},
+      { 1, 26, 52, 162, 109, 152, 208, 144, 255, 231, 128}
+    },
+    { /* Coeff Band 2 */
+      { 1, 57, 179, 220, 156, 175, 210, 158, 255, 223, 128},
+      { 48, 57, 134, 212, 151, 170, 219, 185, 255, 248, 128},
+      { 4, 35, 63, 189, 120, 156, 221, 159, 255, 241, 128},
+      { 1, 17, 23, 110, 97, 143, 187, 120, 255, 234, 128}
+    },
+    { /* Coeff Band 3 */
+      { 1, 115, 205, 243, 182, 187, 254, 218, 255, 255, 128},
+      { 80, 101, 186, 241, 183, 186, 249, 182, 255, 255, 128},
+      { 10, 81, 144, 229, 164, 175, 241, 185, 255, 255, 128},
+      { 1, 44, 81, 192, 130, 148, 240, 180, 255, 255, 128}
+    },
+    { /* Coeff Band 4 */
+      { 1, 161, 207, 249, 187, 176, 255, 180, 128, 128, 128},
+      { 79, 148, 196, 240, 186, 182, 253, 171, 255, 255, 128},
+      { 14, 111, 171, 233, 170, 178, 235, 204, 255, 255, 128},
+      { 1, 63, 103, 202, 143, 162, 240, 178, 255, 255, 128}
+    },
+    { /* Coeff Band 5 */
+      { 1, 101, 202, 239, 185, 184, 252, 186, 255, 255, 128},
+      { 43, 67, 166, 237, 178, 190, 246, 194, 255, 255, 128},
+      { 4, 49, 85, 220, 140, 168, 253, 182, 255, 255, 128},
+      { 1, 24, 35, 144, 93, 135, 239, 159, 255, 253, 128}
+    },
+    { /* Coeff Band 6 */
+      { 1, 212, 243, 255, 240, 234, 255, 255, 128, 128, 128},
+      { 98, 168, 234, 255, 229, 234, 255, 255, 128, 128, 128},
+      { 19, 127, 199, 255, 212, 198, 255, 255, 128, 128, 128},
+      { 1, 103, 162, 253, 186, 151, 255, 255, 128, 128, 128}
+    },
+    { /* Coeff Band 7 */
+      { 1, 188, 253, 255, 255, 128, 128, 128, 128, 128, 128},
+      { 191, 68, 242, 255, 255, 128, 128, 128, 128, 128, 128},
+      { 8, 132, 255, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    }
+  }
+#endif
+};
+
+#if CONFIG_HYBRIDTRANSFORM8X8
 static const vp8_prob
-vp8_default_coef_probs_8x8[BLOCK_TYPES_8X8]
-[COEF_BANDS]
-[PREV_COEF_CONTEXTS]
-[ENTROPY_NODES] = {
+default_hybrid_coef_probs_8x8[BLOCK_TYPES_8X8]
+                                 [COEF_BANDS]
+                                 [PREV_COEF_CONTEXTS]
+                                 [ENTROPY_NODES] = {
   {
     /* block Type 0 */
     {
@@ -433,9 +914,7 @@ vp8_default_coef_probs_8x8[BLOCK_TYPES_8X8]
       { 6, 117, 180, 254, 199, 216, 255, 251, 128, 128, 128},
       { 6, 117, 180, 254, 199, 216, 255, 251, 128, 128, 128}
     }
-  }
-#if CONFIG_HYBRIDTRANSFORM8X8
-  ,
+  },
   { /* block Type 3 */
     { /* Coeff Band 0 */
       { 192, 18, 155, 172, 145, 164, 192, 135, 246, 223, 255},
@@ -486,15 +965,223 @@ vp8_default_coef_probs_8x8[BLOCK_TYPES_8X8]
       { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
     }
   }
+};
 #endif
+
+#if CONFIG_TX16X16
+static const vp8_prob
+  default_coef_probs_16x16[BLOCK_TYPES_16X16]
+                          [COEF_BANDS]
+                          [PREV_COEF_CONTEXTS]
+                          [ENTROPY_NODES] = {
+  { /* block Type 0 */
+    { /* Coeff Band 0 */
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    },
+    { /* Coeff Band 1 */
+      { 60, 140, 195, 255, 212, 214, 128, 128, 128, 128, 128},
+      { 75, 221, 231, 255, 203, 255, 128, 128, 128, 128, 128},
+      { 9, 212, 196, 251, 197, 207, 255, 185, 128, 128, 128},
+      { 9, 212, 196, 251, 197, 207, 255, 185, 128, 128, 128}
+    },
+    { /* Coeff Band 2 */
+      { 1, 227, 226, 255, 215, 215, 128, 128, 128, 128, 128},
+      { 5, 163, 209, 255, 212, 212, 255, 255, 128, 128, 128},
+      { 1, 133, 203, 255, 210, 220, 255, 255, 128, 128, 128},
+      { 1, 133, 203, 255, 210, 220, 255, 255, 128, 128, 128}
+    },
+    { /* Coeff Band 3 */
+      { 1, 226, 225, 255, 228, 236, 128, 128, 128, 128, 128},
+      { 6, 163, 208, 255, 224, 234, 255, 255, 128, 128, 128},
+      { 1, 122, 196, 253, 212, 248, 255, 255, 128, 128, 128},
+      { 1, 122, 196, 253, 212, 248, 255, 255, 128, 128, 128}
+    },
+    { /* Coeff Band 4 */
+      { 1, 222, 197, 254, 193, 216, 255, 236, 128, 128, 128},
+      { 7, 140, 163, 251, 195, 211, 255, 238, 128, 128, 128},
+      { 1, 91, 152, 249, 181, 197, 255, 239, 128, 128, 128},
+      { 1, 91, 152, 249, 181, 197, 255, 239, 128, 128, 128}
+    },
+    { /* Coeff Band 5 */
+      { 1, 226, 218, 255, 216, 241, 255, 255, 128, 128, 128},
+      { 6, 154, 191, 255, 218, 240, 255, 255, 128, 128, 128},
+      { 1, 110, 171, 252, 191, 204, 255, 236, 128, 128, 128},
+      { 1, 110, 171, 252, 191, 204, 255, 236, 128, 128, 128}
+    },
+    { /* Coeff Band 6 */
+      { 1, 221, 217, 255, 208, 217, 255, 232, 128, 128, 128},
+      { 11, 155, 189, 254, 203, 211, 255, 249, 128, 128, 128},
+      { 1, 110, 171, 252, 191, 204, 255, 236, 128, 128, 128},
+      { 1, 110, 171, 252, 191, 204, 255, 236, 128, 128, 128}
+    },
+    { /* Coeff Band 7 */
+      { 1, 207, 235, 255, 232, 240, 128, 128, 128, 128, 128},
+      { 58, 161, 216, 255, 229, 235, 255, 255, 128, 128, 128},
+      { 8, 133, 204, 255, 219, 231, 255, 255, 128, 128, 128},
+      { 8, 133, 204, 255, 219, 231, 255, 255, 128, 128, 128}
+    }
+  },
+  { /* block Type 1 */
+      { /* Coeff Band 0 */
+        { 1, 30, 103, 204, 142, 168, 235, 161, 255, 228, 128},
+        { 1, 35, 90, 192, 130, 161, 227, 158, 255, 226, 255},
+        { 1, 36, 78, 180, 122, 156, 221, 153, 255, 222, 255},
+        { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+      },
+      { /* Coeff Band 1 */
+        { 1, 163, 228, 253, 212, 194, 255, 205, 128, 128, 128},
+        { 67, 160, 226, 253, 210, 202, 245, 172, 255, 255, 128},
+        { 51, 147, 219, 251, 207, 207, 255, 217, 128, 128, 128},
+        { 25, 107, 175, 245, 183, 190, 254, 209, 255, 255, 128}
+      },
+      { /* Coeff Band 2 */
+        { 1, 66, 170, 240, 177, 186, 252, 203, 255, 245, 128},
+        { 23, 64, 145, 230, 161, 177, 252, 198, 255, 255, 128},
+        { 6, 51, 99, 208, 135, 163, 249, 178, 255, 248, 128},
+        { 1, 33, 59, 161, 104, 151, 238, 164, 255, 237, 128}
+      },
+      { /* Coeff Band 3 */
+        { 1, 76, 216, 250, 198, 199, 255, 226, 255, 255, 128},
+        { 86, 83, 200, 247, 189, 193, 255, 224, 255, 255, 128},
+        { 30, 75, 164, 242, 172, 184, 254, 218, 255, 255, 128},
+        { 3, 54, 103, 227, 140, 172, 253, 201, 255, 255, 128}
+      },
+      { /* Coeff Band 4 */
+        { 1, 241, 247, 255, 233, 223, 255, 255, 128, 128, 128},
+        { 78, 212, 242, 255, 226, 230, 255, 255, 128, 128, 128},
+        { 10, 167, 224, 255, 217, 225, 255, 128, 128, 128, 128},
+        { 1, 104, 176, 250, 166, 219, 255, 255, 128, 128, 128}
+      },
+      { /* Coeff Band 5 */
+        { 1, 194, 241, 254, 228, 214, 248, 237, 255, 255, 128},
+        { 95, 133, 228, 254, 218, 215, 255, 229, 128, 128, 128},
+        { 24, 119, 201, 252, 202, 205, 255, 229, 128, 128, 128},
+        { 1, 88, 155, 246, 183, 193, 255, 205, 128, 128, 128}
+      },
+      { /* Coeff Band 6 */
+        { 1, 204, 236, 255, 222, 220, 255, 239, 128, 128, 128},
+        { 126, 105, 225, 254, 214, 217, 255, 254, 128, 128, 128},
+        { 44, 86, 190, 251, 197, 204, 255, 233, 128, 128, 128},
+        { 6, 71, 130, 240, 164, 188, 255, 246, 128, 128, 128}
+      },
+      { /* Coeff Band 7 */
+        { 1, 195, 250, 255, 239, 197, 128, 128, 128, 128, 128},
+        { 167, 102, 249, 255, 234, 255, 128, 128, 128, 128, 128},
+        { 65, 91, 222, 255, 217, 255, 128, 128, 128, 128, 128},
+        { 1, 59, 128, 255, 154, 255, 128, 128, 128, 128, 128}
+      }
+  },
+  { /* block Type 2 */
+      { /* Coeff Band 0 */
+        { 1, 30, 103, 204, 142, 168, 235, 161, 255, 228, 128},
+        { 1, 35, 90, 192, 130, 161, 227, 158, 255, 226, 255},
+        { 1, 36, 78, 180, 122, 156, 221, 153, 255, 222, 255},
+        { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+      },
+      { /* Coeff Band 1 */
+        { 1, 163, 228, 253, 212, 194, 255, 205, 128, 128, 128},
+        { 67, 160, 226, 253, 210, 202, 245, 172, 255, 255, 128},
+        { 51, 147, 219, 251, 207, 207, 255, 217, 128, 128, 128},
+        { 25, 107, 175, 245, 183, 190, 254, 209, 255, 255, 128}
+      },
+      { /* Coeff Band 2 */
+        { 1, 66, 170, 240, 177, 186, 252, 203, 255, 245, 128},
+        { 23, 64, 145, 230, 161, 177, 252, 198, 255, 255, 128},
+        { 6, 51, 99, 208, 135, 163, 249, 178, 255, 248, 128},
+        { 1, 33, 59, 161, 104, 151, 238, 164, 255, 237, 128}
+      },
+      { /* Coeff Band 3 */
+        { 1, 76, 216, 250, 198, 199, 255, 226, 255, 255, 128},
+        { 86, 83, 200, 247, 189, 193, 255, 224, 255, 255, 128},
+        { 30, 75, 164, 242, 172, 184, 254, 218, 255, 255, 128},
+        { 3, 54, 103, 227, 140, 172, 253, 201, 255, 255, 128}
+      },
+      { /* Coeff Band 4 */
+        { 1, 241, 247, 255, 233, 223, 255, 255, 128, 128, 128},
+        { 78, 212, 242, 255, 226, 230, 255, 255, 128, 128, 128},
+        { 10, 167, 224, 255, 217, 225, 255, 128, 128, 128, 128},
+        { 1, 104, 176, 250, 166, 219, 255, 255, 128, 128, 128}
+      },
+      { /* Coeff Band 5 */
+        { 1, 194, 241, 254, 228, 214, 248, 237, 255, 255, 128},
+        { 95, 133, 228, 254, 218, 215, 255, 229, 128, 128, 128},
+        { 24, 119, 201, 252, 202, 205, 255, 229, 128, 128, 128},
+        { 1, 88, 155, 246, 183, 193, 255, 205, 128, 128, 128}
+      },
+      { /* Coeff Band 6 */
+        { 1, 204, 236, 255, 222, 220, 255, 239, 128, 128, 128},
+        { 126, 105, 225, 254, 214, 217, 255, 254, 128, 128, 128},
+        { 44, 86, 190, 251, 197, 204, 255, 233, 128, 128, 128},
+        { 6, 71, 130, 240, 164, 188, 255, 246, 128, 128, 128}
+      },
+      { /* Coeff Band 7 */
+        { 1, 195, 250, 255, 239, 197, 128, 128, 128, 128, 128},
+        { 167, 102, 249, 255, 234, 255, 128, 128, 128, 128, 128},
+        { 65, 91, 222, 255, 217, 255, 128, 128, 128, 128, 128},
+        { 1, 59, 128, 255, 154, 255, 128, 128, 128, 128, 128}
+      }
+  },
+  { /* block Type 3 */
+    { /* Coeff Band 0 */
+      { 17, 105, 227, 195, 164, 170, 168, 137, 221, 160, 184},
+      { 6, 92, 166, 193, 158, 169, 179, 142, 236, 175, 200},
+      { 2, 68, 118, 193, 147, 168, 187, 149, 241, 178, 247},
+      { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
+    },
+    { /* Coeff Band 1 */
+      { 1, 193, 221, 246, 198, 194, 244, 176, 255, 192, 128},
+      { 112, 160, 209, 244, 196, 194, 243, 175, 255, 209, 128},
+      { 45, 123, 175, 240, 184, 195, 239, 178, 255, 218, 255},
+      { 16, 53, 75, 169, 119, 152, 209, 146, 255, 219, 255}
+    },
+    { /* Coeff Band 2 */
+      { 1, 141, 183, 240, 176, 187, 246, 198, 255, 218, 128},
+      { 36, 97, 150, 231, 161, 180, 243, 191, 255, 217, 255},
+      { 8, 65, 111, 210, 143, 166, 230, 167, 255, 224, 255},
+      { 2, 35, 61, 157, 113, 149, 208, 142, 255, 217, 255}
+    },
+    { /* Coeff Band 3 */
+      { 1, 173, 196, 245, 184, 191, 252, 211, 255, 240, 128},
+      { 35, 119, 175, 242, 177, 187, 252, 209, 255, 235, 128},
+      { 4, 88, 141, 234, 161, 180, 249, 200, 255, 228, 128},
+      { 1, 57, 95, 203, 133, 161, 235, 167, 255, 231, 255}
+    },
+    { /* Coeff Band 4 */
+      { 1, 208, 227, 249, 209, 204, 248, 188, 255, 248, 128},
+      { 28, 162, 211, 247, 203, 200, 252, 188, 255, 232, 128},
+      { 5, 114, 174, 238, 182, 189, 245, 184, 255, 238, 128},
+      { 1, 61, 100, 205, 136, 164, 235, 163, 255, 239, 128}
+    },
+    { /* Coeff Band 5 */
+      { 1, 195, 218, 252, 208, 207, 250, 205, 255, 245, 128},
+      { 22, 141, 196, 249, 198, 201, 250, 202, 255, 244, 128},
+      { 2, 105, 163, 240, 178, 189, 246, 191, 255, 246, 128},
+      { 1, 70, 112, 206, 144, 167, 232, 162, 255, 239, 128}
+    },
+    { /* Coeff Band 6 */
+      { 1, 204, 215, 251, 204, 203, 255, 222, 255, 225, 128},
+      { 15, 140, 194, 249, 194, 199, 254, 221, 255, 253, 128},
+      { 1, 95, 153, 243, 172, 188, 254, 213, 255, 248, 128},
+      { 1, 59, 99, 216, 135, 166, 247, 190, 255, 237, 255}
+    },
+    { /* Coeff Band 7 */
+      { 1, 7, 231, 255, 227, 223, 255, 240, 255, 255, 128},
+      { 15, 157, 217, 255, 218, 219, 255, 239, 255, 255, 128},
+      { 1, 114, 182, 252, 198, 207, 255, 235, 255, 255, 128},
+      { 1, 71, 122, 238, 154, 181, 255, 216, 255, 255, 128}
+    }
+  }
 };
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+
+#if CONFIG_HYBRIDTRANSFORM16X16
 static const vp8_prob
-vp8_default_coef_probs_16x16[BLOCK_TYPES_16X16]
-                            [COEF_BANDS]
-                            [PREV_COEF_CONTEXTS]
-                            [ENTROPY_NODES] =
-{
+  default_hybrid_coef_probs_16x16[BLOCK_TYPES_16X16]
+                                 [COEF_BANDS]
+                                 [PREV_COEF_CONTEXTS]
+                                 [ENTROPY_NODES] = {
   { /* block Type 0 */
     { /* Coeff Band 0 */
       { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
@@ -697,3 +1384,4 @@ vp8_default_coef_probs_16x16[BLOCK_TYPES_16X16]
   }
 };
 #endif
+#endif

diff --git a/vp8/common/entropy.c b/vp8/common/entropy.c
index 9ccb18554b716d8973f64be8ca57c643d518f163..67242d5ea98c140ac81eb9978e8c81d9bcd4b234 100644 (file)
--- a/vp8/common/entropy.c
+++ b/vp8/common/entropy.c
@@ -28,6 +28,8 @@ typedef vp8_prob Prob;
 
 #include "coefupdateprobs.h"
 
+const int vp8_i8x8_block[4] = {0, 2, 8, 10};
+
 DECLARE_ALIGNED(16, const unsigned char, vp8_norm[256]) = {
   0, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
@@ -208,13 +210,26 @@ vp8_extra_bit_struct vp8_extra_bits[12] = {
 void vp8_default_coef_probs(VP8_COMMON *pc) {
   vpx_memcpy(pc->fc.coef_probs, default_coef_probs,
              sizeof(pc->fc.coef_probs));
+#if CONFIG_HYBRIDTRANSFORM
+  vpx_memcpy(pc->fc.hybrid_coef_probs, default_hybrid_coef_probs,
+             sizeof(pc->fc.hybrid_coef_probs));
+#endif
 
-  vpx_memcpy(pc->fc.coef_probs_8x8, vp8_default_coef_probs_8x8,
+  vpx_memcpy(pc->fc.coef_probs_8x8, default_coef_probs_8x8,
              sizeof(pc->fc.coef_probs_8x8));
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vpx_memcpy(pc->fc.hybrid_coef_probs_8x8, default_hybrid_coef_probs_8x8,
+             sizeof(pc->fc.hybrid_coef_probs_8x8));
+#endif
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
-  vpx_memcpy(pc->fc.coef_probs_16x16, vp8_default_coef_probs_16x16,
+#if CONFIG_TX16X16
+  vpx_memcpy(pc->fc.coef_probs_16x16, default_coef_probs_16x16,
              sizeof(pc->fc.coef_probs_16x16));
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vpx_memcpy(pc->fc.hybrid_coef_probs_16x16,
+             default_hybrid_coef_probs_16x16,
+             sizeof(pc->fc.hybrid_coef_probs_16x16));
+#endif
 #endif
 }
 
@@ -263,7 +278,8 @@ void vp8_adapt_coef_probs(VP8_COMMON *cm) {
         printf("    {\n");
         for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
           printf("      {");
-          for (t = 0; t < MAX_ENTROPY_TOKENS; ++t) printf("%d, ", cm->fc.coef_counts[i][j][k][t]);
+          for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
+            printf("%d, ", cm->fc.coef_counts[i][j][k][t]);
           printf("},\n");
         }
         printf("    },\n");
@@ -280,7 +296,26 @@ void vp8_adapt_coef_probs(VP8_COMMON *cm) {
         printf("    {\n");
         for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
           printf("      {");
-          for (t = 0; t < MAX_ENTROPY_TOKENS; ++t) printf("%d, ", cm->fc.coef_counts_8x8[i][j][k][t]);
+          for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
+            printf("%d, ", cm->fc.coef_counts_8x8[i][j][k][t]);
+          printf("},\n");
+        }
+        printf("    },\n");
+      }
+      printf("  },\n");
+    }
+    printf("};\n");
+    printf("static const unsigned int\nhybrid_coef_counts"
+           "[BLOCK_TYPES] [COEF_BANDS]"
+           "[PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS] = {\n");
+    for (i = 0; i < BLOCK_TYPES; ++i) {
+      printf("  {\n");
+      for (j = 0; j < COEF_BANDS; ++j) {
+        printf("    {\n");
+        for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+          printf("      {");
+          for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
+            printf("%d, ", cm->fc.hybrid_coef_counts[i][j][k][t]);
           printf("},\n");
         }
         printf("    },\n");
@@ -313,6 +348,30 @@ void vp8_adapt_coef_probs(VP8_COMMON *cm) {
         }
       }
 
+#if CONFIG_HYBRIDTRANSFORM
+  for (i = 0; i < BLOCK_TYPES; ++i)
+    for (j = 0; j < COEF_BANDS; ++j)
+      for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+        if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+          continue;
+        vp8_tree_probs_from_distribution(
+          MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
+          coef_probs, branch_ct, cm->fc.hybrid_coef_counts [i][j][k],
+          256, 1);
+        for (t = 0; t < ENTROPY_NODES; ++t) {
+          int prob;
+          count = branch_ct[t][0] + branch_ct[t][1];
+          count = count > count_sat ? count_sat : count;
+          factor = (update_factor * count / count_sat);
+          prob = ((int)cm->fc.pre_hybrid_coef_probs[i][j][k][t] * (256 - factor) +
+                  (int)coef_probs[t] * factor + 128) >> 8;
+          if (prob <= 0) cm->fc.hybrid_coef_probs[i][j][k][t] = 1;
+          else if (prob > 255) cm->fc.hybrid_coef_probs[i][j][k][t] = 255;
+          else cm->fc.hybrid_coef_probs[i][j][k][t] = prob;
+        }
+      }
+#endif
+
   for (i = 0; i < BLOCK_TYPES_8X8; ++i)
     for (j = 0; j < COEF_BANDS; ++j)
       for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
@@ -335,7 +394,32 @@ void vp8_adapt_coef_probs(VP8_COMMON *cm) {
         }
       }
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  for (i = 0; i < BLOCK_TYPES_8X8; ++i)
+    for (j = 0; j < COEF_BANDS; ++j)
+      for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+        if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+          continue;
+        vp8_tree_probs_from_distribution(
+          MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
+          coef_probs, branch_ct, cm->fc.hybrid_coef_counts_8x8 [i][j][k],
+          256, 1);
+        for (t = 0; t < ENTROPY_NODES; ++t) {
+          int prob;
+          count = branch_ct[t][0] + branch_ct[t][1];
+          count = count > count_sat ? count_sat : count;
+          factor = (update_factor * count / count_sat);
+          prob = ((int)cm->fc.pre_hybrid_coef_probs_8x8[i][j][k][t] *
+                  (256 - factor) +
+                  (int)coef_probs[t] * factor + 128) >> 8;
+          if (prob <= 0) cm->fc.hybrid_coef_probs_8x8[i][j][k][t] = 1;
+          else if (prob > 255) cm->fc.hybrid_coef_probs_8x8[i][j][k][t] = 255;
+          else cm->fc.hybrid_coef_probs_8x8[i][j][k][t] = prob;
+        }
+      }
+#endif
+
+#if CONFIG_TX16X16
   for (i = 0; i < BLOCK_TYPES_16X16; ++i)
     for (j = 0; j < COEF_BANDS; ++j)
       for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
@@ -349,12 +433,36 @@ void vp8_adapt_coef_probs(VP8_COMMON *cm) {
           count = branch_ct[t][0] + branch_ct[t][1];
           count = count > count_sat ? count_sat : count;
           factor = (update_factor * count / count_sat);
-          prob = ((int)cm->fc.pre_coef_probs_16x16[i][j][k][t] * (256 - factor) +
+          prob = ((int)cm->fc.pre_coef_probs_16x16[i][j][k][t] *
+                  (256 - factor) +
                   (int)coef_probs[t] * factor + 128) >> 8;
           if (prob <= 0) cm->fc.coef_probs_16x16[i][j][k][t] = 1;
           else if (prob > 255) cm->fc.coef_probs_16x16[i][j][k][t] = 255;
           else cm->fc.coef_probs_16x16[i][j][k][t] = prob;
         }
       }
+
+#if CONFIG_HYBRIDTRANSFORM16X16
+  for (i = 0; i < BLOCK_TYPES_16X16; ++i)
+    for (j = 0; j < COEF_BANDS; ++j)
+      for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+        if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+          continue;
+        vp8_tree_probs_from_distribution(
+          MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
+          coef_probs, branch_ct, cm->fc.hybrid_coef_counts_16x16[i][j][k], 256, 1);
+        for (t = 0; t < ENTROPY_NODES; ++t) {
+          int prob;
+          count = branch_ct[t][0] + branch_ct[t][1];
+          count = count > count_sat ? count_sat : count;
+          factor = (update_factor * count / count_sat);
+          prob = ((int)cm->fc.pre_hybrid_coef_probs_16x16[i][j][k][t] * (256 - factor) +
+                  (int)coef_probs[t] * factor + 128) >> 8;
+          if (prob <= 0) cm->fc.hybrid_coef_probs_16x16[i][j][k][t] = 1;
+          else if (prob > 255) cm->fc.hybrid_coef_probs_16x16[i][j][k][t] = 255;
+          else cm->fc.hybrid_coef_probs_16x16[i][j][k][t] = prob;
+        }
+      }
+#endif
 #endif
 }

diff --git a/vp8/common/entropy.h b/vp8/common/entropy.h
index ec9f90ef5b05b517dc8c58ce263092aa8b600b40..b3d3eff9fdb8bc1ab9508a176b2c8ec4b0b1e014 100644 (file)
--- a/vp8/common/entropy.h
+++ b/vp8/common/entropy.h
@@ -21,6 +21,8 @@
 //#define SUBMVREF_COUNT 5
 //#define VP8_NUMMBSPLITS 4
 
+extern const int vp8_i8x8_block[4];
+
 /* Coefficient token alphabet */
 
 #define ZERO_TOKEN              0       /* 0         Extra Bits 0+0 */
@@ -97,8 +99,6 @@ extern DECLARE_ALIGNED(16, const int, vp8_coef_bands_16x16[256]);
 
 #define SUBEXP_PARAM                4   /* Subexponential code parameter */
 #define MODULUS_PARAM               13  /* Modulus parameter */
-#define COEFUPDATETYPE              1   /* coef update type to use (1/2) */
-
 
 extern DECLARE_ALIGNED(16, const unsigned char, vp8_prev_token_class[MAX_ENTROPY_TOKENS]);
 

diff --git a/vp8/common/onyxc_int.h b/vp8/common/onyxc_int.h
index 4cdcbeb0da01a3f1cd06b1f672b8aba22e1ea36f..7c6093b41e2269daec3dd73b540bd5eba4bcf9c0 100644 (file)
--- a/vp8/common/onyxc_int.h
+++ b/vp8/common/onyxc_int.h
@@ -51,10 +51,20 @@ typedef struct frame_contexts {
   vp8_prob sub_mv_ref_prob [SUBMVREF_COUNT][VP8_SUBMVREFS - 1];
   vp8_prob mbsplit_prob [VP8_NUMMBSPLITS - 1];
   vp8_prob coef_probs [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_prob hybrid_coef_probs [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#endif
   vp8_prob coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_prob hybrid_coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#endif
+#if CONFIG_TX16X16
   vp8_prob coef_probs_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_prob hybrid_coef_probs_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#endif
 #endif
+
 #if CONFIG_NEWMVENTROPY
   nmv_context nmvc;
   nmv_context pre_nmvc;
@@ -79,20 +89,50 @@ typedef struct frame_contexts {
 
   vp8_prob pre_coef_probs [BLOCK_TYPES] [COEF_BANDS]
       [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_prob pre_hybrid_coef_probs [BLOCK_TYPES] [COEF_BANDS]
+      [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#endif
+
   vp8_prob pre_coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS]
       [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_prob pre_hybrid_coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS]
+      [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#endif
+
+#if CONFIG_TX16X16
   vp8_prob pre_coef_probs_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS]
       [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_prob pre_hybrid_coef_probs_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS]
+      [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
 #endif
+#endif
+
   unsigned int coef_counts [BLOCK_TYPES] [COEF_BANDS]
       [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+#if CONFIG_HYBRIDTRANSFORM
+  unsigned int hybrid_coef_counts [BLOCK_TYPES] [COEF_BANDS]
+      [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+#endif
+
   unsigned int coef_counts_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS]
       [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  unsigned int hybrid_coef_counts_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS]
+      [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+#endif
+
+#if CONFIG_TX16X16
   unsigned int coef_counts_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS]
       [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+#if CONFIG_HYBRIDTRANSFORM16X16
+  unsigned int hybrid_coef_counts_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS]
+      [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
 #endif
+#endif
+
 #if CONFIG_NEWMVENTROPY
   nmv_context_counts NMVcount;
 #else

diff --git a/vp8/decoder/decodframe.c b/vp8/decoder/decodframe.c
index e9b0f1ad0a7687aa2b5f671330c39507b63ffd32..b4d400641eebb671d25dcebd2ff8c257182caf71 100644 (file)
--- a/vp8/decoder/decodframe.c
+++ b/vp8/decoder/decodframe.c
@@ -207,7 +207,6 @@ static void skip_recon_mb(VP8D_COMP *pbi, MACROBLOCKD *xd) {
   }
 }
 
-extern const int vp8_i8x8_block[4];
 static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                               unsigned int mb_col) {
   int eobtotal = 0;
@@ -931,6 +930,7 @@ static void init_frame(VP8D_COMP *pbi) {
 
 }
 
+#if 0
 static void read_coef_probs2(VP8D_COMP *pbi) {
   const vp8_prob grpupd = 192;
   int i, j, k, l;
@@ -973,6 +973,7 @@ static void read_coef_probs2(VP8D_COMP *pbi) {
     }
   }
 }
+#endif
 
 static void read_coef_probs(VP8D_COMP *pbi) {
   int i, j, k, l;
@@ -998,6 +999,27 @@ static void read_coef_probs(VP8D_COMP *pbi) {
           }
         }
   }
+#if CONFIG_HYBRIDTRANSFORM
+  {
+    if (vp8_read_bit(bc)) {
+      /* read coef probability tree */
+      for (i = 0; i < BLOCK_TYPES; i++)
+        for (j = !i; j < COEF_BANDS; j++)
+          for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
+            if (k >= 3 && ((i == 0 && j == 1) ||
+                           (i > 0 && j == 0)))
+              continue;
+            for (l = 0; l < ENTROPY_NODES; l++) {
+              vp8_prob *const p = pc->fc.hybrid_coef_probs [i][j][k] + l;
+
+              if (vp8_read(bc, COEF_UPDATE_PROB)) {
+                *p = read_prob_diff_update(bc, *p);
+              }
+            }
+          }
+        }
+  }
+#endif
 
   if (pbi->common.txfm_mode == ALLOW_8X8 && vp8_read_bit(bc)) {
     // read coef probability tree
@@ -1017,8 +1039,28 @@ static void read_coef_probs(VP8D_COMP *pbi) {
           }
         }
   }
+#if CONFIG_HYBRIDTRANSFORM8X8
+  if (pbi->common.txfm_mode == ALLOW_8X8 && vp8_read_bit(bc)) {
+    // read coef probability tree
+    for (i = 0; i < BLOCK_TYPES_8X8; i++)
+      for (j = !i; j < COEF_BANDS; j++)
+        for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
+          if (k >= 3 && ((i == 0 && j == 1) ||
+                         (i > 0 && j == 0)))
+            continue;
+          for (l = 0; l < ENTROPY_NODES; l++) {
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+            vp8_prob *const p = pc->fc.hybrid_coef_probs_8x8 [i][j][k] + l;
+
+            if (vp8_read(bc, COEF_UPDATE_PROB_8X8)) {
+              *p = read_prob_diff_update(bc, *p);
+            }
+          }
+        }
+  }
+#endif
+
+#if CONFIG_TX16X16
   // 16x16
   if (vp8_read_bit(bc)) {
     // read coef probability tree
@@ -1038,6 +1080,26 @@ static void read_coef_probs(VP8D_COMP *pbi) {
           }
         }
   }
+#if CONFIG_HYBRIDTRANSFORM16X16
+  if (vp8_read_bit(bc)) {
+    // read coef probability tree
+    for (i = 0; i < BLOCK_TYPES_16X16; ++i)
+      for (j = !i; j < COEF_BANDS; ++j)
+        for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+          if (k >= 3 && ((i == 0 && j == 1) ||
+                         (i > 0 && j == 0)))
+            continue;
+          for (l = 0; l < ENTROPY_NODES; ++l) {
+
+            vp8_prob *const p = pc->fc.hybrid_coef_probs_16x16[i][j][k] + l;
+
+            if (vp8_read(bc, COEF_UPDATE_PROB_16X16)) {
+              *p = read_prob_diff_update(bc, *p);
+            }
+          }
+        }
+  }
+#endif
 #endif
 }
 
@@ -1399,10 +1461,25 @@ int vp8_decode_frame(VP8D_COMP *pbi) {
     fclose(z);
   }
 
-  vp8_copy(pbi->common.fc.pre_coef_probs, pbi->common.fc.coef_probs);
-  vp8_copy(pbi->common.fc.pre_coef_probs_8x8, pbi->common.fc.coef_probs_8x8);
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
-  vp8_copy(pbi->common.fc.pre_coef_probs_16x16, pbi->common.fc.coef_probs_16x16);
+  vp8_copy(pbi->common.fc.pre_coef_probs,
+           pbi->common.fc.coef_probs);
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_copy(pbi->common.fc.pre_hybrid_coef_probs,
+           pbi->common.fc.hybrid_coef_probs);
+#endif
+  vp8_copy(pbi->common.fc.pre_coef_probs_8x8,
+           pbi->common.fc.coef_probs_8x8);
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_copy(pbi->common.fc.pre_hybrid_coef_probs_8x8,
+           pbi->common.fc.hybrid_coef_probs_8x8);
+#endif
+#if CONFIG_TX16X16
+  vp8_copy(pbi->common.fc.pre_coef_probs_16x16,
+           pbi->common.fc.coef_probs_16x16);
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_copy(pbi->common.fc.pre_hybrid_coef_probs_16x16,
+           pbi->common.fc.hybrid_coef_probs_16x16);
+#endif
 #endif
   vp8_copy(pbi->common.fc.pre_ymode_prob, pbi->common.fc.ymode_prob);
   vp8_copy(pbi->common.fc.pre_uv_mode_prob, pbi->common.fc.uv_mode_prob);
@@ -1417,9 +1494,18 @@ int vp8_decode_frame(VP8D_COMP *pbi) {
   vp8_copy(pbi->common.fc.pre_mvc_hp, pbi->common.fc.mvc_hp);
 #endif
   vp8_zero(pbi->common.fc.coef_counts);
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_zero(pbi->common.fc.hybrid_coef_counts);
+#endif
   vp8_zero(pbi->common.fc.coef_counts_8x8);
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_zero(pbi->common.fc.hybrid_coef_counts_8x8);
+#endif
+#if CONFIG_TX16X16
   vp8_zero(pbi->common.fc.coef_counts_16x16);
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_zero(pbi->common.fc.hybrid_coef_counts_16x16);
+#endif
 #endif
   vp8_zero(pbi->common.fc.ymode_counts);
   vp8_zero(pbi->common.fc.uv_mode_counts);
@@ -1435,11 +1521,8 @@ int vp8_decode_frame(VP8D_COMP *pbi) {
 #endif
   vp8_zero(pbi->common.fc.mv_ref_ct);
   vp8_zero(pbi->common.fc.mv_ref_ct_a);
-#if COEFUPDATETYPE == 2
-  read_coef_probs2(pbi);
-#else
+
   read_coef_probs(pbi);
-#endif
 
   vpx_memcpy(&xd->pre, &pc->yv12_fb[pc->lst_fb_idx], sizeof(YV12_BUFFER_CONFIG));
   vpx_memcpy(&xd->dst, &pc->yv12_fb[pc->new_fb_idx], sizeof(YV12_BUFFER_CONFIG));

diff --git a/vp8/decoder/detokenize.c b/vp8/decoder/detokenize.c
index e9ea0c10b2d17636647e05909e3513ad950b5d56..b1d5a525935ea69f530c3aa141e4692dba6fd373 100644 (file)
--- a/vp8/decoder/detokenize.c
+++ b/vp8/decoder/detokenize.c
@@ -141,33 +141,26 @@ int get_token(int v) {
 
 #if CONFIG_HYBRIDTRANSFORM
 void static count_tokens_adaptive_scan(const MACROBLOCKD *xd, INT16 *qcoeff_ptr,
-                                       int block, int type, ENTROPY_CONTEXT *a,
-                                       ENTROPY_CONTEXT *l, int eob, int seg_eob,
+                                       int block, int type,
+                                       TX_TYPE tx_type,
+                                       ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
+                                       int eob, int seg_eob,
                                        FRAME_CONTEXT *fc) {
   int c, pt, token, band;
   const int *scan;
 
-  int QIndex = xd->q_index;
-  int active_ht = (QIndex < ACTIVE_HT) &&
-                  (xd->mode_info_context->mbmi.mode == B_PRED) &&
-                  (type == PLANE_TYPE_Y_WITH_DC);
-
-  if(active_ht) {
-    switch(xd->block[block].bmi.as_mode.tx_type) {
-      case ADST_DCT :
-        scan = vp8_row_scan;
-        break;
+  switch(tx_type) {
+    case ADST_DCT :
+      scan = vp8_row_scan;
+      break;
 
-      case DCT_ADST :
-        scan = vp8_col_scan;
-        break;
+    case DCT_ADST :
+      scan = vp8_col_scan;
+      break;
 
-      default :
-        scan = vp8_default_zig_zag1d;
-        break;
-    }
-  } else {
-    scan = vp8_default_zig_zag1d;
+    default :
+      scan = vp8_default_zig_zag1d;
+      break;
   }
 
   VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
@@ -176,13 +169,19 @@ void static count_tokens_adaptive_scan(const MACROBLOCKD *xd, INT16 *qcoeff_ptr,
     int v = qcoeff_ptr[rc];
     band = vp8_coef_bands[c];
     token = get_token(v);
-    fc->coef_counts[type][band][pt][token]++;
+    if (tx_type != DCT_DCT)
+      fc->hybrid_coef_counts[type][band][pt][token]++;
+    else
+      fc->coef_counts[type][band][pt][token]++;
     pt = vp8_prev_token_class[token];
   }
 
   if (eob < seg_eob) {
     band = vp8_coef_bands[c];
-    fc->coef_counts[type][band][pt][DCT_EOB_TOKEN]++;
+    if (tx_type != DCT_DCT)
+      fc->hybrid_coef_counts[type][band][pt][DCT_EOB_TOKEN]++;
+    else
+      fc->coef_counts[type][band][pt][DCT_EOB_TOKEN]++;
   }
 }
 #endif
@@ -207,6 +206,9 @@ void static count_tokens(INT16 *qcoeff_ptr, int block, int type,
 }
 
 void static count_tokens_8x8(INT16 *qcoeff_ptr, int block, int type,
+#if CONFIG_HYBRIDTRANSFORM8X8
+                             TX_TYPE tx_type,
+#endif
                              ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
                              int eob, int seg_eob, FRAME_CONTEXT *fc) {
   int c, pt, token, band;
@@ -216,17 +218,30 @@ void static count_tokens_8x8(INT16 *qcoeff_ptr, int block, int type,
     int v = qcoeff_ptr[rc];
     band = (type == 1 ? vp8_coef_bands[c] : vp8_coef_bands_8x8[c]);
     token = get_token(v);
-    fc->coef_counts_8x8[type][band][pt][token]++;
+#if CONFIG_HYBRIDTRANSFORM8X8
+    if (tx_type != DCT_DCT)
+      fc->hybrid_coef_counts_8x8[type][band][pt][token]++;
+    else
+#endif
+      fc->coef_counts_8x8[type][band][pt][token]++;
     pt = vp8_prev_token_class[token];
   }
   if (eob < seg_eob) {
     band = (type == 1 ? vp8_coef_bands[c] : vp8_coef_bands_8x8[c]);
-    fc->coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN]++;
+#if CONFIG_HYBRIDTRANSFORM8X8
+    if (tx_type != DCT_DCT)
+      fc->hybrid_coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN]++;
+    else
+#endif
+      fc->coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN]++;
   }
 }
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
 void static count_tokens_16x16(INT16 *qcoeff_ptr, int block, int type,
+#if CONFIG_HYBRIDTRANSFORM16X16
+                               TX_TYPE tx_type,
+#endif
                                ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
                                int eob, int seg_eob, FRAME_CONTEXT *fc) {
   int c, pt, token;
@@ -236,12 +251,22 @@ void static count_tokens_16x16(INT16 *qcoeff_ptr, int block, int type,
     int v = qcoeff_ptr[rc];
     int band = vp8_coef_bands_16x16[c];
     token = get_token(v);
-    fc->coef_counts_16x16[type][band][pt][token]++;
+#if CONFIG_HYBRIDTRANSFORM16X16
+    if (tx_type != DCT_DCT)
+      fc->hybrid_coef_counts_16x16[type][band][pt][token]++;
+    else
+#endif
+      fc->coef_counts_16x16[type][band][pt][token]++;
     pt = vp8_prev_token_class[token];
   }
   if (eob < seg_eob) {
     int band = vp8_coef_bands_16x16[c];
-    fc->coef_counts_16x16[type][band][pt][DCT_EOB_TOKEN]++;
+#if CONFIG_HYBRIDTRANSFORM16X16
+    if (tx_type != DCT_DCT)
+      fc->hybrid_coef_counts_16x16[type][band][pt][DCT_EOB_TOKEN]++;
+    else
+#endif
+      fc->coef_counts_16x16[type][band][pt][DCT_EOB_TOKEN]++;
   }
 }
 #endif
@@ -286,6 +311,9 @@ static int vp8_get_signed(BOOL_DECODER *br, int value_to_sign) {
 
 static int vp8_decode_coefs(VP8D_COMP *dx, const MACROBLOCKD *xd,
                             ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l, int type,
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+                            TX_TYPE tx_type,
+#endif
                             int seg_eob, INT16 *qcoeff_ptr, int i,
                             const int *const scan, int block_type,
                             const int *coef_bands) {
@@ -297,14 +325,26 @@ static int vp8_decode_coefs(VP8D_COMP *dx, const MACROBLOCKD *xd,
   switch (block_type) {
     default:
     case TX_4X4:
-      coef_probs = fc->coef_probs[type][0][0];
+      coef_probs =
+#if CONFIG_HYBRIDTRANSFORM
+        tx_type != DCT_DCT ? fc->hybrid_coef_probs[type][0][0] :
+#endif
+        fc->coef_probs[type][0][0];
       break;
     case TX_8X8:
-      coef_probs = fc->coef_probs_8x8[type][0][0];
+      coef_probs =
+#if CONFIG_HYBRIDTRANSFORM8X8
+        tx_type != DCT_DCT ? fc->hybrid_coef_probs_8x8[type][0][0] :
+#endif
+        fc->coef_probs_8x8[type][0][0];
       break;
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
     case TX_16X16:
-      coef_probs = fc->coef_probs_16x16[type][0][0];
+      coef_probs =
+#if CONFIG_HYBRIDTRANSFORM16X16
+        tx_type != DCT_DCT ? fc->hybrid_coef_probs_16x16[type][0][0] :
+#endif
+        fc->coef_probs_16x16[type][0][0];
       break;
 #endif
   }
@@ -391,16 +431,27 @@ SKIP_START:
 
   if (block_type == TX_4X4) {
 #if CONFIG_HYBRIDTRANSFORM
-    count_tokens_adaptive_scan(xd, qcoeff_ptr, i, type, a, l, c, seg_eob, fc);
+    count_tokens_adaptive_scan(xd, qcoeff_ptr, i, type,
+                               tx_type,
+                               a, l, c, seg_eob, fc);
 #else
-    count_tokens(qcoeff_ptr, i, type, a, l, c, seg_eob, fc);
+    count_tokens(qcoeff_ptr, i, type,
+                 a, l, c, seg_eob, fc);
 #endif
   }
   else if (block_type == TX_8X8)
-    count_tokens_8x8(qcoeff_ptr, i, type, a, l, c, seg_eob, fc);
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+    count_tokens_8x8(qcoeff_ptr, i, type,
+#if CONFIG_HYBRIDTRANSFORM8X8
+                     tx_type,
+#endif
+                     a, l, c, seg_eob, fc);
+#if CONFIG_TX16X16
   else
-    count_tokens_16x16(qcoeff_ptr, i, type, a, l, c, seg_eob, fc);
+    count_tokens_16x16(qcoeff_ptr, i, type,
+#if CONFIG_HYBRIDTRANSFORM16X16
+                       tx_type,
+#endif
+                       a, l, c, seg_eob, fc);
 #endif
   return c;
 }
@@ -415,6 +466,12 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd) {
   const int segment_id = xd->mode_info_context->mbmi.segment_id;
   const int seg_active = segfeature_active(xd, segment_id, SEG_LVL_EOB);
   INT16 *qcoeff_ptr = &xd->qcoeff[0];
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+  TX_TYPE tx_type = DCT_DCT;
+#endif
+#if CONFIG_HYBRIDTRANSFORM16X16
+  tx_type = get_tx_type(xd, &xd->block[0]);
+#endif
 
   type = PLANE_TYPE_Y_WITH_DC;
 
@@ -426,7 +483,12 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd) {
   // Luma block
   {
     const int* const scan = vp8_default_zig_zag1d_16x16;
-    c = vp8_decode_coefs(pbi, xd, A, L, type, seg_eob, qcoeff_ptr,
+    //printf("16: %d\n", tx_type);
+    c = vp8_decode_coefs(pbi, xd, A, L, type,
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+                         tx_type,
+#endif
+                         seg_eob, qcoeff_ptr,
                          0, scan, TX_16X16, coef_bands_x_16x16);
     eobs[0] = c;
     *A = *L = (c != !type);
@@ -440,6 +502,9 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd) {
   // 8x8 chroma blocks
   qcoeff_ptr += 256;
   type = PLANE_TYPE_UV;
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+  tx_type = DCT_DCT;
+#endif
   if (seg_active)
     seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
   else
@@ -449,7 +514,12 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd) {
     ENTROPY_CONTEXT* const l = L + vp8_block2left_8x8[i];
     const int* const scan = vp8_default_zig_zag1d_8x8;
 
-    c = vp8_decode_coefs(pbi, xd, a, l, type, seg_eob, qcoeff_ptr,
+    //printf("8: %d\n", tx_type);
+    c = vp8_decode_coefs(pbi, xd, a, l, type,
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+                         tx_type,
+#endif
+                         seg_eob, qcoeff_ptr,
                          i, scan, TX_8X8, coef_bands_x_8x8);
     a[0] = l[0] = ((eobs[i] = c) != !type);
     a[1] = a[0];
@@ -474,6 +544,9 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) {
   const int segment_id = xd->mode_info_context->mbmi.segment_id;
   const int seg_active = segfeature_active(xd, segment_id, SEG_LVL_EOB);
   INT16 *qcoeff_ptr = &xd->qcoeff[0];
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+  TX_TYPE tx_type = DCT_DCT;
+#endif
 
 #if CONFIG_HYBRIDTRANSFORM8X8
   int bufthred = (xd->mode_info_context->mbmi.mode == I8X8_PRED) ? 16 : 24;
@@ -493,7 +566,11 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) {
       seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
     else
       seg_eob = 4;
-    c = vp8_decode_coefs(pbi, xd, a, l, type, seg_eob, qcoeff_ptr + 24 * 16,
+    c = vp8_decode_coefs(pbi, xd, a, l, type,
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+                         tx_type,
+#endif
+                         seg_eob, qcoeff_ptr + 24 * 16,
                          24, scan, TX_8X8, coef_bands_x);
     a[0] = l[0] = ((eobs[24] = c) != !type);
 
@@ -516,11 +593,25 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) {
     ENTROPY_CONTEXT *const a = A + vp8_block2above_8x8[i];
     ENTROPY_CONTEXT *const l = L + vp8_block2left_8x8[i];
     const int *const scan = vp8_default_zig_zag1d_8x8;
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+    tx_type = DCT_DCT;
+#endif
 
     if (i == 16)
       type = PLANE_TYPE_UV;
+#if CONFIG_HYBRIDTRANSFORM8X8
+    if (type == PLANE_TYPE_Y_WITH_DC &&
+        xd->mode_info_context->mbmi.mode == I8X8_PRED) {
+      tx_type = get_tx_type(xd, xd->block + i);
+    }
+#endif
 
-    c = vp8_decode_coefs(pbi, xd, a, l, type, seg_eob, qcoeff_ptr,
+    //printf("8: %d\n", tx_type);
+    c = vp8_decode_coefs(pbi, xd, a, l, type,
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+                         tx_type,
+#endif
+                         seg_eob, qcoeff_ptr,
                          i, scan, TX_8X8, coef_bands_x_8x8);
     a[0] = l[0] = ((eobs[i] = c) != !type);
     a[1] = a[0];
@@ -533,6 +624,7 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) {
 #if CONFIG_HYBRIDTRANSFORM8X8
   if (xd->mode_info_context->mbmi.mode == I8X8_PRED) {
     type = PLANE_TYPE_UV;
+    tx_type = DCT_DCT;
     seg_eob = 16;
 
     // use 4x4 transform for U, V components in I8X8 prediction mode
@@ -541,7 +633,11 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) {
       ENTROPY_CONTEXT *const l = L + vp8_block2left[i];
       const int *scan = vp8_default_zig_zag1d;
 
-      c = vp8_decode_coefs(pbi, xd, a, l, type, seg_eob, qcoeff_ptr,
+      c = vp8_decode_coefs(pbi, xd, a, l, type,
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+                           tx_type,
+#endif
+                           seg_eob, qcoeff_ptr,
                            i, scan, TX_4X4, coef_bands_x);
       a[0] = l[0] = ((eobs[i] = c) != !type);
 
@@ -560,14 +656,7 @@ int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd) {
   ENTROPY_CONTEXT *const L = (ENTROPY_CONTEXT *)xd->left_context;
 
   char *const eobs = xd->eobs;
-#if CONFIG_HYBRIDTRANSFORM
   const int *scan = vp8_default_zig_zag1d;
-  int QIndex = xd->q_index;
-  int active_ht = (QIndex < ACTIVE_HT) &&
-                  (xd->mode_info_context->mbmi.mode == B_PRED);
-#else
-  const int *const scan = vp8_default_zig_zag1d;
-#endif
 
   int c, i, type, eobtotal = 0, seg_eob = 16;
   INT16 *qcoeff_ptr = &xd->qcoeff[0];
@@ -583,7 +672,11 @@ int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd) {
     ENTROPY_CONTEXT *const l = L + vp8_block2left[24];
     type = PLANE_TYPE_Y2;
 
-    c = vp8_decode_coefs(dx, xd, a, l, type, seg_eob, qcoeff_ptr + 24 * 16, 24,
+    c = vp8_decode_coefs(dx, xd, a, l, type,
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+                         DCT_DCT,
+#endif
+                         seg_eob, qcoeff_ptr + 24 * 16, 24,
                          scan, TX_4X4, coef_bands_x);
     a[0] = l[0] = ((eobs[24] = c) != !type);
     eobtotal += c - 16;
@@ -596,45 +689,37 @@ int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd) {
   for (i = 0; i < 24; ++i) {
     ENTROPY_CONTEXT *const a = A + vp8_block2above[i];
     ENTROPY_CONTEXT *const l = L + vp8_block2left[i];
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+    TX_TYPE tx_type = DCT_DCT;
+#endif
     if (i == 16)
       type = PLANE_TYPE_UV;
 
 #if CONFIG_HYBRIDTRANSFORM
-    if (type == PLANE_TYPE_Y_WITH_DC &&
-        xd->mode_info_context->mbmi.mode == B_PRED &&
-        active_ht) {
-      BLOCKD *b = &xd->block[i];
-      switch(b->bmi.as_mode.first) {
-        case B_TM_PRED :
-        case B_RD_PRED :
-          b->bmi.as_mode.tx_type = ADST_ADST;
-          scan = vp8_default_zig_zag1d;
-          break;
-
-        case B_VE_PRED :
-        case B_VR_PRED :
-          b->bmi.as_mode.tx_type = ADST_DCT;
-          scan = vp8_row_scan;
-          break ;
-
-        case B_HE_PRED :
-        case B_HD_PRED :
-        case B_HU_PRED :
-          b->bmi.as_mode.tx_type = DCT_ADST;
-          scan = vp8_col_scan;
-          break;
-
-        default :
-          b->bmi.as_mode.tx_type = DCT_DCT;
-          scan = vp8_default_zig_zag1d;
-          break;
-      }
-    }
-    if (type == PLANE_TYPE_UV) {
-      scan = vp8_default_zig_zag1d;
+    if (type == PLANE_TYPE_Y_WITH_DC)
+      tx_type = get_tx_type(xd, &xd->block[i]);
+#endif
+#if CONFIG_HYBRIDTRANSFORM
+    switch(tx_type) {
+      case ADST_DCT :
+        scan = vp8_row_scan;
+        break;
+
+      case DCT_ADST :
+        scan = vp8_col_scan;
+        break;
+
+      default :
+        scan = vp8_default_zig_zag1d;
+        break;
     }
 #endif
-    c = vp8_decode_coefs(dx, xd, a, l, type, seg_eob, qcoeff_ptr,
+
+    c = vp8_decode_coefs(dx, xd, a, l, type,
+#if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16
+                         tx_type,
+#endif
+                         seg_eob, qcoeff_ptr,
                          i, scan, TX_4X4, coef_bands_x);
     a[0] = l[0] = ((eobs[i] = c) != !type);
 

diff --git a/vp8/encoder/bitstream.c b/vp8/encoder/bitstream.c
index a4df16fee264d3c358d683b788a45e215721f728..2f748015f082d5fca59cf515dbba62f9bdf7d52d 100644 (file)
--- a/vp8/encoder/bitstream.c
+++ b/vp8/encoder/bitstream.c
@@ -45,15 +45,33 @@ unsigned int tree_update_hist [BLOCK_TYPES]
                               [COEF_BANDS]
                               [PREV_COEF_CONTEXTS]
                               [ENTROPY_NODES][2];
+#if CONFIG_HYBRIDTRANSFORM
+unsigned int hybrid_tree_update_hist [BLOCK_TYPES]
+                                     [COEF_BANDS]
+                                     [PREV_COEF_CONTEXTS]
+                                     [ENTROPY_NODES][2];
+#endif
 unsigned int tree_update_hist_8x8 [BLOCK_TYPES_8X8]
                                   [COEF_BANDS]
                                   [PREV_COEF_CONTEXTS]
                                   [ENTROPY_NODES] [2];
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+unsigned int hybrid_tree_update_hist_8x8 [BLOCK_TYPES_8X8]
+                                         [COEF_BANDS]
+                                         [PREV_COEF_CONTEXTS]
+                                         [ENTROPY_NODES] [2];
+#endif
+#if CONFIG_TX16X16
 unsigned int tree_update_hist_16x16 [BLOCK_TYPES_16X16]
                                     [COEF_BANDS]
                                     [PREV_COEF_CONTEXTS]
                                     [ENTROPY_NODES] [2];
+#if CONFIG_HYBRIDTRANSFORM16X16
+unsigned int hybrid_tree_update_hist_16x16 [BLOCK_TYPES_16X16]
+                                           [COEF_BANDS]
+                                           [PREV_COEF_CONTEXTS]
+                                           [ENTROPY_NODES] [2];
+#endif
 #endif
 
 extern unsigned int active_section;
@@ -1522,6 +1540,28 @@ void build_coeff_contexts(VP8_COMP *cpi) {
       }
     }
   }
+#if CONFIG_HYBRIDTRANSFORM
+  for (i = 0; i < BLOCK_TYPES; ++i) {
+    for (j = 0; j < COEF_BANDS; ++j) {
+      for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+        if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+          continue;
+        vp8_tree_probs_from_distribution(
+          MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
+          cpi->frame_hybrid_coef_probs [i][j][k],
+          cpi->frame_hybrid_branch_ct [i][j][k],
+          cpi->hybrid_coef_counts [i][j][k],
+          256, 1
+        );
+#ifdef ENTROPY_STATS
+        if (!cpi->dummy_packing)
+          for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
+            hybrid_context_counters[i][j][k][t] += cpi->hybrid_coef_counts[i][j][k][t];
+#endif
+      }
+    }
+  }
+#endif
 
 
   if (cpi->common.txfm_mode == ALLOW_8X8) {
@@ -1549,9 +1589,35 @@ void build_coeff_contexts(VP8_COMP *cpi) {
         }
       }
     }
+#if CONFIG_HYBRIDTRANSFORM8X8
+    for (i = 0; i < BLOCK_TYPES_8X8; ++i) {
+      for (j = 0; j < COEF_BANDS; ++j) {
+        for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+          /* at every context */
+          /* calc probs and branch cts for this frame only */
+          // vp8_prob new_p           [ENTROPY_NODES];
+          // unsigned int branch_ct   [ENTROPY_NODES] [2];
+          if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+            continue;
+          vp8_tree_probs_from_distribution(
+            MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
+            cpi->frame_hybrid_coef_probs_8x8 [i][j][k],
+            cpi->frame_hybrid_branch_ct_8x8 [i][j][k],
+            cpi->hybrid_coef_counts_8x8 [i][j][k],
+            256, 1
+          );
+#ifdef ENTROPY_STATS
+          if (!cpi->dummy_packing)
+            for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
+              hybrid_context_counters_8x8[i][j][k][t] += cpi->hybrid_coef_counts_8x8[i][j][k][t];
+#endif
+        }
+      }
+    }
+#endif
   }
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
   //16x16
   for (i = 0; i < BLOCK_TYPES_16X16; ++i) {
     for (j = 0; j < COEF_BANDS; ++j) {
@@ -1571,9 +1637,30 @@ void build_coeff_contexts(VP8_COMP *cpi) {
       }
     }
   }
+#if CONFIG_HYBRIDTRANSFORM16X16
+  for (i = 0; i < BLOCK_TYPES_16X16; ++i) {
+    for (j = 0; j < COEF_BANDS; ++j) {
+      for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+        if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+          continue;
+        vp8_tree_probs_from_distribution(
+          MAX_ENTROPY_TOKENS, vp8_coef_encodings, vp8_coef_tree,
+          cpi->frame_hybrid_coef_probs_16x16[i][j][k],
+          cpi->frame_hybrid_branch_ct_16x16[i][j][k],
+          cpi->hybrid_coef_counts_16x16[i][j][k], 256, 1);
+#ifdef ENTROPY_STATS
+        if (!cpi->dummy_packing)
+          for (t = 0; t < MAX_ENTROPY_TOKENS; ++t)
+            hybrid_context_counters_16x16[i][j][k][t] += cpi->hybrid_coef_counts_16x16[i][j][k][t];
+#endif
+      }
+    }
+  }
+#endif
 #endif
 }
 
+#if 0
 static void update_coef_probs2(VP8_COMP *cpi) {
   const vp8_prob grpupd = 192;
   int i, j, k, t;
@@ -1741,6 +1828,7 @@ static void update_coef_probs2(VP8_COMP *cpi) {
     }
   }
 }
+#endif
 
 static void update_coef_probs(VP8_COMP *cpi) {
   int i, j, k, t;
@@ -1844,6 +1932,96 @@ static void update_coef_probs(VP8_COMP *cpi) {
     }
   }
 
+#if CONFIG_HYBRIDTRANSFORM
+  savings = 0;
+  update[0] = update[1] = 0;
+  for (i = 0; i < BLOCK_TYPES; ++i) {
+    for (j = !i; j < COEF_BANDS; ++j) {
+      int prev_coef_savings[ENTROPY_NODES] = {0};
+      for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+        for (t = 0; t < ENTROPY_NODES; ++t) {
+          vp8_prob newp = cpi->frame_hybrid_coef_probs [i][j][k][t];
+          vp8_prob *Pold = cpi->common.fc.hybrid_coef_probs [i][j][k] + t;
+          const vp8_prob upd = COEF_UPDATE_PROB;
+          int s = prev_coef_savings[t];
+          int u = 0;
+          if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+            continue;
+#if defined(SEARCH_NEWP)
+          s = prob_diff_update_savings_search(
+                cpi->frame_hybrid_branch_ct [i][j][k][t],
+                *Pold, &newp, upd);
+          if (s > 0 && newp != *Pold)
+            u = 1;
+          if (u)
+            savings += s - (int)(vp8_cost_zero(upd));
+          else
+            savings -= (int)(vp8_cost_zero(upd));
+#else
+          s = prob_update_savings(
+                cpi->frame_hybrid_branch_ct [i][j][k][t],
+                *Pold, newp, upd);
+          if (s > 0)
+            u = 1;
+          if (u)
+            savings += s;
+#endif
+
+          update[u]++;
+        }
+      }
+    }
+  }
+
+  // printf("Update %d %d, savings %d\n", update[0], update[1], savings);
+  /* Is coef updated at all */
+  if (update[1] == 0 || savings < 0)
+    vp8_write_bit(w, 0);
+  else {
+    vp8_write_bit(w, 1);
+    for (i = 0; i < BLOCK_TYPES; ++i) {
+      for (j = !i; j < COEF_BANDS; ++j) {
+        int prev_coef_savings[ENTROPY_NODES] = {0};
+        for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+          // calc probs and branch cts for this frame only
+          for (t = 0; t < ENTROPY_NODES; ++t) {
+            vp8_prob newp = cpi->frame_hybrid_coef_probs [i][j][k][t];
+            vp8_prob *Pold = cpi->common.fc.hybrid_coef_probs [i][j][k] + t;
+            const vp8_prob upd = COEF_UPDATE_PROB;
+            int s = prev_coef_savings[t];
+            int u = 0;
+            if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+              continue;
+
+#if defined(SEARCH_NEWP)
+            s = prob_diff_update_savings_search(
+                  cpi->frame_hybrid_branch_ct [i][j][k][t],
+                  *Pold, &newp, upd);
+            if (s > 0 && newp != *Pold)
+              u = 1;
+#else
+            s = prob_update_savings(
+                  cpi->frame_hybrid_branch_ct [i][j][k][t],
+                  *Pold, newp, upd);
+            if (s > 0)
+              u = 1;
+#endif
+            vp8_write(w, u, upd);
+#ifdef ENTROPY_STATS
+            if (!cpi->dummy_packing)
+              ++ hybrid_tree_update_hist [i][j][k][t] [u];
+#endif
+            if (u) {
+              /* send/use new probability */
+              write_prob_diff_update(w, newp, *Pold);
+              *Pold = newp;
+            }
+          }
+        }
+      }
+    }
+  }
+#endif
 
   /* do not do this if not even allowed */
   if (cpi->common.txfm_mode == ALLOW_8X8) {
@@ -1921,9 +2099,84 @@ static void update_coef_probs(VP8_COMP *cpi) {
         }
       }
     }
+#if CONFIG_HYBRIDTRANSFORM8X8
+    update[0] = update[1] = 0;
+    savings = 0;
+    for (i = 0; i < BLOCK_TYPES_8X8; ++i) {
+      for (j = !i; j < COEF_BANDS; ++j) {
+        for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+          // calc probs and branch cts for this frame only
+          for (t = 0; t < ENTROPY_NODES; ++t) {
+            const unsigned int *ct  = cpi->frame_hybrid_branch_ct_8x8 [i][j][k][t];
+            vp8_prob newp = cpi->frame_hybrid_coef_probs_8x8 [i][j][k][t];
+            vp8_prob *Pold = cpi->common.fc.hybrid_coef_probs_8x8 [i][j][k] + t;
+            const vp8_prob oldp = *Pold;
+            int s, u;
+            const vp8_prob upd = COEF_UPDATE_PROB_8X8;
+            if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+              continue;
+#if defined(SEARCH_NEWP)
+            s = prob_diff_update_savings_search(ct, oldp, &newp, upd);
+            u = s > 0 && newp != oldp ? 1 : 0;
+            if (u)
+              savings += s - (int)(vp8_cost_zero(upd));
+            else
+              savings -= (int)(vp8_cost_zero(upd));
+#else
+            s = prob_update_savings(ct, oldp, newp, upd);
+            u = s > 0 ? 1 : 0;
+            if (u)
+              savings += s;
+#endif
+            update[u]++;
+          }
+        }
+      }
+    }
+
+    if (update[1] == 0 || savings < 0)
+      vp8_write_bit(w, 0);
+    else {
+      vp8_write_bit(w, 1);
+      for (i = 0; i < BLOCK_TYPES_8X8; ++i) {
+        for (j = !i; j < COEF_BANDS; ++j) {
+          for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+            for (t = 0; t < ENTROPY_NODES; ++t) {
+              const unsigned int *ct  = cpi->frame_hybrid_branch_ct_8x8 [i][j][k][t];
+              vp8_prob newp = cpi->frame_hybrid_coef_probs_8x8 [i][j][k][t];
+              vp8_prob *Pold = cpi->common.fc.hybrid_coef_probs_8x8 [i][j][k] + t;
+              const vp8_prob oldp = *Pold;
+              const vp8_prob upd = COEF_UPDATE_PROB_8X8;
+              int s, u;
+              if (k >= 3 && ((i == 0 && j == 1) ||
+                             (i > 0 && j == 0)))
+                continue;
+#if defined(SEARCH_NEWP)
+              s = prob_diff_update_savings_search(ct, oldp, &newp, upd);
+              u = s > 0 && newp != oldp ? 1 : 0;
+#else
+              s = prob_update_savings(ct, oldp, newp, upd);
+              u = s > 0 ? 1 : 0;
+#endif
+              vp8_write(w, u, upd);
+#ifdef ENTROPY_STATS
+              if (!cpi->dummy_packing)
+                ++ hybrid_tree_update_hist_8x8 [i][j][k][t] [u];
+#endif
+              if (u) {
+                /* send/use new probability */
+                write_prob_diff_update(w, newp, oldp);
+                *Pold = newp;
+              }
+            }
+          }
+        }
+      }
+    }
+#endif
   }
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
   // 16x16
   /* dry run to see if update is necessary */
   update[0] = update[1] = 0;
@@ -1999,6 +2252,81 @@ static void update_coef_probs(VP8_COMP *cpi) {
       }
     }
   }
+#if CONFIG_HYBRIDTRANSFORM16X16
+  update[0] = update[1] = 0;
+  savings = 0;
+  for (i = 0; i < BLOCK_TYPES_16X16; ++i) {
+    for (j = !i; j < COEF_BANDS; ++j) {
+      for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+        // calc probs and branch cts for this frame only
+        for (t = 0; t < ENTROPY_NODES; ++t) {
+          const unsigned int *ct  = cpi->frame_hybrid_branch_ct_16x16[i][j][k][t];
+          vp8_prob newp = cpi->frame_hybrid_coef_probs_16x16[i][j][k][t];
+          vp8_prob *Pold = cpi->common.fc.hybrid_coef_probs_16x16[i][j][k] + t;
+          const vp8_prob oldp = *Pold;
+          int s, u;
+          const vp8_prob upd = COEF_UPDATE_PROB_16X16;
+          if (k >= 3 && ((i == 0 && j == 1) || (i > 0 && j == 0)))
+            continue;
+#if defined(SEARCH_NEWP)
+          s = prob_diff_update_savings_search(ct, oldp, &newp, upd);
+          u = s > 0 && newp != oldp ? 1 : 0;
+          if (u)
+            savings += s - (int)(vp8_cost_zero(upd));
+          else
+            savings -= (int)(vp8_cost_zero(upd));
+#else
+          s = prob_update_savings(ct, oldp, newp, upd);
+          u = s > 0 ? 1 : 0;
+          if (u)
+            savings += s;
+#endif
+          update[u]++;
+        }
+      }
+    }
+  }
+
+  if (update[1] == 0 || savings < 0)
+    vp8_write_bit(w, 0);
+  else {
+    vp8_write_bit(w, 1);
+    for (i = 0; i < BLOCK_TYPES_16X16; ++i) {
+      for (j = !i; j < COEF_BANDS; ++j) {
+        for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
+          for (t = 0; t < ENTROPY_NODES; ++t) {
+            const unsigned int *ct  = cpi->frame_hybrid_branch_ct_16x16[i][j][k][t];
+            vp8_prob newp = cpi->frame_hybrid_coef_probs_16x16[i][j][k][t];
+            vp8_prob *Pold = cpi->common.fc.hybrid_coef_probs_16x16[i][j][k] + t;
+            const vp8_prob oldp = *Pold;
+            const vp8_prob upd = COEF_UPDATE_PROB_16X16;
+            int s, u;
+            if (k >= 3 && ((i == 0 && j == 1) ||
+                           (i > 0 && j == 0)))
+              continue;
+#if defined(SEARCH_NEWP)
+            s = prob_diff_update_savings_search(ct, oldp, &newp, upd);
+            u = s > 0 && newp != oldp ? 1 : 0;
+#else
+            s = prob_update_savings(ct, oldp, newp, upd);
+            u = s > 0 ? 1 : 0;
+#endif
+            vp8_write(w, u, upd);
+#ifdef ENTROPY_STATS
+            if (!cpi->dummy_packing)
+              ++hybrid_tree_update_hist_16x16[i][j][k][t][u];
+#endif
+            if (u) {
+              /* send/use new probability */
+              write_prob_diff_update(w, newp, oldp);
+              *Pold = newp;
+            }
+          }
+        }
+      }
+    }
+  }
+#endif
 #endif
 }
 
@@ -2432,9 +2760,18 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size)
   vp8_clear_system_state();  // __asm emms;
 
   vp8_copy(cpi->common.fc.pre_coef_probs, cpi->common.fc.coef_probs);
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_copy(cpi->common.fc.pre_hybrid_coef_probs, cpi->common.fc.hybrid_coef_probs);
+#endif
   vp8_copy(cpi->common.fc.pre_coef_probs_8x8, cpi->common.fc.coef_probs_8x8);
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_copy(cpi->common.fc.pre_hybrid_coef_probs_8x8, cpi->common.fc.hybrid_coef_probs_8x8);
+#endif
+#if CONFIG_TX16X16
   vp8_copy(cpi->common.fc.pre_coef_probs_16x16, cpi->common.fc.coef_probs_16x16);
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_copy(cpi->common.fc.pre_hybrid_coef_probs_16x16, cpi->common.fc.hybrid_coef_probs_16x16);
+#endif
 #endif
   vp8_copy(cpi->common.fc.pre_ymode_prob, cpi->common.fc.ymode_prob);
   vp8_copy(cpi->common.fc.pre_uv_mode_prob, cpi->common.fc.uv_mode_prob);
@@ -2452,11 +2789,8 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size)
   vp8_zero(cpi->mbsplit_count);
   vp8_zero(cpi->common.fc.mv_ref_ct)
   vp8_zero(cpi->common.fc.mv_ref_ct_a)
-#if COEFUPDATETYPE == 2
-  update_coef_probs2(cpi);
-#else
+
   update_coef_probs(cpi);
-#endif
 
 #ifdef ENTROPY_STATS
   active_section = 2;

diff --git a/vp8/encoder/block.h b/vp8/encoder/block.h
index c0cd2e7833ad9f42167ff2b090e6054ae2270058..a204c8b601f8b61c64e183783a91fbf6d8cf96d3 100644 (file)
--- a/vp8/encoder/block.h
+++ b/vp8/encoder/block.h
@@ -167,6 +167,10 @@ typedef struct {
 
   unsigned int token_costs[TX_SIZE_MAX][BLOCK_TYPES][COEF_BANDS]
     [PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS];
+#if CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM16X16
+  unsigned int hybrid_token_costs[TX_SIZE_MAX][BLOCK_TYPES][COEF_BANDS]
+    [PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS];
+#endif
 
   int optimize;
   int q_index;

diff --git a/vp8/encoder/dct.c b/vp8/encoder/dct.c
index f5c666e245624ced0feeb4fb885700d75d160da0..209ba20b5809c14e89f21fdd417c239b7b3aedea 100644 (file)
--- a/vp8/encoder/dct.c
+++ b/vp8/encoder/dct.c
@@ -478,10 +478,11 @@ void vp8_fht_c(short *input, short *output, int pitch,
         pfa[i] += pfb[k] * pth[k];
       }
       pth += tx_dim;
-     }
+    }
 
     pfa += tx_dim;
     pfb += tx_dim;
+    // pth -= tx_dim * tx_dim;
 
     switch(tx_type) {
       case ADST_ADST :

diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c
index 9b793e20ab7fba495dac8f78f2eed9fbd623f302..584570da9577a553bf96212b4ceb3f7c7d5e2aec 100644 (file)
--- a/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@ -1297,6 +1297,8 @@ static void encode_frame_internal(VP8_COMP *cpi) {
   TOKENEXTRA *tp = cpi->tok;
   int totalrate;
 
+  //printf("encode_frame_internal\n");
+
   // Compute a modified set of reference frame probabilities to use when
   // prediction fails. These are based on the current general estimates for
   // this frame which may be updated with each iteration of the recode loop.
@@ -1360,9 +1362,18 @@ static void encode_frame_internal(VP8_COMP *cpi) {
   vp8_zero(cpi->MVcount_hp);
 #endif
   vp8_zero(cpi->coef_counts);
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_zero(cpi->hybrid_coef_counts);
+#endif
   vp8_zero(cpi->coef_counts_8x8);
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_zero(cpi->hybrid_coef_counts_8x8);
+#endif
+#if CONFIG_TX16X16
   vp8_zero(cpi->coef_counts_16x16);
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_zero(cpi->hybrid_coef_counts_16x16);
+#endif
 #endif
 
   vp8cx_frame_init_quantizer(cpi);

diff --git a/vp8/encoder/encodeintra.c b/vp8/encoder/encodeintra.c
index c2f123c9268a4e6073d699a0953b659eb0c66744..d8757c5317050122b18f158779ce996c514fabb7 100644 (file)
--- a/vp8/encoder/encodeintra.c
+++ b/vp8/encoder/encodeintra.c
@@ -85,21 +85,21 @@ void vp8_encode_intra4x4block(const VP8_ENCODER_RTCD *rtcd,
   ENCODEMB_INVOKE(&rtcd->encodemb, subb)(be, b, 16);
 
 #if CONFIG_HYBRIDTRANSFORM
-    if(active_ht) {
-      b->bmi.as_mode.test = b->bmi.as_mode.first;
-      txfm_map(b, b->bmi.as_mode.first);
-      vp8_fht_c(be->src_diff, be->coeff, 32, b->bmi.as_mode.tx_type, 4);
-      vp8_ht_quantize_b(be, b);
-      vp8_inverse_htransform_b(IF_RTCD(&rtcd->common->idct), b, 32) ;
-    } else {
-      x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32) ;
-      x->quantize_b(be, b) ;
-      vp8_inverse_transform_b(IF_RTCD(&rtcd->common->idct), b, 32) ;
-    }
+  if (active_ht) {
+    b->bmi.as_mode.test = b->bmi.as_mode.first;
+    txfm_map(b, b->bmi.as_mode.first);
+    vp8_fht_c(be->src_diff, be->coeff, 32, b->bmi.as_mode.tx_type, 4);
+    vp8_ht_quantize_b(be, b);
+    vp8_inverse_htransform_b(IF_RTCD(&rtcd->common->idct), b, 32) ;
+  } else {
+    x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32) ;
+    x->quantize_b(be, b) ;
+    vp8_inverse_transform_b(IF_RTCD(&rtcd->common->idct), b, 32) ;
+  }
 #else
-    x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32);
-    x->quantize_b(be, b);
-    vp8_inverse_transform_b(IF_RTCD(&rtcd->common->idct), b, 32);
+  x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32);
+  x->quantize_b(be, b);
+  vp8_inverse_transform_b(IF_RTCD(&rtcd->common->idct), b, 32);
 #endif
 
   RECON_INVOKE(&rtcd->common->recon, recon)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
@@ -298,7 +298,6 @@ void vp8_encode_intra8x8(const VP8_ENCODER_RTCD *rtcd,
   }
 }
 
-extern const int vp8_i8x8_block[4];
 void vp8_encode_intra8x8mby(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) {
   int i, ib;
 

diff --git a/vp8/encoder/encodemb.c b/vp8/encoder/encodemb.c
index a66dbe884065fce685385c151424b701d3f85158..66b9fb970f68769dda5b548e2a895e7edbd2ac69 100644 (file)
--- a/vp8/encoder/encodemb.c
+++ b/vp8/encoder/encodemb.c
@@ -1239,4 +1239,3 @@ void vp8_encode_inter16x16y(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *x) {
   RECON_INVOKE(&rtcd->common->recon, recon_mby)
   (IF_RTCD(&rtcd->common->recon), &x->e_mbd);
 }
-

diff --git a/vp8/encoder/onyx_if.c b/vp8/encoder/onyx_if.c
index ca6570e68b17dee9d7891493e7c9360a84a9d4eb..9a88eddb976fd0fd4b02dceb3c2458cb4cd0d416 100644 (file)
--- a/vp8/encoder/onyx_if.c
+++ b/vp8/encoder/onyx_if.c
@@ -3048,6 +3048,7 @@ static void encode_frame_to_data_rate
   // Clear down mmx registers to allow floating point in what follows
   vp8_clear_system_state();
 
+
   // For an alt ref frame in 2 pass we skip the call to the second
   // pass function that sets the target bandwidth so must set it here
   if (cpi->common.refresh_alt_ref_frame) {
@@ -3758,9 +3759,19 @@ static void encode_frame_to_data_rate
 
   update_reference_frames(cm);
   vp8_copy(cpi->common.fc.coef_counts, cpi->coef_counts);
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_copy(cpi->common.fc.hybrid_coef_counts, cpi->hybrid_coef_counts);
+#endif
   vp8_copy(cpi->common.fc.coef_counts_8x8, cpi->coef_counts_8x8);
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_copy(cpi->common.fc.hybrid_coef_counts_8x8, cpi->hybrid_coef_counts_8x8);
+#endif
+#if CONFIG_TX16X16
   vp8_copy(cpi->common.fc.coef_counts_16x16, cpi->coef_counts_16x16);
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_copy(cpi->common.fc.hybrid_coef_counts_16x16,
+           cpi->hybrid_coef_counts_16x16);
+#endif
 #endif
   vp8_adapt_coef_probs(&cpi->common);
   if (cpi->common.frame_type != KEY_FRAME) {
@@ -4330,8 +4341,9 @@ int vp8_get_compressed_data(VP8_PTR ptr, unsigned int *frame_flags, unsigned lon
     Pass1Encode(cpi, size, dest, frame_flags);
   } else if (cpi->pass == 2) {
     Pass2Encode(cpi, size, dest, frame_flags);
-  } else
+  } else {
     encode_frame_to_data_rate(cpi, size, dest, frame_flags);
+  }
 
   if (cm->refresh_entropy_probs) {
     if (cm->refresh_alt_ref_frame)

diff --git a/vp8/encoder/onyx_int.h b/vp8/encoder/onyx_int.h
index 159cb8527ba09c79df9e414431ac9e941731e6e2..5cc87d7a914c61a69a9b841990249245b08a4a39 100644 (file)
--- a/vp8/encoder/onyx_int.h
+++ b/vp8/encoder/onyx_int.h
@@ -97,11 +97,25 @@ typedef struct {
 
   vp8_prob coef_probs[BLOCK_TYPES]
       [COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES];
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_prob hybrid_coef_probs[BLOCK_TYPES]
+      [COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES];
+#endif
+
   vp8_prob coef_probs_8x8[BLOCK_TYPES_8X8]
       [COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES];
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_prob hybrid_coef_probs_8x8[BLOCK_TYPES_8X8]
+      [COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES];
+#endif
+
+#if CONFIG_TX16X16
   vp8_prob coef_probs_16x16[BLOCK_TYPES_16X16]
       [COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES];
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_prob hybrid_coef_probs_16x16[BLOCK_TYPES_16X16]
+      [COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES];
+#endif
 #endif
 
   vp8_prob ymode_prob [VP8_YMODES - 1]; /* interframe intra mode probs */
@@ -557,17 +571,32 @@ typedef struct VP8_COMP {
 #endif
 
   unsigned int coef_counts [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];  /* for this frame */
-  // DECLARE_ALIGNED(16, int, coef_counts_backup [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]);   //not used any more
-  // save vp8_tree_probs_from_distribution result for each frame to avoid repeat calculation
   vp8_prob frame_coef_probs [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
   unsigned int frame_branch_ct [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES][2];
+#if CONFIG_HYBRIDTRANSFORM
+  unsigned int hybrid_coef_counts [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];  /* for this frame */
+  vp8_prob frame_hybrid_coef_probs [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+  unsigned int frame_hybrid_branch_ct [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES][2];
+#endif
+
   unsigned int coef_counts_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];  /* for this frame */
   vp8_prob frame_coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
   unsigned int frame_branch_ct_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES][2];
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+  unsigned int hybrid_coef_counts_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];  /* for this frame */
+  vp8_prob frame_hybrid_coef_probs_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+  unsigned int frame_hybrid_branch_ct_8x8 [BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES][2];
+#endif
+
+#if CONFIG_TX16X16
   unsigned int coef_counts_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];  /* for this frame */
   vp8_prob frame_coef_probs_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
   unsigned int frame_branch_ct_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES][2];
+#if CONFIG_HYBRIDTRANSFORM16X16
+  unsigned int hybrid_coef_counts_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];  /* for this frame */
+  vp8_prob frame_hybrid_coef_probs_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES];
+  unsigned int frame_hybrid_branch_ct_16x16 [BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [ENTROPY_NODES][2];
+#endif
 #endif
 
   int gfu_boost;

diff --git a/vp8/encoder/ratectrl.c b/vp8/encoder/ratectrl.c
index b7fd07e82305074cafc7b3de3b495931e6cf4c89..e059a10e248d11a6a5b1b2e1d0e203bd14dee834 100644 (file)
--- a/vp8/encoder/ratectrl.c
+++ b/vp8/encoder/ratectrl.c
@@ -178,12 +178,21 @@ void vp8_save_coding_context(VP8_COMP *cpi) {
   vp8_copy(cc->last_mode_lf_deltas, xd->last_mode_lf_deltas);
 
   vp8_copy(cc->coef_probs, cm->fc.coef_probs);
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_copy(cc->hybrid_coef_probs, cm->fc.hybrid_coef_probs);
+#endif
   vp8_copy(cc->coef_probs_8x8, cm->fc.coef_probs_8x8);
-#if CONFIG_SWITCHABLE_INTERP
-  vp8_copy(cc->switchable_interp_prob, cm->fc.switchable_interp_prob);
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_copy(cc->hybrid_coef_probs_8x8, cm->fc.hybrid_coef_probs_8x8);
 #endif
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
   vp8_copy(cc->coef_probs_16x16, cm->fc.coef_probs_16x16);
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_copy(cc->hybrid_coef_probs_16x16, cm->fc.hybrid_coef_probs_16x16);
+#endif
+#endif
+#if CONFIG_SWITCHABLE_INTERP
+  vp8_copy(cc->switchable_interp_prob, cm->fc.switchable_interp_prob);
 #endif
 }
 
@@ -242,12 +251,21 @@ void vp8_restore_coding_context(VP8_COMP *cpi) {
   vp8_copy(xd->last_mode_lf_deltas, cc->last_mode_lf_deltas);
 
   vp8_copy(cm->fc.coef_probs, cc->coef_probs);
+#if CONFIG_HYBRIDTRANSFORM
+  vp8_copy(cm->fc.hybrid_coef_probs, cc->hybrid_coef_probs);
+#endif
   vp8_copy(cm->fc.coef_probs_8x8, cc->coef_probs_8x8);
-#if CONFIG_SWITCHABLE_INTERP
-  vp8_copy(cm->fc.switchable_interp_prob, cc->switchable_interp_prob);
+#if CONFIG_HYBRIDTRANSFORM8X8
+  vp8_copy(cm->fc.hybrid_coef_probs_8x8, cc->hybrid_coef_probs_8x8);
 #endif
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
   vp8_copy(cm->fc.coef_probs_16x16, cc->coef_probs_16x16);
+#if CONFIG_HYBRIDTRANSFORM16X16
+  vp8_copy(cm->fc.hybrid_coef_probs_16x16, cc->hybrid_coef_probs_16x16);
+#endif
+#endif
+#if CONFIG_SWITCHABLE_INTERP
+  vp8_copy(cm->fc.switchable_interp_prob, cc->switchable_interp_prob);
 #endif
 }
 

diff --git a/vp8/encoder/rdopt.c b/vp8/encoder/rdopt.c
index fd03fdb40a68db67c3e10741ab6d392d2d4c934f..0613355fc00c62be3fa0ce75ea25a5835604e6ce 100644 (file)
--- a/vp8/encoder/rdopt.c
+++ b/vp8/encoder/rdopt.c
@@ -41,6 +41,7 @@
 
 #include "vp8/common/seg_common.h"
 #include "vp8/common/pred_common.h"
+#include "vp8/common/entropy.h"
 
 #if CONFIG_NEWBESTREFMV
 #include "vp8/common/mvref_common.h"
@@ -358,17 +359,38 @@ void vp8_initialize_rd_consts(VP8_COMP *cpi, int QIndex) {
     cpi->mb.token_costs[TX_4X4],
     (const vp8_prob( *)[8][PREV_COEF_CONTEXTS][11]) cpi->common.fc.coef_probs,
     BLOCK_TYPES);
+#if CONFIG_HYBRIDTRANSFORM
+  fill_token_costs(
+    cpi->mb.hybrid_token_costs[TX_4X4],
+    (const vp8_prob( *)[8][PREV_COEF_CONTEXTS][11])
+    cpi->common.fc.hybrid_coef_probs,
+    BLOCK_TYPES);
+#endif
 
   fill_token_costs(
     cpi->mb.token_costs[TX_8X8],
     (const vp8_prob( *)[8][PREV_COEF_CONTEXTS][11]) cpi->common.fc.coef_probs_8x8,
     BLOCK_TYPES_8X8);
+#if CONFIG_HYBRIDTRANSFORM8X8
+  fill_token_costs(
+    cpi->mb.hybrid_token_costs[TX_8X8],
+    (const vp8_prob( *)[8][PREV_COEF_CONTEXTS][11])
+    cpi->common.fc.hybrid_coef_probs_8x8,
+    BLOCK_TYPES_8X8);
+#endif
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
   fill_token_costs(
     cpi->mb.token_costs[TX_16X16],
     (const vp8_prob(*)[8][PREV_COEF_CONTEXTS][11]) cpi->common.fc.coef_probs_16x16,
     BLOCK_TYPES_16X16);
+#if CONFIG_HYBRIDTRANSFORM16X16
+  fill_token_costs(
+    cpi->mb.hybrid_token_costs[TX_16X16],
+    (const vp8_prob(*)[8][PREV_COEF_CONTEXTS][11])
+    cpi->common.fc.hybrid_coef_probs_16x16,
+    BLOCK_TYPES_16X16);
+#endif
 #endif
 
   /*rough estimate for costing*/
@@ -582,44 +604,44 @@ static int cost_coeffs_2x2(MACROBLOCK *mb,
 
 static int cost_coeffs(MACROBLOCK *mb, BLOCKD *b, int type,
                        ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
-                       int tx_type) {
+                       int tx_size) {
   const int eob = b->eob;
   int c = !type;              /* start at coef 0, unless Y with Y2 */
   int cost = 0, default_eob, seg_eob;
   int pt;                     /* surrounding block/prev coef predictor */
   int const *scan, *band;
   short *qcoeff_ptr = b->qcoeff;
-  MB_MODE_INFO * mbmi = &mb->e_mbd.mode_info_context->mbmi;
-
+  MACROBLOCKD *xd = &mb->e_mbd;
+  MB_MODE_INFO *mbmi = &mb->e_mbd.mode_info_context->mbmi;
+#if CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM16X16
+  TX_TYPE tx_type = DCT_DCT;
+#endif
   int segment_id = mbmi->segment_id;
 
-  switch (tx_type) {
+  switch (tx_size) {
     case TX_4X4:
       scan = vp8_default_zig_zag1d;
       band = vp8_coef_bands;
       default_eob = 16;
 #if CONFIG_HYBRIDTRANSFORM
-      {
-        int active_ht = (mb->q_index < ACTIVE_HT) &&
-                        (mbmi->mode_rdopt == B_PRED);
-
-        if((type == PLANE_TYPE_Y_WITH_DC) && active_ht) {
-          switch (b->bmi.as_mode.tx_type) {
-            case ADST_DCT:
-              scan = vp8_row_scan;
-              break;
-
-            case DCT_ADST:
-              scan = vp8_col_scan;
-              break;
-
-            default:
-              scan = vp8_default_zig_zag1d;
-              break;
-          }
+      if (type == PLANE_TYPE_Y_WITH_DC &&
+          mb->q_index < ACTIVE_HT &&
+          mbmi->mode_rdopt == B_PRED) {
+        tx_type = b->bmi.as_mode.tx_type;
+        switch (tx_type) {
+          case ADST_DCT:
+            scan = vp8_row_scan;
+            break;
+
+          case DCT_ADST:
+            scan = vp8_col_scan;
+            break;
+
+          default:
+            scan = vp8_default_zig_zag1d;
+            break;
+        }
 
-        } else
-          scan = vp8_default_zig_zag1d;
       }
 #endif
       break;
@@ -627,12 +649,29 @@ static int cost_coeffs(MACROBLOCK *mb, BLOCKD *b, int type,
       scan = vp8_default_zig_zag1d_8x8;
       band = vp8_coef_bands_8x8;
       default_eob = 64;
+#if CONFIG_HYBRIDTRANSFORM8X8
+      {
+        BLOCKD *bb;
+        int ib = (b - xd->block);
+        if (ib >= 16) tx_type = DCT_DCT;
+        ib = (ib & 8) + ((ib & 4) >> 1);
+        bb = xd->block + ib;
+        if (mbmi->mode_rdopt == I8X8_PRED)
+          tx_type = bb->bmi.as_mode.tx_type;
+      }
+#endif
       break;
 #if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
     case TX_16X16:
       scan = vp8_default_zig_zag1d_16x16;
       band = vp8_coef_bands_16x16;
       default_eob = 256;
+#if CONFIG_HYBRIDTRANSFORM16X16
+      if (type == PLANE_TYPE_Y_WITH_DC &&
+          mbmi->mode_rdopt < I8X8_PRED &&
+          mb->q_index < ACTIVE_HT16)
+          tx_type = b->bmi.as_mode.tx_type;
+#endif
       break;
 #endif
     default:
@@ -643,21 +682,37 @@ static int cost_coeffs(MACROBLOCK *mb, BLOCKD *b, int type,
   else
     seg_eob = default_eob;
 
+  //mbmi->mode = mode;
 
   VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
 
-  for (; c < eob; c++) {
-    int v = qcoeff_ptr[scan[c]];
-    int t = vp8_dct_value_tokens_ptr[v].Token;
-    cost += mb->token_costs[tx_type][type][band[c]][pt][t];
-    cost += vp8_dct_value_cost_ptr[v];
-    pt = vp8_prev_token_class[t];
+#if CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM16X16
+  if (tx_type != DCT_DCT) {
+    for (; c < eob; c++) {
+      int v = qcoeff_ptr[scan[c]];
+      int t = vp8_dct_value_tokens_ptr[v].Token;
+      cost += mb->hybrid_token_costs[tx_size][type][band[c]][pt][t];
+      cost += vp8_dct_value_cost_ptr[v];
+      pt = vp8_prev_token_class[t];
+    }
+    if (c < seg_eob)
+      cost += mb->hybrid_token_costs[tx_size][type][band[c]]
+          [pt][DCT_EOB_TOKEN];
+  } else
+#endif
+  {
+    for (; c < eob; c++) {
+      int v = qcoeff_ptr[scan[c]];
+      int t = vp8_dct_value_tokens_ptr[v].Token;
+      cost += mb->token_costs[tx_size][type][band[c]][pt][t];
+      cost += vp8_dct_value_cost_ptr[v];
+      pt = vp8_prev_token_class[t];
+    }
+    if (c < seg_eob)
+      cost += mb->token_costs[tx_size][type][band[c]]
+          [pt][DCT_EOB_TOKEN];
   }
 
-  if (c < seg_eob)
-    cost += mb->token_costs[tx_type][type][band[c]]
-            [pt][DCT_EOB_TOKEN];
-
   pt = (c != !type); // is eob first coefficient;
   *a = *l = pt;
   return cost;
@@ -816,6 +871,7 @@ static int vp8_rdcost_mby_16x16(MACROBLOCK *mb) {
   cost = cost_coeffs(mb, xd->block, PLANE_TYPE_Y_WITH_DC, ta, tl, TX_16X16);
   return cost;
 }
+
 static void macro_block_yrd_16x16(MACROBLOCK *mb, int *Rate, int *Distortion,
                                   const VP8_ENCODER_RTCD *rtcd) {
   int d;
@@ -1427,7 +1483,6 @@ static int64_t rd_pick_intra8x8block(VP8_COMP *cpi, MACROBLOCK *x, int ib,
   return best_rd;
 }
 
-const int vp8_i8x8_block[4] = {0, 2, 8, 10};
 int64_t rd_pick_intra8x8mby_modes(VP8_COMP *cpi, MACROBLOCK *mb,
                                   int *Rate, int *rate_y,
                                   int *Distortion, int64_t best_rd) {

diff --git a/vp8/encoder/tokenize.c b/vp8/encoder/tokenize.c
index d992e1fe6d723577480eb414313ffef7f9fe2ff5..91fafd0883e79c1a8c003c96225adff70b66d4f3 100644 (file)
--- a/vp8/encoder/tokenize.c
+++ b/vp8/encoder/tokenize.c
@@ -19,23 +19,48 @@
 
 #include "vp8/common/pred_common.h"
 #include "vp8/common/seg_common.h"
+#include "vp8/common/entropy.h"
 
 /* Global event counters used for accumulating statistics across several
    compressions, then generating context.c = initial stats. */
 
 #ifdef ENTROPY_STATS
 INT64 context_counters[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+#if CONFIG_HYBRIDTRANSFORM
+INT64 hybrid_context_counters[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+#endif
+
 INT64 context_counters_8x8[BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+INT64 hybrid_context_counters_8x8[BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+#endif
+
+#if CONFIG_TX16X16
 INT64 context_counters_16x16[BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+#if CONFIG_HYBRIDTRANSFORM16X16
+INT64 hybrid_context_counters_16x16[BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
 #endif
+#endif
+
 extern unsigned int tree_update_hist[BLOCK_TYPES][COEF_BANDS]
                     [PREV_COEF_CONTEXTS][ENTROPY_NODES][2];
+#if CONFIG_HYBRIDTRANSFORM
+extern unsigned int hybrid_tree_update_hist[BLOCK_TYPES][COEF_BANDS]
+                    [PREV_COEF_CONTEXTS][ENTROPY_NODES][2];
+#endif
 extern unsigned int tree_update_hist_8x8[BLOCK_TYPES_8X8][COEF_BANDS]
                     [PREV_COEF_CONTEXTS][ENTROPY_NODES] [2];
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_HYBRIDTRANSFORM8X8
+extern unsigned int hybrid_tree_update_hist_8x8[BLOCK_TYPES_8X8][COEF_BANDS]
+                    [PREV_COEF_CONTEXTS][ENTROPY_NODES] [2];
+#endif
+#if CONFIG_TX16X16
 extern unsigned int tree_update_hist_16x16[BLOCK_TYPES_16X16][COEF_BANDS]
                     [PREV_COEF_CONTEXTS][ENTROPY_NODES] [2];
+#if CONFIG_HYBRIDTRANSFORM16X16
+extern unsigned int hybrid_tree_update_hist_16x16[BLOCK_TYPES_16X16][COEF_BANDS]
+                    [PREV_COEF_CONTEXTS][ENTROPY_NODES] [2];
+#endif
 #endif
 #endif
 void vp8_stuff_mb(VP8_COMP *cpi,
@@ -44,7 +69,7 @@ void vp8_stuff_mb_8x8(VP8_COMP *cpi,
                       MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
 void vp8_stuff_mb_8x8_4x4uv(VP8_COMP *cpi,
                             MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
 void vp8_stuff_mb_16x16(VP8_COMP *cpi, MACROBLOCKD *xd,
                         TOKENEXTRA **t, int dry_run);
 #endif
@@ -108,7 +133,7 @@ static void fill_value_tokens() {
   vp8_dct_value_cost_ptr   = dct_value_cost + DCT_MAX_VALUE;
 }
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
 static void tokenize1st_order_b_16x16(MACROBLOCKD *xd,
                                       const BLOCKD *const b,
                                       TOKENEXTRA **tp,
@@ -124,10 +149,15 @@ static void tokenize1st_order_b_16x16(MACROBLOCKD *xd,
   TOKENEXTRA *t = *tp;        /* store tokens starting here */
   int x;
   const short *qcoeff_ptr = b->qcoeff;
+#if CONFIG_HYBRIDTRANSFORM16X16
+  TX_TYPE tx_type = get_tx_type(xd, b);
+#endif
 
   int seg_eob = 256;
   int segment_id = xd->mode_info_context->mbmi.segment_id;
 
+  //if (!dry_run) printf("16: %d\n", tx_type);
+
   if (segfeature_active(xd, segment_id, SEG_LVL_EOB))
     seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB);
 
@@ -149,11 +179,22 @@ static void tokenize1st_order_b_16x16(MACROBLOCKD *xd,
     }
 
     t->Token = x;
-    t->context_tree = cpi->common.fc.coef_probs_16x16[type][band][pt];
+#if CONFIG_HYBRIDTRANSFORM16X16
+    if (tx_type != DCT_DCT)
+      t->context_tree = cpi->common.fc.hybrid_coef_probs_16x16[type][band][pt];
+    else
+#endif
+      t->context_tree = cpi->common.fc.coef_probs_16x16[type][band][pt];
 
     t->skip_eob_node = pt == 0 && ((band > 0 && type > 0) || (band > 1 && type == 0));
-    if (!dry_run)
-      ++cpi->coef_counts_16x16[type][band][pt][x];
+    if (!dry_run) {
+#if CONFIG_HYBRIDTRANSFORM16X16
+      if (tx_type != DCT_DCT)
+        ++cpi->hybrid_coef_counts_16x16[type][band][pt][x];
+      else
+#endif
+        ++cpi->coef_counts_16x16[type][band][pt][x];
+    }
   } while (pt = vp8_prev_token_class[x], ++t, c < eob  &&  ++c < seg_eob);
 
   *tp = t;
@@ -304,6 +345,9 @@ static void tokenize1st_order_b_8x8
   int c = type ? 0 : 1;       /* start at DC unless type 0 */
   TOKENEXTRA *t = *tp;        /* store tokens starting here */
   const short *qcoeff_ptr = b->qcoeff;
+#if CONFIG_HYBRIDTRANSFORM8X8
+  TX_TYPE tx_type = type == 3 ? get_tx_type(xd, b) : DCT_DCT;
+#endif
 
   int seg_eob = 64;
   int segment_id = xd->mode_info_context->mbmi.segment_id;
@@ -313,6 +357,7 @@ static void tokenize1st_order_b_8x8
 
   VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
 
+  //if (!dry_run) printf("8: %d\n", tx_type);
   for (; c < b->eob; ++c) {
     const int band = vp8_coef_bands_8x8[c];
     int rc = vp8_default_zig_zag1d_8x8[c];
@@ -324,12 +369,23 @@ static void tokenize1st_order_b_8x8
     x        = vp8_dct_value_tokens_ptr[v].Token;
 
     t->Token = x;
-    t->context_tree = cpi->common.fc.coef_probs_8x8[type][band][pt];
+#if CONFIG_HYBRIDTRANSFORM8X8
+    if (tx_type != DCT_DCT)
+      t->context_tree = cpi->common.fc.hybrid_coef_probs_8x8[type][band][pt];
+    else
+#endif
+      t->context_tree = cpi->common.fc.coef_probs_8x8[type][band][pt];
 
     t->skip_eob_node = pt == 0 && ((band > 0 && type > 0) || (band > 1 && type == 0));
 
-    if (!dry_run)
-      ++cpi->coef_counts_8x8[type][band][pt][x];
+    if (!dry_run) {
+#if CONFIG_HYBRIDTRANSFORM8X8
+      if (tx_type != DCT_DCT)
+        ++cpi->hybrid_coef_counts_8x8[type][band][pt][x];
+      else
+#endif
+        ++cpi->coef_counts_8x8[type][band][pt][x];
+    }
 
     pt = vp8_prev_token_class[x];
     ++t;
@@ -339,11 +395,23 @@ static void tokenize1st_order_b_8x8
     const int band = vp8_coef_bands_8x8[c];
     t->Token = DCT_EOB_TOKEN;
 
-    t->context_tree = cpi->common.fc.coef_probs_8x8 [type] [band] [pt];
+#if CONFIG_HYBRIDTRANSFORM8X8
+    if (tx_type != DCT_DCT)
+      t->context_tree = cpi->common.fc.hybrid_coef_probs_8x8 [type] [band] [pt];
+    else
+#endif
+      t->context_tree = cpi->common.fc.coef_probs_8x8 [type] [band] [pt];
+
     t->skip_eob_node = pt == 0 && ((band > 0 && type > 0) || (band > 1 && type == 0));
 
-    if (!dry_run)
-      ++cpi->coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN];
+    if (!dry_run) {
+#if CONFIG_HYBRIDTRANSFORM8X8
+      if (tx_type != DCT_DCT)
+        ++cpi->hybrid_coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN];
+      else
+#endif
+        ++cpi->coef_counts_8x8[type][band][pt][DCT_EOB_TOKEN];
+    }
     ++t;
   }
 
@@ -384,10 +452,13 @@ static void tokenize1st_order_ht(   MACROBLOCKD *xd,
   /* Luma */
   for (block = 0; block < 16; block++, b++) {
     B_PREDICTION_MODE b_mode;
+    TX_TYPE tx_type = DCT_DCT;
 
     if( xd->mode_info_context->mbmi.mode == B_PRED ) {
       b_mode = b->bmi.as_mode.first;
+      tx_type = get_tx_type(xd, b);
     }
+    //if (!dry_run) printf("4: %d\n", tx_type);
 
     // assign scanning order for luma components coded in intra4x4 mode
     if( (xd->mode_info_context->mbmi.mode == B_PRED) &&
@@ -430,13 +501,20 @@ static void tokenize1st_order_ht(   MACROBLOCKD *xd,
       token    = vp8_dct_value_tokens_ptr[v].Token;
 
       t->Token = token;
-      t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt];
+      if (tx_type != DCT_DCT)
+        t->context_tree = cpi->common.fc.hybrid_coef_probs [type] [band] [pt];
+      else
+        t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt];
 
       t->skip_eob_node = pt == 0 &&
           ((band > 0 && type > 0) || (band > 1 && type == 0));
 
-      if (!dry_run)
-        ++cpi->coef_counts       [type] [band] [pt] [token];
+      if (!dry_run) {
+        if (tx_type != DCT_DCT)
+          ++cpi->hybrid_coef_counts[type] [band] [pt] [token];
+        else
+          ++cpi->coef_counts       [type] [band] [pt] [token];
+      }
 
       pt = vp8_prev_token_class[token];
       t++;
@@ -445,12 +523,19 @@ static void tokenize1st_order_ht(   MACROBLOCKD *xd,
     if (c < seg_eob) {
       band = vp8_coef_bands[c];
       t->Token = DCT_EOB_TOKEN;
-      t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt];
+      if (tx_type != DCT_DCT)
+        t->context_tree = cpi->common.fc.hybrid_coef_probs [type] [band] [pt];
+      else
+        t->context_tree = cpi->common.fc.coef_probs [type] [band] [pt];
 
       t->skip_eob_node = pt == 0 &&
           ((band > 0 && type > 0) || (band > 1 && type == 0));
-      if (!dry_run)
-        ++cpi->coef_counts       [type] [band] [pt] [DCT_EOB_TOKEN];
+      if (!dry_run) {
+        if (tx_type != DCT_DCT)
+          ++cpi->hybrid_coef_counts[type] [band] [pt] [DCT_EOB_TOKEN];
+        else
+          ++cpi->coef_counts       [type] [band] [pt] [DCT_EOB_TOKEN];
+      }
 
       t++;
     }
@@ -787,7 +872,7 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
   int plane_type;
   int has_y2_block;
   int b;
-  int tx_type = xd->mode_info_context->mbmi.txfm_size;
+  int tx_size = xd->mode_info_context->mbmi.txfm_size;
   int mb_skip_context = get_pred_context(&cpi->common, xd, PRED_MBSKIP);
   TOKENEXTRA *t_backup = *t;
 
@@ -813,10 +898,10 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
                   && xd->mode_info_context->mbmi.mode != I8X8_PRED
                   && xd->mode_info_context->mbmi.mode != SPLITMV);
 #if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
-  if (tx_type == TX_16X16) has_y2_block = 0; // Because of inter frames
+  if (tx_size == TX_16X16) has_y2_block = 0; // Because of inter frames
 #endif
 
-  switch (tx_type) {
+  switch (tx_size) {
 #if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
     case TX_16X16:
       xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_16x16(xd);
@@ -840,12 +925,12 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
     if (!dry_run)
       cpi->skip_true_count[mb_skip_context] += skip_inc;
     if (!cpi->common.mb_no_coeff_skip) {
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
-      if (tx_type == TX_16X16)
+#if CONFIG_TX16X16 && CONFIG_HYBRIDTRANSFORM16X16
+      if (tx_size == TX_16X16)
         vp8_stuff_mb_16x16(cpi, xd, t, dry_run);
       else
 #endif
-      if (tx_type == TX_8X8) {
+      if (tx_size == TX_8X8) {
 #if CONFIG_HYBRIDTRANSFORM8X8
         if (xd->mode_info_context->mbmi.mode == I8X8_PRED)
           vp8_stuff_mb_8x8_4x4uv(cpi, xd, t, dry_run);
@@ -867,7 +952,7 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
 
   plane_type = 3;
   if (has_y2_block) {
-    if (tx_type == TX_8X8) {
+    if (tx_size == TX_8X8) {
       ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
       ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
       tokenize2nd_order_b_8x8(xd,
@@ -881,8 +966,8 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
     plane_type = 0;
   }
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
-  if (tx_type == TX_16X16) {
+#if CONFIG_TX16X16
+  if (tx_size == TX_16X16) {
     ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)xd->above_context;
     ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)xd->left_context;
 
@@ -904,7 +989,7 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
   }
   else
 #endif
-  if (tx_type == TX_8X8) {
+  if (tx_size == TX_8X8) {
     ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
     ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
 #if CONFIG_HYBRIDTRANSFORM8X8
@@ -914,7 +999,8 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
 #endif
     for (b = 0; b < 16; b += 4) {
       tokenize1st_order_b_8x8(xd,
-                              xd->block + b, t, plane_type, xd->frame_type,
+                              xd->block + b,
+                              t, plane_type, xd->frame_type,
                               A + vp8_block2above_8x8[b],
                               L + vp8_block2left_8x8[b],
                               cpi, dry_run);
@@ -945,7 +1031,6 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
 #endif
       tokenize1st_order_b(xd, t, plane_type, cpi, dry_run);
   }
-
   if (dry_run)
     *t = t_backup;
 }
@@ -1214,6 +1299,7 @@ void vp8_tokenize_initialize() {
 
 
 static __inline void stuff2nd_order_b_8x8(
+  MACROBLOCKD *xd,
   const BLOCKD *const b,
   TOKENEXTRA **tp,
   const int type,     /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
@@ -1245,6 +1331,7 @@ static __inline void stuff2nd_order_b_8x8(
 
 static __inline void stuff1st_order_b_8x8
 (
+  MACROBLOCKD *xd,
   const BLOCKD *const b,
   TOKENEXTRA **tp,
   const int type,     /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
@@ -1255,19 +1342,34 @@ static __inline void stuff1st_order_b_8x8
   int dry_run) {
   int pt; /* near block/prev token context index */
   TOKENEXTRA *t = *tp;        /* store tokens starting here */
+#if CONFIG_HYBRIDTRANSFORM8X8
+  TX_TYPE tx_type = type == 3 ? get_tx_type(xd, b) : DCT_DCT;
+#endif
+
   VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
   (void) frametype;
   (void) type;
   (void) b;
 
   t->Token = DCT_EOB_TOKEN;
-  t->context_tree = cpi->common.fc.coef_probs_8x8 [0] [1] [pt];
+#if CONFIG_HYBRIDTRANSFORM8X8
+  if (tx_type != DCT_DCT)
+    t->context_tree = cpi->common.fc.hybrid_coef_probs_8x8 [0] [1] [pt];
+  else
+#endif
+    t->context_tree = cpi->common.fc.coef_probs_8x8 [0] [1] [pt];
   // t->section = 8;
   t->skip_eob_node = 0;
   ++t;
   *tp = t;
-  if (!dry_run)
-    ++cpi->coef_counts_8x8[0] [1] [pt] [DCT_EOB_TOKEN];
+  if (!dry_run) {
+#if CONFIG_HYBRIDTRANSFORM8X8
+    if (tx_type == DCT_DCT)
+      ++cpi->hybrid_coef_counts_8x8[0] [1] [pt] [DCT_EOB_TOKEN];
+    else
+#endif
+      ++cpi->coef_counts_8x8[0] [1] [pt] [DCT_EOB_TOKEN];
+  }
   pt = 0; /* 0 <-> all coeff data is zero */
   *a = *l = pt;
 
@@ -1277,6 +1379,7 @@ static __inline void stuff1st_order_b_8x8
 static __inline
 void stuff1st_order_buv_8x8
 (
+  MACROBLOCKD *xd,
   const BLOCKD *const b,
   TOKENEXTRA **tp,
   const int type,     /* which plane: 0=Y no DC, 1=Y2, 2=UV, 3=Y with DC */
@@ -1315,13 +1418,13 @@ void vp8_stuff_mb_8x8(VP8_COMP *cpi,
   int b;
   TOKENEXTRA *t_backup = *t;
 
-  stuff2nd_order_b_8x8(xd->block + 24, t, 1, xd->frame_type,
+  stuff2nd_order_b_8x8(xd, xd->block + 24, t, 1, xd->frame_type,
                        A + vp8_block2above_8x8[24],
                        L + vp8_block2left_8x8[24], cpi, dry_run);
   plane_type = 0;
 
   for (b = 0; b < 16; b += 4) {
-    stuff1st_order_b_8x8(xd->block + b, t, plane_type, xd->frame_type,
+    stuff1st_order_b_8x8(xd, xd->block + b, t, plane_type, xd->frame_type,
                          A + vp8_block2above_8x8[b],
                          L + vp8_block2left_8x8[b],
                          cpi, dry_run);
@@ -1330,7 +1433,7 @@ void vp8_stuff_mb_8x8(VP8_COMP *cpi,
   }
 
   for (b = 16; b < 24; b += 4) {
-    stuff1st_order_buv_8x8(xd->block + b, t, 2, xd->frame_type,
+    stuff1st_order_buv_8x8(xd, xd->block + b, t, 2, xd->frame_type,
                            A + vp8_block2above[b],
                            L + vp8_block2left[b],
                            cpi, dry_run);
@@ -1341,9 +1444,10 @@ void vp8_stuff_mb_8x8(VP8_COMP *cpi,
     *t = t_backup;
 }
 
-#if CONFIG_TX16X16 || CONFIG_HYBRIDTRANSFORM16X16
+#if CONFIG_TX16X16
 static __inline
-void stuff1st_order_b_16x16(const BLOCKD *const b,
+void stuff1st_order_b_16x16(MACROBLOCKD *xd,
+                            const BLOCKD *const b,
                             TOKENEXTRA **tp,
                             const FRAME_TYPE frametype,
                             ENTROPY_CONTEXT *a,
@@ -1352,17 +1456,31 @@ void stuff1st_order_b_16x16(const BLOCKD *const b,
                             int dry_run){
     int pt; /* near block/prev token context index */
     TOKENEXTRA *t = *tp;        /* store tokens starting here */
+#if CONFIG_HYBRIDTRANSFORM16X16
+    TX_TYPE tx_type = get_tx_type(xd, b);
+#endif
     VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
     (void) frametype;
     (void) b;
 
     t->Token = DCT_EOB_TOKEN;
+#if CONFIG_HYBRIDTRANSFORM16X16
+    if (tx_type != DCT_DCT)
+      t->context_tree = cpi->common.fc.hybrid_coef_probs_16x16[3][1][pt];
+    else
+#endif
     t->context_tree = cpi->common.fc.coef_probs_16x16[3][1][pt];
     t->skip_eob_node = 0;
     ++t;
     *tp = t;
-    if (!dry_run)
+    if (!dry_run) {
+#if CONFIG_HYBRIDTRANSFORM16X16
+      if (tx_type != DCT_DCT)
+        ++cpi->hybrid_coef_counts_16x16[3][1][pt][DCT_EOB_TOKEN];
+      else
+#endif
       ++cpi->coef_counts_16x16[3][1][pt][DCT_EOB_TOKEN];
+    }
     pt = 0; /* 0 <-> all coeff data is zero */
     *a = *l = pt;
 }
@@ -1376,13 +1494,13 @@ void vp8_stuff_mb_16x16(VP8_COMP *cpi,
   int b, i;
   TOKENEXTRA *t_backup = *t;
 
-  stuff1st_order_b_16x16(xd->block, t, xd->frame_type, A, L, cpi, dry_run);
+  stuff1st_order_b_16x16(xd, xd->block, t, xd->frame_type, A, L, cpi, dry_run);
   for (i = 1; i < 16; i++) {
     *(A + vp8_block2above[i]) = *(A);
     *(L +  vp8_block2left[i]) = *(L);
   }
   for (b = 16; b < 24; b += 4) {
-    stuff1st_order_buv_8x8(xd->block + b, t, 2, xd->frame_type,
+    stuff1st_order_buv_8x8(xd, xd->block + b, t, 2, xd->frame_type,
         A + vp8_block2above[b],
         L + vp8_block2left[b],
         cpi, dry_run);
@@ -1398,6 +1516,8 @@ void vp8_stuff_mb_16x16(VP8_COMP *cpi,
 
 static __inline void stuff2nd_order_b
 (
+  MACROBLOCKD *xd,
+  const BLOCKD *const b,
   TOKENEXTRA **tp,
   ENTROPY_CONTEXT *a,
   ENTROPY_CONTEXT *l,
@@ -1420,22 +1540,38 @@ static __inline void stuff2nd_order_b
 
 }
 
-static __inline void stuff1st_order_b(TOKENEXTRA **tp,
+static __inline void stuff1st_order_b(MACROBLOCKD *xd,
+                                      const BLOCKD *const b,
+                                      TOKENEXTRA **tp,
                                       ENTROPY_CONTEXT *a,
                                       ENTROPY_CONTEXT *l,
                                       VP8_COMP *cpi,
                                       int dry_run) {
   int pt; /* near block/prev token context index */
   TOKENEXTRA *t = *tp;        /* store tokens starting here */
+#if CONFIG_HYBRIDTRANSFORM
+  TX_TYPE tx_type = get_tx_type(xd, b);
+#endif
   VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
 
   t->Token = DCT_EOB_TOKEN;
-  t->context_tree = cpi->common.fc.coef_probs [0] [1] [pt];
+#if CONFIG_HYBRIDTRANSFORM
+  if (tx_type != DCT_DCT)
+    t->context_tree = cpi->common.fc.hybrid_coef_probs [0] [1] [pt];
+  else
+#endif
+    t->context_tree = cpi->common.fc.coef_probs [0] [1] [pt];
   t->skip_eob_node = 0;
   ++t;
   *tp = t;
-  if (!dry_run)
-    ++cpi->coef_counts[0] [1] [pt] [DCT_EOB_TOKEN];
+  if (!dry_run) {
+#if CONFIG_HYBRIDTRANSFORM
+    if (tx_type != DCT_DCT)
+      ++cpi->hybrid_coef_counts[0] [1] [pt] [DCT_EOB_TOKEN];
+    else
+#endif
+      ++cpi->coef_counts[0] [1] [pt] [DCT_EOB_TOKEN];
+  }
   pt = 0; /* 0 <-> all coeff data is zero */
   *a = *l = pt;
 
@@ -1443,6 +1579,8 @@ static __inline void stuff1st_order_b(TOKENEXTRA **tp,
 static __inline
 void stuff1st_order_buv
 (
+  MACROBLOCKD *xd,
+  const BLOCKD *const b,
   TOKENEXTRA **tp,
   ENTROPY_CONTEXT *a,
   ENTROPY_CONTEXT *l,
@@ -1467,23 +1605,22 @@ void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *xd,
                   TOKENEXTRA **t, int dry_run) {
   ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
   ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
-  int plane_type;
   int b;
   TOKENEXTRA *t_backup = *t;
 
-  stuff2nd_order_b(t,
+  stuff2nd_order_b(xd, xd->block + 24, t,
                    A + vp8_block2above[24],
                    L + vp8_block2left[24],
                    cpi, dry_run);
 
   for (b = 0; b < 16; b++)
-    stuff1st_order_b(t,
+    stuff1st_order_b(xd, xd->block + b, t,
                      A + vp8_block2above[b],
                      L + vp8_block2left[b],
                      cpi, dry_run);
 
   for (b = 16; b < 24; b++)
-    stuff1st_order_buv(t,
+    stuff1st_order_buv(xd, xd->block + b, t,
                        A + vp8_block2above[b],
                        L + vp8_block2left[b],
                        cpi, dry_run);
@@ -1502,13 +1639,13 @@ void vp8_stuff_mb_8x8_4x4uv(VP8_COMP *cpi,
   int b;
   TOKENEXTRA *t_backup = *t;
 
-  stuff2nd_order_b_8x8(xd->block + 24, t, 1, xd->frame_type,
+  stuff2nd_order_b_8x8(xd, xd->block + 24, t, 1, xd->frame_type,
                        A + vp8_block2above_8x8[24],
                        L + vp8_block2left_8x8[24], cpi, dry_run);
   plane_type = 3;
 
   for (b = 0; b < 16; b += 4) {
-    stuff1st_order_b_8x8(xd->block + b, t, plane_type, xd->frame_type,
+    stuff1st_order_b_8x8(xd, xd->block + b, t, plane_type, xd->frame_type,
                          A + vp8_block2above_8x8[b],
                          L + vp8_block2left_8x8[b],
                          cpi, dry_run);
@@ -1517,7 +1654,7 @@ void vp8_stuff_mb_8x8_4x4uv(VP8_COMP *cpi,
   }
 
   for (b = 16; b < 24; b++)
-    stuff1st_order_buv(t,
+    stuff1st_order_buv(xd, xd->block + b, t,
                        A + vp8_block2above[b],
                        L + vp8_block2left[b],
                        cpi, dry_run);