C言語でのランレングスデコーディングの実装方法を徹底解説

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

// ランレングスデコーディング関数
void runLengthDecode(const char *encoded, char *decoded) {
    int i = 0, j = 0;
    while (encoded[i] != '\0') {
        // 繰り返し回数を取得
        int count = encoded[i] - '0';
        i++;
        // 次の文字を繰り返し回数分出力にコピー
        for (int k = 0; k < count; k++) {
            decoded[j++] = encoded[i];
        }
        i++;
    }
    decoded[j] = '\0'; // 終端文字を追加
}

int main() {
    // 入力のエンコードされた文字列
    char encoded[] = "4A3B2C1D2A";
    // デコードされた文字列を格納するバッファ
    char decoded[100];

    // デコード処理
    runLengthDecode(encoded, decoded);

    // 結果の出力
    printf("Encoded: %s\n", encoded);
    printf("Decoded: %s\n", decoded);

    return 0;
}

gcc -o rle_decode rle_decode.c

./rle_decode

Encoded: 4A3B2C1D2A
Decoded: AAAABBBCCDAA

行 1: 白 白 白 白
行 2: 黒 黒 黒 黒
行 3: 白 白 黒 黒
行 4: 白 黒 黒 黒

4,255,255,255 4,0,0,0 2,255,255,255 2,0,0,0 1,255,255,255 3,0,0,0

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

// ピクセルデータを表す構造体
typedef struct {
    unsigned char r, g, b;
} Pixel;

// 圧縮されたデータを表す構造体
typedef struct {
    Pixel pixel;
    int count;
} RLEPixel;

// 画像データをランレングスエンコードする関数
RLEPixel* runLengthEncode(Pixel *image, int width, int height, int *encodedSize) {
    int maxEncodedSize = width * height;
    RLEPixel *encoded = (RLEPixel*)malloc(maxEncodedSize * sizeof(RLEPixel));

    int index = 0;
    for (int i = 0; i < width * height;) {
        Pixel currentPixel = image[i];
        int count = 1;
        while (i + count < width * height && image[i + count].r == currentPixel.r && image[i + count].g == currentPixel.g && image[i + count].b == currentPixel.b) {
            count++;
        }
        encoded[index].pixel = currentPixel;
        encoded[index].count = count;
        index++;
        i += count;
    }

    *encodedSize = index;
    return encoded;
}

int main() {
    // 例として4x4の画像データ
    Pixel image[16] = {
        {255, 255, 255}, {255, 255, 255}, {255, 255, 255}, {255, 255, 255},
        {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
        {255, 255, 255}, {255, 255, 255}, {0, 0, 0}, {0, 0, 0},
        {255, 255, 255}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}
    };

    int encodedSize;
    RLEPixel *encodedImage = runLengthEncode(image, 4, 4, &encodedSize);

    // 結果の表示
    printf("Encoded Image:\n");
    for (int i = 0; i < encodedSize; i++) {
        printf("Color: (%d, %d, %d), Count: %d\n", encodedImage[i].pixel.r, encodedImage[i].pixel.g, encodedImage[i].pixel.b, encodedImage[i].count);
    }

    free(encodedImage);
    return 0;
}

"AAAAAAAABBBCCCCCCCCDDDDDDDD"

"8A3B8C8D"

0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00

4xFF 4x00

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

// テキストデータのランレングスエンコード関数
char* runLengthEncodeText(const char *text) {
    int n = strlen(text);
    char *encoded = (char*)malloc(2 * n * sizeof(char)); // 最大でも2倍のサイズが必要
    int index = 0;

    for (int i = 0; i < n; i++) {
        int count = 1;
        while (i + 1 < n && text[i] == text[i + 1]) {
            count++;
            i++;
        }
        index += sprintf(&encoded[index], "%d%c", count, text[i]);
    }

    return encoded;
}

// バイナリデータのランレングスエンコード関数
typedef struct {
    unsigned char value;
    int count;
} RLEByte;

RLEByte* runLengthEncodeBinary(const unsigned char *data, int length, int *encodedSize) {
    RLEByte *encoded = (RLEByte*)malloc(length * sizeof(RLEByte));
    int index = 0;

    for (int i = 0; i < length; ) {
        unsigned char value = data[i];
        int count = 1;
        while (i + count < length && data[i + count] == value) {
            count++;
        }
        encoded[index].value = value;
        encoded[index].count = count;
        index++;
        i += count;
    }

    *encodedSize = index;
    return encoded;
}

int main() {
    // テキストデータの圧縮例
    const char *text = "AAAAAAAABBBCCCCCCCCDDDDDDDD";
    char *encodedText = runLengthEncodeText(text);
    printf("Encoded Text: %s\n", encodedText);
    free(encodedText);

    // バイナリデータの圧縮例
    unsigned char binaryData[] = {0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00};
    int encodedSize;
    RLEByte *encodedBinary = runLengthEncodeBinary(binaryData, 8, &encodedSize);

    printf("Encoded Binary Data:\n");
    for (int i = 0; i < encodedSize; i++) {
        printf("Value: 0x%02X, Count: %d\n", encodedBinary[i].value, encodedBinary[i].count);
    }
    free(encodedBinary);

    return 0;
}

int isValidFormat(const char *encoded) {
    int i = 0;
    while (encoded[i] != '\0') {
        if (!isdigit(encoded[i]) || !isalpha(encoded[i + 1])) {
            return 0; // 無効な形式
        }
        i += 2;
    }
    return 1; // 有効な形式
}

char* allocateBuffer(const char *encoded) {
    int length = 0;
    int i = 0;
    while (encoded[i] != '\0') {
        length += encoded[i] - '0';
        i += 2;
    }
    char *buffer = (char*)malloc((length + 1) * sizeof(char)); // +1は終端文字のため
    return buffer;
}

int getCount(const char *encoded, int *index) {
    int count = 0;
    while (isdigit(encoded[*index])) {
        count = count * 10 + (encoded[*index] - '0');
        (*index)++;
    }
    return count;
}

void decodeAndPrint(const char *encoded) {
    if (!isValidFormat(encoded)) {
        printf("Invalid format!\n");
        return;
    }
    char *decoded = allocateBuffer(encoded);
    runLengthDecode(encoded, decoded);
    printf("Decoded: %s\n", decoded);
    free(decoded);
}