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 "bitstream.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 << 8); 443 444 while (get_bits_count(&gb) < (buf_size << 8) && 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 << 8); 548 549 while (get_bits_count(&gb) < (buf_size << 8) && 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#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 836static 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 895static 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 985static 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 1101static 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 1175static 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 1269static 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->pict.linesize[0] = region->width; 1309 1310 clut = get_clut(ctx, region->clut); 1311 1312 if (!clut) 1313 clut = &default_clut; 1314 1315 switch (region->depth) { 1316 case 2: 1317 clut_table = clut->clut4; 1318 break; 1319 case 8: 1320 clut_table = clut->clut256; 1321 break; 1322 case 4: 1323 default: 1324 clut_table = clut->clut16; 1325 break; 1326 } 1327 1328 rect->pict.data[1] = av_malloc((1 << region->depth) * sizeof(uint32_t)); 1329 memcpy(rect->pict.data[1], clut_table, (1 << region->depth) * sizeof(uint32_t)); 1330 1331 rect->pict.data[0] = av_malloc(region->buf_size); 1332 memcpy(rect->pict.data[0], region->pbuf, region->buf_size); 1333 1334 i++; 1335 } 1336 1337 sub->num_rects = i; 1338 1339#ifdef DEBUG_SAVE_IMAGES 1340 save_display_set(ctx); 1341#endif 1342 1343 return 1; 1344} 1345 1346static int dvbsub_decode(AVCodecContext *avctx, 1347 void *data, int *data_size, 1348 const uint8_t *buf, int buf_size) 1349{ 1350 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; 1351 AVSubtitle *sub = (AVSubtitle*) data; 1352 const uint8_t *p, *p_end; 1353 int segment_type; 1354 int page_id; 1355 int segment_length; 1356 1357#ifdef DEBUG_PACKET_CONTENTS 1358 int i; 1359 1360 av_log(avctx, AV_LOG_INFO, "DVB sub packet:\n"); 1361 1362 for (i=0; i < buf_size; i++) { 1363 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]); 1364 if (i % 16 == 15) 1365 av_log(avctx, AV_LOG_INFO, "\n"); 1366 } 1367 1368 if (i % 16) 1369 av_log(avctx, AV_LOG_INFO, "\n"); 1370 1371#endif 1372 1373 if (buf_size <= 2) 1374 return -1; 1375 1376 p = buf; 1377 p_end = buf + buf_size; 1378 1379 while (p < p_end && *p == 0x0f) { 1380 p += 1; 1381 segment_type = *p++; 1382 page_id = AV_RB16(p); 1383 p += 2; 1384 segment_length = AV_RB16(p); 1385 p += 2; 1386 1387 if (page_id == ctx->composition_id || page_id == ctx->ancillary_id) { 1388 switch (segment_type) { 1389 case DVBSUB_PAGE_SEGMENT: 1390 dvbsub_parse_page_segment(avctx, p, segment_length); 1391 break; 1392 case DVBSUB_REGION_SEGMENT: 1393 dvbsub_parse_region_segment(avctx, p, segment_length); 1394 break; 1395 case DVBSUB_CLUT_SEGMENT: 1396 dvbsub_parse_clut_segment(avctx, p, segment_length); 1397 break; 1398 case DVBSUB_OBJECT_SEGMENT: 1399 dvbsub_parse_object_segment(avctx, p, segment_length); 1400 break; 1401 case DVBSUB_DISPLAY_SEGMENT: 1402 *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub); 1403 break; 1404 default: 1405#ifdef DEBUG 1406 av_log(avctx, AV_LOG_INFO, "Subtitling segment type 0x%x, page id %d, length %d\n", 1407 segment_type, page_id, segment_length); 1408#endif 1409 break; 1410 } 1411 } 1412 1413 p += segment_length; 1414 } 1415 1416 if (p != p_end) { 1417#ifdef DEBUG 1418 av_log(avctx, AV_LOG_INFO, "Junk at end of packet\n"); 1419#endif 1420 return -1; 1421 } 1422 1423 return buf_size; 1424} 1425 1426 1427AVCodec dvbsub_decoder = { 1428 "dvbsub", 1429 CODEC_TYPE_SUBTITLE, 1430 CODEC_ID_DVB_SUBTITLE, 1431 sizeof(DVBSubContext), 1432 dvbsub_init_decoder, 1433 NULL, 1434 dvbsub_close_decoder, 1435 dvbsub_decode, 1436 .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"), 1437}; 1438