libzvbi-teletextdec.c 19.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * Teletext decoding for ffmpeg
 * Copyright (c) 2005-2010, 2012 Wolfram Gloger
 * Copyright (c) 2013 Marton Balint
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * 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
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 20 21
 */

#include "avcodec.h"
22
#include "libavcodec/ass.h"
23
#include "libavutil/opt.h"
24
#include "libavutil/bprint.h"
25
#include "libavutil/intreadwrite.h"
26
#include "libavutil/log.h"
27 28 29 30 31 32 33 34 35 36

#include <libzvbi.h>

#define TEXT_MAXSZ    (25 * (56 + 1) * 4 + 2)
#define VBI_NB_COLORS 40
#define RGBA(r,g,b,a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
#define VBI_R(rgba)   (((rgba) >> 0) & 0xFF)
#define VBI_G(rgba)   (((rgba) >> 8) & 0xFF)
#define VBI_B(rgba)   (((rgba) >> 16) & 0xFF)
#define VBI_A(rgba)   (((rgba) >> 24) & 0xFF)
37
#define MAX_BUFFERED_PAGES 25
38 39
#define BITMAP_CHAR_WIDTH  12
#define BITMAP_CHAR_HEIGHT 10
40
#define MAX_SLICES 64
41 42 43 44 45 46 47 48

typedef struct TeletextPage
{
    AVSubtitleRect *sub_rect;
    int pgno;
    int subno;
    int64_t pts;
} TeletextPage;
49 50 51 52 53 54 55

typedef struct TeletextContext
{
    AVClass        *class;
    char           *pgno;
    int             x_offset;
    int             y_offset;
56
    int             format_id; /* 0 = bitmap, 1 = text/ass */
57 58 59 60 61 62
    int             chop_top;
    int             sub_duration; /* in msec */
    int             transparent_bg;
    int             chop_spaces;

    int             lines_processed;
63 64 65
    TeletextPage    *pages;
    int             nb_pages;
    int64_t         pts;
66
    int             handler_ret;
67 68 69 70 71

    vbi_decoder *   vbi;
#ifdef DEBUG
    vbi_export *    ex;
#endif
72
    vbi_sliced      sliced[MAX_SLICES];
73 74
} TeletextContext;

75
static int chop_spaces_utf8(const unsigned char* t, int len)
76 77 78 79 80 81 82 83 84 85
{
    t += len;
    while (len > 0) {
        if (*--t != ' ' || (len-1 > 0 && *(t-1) & 0x80))
            break;
        --len;
    }
    return len;
}

86
static void subtitle_rect_free(AVSubtitleRect **sub_rect)
87 88 89
{
    av_freep(&(*sub_rect)->pict.data[0]);
    av_freep(&(*sub_rect)->pict.data[1]);
90
    av_freep(&(*sub_rect)->ass);
91 92 93
    av_freep(sub_rect);
}

94
static int create_ass_text(TeletextContext *ctx, const char *text, char **ass)
95 96 97 98 99 100 101 102 103
{
    int ret;
    AVBPrint buf, buf2;
    const int ts_start    = av_rescale_q(ctx->pts,          AV_TIME_BASE_Q,        (AVRational){1, 100});
    const int ts_duration = av_rescale_q(ctx->sub_duration, (AVRational){1, 1000}, (AVRational){1, 100});

    /* First we escape the plain text into buf. */
    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
    ff_ass_bprint_text_event(&buf, text, strlen(text), "", 0);
104
    av_bprintf(&buf, "\r\n");
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126

    if (!av_bprint_is_complete(&buf)) {
        av_bprint_finalize(&buf, NULL);
        return AVERROR(ENOMEM);
    }

    /* Then we create the ass dialog line in buf2 from the escaped text in buf. */
    av_bprint_init(&buf2, 0, AV_BPRINT_SIZE_UNLIMITED);
    ff_ass_bprint_dialog(&buf2, buf.str, ts_start, ts_duration, 0);
    av_bprint_finalize(&buf, NULL);

    if (!av_bprint_is_complete(&buf2)) {
        av_bprint_finalize(&buf2, NULL);
        return AVERROR(ENOMEM);
    }

    if ((ret = av_bprint_finalize(&buf2, ass)) < 0)
        return ret;

    return 0;
}

127 128
/* Draw a page as text */
static int gen_sub_text(TeletextContext *ctx, AVSubtitleRect *sub_rect, vbi_page *page, int chop_top)
129 130
{
    const char *in;
131
    AVBPrint buf;
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
    char *vbi_text = av_malloc(TEXT_MAXSZ);
    int sz;

    if (!vbi_text)
        return AVERROR(ENOMEM);

    sz = vbi_print_page_region(page, vbi_text, TEXT_MAXSZ-1, "UTF-8",
                                   /*table mode*/ TRUE, FALSE,
                                   0,             chop_top,
                                   page->columns, page->rows-chop_top);
    if (sz <= 0) {
        av_log(ctx, AV_LOG_ERROR, "vbi_print error\n");
        av_free(vbi_text);
        return AVERROR_EXTERNAL;
    }
    vbi_text[sz] = '\0';
    in  = vbi_text;
149 150
    av_bprint_init(&buf, 0, TEXT_MAXSZ);

151 152 153 154 155 156 157 158 159 160 161 162 163 164
    if (ctx->chop_spaces) {
        for (;;) {
            int nl, sz;

            // skip leading spaces and newlines
            in += strspn(in, " \n");
            // compute end of row
            for (nl = 0; in[nl]; ++nl)
                if (in[nl] == '\n' && (nl==0 || !(in[nl-1] & 0x80)))
                    break;
            if (!in[nl])
                break;
            // skip trailing spaces
            sz = chop_spaces_utf8(in, nl);
165 166
            av_bprint_append_data(&buf, in, sz);
            av_bprintf(&buf, "\n");
167 168 169
            in += nl;
        }
    } else {
170
        av_bprintf(&buf, "%s\n", vbi_text);
171 172
    }
    av_free(vbi_text);
173 174 175 176 177 178 179 180

    if (!av_bprint_is_complete(&buf)) {
        av_bprint_finalize(&buf, NULL);
        return AVERROR(ENOMEM);
    }

    if (buf.len) {
        int ret;
181 182 183
        sub_rect->type = SUBTITLE_ASS;
        if ((ret = create_ass_text(ctx, buf.str, &sub_rect->ass)) < 0) {
            av_bprint_finalize(&buf, NULL);
184
            return ret;
185 186
        }
        av_log(ctx, AV_LOG_DEBUG, "subtext:%s:txetbus\n", sub_rect->ass);
187 188 189
    } else {
        sub_rect->type = SUBTITLE_NONE;
    }
190
    av_bprint_finalize(&buf, NULL);
191 192 193
    return 0;
}

194 195
static void fix_transparency(TeletextContext *ctx, AVSubtitleRect *sub_rect, vbi_page *page,
                             int chop_top, uint8_t transparent_color, int resx, int resy)
196 197 198 199 200 201
{
    int iy;

    // Hack for transparency, inspired by VLC code...
    for (iy = 0; iy < resy; iy++) {
        uint8_t *pixel = sub_rect->pict.data[0] + iy * sub_rect->pict.linesize[0];
202
        vbi_char *vc = page->text + (iy / BITMAP_CHAR_HEIGHT + chop_top) * page->columns;
203 204
        vbi_char *vcnext = vc + page->columns;
        for (; vc < vcnext; vc++) {
205
            uint8_t *pixelnext = pixel + BITMAP_CHAR_WIDTH;
206 207
            switch (vc->opacity) {
                case VBI_TRANSPARENT_SPACE:
208
                    memset(pixel, transparent_color, BITMAP_CHAR_WIDTH);
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
                    break;
                case VBI_OPAQUE:
                case VBI_SEMI_TRANSPARENT:
                    if (!ctx->transparent_bg)
                        break;
                case VBI_TRANSPARENT_FULL:
                    for(; pixel < pixelnext; pixel++)
                        if (*pixel == vc->background)
                            *pixel = transparent_color;
                    break;
            }
            pixel = pixelnext;
        }
    }
}

225 226
/* Draw a page as bitmap */
static int gen_sub_bitmap(TeletextContext *ctx, AVSubtitleRect *sub_rect, vbi_page *page, int chop_top)
227
{
228 229
    int resx = page->columns * BITMAP_CHAR_WIDTH;
    int resy = (page->rows - chop_top) * BITMAP_CHAR_HEIGHT;
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
    uint8_t ci, cmax = 0;
    int ret;
    vbi_char *vc = page->text + (chop_top * page->columns);
    vbi_char *vcend = page->text + (page->rows * page->columns);

    for (; vc < vcend; vc++) {
        if (vc->opacity != VBI_TRANSPARENT_SPACE) {
            cmax = VBI_NB_COLORS;
            break;
        }
    }

    if (cmax == 0) {
        av_log(ctx, AV_LOG_DEBUG, "dropping empty page %3x\n", page->pgno);
        sub_rect->type = SUBTITLE_NONE;
        return 0;
    }

    if ((ret = avpicture_alloc(&sub_rect->pict, AV_PIX_FMT_PAL8, resx, resy)) < 0)
        return ret;
    // Yes, we want to allocate the palette on our own because AVSubtitle works this way
    sub_rect->pict.data[1] = NULL;

    vbi_draw_vt_page_region(page, VBI_PIXFMT_PAL8,
                            sub_rect->pict.data[0], sub_rect->pict.linesize[0],
                            0, chop_top, page->columns, page->rows - chop_top,
                            /*reveal*/ 1, /*flash*/ 1);

258
    fix_transparency(ctx, sub_rect, page, chop_top, cmax, resx, resy);
259
    sub_rect->x = ctx->x_offset;
260
    sub_rect->y = ctx->y_offset + chop_top * BITMAP_CHAR_HEIGHT;
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
    sub_rect->w = resx;
    sub_rect->h = resy;
    sub_rect->nb_colors = (int)cmax + 1;
    sub_rect->pict.data[1] = av_mallocz(AVPALETTE_SIZE);
    if (!sub_rect->pict.data[1]) {
        av_freep(&sub_rect->pict.data[0]);
        return AVERROR(ENOMEM);
    }
    for (ci = 0; ci < cmax; ci++) {
        int r, g, b, a;

        r = VBI_R(page->color_map[ci]);
        g = VBI_G(page->color_map[ci]);
        b = VBI_B(page->color_map[ci]);
        a = VBI_A(page->color_map[ci]);
        ((uint32_t *)sub_rect->pict.data[1])[ci] = RGBA(r, g, b, a);
277
        av_dlog(ctx, "palette %0x\n", ((uint32_t *)sub_rect->pict.data[1])[ci]);
278 279 280 281 282 283
    }
    ((uint32_t *)sub_rect->pict.data[1])[cmax] = RGBA(0, 0, 0, 0);
    sub_rect->type = SUBTITLE_BITMAP;
    return 0;
}

284
static void handler(vbi_event *ev, void *user_data)
285 286
{
    TeletextContext *ctx = user_data;
287
    TeletextPage *new_pages;
288 289 290 291 292 293 294 295 296 297 298 299 300 301
    vbi_page page;
    int res;
    char pgno_str[12];
    vbi_subno subno;
    vbi_page_type vpt;
    int chop_top;
    char *lang;

    snprintf(pgno_str, sizeof pgno_str, "%03x", ev->ev.ttx_page.pgno);
    av_log(ctx, AV_LOG_DEBUG, "decoded page %s.%02x\n",
           pgno_str, ev->ev.ttx_page.subno & 0xFF);

    if (strcmp(ctx->pgno, "*") && !strstr(ctx->pgno, pgno_str))
        return;
302 303
    if (ctx->handler_ret < 0)
        return;
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328

    res = vbi_fetch_vt_page(ctx->vbi, &page,
                            ev->ev.ttx_page.pgno,
                            ev->ev.ttx_page.subno,
                            VBI_WST_LEVEL_3p5, 25, TRUE);

    if (!res)
        return;

#ifdef DEBUG
    fprintf(stderr, "\nSaving res=%d dy0=%d dy1=%d...\n",
            res, page.dirty.y0, page.dirty.y1);
    fflush(stderr);

    if (!vbi_export_stdio(ctx->ex, stderr, &page))
        fprintf(stderr, "failed: %s\n", vbi_export_errstr(ctx->ex));
#endif

    vpt = vbi_classify_page(ctx->vbi, ev->ev.ttx_page.pgno, &subno, &lang);
    chop_top = ctx->chop_top ||
        ((page.rows > 1) && (vpt == VBI_SUBTITLE_PAGE));

    av_log(ctx, AV_LOG_DEBUG, "%d x %d page chop:%d\n",
           page.columns, page.rows, chop_top);

329 330 331 332 333 334 335 336 337 338 339 340
    if (ctx->nb_pages < MAX_BUFFERED_PAGES) {
        if ((new_pages = av_realloc_array(ctx->pages, ctx->nb_pages + 1, sizeof(TeletextPage)))) {
            TeletextPage *cur_page = new_pages + ctx->nb_pages;
            ctx->pages = new_pages;
            cur_page->sub_rect = av_mallocz(sizeof(*cur_page->sub_rect));
            cur_page->pts = ctx->pts;
            cur_page->pgno = ev->ev.ttx_page.pgno;
            cur_page->subno = ev->ev.ttx_page.subno;
            if (cur_page->sub_rect) {
                res = (ctx->format_id == 0) ?
                    gen_sub_bitmap(ctx, cur_page->sub_rect, &page, chop_top) :
                    gen_sub_text  (ctx, cur_page->sub_rect, &page, chop_top);
341
                if (res < 0) {
342
                    av_freep(&cur_page->sub_rect);
343 344
                    ctx->handler_ret = res;
                } else {
345
                    ctx->pages[ctx->nb_pages++] = *cur_page;
346 347 348
                }
            } else {
                ctx->handler_ret = AVERROR(ENOMEM);
349 350
            }
        } else {
351
            ctx->handler_ret = AVERROR(ENOMEM);
352 353
        }
    } else {
354 355
        //TODO: If multiple packets contain more than one page, pages may got queued up, and this may happen...
        av_log(ctx, AV_LOG_ERROR, "Buffered too many pages, dropping page %s.\n", pgno_str);
356
        ctx->handler_ret = AVERROR(ENOSYS);
357 358 359 360 361
    }

    vbi_unref_page(&page);
}

362 363 364 365 366 367 368 369 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
static inline int data_identifier_is_teletext(int data_identifier) {
    /* See EN 301 775 section 4.4.2. */
    return (data_identifier >= 0x10 && data_identifier <= 0x1F ||
            data_identifier >= 0x99 && data_identifier <= 0x9B);
}

static int slice_to_vbi_lines(TeletextContext *ctx, uint8_t* buf, int size)
{
    int lines = 0;
    while (size >= 2 && lines < MAX_SLICES) {
        int data_unit_id     = buf[0];
        int data_unit_length = buf[1];
        if (data_unit_length + 2 > size)
            return AVERROR_INVALIDDATA;
        if (data_unit_id == 0x02 || data_unit_id == 0x03) {
            if (data_unit_length != 0x2c)
                return AVERROR_INVALIDDATA;
            else {
                int line_offset  = buf[2] & 0x1f;
                int field_parity = buf[2] & 0x20;
                int i;
                ctx->sliced[lines].id = VBI_SLICED_TELETEXT_B;
                ctx->sliced[lines].line = (line_offset > 0 ? (line_offset + (field_parity ? 0 : 313)) : 0);
                for (i = 0; i < 42; i++)
                    ctx->sliced[lines].data[i] = vbi_rev8(buf[4 + i]);
                lines++;
            }
        }
        size -= data_unit_length + 2;
        buf += data_unit_length + 2;
    }
    if (size)
        av_log(ctx, AV_LOG_WARNING, "%d bytes remained after slicing data\n", size);
    return lines;
}

398
static int teletext_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
399 400 401
{
    TeletextContext *ctx = avctx->priv_data;
    AVSubtitle      *sub = data;
402
    int             ret = 0;
403 404 405 406 407 408 409 410 411 412 413

    if (!ctx->vbi) {
        if (!(ctx->vbi = vbi_decoder_new()))
            return AVERROR(ENOMEM);
        if (!vbi_event_handler_add(ctx->vbi, VBI_EVENT_TTX_PAGE, handler, ctx)) {
            vbi_decoder_delete(ctx->vbi);
            ctx->vbi = NULL;
            return AVERROR(ENOMEM);
        }
    }

414 415 416
    if (avctx->pkt_timebase.den && pkt->pts != AV_NOPTS_VALUE)
        ctx->pts = av_rescale_q(pkt->pts, avctx->pkt_timebase, AV_TIME_BASE_Q);

417 418 419 420
    if (pkt->size) {
        int lines;
        const int full_pes_size = pkt->size + 45; /* PES header is 45 bytes */

421
        // We allow unreasonably big packets, even if the standard only allows a max size of 1472
422
        if (full_pes_size < 184 || full_pes_size > 65504 || full_pes_size % 184 != 0)
423
            return AVERROR_INVALIDDATA;
424

425 426
        ctx->handler_ret = pkt->size;

427 428 429 430 431
        if (data_identifier_is_teletext(*pkt->data)) {
            if ((lines = slice_to_vbi_lines(ctx, pkt->data + 1, pkt->size - 1)) < 0)
                return lines;
            av_dlog(avctx, "ctx=%p buf_size=%d lines=%u pkt_pts=%7.3f\n",
                    ctx, pkt->size, lines, (double)pkt->pts/90000.0);
432
            if (lines > 0) {
433
#ifdef DEBUG
434
                int i;
435 436 437 438
                av_log(avctx, AV_LOG_DEBUG, "line numbers:");
                for(i = 0; i < lines; i++)
                    av_log(avctx, AV_LOG_DEBUG, " %d", ctx->sliced[i].line);
                av_log(avctx, AV_LOG_DEBUG, "\n");
439
#endif
440
                vbi_decode(ctx->vbi, ctx->sliced, lines, 0.0);
441 442
                ctx->lines_processed += lines;
            }
443
        }
444
        ctx->pts = AV_NOPTS_VALUE;
445
        ret = ctx->handler_ret;
446
    }
447

448 449 450
    if (ret < 0)
        return ret;

451
    // is there a subtitle to pass?
452 453
    if (ctx->nb_pages) {
        int i;
454
        sub->format = ctx->format_id;
455 456 457
        sub->start_display_time = 0;
        sub->end_display_time = ctx->sub_duration;
        sub->num_rects = 0;
458
        sub->pts = ctx->pages->pts;
459

460
        if (ctx->pages->sub_rect->type != SUBTITLE_NONE) {
461
            sub->rects = av_malloc(sizeof(*sub->rects));
462 463
            if (sub->rects) {
                sub->num_rects = 1;
464
                sub->rects[0] = ctx->pages->sub_rect;
465 466
            } else {
                ret = AVERROR(ENOMEM);
467 468 469 470 471 472
            }
        } else {
            av_log(avctx, AV_LOG_DEBUG, "sending empty sub\n");
            sub->rects = NULL;
        }
        if (!sub->rects) // no rect was passed
473 474 475 476 477
            subtitle_rect_free(&ctx->pages->sub_rect);

        for (i = 0; i < ctx->nb_pages - 1; i++)
            ctx->pages[i] = ctx->pages[i + 1];
        ctx->nb_pages--;
478

479 480
        if (ret >= 0)
            *data_size = 1;
481 482 483
    } else
        *data_size = 0;

484
    return ret;
485 486 487 488 489 490 491 492 493 494 495 496 497
}

static int teletext_init_decoder(AVCodecContext *avctx)
{
    TeletextContext *ctx = avctx->priv_data;
    unsigned int maj, min, rev;

    vbi_version(&maj, &min, &rev);
    if (!(maj > 0 || min > 2 || min == 2 && rev >= 26)) {
        av_log(avctx, AV_LOG_ERROR, "decoder needs zvbi version >= 0.2.26.\n");
        return AVERROR_EXTERNAL;
    }

498 499 500 501 502
    if (ctx->format_id == 0) {
        avctx->width  = 41 * BITMAP_CHAR_WIDTH;
        avctx->height = 25 * BITMAP_CHAR_HEIGHT;
    }

503
    ctx->vbi = NULL;
504
    ctx->pts = AV_NOPTS_VALUE;
505 506 507 508 509 510 511 512

#ifdef DEBUG
    {
        char *t;
        ctx->ex = vbi_export_new("text", &t);
    }
#endif
    av_log(avctx, AV_LOG_VERBOSE, "page filter: %s\n", ctx->pgno);
513
    return (ctx->format_id == 1) ? ff_ass_subtitle_header_default(avctx) : 0;
514 515 516 517 518 519
}

static int teletext_close_decoder(AVCodecContext *avctx)
{
    TeletextContext *ctx = avctx->priv_data;

520
    av_dlog(avctx, "lines_total=%u\n", ctx->lines_processed);
521 522 523
    while (ctx->nb_pages)
        subtitle_rect_free(&ctx->pages[--ctx->nb_pages].sub_rect);
    av_freep(&ctx->pages);
524 525 526

    vbi_decoder_delete(ctx->vbi);
    ctx->vbi = NULL;
527
    ctx->pts = AV_NOPTS_VALUE;
528 529 530 531 532 533 534 535 536 537 538 539 540
    return 0;
}

static void teletext_flush(AVCodecContext *avctx)
{
    teletext_close_decoder(avctx);
}

#define OFFSET(x) offsetof(TeletextContext, x)
#define SD AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
    {"txt_page",        "list of teletext page numbers to decode, * is all", OFFSET(pgno),           AV_OPT_TYPE_STRING, {.str = "*"},      0, 0,        SD},
    {"txt_chop_top",    "discards the top teletext line",                    OFFSET(chop_top),       AV_OPT_TYPE_INT,    {.i64 = 1},        0, 1,        SD},
541 542 543
    {"txt_format",      "format of the subtitles (bitmap or text)",          OFFSET(format_id),      AV_OPT_TYPE_INT,    {.i64 = 0},        0, 1,        SD,  "txt_format"},
    {"bitmap",          NULL,                                                0,                      AV_OPT_TYPE_CONST,  {.i64 = 0},        0, 0,        SD,  "txt_format"},
    {"text",            NULL,                                                0,                      AV_OPT_TYPE_CONST,  {.i64 = 1},        0, 0,        SD,  "txt_format"},
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
    {"txt_left",        "x offset of generated bitmaps",                     OFFSET(x_offset),       AV_OPT_TYPE_INT,    {.i64 = 0},        0, 65535,    SD},
    {"txt_top",         "y offset of generated bitmaps",                     OFFSET(y_offset),       AV_OPT_TYPE_INT,    {.i64 = 0},        0, 65535,    SD},
    {"txt_chop_spaces", "chops leading and trailing spaces from text",       OFFSET(chop_spaces),    AV_OPT_TYPE_INT,    {.i64 = 1},        0, 1,        SD},
    {"txt_duration",    "display duration of teletext pages in msecs",       OFFSET(sub_duration),   AV_OPT_TYPE_INT,    {.i64 = 30000},    0, 86400000, SD},
    {"txt_transparent", "force transparent background of the teletext",      OFFSET(transparent_bg), AV_OPT_TYPE_INT,    {.i64 = 0},        0, 1,        SD},
    { NULL },
};

static const AVClass teletext_class = {
    .class_name = "libzvbi_teletextdec",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_libzvbi_teletext_decoder = {
    .name      = "libzvbi_teletextdec",
561
    .long_name = NULL_IF_CONFIG_SMALL("Libzvbi DVB teletext decoder"),
562
    .type      = AVMEDIA_TYPE_SUBTITLE,
563
    .id        = AV_CODEC_ID_DVB_TELETEXT,
564 565 566 567
    .priv_data_size = sizeof(TeletextContext),
    .init      = teletext_init_decoder,
    .close     = teletext_close_decoder,
    .decode    = teletext_decode_frame,
568
    .capabilities = CODEC_CAP_DELAY,
569 570 571
    .flush     = teletext_flush,
    .priv_class= &teletext_class,
};