minor simplification
[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_ptr = &object->display_list;
278             obj_disp = *obj_disp_ptr;
279
280             while (obj_disp && obj_disp != display) {
281                 obj_disp_ptr = &obj_disp->object_list_next;
282                 obj_disp = *obj_disp_ptr;
283             }
284
285             if (obj_disp) {
286                 *obj_disp_ptr = obj_disp->object_list_next;
287
288                 if (!object->display_list) {
289                     obj2_ptr = &ctx->object_list;
290                     obj2 = *obj2_ptr;
291
292                     while (obj2 != object) {
293                         assert(obj2);
294                         obj2_ptr = &obj2->next;
295                         obj2 = *obj2_ptr;
296                     }
297
298                     *obj2_ptr = obj2->next;
299
300                     av_free(obj2);
301                 }
302             }
303         }
304
305         region->display_list = display->region_list_next;
306
307         av_free(display);
308     }
309
310 }
311
312 static void delete_state(DVBSubContext *ctx)
313 {
314     DVBSubRegion *region;
315     DVBSubCLUT *clut;
316
317     while (ctx->region_list) {
318         region = ctx->region_list;
319
320         ctx->region_list = region->next;
321
322         delete_region_display_list(ctx, region);
323         if (region->pbuf)
324             av_free(region->pbuf);
325
326         av_free(region);
327     }
328
329     while (ctx->clut_list) {
330         clut = ctx->clut_list;
331
332         ctx->clut_list = clut->next;
333
334         av_free(clut);
335     }
336
337     /* Should already be null */
338     if (ctx->object_list)
339         av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n");
340 }
341
342 static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
343 {
344     int i, r, g, b, a = 0;
345     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
346
347     memset(avctx->priv_data, 0, sizeof(DVBSubContext));
348
349     ctx->composition_id = avctx->sub_id & 0xffff;
350     ctx->ancillary_id = avctx->sub_id >> 16;
351
352     default_clut.id = -1;
353     default_clut.next = NULL;
354
355     default_clut.clut4[0] = RGBA(  0,   0,   0,   0);
356     default_clut.clut4[1] = RGBA(255, 255, 255, 255);
357     default_clut.clut4[2] = RGBA(  0,   0,   0, 255);
358     default_clut.clut4[3] = RGBA(127, 127, 127, 255);
359
360     default_clut.clut16[0] = RGBA(  0,   0,   0,   0);
361     for (i = 1; i < 16; i++) {
362         if (i < 8) {
363             r = (i & 1) ? 255 : 0;
364             g = (i & 2) ? 255 : 0;
365             b = (i & 4) ? 255 : 0;
366         } else {
367             r = (i & 1) ? 127 : 0;
368             g = (i & 2) ? 127 : 0;
369             b = (i & 4) ? 127 : 0;
370         }
371         default_clut.clut16[i] = RGBA(r, g, b, 255);
372     }
373
374     default_clut.clut256[0] = RGBA(  0,   0,   0,   0);
375     for (i = 1; i < 256; i++) {
376         if (i < 8) {
377             r = (i & 1) ? 255 : 0;
378             g = (i & 2) ? 255 : 0;
379             b = (i & 4) ? 255 : 0;
380             a = 63;
381         } else {
382             switch (i & 0x88) {
383             case 0x00:
384                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
385                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
386                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
387                 a = 255;
388                 break;
389             case 0x08:
390                 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
391                 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
392                 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
393                 a = 127;
394                 break;
395             case 0x80:
396                 r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
397                 g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
398                 b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
399                 a = 255;
400                 break;
401             case 0x88:
402                 r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
403                 g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
404                 b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
405                 a = 255;
406                 break;
407             }
408         }
409         default_clut.clut256[i] = RGBA(r, g, b, a);
410     }
411
412     return 0;
413 }
414
415 static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
416 {
417     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
418     DVBSubRegionDisplay *display;
419
420     delete_state(ctx);
421
422     while (ctx->display_list) {
423         display = ctx->display_list;
424         ctx->display_list = display->next;
425
426         av_free(display);
427     }
428
429     return 0;
430 }
431
432 static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
433                                    const uint8_t **srcbuf, int buf_size,
434                                    int non_mod, uint8_t *map_table)
435 {
436     GetBitContext gb;
437
438     int bits;
439     int run_length;
440     int pixels_read = 0;
441
442     init_get_bits(&gb, *srcbuf, buf_size << 8);
443
444     while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
445         bits = get_bits(&gb, 2);
446
447         if (bits) {
448             if (non_mod != 1 || bits != 1) {
449                 if (map_table)
450                     *destbuf++ = map_table[bits];
451                 else
452                     *destbuf++ = bits;
453             }
454             pixels_read++;
455         } else {
456             bits = get_bits1(&gb);
457             if (bits == 1) {
458                 run_length = get_bits(&gb, 3) + 3;
459                 bits = get_bits(&gb, 2);
460
461                 if (non_mod == 1 && bits == 1)
462                     pixels_read += run_length;
463                 else {
464                     if (map_table)
465                         bits = map_table[bits];
466                     while (run_length-- > 0 && pixels_read < dbuf_len) {
467                         *destbuf++ = bits;
468                         pixels_read++;
469                     }
470                 }
471             } else {
472                 bits = get_bits1(&gb);
473                 if (bits == 0) {
474                     bits = get_bits(&gb, 2);
475                     if (bits == 2) {
476                         run_length = get_bits(&gb, 4) + 12;
477                         bits = get_bits(&gb, 2);
478
479                         if (non_mod == 1 && bits == 1)
480                             pixels_read += run_length;
481                         else {
482                             if (map_table)
483                                 bits = map_table[bits];
484                             while (run_length-- > 0 && pixels_read < dbuf_len) {
485                                 *destbuf++ = bits;
486                                 pixels_read++;
487                             }
488                         }
489                     } else if (bits == 3) {
490                         run_length = get_bits(&gb, 8) + 29;
491                         bits = get_bits(&gb, 2);
492
493                         if (non_mod == 1 && bits == 1)
494                             pixels_read += run_length;
495                         else {
496                             if (map_table)
497                                 bits = map_table[bits];
498                             while (run_length-- > 0 && pixels_read < dbuf_len) {
499                                 *destbuf++ = bits;
500                                 pixels_read++;
501                             }
502                         }
503                     } else if (bits == 1) {
504                         pixels_read += 2;
505                         if (map_table)
506                             bits = map_table[0];
507                         else
508                             bits = 0;
509                         if (pixels_read <= dbuf_len) {
510                             *destbuf++ = bits;
511                             *destbuf++ = bits;
512                         }
513                     } else {
514                         (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
515                         return pixels_read;
516                     }
517                 } else {
518                     if (map_table)
519                         bits = map_table[0];
520                     else
521                         bits = 0;
522                     *destbuf++ = bits;
523                     pixels_read++;
524                 }
525             }
526         }
527     }
528
529     if (get_bits(&gb, 6))
530         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
531
532     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
533
534     return pixels_read;
535 }
536
537 static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
538                                    const uint8_t **srcbuf, int buf_size,
539                                    int non_mod, uint8_t *map_table)
540 {
541     GetBitContext gb;
542
543     int bits;
544     int run_length;
545     int pixels_read = 0;
546
547     init_get_bits(&gb, *srcbuf, buf_size << 8);
548
549     while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
550         bits = get_bits(&gb, 4);
551
552         if (bits) {
553             if (non_mod != 1 || bits != 1) {
554                 if (map_table)
555                     *destbuf++ = map_table[bits];
556                 else
557                     *destbuf++ = bits;
558             }
559             pixels_read++;
560         } else {
561             bits = get_bits1(&gb);
562             if (bits == 0) {
563                 run_length = get_bits(&gb, 3);
564
565                 if (run_length == 0) {
566                     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
567                     return pixels_read;
568                 }
569
570                 run_length += 2;
571
572                 if (map_table)
573                     bits = map_table[0];
574                 else
575                     bits = 0;
576
577                 while (run_length-- > 0 && pixels_read < dbuf_len) {
578                     *destbuf++ = bits;
579                     pixels_read++;
580                 }
581             } else {
582                 bits = get_bits1(&gb);
583                 if (bits == 0) {
584                     run_length = get_bits(&gb, 2) + 4;
585                     bits = get_bits(&gb, 4);
586
587                     if (non_mod == 1 && bits == 1)
588                         pixels_read += run_length;
589                     else {
590                         if (map_table)
591                             bits = map_table[bits];
592                         while (run_length-- > 0 && pixels_read < dbuf_len) {
593                             *destbuf++ = bits;
594                             pixels_read++;
595                         }
596                     }
597                 } else {
598                     bits = get_bits(&gb, 2);
599                     if (bits == 2) {
600                         run_length = get_bits(&gb, 4) + 9;
601                         bits = get_bits(&gb, 4);
602
603                         if (non_mod == 1 && bits == 1)
604                             pixels_read += run_length;
605                         else {
606                             if (map_table)
607                                 bits = map_table[bits];
608                             while (run_length-- > 0 && pixels_read < dbuf_len) {
609                                 *destbuf++ = bits;
610                                 pixels_read++;
611                             }
612                         }
613                     } else if (bits == 3) {
614                         run_length = get_bits(&gb, 8) + 25;
615                         bits = get_bits(&gb, 4);
616
617                         if (non_mod == 1 && bits == 1)
618                             pixels_read += run_length;
619                         else {
620                             if (map_table)
621                                 bits = map_table[bits];
622                             while (run_length-- > 0 && pixels_read < dbuf_len) {
623                                 *destbuf++ = bits;
624                                 pixels_read++;
625                             }
626                         }
627                     } else if (bits == 1) {
628                         pixels_read += 2;
629                         if (map_table)
630                             bits = map_table[0];
631                         else
632                             bits = 0;
633                         if (pixels_read <= dbuf_len) {
634                             *destbuf++ = bits;
635                             *destbuf++ = bits;
636                         }
637                     } else {
638                         if (map_table)
639                             bits = map_table[0];
640                         else
641                             bits = 0;
642                         *destbuf++ = bits;
643                         pixels_read ++;
644                     }
645                 }
646             }
647         }
648     }
649
650     if (get_bits(&gb, 8))
651         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
652
653     (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
654
655     return pixels_read;
656 }
657
658 static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,
659                                     const uint8_t **srcbuf, int buf_size,
660                                     int non_mod, uint8_t *map_table)
661 {
662     const uint8_t *sbuf_end = (*srcbuf) + buf_size;
663     int bits;
664     int run_length;
665     int pixels_read = 0;
666
667     while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
668         bits = *(*srcbuf)++;
669
670         if (bits) {
671             if (non_mod != 1 || bits != 1) {
672                 if (map_table)
673                     *destbuf++ = map_table[bits];
674                 else
675                     *destbuf++ = bits;
676             }
677             pixels_read++;
678         } else {
679             bits = *(*srcbuf)++;
680             run_length = bits & 0x7f;
681             if ((bits & 0x80) == 0) {
682                 if (run_length == 0) {
683                     return pixels_read;
684                 }
685
686                 if (map_table)
687                     bits = map_table[0];
688                 else
689                     bits = 0;
690                 while (run_length-- > 0 && pixels_read < dbuf_len) {
691                     *destbuf++ = bits;
692                     pixels_read++;
693                 }
694             } else {
695                 bits = *(*srcbuf)++;
696
697                 if (non_mod == 1 && bits == 1)
698                     pixels_read += run_length;
699                 if (map_table)
700                     bits = map_table[bits];
701                 else while (run_length-- > 0 && pixels_read < dbuf_len) {
702                     *destbuf++ = bits;
703                     pixels_read++;
704                 }
705             }
706         }
707     }
708
709     if (*(*srcbuf)++)
710         av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
711
712     return pixels_read;
713 }
714
715
716
717 static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
718                                           const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
719 {
720     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
721
722     DVBSubRegion *region = get_region(ctx, display->region_id);
723     const uint8_t *buf_end = buf + buf_size;
724     uint8_t *pbuf;
725     int x_pos, y_pos;
726     int i;
727
728     uint8_t map2to4[] = { 0x0,  0x7,  0x8,  0xf};
729     uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
730     uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
731                          0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
732     uint8_t *map_table;
733
734 #ifdef DEBUG
735     av_log(avctx, AV_LOG_INFO, "DVB pixel block size %d, %s field:\n", buf_size,
736                 top_bottom ? "bottom" : "top");
737 #endif
738
739 #ifdef DEBUG_PACKET_CONTENTS
740     for (i = 0; i < buf_size; i++) {
741         if (i % 16 == 0)
742             av_log(avctx, AV_LOG_INFO, "0x%08p: ", buf+i);
743
744         av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
745         if (i % 16 == 15)
746             av_log(avctx, AV_LOG_INFO, "\n");
747     }
748
749     if (i % 16)
750         av_log(avctx, AV_LOG_INFO, "\n");
751
752 #endif
753
754     if (region == 0)
755         return;
756
757     pbuf = region->pbuf;
758
759     x_pos = display->x_pos;
760     y_pos = display->y_pos;
761
762     if ((y_pos & 1) != top_bottom)
763         y_pos++;
764
765     while (buf < buf_end) {
766         if (x_pos > region->width || y_pos > region->height) {
767             av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");
768             return;
769         }
770
771         switch (*buf++) {
772         case 0x10:
773             if (region->depth == 8)
774                 map_table = map2to8;
775             else if (region->depth == 4)
776                 map_table = map2to4;
777             else
778                 map_table = NULL;
779
780             x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos,
781                                                 region->width - x_pos, &buf, buf_size,
782                                                 non_mod, map_table);
783             break;
784         case 0x11:
785             if (region->depth < 4) {
786                 av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
787                 return;
788             }
789
790             if (region->depth == 8)
791                 map_table = map4to8;
792             else
793                 map_table = NULL;
794
795             x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos,
796                                                 region->width - x_pos, &buf, buf_size,
797                                                 non_mod, map_table);
798             break;
799         case 0x12:
800             if (region->depth < 8) {
801                 av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
802                 return;
803             }
804
805             x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos,
806                                                 region->width - x_pos, &buf, buf_size,
807                                                 non_mod, NULL);
808             break;
809
810         case 0x20:
811             map2to4[0] = (*buf) >> 4;
812             map2to4[1] = (*buf++) & 0xf;
813             map2to4[2] = (*buf) >> 4;
814             map2to4[3] = (*buf++) & 0xf;
815             break;
816         case 0x21:
817             for (i = 0; i < 4; i++)
818                 map2to8[i] = *buf++;
819             break;
820         case 0x22:
821             for (i = 0; i < 16; i++)
822                 map4to8[i] = *buf++;
823             break;
824
825         case 0xf0:
826             x_pos = display->x_pos;
827             y_pos += 2;
828             break;
829         default:
830             av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
831         }
832     }
833
834 }
835
836 static void dvbsub_parse_object_segment(AVCodecContext *avctx,
837                                         const uint8_t *buf, int buf_size)
838 {
839     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
840
841     const uint8_t *buf_end = buf + buf_size;
842     const uint8_t *block;
843     int object_id;
844     DVBSubObject *object;
845     DVBSubObjectDisplay *display;
846     int top_field_len, bottom_field_len;
847
848     int coding_method, non_modifying_color;
849
850     object_id = AV_RB16(buf);
851     buf += 2;
852
853     object = get_object(ctx, object_id);
854
855     if (!object)
856         return;
857
858     coding_method = ((*buf) >> 2) & 3;
859     non_modifying_color = ((*buf++) >> 1) & 1;
860
861     if (coding_method == 0) {
862         top_field_len = AV_RB16(buf);
863         buf += 2;
864         bottom_field_len = AV_RB16(buf);
865         buf += 2;
866
867         if (buf + top_field_len + bottom_field_len > buf_end) {
868             av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");
869             return;
870         }
871
872         for (display = object->display_list; display; display = display->object_list_next) {
873             block = buf;
874
875             dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
876                                             non_modifying_color);
877
878             if (bottom_field_len > 0)
879                 block = buf + top_field_len;
880             else
881                 bottom_field_len = top_field_len;
882
883             dvbsub_parse_pixel_data_block(avctx, display, block, bottom_field_len, 1,
884                                             non_modifying_color);
885         }
886
887 /*  } else if (coding_method == 1) {*/
888
889     } else {
890         av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
891     }
892
893 }
894
895 static void dvbsub_parse_clut_segment(AVCodecContext *avctx,
896                                         const uint8_t *buf, int buf_size)
897 {
898     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
899
900     const uint8_t *buf_end = buf + buf_size;
901     int clut_id;
902     DVBSubCLUT *clut;
903     int entry_id, depth , full_range;
904     int y, cr, cb, alpha;
905     int r, g, b, r_add, g_add, b_add;
906
907 #ifdef DEBUG_PACKET_CONTENTS
908     int i;
909
910     av_log(avctx, AV_LOG_INFO, "DVB clut packet:\n");
911
912     for (i=0; i < buf_size; i++) {
913         av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
914         if (i % 16 == 15)
915             av_log(avctx, AV_LOG_INFO, "\n");
916     }
917
918     if (i % 16)
919         av_log(avctx, AV_LOG_INFO, "\n");
920
921 #endif
922
923     clut_id = *buf++;
924     buf += 1;
925
926     clut = get_clut(ctx, clut_id);
927
928     if (!clut) {
929         clut = av_malloc(sizeof(DVBSubCLUT));
930
931         memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
932
933         clut->id = clut_id;
934
935         clut->next = ctx->clut_list;
936         ctx->clut_list = clut;
937     }
938
939     while (buf + 4 < buf_end) {
940         entry_id = *buf++;
941
942         depth = (*buf) & 0xe0;
943
944         if (depth == 0) {
945             av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
946             return;
947         }
948
949         full_range = (*buf++) & 1;
950
951         if (full_range) {
952             y = *buf++;
953             cr = *buf++;
954             cb = *buf++;
955             alpha = *buf++;
956         } else {
957             y = buf[0] & 0xfc;
958             cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
959             cb = (buf[1] << 2) & 0xf0;
960             alpha = (buf[1] << 6) & 0xc0;
961
962             buf += 2;
963         }
964
965         if (y == 0)
966             alpha = 0xff;
967
968         YUV_TO_RGB1_CCIR(cb, cr);
969         YUV_TO_RGB2_CCIR(r, g, b, y);
970
971 #ifdef DEBUG
972         av_log(avctx, AV_LOG_INFO, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
973 #endif
974
975         if (depth & 0x80)
976             clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
977         if (depth & 0x40)
978             clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
979         if (depth & 0x20)
980             clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
981     }
982 }
983
984
985 static void dvbsub_parse_region_segment(AVCodecContext *avctx,
986                                         const uint8_t *buf, int buf_size)
987 {
988     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
989
990     const uint8_t *buf_end = buf + buf_size;
991     int region_id, object_id;
992     DVBSubRegion *region;
993     DVBSubObject *object;
994     DVBSubObjectDisplay *display;
995     int fill;
996
997     if (buf_size < 10)
998         return;
999
1000     region_id = *buf++;
1001
1002     region = get_region(ctx, region_id);
1003
1004     if (!region) {
1005         region = av_mallocz(sizeof(DVBSubRegion));
1006
1007         region->id = region_id;
1008
1009         region->next = ctx->region_list;
1010         ctx->region_list = region;
1011     }
1012
1013     fill = ((*buf++) >> 3) & 1;
1014
1015     region->width = AV_RB16(buf);
1016     buf += 2;
1017     region->height = AV_RB16(buf);
1018     buf += 2;
1019
1020     if (region->width * region->height != region->buf_size) {
1021         if (region->pbuf)
1022             av_free(region->pbuf);
1023
1024         region->buf_size = region->width * region->height;
1025
1026         region->pbuf = av_malloc(region->buf_size);
1027
1028         fill = 1;
1029     }
1030
1031     region->depth = 1 << (((*buf++) >> 2) & 7);
1032     if(region->depth<2 || region->depth>8){
1033         av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
1034         region->depth= 4;
1035     }
1036     region->clut = *buf++;
1037
1038     if (region->depth == 8)
1039         region->bgcolor = *buf++;
1040     else {
1041         buf += 1;
1042
1043         if (region->depth == 4)
1044             region->bgcolor = (((*buf++) >> 4) & 15);
1045         else
1046             region->bgcolor = (((*buf++) >> 2) & 3);
1047     }
1048
1049 #ifdef DEBUG
1050     av_log(avctx, AV_LOG_INFO, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1051 #endif
1052
1053     if (fill) {
1054         memset(region->pbuf, region->bgcolor, region->buf_size);
1055 #ifdef DEBUG
1056         av_log(avctx, AV_LOG_INFO, "Fill region (%d)\n", region->bgcolor);
1057 #endif
1058     }
1059
1060     delete_region_display_list(ctx, region);
1061
1062     while (buf + 5 < buf_end) {
1063         object_id = AV_RB16(buf);
1064         buf += 2;
1065
1066         object = get_object(ctx, object_id);
1067
1068         if (!object) {
1069             object = av_mallocz(sizeof(DVBSubObject));
1070
1071             object->id = object_id;
1072             object->next = ctx->object_list;
1073             ctx->object_list = object;
1074         }
1075
1076         object->type = (*buf) >> 6;
1077
1078         display = av_mallocz(sizeof(DVBSubObjectDisplay));
1079
1080         display->object_id = object_id;
1081         display->region_id = region_id;
1082
1083         display->x_pos = AV_RB16(buf) & 0xfff;
1084         buf += 2;
1085         display->y_pos = AV_RB16(buf) & 0xfff;
1086         buf += 2;
1087
1088         if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1089             display->fgcolor = *buf++;
1090             display->bgcolor = *buf++;
1091         }
1092
1093         display->region_list_next = region->display_list;
1094         region->display_list = display;
1095
1096         display->object_list_next = object->display_list;
1097         object->display_list = display;
1098     }
1099 }
1100
1101 static void dvbsub_parse_page_segment(AVCodecContext *avctx,
1102                                         const uint8_t *buf, int buf_size)
1103 {
1104     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
1105     DVBSubRegionDisplay *display;
1106     DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1107
1108     const uint8_t *buf_end = buf + buf_size;
1109     int region_id;
1110     int page_state;
1111
1112     if (buf_size < 1)
1113         return;
1114
1115     ctx->time_out = *buf++;
1116     page_state = ((*buf++) >> 2) & 3;
1117
1118 #ifdef DEBUG
1119     av_log(avctx, AV_LOG_INFO, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1120 #endif
1121
1122     if (page_state == 2) {
1123         delete_state(ctx);
1124     }
1125
1126     tmp_display_list = ctx->display_list;
1127     ctx->display_list = NULL;
1128     ctx->display_list_size = 0;
1129
1130     while (buf + 5 < buf_end) {
1131         region_id = *buf++;
1132         buf += 1;
1133
1134         display = tmp_display_list;
1135         tmp_ptr = &tmp_display_list;
1136
1137         while (display && display->region_id != region_id) {
1138             tmp_ptr = &display->next;
1139             display = display->next;
1140         }
1141
1142         if (!display)
1143             display = av_mallocz(sizeof(DVBSubRegionDisplay));
1144
1145         display->region_id = region_id;
1146
1147         display->x_pos = AV_RB16(buf);
1148         buf += 2;
1149         display->y_pos = AV_RB16(buf);
1150         buf += 2;
1151
1152         *tmp_ptr = display->next;
1153
1154         display->next = ctx->display_list;
1155         ctx->display_list = display;
1156         ctx->display_list_size++;
1157
1158 #ifdef DEBUG
1159         av_log(avctx, AV_LOG_INFO, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1160 #endif
1161     }
1162
1163     while (tmp_display_list) {
1164         display = tmp_display_list;
1165
1166         tmp_display_list = display->next;
1167
1168         av_free(display);
1169     }
1170
1171 }
1172
1173
1174 #ifdef DEBUG_SAVE_IMAGES
1175 static void save_display_set(DVBSubContext *ctx)
1176 {
1177     DVBSubRegion *region;
1178     DVBSubRegionDisplay *display;
1179     DVBSubCLUT *clut;
1180     uint32_t *clut_table;
1181     int x_pos, y_pos, width, height;
1182     int x, y, y_off, x_off;
1183     uint32_t *pbuf;
1184     char filename[32];
1185     static int fileno_index = 0;
1186
1187     x_pos = -1;
1188     y_pos = -1;
1189     width = 0;
1190     height = 0;
1191
1192     for (display = ctx->display_list; display; display = display->next) {
1193         region = get_region(ctx, display->region_id);
1194
1195         if (x_pos == -1) {
1196             x_pos = display->x_pos;
1197             y_pos = display->y_pos;
1198             width = region->width;
1199             height = region->height;
1200         } else {
1201             if (display->x_pos < x_pos) {
1202                 width += (x_pos - display->x_pos);
1203                 x_pos = display->x_pos;
1204             }
1205
1206             if (display->y_pos < y_pos) {
1207                 height += (y_pos - display->y_pos);
1208                 y_pos = display->y_pos;
1209             }
1210
1211             if (display->x_pos + region->width > x_pos + width) {
1212                 width = display->x_pos + region->width - x_pos;
1213             }
1214
1215             if (display->y_pos + region->height > y_pos + height) {
1216                 height = display->y_pos + region->height - y_pos;
1217             }
1218         }
1219     }
1220
1221     if (x_pos >= 0) {
1222
1223         pbuf = av_malloc(width * height * 4);
1224
1225         for (display = ctx->display_list; display; display = display->next) {
1226             region = get_region(ctx, display->region_id);
1227
1228             x_off = display->x_pos - x_pos;
1229             y_off = display->y_pos - y_pos;
1230
1231             clut = get_clut(ctx, region->clut);
1232
1233             if (clut == 0)
1234                 clut = &default_clut;
1235
1236             switch (region->depth) {
1237             case 2:
1238                 clut_table = clut->clut4;
1239                 break;
1240             case 8:
1241                 clut_table = clut->clut256;
1242                 break;
1243             case 4:
1244             default:
1245                 clut_table = clut->clut16;
1246                 break;
1247             }
1248
1249             for (y = 0; y < region->height; y++) {
1250                 for (x = 0; x < region->width; x++) {
1251                     pbuf[((y + y_off) * width) + x_off + x] =
1252                         clut_table[region->pbuf[y * region->width + x]];
1253                 }
1254             }
1255
1256         }
1257
1258         snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1259
1260         png_save2(filename, pbuf, width, height);
1261
1262         av_free(pbuf);
1263     }
1264
1265     fileno_index++;
1266 }
1267 #endif
1268
1269 static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
1270                                         int buf_size, AVSubtitle *sub)
1271 {
1272     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
1273
1274     DVBSubRegion *region;
1275     DVBSubRegionDisplay *display;
1276     AVSubtitleRect *rect;
1277     DVBSubCLUT *clut;
1278     uint32_t *clut_table;
1279     int i;
1280
1281     sub->rects = NULL;
1282     sub->start_display_time = 0;
1283     sub->end_display_time = ctx->time_out * 1000;
1284     sub->format = 0;
1285
1286     sub->num_rects = ctx->display_list_size;
1287
1288     if (sub->num_rects > 0)
1289         sub->rects = av_mallocz(sizeof(AVSubtitleRect) * sub->num_rects);
1290
1291     i = 0;
1292
1293     for (display = ctx->display_list; display; display = display->next) {
1294         region = get_region(ctx, display->region_id);
1295         rect = &sub->rects[i];
1296
1297         if (!region)
1298             continue;
1299
1300         rect->x = display->x_pos;
1301         rect->y = display->y_pos;
1302         rect->w = region->width;
1303         rect->h = region->height;
1304         rect->nb_colors = 16;
1305         rect->linesize = region->width;
1306
1307         clut = get_clut(ctx, region->clut);
1308
1309         if (!clut)
1310             clut = &default_clut;
1311
1312         switch (region->depth) {
1313         case 2:
1314             clut_table = clut->clut4;
1315             break;
1316         case 8:
1317             clut_table = clut->clut256;
1318             break;
1319         case 4:
1320         default:
1321             clut_table = clut->clut16;
1322             break;
1323         }
1324
1325         rect->rgba_palette = av_malloc((1 << region->depth) * sizeof(uint32_t));
1326         memcpy(rect->rgba_palette, clut_table, (1 << region->depth) * sizeof(uint32_t));
1327
1328         rect->bitmap = av_malloc(region->buf_size);
1329         memcpy(rect->bitmap, region->pbuf, region->buf_size);
1330
1331         i++;
1332     }
1333
1334     sub->num_rects = i;
1335
1336 #ifdef DEBUG_SAVE_IMAGES
1337     save_display_set(ctx);
1338 #endif
1339
1340     return 1;
1341 }
1342
1343 static int dvbsub_decode(AVCodecContext *avctx,
1344                          void *data, int *data_size,
1345                          const uint8_t *buf, int buf_size)
1346 {
1347     DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
1348     AVSubtitle *sub = (AVSubtitle*) data;
1349     const uint8_t *p, *p_end;
1350     int segment_type;
1351     int page_id;
1352     int segment_length;
1353
1354 #ifdef DEBUG_PACKET_CONTENTS
1355     int i;
1356
1357     av_log(avctx, AV_LOG_INFO, "DVB sub packet:\n");
1358
1359     for (i=0; i < buf_size; i++) {
1360         av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
1361         if (i % 16 == 15)
1362             av_log(avctx, AV_LOG_INFO, "\n");
1363     }
1364
1365     if (i % 16)
1366         av_log(avctx, AV_LOG_INFO, "\n");
1367
1368 #endif
1369
1370     if (buf_size <= 2)
1371         return -1;
1372
1373     p = buf;
1374     p_end = buf + buf_size;
1375
1376     while (p < p_end && *p == 0x0f) {
1377         p += 1;
1378         segment_type = *p++;
1379         page_id = AV_RB16(p);
1380         p += 2;
1381         segment_length = AV_RB16(p);
1382         p += 2;
1383
1384         if (page_id == ctx->composition_id || page_id == ctx->ancillary_id) {
1385             switch (segment_type) {
1386             case DVBSUB_PAGE_SEGMENT:
1387                 dvbsub_parse_page_segment(avctx, p, segment_length);
1388                 break;
1389             case DVBSUB_REGION_SEGMENT:
1390                 dvbsub_parse_region_segment(avctx, p, segment_length);
1391                 break;
1392             case DVBSUB_CLUT_SEGMENT:
1393                 dvbsub_parse_clut_segment(avctx, p, segment_length);
1394                 break;
1395             case DVBSUB_OBJECT_SEGMENT:
1396                 dvbsub_parse_object_segment(avctx, p, segment_length);
1397                 break;
1398             case DVBSUB_DISPLAY_SEGMENT:
1399                 *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);
1400                 break;
1401             default:
1402 #ifdef DEBUG
1403                 av_log(avctx, AV_LOG_INFO, "Subtitling segment type 0x%x, page id %d, length %d\n",
1404                         segment_type, page_id, segment_length);
1405 #endif
1406                 break;
1407             }
1408         }
1409
1410         p += segment_length;
1411     }
1412
1413     if (p != p_end) {
1414 #ifdef DEBUG
1415         av_log(avctx, AV_LOG_INFO, "Junk at end of packet\n");
1416 #endif
1417         return -1;
1418     }
1419
1420     return buf_size;
1421 }
1422
1423
1424 AVCodec dvbsub_decoder = {
1425     "dvbsub",
1426     CODEC_TYPE_SUBTITLE,
1427     CODEC_ID_DVB_SUBTITLE,
1428     sizeof(DVBSubContext),
1429     dvbsub_init_decoder,
1430     NULL,
1431     dvbsub_close_decoder,
1432     dvbsub_decode,
1433     .long_name = "DVB subtitles",
1434 };