comparison arib25/src/ts_section_parser.c @ 53:41a5481db56f

rearrange arib25 directory
author Yoshiki Yazawa <yaz@honeyplanet.jp>
date Sun, 13 Sep 2009 02:11:33 +0900
parents arib25v023/arib25/src/ts_section_parser.c@6801fe7e04ff
children
comparison
equal deleted inserted replaced
52:db7af62da709 53:41a5481db56f
1 #include <stdlib.h>
2 #include <string.h>
3
4 #include "ts_section_parser.h"
5 #include "ts_section_parser_error_code.h"
6
7 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8 inner structures
9 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
10 typedef struct {
11 void *prev;
12 void *next;
13 TS_SECTION sect;
14 int32_t ref;
15 } TS_SECTION_ELEM;
16
17 typedef struct {
18 TS_SECTION_ELEM *head;
19 TS_SECTION_ELEM *tail;
20 int32_t count;
21 } TS_SECTION_LIST;
22
23 typedef struct {
24
25 int32_t pid;
26
27 TS_SECTION_ELEM *work;
28 TS_SECTION_ELEM *last;
29
30 TS_SECTION_LIST pool;
31 TS_SECTION_LIST buff;
32
33 TS_SECTION_PARSER_STAT stat;
34
35 } TS_SECTION_PARSER_PRIVATE_DATA;
36
37 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
38 constant values
39 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
40 #define MAX_RAW_SECTION_SIZE 4100
41
42 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
43 function prottypes (interface method)
44 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
45 static void release_ts_section_parser(void *parser);
46 static int reset_ts_section_parser(void *parser);
47 static int put_ts_section_parser(void *parser, TS_HEADER *hdr, uint8_t *data, int size);
48 static int get_ts_section_parser(void *parser, TS_SECTION *sect);
49 static int ret_ts_section_parser(void *parser, TS_SECTION *sect);
50 static int get_count_ts_section_parser(void *parser);
51 static int get_stat_ts_section_parser(void *parser, TS_SECTION_PARSER_STAT *stat);
52
53 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
54 global function implementation (factory method)
55 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
56 TS_SECTION_PARSER *create_ts_section_parser()
57 {
58 TS_SECTION_PARSER *r;
59 TS_SECTION_PARSER_PRIVATE_DATA *prv;
60
61 int n;
62
63 n = sizeof(TS_SECTION_PARSER_PRIVATE_DATA);
64 n += sizeof(TS_SECTION_PARSER);
65
66 prv = (TS_SECTION_PARSER_PRIVATE_DATA *)calloc(1, n);
67 if(prv == NULL){
68 /* failed on malloc() - no enough memory */
69 return NULL;
70 }
71
72 prv->pid = -1;
73
74 r = (TS_SECTION_PARSER *)(prv+1);
75 r->private_data = prv;
76
77 r->release = release_ts_section_parser;
78 r->reset = reset_ts_section_parser;
79
80 r->put = put_ts_section_parser;
81 r->get = get_ts_section_parser;
82 r->ret = ret_ts_section_parser;
83
84 r->get_count = get_count_ts_section_parser;
85
86 r->get_stat = get_stat_ts_section_parser;
87
88 return r;
89 }
90
91 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
92 function prottypes (private method)
93 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
94 static TS_SECTION_PARSER_PRIVATE_DATA *private_data(void *parser);
95 static void teardown(TS_SECTION_PARSER_PRIVATE_DATA *prv);
96
97 static int put_exclude_section_start(TS_SECTION_PARSER_PRIVATE_DATA *prv, uint8_t *data, int size);
98 static int put_include_section_start(TS_SECTION_PARSER_PRIVATE_DATA *prv, uint8_t *data, int size);
99
100 static void reset_section(TS_SECTION *sect);
101 static void append_section_data(TS_SECTION *sect, uint8_t *data, int size);
102 static int check_section_complete(TS_SECTION *sect);
103
104 static int compare_elem_section(TS_SECTION_ELEM *a, TS_SECTION_ELEM *b);
105
106 static void cancel_elem_empty(TS_SECTION_PARSER_PRIVATE_DATA *prv, TS_SECTION_ELEM *elem);
107 static void cancel_elem_error(TS_SECTION_PARSER_PRIVATE_DATA *prv, TS_SECTION_ELEM *elem);
108 static void cancel_elem_same(TS_SECTION_PARSER_PRIVATE_DATA *prv, TS_SECTION_ELEM *elem);
109 static void commit_elem_updated(TS_SECTION_PARSER_PRIVATE_DATA *prv, TS_SECTION_ELEM *elem);
110
111 static TS_SECTION_ELEM *query_work_elem(TS_SECTION_PARSER_PRIVATE_DATA *prv);
112
113 static void extract_ts_section_header(TS_SECTION *sect);
114
115 static TS_SECTION_ELEM *create_ts_section_elem();
116 static TS_SECTION_ELEM *get_ts_section_list_head(TS_SECTION_LIST *list);
117 static void put_ts_section_list_tail(TS_SECTION_LIST *list, TS_SECTION_ELEM *elem);
118 static void unlink_ts_section_list(TS_SECTION_LIST *list, TS_SECTION_ELEM *elem);
119 static void clear_ts_section_list(TS_SECTION_LIST *list);
120
121 static uint32_t crc32(uint8_t *head, uint8_t *tail);
122
123 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
124 function implementation (interface method)
125 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
126 static void release_ts_section_parser(void *parser)
127 {
128 TS_SECTION_PARSER_PRIVATE_DATA *prv;
129
130 prv = private_data(parser);
131 if(prv == NULL){
132 return;
133 }
134
135 teardown(prv);
136
137 memset(parser, 0, sizeof(TS_SECTION_PARSER));
138 free(prv);
139 }
140
141 static int reset_ts_section_parser(void *parser)
142 {
143 TS_SECTION_PARSER_PRIVATE_DATA *prv;
144
145 prv = private_data(parser);
146 if(prv == NULL){
147 return TS_SECTION_PARSER_ERROR_INVALID_PARAM;
148 }
149
150 teardown(prv);
151
152 return 0;
153 }
154
155 static int put_ts_section_parser(void *parser, TS_HEADER *hdr, uint8_t *data, int size)
156 {
157 TS_SECTION_PARSER_PRIVATE_DATA *prv;
158
159 prv = private_data(parser);
160 if( (prv == NULL) || (hdr == NULL) || (data == NULL) || (size < 1) ){
161 return TS_SECTION_PARSER_ERROR_INVALID_PARAM;
162 }
163
164 if( (prv->pid >= 0) && (prv->pid != hdr->pid) ){
165 return TS_SECTION_PARSER_ERROR_INVALID_TS_PID;
166 }
167
168 prv->pid = hdr->pid;
169
170 if(hdr->payload_unit_start_indicator == 0){
171 /* exclude section start */
172 return put_exclude_section_start(prv, data, size);
173 }else{
174 /* include section start */
175 return put_include_section_start(prv, data, size);
176 }
177 }
178
179 static int get_ts_section_parser(void *parser, TS_SECTION *sect)
180 {
181 TS_SECTION_PARSER_PRIVATE_DATA *prv;
182 TS_SECTION_ELEM *w;
183
184 prv = private_data(parser);
185 if( (prv == NULL) || (sect == NULL) ){
186 return TS_SECTION_PARSER_ERROR_INVALID_PARAM;
187 }
188
189 w = get_ts_section_list_head(&(prv->buff));
190 if(w == NULL){
191 memset(sect, 0, sizeof(TS_SECTION));
192 return TS_SECTION_PARSER_ERROR_NO_SECTION_DATA;
193 }
194
195 memcpy(sect, &(w->sect), sizeof(TS_SECTION));
196 put_ts_section_list_tail(&(prv->pool), w);
197
198 return 0;
199 }
200
201 static int ret_ts_section_parser(void *parser, TS_SECTION *sect)
202 {
203 TS_SECTION_PARSER_PRIVATE_DATA *prv;
204 TS_SECTION_ELEM *w;
205
206 prv = private_data(parser);
207 if( (prv == NULL) || (sect == NULL) ){
208 return TS_SECTION_PARSER_ERROR_INVALID_PARAM;
209 }
210
211 w = prv->pool.tail;
212 while(w != NULL){
213 if(w->sect.data == sect->data){
214 break;
215 }
216 w = (TS_SECTION_ELEM *)(w->prev);
217 }
218
219 if( (w != NULL) && (w->ref > 0) ){
220 w->ref -= 1;
221 }
222
223 return 0;
224 }
225
226 static int get_count_ts_section_parser(void *parser)
227 {
228 TS_SECTION_PARSER_PRIVATE_DATA *prv;
229
230 prv = private_data(parser);
231 if(prv == NULL){
232 return TS_SECTION_PARSER_ERROR_INVALID_PARAM;
233 }
234
235 return prv->buff.count;
236 }
237
238 static int get_stat_ts_section_parser(void *parser, TS_SECTION_PARSER_STAT *stat)
239 {
240 TS_SECTION_PARSER_PRIVATE_DATA *prv;
241
242 prv = private_data(parser);
243 if( (prv == NULL) || (stat == NULL) ){
244 return TS_SECTION_PARSER_ERROR_INVALID_PARAM;
245 }
246
247 memcpy(stat, &(prv->stat), sizeof(TS_SECTION_PARSER_STAT));
248
249 return 0;
250 }
251
252 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
253 function implementation (private method)
254 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
255 static TS_SECTION_PARSER_PRIVATE_DATA *private_data(void *parser)
256 {
257 TS_SECTION_PARSER_PRIVATE_DATA *r;
258 TS_SECTION_PARSER *p;
259
260 p = (TS_SECTION_PARSER *)parser;
261 if(p == NULL){
262 return NULL;
263 }
264
265 r = (TS_SECTION_PARSER_PRIVATE_DATA *)(p->private_data);
266 if( ((void *)(r+1)) != parser ){
267 return NULL;
268 }
269
270 return r;
271 }
272
273 static void teardown(TS_SECTION_PARSER_PRIVATE_DATA *prv)
274 {
275 prv->pid = -1;
276
277 if(prv->work != NULL){
278 free(prv->work);
279 prv->work = NULL;
280 }
281
282 prv->last = NULL;
283
284 clear_ts_section_list(&(prv->pool));
285 clear_ts_section_list(&(prv->buff));
286
287 memset(&(prv->stat), 0, sizeof(TS_SECTION_PARSER_STAT));
288 }
289
290 static int put_exclude_section_start(TS_SECTION_PARSER_PRIVATE_DATA *prv, uint8_t *data, int size)
291 {
292 TS_SECTION_ELEM *w;
293
294 w = prv->work;
295 if( (w == NULL) || (w->sect.raw == w->sect.tail) ){
296 /* no previous data */
297 return 0;
298 }
299
300 append_section_data(&(w->sect), data, size);
301 if(check_section_complete(&(w->sect)) == 0){
302 /* need more data */
303 return 0;
304 }
305
306 prv->work = NULL;
307
308 if( (w->sect.hdr.section_syntax_indicator != 0) &&
309 (crc32(w->sect.raw, w->sect.tail) != 0) ){
310 cancel_elem_error(prv, w);
311 return TS_SECTION_PARSER_WARN_CRC_MISSMATCH;
312 }
313
314 if(compare_elem_section(w, prv->last) == 0){
315 /* same section data */
316 cancel_elem_same(prv, w);
317 return 0;
318 }
319
320 commit_elem_updated(prv, w);
321 return 0;
322 }
323
324 static int put_include_section_start(TS_SECTION_PARSER_PRIVATE_DATA *prv, uint8_t *data, int size)
325 {
326 TS_SECTION_ELEM *w;
327
328 int pointer_field;
329
330 uint8_t *p;
331 uint8_t *tail;
332
333 int r;
334 int length;
335
336 p = data;
337 tail = p + size;
338
339 r = 0;
340
341 pointer_field = p[0];
342 p += 1;
343
344 if( (p+pointer_field) >= tail ){
345 /* input data is probably broken */
346 w = prv->work;
347 prv->work = NULL;
348 if(w != NULL) {
349 if(w->sect.raw != w->sect.tail){
350 cancel_elem_error(prv, w);
351 return TS_SECTION_PARSER_WARN_LENGTH_MISSMATCH;
352 }
353 cancel_elem_empty(prv, w);
354 }
355 return 0;
356 }
357
358 if(pointer_field > 0){
359 r = put_exclude_section_start(prv, p, pointer_field);
360 if(r < 0){
361 return r;
362 }
363 p += pointer_field;
364 }
365
366 w = prv->work;
367 prv->work = NULL;
368
369 if(w != NULL){
370 if(w->sect.raw != w->sect.tail){
371 cancel_elem_error(prv, w);
372 r = TS_SECTION_PARSER_WARN_LENGTH_MISSMATCH;
373 }else{
374 cancel_elem_empty(prv, w);
375 }
376 w = NULL;
377 }
378
379 do {
380
381 w = query_work_elem(prv);
382 if(w == NULL){
383 return TS_SECTION_PARSER_ERROR_NO_ENOUGH_MEMORY;
384 }
385
386 append_section_data(&(w->sect), p, tail-p);
387 if(check_section_complete(&(w->sect)) == 0){
388 /* need more data */
389 prv->work = w;
390 return 0;
391 }
392 length = (w->sect.tail - w->sect.raw);
393
394 if( (w->sect.hdr.section_syntax_indicator != 0) &&
395 (crc32(w->sect.raw, w->sect.tail) != 0) ){
396 cancel_elem_error(prv, w);
397 r = TS_SECTION_PARSER_WARN_CRC_MISSMATCH;
398 }else if(compare_elem_section(w, prv->last) == 0){
399 cancel_elem_same(prv, w);
400 }else{
401 commit_elem_updated(prv, w);
402 }
403
404 p += length;
405
406 } while ( (p < tail) && (p[0] != 0xff) );
407
408 return r;
409 }
410
411 static void reset_section(TS_SECTION *sect)
412 {
413 memset(&(sect->hdr), 0, sizeof(TS_SECTION_HEADER));
414 sect->tail = sect->raw;
415 sect->data = NULL;
416 }
417
418 static void append_section_data(TS_SECTION *sect, uint8_t *data, int size)
419 {
420 int m,n;
421
422 m = sect->tail - sect->raw;
423 n = MAX_RAW_SECTION_SIZE - m;
424
425 if(size < n){
426 n = size;
427 }
428 memcpy(sect->tail, data, n);
429 sect->tail += n;
430 m += n;
431
432 if(sect->data == NULL){
433 extract_ts_section_header(sect);
434 }
435
436 if(sect->data == NULL){
437 /* need more data */
438 return;
439 }
440
441 n = sect->hdr.section_length + 3;
442 if(m > n){
443 sect->tail = sect->raw + n;
444 }
445
446 return;
447 }
448
449 static int check_section_complete(TS_SECTION *sect)
450 {
451 int m,n;
452
453 if(sect->data == NULL){
454 return 0;
455 }
456
457 m = sect->tail - sect->raw;
458 n = sect->hdr.section_length + 3;
459
460 if(n > m){
461 return 0;
462 }
463
464 return 1;
465 }
466
467 static int compare_elem_section(TS_SECTION_ELEM *a, TS_SECTION_ELEM *b)
468 {
469 int m,n;
470
471 if( (a == NULL) || (b == NULL) ){
472 return 1;
473 }
474
475 m = a->sect.tail - a->sect.raw;
476 n = b->sect.tail - b->sect.raw;
477 if( m != n ){
478 return 1;
479 }
480
481 if(memcmp(a->sect.raw, b->sect.raw, m) != 0){
482 return 1;
483 }
484
485 return 0;
486 }
487
488 static void cancel_elem_empty(TS_SECTION_PARSER_PRIVATE_DATA *prv, TS_SECTION_ELEM *elem)
489 {
490 reset_section(&(elem->sect));
491 elem->ref = 0;
492 put_ts_section_list_tail(&(prv->pool), elem);
493 }
494
495 static void cancel_elem_error(TS_SECTION_PARSER_PRIVATE_DATA *prv, TS_SECTION_ELEM *elem)
496 {
497 reset_section(&(elem->sect));
498 elem->ref = 0;
499 put_ts_section_list_tail(&(prv->pool), elem);
500 prv->stat.total += 1;
501 prv->stat.error += 1;
502 }
503
504 static void cancel_elem_same(TS_SECTION_PARSER_PRIVATE_DATA *prv, TS_SECTION_ELEM *elem)
505 {
506 reset_section(&(elem->sect));
507 elem->ref = 0;
508 put_ts_section_list_tail(&(prv->pool), elem);
509 prv->stat.total +=1;
510 }
511
512 static void commit_elem_updated(TS_SECTION_PARSER_PRIVATE_DATA *prv, TS_SECTION_ELEM *elem)
513 {
514 if( (prv->last != NULL) && (prv->last->ref > 0) ){
515 prv->last->ref -= 1;
516 }
517
518 elem->ref = 2;
519 prv->last = elem;
520 put_ts_section_list_tail(&(prv->buff), elem);
521 prv->stat.total += 1;
522 prv->stat.unique += 1;
523 }
524
525 static TS_SECTION_ELEM *query_work_elem(TS_SECTION_PARSER_PRIVATE_DATA *prv)
526 {
527 TS_SECTION_ELEM *r;
528
529 r = prv->pool.head;
530 while(r != NULL){
531 if(r->ref < 1){
532 break;
533 }
534 r = (TS_SECTION_ELEM *)(r->next);
535 }
536
537 if(r != NULL){
538 unlink_ts_section_list(&(prv->pool), r);
539 reset_section(&(r->sect));
540 r->ref = 0;
541 return r;
542 }
543
544 return create_ts_section_elem();
545 }
546
547 static void extract_ts_section_header(TS_SECTION *sect)
548 {
549 int size;
550 uint8_t *p;
551
552 sect->data = NULL;
553
554 size = sect->tail - sect->raw;
555 if(size < 3){
556 /* need more data */
557 return;
558 }
559
560 p = sect->raw;
561
562 sect->hdr.table_id = p[0];
563 sect->hdr.section_syntax_indicator = (p[1] >> 7) & 0x01;
564 sect->hdr.private_indicator = (p[1] >> 6) & 0x01;
565 sect->hdr.section_length =((p[1] << 8) | p[2]) & 0x0fff;
566
567 if(sect->hdr.section_syntax_indicator == 0){
568 /* short format section header */
569 sect->data = p+3;
570 return;
571 }
572
573 /* long format section header */
574
575 if(size < 8){
576 /* need more data */
577 return;
578 }
579
580 sect->hdr.table_id_extension =((p[3] << 8) | p[4]);
581 sect->hdr.version_number = (p[5] >> 1) & 0x1f;
582 sect->hdr.current_next_indicator = p[5] & 0x01;
583 sect->hdr.section_number = p[6];
584 sect->hdr.last_section_number = p[7];
585
586 sect->data = p+8;
587
588 return;
589 }
590
591 static TS_SECTION_ELEM *create_ts_section_elem()
592 {
593 TS_SECTION_ELEM *r;
594 int n;
595
596 n = sizeof(TS_SECTION_ELEM) + MAX_RAW_SECTION_SIZE;
597 r = (TS_SECTION_ELEM *)calloc(1, n);
598 if(r == NULL){
599 /* failed on malloc() */
600 return NULL;
601 }
602
603 r->sect.raw = (uint8_t *)(r+1);
604 r->sect.tail = r->sect.raw;
605
606 return r;
607 }
608
609 static TS_SECTION_ELEM *get_ts_section_list_head(TS_SECTION_LIST *list)
610 {
611 TS_SECTION_ELEM *r;
612
613 if(list == NULL){/* invalid param */
614 return NULL;
615 }
616
617 r = list->head;
618 if(r == NULL){
619 return NULL;
620 }
621
622 list->head = (TS_SECTION_ELEM *)(r->next);
623 if(list->head != NULL){
624 list->head->prev = NULL;
625 list->count -= 1;
626 }else{
627 list->tail = NULL;
628 list->count = 0;
629 }
630
631 r->next = NULL;
632
633 return r;
634 }
635
636 static void put_ts_section_list_tail(TS_SECTION_LIST *list, TS_SECTION_ELEM *elem)
637 {
638 if( (list == NULL) || (elem == NULL) ){
639 /* invalid param */
640 return;
641 }
642
643 if(list->tail != NULL){
644 elem->prev = list->tail;
645 elem->next = NULL;
646 list->tail->next = elem;
647 list->tail = elem;
648 list->count += 1;
649 }else{
650 elem->prev = NULL;
651 elem->next = NULL;
652 list->head = elem;
653 list->tail = elem;
654 list->count = 1;
655 }
656 }
657
658 static void unlink_ts_section_list(TS_SECTION_LIST *list, TS_SECTION_ELEM *elem)
659 {
660 TS_SECTION_ELEM *prev;
661 TS_SECTION_ELEM *next;
662
663 if( (list == NULL) || (elem == NULL) ){
664 /* invalid param */
665 return;
666 }
667
668 prev = (TS_SECTION_ELEM *)(elem->prev);
669 next = (TS_SECTION_ELEM *)(elem->next);
670
671 if(prev != NULL){
672 prev->next = next;
673 }else{
674 list->head = next;
675 }
676 if(next != NULL){
677 next->prev = prev;
678 }else{
679 list->tail = prev;
680 }
681 list->count -= 1;
682 }
683
684 static void clear_ts_section_list(TS_SECTION_LIST *list)
685 {
686 TS_SECTION_ELEM *e;
687 TS_SECTION_ELEM *n;
688
689 if(list == NULL){ /* invalid param */
690 return;
691 }
692
693 e = list->head;
694 while(e != NULL){
695 n = (TS_SECTION_ELEM *)(e->next);
696 free(e);
697 e = n;
698 }
699
700 list->head = NULL;
701 list->tail = NULL;
702 list->count = 0;
703 }
704
705 static uint32_t crc32(uint8_t *head, uint8_t *tail)
706 {
707 uint32_t crc;
708 uint8_t *p;
709
710 static const uint32_t table[256] = {
711 0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9,
712 0x130476DC, 0x17C56B6B, 0x1A864DB2, 0x1E475005,
713 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61,
714 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD,
715
716 0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9,
717 0x5F15ADAC, 0x5BD4B01B, 0x569796C2, 0x52568B75,
718 0x6A1936C8, 0x6ED82B7F, 0x639B0DA6, 0x675A1011,
719 0x791D4014, 0x7DDC5DA3, 0x709F7B7A, 0x745E66CD,
720
721 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039,
722 0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5,
723 0xBE2B5B58, 0xBAEA46EF, 0xB7A96036, 0xB3687D81,
724 0xAD2F2D84, 0xA9EE3033, 0xA4AD16EA, 0xA06C0B5D,
725
726 0xD4326D90, 0xD0F37027, 0xDDB056FE, 0xD9714B49,
727 0xC7361B4C, 0xC3F706FB, 0xCEB42022, 0xCA753D95,
728 0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1,
729 0xE13EF6F4, 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D,
730
731 0x34867077, 0x30476DC0, 0x3D044B19, 0x39C556AE,
732 0x278206AB, 0x23431B1C, 0x2E003DC5, 0x2AC12072,
733 0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16,
734 0x018AEB13, 0x054BF6A4, 0x0808D07D, 0x0CC9CDCA,
735
736 0x7897AB07, 0x7C56B6B0, 0x71159069, 0x75D48DDE,
737 0x6B93DDDB, 0x6F52C06C, 0x6211E6B5, 0x66D0FB02,
738 0x5E9F46BF, 0x5A5E5B08, 0x571D7DD1, 0x53DC6066,
739 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA,
740
741 0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E,
742 0xBFA1B04B, 0xBB60ADFC, 0xB6238B25, 0xB2E29692,
743 0x8AAD2B2F, 0x8E6C3698, 0x832F1041, 0x87EE0DF6,
744 0x99A95DF3, 0x9D684044, 0x902B669D, 0x94EA7B2A,
745
746 0xE0B41DE7, 0xE4750050, 0xE9362689, 0xEDF73B3E,
747 0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2,
748 0xC6BCF05F, 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686,
749 0xD5B88683, 0xD1799B34, 0xDC3ABDED, 0xD8FBA05A,
750
751 0x690CE0EE, 0x6DCDFD59, 0x608EDB80, 0x644FC637,
752 0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB,
753 0x4F040D56, 0x4BC510E1, 0x46863638, 0x42472B8F,
754 0x5C007B8A, 0x58C1663D, 0x558240E4, 0x51435D53,
755
756 0x251D3B9E, 0x21DC2629, 0x2C9F00F0, 0x285E1D47,
757 0x36194D42, 0x32D850F5, 0x3F9B762C, 0x3B5A6B9B,
758 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF,
759 0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623,
760
761 0xF12F560E, 0xF5EE4BB9, 0xF8AD6D60, 0xFC6C70D7,
762 0xE22B20D2, 0xE6EA3D65, 0xEBA91BBC, 0xEF68060B,
763 0xD727BBB6, 0xD3E6A601, 0xDEA580D8, 0xDA649D6F,
764 0xC423CD6A, 0xC0E2D0DD, 0xCDA1F604, 0xC960EBB3,
765
766 0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7,
767 0xAE3AFBA2, 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B,
768 0x9B3660C6, 0x9FF77D71, 0x92B45BA8, 0x9675461F,
769 0x8832161A, 0x8CF30BAD, 0x81B02D74, 0x857130C3,
770
771 0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640,
772 0x4E8EE645, 0x4A4FFBF2, 0x470CDD2B, 0x43CDC09C,
773 0x7B827D21, 0x7F436096, 0x7200464F, 0x76C15BF8,
774 0x68860BFD, 0x6C47164A, 0x61043093, 0x65C52D24,
775
776 0x119B4BE9, 0x155A565E, 0x18197087, 0x1CD86D30,
777 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC,
778 0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088,
779 0x2497D08D, 0x2056CD3A, 0x2D15EBE3, 0x29D4F654,
780
781 0xC5A92679, 0xC1683BCE, 0xCC2B1D17, 0xC8EA00A0,
782 0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB, 0xDBEE767C,
783 0xE3A1CBC1, 0xE760D676, 0xEA23F0AF, 0xEEE2ED18,
784 0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4,
785
786 0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0,
787 0x9ABC8BD5, 0x9E7D9662, 0x933EB0BB, 0x97FFAD0C,
788 0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668,
789 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4,
790 };
791
792 crc = 0xffffffff;
793
794 p = head;
795 while(p < tail){
796 crc = (crc << 8) ^ table[ ((crc >> 24) ^ p[0]) & 0xff ];
797 p += 1;
798 }
799
800 return crc;
801 }
802