Восстановление данных переданных по радиоканалу.

Необходимо написать программу восстанавливающую данные - файл JPEG, переданные по беспроводному каналу.
Ограничения: использовать как можно меньше вычислительных ресурсов, при использовании избыточных кодов добавляемая информация не должна превышать 10% от изначального объёма.
Если чуть подробнее, то полученная картинка обрабатывается (кодируется) микроконтроллером AVR32 AT32UC3 и передаётся по беспроводному каналу NanoNet. Принимаются данные на ПК, там происходит их декодирование. Язык программирования С.

Так как повторная передача исключена, то кроме корректирующих кодов вариантов вроде нет.
Корректирующие коды выбираются исходя из наиболее вероятного типа ошибок, вот тут пробел - какой тип ошибок более характерен для NanoNet? У него частота что и у WiFi, но модуляция другая.
Для одиночных ошибок лучше всего подходит классика - код Хемминга. Учитывая 10% ограничение минимально возможный код (63, 57).
Только работа в с файлами происходит побайтно и использование такого кода означает лишние сдвиги, создание массивов и т.д. Как вариант код (88,80), но он избыточен и лишь чуть более удобен.
Циклические коды БЧХ или Рида-Соломона выглядят более привлекательными и вроде не сложны в реализации. У БЧХ как я понимаю можно задавать и длину кодируемого блока и количество исправляемых ошибок. Для кода Рида-Соломона в качестве символа можно задать байт.

В общем задача с разными решениями и где оптимальный путь, пока не определил.
С благодарностью приму любой совет.

 

Изображение черно-белое, поступает с камеры 640х480, образца изображения к сожалению нет.
BER увы не известен в даном случае.
А вообще технология NanoNet довольно стойкая к помехам: модуляция NanoNet помехоустойчиваяt, там есть аппаратная реализация
Хемминга (7, 4), причём с перемешиванием, таким образом достигается исправление 2 ошибок на байт, есть и CRC32 (для интересующихся:

wireless-e ru, там есть статьи по данной технологии).
Но вот только при включении аппаратной коррекции информационная скорость падает в соответственно в 2 раза, что неприемлимо.

Тестовый образец изображения приходится создавать самому, конвертировал черно-белый .BMP в трех программах: Paint, ACD See и PhotoShop,

в JPEG.
В двух первых в файле один сегмент, а вот фотошоп напихал туда чего то своего и в файле три сегмента. Ну да это ладно.

Заголовочная информация (определяю так для себя, то что до 0xFFDA) занимает приблизительно 2% от объема файла. С учетом заданного

ограничения избыточности в 10% от объема файла, добавачная информация при кодировании заголовка может превышать объём самого

заголовка в 5 раз, есть простор для фантазии)).
Кодировать весь заголовок я хочу потому что там содержится служебная информация о процессе кодирования-декодирования, таблица

квантования как я понимаю тоже одна и её порча влияет на отображения каждого блока 8х8. Ну и таблица Хаффмана конечно.
А единичные ошибки в данных, как понимаю влияют на блок 8х8.

Задача, поставленная на данный момент - реализация простого (и менее ресурсоёмкого) алгоритма устраняющего одиночные ошибки, раз BER

не известен, тогда защищаем минимально возможный объём информации - байт или даже полбайта.
В соответствующей литературе
(
опять для тех кому будет интересно:
Блейхут Р. Теория и практика кодов, контролирующих ошибки 1986
Золотарёв В.В. Овечкин Г.В. Помехоустойчивое кодирование. 2004
Кларк Дж. Кейн Дж. Кодирование с исправлением ошибок
Питерсон У. Коды, исправляющие ошибки. 1976
Цифровая связь. Теоретические основы и практическое применение (Бернард Скляр)
это и прочие книги есть например на twirpx com
)
указывают, что достаточно просты и эффективны циклические алгоритмы.
Например для полубайта - циклический код Хемминга (7, 4), чтобы избежать дополнительных сдвигов можно реализовать как (8, 4).
На данный момент примерно такие мысли у меня, но открыт для любой корректирующей))) информации.

P.S. С полубайтом все более менее ясно, а вот если надо кодировать ровно байт?
В оптимальных циклических кодах n и k нечетные.
То есть надо спроектироват код (16, 8) или другой (n, k) код, где к<n и оба кратны 8.
В Питерсон У. Коды, исправляющие ошибки. 1976, таблица 8.3, есть подобные коды, называются квазициклическими.
Но вот с теорией и примерами их построения не густо. Допустим как определить d (расстояние Хемминга) у (16, 8) или (24, 16), чтобы в свою
очередь определить количество ошибок ими исправляемых.

 

Как по мне не стой стороны вы подходите.

1. Разобраться с NanoNet. Как он работает я не знаю. Насколько я знаю у сетевых протоколов есть такая вещь если контрольная сумма не совпадают то они перезапрашивают пакет что влечет к серьезным потерям в скорости.

2. Выяснить какой тип ошибок имеет место быть что мы можем исправить.

3. Заголовочную информацию можно восстановить из предыдущих пакетов.

4. Вообще совет такой сгруппировать медленно меняющиеся данные и быстро меняющиеся.

Медленно меняющиеся мы сможем восстановить из предыдущих данных, а быстро меняющиеся надо резервировать.

А еще на jpeg что свет клином сошелся?

 

Как замечено повторная передача не приветствуется из-за увеличения трафика.
Про заголовок согласен, можно вообще хранить его на принимающей стороне, теоретически.

4. Вообще совет такой сгруппировать медленно меняющиеся данные и быстро меняющиеся.
Можно чуть подробнее?


Просмотрев несклько черно-белых JPEG файлов пожатых с хорошим качеством выяснил, что заголовок (до маркера FFDA)
находится в пределах 0,8 - 1,5%. Округлил до 2%.
Закодировал заголовок циклическим кодом (7, 4).

Код (Text):

1. #include <stdio.h>
2. #include <stdlib.h>
3.  
4.  
5. #define BSIZE 512
6.  
7. short int coder(unsigned char);
8.  
9. int main(int argc, char *argv[])
10. {
11.  
12. unsigned char bufRead[BSIZE], buf2uc[2], a;
13. FILE *fdWrite, *fdRead;
14. short int numByte = 0, buf2si[2], i, ac;
15. int cnt = 0;
16.  
17. fdRead = fopen("a.dat", "rb");
18. if (fdRead == NULL)
19. {
20.   printf ("Oshibka pri otkritii faila Read\n");
21.   exit(1);
22. }  
23. else
24.   printf ("\nFile Read otkrit\n");
25.  
26. fdWrite = fopen("acode.dat","wb");
27. if (fdWrite == NULL)
28. {
29.   printf ("Oshibka pri otkritii faila Write\n");
30.   exit(1);
31. }  
32. else
33.   printf ("File Write otkrit\n");
34.  
35.  
36. do
37. {
38.   fread(bufRead, sizeof(unsigned char), BSIZE, fdRead);
39.   for (i = 0; i < (BSIZE - 1); i++)
40.   {
41.     if ((bufRead[i] == 0xff) && (bufRead[i+1] == 0xda))
42.     {
43.       numByte = cnt*(BSIZE-1) + i + 2;
44.       break;
45.     }
46.   }  
47.   if (numByte == 0)
48.   {
49.     cnt++;
50.     fseek(fdRead, -1, SEEK_CUR);
51.   }
52. }
53. while (numByte == 0);
54.  
55. printf("\nKodirovat bait %i\n", numByte);
56.  
57. memcpy(buf2uc, &numByte, sizeof buf2uc);
58. buf2si[0] = coder(buf2uc[0]);
59. buf2si[1] = coder(buf2uc[1]);
60. fwrite(buf2si, sizeof(short int), 2, fdWrite);
61. fseek(fdRead, 0, SEEK_SET);
62. for (i = 0; i < numByte; i++)
63. {
64.   fread(&a, sizeof(unsigned char), 1, fdRead);
65.   ac = coder(a);
66.   fwrite(&ac, sizeof(short int), 1, fdWrite);
67. }
68.  
69.   fread(&a, sizeof(unsigned char), 1, fdRead);
70.   while (!feof(fdRead))
71.   {  
72.     fwrite(&a, sizeof(unsigned char), 1, fdWrite);  
73.     fread(&a, sizeof(unsigned char), 1, fdRead);  
74.   }
75.  
76.    
77.   if (fclose (fdRead) == 0)
78.      printf ("File Read zakrit\n");
79.   else
80.      printf ("Oshibka pri zakritii faila Read\n");
81.      
82.   if (fclose (fdWrite) == 0)
83.      printf ("File Write zakrit\n");
84.   else
85.      printf ("Oshibka pri zakritii faila Write\n");
86.  
87.  
88.  
89.  
90. getch();   
91.   return 0;
92. }
93.  
94. short int coder(unsigned char a)
95. {
96. unsigned char aH, aH_Code, aL, aL_Code;
97. short int i, Code;  
98.  
99. /*
100. a - байт введённый для кодирования.
101. aH - полученный остаток от деления старших 4 бит.
102. aH_Code - значение закодированных 4 старших бит.
103. aL - полученный остаток от деления младших 4 бит.
104. aL_Code - значение закодированных 4 младших бит.
105. Code - 2 байтное число, в младшем байте содержится 7 битное число
106. полученное при кодировании младших 4 бит введеного числа.
107. В старшем байте - значение закодированных старших 4 бит.
108. */
109.  
110. // складываем с маской для обнуления ненужных бит
111. // в aH хранится старший полубайт его сдвигаем вправо на два разряда
112. // чтобы коменсировать первый сдвиг влево в цикле
113. aH = a & 0xf0;
114. aH_Code = aH >> 1;
115. aH = aH >> 2;
116.  
117. // складываем с маской для обнуления ненужных бит
118. // в aL хранится младший полубайт его сдвигаем влево на два разряда
119. // (надо на три), третий сдвиг - первый сдвиг влево в цикле
120. aL = a & 0x0f;
121. aL_Code = aL << 3;
122. aL = a << 2;
123. // aH_Code и aL_Code хранят исходные полубайты
124. // сдвинутые на три разряда влево относительно первого
125. // к ним происходит присоединение остатка
126.  
127. for (i = 0; i < 4; i++)
128. {    
129.   aH = aH << 1;  
130.   if (aH & 0x40)
131.     aH = aH ^ 0x58;      
132.  
133.   aL = aL << 1;
134.   if (aL & 0x40)
135.     aL = aL ^ 0x58;
136. }
137.  
138. // остаток получается сдвинутым на 3 разряда влево,
139. // поэтому надо сдвинуть его вправо
140. aH = aH >> 3;
141. aH_Code = aH_Code | aH;
142.  
143. aL = aL >> 3;
144. aL_Code = aL_Code | aL;
145.  
146. //16 битному числу Code присваеваем в старший байт aH_Code,
147. //а в младший байт aL_Code
148.  
149. Code = aH_Code;
150. Code = Code << 8;
151. Code = Code | aL_Code;
152.      
153.   return Code;
154. }
155.  
156.  
157. После моделировал ошибку с помощью следующей программы:
158.  
159. #include <stdio.h>
160. #include <stdlib.h>
161. #include <time.h>
162.  
163. int main(int argc, char *argv[])
164. {
165.  
166. int i, P_err, indention;
167. unsigned char masErr[8] = {1,2,4,8,16,32,64,128}, a, err;
168. FILE  *fdRead;
169. long fileSize, pos;
170. unsigned char fileName[100];
171.  
172. printf ("Vvedite imya faila: ");
173. scanf("%s", fileName);
174.  
175. printf ("Na skolko byte otstupit ot nachala faila: ");
176. scanf("%i", &indention);
177.  
178. printf ("Vvedite chislo byte na kotorie prixoditsa 1 oshibka: ");
179. scanf("%i", &P_err);
180.  
181. fdRead = fopen(fileName, "r+b");
182. if (fdRead == NULL)
183. {
184.   printf ("Oshibka pri otkritii faila Read\n");
185.   exit(1);
186. }  
187. else
188.   printf ("\nFile Read otkrit\n");
189.  
190. fseek(fdRead,0,SEEK_END);
191. fileSize = ftell(fdRead);
192. printf("\nThe size of file is %ld bytes\n",  fileSize);
193.  
194. srand(time(NULL));
195.  
196. for (i = (indention + P_err - 1); i < fileSize; i = i + P_err)
197. {
198.   fseek(fdRead, i - rand()%P_err, SEEK_SET);
199.  
200. //  pos = ftell(fdRead);
201. //  printf("Pos SEEK_SET+i %i \n",  pos);
202.  
203.   fread(&a, sizeof(unsigned char), 1, fdRead);
204.  
205. //  pos = ftell(fdRead);
206. //  printf("Pos SEEK_SET+i %i posle chteniya simvola %x\n", pos, a);
207.  
208.  
209.   err = masErr[rand()%8];
210.   a = a ^ err;
211. //  printf("simvol %x posle ^ c %x\n", a, err);
212.  
213.   fseek(fdRead, -1, SEEK_CUR);
214.  
215. //  pos = ftell(fdRead);
216. //  printf("Pos SEEK_SET+i-1 %i \n---------------------\n",  pos);
217.  
218.   fwrite(&a, sizeof(unsigned char), 1, fdRead);
219. }
220.  
221.   if (fclose (fdRead) == 0)
222.      printf ("File Read zakrit\n");
223.   else
224.      printf ("Oshibka pri zakritii faila Read\n");
225.      
226. getch();   
227.   return 0;
228. }

Ну и декодер исправляющий ошибки в закодированной части файла.

Код (Text):

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4.  
5. #define BSIZE 512
6.  
7. unsigned char decoder(short int);
8.  
9. int main(int argc, char *argv[])
10. {
11.  
12. unsigned char bufRead[BSIZE], buf2uc[2], a;
13. FILE *fdWrite, *fdRead;
14. long position;
15. short int numByte, buf2si[2], i, ac;
16. int cnt = 0, razn = 0;
17.  
18. fdRead = fopen("acode.dat", "rb");
19. if (fdRead == NULL)
20. {
21.   printf ("Oshibka pri otkritii faila Read\n");
22.   exit(1);
23. }  
24. else
25.   printf ("\nFile Read otkrit\n");
26.  
27. fdWrite = fopen("adecode.dat","wb");
28. if (fdWrite == NULL)
29. {
30.   printf ("Oshibka pri otkritii faila Write\n");
31.   exit(1);
32. }  
33. else
34.   printf ("File Write otkrit\n");
35.  
36.  
37.  
38. fread(buf2si, sizeof(short int), 2, fdRead);
39. buf2uc[0] = decoder(buf2si[0]);
40. buf2uc[1] = decoder(buf2si[1]);
41. memcpy(&numByte, buf2uc, sizeof buf2uc);
42.  
43. for (i = 0; i < numByte; i++)
44. {
45.   fread(&ac, sizeof(short int), 1, fdRead);
46.   a = decoder(ac);
47.   fwrite(&a, sizeof(unsigned char), 1, fdWrite);
48. }
49.  
50.   fread(&a, sizeof(unsigned char), 1, fdRead);
51.   while (!feof(fdRead))
52.   {  
53.     fwrite(&a, sizeof(unsigned char), 1, fdWrite);  
54.     fread(&a, sizeof(unsigned char), 1, fdRead);  
55.   }
56.    
57.   if (fclose (fdRead) == 0)
58.      printf ("File Read zakrit\n");
59.   else
60.      printf ("Oshibka pri zakritii faila Read\n");
61.      
62.   if (fclose (fdWrite) == 0)
63.      printf ("File Write zakrit\n");
64.   else
65.      printf ("Oshibka pri zakritii faila Write\n");
66.  
67.  
68. getch();   
69.   return 0;
70. }
71.  
72.  
73. unsigned char decoder(short int c)
74. {
75.          
76. unsigned char cL, cH, cH_Decode, cL_Decode, Decode;
77. short int i;
78.  
79. /*
80. с - 2 байтное число введённый для декодирования.
81. сH - полученный остаток от деления старшего байта.
82. сH_Decode - значение декодированных 4 старших бит.
83. сL - полученный остаток от деления младшего байта.
84. cL_Decode - значение декодированных 4 младших бит.
85. Deode - 1 байтное декодированное число.
86. */
87.  
88. cL_Decode = (unsigned char)c;
89. c = c >> 8;
90. cH_Decode = (unsigned char)c;
91. cH = cH_Decode;
92. cL = cL_Decode;
93.  
94. for (i = 0; i < 4; i++)
95. {
96.   if (cH & 0x40)
97.     cH = cH ^ 0x58;
98.   cH = cH << 1;
99.  
100.   if (cL & 0x40)
101.     cL = cL ^ 0x58;
102.   cL = cL << 1;  
103. }
104.  
105. cH = cH >> 4;
106. cL = cL >> 4;
107.  
108. switch(cH)
109. {
110.   case 1:
111.     printf ("oshibka v 1 bite\n");
112.     cH_Decode = cH_Decode ^ 1;
113.     break;
114.    
115.   case 2:
116.     printf ("oshibka v 2 bite\n");
117.     cH_Decode = cH_Decode ^ 2;    
118.     break;
119.    
120.   case 4:
121.     printf ("oshibka v 3 bite\n");
122.     cH_Decode = cH_Decode ^ 4;  
123.     break;
124.    
125.   case 3:
126.     printf ("oshibka v 4 bite\n");
127.     cH_Decode = cH_Decode ^ 8;      
128.     break;
129.    
130.   case 6:
131.     printf ("oshibka v 5 bite\n");
132.     cH_Decode = cH_Decode ^ 16;      
133.     break;
134.    
135.   case 7:
136.     printf ("oshibka v 6 bite\n");
137.     cH_Decode = cH_Decode ^ 32;      
138.     break;
139.    
140.   case 5:
141.     printf ("oshibka v 7 bite\n");
142.     cH_Decode = cH_Decode ^ 64;      
143.     break;
144.    
145.   default:
146.  
147.     break;                            
148. }
149.  
150.  
151. cH_Decode = cH_Decode & 0x78;
152. Decode = cH_Decode << 1;
153. cH_Decode = cH_Decode >> 3;
154.  
155. switch(cL)
156. {
157.   case 1:
158.     printf ("oshibka v 1 bite\n");
159.     cL_Decode = cL_Decode ^ 1;
160.     break;
161.    
162.   case 2:
163.     printf ("oshibka v 2 bite\n");
164.     cL_Decode = cL_Decode ^ 2;    
165.     break;
166.    
167.   case 4:
168.     printf ("oshibka v 3 bite\n");
169.     cL_Decode = cL_Decode ^ 4;  
170.     break;
171.    
172.   case 3:
173.     printf ("oshibka v 4 bite\n");
174.     cL_Decode = cL_Decode ^ 8;      
175.     break;
176.    
177.   case 6:
178.     printf ("oshibka v 5 bite\n");
179.     cL_Decode = cL_Decode ^ 16;      
180.     break;
181.    
182.   case 7:
183.     printf ("oshibka v 6 bite\n");
184.     cL_Decode = cL_Decode ^ 32;      
185.     break;
186.    
187.   case 5:
188.     printf ("oshibka v 7 bite\n");
189.     cL_Decode = cL_Decode ^ 64;      
190.     break;
191.    
192.   default:
193.  
194.     break;                            
195. }
196.  
197. cL_Decode = cL_Decode >> 3;
198. cL_Decode = cL_Decode & 0x0f;
199. Decode = Decode | cL_Decode;
200.  
201. return Decode;        
202. }

Код конечно не оптимален, написан для проверки идеи.

Как результат:
При внесении нескольких ошибок в незакодированный файл, он зачастую не открывался. Видимо когда
ошибки приходились на заголовок.
При кодировании, внесении ошибок и декодировании, файл стабильно открывается, но даже несколько ошибок в данных
зачастую делают его визуально безнадёжно испорченным.

Очевидно данные тоже надо кодировать, причем как можно лучше.
Так как 2% избыточности из допустимых 10% использованно, то максимально допустимый вариант БЧХ (127, 120).

______________________________
Пожалуйста, не стесняйтесь использовать теги [code][/code] - G13

 

интересная задача. только при чем здесь jpeg? если я правильно понимаю задачу, нужно подобрать наиболее оптимальный (скорость/помехоустойчивость/автокоррекция) алгоритм или протокол передачи данных по радиоканалу. какие именно данные передаются - не важно. важно, каким протоколом передачи пользоваться, чтобы и скорость была хорошая (для выбранного способа) и автокоррекция ошибок была. когда то давно просматривал литературу на эту тему - кажется все уже давным давно изучено и расписано от и до, вдоль и поперек. ИМХО не велосипед надо изобретать, а в библиотеку идти...