git.sesse.net Git - ffmpeg/blob - libavcodec/dvbsubdec.c

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