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 41static 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 98static 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 156typedef 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 166static DVBSubCLUT default_clut; 167 168typedef 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 182typedef struct DVBSubObject { 183 int id; 184 185 int type; 186 187 DVBSubObjectDisplay *display_list; 188 189 struct DVBSubObject *next; 190} DVBSubObject; 191 192typedef struct DVBSubRegionDisplay { 193 int region_id; 194 195 int x_pos; 196 int y_pos; 197 198 struct DVBSubRegionDisplay *next; 199} DVBSubRegionDisplay; 200 201typedef 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 219typedef 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 233static 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 244static 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 255static 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 266static 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 312static 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 342static 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 415static 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 432static 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 537static 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 658static 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 717static 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 dprintf(avctx, "DVB pixel block size %d, %s field:\n", buf_size, 735 top_bottom ? "bottom" : "top"); 736 737#ifdef DEBUG_PACKET_CONTENTS 738 for (i = 0; i < buf_size; i++) { 739 if (i % 16 == 0) 740 av_log(avctx, AV_LOG_INFO, "0x%08p: ", buf+i); 741 742 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]); 743 if (i % 16 == 15) 744 av_log(avctx, AV_LOG_INFO, "\n"); 745 } 746 747 if (i % 16) 748 av_log(avctx, AV_LOG_INFO, "\n"); 749 750#endif 751 752 if (region == 0) 753 return; 754 755 pbuf = region->pbuf; 756 757 x_pos = display->x_pos; 758 y_pos = display->y_pos; 759 760 if ((y_pos & 1) != top_bottom) 761 y_pos++; 762 763 while (buf < buf_end) { 764 if (x_pos > region->width || y_pos > region->height) { 765 av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n"); 766 return; 767 } 768 769 switch (*buf++) { 770 case 0x10: 771 if (region->depth == 8) 772 map_table = map2to8; 773 else if (region->depth == 4) 774 map_table = map2to4; 775 else 776 map_table = NULL; 777 778 x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos, 779 region->width - x_pos, &buf, buf_size, 780 non_mod, map_table); 781 break; 782 case 0x11: 783 if (region->depth < 4) { 784 av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth); 785 return; 786 } 787 788 if (region->depth == 8) 789 map_table = map4to8; 790 else 791 map_table = NULL; 792 793 x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos, 794 region->width - x_pos, &buf, buf_size, 795 non_mod, map_table); 796 break; 797 case 0x12: 798 if (region->depth < 8) { 799 av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth); 800 return; 801 } 802 803 x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos, 804 region->width - x_pos, &buf, buf_size, 805 non_mod, NULL); 806 break; 807 808 case 0x20: 809 map2to4[0] = (*buf) >> 4; 810 map2to4[1] = (*buf++) & 0xf; 811 map2to4[2] = (*buf) >> 4; 812 map2to4[3] = (*buf++) & 0xf; 813 break; 814 case 0x21: 815 for (i = 0; i < 4; i++) 816 map2to8[i] = *buf++; 817 break; 818 case 0x22: 819 for (i = 0; i < 16; i++) 820 map4to8[i] = *buf++; 821 break; 822 823 case 0xf0: 824 x_pos = display->x_pos; 825 y_pos += 2; 826 break; 827 default: 828 av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1)); 829 } 830 } 831 832} 833 834static void dvbsub_parse_object_segment(AVCodecContext *avctx, 835 const uint8_t *buf, int buf_size) 836{ 837 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; 838 839 const uint8_t *buf_end = buf + buf_size; 840 const uint8_t *block; 841 int object_id; 842 DVBSubObject *object; 843 DVBSubObjectDisplay *display; 844 int top_field_len, bottom_field_len; 845 846 int coding_method, non_modifying_color; 847 848 object_id = AV_RB16(buf); 849 buf += 2; 850 851 object = get_object(ctx, object_id); 852 853 if (!object) 854 return; 855 856 coding_method = ((*buf) >> 2) & 3; 857 non_modifying_color = ((*buf++) >> 1) & 1; 858 859 if (coding_method == 0) { 860 top_field_len = AV_RB16(buf); 861 buf += 2; 862 bottom_field_len = AV_RB16(buf); 863 buf += 2; 864 865 if (buf + top_field_len + bottom_field_len > buf_end) { 866 av_log(avctx, AV_LOG_ERROR, "Field data size too large\n"); 867 return; 868 } 869 870 for (display = object->display_list; display; display = display->object_list_next) { 871 block = buf; 872 873 dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0, 874 non_modifying_color); 875 876 if (bottom_field_len > 0) 877 block = buf + top_field_len; 878 else 879 bottom_field_len = top_field_len; 880 881 dvbsub_parse_pixel_data_block(avctx, display, block, bottom_field_len, 1, 882 non_modifying_color); 883 } 884 885/* } else if (coding_method == 1) {*/ 886 887 } else { 888 av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method); 889 } 890 891} 892 893static void dvbsub_parse_clut_segment(AVCodecContext *avctx, 894 const uint8_t *buf, int buf_size) 895{ 896 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; 897 898 const uint8_t *buf_end = buf + buf_size; 899 int clut_id; 900 DVBSubCLUT *clut; 901 int entry_id, depth , full_range; 902 int y, cr, cb, alpha; 903 int r, g, b, r_add, g_add, b_add; 904 905#ifdef DEBUG_PACKET_CONTENTS 906 int i; 907 908 av_log(avctx, AV_LOG_INFO, "DVB clut packet:\n"); 909 910 for (i=0; i < buf_size; i++) { 911 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]); 912 if (i % 16 == 15) 913 av_log(avctx, AV_LOG_INFO, "\n"); 914 } 915 916 if (i % 16) 917 av_log(avctx, AV_LOG_INFO, "\n"); 918 919#endif 920 921 clut_id = *buf++; 922 buf += 1; 923 924 clut = get_clut(ctx, clut_id); 925 926 if (!clut) { 927 clut = av_malloc(sizeof(DVBSubCLUT)); 928 929 memcpy(clut, &default_clut, sizeof(DVBSubCLUT)); 930 931 clut->id = clut_id; 932 933 clut->next = ctx->clut_list; 934 ctx->clut_list = clut; 935 } 936 937 while (buf + 4 < buf_end) { 938 entry_id = *buf++; 939 940 depth = (*buf) & 0xe0; 941 942 if (depth == 0) { 943 av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf); 944 return; 945 } 946 947 full_range = (*buf++) & 1; 948 949 if (full_range) { 950 y = *buf++; 951 cr = *buf++; 952 cb = *buf++; 953 alpha = *buf++; 954 } else { 955 y = buf[0] & 0xfc; 956 cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4; 957 cb = (buf[1] << 2) & 0xf0; 958 alpha = (buf[1] << 6) & 0xc0; 959 960 buf += 2; 961 } 962 963 if (y == 0) 964 alpha = 0xff; 965 966 YUV_TO_RGB1_CCIR(cb, cr); 967 YUV_TO_RGB2_CCIR(r, g, b, y); 968 969 dprintf(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha); 970 971 if (depth & 0x80) 972 clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha); 973 if (depth & 0x40) 974 clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha); 975 if (depth & 0x20) 976 clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha); 977 } 978} 979 980 981static void dvbsub_parse_region_segment(AVCodecContext *avctx, 982 const uint8_t *buf, int buf_size) 983{ 984 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; 985 986 const uint8_t *buf_end = buf + buf_size; 987 int region_id, object_id; 988 DVBSubRegion *region; 989 DVBSubObject *object; 990 DVBSubObjectDisplay *display; 991 int fill; 992 993 if (buf_size < 10) 994 return; 995 996 region_id = *buf++; 997 998 region = get_region(ctx, region_id); 999 1000 if (!region) { 1001 region = av_mallocz(sizeof(DVBSubRegion)); 1002 1003 region->id = region_id; 1004 1005 region->next = ctx->region_list; 1006 ctx->region_list = region; 1007 } 1008 1009 fill = ((*buf++) >> 3) & 1; 1010 1011 region->width = AV_RB16(buf); 1012 buf += 2; 1013 region->height = AV_RB16(buf); 1014 buf += 2; 1015 1016 if (region->width * region->height != region->buf_size) { 1017 if (region->pbuf) 1018 av_free(region->pbuf); 1019 1020 region->buf_size = region->width * region->height; 1021 1022 region->pbuf = av_malloc(region->buf_size); 1023 1024 fill = 1; 1025 } 1026 1027 region->depth = 1 << (((*buf++) >> 2) & 7); 1028 if(region->depth<2 || region->depth>8){ 1029 av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth); 1030 region->depth= 4; 1031 } 1032 region->clut = *buf++; 1033 1034 if (region->depth == 8) 1035 region->bgcolor = *buf++; 1036 else { 1037 buf += 1; 1038 1039 if (region->depth == 4) 1040 region->bgcolor = (((*buf++) >> 4) & 15); 1041 else 1042 region->bgcolor = (((*buf++) >> 2) & 3); 1043 } 1044 1045 dprintf(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height); 1046 1047 if (fill) { 1048 memset(region->pbuf, region->bgcolor, region->buf_size); 1049 dprintf(avctx, "Fill region (%d)\n", region->bgcolor); 1050 } 1051 1052 delete_region_display_list(ctx, region); 1053 1054 while (buf + 5 < buf_end) { 1055 object_id = AV_RB16(buf); 1056 buf += 2; 1057 1058 object = get_object(ctx, object_id); 1059 1060 if (!object) { 1061 object = av_mallocz(sizeof(DVBSubObject)); 1062 1063 object->id = object_id; 1064 object->next = ctx->object_list; 1065 ctx->object_list = object; 1066 } 1067 1068 object->type = (*buf) >> 6; 1069 1070 display = av_mallocz(sizeof(DVBSubObjectDisplay)); 1071 1072 display->object_id = object_id; 1073 display->region_id = region_id; 1074 1075 display->x_pos = AV_RB16(buf) & 0xfff; 1076 buf += 2; 1077 display->y_pos = AV_RB16(buf) & 0xfff; 1078 buf += 2; 1079 1080 if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) { 1081 display->fgcolor = *buf++; 1082 display->bgcolor = *buf++; 1083 } 1084 1085 display->region_list_next = region->display_list; 1086 region->display_list = display; 1087 1088 display->object_list_next = object->display_list; 1089 object->display_list = display; 1090 } 1091} 1092 1093static void dvbsub_parse_page_segment(AVCodecContext *avctx, 1094 const uint8_t *buf, int buf_size) 1095{ 1096 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; 1097 DVBSubRegionDisplay *display; 1098 DVBSubRegionDisplay *tmp_display_list, **tmp_ptr; 1099 1100 const uint8_t *buf_end = buf + buf_size; 1101 int region_id; 1102 int page_state; 1103 1104 if (buf_size < 1) 1105 return; 1106 1107 ctx->time_out = *buf++; 1108 page_state = ((*buf++) >> 2) & 3; 1109 1110 dprintf(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state); 1111 1112 if (page_state == 2) { 1113 delete_state(ctx); 1114 } 1115 1116 tmp_display_list = ctx->display_list; 1117 ctx->display_list = NULL; 1118 ctx->display_list_size = 0; 1119 1120 while (buf + 5 < buf_end) { 1121 region_id = *buf++; 1122 buf += 1; 1123 1124 display = tmp_display_list; 1125 tmp_ptr = &tmp_display_list; 1126 1127 while (display && display->region_id != region_id) { 1128 tmp_ptr = &display->next; 1129 display = display->next; 1130 } 1131 1132 if (!display) 1133 display = av_mallocz(sizeof(DVBSubRegionDisplay)); 1134 1135 display->region_id = region_id; 1136 1137 display->x_pos = AV_RB16(buf); 1138 buf += 2; 1139 display->y_pos = AV_RB16(buf); 1140 buf += 2; 1141 1142 *tmp_ptr = display->next; 1143 1144 display->next = ctx->display_list; 1145 ctx->display_list = display; 1146 ctx->display_list_size++; 1147 1148 dprintf(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos); 1149 } 1150 1151 while (tmp_display_list) { 1152 display = tmp_display_list; 1153 1154 tmp_display_list = display->next; 1155 1156 av_free(display); 1157 } 1158 1159} 1160 1161 1162#ifdef DEBUG_SAVE_IMAGES 1163static void save_display_set(DVBSubContext *ctx) 1164{ 1165 DVBSubRegion *region; 1166 DVBSubRegionDisplay *display; 1167 DVBSubCLUT *clut; 1168 uint32_t *clut_table; 1169 int x_pos, y_pos, width, height; 1170 int x, y, y_off, x_off; 1171 uint32_t *pbuf; 1172 char filename[32]; 1173 static int fileno_index = 0; 1174 1175 x_pos = -1; 1176 y_pos = -1; 1177 width = 0; 1178 height = 0; 1179 1180 for (display = ctx->display_list; display; display = display->next) { 1181 region = get_region(ctx, display->region_id); 1182 1183 if (x_pos == -1) { 1184 x_pos = display->x_pos; 1185 y_pos = display->y_pos; 1186 width = region->width; 1187 height = region->height; 1188 } else { 1189 if (display->x_pos < x_pos) { 1190 width += (x_pos - display->x_pos); 1191 x_pos = display->x_pos; 1192 } 1193 1194 if (display->y_pos < y_pos) { 1195 height += (y_pos - display->y_pos); 1196 y_pos = display->y_pos; 1197 } 1198 1199 if (display->x_pos + region->width > x_pos + width) { 1200 width = display->x_pos + region->width - x_pos; 1201 } 1202 1203 if (display->y_pos + region->height > y_pos + height) { 1204 height = display->y_pos + region->height - y_pos; 1205 } 1206 } 1207 } 1208 1209 if (x_pos >= 0) { 1210 1211 pbuf = av_malloc(width * height * 4); 1212 1213 for (display = ctx->display_list; display; display = display->next) { 1214 region = get_region(ctx, display->region_id); 1215 1216 x_off = display->x_pos - x_pos; 1217 y_off = display->y_pos - y_pos; 1218 1219 clut = get_clut(ctx, region->clut); 1220 1221 if (clut == 0) 1222 clut = &default_clut; 1223 1224 switch (region->depth) { 1225 case 2: 1226 clut_table = clut->clut4; 1227 break; 1228 case 8: 1229 clut_table = clut->clut256; 1230 break; 1231 case 4: 1232 default: 1233 clut_table = clut->clut16; 1234 break; 1235 } 1236 1237 for (y = 0; y < region->height; y++) { 1238 for (x = 0; x < region->width; x++) { 1239 pbuf[((y + y_off) * width) + x_off + x] = 1240 clut_table[region->pbuf[y * region->width + x]]; 1241 } 1242 } 1243 1244 } 1245 1246 snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index); 1247 1248 png_save2(filename, pbuf, width, height); 1249 1250 av_free(pbuf); 1251 } 1252 1253 fileno_index++; 1254} 1255#endif 1256 1257static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf, 1258 int buf_size, AVSubtitle *sub) 1259{ 1260 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; 1261 1262 DVBSubRegion *region; 1263 DVBSubRegionDisplay *display; 1264 AVSubtitleRect *rect; 1265 DVBSubCLUT *clut; 1266 uint32_t *clut_table; 1267 int i; 1268 1269 sub->rects = NULL; 1270 sub->start_display_time = 0; 1271 sub->end_display_time = ctx->time_out * 1000; 1272 sub->format = 0; 1273 1274 sub->num_rects = ctx->display_list_size; 1275 1276 if (sub->num_rects > 0){ 1277 sub->rects = av_mallocz(sizeof(*sub->rects) * sub->num_rects); 1278 for(i=0; i<sub->num_rects; i++) 1279 sub->rects[i] = av_mallocz(sizeof(*sub->rects[i])); 1280 } 1281 1282 i = 0; 1283 1284 for (display = ctx->display_list; display; display = display->next) { 1285 region = get_region(ctx, display->region_id); 1286 rect = sub->rects[i]; 1287 1288 if (!region) 1289 continue; 1290 1291 rect->x = display->x_pos; 1292 rect->y = display->y_pos; 1293 rect->w = region->width; 1294 rect->h = region->height; 1295 rect->nb_colors = 16; 1296 rect->type = SUBTITLE_BITMAP; 1297 rect->pict.linesize[0] = region->width; 1298 1299 clut = get_clut(ctx, region->clut); 1300 1301 if (!clut) 1302 clut = &default_clut; 1303 1304 switch (region->depth) { 1305 case 2: 1306 clut_table = clut->clut4; 1307 break; 1308 case 8: 1309 clut_table = clut->clut256; 1310 break; 1311 case 4: 1312 default: 1313 clut_table = clut->clut16; 1314 break; 1315 } 1316 1317 rect->pict.data[1] = av_mallocz(AVPALETTE_SIZE); 1318 memcpy(rect->pict.data[1], clut_table, (1 << region->depth) * sizeof(uint32_t)); 1319 1320 rect->pict.data[0] = av_malloc(region->buf_size); 1321 memcpy(rect->pict.data[0], region->pbuf, region->buf_size); 1322 1323 i++; 1324 } 1325 1326 sub->num_rects = i; 1327 1328#ifdef DEBUG_SAVE_IMAGES 1329 save_display_set(ctx); 1330#endif 1331 1332 return 1; 1333} 1334 1335static int dvbsub_decode(AVCodecContext *avctx, 1336 void *data, int *data_size, 1337 AVPacket *avpkt) 1338{ 1339 const uint8_t *buf = avpkt->data; 1340 int buf_size = avpkt->size; 1341 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; 1342 AVSubtitle *sub = (AVSubtitle*) data; 1343 const uint8_t *p, *p_end; 1344 int segment_type; 1345 int page_id; 1346 int segment_length; 1347 1348#ifdef DEBUG_PACKET_CONTENTS 1349 int i; 1350 1351 av_log(avctx, AV_LOG_INFO, "DVB sub packet:\n"); 1352 1353 for (i=0; i < buf_size; i++) { 1354 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]); 1355 if (i % 16 == 15) 1356 av_log(avctx, AV_LOG_INFO, "\n"); 1357 } 1358 1359 if (i % 16) 1360 av_log(avctx, AV_LOG_INFO, "\n"); 1361 1362#endif 1363 1364 if (buf_size <= 2) 1365 return -1; 1366 1367 p = buf; 1368 p_end = buf + buf_size; 1369 1370 while (p < p_end && *p == 0x0f) { 1371 p += 1; 1372 segment_type = *p++; 1373 page_id = AV_RB16(p); 1374 p += 2; 1375 segment_length = AV_RB16(p); 1376 p += 2; 1377 1378 if (page_id == ctx->composition_id || page_id == ctx->ancillary_id) { 1379 switch (segment_type) { 1380 case DVBSUB_PAGE_SEGMENT: 1381 dvbsub_parse_page_segment(avctx, p, segment_length); 1382 break; 1383 case DVBSUB_REGION_SEGMENT: 1384 dvbsub_parse_region_segment(avctx, p, segment_length); 1385 break; 1386 case DVBSUB_CLUT_SEGMENT: 1387 dvbsub_parse_clut_segment(avctx, p, segment_length); 1388 break; 1389 case DVBSUB_OBJECT_SEGMENT: 1390 dvbsub_parse_object_segment(avctx, p, segment_length); 1391 break; 1392 case DVBSUB_DISPLAY_SEGMENT: 1393 *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub); 1394 break; 1395 default: 1396 dprintf(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n", 1397 segment_type, page_id, segment_length); 1398 break; 1399 } 1400 } 1401 1402 p += segment_length; 1403 } 1404 1405 if (p != p_end) { 1406 dprintf(avctx, "Junk at end of packet\n"); 1407 return -1; 1408 } 1409 1410 return buf_size; 1411} 1412 1413 1414AVCodec dvbsub_decoder = { 1415 "dvbsub", 1416 AVMEDIA_TYPE_SUBTITLE, 1417 CODEC_ID_DVB_SUBTITLE, 1418 sizeof(DVBSubContext), 1419 dvbsub_init_decoder, 1420 NULL, 1421 dvbsub_close_decoder, 1422 dvbsub_decode, 1423 .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"), 1424}; 1425