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