dvbsubdec.c 38.3 KB
Newer Older
1 2 3 4
/*
 * DVB subtitle decoding for ffmpeg
 * Copyright (c) 2005 Ian Caulfield.
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * 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 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 21 22 23
 */
#include "avcodec.h"
#include "dsputil.h"
#include "bitstream.h"
24
#include "colorspace.h"
25 26 27 28 29 30 31 32 33 34 35

//#define DEBUG
//#define DEBUG_PACKET_CONTENTS
//#define DEBUG_SAVE_IMAGES

#define DVBSUB_PAGE_SEGMENT     0x10
#define DVBSUB_REGION_SEGMENT   0x11
#define DVBSUB_CLUT_SEGMENT     0x12
#define DVBSUB_OBJECT_SEGMENT   0x13
#define DVBSUB_DISPLAY_SEGMENT  0x80

michael's avatar
michael committed
36
#define cm (ff_cropTbl + MAX_NEG_CROP)
37 38 39 40 41 42 43 44 45 46 47

#ifdef DEBUG_SAVE_IMAGES
#undef fprintf
#if 0
static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
                     uint32_t *rgba_palette)
{
    int x, y, v;
    FILE *f;
    char fname[40], fname2[40];
    char command[1024];
48

49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
    snprintf(fname, 40, "%s.ppm", filename);

    f = fopen(fname, "w");
    if (!f) {
        perror(fname);
        exit(1);
    }
    fprintf(f, "P6\n"
            "%d %d\n"
            "%d\n",
            w, h, 255);
    for(y = 0; y < h; y++) {
        for(x = 0; x < w; x++) {
            v = rgba_palette[bitmap[y * w + x]];
            putc((v >> 16) & 0xff, f);
            putc((v >> 8) & 0xff, f);
            putc((v >> 0) & 0xff, f);
        }
    }
    fclose(f);
69 70


71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
    snprintf(fname2, 40, "%s-a.pgm", filename);

    f = fopen(fname2, "w");
    if (!f) {
        perror(fname2);
        exit(1);
    }
    fprintf(f, "P5\n"
            "%d %d\n"
            "%d\n",
            w, h, 255);
    for(y = 0; y < h; y++) {
        for(x = 0; x < w; x++) {
            v = rgba_palette[bitmap[y * w + x]];
            putc((v >> 24) & 0xff, f);
        }
    }
    fclose(f);
89

90 91
    snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
    system(command);
92

93 94 95 96 97 98 99 100 101 102 103
    snprintf(command, 1024, "rm %s %s", fname, fname2);
    system(command);
}
#endif

static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)
{
    int x, y, v;
    FILE *f;
    char fname[40], fname2[40];
    char command[1024];
104

105
    snprintf(fname, sizeof(fname), "%s.ppm", filename);
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124

    f = fopen(fname, "w");
    if (!f) {
        perror(fname);
        exit(1);
    }
    fprintf(f, "P6\n"
            "%d %d\n"
            "%d\n",
            w, h, 255);
    for(y = 0; y < h; y++) {
        for(x = 0; x < w; x++) {
            v = bitmap[y * w + x];
            putc((v >> 16) & 0xff, f);
            putc((v >> 8) & 0xff, f);
            putc((v >> 0) & 0xff, f);
        }
    }
    fclose(f);
125 126


127
    snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144

    f = fopen(fname2, "w");
    if (!f) {
        perror(fname2);
        exit(1);
    }
    fprintf(f, "P5\n"
            "%d %d\n"
            "%d\n",
            w, h, 255);
    for(y = 0; y < h; y++) {
        for(x = 0; x < w; x++) {
            v = bitmap[y * w + x];
            putc((v >> 24) & 0xff, f);
        }
    }
    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 151 152 153 154 155 156 157 158 159 160 161
    system(command);
}
#endif

#define RGBA(r,g,b,a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))

typedef struct DVBSubCLUT {
    int id;

    uint32_t clut4[4];
    uint32_t clut16[16];
    uint32_t clut256[256];
162

163 164 165 166 167 168 169 170 171 172 173 174
    struct DVBSubCLUT *next;
} DVBSubCLUT;

static DVBSubCLUT default_clut;

typedef struct DVBSubObjectDisplay {
    int object_id;
    int region_id;

    int x_pos;
    int y_pos;

diego's avatar
diego committed
175 176
    int fgcolor;
    int bgcolor;
177

178
    struct DVBSubObjectDisplay *region_list_next;
179
    struct DVBSubObjectDisplay *object_list_next;
180 181 182 183 184 185
} DVBSubObjectDisplay;

typedef struct DVBSubObject {
    int id;

    int type;
186 187 188

    DVBSubObjectDisplay *display_list;

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
    struct DVBSubObject *next;
} DVBSubObject;

typedef struct DVBSubRegionDisplay {
    int region_id;

    int x_pos;
    int y_pos;

    struct DVBSubRegionDisplay *next;
} DVBSubRegionDisplay;

typedef struct DVBSubRegion {
    int id;

    int width;
    int height;
    int depth;
207

208
    int clut;
diego's avatar
diego committed
209
    int bgcolor;
210

211 212 213 214
    uint8_t *pbuf;
    int buf_size;

    DVBSubObjectDisplay *display_list;
215

216 217 218 219 220 221 222 223 224 225 226
    struct DVBSubRegion *next;
} DVBSubRegion;

typedef struct DVBSubContext {
    int composition_id;
    int ancillary_id;

    int time_out;
    DVBSubRegion *region_list;
    DVBSubCLUT   *clut_list;
    DVBSubObject *object_list;
227

228 229 230 231 232 233 234 235 236
    int display_list_size;
    DVBSubRegionDisplay *display_list;
} DVBSubContext;


static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
{
    DVBSubObject *ptr = ctx->object_list;

michael's avatar
michael committed
237
    while (ptr && ptr->id != object_id) {
238 239
        ptr = ptr->next;
    }
240

241 242 243 244 245 246 247
    return ptr;
}

static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
{
    DVBSubCLUT *ptr = ctx->clut_list;

michael's avatar
michael committed
248
    while (ptr && ptr->id != clut_id) {
249 250
        ptr = ptr->next;
    }
251

252 253 254 255 256 257 258
    return ptr;
}

static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
{
    DVBSubRegion *ptr = ctx->region_list;

michael's avatar
michael committed
259
    while (ptr && ptr->id != region_id) {
260 261
        ptr = ptr->next;
    }
262

263 264 265 266 267 268 269 270
    return ptr;
}

static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
{
    DVBSubObject *object, *obj2, **obj2_ptr;
    DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;

michael's avatar
michael committed
271
    while (region->display_list) {
272
        display = region->display_list;
273

274
        object = get_object(ctx, display->object_id);
275

michael's avatar
michael committed
276
        if (object) {
277
            obj_disp_ptr = &object->display_list;
michael's avatar
michael committed
278
            obj_disp = *obj_disp_ptr;
279

michael's avatar
michael committed
280
            while (obj_disp && obj_disp != display) {
281
                obj_disp_ptr = &obj_disp->object_list_next;
michael's avatar
michael committed
282
                obj_disp = *obj_disp_ptr;
283
            }
284

285 286
            if (obj_disp) {
                *obj_disp_ptr = obj_disp->object_list_next;
287

michael's avatar
michael committed
288
                if (!object->display_list) {
289
                    obj2_ptr = &ctx->object_list;
michael's avatar
michael committed
290
                    obj2 = *obj2_ptr;
291

michael's avatar
michael committed
292 293
                    while (obj2 != object) {
                        assert(obj2);
294
                        obj2_ptr = &obj2->next;
michael's avatar
michael committed
295
                        obj2 = *obj2_ptr;
296
                    }
297

298
                    *obj2_ptr = obj2->next;
299

300 301 302 303
                    av_free(obj2);
                }
            }
        }
304

305
        region->display_list = display->region_list_next;
306

307 308
        av_free(display);
    }
309

310 311 312 313 314 315
}

static void delete_state(DVBSubContext *ctx)
{
    DVBSubRegion *region;
    DVBSubCLUT *clut;
316

michael's avatar
michael committed
317
    while (ctx->region_list) {
318 319 320 321 322
        region = ctx->region_list;

        ctx->region_list = region->next;

        delete_region_display_list(ctx, region);
michael's avatar
michael committed
323
        if (region->pbuf)
324 325 326 327 328
            av_free(region->pbuf);

        av_free(region);
    }

michael's avatar
michael committed
329
    while (ctx->clut_list) {
330 331 332 333 334 335 336 337
        clut = ctx->clut_list;

        ctx->clut_list = clut->next;

        av_free(clut);
    }

    /* Should already be null */
michael's avatar
michael committed
338
    if (ctx->object_list)
339 340 341
        av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n");
}

342
static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
343 344 345 346 347
{
    int i, r, g, b, a = 0;
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;

    memset(avctx->priv_data, 0, sizeof(DVBSubContext));
348

349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
    ctx->composition_id = avctx->sub_id & 0xffff;
    ctx->ancillary_id = avctx->sub_id >> 16;

    default_clut.id = -1;
    default_clut.next = NULL;

    default_clut.clut4[0] = RGBA(  0,   0,   0,   0);
    default_clut.clut4[1] = RGBA(255, 255, 255, 255);
    default_clut.clut4[2] = RGBA(  0,   0,   0, 255);
    default_clut.clut4[3] = RGBA(127, 127, 127, 255);

    default_clut.clut16[0] = RGBA(  0,   0,   0,   0);
    for (i = 1; i < 16; i++) {
        if (i < 8) {
            r = (i & 1) ? 255 : 0;
            g = (i & 2) ? 255 : 0;
            b = (i & 4) ? 255 : 0;
        } else {
            r = (i & 1) ? 127 : 0;
            g = (i & 2) ? 127 : 0;
            b = (i & 4) ? 127 : 0;
370
        }
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
        default_clut.clut16[i] = RGBA(r, g, b, 255);
    }

    default_clut.clut256[0] = RGBA(  0,   0,   0,   0);
    for (i = 1; i < 256; i++) {
        if (i < 8) {
            r = (i & 1) ? 255 : 0;
            g = (i & 2) ? 255 : 0;
            b = (i & 4) ? 255 : 0;
            a = 63;
        } else {
            switch (i & 0x88) {
            case 0x00:
                r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
                g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
                b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
                a = 255;
                break;
            case 0x08:
                r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
                g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
                b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
                a = 127;
                break;
            case 0x80:
                r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
                g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
                b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
                a = 255;
                break;
            case 0x88:
                r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
                g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
                b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
                a = 255;
                break;
            }
408
        }
409 410 411 412 413 414
        default_clut.clut256[i] = RGBA(r, g, b, a);
    }

    return 0;
}

415
static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
416 417 418 419 420
{
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
    DVBSubRegionDisplay *display;

    delete_state(ctx);
421

michael's avatar
michael committed
422
    while (ctx->display_list) {
423 424
        display = ctx->display_list;
        ctx->display_list = display->next;
425

426 427 428 429 430 431
        av_free(display);
    }

    return 0;
}

432
static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
michael's avatar
michael committed
433
                                   const uint8_t **srcbuf, int buf_size,
434 435 436
                                   int non_mod, uint8_t *map_table)
{
    GetBitContext gb;
437

438 439 440
    int bits;
    int run_length;
    int pixels_read = 0;
441

442
    init_get_bits(&gb, *srcbuf, buf_size << 8);
443

444 445 446
    while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
        bits = get_bits(&gb, 2);

michael's avatar
michael committed
447
        if (bits) {
448
            if (non_mod != 1 || bits != 1) {
michael's avatar
michael committed
449
                if (map_table)
450 451 452 453 454 455
                    *destbuf++ = map_table[bits];
                else
                    *destbuf++ = bits;
            }
            pixels_read++;
        } else {
456
            bits = get_bits1(&gb);
457 458 459
            if (bits == 1) {
                run_length = get_bits(&gb, 3) + 3;
                bits = get_bits(&gb, 2);
460

461 462 463
                if (non_mod == 1 && bits == 1)
                    pixels_read += run_length;
                else {
michael's avatar
michael committed
464
                    if (map_table)
465 466 467 468 469 470 471
                        bits = map_table[bits];
                    while (run_length-- > 0 && pixels_read < dbuf_len) {
                        *destbuf++ = bits;
                        pixels_read++;
                    }
                }
            } else {
472
                bits = get_bits1(&gb);
473 474 475 476 477 478 479 480 481
                if (bits == 0) {
                    bits = get_bits(&gb, 2);
                    if (bits == 2) {
                        run_length = get_bits(&gb, 4) + 12;
                        bits = get_bits(&gb, 2);

                        if (non_mod == 1 && bits == 1)
                            pixels_read += run_length;
                        else {
michael's avatar
michael committed
482
                            if (map_table)
483 484 485 486 487 488 489 490 491 492 493 494 495
                                bits = map_table[bits];
                            while (run_length-- > 0 && pixels_read < dbuf_len) {
                                *destbuf++ = bits;
                                pixels_read++;
                            }
                        }
                    } else if (bits == 3) {
                        run_length = get_bits(&gb, 8) + 29;
                        bits = get_bits(&gb, 2);

                        if (non_mod == 1 && bits == 1)
                            pixels_read += run_length;
                        else {
michael's avatar
michael committed
496
                            if (map_table)
497 498 499 500 501 502 503 504
                                bits = map_table[bits];
                            while (run_length-- > 0 && pixels_read < dbuf_len) {
                                *destbuf++ = bits;
                                pixels_read++;
                            }
                        }
                    } else if (bits == 1) {
                        pixels_read += 2;
michael's avatar
michael committed
505
                        if (map_table)
506 507 508 509 510 511 512 513 514 515 516 517
                            bits = map_table[0];
                        else
                            bits = 0;
                        if (pixels_read <= dbuf_len) {
                            *destbuf++ = bits;
                            *destbuf++ = bits;
                        }
                    } else {
                        (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
                        return pixels_read;
                    }
                } else {
michael's avatar
michael committed
518
                    if (map_table)
519 520 521 522 523 524 525 526 527
                        bits = map_table[0];
                    else
                        bits = 0;
                    *destbuf++ = bits;
                    pixels_read++;
                }
            }
        }
    }
528

michael's avatar
michael committed
529
    if (get_bits(&gb, 6))
530 531 532 533 534 535
        av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");

    (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

    return pixels_read;
}
536 537

static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,
michael's avatar
michael committed
538
                                   const uint8_t **srcbuf, int buf_size,
539 540 541
                                   int non_mod, uint8_t *map_table)
{
    GetBitContext gb;
542

543 544 545
    int bits;
    int run_length;
    int pixels_read = 0;
546 547 548

    init_get_bits(&gb, *srcbuf, buf_size << 8);

549 550 551
    while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
        bits = get_bits(&gb, 4);

michael's avatar
michael committed
552
        if (bits) {
553
            if (non_mod != 1 || bits != 1) {
michael's avatar
michael committed
554
                if (map_table)
555 556 557 558 559 560
                    *destbuf++ = map_table[bits];
                else
                    *destbuf++ = bits;
            }
            pixels_read++;
        } else {
561
            bits = get_bits1(&gb);
562 563
            if (bits == 0) {
                run_length = get_bits(&gb, 3);
564

565 566 567 568
                if (run_length == 0) {
                    (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
                    return pixels_read;
                }
569

570
                run_length += 2;
571

michael's avatar
michael committed
572
                if (map_table)
573 574 575
                    bits = map_table[0];
                else
                    bits = 0;
576

577 578 579 580 581
                while (run_length-- > 0 && pixels_read < dbuf_len) {
                    *destbuf++ = bits;
                    pixels_read++;
                }
            } else {
582
                bits = get_bits1(&gb);
583 584 585 586 587 588 589
                if (bits == 0) {
                    run_length = get_bits(&gb, 2) + 4;
                    bits = get_bits(&gb, 4);

                    if (non_mod == 1 && bits == 1)
                        pixels_read += run_length;
                    else {
michael's avatar
michael committed
590
                        if (map_table)
591 592 593 594 595 596 597 598 599 600 601
                            bits = map_table[bits];
                        while (run_length-- > 0 && pixels_read < dbuf_len) {
                            *destbuf++ = bits;
                            pixels_read++;
                        }
                    }
                } else {
                    bits = get_bits(&gb, 2);
                    if (bits == 2) {
                        run_length = get_bits(&gb, 4) + 9;
                        bits = get_bits(&gb, 4);
602

603 604 605
                        if (non_mod == 1 && bits == 1)
                            pixels_read += run_length;
                        else {
michael's avatar
michael committed
606
                            if (map_table)
607 608 609 610 611 612 613 614 615 616 617 618 619
                                bits = map_table[bits];
                            while (run_length-- > 0 && pixels_read < dbuf_len) {
                                *destbuf++ = bits;
                                pixels_read++;
                            }
                        }
                    } else if (bits == 3) {
                        run_length = get_bits(&gb, 8) + 25;
                        bits = get_bits(&gb, 4);

                        if (non_mod == 1 && bits == 1)
                            pixels_read += run_length;
                        else {
michael's avatar
michael committed
620
                            if (map_table)
621 622 623 624 625 626 627 628
                                bits = map_table[bits];
                            while (run_length-- > 0 && pixels_read < dbuf_len) {
                                *destbuf++ = bits;
                                pixels_read++;
                            }
                        }
                    } else if (bits == 1) {
                        pixels_read += 2;
michael's avatar
michael committed
629
                        if (map_table)
630 631 632 633 634 635 636 637
                            bits = map_table[0];
                        else
                            bits = 0;
                        if (pixels_read <= dbuf_len) {
                            *destbuf++ = bits;
                            *destbuf++ = bits;
                        }
                    } else {
michael's avatar
michael committed
638
                        if (map_table)
639 640 641 642 643 644 645 646 647 648
                            bits = map_table[0];
                        else
                            bits = 0;
                        *destbuf++ = bits;
                        pixels_read ++;
                    }
                }
            }
        }
    }
649

michael's avatar
michael committed
650
    if (get_bits(&gb, 8))
651
        av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
652

653 654 655 656
    (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

    return pixels_read;
}
657 658

static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,
michael's avatar
michael committed
659
                                    const uint8_t **srcbuf, int buf_size,
660 661
                                    int non_mod, uint8_t *map_table)
{
michael's avatar
michael committed
662
    const uint8_t *sbuf_end = (*srcbuf) + buf_size;
663 664 665
    int bits;
    int run_length;
    int pixels_read = 0;
666

667 668
    while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
        bits = *(*srcbuf)++;
669

michael's avatar
michael committed
670
        if (bits) {
671
            if (non_mod != 1 || bits != 1) {
michael's avatar
michael committed
672
                if (map_table)
673 674 675 676 677 678 679 680 681 682 683 684
                    *destbuf++ = map_table[bits];
                else
                    *destbuf++ = bits;
            }
            pixels_read++;
        } else {
            bits = *(*srcbuf)++;
            run_length = bits & 0x7f;
            if ((bits & 0x80) == 0) {
                if (run_length == 0) {
                    return pixels_read;
                }
685

michael's avatar
michael committed
686
                if (map_table)
687 688 689 690 691 692 693 694 695 696 697 698
                    bits = map_table[0];
                else
                    bits = 0;
                while (run_length-- > 0 && pixels_read < dbuf_len) {
                    *destbuf++ = bits;
                    pixels_read++;
                }
            } else {
                bits = *(*srcbuf)++;

                if (non_mod == 1 && bits == 1)
                    pixels_read += run_length;
michael's avatar
michael committed
699
                if (map_table)
700 701 702 703 704 705 706 707
                    bits = map_table[bits];
                else while (run_length-- > 0 && pixels_read < dbuf_len) {
                    *destbuf++ = bits;
                    pixels_read++;
                }
            }
        }
    }
708

michael's avatar
michael committed
709
    if (*(*srcbuf)++)
710
        av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
711

712 713
    return pixels_read;
}
714

715 716 717


static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
michael's avatar
michael committed
718
                                          const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
719 720 721 722
{
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;

    DVBSubRegion *region = get_region(ctx, display->region_id);
michael's avatar
michael committed
723
    const uint8_t *buf_end = buf + buf_size;
724 725 726
    uint8_t *pbuf;
    int x_pos, y_pos;
    int i;
727

728 729
    uint8_t map2to4[] = { 0x0,  0x7,  0x8,  0xf};
    uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
730
    uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
731 732
                         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
    uint8_t *map_table;
733

734 735 736 737 738 739
#ifdef DEBUG
    av_log(avctx, AV_LOG_INFO, "DVB pixel block size %d, %s field:\n", buf_size,
                top_bottom ? "bottom" : "top");
#endif

#ifdef DEBUG_PACKET_CONTENTS
michael's avatar
michael committed
740
    for (i = 0; i < buf_size; i++) {
741 742 743 744 745 746 747
        if (i % 16 == 0)
            av_log(avctx, AV_LOG_INFO, "0x%08p: ", buf+i);

        av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
        if (i % 16 == 15)
            av_log(avctx, AV_LOG_INFO, "\n");
    }
748

michael's avatar
michael committed
749
    if (i % 16)
750 751 752 753 754 755
        av_log(avctx, AV_LOG_INFO, "\n");

#endif

    if (region == 0)
        return;
756

757
    pbuf = region->pbuf;
758

759 760
    x_pos = display->x_pos;
    y_pos = display->y_pos;
761

762 763 764 765 766 767 768 769
    if ((y_pos & 1) != top_bottom)
        y_pos++;

    while (buf < buf_end) {
        if (x_pos > region->width || y_pos > region->height) {
            av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");
            return;
        }
770

771 772 773 774 775 776 777 778
        switch (*buf++) {
        case 0x10:
            if (region->depth == 8)
                map_table = map2to8;
            else if (region->depth == 4)
                map_table = map2to4;
            else
                map_table = NULL;
779 780 781

            x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos,
                                                region->width - x_pos, &buf, buf_size,
782 783 784 785 786 787 788
                                                non_mod, map_table);
            break;
        case 0x11:
            if (region->depth < 4) {
                av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
                return;
            }
789

790 791 792 793
            if (region->depth == 8)
                map_table = map4to8;
            else
                map_table = NULL;
794 795 796

            x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos,
                                                region->width - x_pos, &buf, buf_size,
797 798 799 800 801 802 803
                                                non_mod, map_table);
            break;
        case 0x12:
            if (region->depth < 8) {
                av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
                return;
            }
804 805 806

            x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos,
                                                region->width - x_pos, &buf, buf_size,
807 808
                                                non_mod, NULL);
            break;
809

810 811 812 813 814 815 816 817 818 819 820 821 822 823
        case 0x20:
            map2to4[0] = (*buf) >> 4;
            map2to4[1] = (*buf++) & 0xf;
            map2to4[2] = (*buf) >> 4;
            map2to4[3] = (*buf++) & 0xf;
            break;
        case 0x21:
            for (i = 0; i < 4; i++)
                map2to8[i] = *buf++;
            break;
        case 0x22:
            for (i = 0; i < 16; i++)
                map4to8[i] = *buf++;
            break;
824

825 826 827 828 829 830 831 832
        case 0xf0:
            x_pos = display->x_pos;
            y_pos += 2;
            break;
        default:
            av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
        }
    }
833

834 835 836
}

static void dvbsub_parse_object_segment(AVCodecContext *avctx,
michael's avatar
michael committed
837
                                        const uint8_t *buf, int buf_size)
838 839
{
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
840

michael's avatar
michael committed
841 842
    const uint8_t *buf_end = buf + buf_size;
    const uint8_t *block;
843 844 845 846
    int object_id;
    DVBSubObject *object;
    DVBSubObjectDisplay *display;
    int top_field_len, bottom_field_len;
847

diego's avatar
diego committed
848
    int coding_method, non_modifying_color;
849

850
    object_id = AV_RB16(buf);
851
    buf += 2;
852

853 854
    object = get_object(ctx, object_id);

855 856 857
    if (!object)
        return;

858
    coding_method = ((*buf) >> 2) & 3;
diego's avatar
diego committed
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 868 869
        if (buf + top_field_len + bottom_field_len > buf_end) {
            av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");
            return;
870 871
        }

michael's avatar
michael committed
872
        for (display = object->display_list; display; display = display->object_list_next) {
873 874 875
            block = buf;

            dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
diego's avatar
diego committed
876
                                            non_modifying_color);
877 878 879 880 881 882 883

            if (bottom_field_len > 0)
                block = buf + top_field_len;
            else
                bottom_field_len = top_field_len;

            dvbsub_parse_pixel_data_block(avctx, display, block, bottom_field_len, 1,
diego's avatar
diego committed
884
                                            non_modifying_color);
885
        }
886

887
/*  } else if (coding_method == 1) {*/
888

889 890 891
    } else {
        av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
    }
892

893 894 895
}

static void dvbsub_parse_clut_segment(AVCodecContext *avctx,
michael's avatar
michael committed
896
                                        const uint8_t *buf, int buf_size)
897 898
{
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
899

michael's avatar
michael committed
900
    const uint8_t *buf_end = buf + buf_size;
901 902 903 904 905 906 907 908 909 910 911
    int clut_id;
    DVBSubCLUT *clut;
    int entry_id, depth , full_range;
    int y, cr, cb, alpha;
    int r, g, b, r_add, g_add, b_add;

#ifdef DEBUG_PACKET_CONTENTS
    int i;

    av_log(avctx, AV_LOG_INFO, "DVB clut packet:\n");

michael's avatar
michael committed
912
    for (i=0; i < buf_size; i++) {
913 914 915 916
        av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
        if (i % 16 == 15)
            av_log(avctx, AV_LOG_INFO, "\n");
    }
917

michael's avatar
michael committed
918
    if (i % 16)
919 920 921 922 923 924
        av_log(avctx, AV_LOG_INFO, "\n");

#endif

    clut_id = *buf++;
    buf += 1;
925

926
    clut = get_clut(ctx, clut_id);
927

michael's avatar
michael committed
928
    if (!clut) {
929
        clut = av_malloc(sizeof(DVBSubCLUT));
930

931 932 933
        memcpy(clut, &default_clut, sizeof(DVBSubCLUT));

        clut->id = clut_id;
934 935

        clut->next = ctx->clut_list;
936 937
        ctx->clut_list = clut;
    }
938

michael's avatar
michael committed
939
    while (buf + 4 < buf_end) {
940
        entry_id = *buf++;
941

942
        depth = (*buf) & 0xe0;
943

944 945 946 947
        if (depth == 0) {
            av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
            return;
        }
948

949
        full_range = (*buf++) & 1;
950

951 952 953 954 955 956 957 958 959 960
        if (full_range) {
            y = *buf++;
            cr = *buf++;
            cb = *buf++;
            alpha = *buf++;
        } else {
            y = buf[0] & 0xfc;
            cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
            cb = (buf[1] << 2) & 0xf0;
            alpha = (buf[1] << 6) & 0xc0;
961

962 963
            buf += 2;
        }
964

965 966
        if (y == 0)
            alpha = 0xff;
967

968 969
        YUV_TO_RGB1_CCIR(cb, cr);
        YUV_TO_RGB2_CCIR(r, g, b, y);
970

971 972 973
#ifdef DEBUG
        av_log(avctx, AV_LOG_INFO, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
#endif
974

975 976 977 978 979 980 981 982 983 984 985
        if (depth & 0x80)
            clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
        if (depth & 0x40)
            clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
        if (depth & 0x20)
            clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
    }
}


static void dvbsub_parse_region_segment(AVCodecContext *avctx,
michael's avatar
michael committed
986
                                        const uint8_t *buf, int buf_size)
987 988
{
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
989

michael's avatar
michael committed
990
    const uint8_t *buf_end = buf + buf_size;
991 992 993 994 995
    int region_id, object_id;
    DVBSubRegion *region;
    DVBSubObject *object;
    DVBSubObjectDisplay *display;
    int fill;
996

997 998
    if (buf_size < 10)
        return;
999

1000
    region_id = *buf++;
1001

1002
    region = get_region(ctx, region_id);
1003

michael's avatar
michael committed
1004
    if (!region) {
1005
        region = av_mallocz(sizeof(DVBSubRegion));
1006

1007
        region->id = region_id;
1008

1009 1010 1011
        region->next = ctx->region_list;
        ctx->region_list = region;
    }
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) {
michael's avatar
michael committed
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 1029
        fill = 1;
    }
1030

1031
    region->depth = 1 << (((*buf++) >> 2) & 7);
michael's avatar
michael committed
1032 1033 1034 1035
    if(region->depth<2 || region->depth>8){
        av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
        region->depth= 4;
    }
1036
    region->clut = *buf++;
1037

1038
    if (region->depth == 8)
diego's avatar
diego committed
1039
        region->bgcolor = *buf++;
1040 1041
    else {
        buf += 1;
1042

1043
        if (region->depth == 4)
diego's avatar
diego committed
1044
            region->bgcolor = (((*buf++) >> 4) & 15);
1045
        else
diego's avatar
diego committed
1046
            region->bgcolor = (((*buf++) >> 2) & 3);
1047 1048 1049 1050 1051 1052 1053
    }

#ifdef DEBUG
    av_log(avctx, AV_LOG_INFO, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
#endif

    if (fill) {
diego's avatar
diego committed
1054
        memset(region->pbuf, region->bgcolor, region->buf_size);
1055
#ifdef DEBUG
diego's avatar
diego committed
1056
        av_log(avctx, AV_LOG_INFO, "Fill region (%d)\n", region->bgcolor);
1057 1058 1059 1060 1061 1062
#endif
    }

    delete_region_display_list(ctx, region);

    while (buf + 5 < buf_end) {
1063
        object_id = AV_RB16(buf);
1064
        buf += 2;
1065

1066 1067
        object = get_object(ctx, object_id);

michael's avatar
michael committed
1068
        if (!object) {
1069
            object = av_mallocz(sizeof(DVBSubObject));
1070

1071 1072 1073 1074
            object->id = object_id;
            object->next = ctx->object_list;
            ctx->object_list = object;
        }
1075

1076
        object->type = (*buf) >> 6;
1077

1078
        display = av_mallocz(sizeof(DVBSubObjectDisplay));
1079

1080 1081
        display->object_id = object_id;
        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) {
diego's avatar
diego committed
1089 1090
            display->fgcolor = *buf++;
            display->bgcolor = *buf++;
1091
        }
1092

1093 1094
        display->region_list_next = region->display_list;
        region->display_list = display;
1095

1096 1097 1098 1099 1100 1101
        display->object_list_next = object->display_list;
        object->display_list = display;
    }
}

static void dvbsub_parse_page_segment(AVCodecContext *avctx,
michael's avatar
michael committed
1102
                                        const uint8_t *buf, int buf_size)
1103 1104 1105 1106
{
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
    DVBSubRegionDisplay *display;
    DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1107

michael's avatar
michael committed
1108
    const uint8_t *buf_end = buf + buf_size;
1109 1110
    int region_id;
    int page_state;
1111

1112 1113
    if (buf_size < 1)
        return;
1114

1115 1116
    ctx->time_out = *buf++;
    page_state = ((*buf++) >> 2) & 3;
1117

1118 1119 1120 1121
#ifdef DEBUG
    av_log(avctx, AV_LOG_INFO, "Page time out %ds, state %d\n", ctx->time_out, page_state);
#endif

michael's avatar
michael committed
1122
    if (page_state == 2) {
1123 1124
        delete_state(ctx);
    }
1125

1126 1127 1128
    tmp_display_list = ctx->display_list;
    ctx->display_list = NULL;
    ctx->display_list_size = 0;
1129

1130 1131 1132
    while (buf + 5 < buf_end) {
        region_id = *buf++;
        buf += 1;
1133

1134 1135
        display = tmp_display_list;
        tmp_ptr = &tmp_display_list;
1136

michael's avatar
michael committed
1137
        while (display && display->region_id != region_id) {
1138 1139 1140
            tmp_ptr = &display->next;
            display = display->next;
        }
1141

michael's avatar
michael committed
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 1155 1156
        display->next = ctx->display_list;
        ctx->display_list = display;
        ctx->display_list_size++;
1157

1158 1159 1160 1161
#ifdef DEBUG
        av_log(avctx, AV_LOG_INFO, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
#endif
    }
1162

michael's avatar
michael committed
1163
    while (tmp_display_list) {
1164
        display = tmp_display_list;
1165

1166
        tmp_display_list = display->next;
1167

1168 1169
        av_free(display);
    }
1170

1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
}


#ifdef DEBUG_SAVE_IMAGES
static void save_display_set(DVBSubContext *ctx)
{
    DVBSubRegion *region;
    DVBSubRegionDisplay *display;
    DVBSubCLUT *clut;
    uint32_t *clut_table;
    int x_pos, y_pos, width, height;
    int x, y, y_off, x_off;
    uint32_t *pbuf;
    char filename[32];
    static int fileno_index = 0;

    x_pos = -1;
    y_pos = -1;
    width = 0;
    height = 0;
1191

michael's avatar
michael committed
1192
    for (display = ctx->display_list; display; display = display->next) {
1193
        region = get_region(ctx, display->region_id);
1194

1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
        if (x_pos == -1) {
            x_pos = display->x_pos;
            y_pos = display->y_pos;
            width = region->width;
            height = region->height;
        } else {
            if (display->x_pos < x_pos) {
                width += (x_pos - display->x_pos);
                x_pos = display->x_pos;
            }
1205

1206 1207 1208 1209
            if (display->y_pos < y_pos) {
                height += (y_pos - display->y_pos);
                y_pos = display->y_pos;
            }
1210

1211 1212 1213
            if (display->x_pos + region->width > x_pos + width) {
                width = display->x_pos + region->width - x_pos;
            }
1214

1215 1216 1217 1218 1219
            if (display->y_pos + region->height > y_pos + height) {
                height = display->y_pos + region->height - y_pos;
            }
        }
    }
1220

1221
    if (x_pos >= 0) {
1222

1223 1224
        pbuf = av_malloc(width * height * 4);

michael's avatar
michael committed
1225
        for (display = ctx->display_list; display; display = display->next) {
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
            region = get_region(ctx, display->region_id);

            x_off = display->x_pos - x_pos;
            y_off = display->y_pos - y_pos;

            clut = get_clut(ctx, region->clut);

            if (clut == 0)
                clut = &default_clut;

            switch (region->depth) {
            case 2:
                clut_table = clut->clut4;
                break;
            case 8:
                clut_table = clut->clut256;
                break;
            case 4:
            default:
                clut_table = clut->clut16;
                break;
            }
1248

1249 1250
            for (y = 0; y < region->height; y++) {
                for (x = 0; x < region->width; x++) {
1251
                    pbuf[((y + y_off) * width) + x_off + x] =
1252 1253 1254 1255
                        clut_table[region->pbuf[y * region->width + x]];
                }
            }

1256
        }
1257

1258
        snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1259 1260 1261 1262 1263

        png_save2(filename, pbuf, width, height);

        av_free(pbuf);
    }
1264

1265 1266 1267 1268
    fileno_index++;
}
#endif

michael's avatar
michael committed
1269
static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279
                                        int buf_size, AVSubtitle *sub)
{
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;

    DVBSubRegion *region;
    DVBSubRegionDisplay *display;
    AVSubtitleRect *rect;
    DVBSubCLUT *clut;
    uint32_t *clut_table;
    int i;
1280

1281 1282 1283 1284 1285 1286
    sub->rects = NULL;
    sub->start_display_time = 0;
    sub->end_display_time = ctx->time_out * 1000;
    sub->format = 0;

    sub->num_rects = ctx->display_list_size;
1287

1288 1289 1290 1291 1292
    if (sub->num_rects > 0){
        sub->rects = av_mallocz(sizeof(*sub->rects) * sub->num_rects);
        for(i=0; i<sub->num_rects; i++)
            sub->rects[i] = av_mallocz(sizeof(*sub->rects[i]));
    }
1293 1294 1295

    i = 0;

michael's avatar
michael committed
1296
    for (display = ctx->display_list; display; display = display->next) {
1297
        region = get_region(ctx, display->region_id);
1298
        rect = sub->rects[i];
1299

michael's avatar
michael committed
1300
        if (!region)
1301
            continue;
1302

1303 1304 1305 1306 1307 1308 1309 1310
        rect->x = display->x_pos;
        rect->y = display->y_pos;
        rect->w = region->width;
        rect->h = region->height;
        rect->nb_colors = 16;
        rect->linesize = region->width;

        clut = get_clut(ctx, region->clut);
1311

michael's avatar
michael committed
1312
        if (!clut)
1313
            clut = &default_clut;
1314

1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
        switch (region->depth) {
        case 2:
            clut_table = clut->clut4;
            break;
        case 8:
            clut_table = clut->clut256;
            break;
        case 4:
        default:
            clut_table = clut->clut16;
            break;
        }
1327

1328 1329
        rect->rgba_palette = av_malloc((1 << region->depth) * sizeof(uint32_t));
        memcpy(rect->rgba_palette, clut_table, (1 << region->depth) * sizeof(uint32_t));
1330

1331 1332
        rect->bitmap = av_malloc(region->buf_size);
        memcpy(rect->bitmap, region->pbuf, region->buf_size);
1333

1334 1335
        i++;
    }
1336

1337
    sub->num_rects = i;
1338

1339 1340 1341
#ifdef DEBUG_SAVE_IMAGES
    save_display_set(ctx);
#endif
1342

1343 1344 1345 1346 1347
    return 1;
}

static int dvbsub_decode(AVCodecContext *avctx,
                         void *data, int *data_size,
michael's avatar
michael committed
1348
                         const uint8_t *buf, int buf_size)
1349 1350 1351
{
    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
    AVSubtitle *sub = (AVSubtitle*) data;
michael's avatar
michael committed
1352
    const uint8_t *p, *p_end;
1353 1354 1355
    int segment_type;
    int page_id;
    int segment_length;
1356

1357 1358 1359 1360 1361
#ifdef DEBUG_PACKET_CONTENTS
    int i;

    av_log(avctx, AV_LOG_INFO, "DVB sub packet:\n");

michael's avatar
michael committed
1362
    for (i=0; i < buf_size; i++) {
1363 1364 1365 1366
        av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
        if (i % 16 == 15)
            av_log(avctx, AV_LOG_INFO, "\n");
    }
1367

michael's avatar
michael committed
1368
    if (i % 16)
1369 1370 1371 1372 1373 1374
        av_log(avctx, AV_LOG_INFO, "\n");

#endif

    if (buf_size <= 2)
        return -1;
1375

1376 1377
    p = buf;
    p_end = buf + buf_size;
1378

michael's avatar
michael committed
1379
    while (p < p_end && *p == 0x0f) {
1380 1381
        p += 1;
        segment_type = *p++;
1382
        page_id = AV_RB16(p);
1383
        p += 2;
1384
        segment_length = AV_RB16(p);
1385
        p += 2;
1386

1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
        if (page_id == ctx->composition_id || page_id == ctx->ancillary_id) {
            switch (segment_type) {
            case DVBSUB_PAGE_SEGMENT:
                dvbsub_parse_page_segment(avctx, p, segment_length);
                break;
            case DVBSUB_REGION_SEGMENT:
                dvbsub_parse_region_segment(avctx, p, segment_length);
                break;
            case DVBSUB_CLUT_SEGMENT:
                dvbsub_parse_clut_segment(avctx, p, segment_length);
                break;
            case DVBSUB_OBJECT_SEGMENT:
                dvbsub_parse_object_segment(avctx, p, segment_length);
                break;
            case DVBSUB_DISPLAY_SEGMENT:
                *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);
                break;
            default:
#ifdef DEBUG
1406
                av_log(avctx, AV_LOG_INFO, "Subtitling segment type 0x%x, page id %d, length %d\n",
1407 1408 1409 1410 1411 1412 1413 1414
                        segment_type, page_id, segment_length);
#endif
                break;
            }
        }

        p += segment_length;
    }
1415

michael's avatar
michael committed
1416
    if (p != p_end) {
1417 1418 1419 1420 1421 1422
#ifdef DEBUG
        av_log(avctx, AV_LOG_INFO, "Junk at end of packet\n");
#endif
        return -1;
    }

1423
    return buf_size;
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435
}


AVCodec dvbsub_decoder = {
    "dvbsub",
    CODEC_TYPE_SUBTITLE,
    CODEC_ID_DVB_SUBTITLE,
    sizeof(DVBSubContext),
    dvbsub_init_decoder,
    NULL,
    dvbsub_close_decoder,
    dvbsub_decode,
1436
    .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
1437
};