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