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