Форум программистов, компьютерный форум, киберфорум
Наши страницы
C для начинающих
Войти
Регистрация
Восстановить пароль
 
Rillaxac
Заблокирован
1

Найти ошибки в реализации RLE-алгоритма архивации

24.05.2015, 21:22. Просмотров 247. Ответов 0
Метки нет (Все метки)

реализовал простенький RLE-алгоритм архивации данных, проверьте пожалуйста, вдруг чего не доглядел... но вроде бы работает
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include <Windows.h>
#include <stdio.h>
 
#define RLE_ID (*(DWORD*)L"RLE")
#define RLE_OK 0
#define RLE_BUF_ERROR -1
#define RLE_DATA_ERROR -2
 
#pragma pack (push, 1)
typedef struct _RLEHEADER
{
    DWORD id;
    size_t destlen;
    size_t sourcelen;
} RLEHEADER;
 
typedef struct _RLECHUNK
{
    DWORD id;
    size_t count;
    byte data;
} RLECHUNK;
#pragma pack (pop)
 
int RLECompress(byte *dest, size_t destlen, const byte *source, size_t sourcelen)
{
    byte *tmp_dest = dest + sizeof(RLEHEADER);
    const byte *tmp_source = source;
    RLECHUNK chunk = { 0 };
    chunk.id = RLE_ID;
    RLEHEADER header = { 0 };
    header.id = RLE_ID;
    header.destlen = destlen;
    header.sourcelen = sourcelen;
 
    __try
    {
        *(RLEHEADER*)dest = header;
 
        while (tmp_dest - dest < destlen && tmp_source - source < sourcelen)
        {
            source = tmp_source++;
            while (*tmp_source == *(tmp_source - 1) && tmp_source - source < sourcelen)
                tmp_source++;
            if (tmp_source > source + sizeof(RLECHUNK) + 1)
            {
                chunk.count = tmp_source - source;
                chunk.data = *source;
                *(RLECHUNK*)tmp_dest = chunk;
                tmp_dest += sizeof(RLECHUNK);
            }
            else
            {
                memcpy(tmp_dest, source, tmp_source - source);
                tmp_dest += tmp_source - source;
            }
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return RLE_BUF_ERROR;
    }
    return RLE_OK;
}
 
int RLEUncompress(byte *dest, size_t destlen, const byte *source, size_t sourcelen)
{
    byte *tmp_dest = dest;
    const byte *tmp_source = source + sizeof(RLEHEADER);
    RLECHUNK *chunk = NULL;
    RLEHEADER header = { 0 };
 
    __try
    {
        header = *(RLEHEADER*)source;
        if (header.id != RLE_ID)
            return RLE_DATA_ERROR;
 
        while (tmp_dest - dest < destlen && tmp_source - source < sourcelen)
        {
            source = tmp_source;
 
            while (*(DWORD*)tmp_source != RLE_ID && tmp_source - source < sourcelen)
                tmp_source++;
 
            memcpy(tmp_dest, source, tmp_source - source);
            tmp_dest += tmp_source - source;
 
            if (tmp_source - source < sourcelen)
            {
                chunk = (RLECHUNK*)tmp_source;
                tmp_source += sizeof(RLECHUNK);
                memset(tmp_dest, chunk->data, chunk->count);
                tmp_dest += chunk->count;
            }
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return RLE_BUF_ERROR;
    }
    return RLE_OK;
}
 
INT64 RLESize(const byte *data)
{
    __try
    {
        return ((RLEHEADER*)data)->sourcelen;
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return -1;
    }
}
 
void main(int argc, char *argv[])
{
    byte data[] = { 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 255, 35, 35, 35, 35, 
        73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 0, 5, 5, 2 };
 
    byte buff[sizeof(data) + sizeof(RLEHEADER)] = { 0 };
 
    byte data_r[sizeof(data)] = { 0 };
 
    int e = RLECompress(buff, sizeof(buff), data, sizeof(data));
 
    INT64 sz = RLESize(buff);
 
    RLEHEADER header = *(RLEHEADER*)buff;
 
    e = RLEUncompress(data_r, header.sourcelen, buff, header.destlen);
}
Добавлено через 1 час 53 минуты
уже нашел сам ошибку: в функции compress лишние круги ходит в конце... не знаю как правильно условие поставить чтобы не ходил
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#include <Windows.h>
#include <stdio.h>
 
#define RLE_ID (*(DWORD*)L"RLE")
#define RLE_OK 0
#define RLE_BUF_ERROR -1
#define RLE_DATA_ERROR -2
 
#pragma pack (push, 1)
typedef struct _RLEHEADER
{
    DWORD id;
    size_t destlen;
    size_t sourcelen;
} RLEHEADER;
 
typedef struct _RLECHUNK
{
    DWORD id;
    size_t count;
    byte data;
} RLECHUNK;
#pragma pack (pop)
 
int RLECompress(byte *dest, size_t destlen, const byte *source, size_t sourcelen)
{
    byte *tmp_dest = dest + sizeof(RLEHEADER);
    const byte *tmp_source = source;
    RLECHUNK chunk = { 0 };
    chunk.id = RLE_ID;
    RLEHEADER header = { 0 };
    header.id = RLE_ID;
    header.sourcelen = sourcelen;
 
    __try
    {
        while (tmp_dest - dest < destlen && tmp_source - source < sourcelen)
        {
            source = tmp_source++;
            while (*tmp_source == *(tmp_source - 1) && tmp_source - source < sourcelen)
                tmp_source++;
            if (tmp_source > source + sizeof(RLECHUNK) + 1)
            {
                chunk.count = tmp_source - source;
                chunk.data = *source;
                *(RLECHUNK*)tmp_dest = chunk;
                tmp_dest += sizeof(RLECHUNK);
                header.destlen += sizeof(RLECHUNK);
            }
            else
            {
                memcpy(tmp_dest, source, tmp_source - source);
                tmp_dest += tmp_source - source;
                header.destlen += tmp_source - source;
            }
        }
        *(RLEHEADER*)dest = header;
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return RLE_BUF_ERROR;
    }
    return RLE_OK;
}
 
int RLEUncompress(byte *dest, size_t destlen, const byte *source, size_t sourcelen)
{
    byte *tmp_dest = dest;
    const byte *tmp_source = source + sizeof(RLEHEADER);
    RLECHUNK *chunk = NULL;
    RLEHEADER header = { 0 };
 
    __try
    {
        header = *(RLEHEADER*)source;
        if (header.id != RLE_ID)
            return RLE_DATA_ERROR;
 
        while (tmp_dest - dest < destlen && tmp_source - source < sourcelen)
        {
            source = tmp_source;
 
            while (*(DWORD*)tmp_source != RLE_ID && tmp_source - source < sourcelen)
                tmp_source++;
 
            memcpy(tmp_dest, source, tmp_source - source);
            tmp_dest += tmp_source - source;
 
            if (tmp_source - source < sourcelen)
            {
                chunk = (RLECHUNK*)tmp_source;
                tmp_source += sizeof(RLECHUNK);
                memset(tmp_dest, chunk->data, chunk->count);
                tmp_dest += chunk->count;
            }
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return RLE_BUF_ERROR;
    }
    return RLE_OK;
}
 
INT64 RLESourceSize(const byte *data)
{
    __try
    {
        return ((RLEHEADER*)data)->sourcelen;
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return RLE_BUF_ERROR;
    }
}
 
INT64 RLEDestSize(const byte *data)
{
    __try
    {
        return ((RLEHEADER*)data)->destlen;
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return RLE_BUF_ERROR;
    }
}
 
void main(int argc, char *argv[])
{
    byte data[] = { 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 255, 35, 35, 35, 35, 
        73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 0, 5, 5, 2 };
 
    byte buff[sizeof(data) + sizeof(RLEHEADER)] = { 0 };
 
    byte data_r[sizeof(data)] = { 0 };
 
    int e = RLECompress(buff, sizeof(buff), data, sizeof(data));
 
    INT64 szs = RLESourceSize(buff);
 
    INT64 szd = RLEDestSize(buff);
 
    RLEHEADER header = *(RLEHEADER*)buff;
 
    e = RLEUncompress(data_r, header.sourcelen, buff, header.destlen);
}
0
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
24.05.2015, 21:22
Ответы с готовыми решениями:

Сколько нужно циклов для реализации алгоритма Гаусса?
Подскажите, сколько нужно циклов для реализации алгоритма Гаусса?

Найти ошибку в реализации файлового ввода-вывода
Ошибка заключается в том, что на этом промежутке while(fread(&amp;a,sizeof(int),1,f)) {...

Программа реализации алгоритма Run-Length Encoding (RLE)
Уважаемые программисты не могу исправить код этой программы напишите в чем проблема и исправьте...

Найти и исправить ошибки в реализации алгоритма Дейкстры
Алгоритм Дейкстры (построение путей с минимальными цепями) #include&lt;iostream.h&gt;...

Сможете найти ошибки в реализации алгоритма Гаусса Зейделя для вычисления СЛУ
Procedure GaussZeid; Var k,kol,l:Integer; q,r,s:extended; Begin k:=0; kol:=0; for i:=1 to n-1...

0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
24.05.2015, 21:22

Не могу найти ошибку в реализации алгоритма
Нужно перевести алгоритм в код. Вот мой код, но он не работает: double a = -10; ...

Реализация алгоритма RLE
ребят помогите написать не сложный алгоритм с комментариями)))

Реализация алгоритма RLE
Есть задачка, надо реализовать две функции &quot;закодировать&quot; и &quot;раскодировать&quot; массив данных типа: ...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
1
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2019, vBulletin Solutions, Inc.
Рейтинг@Mail.ru