परिवर्तनीय लंबाई पूर्णांक एन्कोडिंग

Question

मैं एक एलजेड 1/एलजेड 77 डीकंप्रेशन एल्गोरिदम इंजीनियर को रिवर्स करने का प्रयास कर रहा हूं। आउटपुट होने के लिए डीकोड बफर/विंडो के क्षेत्र की लंबाई एक चर लंबाई लंबाई पूर्णांक के रूप में फ़ाइल में एन्कोड किया गया है। मैंने वैरिएबल लम्बाई पूर्णांक एन्कोडिंग के बारे में जितना भी पढ़ा है और इस मामले में इस्तेमाल की जाने वाली विधि किसी अन्य व्यक्ति की तरह दिखाई नहीं दे रही है। शायद पेटेंट मुद्दों से बचने के लिए या शायद सिर्फ obfuscate करने के लिए। शामिल कोड काफी पूरा नहीं हो सकता है लेकिन यह इस बिंदु पर कम से कम कई फाइलों पर काम कर रहा है।

मैं नहीं देख सकता कि, अगर बिल्कुल, नीचे दिए गए सूत्रों को कुछ सरल में कम किया जा सकता है। अधिकांश परिवर्तनीय लंबाई पूर्णांक एन्कोडिंग एल्गोरिदम कुछ प्रकार के लूप का उपयोग करते हैं, लेकिन इसके लिए, मैं ऐसा करने में सक्षम नहीं हूं क्योंकि सूत्र प्रत्येक निबेल का मूल्यांकन करते समय सुसंगत प्रतीत नहीं होता है।

सुझावों की बहुत सराहना की जाती है।

private static int getLength(BitReader bitStream) 
{ 
    const int minSize = 2; 

    int length = 0; 

    byte nibble3, nibble2, nibble1; 

    nibble3 = bitStream.ReadNibble(); 

    if (nibble3 >= 0xc) 
    { 
     nibble2 = bitStream.ReadNibble(); 
     nibble1 = bitStream.ReadNibble(); 

     if (nibble3 == 0xF & nibble2 == 0xF & nibble1 == 0xF) return -1; 

     if ((nibble3 & 2) != 0) 
     { 
      length = (((((nibble3 & 7) + 3) << 6) + 8)) + 
       ((nibble2 & 7) << 3) + nibble1 + minSize; 
     } 
     else if ((nibble3 & 1) != 0) 
     { 
      length = (((nibble3 & 7) << 6) + 8) + 
       ((((nibble2 & 7)) + 1) << 3) + nibble1 + minSize; 
     } 
     else 
     { 
      length = ((((nibble3 & 7) << 4) + 8)) + 
       ((nibble2 & 7) << 4) + nibble1 + minSize; 
     } 
    } 
    else if ((nibble3 & 8) != 0) 
    { 
     nibble1 = bitStream.ReadNibble(); 

     length = ((((nibble3 & 7) << 1) + 1) << 3) + nibble1 + minSize; 
    } 
    else 
    { 
     length = nibble3 + minSize; 
    } 

    return length; 
} 

Answer 1

ऐसा लगता है कि चर लंबाई पूर्णांक एन्कोडिंग एल्गोरिथ्म इस्तेमाल किया जा रहा बहुत Dlugosz' Variable-Length Integer Encoding विधि के समान है। वास्तव में, एक ही सूत्र के बजाय, कई गणनाएं आवश्यक हैं।

उस पर आधारित, मैंने कोड को फिर से लिखा है। मैं अभी भी उस तंत्र के सटीक प्रारूप को समझने की कोशिश कर रहा हूं जहां एक अग्रणी 0xFFF का उपयोग किया जाता है।

private static int getLength(BitReader bitStream) 
    { 
     const int minSize = 2; 
     int length = 0; 
     byte nibble3, nibble2, nibble1; 
     byte nibble; 
     nibble = bitStream.ReadNibble(); 
     if (nibble == 0xF) 
     { 
      nibble2 = bitStream.ReadNibble(); 
      nibble1 = bitStream.ReadNibble(); 
      if (nibble2 == 0xf && nibble1 == 0xF) 
      { 
       //The next nibble specifies the number of nibbles to be read, maybe. 
       byte nibblesToRead = (byte) (bitStream.ReadNibble()) ; 
       //The Dlugosz' mechanism would use a mask on the value but that doesn't appear to be the case here. 
       //nibblesToRead &= 7; 
       //switch (nibblesToRead & 7){ 
       // case 0: nibblesToRead = 5; break; 
       // case 1: nibblesToRead = 8; break; 
       // case 2: nibblesToRead = 16; break;       
       //} 
       byte value=0; 
       byte[] values = new byte[nibblesToRead]; 
       bool c=true; 
       for (int i = 0; i < nibblesToRead; i++) 
       { 
        value = bitStream.ReadNibble(); 
        //values[i] = value; 
        length += (((value << 1) | 1) << 3); 
       } 
       value = bitStream.ReadNibble(); 
       length += value; 
      } 
     } 
     else if((nibble >= 0xC)){ 
      nibble2 = bitStream.ReadNibble(); 
      nibble1 = bitStream.ReadNibble(); 
      length = ((((((nibble & 1) <<1)|1))<< 3) + ((nibble2<<1)|1)<<3)+nibble1; 
     } 
     else if ((nibble & 8)!=0){ 
      nibble1 = bitStream.ReadNibble(); 
      length = ((((nibble & 3)<<1) | 1) << 3) + nibble1; 
     } 
     else{ 
      length=nibble; 
     } 
     return length + minSize; 
     };