libavcodec/dvbsubdec.c

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