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