Changeset 203 for libmpc/branches/r2d/libmpcenc

Timestamp:

02/08/07 14:29:39 (18 years ago)

Author:

r2d

Message:

• added sv7 to sv8 conversion utility (still work to do, but able to convert basic files)
• moved libmpcenc functions prototypes in libmpcenc.h
• removed global variables from encode_sv7 (put in mpc_encoder_t)

Location:

libmpc/branches/r2d/libmpcenc

Files:

• encode_sv7.c (modified) (14 diffs)
• libmpcenc.h (modified) (2 diffs)

libmpc/branches/r2d/libmpcenc/encode_sv7.c

@@ -58 +58 @@
  */
 
-unsigned char         MS_Flag     [32];         // Flag to save if Subband was MS- or LR-coded
-int                   SCF_Last_L  [32];
-int                   SCF_Last_R  [32];         // Last coded SCF value
-static unsigned char  DSCF_RLL_L  [32];
-static unsigned char  DSCF_RLL_R  [32];         // Duration of the differential SCF-coding for RLL (run length limitation)
-int                   Res_L       [32];
-int                   Res_R       [32];         // Quantization precision of the subbands
-int                   SCF_Index_L [32] [3];
-int                   SCF_Index_R [32] [3];     // Scalefactor index for quantized subband values
-
 // initialize SV8
 void
@@ -146 +136 @@
 // formatting and writing SV8-bitstream for one frame
 void
-writeBitstream_SV8 ( mpc_encoder_t* e, int MaxBand, const SubbandQuantTyp*  Q )
+writeBitstream_SV8 ( mpc_encoder_t* e, int MaxBand)
 {
         int n;
@@ -152 +142 @@
 
         for( n = MaxBand; n >= 0; n--)
-                if (Res_L[n] != 0 || Res_R[n] != 0) break;
+                if (e->Res_L[n] != 0 || e->Res_R[n] != 0) break;
 
         n++;
@@ -168 +158 @@
 
         if (MaxBand) {
-                writeBits(e, HuffRes[0][Res_L[MaxBand - 1]].Code, HuffRes[0][Res_L[MaxBand - 1]].Length);
-                writeBits(e, HuffRes[0][Res_R[MaxBand - 1]].Code, HuffRes[0][Res_R[MaxBand - 1]].Length);
+                writeBits(e, HuffRes[0][e->Res_L[MaxBand - 1]].Code, HuffRes[0][e->Res_L[MaxBand - 1]].Length);
+                writeBits(e, HuffRes[0][e->Res_R[MaxBand - 1]].Code, HuffRes[0][e->Res_R[MaxBand - 1]].Length);
                 for ( n = MaxBand - 2; n >= 0; n--) {
-                        int tmp = Res_L[n] - Res_L[n + 1];
+                        int tmp = e->Res_L[n] - e->Res_L[n + 1];
                         if (tmp < 0) tmp += 17;
-                        writeBits(e, HuffRes[Res_L[n + 1] > 2][tmp].Code, HuffRes[Res_L[n + 1] > 2][tmp].Length);
-
-                        tmp = Res_R[n] - Res_R[n + 1];
+                        writeBits(e, HuffRes[e->Res_L[n + 1] > 2][tmp].Code, HuffRes[e->Res_L[n + 1] > 2][tmp].Length);
+
+                        tmp = e->Res_R[n] - e->Res_R[n + 1];
                         if (tmp < 0) tmp += 17;
-                        writeBits(e, HuffRes[Res_R[n + 1] > 2][tmp].Code, HuffRes[Res_R[n + 1] > 2][tmp].Length);
+                        writeBits(e, HuffRes[e->Res_R[n + 1] > 2][tmp].Code, HuffRes[e->Res_R[n + 1] > 2][tmp].Length);
                 }
 
@@ -184 +174 @@
                         int cnt = 0, tot = 0;
                         for( n = 0; n < MaxBand; n++) {
-                                if ( Res_L[n] != 0 || Res_R[n] != 0 ) {
-                                        tmp = (tmp << 1) | MS_Flag[n];
-                                        cnt += MS_Flag[n];
+                                if ( e->Res_L[n] != 0 || e->Res_R[n] != 0 ) {
+                                        tmp = (tmp << 1) | e->MS_Flag[n];
+                                        cnt += e->MS_Flag[n];
                                         tot++;
                                 }
@@ -200 +190 @@
         if (e->framesInBlock == 0){
                 for( n = 0; n < 32; n++)
-                        DSCF_RLL_L[n] = DSCF_RLL_R[n] = 1; // new block -> force key frame
+                        e->DSCF_Flag_L[n] = e->DSCF_Flag_R[n] = 1; // new block -> force key frame
         }
 
@@ -207 +197 @@
         for ( n = 0; n < MaxBand; n++ ) {
                 int tmp = 0, cnt = -1;
-                if (Res_L[n]) {
-                        tmp = (SCF_Index_L[n][1] == SCF_Index_L[n][0]) * 2 + (SCF_Index_L[n][2] == SCF_Index_L[n][1]);
+                if (e->Res_L[n]) {
+                        tmp = (e->SCF_Index_L[n][1] == e->SCF_Index_L[n][0]) * 2 + (e->SCF_Index_L[n][2] == e->SCF_Index_L[n][1]);
                         cnt++;
                 }
-                if (Res_R[n]) {
-                        tmp = (tmp << 2) | ((SCF_Index_R[n][1] == SCF_Index_R[n][0]) * 2 + (SCF_Index_R[n][2] == SCF_Index_R[n][1]));
+                if (e->Res_R[n]) {
+                        tmp = (tmp << 2) | ((e->SCF_Index_R[n][1] == e->SCF_Index_R[n][0]) * 2 + (e->SCF_Index_R[n][2] == e->SCF_Index_R[n][1]));
                         cnt++;
                 }
@@ -222 +212 @@
 
         for ( n = 0; n < MaxBand; n++ ) {
-                if ( Res_L[n] ) {
+                if ( e->Res_L[n] ) {
                         int m;
-                        if (DSCF_RLL_L[n] == 1) {
-                                writeBits(e, SCF_Index_L[n][0] + 6, 7);
-                                DSCF_RLL_L[n] = 0;
+                        if (e->DSCF_Flag_L[n] == 1) {
+                                writeBits(e, e->SCF_Index_L[n][0] + 6, 7);
+                                e->DSCF_Flag_L[n] = 0;
                         } else {
-                                unsigned int tmp = (SCF_Index_L[n][0] - SCF_Last_L[n] + 31) & 127;
+                                unsigned int tmp = (e->SCF_Index_L[n][0] - e->SCF_Last_L[n] + 31) & 127;
                                 if (tmp < 64)
                                         writeBits(e, HuffDSCF_2[tmp].Code, HuffDSCF_2[tmp].Length);
@@ -237 +227 @@
                         }
                         for( m = 0; m < 2; m++){
-                                if (SCF_Index_L[n][m+1] != SCF_Index_L[n][m]) {
-                                        unsigned int tmp = (SCF_Index_L[n][m+1] - SCF_Index_L[n][m] + 31) & 127;
+                                if (e->SCF_Index_L[n][m+1] != e->SCF_Index_L[n][m]) {
+                                        unsigned int tmp = (e->SCF_Index_L[n][m+1] - e->SCF_Index_L[n][m] + 31) & 127;
                                         if (tmp < 64)
                                                 writeBits(e, HuffDSCF_1[tmp].Code, HuffDSCF_1[tmp].Length);
@@ -247 +237 @@
                                 }
                         }
-                        SCF_Last_L[n] = SCF_Index_L[n][2];
-                }
-                if ( Res_R[n] ) {
+                        e->SCF_Last_L[n] = e->SCF_Index_L[n][2];
+                }
+                if ( e->Res_R[n] ) {
                         int m;
-                        if (DSCF_RLL_R[n] == 1) {
-                                writeBits(e, SCF_Index_R[n][0] + 6, 7);
-                                DSCF_RLL_R[n] = 0;
+                        if (e->DSCF_Flag_R[n] == 1) {
+                                writeBits(e, e->SCF_Index_R[n][0] + 6, 7);
+                                e->DSCF_Flag_R[n] = 0;
                         } else {
-                                unsigned int tmp = (SCF_Index_R[n][0] - SCF_Last_R[n] + 31) & 127;
+                                unsigned int tmp = (e->SCF_Index_R[n][0] - e->SCF_Last_R[n] + 31) & 127;
                                 if (tmp < 64)
                                         writeBits(e, HuffDSCF_2[tmp].Code, HuffDSCF_2[tmp].Length);
@@ -264 +254 @@
                         }
                         for( m = 0; m < 2; m++){
-                                if (SCF_Index_R[n][m+1] != SCF_Index_R[n][m]) {
-                                        unsigned int tmp = (SCF_Index_R[n][m+1] - SCF_Index_R[n][m] + 31) & 127;
+                                if (e->SCF_Index_R[n][m+1] != e->SCF_Index_R[n][m]) {
+                                        unsigned int tmp = (e->SCF_Index_R[n][m+1] - e->SCF_Index_R[n][m] + 31) & 127;
                                         if (tmp < 64)
                                                 writeBits(e, HuffDSCF_1[tmp].Code, HuffDSCF_1[tmp].Length);
@@ -274 +264 @@
                                 }
                         }
-                        SCF_Last_R[n] = SCF_Index_R[n][2];
+                        e->SCF_Last_R[n] = e->SCF_Index_R[n][2];
                 }
         }
@@ -280 +270 @@
         /*********************************** Samples *********************************/
         for ( n = 0; n < MaxBand; n++ ) {
-                int Res = Res_L[n];
-                const unsigned int * q = Q[n].L;
+                int Res = e->Res_L[n];
+                const unsigned int * q = e->Q[n].L;
                 static const unsigned int thres[] = {0, 0, 3, 7, 9, 1, 3, 4, 8};
                 static const int HuffQ2_var[5*5*5] =
@@ -357 +347 @@
                         }
 
-                        Res = Res_R[n];
-                } while (q == Q[n].L && (q = Q[n].R));
+                        Res = e->Res_R[n];
+                } while (q == e->Q[n].L && (q = e->Q[n].R));
         }
 

libmpc/branches/r2d/libmpcenc/libmpcenc.h

@@ -36 +36 @@
 
 typedef struct {
-        unsigned int  L [36];
-        unsigned int  R [36];
-} SubbandQuantTyp;
-
-typedef struct {
         mpc_uint16_t    Code;        // >= 14 bit
         mpc_uint16_t    Length;      // >=  4 bit
@@ -63 +58 @@
         FILE * outputFile; // ouput file
 
-        unsigned int  MS_Channelmode;
-        unsigned int  Overflows; //       = 0;      // number of internal (filterbank) clippings
-        unsigned int MaxBand; /// number of non zero bands in last frame
+        mpc_uint32_t MS_Channelmode;
+        mpc_uint32_t Overflows; //       = 0;      // number of internal (filterbank) clippings
+        mpc_uint32_t MaxBand; /// number of non zero bands in last frame
+
+        mpc_int32_t   SCF_Index_L [32] [3];
+        mpc_int32_t   SCF_Index_R [32] [3];       // holds scalefactor-indices
+        mpc_int32_t   SCF_Last_L  [32];
+        mpc_int32_t   SCF_Last_R  [32];           // Last coded SCF value
+        mpc_quantizer Q [32];                     // holds quantized samples
+        mpc_int32_t   Res_L [32];
+        mpc_int32_t   Res_R [32];                 // holds the chosen quantizer for each subband
+        mpc_bool_t    DSCF_Flag_L [32];
+        mpc_bool_t    DSCF_Flag_R [32];           // differential SCF used?
+        mpc_bool_t    MS_Flag[32];                // MS used?
  } mpc_encoder_t;
 
+ void         Init_SV8             ( mpc_encoder_t* );
+ void writeStreamInfo ( mpc_encoder_t*e,
+                                                const unsigned int  MaxBand,
+                                                const unsigned int  MS_on,
+                                                const unsigned int  SamplesCount,
+                                                const unsigned int  SampleFreq,
+                                                const unsigned int  ChannelCount);
+ void writeEncoderInfo ( mpc_encoder_t * e,
+                                                 const float profile,
+                                                 const int PNS_on,
+                                                 const int version_major,
+                                                 const int version_minor,
+                                                 const int version_implement,
+                                                 const int version_build );
+ void writeBlock ( mpc_encoder_t * e, const char * key, const mpc_bool_t addCRC);
+ void writeMagic (mpc_encoder_t * e);
+ void writeBits (mpc_encoder_t * e, mpc_uint32_t input, unsigned int bits );
+ void writeSeekTable (mpc_encoder_t * e);
+ void writeBitstream_SV8 ( mpc_encoder_t*, int);
+