C 解压位掩码源

Question

这可能是一个有点奇怪的问题，也是我在这个网站上的第一个问题，而且是一个非常复杂的问题，基本上我有一个用于非常具体的存档文件的解压缩器，我几乎不明白这一点，但据我所知它是某种“位掩码”，它从目标文件中读取前 2 个字节，并将它们存储为一个序列。

第一个 for 循环让我感到困惑

为了参数的缘故，掩码是 2 个字节 10 04，或者 1040(十进制)，这就是这些文件中通常的值

    for (t = 0; t<16; t++) {
        if (mask & (1 << (15 - t))) { 

这似乎是循环遍历这 2 个字节的所有 16 位并对每一位运行掩码 (1040) 的 AND 运算？
if语句是我完全不明白的？是什么触发了 if？如果该位大于0？

因为如果 mask 是 1040，那么我们真正看到的是

if(1040 & 32768)    index 15
if(1040 & 16384)    index 14
if(1040 & 8192)     index 13
if(1040 & 4096)     index 12
if(1040 & 2048)     index 11
if(1040 & 1024)     index 10
if(1040 & 512)      and so on.....
if(1040 & 256)

我真的很想知道是什么触发了这个 if 语句？我想我可能想多了，但如果当前位大于 0，它是否只是触发？

我唯一能做的就是自己编译这个源代码，在关键变量上插入 printfs 并与十六进制编辑器并驾齐驱，试着弄清楚这里到底发生了什么，如果有人能帮我一把的话太棒了。

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

uint8_t  dest[1024 * 1024 * 4]; // holds the actual data

int main(int argc, char *argv[]) {
    FILE *fi, *fo;
    char fname[255];

    uint16_t mask, tmp, offset, length;
    uint16_t seq;
    uint32_t dptr, sptr;
    uint16_t l, ct;
    uint16_t t, s;
    int test_len;
    int t_length, t_off;


    // Print Usage if filename is missing
    if (argc<3) {
        printf("sld_unpack - Decompressor for .sld files ()\nsld_unpack <filename.sld> <filename.t2>\n");
        return(-1);
    }

    // Open .SLD-file
    if (!(fi = fopen(argv[1], "rb"))) {
        printf("Error opening %s\n", argv[1]);
        return(-1);
    }

    dptr = 0;

    fread((uint16_t*)&seq, 1, 2, fi); // read 1st 2 bytes in file
    test_len = ftell(fi);

    printf("[Main Header sequence: %d]\n 'offset' : %d \n", seq, test_len);
    sptr = 0;

    fread((uint16_t*)&seq, 1, 2, fi);



    while (!feof(fi)) { // while not at the end of the file set mask equal to sequence (first 2 bytes of header)
        mask = seq;
        // loop through 16 bit mask

        for (t = 0; t<16; t++) {
            if (mask & (1 << (15 - t))) { // check all bit fields and run AND check to if value greater then 0?

                test_len = ftell(fi);
                fread((uint16_t*)&seq, 1, 2, fi); // read 


                sptr = sptr + 2; // set from 0 to 2
                tmp = seq; // set tmp to sequence
                offset = ((uint32_t)tmp & 0x07ff) * 2; 


                length = ((tmp >> 11) & 0x1f) * 2; //  32 - 1?



                if (length>0) {

                    for (l = 0; l<length; l++) {
                        dest[dptr] = dest[dptr - offset];
                        dptr++;

                    }
                }
                else { // if length == 0 

                    t_length = ftell(fi);
                    fread((uint16_t*)&seq, 1, 2, fi);


                    sptr = sptr + 2;
                    length = seq * 2;

                    for (s = 0; s<length; s++) {
                        dest[dptr] = dest[dptr - offset];
                        dptr++;

                    }
                }
            }
            else { // if sequence AND returns 0 (or less)?

                fread((uint16_t*)&seq, 1, 2, fi);
                t_length = ftell(fi);

                sptr = sptr + 2;
                dest[dptr++] = seq & 0xff;
                dest[dptr++] = (seq >> 8) & 0xff;
            }
        }
        fread((uint16_t*)&seq, 1, 2, fi);

    }

    fclose(fi);

    sprintf(fname, "%s\0", argv[2]);

    if (!(fo = fopen(fname, "wb"))) { // if file 
        printf("Error creating %s\n", fname);
        return(-1);
    }

    fwrite((uint8_t*)&dest, 1, dptr, fo);


    fclose(fo);

    printf("Done.\n");

    return(0);
}

Answer 1

注意这里。

for arguments sake mask is 2 bytes 10 04, or 1040(decimal)

这个假设可能远非真实。您需要显示 mask 是如何定义的，但通常是 10 (00001010) 和 40 ( 00101000) 是二进制 101000101000 或十进制 (2600) 不完全是 1040。

2600 十进制的一般掩码将在位 4、6、10 和 12 被设置 时匹配。请记住，位掩码只不过是一个数字，当用第二个数字进行anded 或ored 时，其二进制表示会产生一些所需的结果。 位掩码并没有什么神奇之处，它只是一个为您的预期目的设置了正确位的数字。

当您将 和 两个数字放在一起进行测试时，您正在测试两个数字中是否设置了公共(public)位。使用 for 循环和 shift，您可以按位测试设置了哪些公共(public)位。当位 4、6、10 和 12 被设置时，将 2600 的掩码 与循环计数器一起使用将测试为真>。换句话说，当测试子句等于 8、32、512 或 2048 时。

以下是 loop 和 if 语句中发生的事情的简短示例。

#include <stdio.h>

/* BUILD_64 */
#if defined(__LP64__) || defined(_LP64)
# define BUILD_64   1
#endif

/* BITS_PER_LONG */
#ifdef BUILD_64
# define BITS_PER_LONG 64
#else
# define BITS_PER_LONG 32
#endif

/* CHAR_BIT */
#ifndef CHAR_BIT
# define CHAR_BIT  8
#endif

char *binpad (unsigned long n, size_t sz);

int main (void) {

    unsigned short t, mask;

    mask = (10 << 8) | 40;

    printf ("\n mask : %s  (%hu)\n\n",
            binpad (mask, sizeof mask * CHAR_BIT), mask);

    for (t = 0; t<16; t++)
        if (mask & (1 << (15 - t)))
            printf (" t %2hu : %s  (%hu)\n", t, 
                    binpad (mask & (1 << (15 - t)), sizeof mask * CHAR_BIT), 
                    mask & (1 << (15 - t)));


    return 0;
}

/** returns pointer to binary representation of 'n' zero padded to 'sz'.
 *  returns pointer to string contianing binary representation of
 *  unsigned 64-bit (or less ) value zero padded to 'sz' digits.
 */
char *binpad (unsigned long n, size_t sz)
{
    static char s[BITS_PER_LONG + 1] = {0};
    char *p = s + BITS_PER_LONG;
    register size_t i;

    for (i = 0; i < sz; i++)
        *--p = (n>>i & 1) ? '1' : '0';

    return p;
}

输出

$ ./bin/bitmask1040

 mask : 0000101000101000  (2600)

 t  4 : 0000100000000000  (2048)
 t  6 : 0000001000000000  (512)
 t 10 : 0000000000100000  (32)
 t 12 : 0000000000001000  (8)