Changeset 296 for libmpc/trunk/libmpcdec/mpc_decoder.c

Timestamp:

04/24/07 15:07:19 (17 years ago)

Author:

r2d

Message:

Improved sv8 huffman decoding using canonical property of the huffman tables. It reduces memory usage for the tables and improves speed (mainly with small LUT size).

File:

• libmpc/trunk/libmpcdec/mpc_decoder.c (modified) (12 diffs)

libmpc/trunk/libmpcdec/mpc_decoder.c

@@ -52 +52 @@
 
 //SV8 tables
-extern const mpc_huffman mpc_table_HuffBands[33];
-extern const mpc_lut_data mpc_HuffRes [2];
-extern const mpc_lut_data mpc_HuffQ_8 [8][2];
-extern const mpc_lut_data mpc_HuffQ9up_8;
-extern const mpc_lut_data mpc_HuffSCFI_1;
-extern const mpc_lut_data mpc_HuffSCFI_2;
-extern const mpc_lut_data mpc_HuffDSCF_1;
-extern const mpc_lut_data mpc_HuffDSCF_2;
+extern const mpc_can_data mpc_can_Bands;
+extern const mpc_can_data mpc_can_SCFI[2];
+extern const mpc_can_data mpc_can_DSCF[2];
+extern const mpc_can_data mpc_can_Res [2];
+extern const mpc_can_data mpc_can_Q [8][2];
+extern const mpc_can_data mpc_can_Q1;
+extern const mpc_can_data mpc_can_Q9up;
 
 //------------------------------------------------------------------------------
@@ -509 +508 @@
 
         mpc_int32_t n, Max_used_Band;
-        const mpc_lut_data * Table, * Tables[2];
+        const mpc_can_data * Table, * Tables[2];
 
         /***************************** Header *****************************/
@@ -516 +515 @@
                 Max_used_Band = mpc_bits_log_dec(r, d->max_band + 1);
         } else {
-                Max_used_Band = d->last_max_band + mpc_bits_huff_dec(r, mpc_table_HuffBands);
+                Max_used_Band = d->last_max_band + mpc_bits_can_dec(r, & mpc_can_Bands);
                 if (Max_used_Band > 32) Max_used_Band -= 33;
         }
@@ -522 +521 @@
 
         if (Max_used_Band) {
-                d->Res_L[Max_used_Band-1] = mpc_bits_huff_lut(r, & mpc_HuffRes[0]);
-                d->Res_R[Max_used_Band-1] = mpc_bits_huff_lut(r, & mpc_HuffRes[0]);
+                d->Res_L[Max_used_Band-1] = mpc_bits_can_dec(r, & mpc_can_Res[0]);
+                d->Res_R[Max_used_Band-1] = mpc_bits_can_dec(r, & mpc_can_Res[0]);
                 if (d->Res_L[Max_used_Band-1] > 15) d->Res_L[Max_used_Band-1] -= 17;
                 if (d->Res_R[Max_used_Band-1] > 15) d->Res_R[Max_used_Band-1] -= 17;
                 for ( n = Max_used_Band - 2; n >= 0; n--) {
-                        d->Res_L[n] = mpc_bits_huff_lut(r, & mpc_HuffRes[d->Res_L[n + 1] > 2]) + d->Res_L[n + 1];
+                        d->Res_L[n] = mpc_bits_can_dec(r, & mpc_can_Res[d->Res_L[n + 1] > 2]) + d->Res_L[n + 1];
                         if (d->Res_L[n] > 15) d->Res_L[n] -= 17;
-                        d->Res_R[n] = mpc_bits_huff_lut(r, & mpc_HuffRes[d->Res_R[n + 1] > 2]) + d->Res_R[n + 1];
+                        d->Res_R[n] = mpc_bits_can_dec(r, & mpc_can_Res[d->Res_R[n + 1] > 2]) + d->Res_R[n + 1];
                         if (d->Res_R[n] > 15) d->Res_R[n] -= 17;
                 }
@@ -562 +561 @@
         }
 
-        Tables[0] = & mpc_HuffSCFI_1;
-        Tables[1] = & mpc_HuffSCFI_2;
+        Tables[0] = & mpc_can_SCFI[0];
+        Tables[1] = & mpc_can_SCFI[1];
         for ( n = 0; n < Max_used_Band; n++ ) {
                 int tmp = 0, cnt = -1;
@@ -569 +568 @@
                 if (d->Res_R[n]) cnt++;
                 if (cnt >= 0) {
-                        tmp = mpc_bits_huff_lut(r, Tables[cnt]);
+                        tmp = mpc_bits_can_dec(r, Tables[cnt]);
                         if (d->Res_L[n]) d->SCFI_L[n] = tmp >> (2 * cnt);
                         if (d->Res_R[n]) d->SCFI_R[n] = tmp & 3;
@@ -589 +588 @@
                                         *DSCF_Flag = 0;
                                 } else {
-                                        mpc_uint_t tmp = mpc_bits_huff_lut(r, & mpc_HuffDSCF_2);
+                                        mpc_uint_t tmp = mpc_bits_can_dec(r, & mpc_can_DSCF[1]);
                                         if (tmp == 64)
                                                 tmp += mpc_bits_read(r, 6);
@@ -596 +595 @@
                                 for( m = 0; m < 2; m++){
                                         if (((SCFI << m) & 2) == 0) {
-                                                mpc_uint_t tmp = mpc_bits_huff_lut(r, & mpc_HuffDSCF_1);
+                                                mpc_uint_t tmp = mpc_bits_can_dec(r, & mpc_can_DSCF[0]);
                                                 if (tmp == 31)
                                                         tmp = 64 + mpc_bits_read(r, 6);
@@ -621 +620 @@
                         if (Res != 0) {
                                 if (Res == 2) {
-                                        Tables[0] = & mpc_HuffQ_8 [1][0];
-                                        Tables[1] = & mpc_HuffQ_8 [1][1];
+                                        Tables[0] = & mpc_can_Q [0][0];
+                                        Tables[1] = & mpc_can_Q [0][1];
                                         idx = 2 * thres[Res];
                                         for ( ; k < 36; k += 3) {
-                                                int tmp = mpc_bits_huff_lut(r, Tables[idx > thres[Res]]);
+                                                int tmp = mpc_bits_can_dec(r, Tables[idx > thres[Res]]);
                                                 q[k] = idx50[tmp];
                                                 q[k + 1] = idx51[tmp];
@@ -632 +631 @@
                                         }
                                 } else if (Res == 1) {
-                                        Table = & mpc_HuffQ_8 [0][0];
+                                        Table = & mpc_can_Q1;
                                         for( ; k < 36; ){
                                                 int kmax = k + 18;
-                                                mpc_uint_t cnt = mpc_bits_huff_lut(r, Table);
+                                                mpc_uint_t cnt = mpc_bits_can_dec(r, Table);
                                                 idx = 0;
                                                 if (cnt > 0 && cnt < 18)
@@ -653 +652 @@
                                         }
                                 } else if (Res <= 4) {
-                                        Table = & mpc_HuffQ_8[Res - 1][0];
+                                        Table = & mpc_can_Q[1][Res - 3];
                                         for ( ; k < 36; k += 2 ) {
                                                 union {
@@ -659 +658 @@
                                                         struct { mpc_int8_t s1:4, s2:4; };
                                                 } tmp;
-                                                tmp.sym = mpc_bits_huff_lut(r, Table);
+                                                tmp.sym = mpc_bits_can_dec(r, Table);
                                                 q[k] = tmp.s1;
                                                 q[k + 1] = tmp.s2;
                                         }
                                 } else if (Res <= 8) {
-                                        Tables[0] = & mpc_HuffQ_8 [Res - 1][0];
-                                        Tables[1] = & mpc_HuffQ_8 [Res - 1][1];
+                                        Tables[0] = & mpc_can_Q [Res - 3][0];
+                                        Tables[1] = & mpc_can_Q [Res - 3][1];
                                         idx = 2 * thres[Res];
                                         for ( ; k < 36; k++ ) {
-                                                q[k] = mpc_bits_huff_lut(r, Tables[idx > thres[Res]]);
+                                                q[k] = mpc_bits_can_dec(r, Tables[idx > thres[Res]]);
                                                 idx = (idx >> 1) + absi(q[k]);
                                         }
                                 } else {
                                         for ( ; k < 36; k++ ) {
-                                                q[k] = (unsigned char) mpc_bits_huff_lut(r, & mpc_HuffQ9up_8);
+                                                q[k] = (unsigned char) mpc_bits_can_dec(r, & mpc_can_Q9up);
                                                 if (Res != 9)
                                                         q[k] = (q[k] << (Res - 9)) | mpc_bits_read(r, Res - 9);