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