colour --> color in variable names
[ffmpeg.git] / libavcodec / dvbsubdec.c
1 /*
2  * DVB subtitle decoding for ffmpeg
3  * Copyright (c) 2005 Ian Caulfield.
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 #include "avcodec.h"
22 #include "dsputil.h"
23 #include "bitstream.h"
24 #include "colorspace.h"
25
26 //#define DEBUG
27 //#define DEBUG_PACKET_CONTENTS
28 //#define DEBUG_SAVE_IMAGES
29
30 #define DVBSUB_PAGE_SEGMENT     0x10
31 #define DVBSUB_REGION_SEGMENT   0x11
32 #define DVBSUB_CLUT_SEGMENT     0x12
33 #define DVBSUB_OBJECT_SEGMENT   0x13
34 #define DVBSUB_DISPLAY_SEGMENT  0x80
35
36 #define cm (ff_cropTbl + MAX_NEG_CROP)
37
38 #ifdef DEBUG_SAVE_IMAGES
39 #undef fprintf
40 #if 0
41 static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
42                      uint32_t *rgba_palette)
43 {
44     int x, y, v;
45     FILE *f;
46     char fname[40], fname2[40];
47     char command[1024];
48
49     snprintf(fname, 40, "%s.ppm", filename);
50
51     f = fopen(fname, "w");
52     if (!f) {
53         perror(fname);
54         exit(1);
55     }
56     fprintf(f, "P6\n"
57             "%d %d\n"
58             "%d\n",
59             w, h, 255);
60     for(y = 0; y < h; y++) {
61         for(x = 0; x < w; x++) {
62             v = rgba_palette[bitmap[y * w + x]];
63             putc((v >> 16) & 0xff, f);
64             putc((v >> 8) & 0xff, f);
65             putc((v >> 0) & 0xff, f);
66         }
67     }
68     fclose(f);
69
70
71     snprintf(fname2, 40, "%s-a.pgm", filename);
72
73     f = fopen(fname2, "w");
74     if (!f) {
75         perror(fname2);
76         exit(1);
77     }
78     fprintf(f, "P5\n"
79             "%d %d\n"
80             "%d\n",
81             w, h, 255);
82     for(y = 0; y < h; y++) {
83         for(x = 0; x < w; x++) {
84             v = rgba_palette[bitmap[y * w + x]];
85             putc((v >> 24) & 0xff, f);
86         }
87     }
88     fclose(f);
89
90     snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
91     system(command);
92
93     snprintf(command, 1024, "rm %s %s", fname, fname2);
94     system(command);
95 }
96 #endif
97
98 static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)
99 {
100     int x, y, v;
101     FILE *f;
102     char fname[40], fname2[40];
103     char command[1024];
104
105     snprintf(fname, sizeof(fname), "%s.ppm", filename);
106
107     f = fopen(fname, "w");
108     if (!f) {
109         perror(fname);
110         exit(1);
111     }
112     fprintf(f, "P6\n"
113             "%d %d\n"
114             "%d\n",
115             w, h, 255);
116     for(y = 0; y < h; y++) {
117         for(x = 0; x < w; x++) {
118             v = bitmap[y * w + x];
119             putc((v >> 16) & 0xff, f);
120             putc((v >> 8) & 0xff, f);
121             putc((v >> 0) & 0xff, f);
122         }
123     }
124     fclose(f);
125
126
127     snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
128
129     f = fopen(fname2, "w");
130     if (!f) {
131         perror(fname2);
132         exit(1);
133     }
134     fprintf(f, "P5\n"
135             "%d %d\n"
136             "%d\n",
137             w, h, 255);
138     for(y = 0; y < h; y++) {
139         for(x = 0; x < w; x++) {
140             v = bitmap[y * w + x];
141             putc((v >> 24) & 0xff, f);
142         }
143     }
144     fclose(f);
145
146     snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
147     system(command);
148
149     snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
150     system(command);
151 }
152 #endif
153
154 #define RGBA(r,g,b,a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
155
156 typedef struct DVBSubCLUT {
157     int id;
158
159     uint32_t clut4[4];
160     uint32_t clut16[16];
161     uint32_t clut256[256];
162
163     struct DVBSubCLUT *next;
164 } DVBSubCLUT;
165
166 static DVBSubCLUT default_clut;
167
168 typedef struct DVBSubObjectDisplay {
169     int object_id;
170     int region_id;
171
172     int x_pos;
173     int y_pos;
174
175     int fgcolor;
176     int bgcolor;
177
178     struct DVBSubObjectDisplay *region_list_next;
179     struct DVBSubObjectDisplay *object_list_next;
180 } DVBSubObjectDisplay;
181
182 typedef struct DVBSubObject {
183     int id;
184
185     int type;
186
187     DVBSubObjectDisplay *display_list;
188
189     struct DVBSubObject *next;
190 } DVBSubObject;
191
192 typedef struct DVBSubRegionDisplay {
193     int region_id;
194
195     int x_pos;
196     int y_pos;
197
198     struct DVBSubRegionDisplay *next;
199 } DVBSubRegionDisplay;
200
201 typedef struct DVBSubRegion {
202     int id;
203
204     int width;
205     int height;
206     int depth;
207
208     int clut;
209     int bgcolor;
210
211     uint8_t *pbuf;
212     int buf_size;
213
214     DVBSubObjectDisplay *display_list;
215
216     struct DVBSubRegion *next;
217 } DVBSubRegion;
218
219 typedef struct DVBSubContext {
220     int composition_id;
221     int ancillary_id;
222
223     int time_out;
224     DVBSubRegion *region_list;
225     DVBSubCLUT   *clut_list;
226     DVBSubObject *object_list;
227
228     int display_list_size;
229     DVBSubRegionDisplay *display_list;
230 } DVBSubContext;
231
232
233 static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
234 {
235     DVBSubObject *ptr = ctx->object_list;
236
237     while (ptr && ptr->id != object_id) {
238         ptr = ptr->next;
239     }
240
241     return ptr;
242 }
243
244 static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
245 {
246     DVBSubCLUT *ptr = ctx->clut_list;
247
248     while (ptr && ptr->id != clut_id) {
249         ptr = ptr->next;
250     }
251
252     return ptr;
253 }
254
255 static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
256 {
257     DVBSubRegion *ptr = ctx->region_list;
258
259     while (ptr && ptr->id != region_id) {
260         ptr = ptr->next;
261     }
262
263     return ptr;
264 }
265
266 static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
267 {
268     DVBSubObject *object, *obj2, **obj2_ptr;
269     DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;
270
271     while (region->display_list) {
272         display = region->display_list;
273
274         object = get_object(ctx, display->object_id);
275
276         if (object) {
277             obj_disp = object->display_list;
278             obj_disp_ptr = &object->display_list;
279
280             while (obj_disp && obj_disp != display) {
281                 obj_disp_ptr = &obj_disp->object_list_next;
282                 obj_disp = obj_disp->object_list_next;
283             }
284
285             if (obj_disp) {
286                 *obj_disp_ptr = obj_disp->object_list_next;
287
288                 if (!object->display_list) {
289                     obj2 = ctx->object_list;
290                     obj2_ptr = &ctx->object_list;
291
292                     while (obj2 && obj2 != object) {
293                         obj2_ptr = &obj2->next;
294                         obj2 = obj2->next;
295                     }
296
297                     *obj2_ptr = obj2->next;
298
299                     av_free(obj2);
300                 }
301             }
302         }
303
304         region->display_list = display->region_list_next;
305
306         av_free(display);
307     }
308
309 }
310
311 static void delete_state(DVBSubContext *ctx)
312 {
313     DVBSubRegion *region;
314     DVBSubCLUT *clut;
315
316     while (ctx->region_list) {
317         region = ctx->region_list;
318
319         ctx->region_list = region->next;
320
321         delete_region_display_list(ctx, region);
322         if (region->pbuf)
323             av_free(region->pbuf);
324
325         av_free(region);
326     }
327
328     while (ctx->clut_list) {
329         clut = ctx->clut_list;
330
331         ctx->clut_list = clut->next;
332
333         av_free(clut);
334     }
335
336     /* Should already be null */
337     if (ctx->object_list)
338         av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n");
339 }
340
341 static int dvbsub_init_decoder(AVCodecContext *avctx)
342 {
343     int i, r, g, b, a = 0;
344     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
345
346     memset(avctx->priv_data, 0, sizeof(DVBSubContext));
347
348     ctx->composition_id = avctx->sub_id & 0xffff;
349     ctx->ancillary_id = avctx->sub_id >> 16;
350
351     default_clut.id = -1;
352     default_clut.next = NULL;
353
354     default_clut.clut4[0] = RGBA(  0,   0,   0,   0);
355     default_clut.clut4[1] = RGBA(255, 255, 255, 255);
356     default_clut.clut4[2] = RGBA(  0,   0,   0, 255);
357     default_clut.clut4[3] = RGBA(127, 127, 127, 255);
358
359     default_clut.clut16[0] = RGBA(  0,   0,   0,   0);
360     for (i = 1; i < 16; i++) {
361         if (i < 8) {
362             r = (i & 1) ? 255 : 0;
363             g = (i & 2) ? 255 : 0;
364             b = (i & 4) ? 255 : 0;
365         } else {
366             r = (i & 1) ? 127 : 0;
367             g = (i & 2) ? 127 : 0;
368             b = (i & 4) ? 127 : 0;
369         }
370         default_clut.clut16[i] = RGBA(r, g, b, 255);
371     }
372
373     default_clut.clut256[0] = RGBA(  0,   0,   0,   0);
374     for (i = 1; i < 256; i++) {
375         if (i < 8) {
376             r = (i & 1) ? 255 : 0;
377             g = (i & 2) ? 255 : 0;
378             b = (i & 4) ? 255 : 0;
379             a = 63;
380         } else {
381             switch (i & 0x88) {
382             case 0x00:
383                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
384                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
385                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
386                 a = 255;
387                 break;
388             case 0x08:
389                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
390                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
391                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
392                 a = 127;
393                 break;
394             case 0x80:
395                 r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
396                 g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
397                 b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
398                 a = 255;
399                 break;
400             case 0x88:
401                 r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
402                 g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
403                 b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
404                 a = 255;
405                 break;
406             }
407         }
408         default_clut.clut256[i] = RGBA(r, g, b, a);
409     }
410
411     return 0;
412 }
413
414 static int dvbsub_close_decoder(AVCodecContext *avctx)
415 {
416     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
417     DVBSubRegionDisplay *display;
418
419     delete_state(ctx);
420
421     while (ctx->display_list) {
422         display = ctx->display_list;
423         ctx->display_list = display->next;
424
425         av_free(display);
426     }
427
428     return 0;
429 }
430
431 static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
432                                    uint8_t **srcbuf, int buf_size,
433                                    int non_mod, uint8_t *map_table)
434 {
435     GetBitContext gb;
436
437     int bits;
438     int run_length;
439     int pixels_read = 0;
440
441     init_get_bits(&gb, *srcbuf, buf_size << 8);
442
443     while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
444         bits = get_bits(&gb, 2);
445
446         if (bits) {
447             if (non_mod != 1 || bits != 1) {
448                 if (map_table)
449                     *destbuf++ = map_table[bits];
450                 else
451                     *destbuf++ = bits;
452             }
453             pixels_read++;
454         } else {
455             bits = get_bits1(&gb);
456             if (bits == 1) {
457                 run_length = get_bits(&gb, 3) + 3;
458                 bits = get_bits(&gb, 2);
459
460                 if (non_mod == 1 && bits == 1)
461                     pixels_read += run_length;
462                 else {
463                     if (map_table)
464                         bits = map_table[bits];
465                     while (run_length-- > 0 && pixels_read < dbuf_len) {
466                         *destbuf++ = bits;
467                         pixels_read++;
468                     }
469                 }
470             } else {
471                 bits = get_bits1(&gb);
472                 if (bits == 0) {
473                     bits = get_bits(&gb, 2);
474                     if (bits == 2) {
475                         run_length = get_bits(&gb, 4) + 12;
476                         bits = get_bits(&gb, 2);
477
478                         if (non_mod == 1 && bits == 1)
479                             pixels_read += run_length;
480                         else {
481                             if (map_table)
482                                 bits = map_table[bits];
483                             while (run_length-- > 0 && pixels_read < dbuf_len) {
484                                 *destbuf++ = bits;
485                                 pixels_read++;
486                             }
487                         }
488                     } else if (bits == 3) {
489                         run_length = get_bits(&gb, 8) + 29;
490                         bits = get_bits(&gb, 2);
491
492                         if (non_mod == 1 && bits == 1)
493                             pixels_read += run_length;
494                         else {
495                             if (map_table)
496                                 bits = map_table[bits];
497                             while (run_length-- > 0 && pixels_read < dbuf_len) {
498                                 *destbuf++ = bits;
499                                 pixels_read++;
500                             }
501                         }
502                     } else if (bits == 1) {
503                         pixels_read += 2;
504                         if (map_table)
505                             bits = map_table[0];
506                         else
507                             bits = 0;
508                         if (pixels_read <= dbuf_len) {
509                             *destbuf++ = bits;
510                             *destbuf++ = bits;
511                         }
512                     } else {
513                         (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
514                         return pixels_read;
515                     }
516                 } else {
517                     if (map_table)
518                         bits = map_table[0];
519                     else
520                         bits = 0;
521                     *destbuf++ = bits;
522                     pixels_read++;
523                 }
524             }
525         }
526     }
527
528     if (get_bits(&gb, 6))
529         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
530
531     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
532
533     return pixels_read;
534 }
535
536 static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
537                                    uint8_t **srcbuf, int buf_size,
538                                    int non_mod, uint8_t *map_table)
539 {
540     GetBitContext gb;
541
542     int bits;
543     int run_length;
544     int pixels_read = 0;
545
546     init_get_bits(&gb, *srcbuf, buf_size << 8);
547
548     while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
549         bits = get_bits(&gb, 4);
550
551         if (bits) {
552             if (non_mod != 1 || bits != 1) {
553                 if (map_table)
554                     *destbuf++ = map_table[bits];
555                 else
556                     *destbuf++ = bits;
557             }
558             pixels_read++;
559         } else {
560             bits = get_bits1(&gb);
561             if (bits == 0) {
562                 run_length = get_bits(&gb, 3);
563
564                 if (run_length == 0) {
565                     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
566                     return pixels_read;
567                 }
568
569                 run_length += 2;
570
571                 if (map_table)
572                     bits = map_table[0];
573                 else
574                     bits = 0;
575
576                 while (run_length-- > 0 && pixels_read < dbuf_len) {
577                     *destbuf++ = bits;
578                     pixels_read++;
579                 }
580             } else {
581                 bits = get_bits1(&gb);
582                 if (bits == 0) {
583                     run_length = get_bits(&gb, 2) + 4;
584                     bits = get_bits(&gb, 4);
585
586                     if (non_mod == 1 && bits == 1)
587                         pixels_read += run_length;
588                     else {
589                         if (map_table)
590                             bits = map_table[bits];
591                         while (run_length-- > 0 && pixels_read < dbuf_len) {
592                             *destbuf++ = bits;
593                             pixels_read++;
594                         }
595                     }
596                 } else {
597                     bits = get_bits(&gb, 2);
598                     if (bits == 2) {
599                         run_length = get_bits(&gb, 4) + 9;
600                         bits = get_bits(&gb, 4);
601
602                         if (non_mod == 1 && bits == 1)
603                             pixels_read += run_length;
604                         else {
605                             if (map_table)
606                                 bits = map_table[bits];
607                             while (run_length-- > 0 && pixels_read < dbuf_len) {
608                                 *destbuf++ = bits;
609                                 pixels_read++;
610                             }
611                         }
612                     } else if (bits == 3) {
613                         run_length = get_bits(&gb, 8) + 25;
614                         bits = get_bits(&gb, 4);
615
616                         if (non_mod == 1 && bits == 1)
617                             pixels_read += run_length;
618                         else {
619                             if (map_table)
620                                 bits = map_table[bits];
621                             while (run_length-- > 0 && pixels_read < dbuf_len) {
622                                 *destbuf++ = bits;
623                                 pixels_read++;
624                             }
625                         }
626                     } else if (bits == 1) {
627                         pixels_read += 2;
628                         if (map_table)
629                             bits = map_table[0];
630                         else
631                             bits = 0;
632                         if (pixels_read <= dbuf_len) {
633                             *destbuf++ = bits;
634                             *destbuf++ = bits;
635                         }
636                     } else {
637                         if (map_table)
638                             bits = map_table[0];
639                         else
640                             bits = 0;
641                         *destbuf++ = bits;
642                         pixels_read ++;
643                     }
644                 }
645             }
646         }
647     }
648
649     if (get_bits(&gb, 8))
650         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
651
652     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
653
654     return pixels_read;
655 }
656
657 static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,
658                                     uint8_t **srcbuf, int buf_size,
659                                     int non_mod, uint8_t *map_table)
660 {
661     uint8_t *sbuf_end = (*srcbuf) + buf_size;
662     int bits;
663     int run_length;
664     int pixels_read = 0;
665
666     while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
667         bits = *(*srcbuf)++;
668
669         if (bits) {
670             if (non_mod != 1 || bits != 1) {
671                 if (map_table)
672                     *destbuf++ = map_table[bits];
673                 else
674                     *destbuf++ = bits;
675             }
676             pixels_read++;
677         } else {
678             bits = *(*srcbuf)++;
679             run_length = bits & 0x7f;
680             if ((bits & 0x80) == 0) {
681                 if (run_length == 0) {
682                     return pixels_read;
683                 }
684
685                 if (map_table)
686                     bits = map_table[0];
687                 else
688                     bits = 0;
689                 while (run_length-- > 0 && pixels_read < dbuf_len) {
690                     *destbuf++ = bits;
691                     pixels_read++;
692                 }
693             } else {
694                 bits = *(*srcbuf)++;
695
696                 if (non_mod == 1 && bits == 1)
697                     pixels_read += run_length;
698                 if (map_table)
699                     bits = map_table[bits];
700                 else while (run_length-- > 0 && pixels_read < dbuf_len) {
701                     *destbuf++ = bits;
702                     pixels_read++;
703                 }
704             }
705         }
706     }
707
708     if (*(*srcbuf)++)
709         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
710
711     return pixels_read;
712 }
713
714
715
716 static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
717                                           uint8_t *buf, int buf_size, int top_bottom, int non_mod)
718 {
719     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
720
721     DVBSubRegion *region = get_region(ctx, display->region_id);
722     uint8_t *buf_end = buf + buf_size;
723     uint8_t *pbuf;
724     int x_pos, y_pos;
725     int i;
726
727     uint8_t map2to4[] = { 0x0,  0x7,  0x8,  0xf};
728     uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
729     uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
730                          0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
731     uint8_t *map_table;
732
733 #ifdef DEBUG
734     av_log(avctx, AV_LOG_INFO, "DVB pixel block size %d, %s field:\n", buf_size,
735                 top_bottom ? "bottom" : "top");
736 #endif
737
738 #ifdef DEBUG_PACKET_CONTENTS
739     for (i = 0; i < buf_size; i++) {
740         if (i % 16 == 0)
741             av_log(avctx, AV_LOG_INFO, "0x%08p: ", buf+i);
742
743         av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
744         if (i % 16 == 15)
745             av_log(avctx, AV_LOG_INFO, "\n");
746     }
747
748     if (i % 16)
749         av_log(avctx, AV_LOG_INFO, "\n");
750
751 #endif
752
753     if (region == 0)
754         return;
755
756     pbuf = region->pbuf;
757
758     x_pos = display->x_pos;
759     y_pos = display->y_pos;
760
761     if ((y_pos & 1) != top_bottom)
762         y_pos++;
763
764     while (buf < buf_end) {
765         if (x_pos > region->width || y_pos > region->height) {
766             av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");
767             return;
768         }
769
770         switch (*buf++) {
771         case 0x10:
772             if (region->depth == 8)
773                 map_table = map2to8;
774             else if (region->depth == 4)
775                 map_table = map2to4;
776             else
777                 map_table = NULL;
778
779             x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos,
780                                                 region->width - x_pos, &buf, buf_size,
781                                                 non_mod, map_table);
782             break;
783         case 0x11:
784             if (region->depth < 4) {
785                 av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
786                 return;
787             }
788
789             if (region->depth == 8)
790                 map_table = map4to8;
791             else
792                 map_table = NULL;
793
794             x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos,
795                                                 region->width - x_pos, &buf, buf_size,
796                                                 non_mod, map_table);
797             break;
798         case 0x12:
799             if (region->depth < 8) {
800                 av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
801                 return;
802             }
803
804             x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos,
805                                                 region->width - x_pos, &buf, buf_size,
806                                                 non_mod, NULL);
807             break;
808
809         case 0x20:
810             map2to4[0] = (*buf) >> 4;
811             map2to4[1] = (*buf++) & 0xf;
812             map2to4[2] = (*buf) >> 4;
813             map2to4[3] = (*buf++) & 0xf;
814             break;
815         case 0x21:
816             for (i = 0; i < 4; i++)
817                 map2to8[i] = *buf++;
818             break;
819         case 0x22:
820             for (i = 0; i < 16; i++)
821                 map4to8[i] = *buf++;
822             break;
823
824         case 0xf0:
825             x_pos = display->x_pos;
826             y_pos += 2;
827             break;
828         default:
829             av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
830         }
831     }
832
833 }
834
835 static void dvbsub_parse_object_segment(AVCodecContext *avctx,
836                                         uint8_t *buf, int buf_size)
837 {
838     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
839
840     uint8_t *buf_end = buf + buf_size;
841     uint8_t *block;
842     int object_id;
843     DVBSubObject *object;
844     DVBSubObjectDisplay *display;
845     int top_field_len, bottom_field_len;
846
847     int coding_method, non_modifying_color;
848
849     object_id = AV_RB16(buf);
850     buf += 2;
851
852     object = get_object(ctx, object_id);
853
854     if (!object)
855         return;
856
857     coding_method = ((*buf) >> 2) & 3;
858     non_modifying_color = ((*buf++) >> 1) & 1;
859
860     if (coding_method == 0) {
861         top_field_len = AV_RB16(buf);
862         buf += 2;
863         bottom_field_len = AV_RB16(buf);
864         buf += 2;
865
866         if (buf + top_field_len + bottom_field_len > buf_end) {
867             av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");
868             return;
869         }
870
871         for (display = object->display_list; display; display = display->object_list_next) {
872             block = buf;
873
874             dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
875                                             non_modifying_color);
876
877             if (bottom_field_len > 0)
878                 block = buf + top_field_len;
879             else
880                 bottom_field_len = top_field_len;
881
882             dvbsub_parse_pixel_data_block(avctx, display, block, bottom_field_len, 1,
883                                             non_modifying_color);
884         }
885
886 /*  } else if (coding_method == 1) {*/
887
888     } else {
889         av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
890     }
891
892 }
893
894 static void dvbsub_parse_clut_segment(AVCodecContext *avctx,
895                                         uint8_t *buf, int buf_size)
896 {
897     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
898
899     uint8_t *buf_end = buf + buf_size;
900     int clut_id;
901     DVBSubCLUT *clut;
902     int entry_id, depth , full_range;
903     int y, cr, cb, alpha;
904     int r, g, b, r_add, g_add, b_add;
905
906 #ifdef DEBUG_PACKET_CONTENTS
907     int i;
908
909     av_log(avctx, AV_LOG_INFO, "DVB clut packet:\n");
910
911     for (i=0; i < buf_size; i++) {
912         av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
913         if (i % 16 == 15)
914             av_log(avctx, AV_LOG_INFO, "\n");
915     }
916
917     if (i % 16)
918         av_log(avctx, AV_LOG_INFO, "\n");
919
920 #endif
921
922     clut_id = *buf++;
923     buf += 1;
924
925     clut = get_clut(ctx, clut_id);
926
927     if (!clut) {
928         clut = av_malloc(sizeof(DVBSubCLUT));
929
930         memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
931
932         clut->id = clut_id;
933
934         clut->next = ctx->clut_list;
935         ctx->clut_list = clut;
936     }
937
938     while (buf + 4 < buf_end) {
939         entry_id = *buf++;
940
941         depth = (*buf) & 0xe0;
942
943         if (depth == 0) {
944             av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
945             return;
946         }
947
948         full_range = (*buf++) & 1;
949
950         if (full_range) {
951             y = *buf++;
952             cr = *buf++;
953             cb = *buf++;
954             alpha = *buf++;
955         } else {
956             y = buf[0] & 0xfc;
957             cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
958             cb = (buf[1] << 2) & 0xf0;
959             alpha = (buf[1] << 6) & 0xc0;
960
961             buf += 2;
962         }
963
964         if (y == 0)
965             alpha = 0xff;
966
967         YUV_TO_RGB1_CCIR(cb, cr);
968         YUV_TO_RGB2_CCIR(r, g, b, y);
969
970 #ifdef DEBUG
971         av_log(avctx, AV_LOG_INFO, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
972 #endif
973
974         if (depth & 0x80)
975             clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
976         if (depth & 0x40)
977             clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
978         if (depth & 0x20)
979             clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
980     }
981 }
982
983
984 static void dvbsub_parse_region_segment(AVCodecContext *avctx,
985                                         uint8_t *buf, int buf_size)
986 {
987     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
988
989     uint8_t *buf_end = buf + buf_size;
990     int region_id, object_id;
991     DVBSubRegion *region;
992     DVBSubObject *object;
993     DVBSubObjectDisplay *display;
994     int fill;
995
996     if (buf_size < 10)
997         return;
998
999     region_id = *buf++;
1000
1001     region = get_region(ctx, region_id);
1002
1003     if (!region) {
1004         region = av_mallocz(sizeof(DVBSubRegion));
1005
1006         region->id = region_id;
1007
1008         region->next = ctx->region_list;
1009         ctx->region_list = region;
1010     }
1011
1012     fill = ((*buf++) >> 3) & 1;
1013
1014     region->width = AV_RB16(buf);
1015     buf += 2;
1016     region->height = AV_RB16(buf);
1017     buf += 2;
1018
1019     if (region->width * region->height != region->buf_size) {
1020         if (region->pbuf)
1021             av_free(region->pbuf);
1022
1023         region->buf_size = region->width * region->height;
1024
1025         region->pbuf = av_malloc(region->buf_size);
1026
1027         fill = 1;
1028     }
1029
1030     region->depth = 1 << (((*buf++) >> 2) & 7);
1031     if(region->depth<2 || region->depth>8){
1032         av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
1033         region->depth= 4;
1034     }
1035     region->clut = *buf++;
1036
1037     if (region->depth == 8)
1038         region->bgcolor = *buf++;
1039     else {
1040         buf += 1;
1041
1042         if (region->depth == 4)
1043             region->bgcolor = (((*buf++) >> 4) & 15);
1044         else
1045             region->bgcolor = (((*buf++) >> 2) & 3);
1046     }
1047
1048 #ifdef DEBUG
1049     av_log(avctx, AV_LOG_INFO, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1050 #endif
1051
1052     if (fill) {
1053         memset(region->pbuf, region->bgcolor, region->buf_size);
1054 #ifdef DEBUG
1055         av_log(avctx, AV_LOG_INFO, "Fill region (%d)\n", region->bgcolor);
1056 #endif
1057     }
1058
1059     delete_region_display_list(ctx, region);
1060
1061     while (buf + 5 < buf_end) {
1062         object_id = AV_RB16(buf);
1063         buf += 2;
1064
1065         object = get_object(ctx, object_id);
1066
1067         if (!object) {
1068             object = av_mallocz(sizeof(DVBSubObject));
1069
1070             object->id = object_id;
1071             object->next = ctx->object_list;
1072             ctx->object_list = object;
1073         }
1074
1075         object->type = (*buf) >> 6;
1076
1077         display = av_mallocz(sizeof(DVBSubObjectDisplay));
1078
1079         display->object_id = object_id;
1080         display->region_id = region_id;
1081
1082         display->x_pos = AV_RB16(buf) & 0xfff;
1083         buf += 2;
1084         display->y_pos = AV_RB16(buf) & 0xfff;
1085         buf += 2;
1086
1087         if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1088             display->fgcolor = *buf++;
1089             display->bgcolor = *buf++;
1090         }
1091
1092         display->region_list_next = region->display_list;
1093         region->display_list = display;
1094
1095         display->object_list_next = object->display_list;
1096         object->display_list = display;
1097     }
1098 }
1099
1100 static void dvbsub_parse_page_segment(AVCodecContext *avctx,
1101                                         uint8_t *buf, int buf_size)
1102 {
1103     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
1104     DVBSubRegionDisplay *display;
1105     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1106
1107     uint8_t *buf_end = buf + buf_size;
1108     int region_id;
1109     int page_state;
1110
1111     if (buf_size < 1)
1112         return;
1113
1114     ctx->time_out = *buf++;
1115     page_state = ((*buf++) >> 2) & 3;
1116
1117 #ifdef DEBUG
1118     av_log(avctx, AV_LOG_INFO, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1119 #endif
1120
1121     if (page_state == 2) {
1122         delete_state(ctx);
1123     }
1124
1125     tmp_display_list = ctx->display_list;
1126     ctx->display_list = NULL;
1127     ctx->display_list_size = 0;
1128
1129     while (buf + 5 < buf_end) {
1130         region_id = *buf++;
1131         buf += 1;
1132
1133         display = tmp_display_list;
1134         tmp_ptr = &tmp_display_list;
1135
1136         while (display && display->region_id != region_id) {
1137             tmp_ptr = &display->next;
1138             display = display->next;
1139         }
1140
1141         if (!display)
1142             display = av_mallocz(sizeof(DVBSubRegionDisplay));
1143
1144         display->region_id = region_id;
1145
1146         display->x_pos = AV_RB16(buf);
1147         buf += 2;
1148         display->y_pos = AV_RB16(buf);
1149         buf += 2;
1150
1151         *tmp_ptr = display->next;
1152
1153         display->next = ctx->display_list;
1154         ctx->display_list = display;
1155         ctx->display_list_size++;
1156
1157 #ifdef DEBUG
1158         av_log(avctx, AV_LOG_INFO, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1159 #endif
1160     }
1161
1162     while (tmp_display_list) {
1163         display = tmp_display_list;
1164
1165         tmp_display_list = display->next;
1166
1167         av_free(display);
1168     }
1169
1170 }
1171
1172
1173 #ifdef DEBUG_SAVE_IMAGES
1174 static void save_display_set(DVBSubContext *ctx)
1175 {
1176     DVBSubRegion *region;
1177     DVBSubRegionDisplay *display;
1178     DVBSubCLUT *clut;
1179     uint32_t *clut_table;
1180     int x_pos, y_pos, width, height;
1181     int x, y, y_off, x_off;
1182     uint32_t *pbuf;
1183     char filename[32];
1184     static int fileno_index = 0;
1185
1186     x_pos = -1;
1187     y_pos = -1;
1188     width = 0;
1189     height = 0;
1190
1191     for (display = ctx->display_list; display; display = display->next) {
1192         region = get_region(ctx, display->region_id);
1193
1194         if (x_pos == -1) {
1195             x_pos = display->x_pos;
1196             y_pos = display->y_pos;
1197             width = region->width;
1198             height = region->height;
1199         } else {
1200             if (display->x_pos < x_pos) {
1201                 width += (x_pos - display->x_pos);
1202                 x_pos = display->x_pos;
1203             }
1204
1205             if (display->y_pos < y_pos) {
1206                 height += (y_pos - display->y_pos);
1207                 y_pos = display->y_pos;
1208             }
1209
1210             if (display->x_pos + region->width > x_pos + width) {
1211                 width = display->x_pos + region->width - x_pos;
1212             }
1213
1214             if (display->y_pos + region->height > y_pos + height) {
1215                 height = display->y_pos + region->height - y_pos;
1216             }
1217         }
1218     }
1219
1220     if (x_pos >= 0) {
1221
1222         pbuf = av_malloc(width * height * 4);
1223
1224         for (display = ctx->display_list; display; display = display->next) {
1225             region = get_region(ctx, display->region_id);
1226
1227             x_off = display->x_pos - x_pos;
1228             y_off = display->y_pos - y_pos;
1229
1230             clut = get_clut(ctx, region->clut);
1231
1232             if (clut == 0)
1233                 clut = &default_clut;
1234
1235             switch (region->depth) {
1236             case 2:
1237                 clut_table = clut->clut4;
1238                 break;
1239             case 8:
1240                 clut_table = clut->clut256;
1241                 break;
1242             case 4:
1243             default:
1244                 clut_table = clut->clut16;
1245                 break;
1246             }
1247
1248             for (y = 0; y < region->height; y++) {
1249                 for (x = 0; x < region->width; x++) {
1250                     pbuf[((y + y_off) * width) + x_off + x] =
1251                         clut_table[region->pbuf[y * region->width + x]];
1252                 }
1253             }
1254
1255         }
1256
1257         snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1258
1259         png_save2(filename, pbuf, width, height);
1260
1261         av_free(pbuf);
1262     }
1263
1264     fileno_index++;
1265 }
1266 #endif
1267
1268 static int dvbsub_display_end_segment(AVCodecContext *avctx, uint8_t *buf,
1269                                         int buf_size, AVSubtitle *sub)
1270 {
1271     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
1272
1273     DVBSubRegion *region;
1274     DVBSubRegionDisplay *display;
1275     AVSubtitleRect *rect;
1276     DVBSubCLUT *clut;
1277     uint32_t *clut_table;
1278     int i;
1279
1280     sub->rects = NULL;
1281     sub->start_display_time = 0;
1282     sub->end_display_time = ctx->time_out * 1000;
1283     sub->format = 0;
1284
1285     sub->num_rects = ctx->display_list_size;
1286
1287     if (sub->num_rects > 0)
1288         sub->rects = av_mallocz(sizeof(AVSubtitleRect) * sub->num_rects);
1289
1290     i = 0;
1291
1292     for (display = ctx->display_list; display; display = display->next) {
1293         region = get_region(ctx, display->region_id);
1294         rect = &sub->rects[i];
1295
1296         if (!region)
1297             continue;
1298
1299         rect->x = display->x_pos;
1300         rect->y = display->y_pos;
1301         rect->w = region->width;
1302         rect->h = region->height;
1303         rect->nb_colors = 16;
1304         rect->linesize = region->width;
1305
1306         clut = get_clut(ctx, region->clut);
1307
1308         if (!clut)
1309             clut = &default_clut;
1310
1311         switch (region->depth) {
1312         case 2:
1313             clut_table = clut->clut4;
1314             break;
1315         case 8:
1316             clut_table = clut->clut256;
1317             break;
1318         case 4:
1319         default:
1320             clut_table = clut->clut16;
1321             break;
1322         }
1323
1324         rect->rgba_palette = av_malloc((1 << region->depth) * sizeof(uint32_t));
1325         memcpy(rect->rgba_palette, clut_table, (1 << region->depth) * sizeof(uint32_t));
1326
1327         rect->bitmap = av_malloc(region->buf_size);
1328         memcpy(rect->bitmap, region->pbuf, region->buf_size);
1329
1330         i++;
1331     }
1332
1333     sub->num_rects = i;
1334
1335 #ifdef DEBUG_SAVE_IMAGES
1336     save_display_set(ctx);
1337 #endif
1338
1339     return 1;
1340 }
1341
1342 static int dvbsub_decode(AVCodecContext *avctx,
1343                          void *data, int *data_size,
1344                          uint8_t *buf, int buf_size)
1345 {
1346     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
1347     AVSubtitle *sub = (AVSubtitle*) data;
1348     uint8_t *p, *p_end;
1349     int segment_type;
1350     int page_id;
1351     int segment_length;
1352
1353 #ifdef DEBUG_PACKET_CONTENTS
1354     int i;
1355
1356     av_log(avctx, AV_LOG_INFO, "DVB sub packet:\n");
1357
1358     for (i=0; i < buf_size; i++) {
1359         av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
1360         if (i % 16 == 15)
1361             av_log(avctx, AV_LOG_INFO, "\n");
1362     }
1363
1364     if (i % 16)
1365         av_log(avctx, AV_LOG_INFO, "\n");
1366
1367 #endif
1368
1369     if (buf_size <= 2)
1370         return -1;
1371
1372     p = buf;
1373     p_end = buf + buf_size;
1374
1375     while (p < p_end && *p == 0x0f) {
1376         p += 1;
1377         segment_type = *p++;
1378         page_id = AV_RB16(p);
1379         p += 2;
1380         segment_length = AV_RB16(p);
1381         p += 2;
1382
1383         if (page_id == ctx->composition_id || page_id == ctx->ancillary_id) {
1384             switch (segment_type) {
1385             case DVBSUB_PAGE_SEGMENT:
1386                 dvbsub_parse_page_segment(avctx, p, segment_length);
1387                 break;
1388             case DVBSUB_REGION_SEGMENT:
1389                 dvbsub_parse_region_segment(avctx, p, segment_length);
1390                 break;
1391             case DVBSUB_CLUT_SEGMENT:
1392                 dvbsub_parse_clut_segment(avctx, p, segment_length);
1393                 break;
1394             case DVBSUB_OBJECT_SEGMENT:
1395                 dvbsub_parse_object_segment(avctx, p, segment_length);
1396                 break;
1397             case DVBSUB_DISPLAY_SEGMENT:
1398                 *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);
1399                 break;
1400             default:
1401 #ifdef DEBUG
1402                 av_log(avctx, AV_LOG_INFO, "Subtitling segment type 0x%x, page id %d, length %d\n",
1403                         segment_type, page_id, segment_length);
1404 #endif
1405                 break;
1406             }
1407         }
1408
1409         p += segment_length;
1410     }
1411
1412     if (p != p_end) {
1413 #ifdef DEBUG
1414         av_log(avctx, AV_LOG_INFO, "Junk at end of packet\n");
1415 #endif
1416         return -1;
1417     }
1418
1419     return buf_size;
1420 }
1421
1422
1423 AVCodec dvbsub_decoder = {
1424     "dvbsub",
1425     CODEC_TYPE_SUBTITLE,
1426     CODEC_ID_DVB_SUBTITLE,
1427     sizeof(DVBSubContext),
1428     dvbsub_init_decoder,
1429     NULL,
1430     dvbsub_close_decoder,
1431     dvbsub_decode,
1432 };