GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dvbsubdec.c Lines: 479 843 56.8 %
Date: 2021-04-20 15:25:36 Branches: 269 589 45.7 %

Line Branch Exec Source
1
/*
2
 * DVB subtitle decoding
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
22
#include "avcodec.h"
23
#include "get_bits.h"
24
#include "bytestream.h"
25
#include "internal.h"
26
#include "libavutil/colorspace.h"
27
#include "libavutil/imgutils.h"
28
#include "libavutil/opt.h"
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_DISPLAYDEFINITION_SEGMENT 0x14
35
#define DVBSUB_DISPLAY_SEGMENT  0x80
36
37
#define cm (ff_crop_tab + MAX_NEG_CROP)
38
39
#define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
40
41
typedef struct DVBSubCLUT {
42
    int id;
43
    int version;
44
45
    uint32_t clut4[4];
46
    uint32_t clut16[16];
47
    uint32_t clut256[256];
48
49
    struct DVBSubCLUT *next;
50
} DVBSubCLUT;
51
52
static DVBSubCLUT default_clut;
53
54
typedef struct DVBSubObjectDisplay {
55
    int object_id;
56
    int region_id;
57
58
    int x_pos;
59
    int y_pos;
60
61
    int fgcolor;
62
    int bgcolor;
63
64
    struct DVBSubObjectDisplay *region_list_next;
65
    struct DVBSubObjectDisplay *object_list_next;
66
} DVBSubObjectDisplay;
67
68
typedef struct DVBSubObject {
69
    int id;
70
    int version;
71
72
    int type;
73
74
    DVBSubObjectDisplay *display_list;
75
76
    struct DVBSubObject *next;
77
} DVBSubObject;
78
79
typedef struct DVBSubRegionDisplay {
80
    int region_id;
81
82
    int x_pos;
83
    int y_pos;
84
85
    struct DVBSubRegionDisplay *next;
86
} DVBSubRegionDisplay;
87
88
typedef struct DVBSubRegion {
89
    int id;
90
    int version;
91
92
    int width;
93
    int height;
94
    int depth;
95
96
    int clut;
97
    int bgcolor;
98
99
    uint8_t computed_clut[4*256];
100
    int has_computed_clut;
101
102
    uint8_t *pbuf;
103
    int buf_size;
104
    int dirty;
105
106
    DVBSubObjectDisplay *display_list;
107
108
    struct DVBSubRegion *next;
109
} DVBSubRegion;
110
111
typedef struct DVBSubDisplayDefinition {
112
    int version;
113
114
    int x;
115
    int y;
116
    int width;
117
    int height;
118
} DVBSubDisplayDefinition;
119
120
typedef struct DVBSubContext {
121
    AVClass *class;
122
    int composition_id;
123
    int ancillary_id;
124
125
    int version;
126
    int time_out;
127
    int compute_edt; /**< if 1 end display time calculated using pts
128
                          if 0 (Default) calculated using time out */
129
    int compute_clut;
130
    int clut_count2[257][256];
131
    int substream;
132
    int64_t prev_start;
133
    DVBSubRegion *region_list;
134
    DVBSubCLUT   *clut_list;
135
    DVBSubObject *object_list;
136
137
    DVBSubRegionDisplay *display_list;
138
    DVBSubDisplayDefinition *display_definition;
139
} DVBSubContext;
140
141
142
126
static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
143
{
144
126
    DVBSubObject *ptr = ctx->object_list;
145
146

162
    while (ptr && ptr->id != object_id) {
147
36
        ptr = ptr->next;
148
    }
149
150
126
    return ptr;
151
}
152
153
79
static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
154
{
155
79
    DVBSubCLUT *ptr = ctx->clut_list;
156
157

115
    while (ptr && ptr->id != clut_id) {
158
36
        ptr = ptr->next;
159
    }
160
161
79
    return ptr;
162
}
163
164
273
static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
165
{
166
273
    DVBSubRegion *ptr = ctx->region_list;
167
168

906
    while (ptr && ptr->id != region_id) {
169
633
        ptr = ptr->next;
170
    }
171
172
273
    return ptr;
173
}
174
175
85
static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
176
{
177
    DVBSubObject *object, *obj2, **obj2_ptr;
178
    DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;
179
180
127
    while (region->display_list) {
181
42
        display = region->display_list;
182
183
42
        object = get_object(ctx, display->object_id);
184
185
42
        if (object) {
186
42
            obj_disp_ptr = &object->display_list;
187
42
            obj_disp = *obj_disp_ptr;
188
189

42
            while (obj_disp && obj_disp != display) {
190
                obj_disp_ptr = &obj_disp->object_list_next;
191
                obj_disp = *obj_disp_ptr;
192
            }
193
194
42
            if (obj_disp) {
195
42
                *obj_disp_ptr = obj_disp->object_list_next;
196
197
42
                if (!object->display_list) {
198
42
                    obj2_ptr = &ctx->object_list;
199
42
                    obj2 = *obj2_ptr;
200
201
42
                    while (obj2 != object) {
202
                        av_assert0(obj2);
203
                        obj2_ptr = &obj2->next;
204
                        obj2 = *obj2_ptr;
205
                    }
206
207
42
                    *obj2_ptr = obj2->next;
208
209
42
                    av_freep(&obj2);
210
                }
211
            }
212
        }
213
214
42
        region->display_list = display->region_list_next;
215
216
42
        av_freep(&display);
217
    }
218
219
85
}
220
221
11
static void delete_cluts(DVBSubContext *ctx)
222
{
223
24
    while (ctx->clut_list) {
224
13
        DVBSubCLUT *clut = ctx->clut_list;
225
226
13
        ctx->clut_list = clut->next;
227
228
13
        av_freep(&clut);
229
    }
230
11
}
231
232
11
static void delete_objects(DVBSubContext *ctx)
233
{
234
11
    while (ctx->object_list) {
235
        DVBSubObject *object = ctx->object_list;
236
237
        ctx->object_list = object->next;
238
239
        av_freep(&object);
240
    }
241
11
}
242
243
11
static void delete_regions(DVBSubContext *ctx)
244
{
245
39
    while (ctx->region_list) {
246
28
        DVBSubRegion *region = ctx->region_list;
247
248
28
        ctx->region_list = region->next;
249
250
28
        delete_region_display_list(ctx, region);
251
252
28
        av_freep(&region->pbuf);
253
28
        av_freep(&region);
254
    }
255
11
}
256
257
4
static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
258
{
259
4
    int i, r, g, b, a = 0;
260
4
    DVBSubContext *ctx = avctx->priv_data;
261
262
4
    if (ctx->substream < 0) {
263
4
        ctx->composition_id = -1;
264
4
        ctx->ancillary_id   = -1;
265
    } else if (!avctx->extradata || (avctx->extradata_size < 4) || ((avctx->extradata_size % 5 != 0) && (avctx->extradata_size != 4))) {
266
        av_log(avctx, AV_LOG_WARNING, "Invalid DVB subtitles stream extradata!\n");
267
        ctx->composition_id = -1;
268
        ctx->ancillary_id   = -1;
269
    } else {
270
        if (avctx->extradata_size > 5*ctx->substream + 2) {
271
            ctx->composition_id = AV_RB16(avctx->extradata + 5*ctx->substream);
272
            ctx->ancillary_id   = AV_RB16(avctx->extradata + 5*ctx->substream + 2);
273
        } else {
274
            av_log(avctx, AV_LOG_WARNING, "Selected DVB subtitles sub-stream %d is not available\n", ctx->substream);
275
            ctx->composition_id = AV_RB16(avctx->extradata);
276
            ctx->ancillary_id   = AV_RB16(avctx->extradata + 2);
277
        }
278
    }
279
280
4
    ctx->version = -1;
281
4
    ctx->prev_start = AV_NOPTS_VALUE;
282
283
4
    default_clut.id = -1;
284
4
    default_clut.next = NULL;
285
286
4
    default_clut.clut4[0] = RGBA(  0,   0,   0,   0);
287
4
    default_clut.clut4[1] = RGBA(255, 255, 255, 255);
288
4
    default_clut.clut4[2] = RGBA(  0,   0,   0, 255);
289
4
    default_clut.clut4[3] = RGBA(127, 127, 127, 255);
290
291
4
    default_clut.clut16[0] = RGBA(  0,   0,   0,   0);
292
64
    for (i = 1; i < 16; i++) {
293
60
        if (i < 8) {
294
28
            r = (i & 1) ? 255 : 0;
295
28
            g = (i & 2) ? 255 : 0;
296
28
            b = (i & 4) ? 255 : 0;
297
        } else {
298
32
            r = (i & 1) ? 127 : 0;
299
32
            g = (i & 2) ? 127 : 0;
300
32
            b = (i & 4) ? 127 : 0;
301
        }
302
60
        default_clut.clut16[i] = RGBA(r, g, b, 255);
303
    }
304
305
4
    default_clut.clut256[0] = RGBA(  0,   0,   0,   0);
306
1024
    for (i = 1; i < 256; i++) {
307
1020
        if (i < 8) {
308
28
            r = (i & 1) ? 255 : 0;
309
28
            g = (i & 2) ? 255 : 0;
310
28
            b = (i & 4) ? 255 : 0;
311
28
            a = 63;
312
        } else {
313

992
            switch (i & 0x88) {
314
224
            case 0x00:
315

224
                r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
316

224
                g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
317

224
                b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
318
224
                a = 255;
319
224
                break;
320
256
            case 0x08:
321

256
                r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
322

256
                g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
323

256
                b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
324
256
                a = 127;
325
256
                break;
326
256
            case 0x80:
327

256
                r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
328

256
                g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
329

256
                b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
330
256
                a = 255;
331
256
                break;
332
256
            case 0x88:
333

256
                r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
334

256
                g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
335

256
                b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
336
256
                a = 255;
337
256
                break;
338
            }
339
1020
        }
340
1020
        default_clut.clut256[i] = RGBA(r, g, b, a);
341
    }
342
343
4
    return 0;
344
}
345
346
4
static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
347
{
348
4
    DVBSubContext *ctx = avctx->priv_data;
349
    DVBSubRegionDisplay *display;
350
351
4
    delete_regions(ctx);
352
353
4
    delete_objects(ctx);
354
355
4
    delete_cluts(ctx);
356
357
4
    av_freep(&ctx->display_definition);
358
359
4
    while (ctx->display_list) {
360
        display = ctx->display_list;
361
        ctx->display_list = display->next;
362
363
        av_freep(&display);
364
    }
365
366
4
    return 0;
367
}
368
369
static int dvbsub_read_2bit_string(AVCodecContext *avctx,
370
                                   uint8_t *destbuf, int dbuf_len,
371
                                   const uint8_t **srcbuf, int buf_size,
372
                                   int non_mod, uint8_t *map_table, int x_pos)
373
{
374
    GetBitContext gb;
375
376
    int bits;
377
    int run_length;
378
    int pixels_read = x_pos;
379
380
    init_get_bits(&gb, *srcbuf, buf_size << 3);
381
382
    destbuf += x_pos;
383
384
    while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
385
        bits = get_bits(&gb, 2);
386
387
        if (bits) {
388
            if (non_mod != 1 || bits != 1) {
389
                if (map_table)
390
                    *destbuf++ = map_table[bits];
391
                else
392
                    *destbuf++ = bits;
393
            }
394
            pixels_read++;
395
        } else {
396
            bits = get_bits1(&gb);
397
            if (bits == 1) {
398
                run_length = get_bits(&gb, 3) + 3;
399
                bits = get_bits(&gb, 2);
400
401
                if (non_mod == 1 && bits == 1)
402
                    pixels_read += run_length;
403
                else {
404
                    if (map_table)
405
                        bits = map_table[bits];
406
                    while (run_length-- > 0 && pixels_read < dbuf_len) {
407
                        *destbuf++ = bits;
408
                        pixels_read++;
409
                    }
410
                }
411
            } else {
412
                bits = get_bits1(&gb);
413
                if (bits == 0) {
414
                    bits = get_bits(&gb, 2);
415
                    if (bits == 2) {
416
                        run_length = get_bits(&gb, 4) + 12;
417
                        bits = get_bits(&gb, 2);
418
419
                        if (non_mod == 1 && bits == 1)
420
                            pixels_read += run_length;
421
                        else {
422
                            if (map_table)
423
                                bits = map_table[bits];
424
                            while (run_length-- > 0 && pixels_read < dbuf_len) {
425
                                *destbuf++ = bits;
426
                                pixels_read++;
427
                            }
428
                        }
429
                    } else if (bits == 3) {
430
                        run_length = get_bits(&gb, 8) + 29;
431
                        bits = get_bits(&gb, 2);
432
433
                        if (non_mod == 1 && bits == 1)
434
                            pixels_read += run_length;
435
                        else {
436
                            if (map_table)
437
                                bits = map_table[bits];
438
                            while (run_length-- > 0 && pixels_read < dbuf_len) {
439
                                *destbuf++ = bits;
440
                                pixels_read++;
441
                            }
442
                        }
443
                    } else if (bits == 1) {
444
                        if (map_table)
445
                            bits = map_table[0];
446
                        else
447
                            bits = 0;
448
                        run_length = 2;
449
                        while (run_length-- > 0 && pixels_read < dbuf_len) {
450
                            *destbuf++ = bits;
451
                            pixels_read++;
452
                        }
453
                    } else {
454
                        (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
455
                        return pixels_read;
456
                    }
457
                } else {
458
                    if (map_table)
459
                        bits = map_table[0];
460
                    else
461
                        bits = 0;
462
                    *destbuf++ = bits;
463
                    pixels_read++;
464
                }
465
            }
466
        }
467
    }
468
469
    if (get_bits(&gb, 6))
470
        av_log(avctx, AV_LOG_ERROR, "line overflow\n");
471
472
    (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
473
474
    return pixels_read;
475
}
476
477
1512
static int dvbsub_read_4bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len,
478
                                   const uint8_t **srcbuf, int buf_size,
479
                                   int non_mod, uint8_t *map_table, int x_pos)
480
{
481
    GetBitContext gb;
482
483
    int bits;
484
    int run_length;
485
1512
    int pixels_read = x_pos;
486
487
1512
    init_get_bits(&gb, *srcbuf, buf_size << 3);
488
489
1512
    destbuf += x_pos;
490
491

70104
    while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
492
70104
        bits = get_bits(&gb, 4);
493
494
70104
        if (bits) {
495

62235
            if (non_mod != 1 || bits != 1) {
496
62235
                if (map_table)
497
                    *destbuf++ = map_table[bits];
498
                else
499
62235
                    *destbuf++ = bits;
500
            }
501
62235
            pixels_read++;
502
        } else {
503
7869
            bits = get_bits1(&gb);
504
7869
            if (bits == 0) {
505
1512
                run_length = get_bits(&gb, 3);
506
507
1512
                if (run_length == 0) {
508
1512
                    (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
509
1512
                    return pixels_read;
510
                }
511
512
                run_length += 2;
513
514
                if (map_table)
515
                    bits = map_table[0];
516
                else
517
                    bits = 0;
518
519
                while (run_length-- > 0 && pixels_read < dbuf_len) {
520
                    *destbuf++ = bits;
521
                    pixels_read++;
522
                }
523
            } else {
524
6357
                bits = get_bits1(&gb);
525
6357
                if (bits == 0) {
526
3538
                    run_length = get_bits(&gb, 2) + 4;
527
3538
                    bits = get_bits(&gb, 4);
528
529

3538
                    if (non_mod == 1 && bits == 1)
530
                        pixels_read += run_length;
531
                    else {
532
3538
                        if (map_table)
533
                            bits = map_table[bits];
534

20875
                        while (run_length-- > 0 && pixels_read < dbuf_len) {
535
17337
                            *destbuf++ = bits;
536
17337
                            pixels_read++;
537
                        }
538
                    }
539
                } else {
540
2819
                    bits = get_bits(&gb, 2);
541
2819
                    if (bits == 2) {
542
1741
                        run_length = get_bits(&gb, 4) + 9;
543
1741
                        bits = get_bits(&gb, 4);
544
545

1741
                        if (non_mod == 1 && bits == 1)
546
                            pixels_read += run_length;
547
                        else {
548
1741
                            if (map_table)
549
                                bits = map_table[bits];
550

23107
                            while (run_length-- > 0 && pixels_read < dbuf_len) {
551
21366
                                *destbuf++ = bits;
552
21366
                                pixels_read++;
553
                            }
554
                        }
555
1078
                    } else if (bits == 3) {
556
1078
                        run_length = get_bits(&gb, 8) + 25;
557
1078
                        bits = get_bits(&gb, 4);
558
559

1078
                        if (non_mod == 1 && bits == 1)
560
                            pixels_read += run_length;
561
                        else {
562
1078
                            if (map_table)
563
                                bits = map_table[bits];
564

92020
                            while (run_length-- > 0 && pixels_read < dbuf_len) {
565
90942
                                *destbuf++ = bits;
566
90942
                                pixels_read++;
567
                            }
568
                        }
569
                    } else if (bits == 1) {
570
                        if (map_table)
571
                            bits = map_table[0];
572
                        else
573
                            bits = 0;
574
                        run_length = 2;
575
                        while (run_length-- > 0 && pixels_read < dbuf_len) {
576
                            *destbuf++ = bits;
577
                            pixels_read++;
578
                        }
579
                    } else {
580
                        if (map_table)
581
                            bits = map_table[0];
582
                        else
583
                            bits = 0;
584
                        *destbuf++ = bits;
585
                        pixels_read ++;
586
                    }
587
                }
588
            }
589
        }
590
    }
591
592
    if (get_bits(&gb, 8))
593
        av_log(avctx, AV_LOG_ERROR, "line overflow\n");
594
595
    (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
596
597
    return pixels_read;
598
}
599
600
static int dvbsub_read_8bit_string(AVCodecContext *avctx,
601
                                   uint8_t *destbuf, int dbuf_len,
602
                                    const uint8_t **srcbuf, int buf_size,
603
                                    int non_mod, uint8_t *map_table, int x_pos)
604
{
605
    const uint8_t *sbuf_end = (*srcbuf) + buf_size;
606
    int bits;
607
    int run_length;
608
    int pixels_read = x_pos;
609
610
    destbuf += x_pos;
611
612
    while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
613
        bits = *(*srcbuf)++;
614
615
        if (bits) {
616
            if (non_mod != 1 || bits != 1) {
617
                if (map_table)
618
                    *destbuf++ = map_table[bits];
619
                else
620
                    *destbuf++ = bits;
621
            }
622
            pixels_read++;
623
        } else {
624
            bits = *(*srcbuf)++;
625
            run_length = bits & 0x7f;
626
            if ((bits & 0x80) == 0) {
627
                if (run_length == 0) {
628
                    return pixels_read;
629
                }
630
631
                bits = 0;
632
            } else {
633
                bits = *(*srcbuf)++;
634
            }
635
            if (non_mod == 1 && bits == 1)
636
                pixels_read += run_length;
637
            else {
638
                if (map_table)
639
                    bits = map_table[bits];
640
                while (run_length-- > 0 && pixels_read < dbuf_len) {
641
                    *destbuf++ = bits;
642
                    pixels_read++;
643
                }
644
            }
645
        }
646
    }
647
648
    if (*(*srcbuf)++)
649
        av_log(avctx, AV_LOG_ERROR, "line overflow\n");
650
651
    return pixels_read;
652
}
653
654
static void compute_default_clut(DVBSubContext *ctx, uint8_t *clut, AVSubtitleRect *rect, int w, int h)
655
{
656
    uint8_t list[256] = {0};
657
    uint8_t list_inv[256];
658
    int counttab[256] = {0};
659
    int (*counttab2)[256] = ctx->clut_count2;
660
    int count, i, x, y;
661
    ptrdiff_t stride = rect->linesize[0];
662
663
    memset(ctx->clut_count2, 0 , sizeof(ctx->clut_count2));
664
665
#define V(x,y) rect->data[0][(x) + (y)*stride]
666
    for (y = 0; y<h; y++) {
667
        for (x = 0; x<w; x++) {
668
            int v = V(x,y) + 1;
669
            int vl = x     ? V(x-1,y) + 1 : 0;
670
            int vr = x+1<w ? V(x+1,y) + 1 : 0;
671
            int vt = y     ? V(x,y-1) + 1 : 0;
672
            int vb = y+1<h ? V(x,y+1) + 1 : 0;
673
            counttab[v-1] += !!((v!=vl) + (v!=vr) + (v!=vt) + (v!=vb));
674
            counttab2[vl][v-1] ++;
675
            counttab2[vr][v-1] ++;
676
            counttab2[vt][v-1] ++;
677
            counttab2[vb][v-1] ++;
678
        }
679
    }
680
#define L(x,y) list[d[(x) + (y)*stride]]
681
682
    for (i = 0; i<256; i++) {
683
        counttab2[i+1][i] = 0;
684
    }
685
    for (i = 0; i<256; i++) {
686
        int bestscore = 0;
687
        int bestv = 0;
688
689
        for (x = 0; x < 256; x++) {
690
            int scorev = 0;
691
            if (list[x])
692
                continue;
693
            scorev += counttab2[0][x];
694
            for (y = 0; y < 256; y++) {
695
                scorev += list[y] * counttab2[y+1][x];
696
            }
697
698
            if (scorev) {
699
                int score = 1024LL*scorev / counttab[x];
700
                if (score > bestscore) {
701
                    bestscore = score;
702
                    bestv = x;
703
                }
704
            }
705
        }
706
        if (!bestscore)
707
            break;
708
        list    [ bestv ] = 1;
709
        list_inv[     i ] = bestv;
710
    }
711
712
    count = FFMAX(i - 1, 1);
713
    for (i--; i >= 0; i--) {
714
        int v = i * 255 / count;
715
        AV_WN32(clut + 4*list_inv[i], RGBA(v/2,v,v/2,v));
716
    }
717
}
718
719
720
46
static int save_subtitle_set(AVCodecContext *avctx, AVSubtitle *sub, int *got_output)
721
{
722
46
    DVBSubContext *ctx = avctx->priv_data;
723
    DVBSubRegionDisplay *display;
724
46
    DVBSubDisplayDefinition *display_def = ctx->display_definition;
725
    DVBSubRegion *region;
726
    AVSubtitleRect *rect;
727
    DVBSubCLUT *clut;
728
    uint32_t *clut_table;
729
    int i;
730
46
    int offset_x=0, offset_y=0;
731
46
    int ret = 0;
732
733
734
46
    if (display_def) {
735
        offset_x = display_def->x;
736
        offset_y = display_def->y;
737
    }
738
739
    /* Not touching AVSubtitles again*/
740
46
    if (sub->num_rects) {
741
        avpriv_request_sample(ctx, "Different Version of Segment asked Twice");
742
        return AVERROR_PATCHWELCOME;
743
    }
744
112
    for (display = ctx->display_list; display; display = display->next) {
745
66
        region = get_region(ctx, display->region_id);
746

66
        if (region && region->dirty)
747
66
            sub->num_rects++;
748
    }
749
750
46
    if (ctx->compute_edt == 0) {
751
        sub->end_display_time = ctx->time_out * 1000;
752
        *got_output = 1;
753
46
    } else if (ctx->prev_start != AV_NOPTS_VALUE) {
754
45
        sub->end_display_time = av_rescale_q((sub->pts - ctx->prev_start ), AV_TIME_BASE_Q, (AVRational){ 1, 1000 }) - 1;
755
45
        *got_output = 1;
756
    }
757
46
    if (sub->num_rects > 0) {
758
759
36
        sub->rects = av_mallocz_array(sizeof(*sub->rects), sub->num_rects);
760
36
        if (!sub->rects) {
761
            ret = AVERROR(ENOMEM);
762
            goto fail;
763
        }
764
765
102
        for (i = 0; i < sub->num_rects; i++) {
766
66
            sub->rects[i] = av_mallocz(sizeof(*sub->rects[i]));
767
66
            if (!sub->rects[i]) {
768
                ret = AVERROR(ENOMEM);
769
                goto fail;
770
            }
771
        }
772
773
36
        i = 0;
774
775
102
        for (display = ctx->display_list; display; display = display->next) {
776
66
            region = get_region(ctx, display->region_id);
777
778
66
            if (!region)
779
                continue;
780
781
66
            if (!region->dirty)
782
                continue;
783
784
66
            rect = sub->rects[i];
785
66
            rect->x = display->x_pos + offset_x;
786
66
            rect->y = display->y_pos + offset_y;
787
66
            rect->w = region->width;
788
66
            rect->h = region->height;
789
66
            rect->nb_colors = (1 << region->depth);
790
66
            rect->type      = SUBTITLE_BITMAP;
791
66
            rect->linesize[0] = region->width;
792
793
66
            clut = get_clut(ctx, region->clut);
794
795
66
            if (!clut)
796
                clut = &default_clut;
797
798
66
            switch (region->depth) {
799
            case 2:
800
                clut_table = clut->clut4;
801
                break;
802
            case 8:
803
                clut_table = clut->clut256;
804
                break;
805
66
            case 4:
806
            default:
807
66
                clut_table = clut->clut16;
808
66
                break;
809
            }
810
811
66
            rect->data[1] = av_mallocz(AVPALETTE_SIZE);
812
66
            if (!rect->data[1]) {
813
                ret = AVERROR(ENOMEM);
814
                goto fail;
815
            }
816
66
            memcpy(rect->data[1], clut_table, (1 << region->depth) * sizeof(*clut_table));
817
818
66
            rect->data[0] = av_malloc(region->buf_size);
819
66
            if (!rect->data[0]) {
820
                ret = AVERROR(ENOMEM);
821
                goto fail;
822
            }
823
824
66
            memcpy(rect->data[0], region->pbuf, region->buf_size);
825
826

66
            if ((clut == &default_clut && ctx->compute_clut < 0) || ctx->compute_clut == 1) {
827
                if (!region->has_computed_clut) {
828
                    compute_default_clut(ctx, region->computed_clut, rect, rect->w, rect->h);
829
                    region->has_computed_clut = 1;
830
                }
831
832
                memcpy(rect->data[1], region->computed_clut, sizeof(region->computed_clut));
833
            }
834
835
#if FF_API_AVPICTURE
836
FF_DISABLE_DEPRECATION_WARNINGS
837
{
838
            int j;
839
330
            for (j = 0; j < 4; j++) {
840
264
                rect->pict.data[j] = rect->data[j];
841
264
                rect->pict.linesize[j] = rect->linesize[j];
842
            }
843
}
844
FF_ENABLE_DEPRECATION_WARNINGS
845
#endif
846
847
66
            i++;
848
        }
849
    }
850
851
46
    return 0;
852
fail:
853
    if (sub->rects) {
854
        for (i=0; i < sub->num_rects; i++) {
855
            rect = sub->rects[i];
856
            if (rect) {
857
                av_freep(&rect->data[0]);
858
                av_freep(&rect->data[1]);
859
            }
860
            av_freep(&sub->rects[i]);
861
        }
862
        av_freep(&sub->rects);
863
    }
864
    sub->num_rects = 0;
865
    return ret;
866
}
867
868
84
static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
869
                                          const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
870
{
871
84
    DVBSubContext *ctx = avctx->priv_data;
872
873
84
    DVBSubRegion *region = get_region(ctx, display->region_id);
874
84
    const uint8_t *buf_end = buf + buf_size;
875
    uint8_t *pbuf;
876
    int x_pos, y_pos;
877
    int i;
878
879
84
    uint8_t map2to4[] = { 0x0,  0x7,  0x8,  0xf};
880
84
    uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
881
84
    uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
882
                         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
883
    uint8_t *map_table;
884
885
#if 0
886
    ff_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
887
            top_bottom ? "bottom" : "top");
888
889
    for (i = 0; i < buf_size; i++) {
890
        if (i % 16 == 0)
891
            ff_dlog(avctx, "0x%8p: ", buf+i);
892
893
        ff_dlog(avctx, "%02x ", buf[i]);
894
        if (i % 16 == 15)
895
            ff_dlog(avctx, "\n");
896
    }
897
898
    if (i % 16)
899
        ff_dlog(avctx, "\n");
900
#endif
901
902
84
    if (!region)
903
        return;
904
905
84
    pbuf = region->pbuf;
906
84
    region->dirty = 1;
907
908
84
    x_pos = display->x_pos;
909
84
    y_pos = display->y_pos;
910
911
84
    y_pos += top_bottom;
912
913
3108
    while (buf < buf_end) {
914

3024
        if ((*buf!=0xf0 && x_pos >= region->width) || y_pos >= region->height) {
915
            av_log(avctx, AV_LOG_ERROR, "Invalid object location! %d-%d %d-%d %02x\n", x_pos, region->width, y_pos, region->height, *buf);
916
            return;
917
        }
918
919


3024
        switch (*buf++) {
920
        case 0x10:
921
            if (region->depth == 8)
922
                map_table = map2to8;
923
            else if (region->depth == 4)
924
                map_table = map2to4;
925
            else
926
                map_table = NULL;
927
928
            x_pos = dvbsub_read_2bit_string(avctx, pbuf + (y_pos * region->width),
929
                                            region->width, &buf, buf_end - buf,
930
                                            non_mod, map_table, x_pos);
931
            break;
932
1512
        case 0x11:
933
1512
            if (region->depth < 4) {
934
                av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
935
                return;
936
            }
937
938
1512
            if (region->depth == 8)
939
                map_table = map4to8;
940
            else
941
1512
                map_table = NULL;
942
943
1512
            x_pos = dvbsub_read_4bit_string(avctx, pbuf + (y_pos * region->width),
944
1512
                                            region->width, &buf, buf_end - buf,
945
                                            non_mod, map_table, x_pos);
946
1512
            break;
947
        case 0x12:
948
            if (region->depth < 8) {
949
                av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
950
                return;
951
            }
952
953
            x_pos = dvbsub_read_8bit_string(avctx, pbuf + (y_pos * region->width),
954
                                            region->width, &buf, buf_end - buf,
955
                                            non_mod, NULL, x_pos);
956
            break;
957
958
        case 0x20:
959
            map2to4[0] = (*buf) >> 4;
960
            map2to4[1] = (*buf++) & 0xf;
961
            map2to4[2] = (*buf) >> 4;
962
            map2to4[3] = (*buf++) & 0xf;
963
            break;
964
        case 0x21:
965
            for (i = 0; i < 4; i++)
966
                map2to8[i] = *buf++;
967
            break;
968
        case 0x22:
969
            for (i = 0; i < 16; i++)
970
                map4to8[i] = *buf++;
971
            break;
972
973
1512
        case 0xf0:
974
1512
            x_pos = display->x_pos;
975
1512
            y_pos += 2;
976
1512
            break;
977
        default:
978
            av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
979
        }
980
    }
981
982
84
    if (ctx->compute_clut != -2)
983
84
        region->has_computed_clut = 0;
984
}
985
986
42
static int dvbsub_parse_object_segment(AVCodecContext *avctx,
987
                                       const uint8_t *buf, int buf_size)
988
{
989
42
    DVBSubContext *ctx = avctx->priv_data;
990
991
42
    const uint8_t *buf_end = buf + buf_size;
992
    int object_id;
993
    DVBSubObject *object;
994
    DVBSubObjectDisplay *display;
995
    int top_field_len, bottom_field_len;
996
997
    int coding_method, non_modifying_color;
998
999
42
    object_id = AV_RB16(buf);
1000
42
    buf += 2;
1001
1002
42
    object = get_object(ctx, object_id);
1003
1004
42
    if (!object)
1005
        return AVERROR_INVALIDDATA;
1006
1007
42
    coding_method = ((*buf) >> 2) & 3;
1008
42
    non_modifying_color = ((*buf++) >> 1) & 1;
1009
1010
42
    if (coding_method == 0) {
1011
42
        top_field_len = AV_RB16(buf);
1012
42
        buf += 2;
1013
42
        bottom_field_len = AV_RB16(buf);
1014
42
        buf += 2;
1015
1016
42
        if (buf + top_field_len + bottom_field_len > buf_end) {
1017
            av_log(avctx, AV_LOG_ERROR, "Field data size %d+%d too large\n", top_field_len, bottom_field_len);
1018
            return AVERROR_INVALIDDATA;
1019
        }
1020
1021
84
        for (display = object->display_list; display; display = display->object_list_next) {
1022
42
            const uint8_t *block = buf;
1023
42
            int bfl = bottom_field_len;
1024
1025
42
            dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
1026
                                            non_modifying_color);
1027
1028
42
            if (bottom_field_len > 0)
1029
42
                block = buf + top_field_len;
1030
            else
1031
                bfl = top_field_len;
1032
1033
42
            dvbsub_parse_pixel_data_block(avctx, display, block, bfl, 1,
1034
                                            non_modifying_color);
1035
        }
1036
    } else if (coding_method == 1) {
1037
        avpriv_report_missing_feature(avctx, "coded as a string of characters");
1038
        return AVERROR_PATCHWELCOME;
1039
    } else if (coding_method == 2) {
1040
        avpriv_report_missing_feature(avctx, "progressive coding of pixels");
1041
        return AVERROR_PATCHWELCOME;
1042
    } else {
1043
        av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
1044
        return AVERROR_INVALIDDATA;
1045
    }
1046
1047
42
    return 0;
1048
}
1049
1050
13
static int dvbsub_parse_clut_segment(AVCodecContext *avctx,
1051
                                     const uint8_t *buf, int buf_size)
1052
{
1053
13
    DVBSubContext *ctx = avctx->priv_data;
1054
1055
13
    const uint8_t *buf_end = buf + buf_size;
1056
    int i, clut_id;
1057
    int version;
1058
    DVBSubCLUT *clut;
1059
    int entry_id, depth , full_range;
1060
    int y, cr, cb, alpha;
1061
    int r, g, b, r_add, g_add, b_add;
1062
1063
    ff_dlog(avctx, "DVB clut packet:\n");
1064
1065
741
    for (i=0; i < buf_size; i++) {
1066
        ff_dlog(avctx, "%02x ", buf[i]);
1067
728
        if (i % 16 == 15)
1068
            ff_dlog(avctx, "\n");
1069
    }
1070
1071
13
    if (i % 16)
1072
        ff_dlog(avctx, "\n");
1073
1074
13
    clut_id = *buf++;
1075
13
    version = ((*buf)>>4)&15;
1076
13
    buf += 1;
1077
1078
13
    clut = get_clut(ctx, clut_id);
1079
1080
13
    if (!clut) {
1081
13
        clut = av_malloc(sizeof(*clut));
1082
13
        if (!clut)
1083
            return AVERROR(ENOMEM);
1084
1085
13
        memcpy(clut, &default_clut, sizeof(*clut));
1086
1087
13
        clut->id = clut_id;
1088
13
        clut->version = -1;
1089
1090
13
        clut->next = ctx->clut_list;
1091
13
        ctx->clut_list = clut;
1092
    }
1093
1094
13
    if (clut->version != version) {
1095
1096
13
        clut->version = version;
1097
1098
130
        while (buf + 4 < buf_end) {
1099
117
            entry_id = *buf++;
1100
1101
117
            depth = (*buf) & 0xe0;
1102
1103
117
            if (depth == 0) {
1104
                av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
1105
            }
1106
1107
117
            full_range = (*buf++) & 1;
1108
1109
117
            if (full_range) {
1110
117
                y     = *buf++;
1111
117
                cr    = *buf++;
1112
117
                cb    = *buf++;
1113
117
                alpha = *buf++;
1114
            } else {
1115
                y     = buf[0] & 0xfc;
1116
                cr    = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
1117
                cb    = (buf[1] << 2) & 0xf0;
1118
                alpha = (buf[1] << 6) & 0xc0;
1119
1120
                buf += 2;
1121
            }
1122
1123
117
            if (y == 0)
1124
13
                alpha = 0xff;
1125
1126
117
            YUV_TO_RGB1_CCIR(cb, cr);
1127
117
            YUV_TO_RGB2_CCIR(r, g, b, y);
1128
1129
            ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
1130
117
            if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
1131
                ff_dlog(avctx, "More than one bit level marked: %x\n", depth);
1132
                if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)
1133
                    return AVERROR_INVALIDDATA;
1134
            }
1135
1136

117
            if (depth & 0x80 && entry_id < 4)
1137
                clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
1138

117
            else if (depth & 0x40 && entry_id < 16)
1139
117
                clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
1140
            else if (depth & 0x20)
1141
                clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
1142
        }
1143
    }
1144
1145
13
    return 0;
1146
}
1147
1148
1149
57
static int dvbsub_parse_region_segment(AVCodecContext *avctx,
1150
                                       const uint8_t *buf, int buf_size)
1151
{
1152
57
    DVBSubContext *ctx = avctx->priv_data;
1153
1154
57
    const uint8_t *buf_end = buf + buf_size;
1155
    int region_id, object_id;
1156
    int av_unused version;
1157
    DVBSubRegion *region;
1158
    DVBSubObject *object;
1159
    DVBSubObjectDisplay *display;
1160
    int fill;
1161
    int ret;
1162
1163
57
    if (buf_size < 10)
1164
        return AVERROR_INVALIDDATA;
1165
1166
57
    region_id = *buf++;
1167
1168
57
    region = get_region(ctx, region_id);
1169
1170
57
    if (!region) {
1171
28
        region = av_mallocz(sizeof(*region));
1172
28
        if (!region)
1173
            return AVERROR(ENOMEM);
1174
1175
28
        region->id = region_id;
1176
28
        region->version = -1;
1177
1178
28
        region->next = ctx->region_list;
1179
28
        ctx->region_list = region;
1180
    }
1181
1182
57
    version = ((*buf)>>4) & 15;
1183
57
    fill = ((*buf++) >> 3) & 1;
1184
1185
57
    region->width = AV_RB16(buf);
1186
57
    buf += 2;
1187
57
    region->height = AV_RB16(buf);
1188
57
    buf += 2;
1189
1190
57
    ret = av_image_check_size2(region->width, region->height, avctx->max_pixels, AV_PIX_FMT_PAL8, 0, avctx);
1191

57
    if (ret >= 0 && region->width * region->height * 2 > 320 * 1024 * 8) {
1192
        ret = AVERROR_INVALIDDATA;
1193
        av_log(avctx, AV_LOG_ERROR, "Pixel buffer memory constraint violated\n");
1194
    }
1195
57
    if (ret < 0) {
1196
        region->width= region->height= 0;
1197
        return ret;
1198
    }
1199
1200
57
    if (region->width * region->height != region->buf_size) {
1201
28
        av_free(region->pbuf);
1202
1203
28
        region->buf_size = region->width * region->height;
1204
1205
28
        region->pbuf = av_malloc(region->buf_size);
1206
28
        if (!region->pbuf) {
1207
            region->buf_size =
1208
            region->width =
1209
            region->height = 0;
1210
            return AVERROR(ENOMEM);
1211
        }
1212
1213
28
        fill = 1;
1214
28
        region->dirty = 0;
1215
    }
1216
1217
57
    region->depth = 1 << (((*buf++) >> 2) & 7);
1218

57
    if (region->depth < 2 || region->depth > 8) {
1219
        av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
1220
        region->depth= 4;
1221
    }
1222
57
    region->clut = *buf++;
1223
1224
57
    if (region->depth == 8) {
1225
        region->bgcolor = *buf++;
1226
        buf += 1;
1227
    } else {
1228
57
        buf += 1;
1229
1230
57
        if (region->depth == 4)
1231
57
            region->bgcolor = (((*buf++) >> 4) & 15);
1232
        else
1233
            region->bgcolor = (((*buf++) >> 2) & 3);
1234
    }
1235
1236
    ff_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1237
1238
57
    if (fill) {
1239
28
        memset(region->pbuf, region->bgcolor, region->buf_size);
1240
        ff_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
1241
    }
1242
1243
57
    delete_region_display_list(ctx, region);
1244
1245
99
    while (buf + 5 < buf_end) {
1246
42
        object_id = AV_RB16(buf);
1247
42
        buf += 2;
1248
1249
42
        object = get_object(ctx, object_id);
1250
1251
42
        if (!object) {
1252
42
            object = av_mallocz(sizeof(*object));
1253
42
            if (!object)
1254
                return AVERROR(ENOMEM);
1255
1256
42
            object->id = object_id;
1257
42
            object->next = ctx->object_list;
1258
42
            ctx->object_list = object;
1259
        }
1260
1261
42
        object->type = (*buf) >> 6;
1262
1263
42
        display = av_mallocz(sizeof(*display));
1264
42
        if (!display)
1265
            return AVERROR(ENOMEM);
1266
1267
42
        display->object_id = object_id;
1268
42
        display->region_id = region_id;
1269
1270
42
        display->x_pos = AV_RB16(buf) & 0xfff;
1271
42
        buf += 2;
1272
42
        display->y_pos = AV_RB16(buf) & 0xfff;
1273
42
        buf += 2;
1274
1275
42
        if (display->x_pos >= region->width ||
1276
42
            display->y_pos >= region->height) {
1277
            av_log(avctx, AV_LOG_ERROR, "Object outside region\n");
1278
            av_free(display);
1279
            return AVERROR_INVALIDDATA;
1280
        }
1281
1282

42
        if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {
1283
            display->fgcolor = *buf++;
1284
            display->bgcolor = *buf++;
1285
        }
1286
1287
42
        display->region_list_next = region->display_list;
1288
42
        region->display_list = display;
1289
1290
42
        display->object_list_next = object->display_list;
1291
42
        object->display_list = display;
1292
    }
1293
1294
57
    return 0;
1295
}
1296
1297
46
static int dvbsub_parse_page_segment(AVCodecContext *avctx,
1298
                                     const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
1299
{
1300
46
    DVBSubContext *ctx = avctx->priv_data;
1301
    DVBSubRegionDisplay *display;
1302
    DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
1303
1304
46
    const uint8_t *buf_end = buf + buf_size;
1305
    int region_id;
1306
    int page_state;
1307
    int timeout;
1308
    int version;
1309
1310
46
    if (buf_size < 1)
1311
        return AVERROR_INVALIDDATA;
1312
1313
46
    timeout = *buf++;
1314
46
    version = ((*buf)>>4) & 15;
1315
46
    page_state = ((*buf++) >> 2) & 3;
1316
1317
46
    if (ctx->version == version) {
1318
        return 0;
1319
    }
1320
1321
46
    ctx->time_out = timeout;
1322
46
    ctx->version = version;
1323
1324
    ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1325
1326
46
    if (ctx->compute_edt == 1)
1327
46
        save_subtitle_set(avctx, sub, got_output);
1328
1329

46
    if (page_state == 1 || page_state == 2) {
1330
7
        delete_regions(ctx);
1331
7
        delete_objects(ctx);
1332
7
        delete_cluts(ctx);
1333
    }
1334
1335
46
    tmp_display_list = ctx->display_list;
1336
46
    ctx->display_list = NULL;
1337
1338
112
    while (buf + 5 < buf_end) {
1339
66
        region_id = *buf++;
1340
66
        buf += 1;
1341
1342
66
        display = ctx->display_list;
1343

96
        while (display && display->region_id != region_id) {
1344
30
            display = display->next;
1345
        }
1346
66
        if (display) {
1347
            av_log(avctx, AV_LOG_ERROR, "duplicate region\n");
1348
            break;
1349
        }
1350
1351
66
        display = tmp_display_list;
1352
66
        tmp_ptr = &tmp_display_list;
1353
1354

95
        while (display && display->region_id != region_id) {
1355
29
            tmp_ptr = &display->next;
1356
29
            display = display->next;
1357
        }
1358
1359
66
        if (!display) {
1360
2
            display = av_mallocz(sizeof(*display));
1361
2
            if (!display)
1362
                return AVERROR(ENOMEM);
1363
        }
1364
1365
66
        display->region_id = region_id;
1366
1367
66
        display->x_pos = AV_RB16(buf);
1368
66
        buf += 2;
1369
66
        display->y_pos = AV_RB16(buf);
1370
66
        buf += 2;
1371
1372
66
        *tmp_ptr = display->next;
1373
1374
66
        display->next = ctx->display_list;
1375
66
        ctx->display_list = display;
1376
1377
        ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1378
    }
1379
1380
48
    while (tmp_display_list) {
1381
2
        display = tmp_display_list;
1382
1383
2
        tmp_display_list = display->next;
1384
1385
2
        av_freep(&display);
1386
    }
1387
1388
46
    return 0;
1389
}
1390
1391
1392
#ifdef DEBUG
1393
static void png_save(DVBSubContext *ctx, const char *filename, uint32_t *bitmap, int w, int h)
1394
{
1395
    int x, y, v;
1396
    FILE *f;
1397
    char fname[40], fname2[40];
1398
    char command[1024];
1399
1400
    snprintf(fname, sizeof(fname), "%s.ppm", filename);
1401
1402
    f = fopen(fname, "w");
1403
    if (!f) {
1404
        perror(fname);
1405
        return;
1406
    }
1407
    fprintf(f, "P6\n"
1408
            "%d %d\n"
1409
            "%d\n",
1410
            w, h, 255);
1411
    for(y = 0; y < h; y++) {
1412
        for(x = 0; x < w; x++) {
1413
            v = bitmap[y * w + x];
1414
            putc((v >> 16) & 0xff, f);
1415
            putc((v >> 8) & 0xff, f);
1416
            putc((v >> 0) & 0xff, f);
1417
        }
1418
    }
1419
    fclose(f);
1420
1421
1422
    snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
1423
1424
    f = fopen(fname2, "w");
1425
    if (!f) {
1426
        perror(fname2);
1427
        return;
1428
    }
1429
    fprintf(f, "P5\n"
1430
            "%d %d\n"
1431
            "%d\n",
1432
            w, h, 255);
1433
    for(y = 0; y < h; y++) {
1434
        for(x = 0; x < w; x++) {
1435
            v = bitmap[y * w + x];
1436
            putc((v >> 24) & 0xff, f);
1437
        }
1438
    }
1439
    fclose(f);
1440
1441
    snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
1442
    if (system(command) != 0) {
1443
        av_log(ctx, AV_LOG_ERROR, "Error running pnmtopng\n");
1444
        return;
1445
    }
1446
1447
    snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
1448
    if (system(command) != 0) {
1449
        av_log(ctx, AV_LOG_ERROR, "Error removing %s and %s\n", fname, fname2);
1450
        return;
1451
    }
1452
}
1453
1454
static int save_display_set(DVBSubContext *ctx)
1455
{
1456
    DVBSubRegion *region;
1457
    DVBSubRegionDisplay *display;
1458
    DVBSubCLUT *clut;
1459
    uint32_t *clut_table;
1460
    int x_pos, y_pos, width, height;
1461
    int x, y, y_off, x_off;
1462
    uint32_t *pbuf;
1463
    char filename[32];
1464
    static int fileno_index = 0;
1465
1466
    x_pos = -1;
1467
    y_pos = -1;
1468
    width = 0;
1469
    height = 0;
1470
1471
    for (display = ctx->display_list; display; display = display->next) {
1472
        region = get_region(ctx, display->region_id);
1473
1474
        if (!region)
1475
            return -1;
1476
1477
        if (x_pos == -1) {
1478
            x_pos = display->x_pos;
1479
            y_pos = display->y_pos;
1480
            width = region->width;
1481
            height = region->height;
1482
        } else {
1483
            if (display->x_pos < x_pos) {
1484
                width += (x_pos - display->x_pos);
1485
                x_pos = display->x_pos;
1486
            }
1487
1488
            if (display->y_pos < y_pos) {
1489
                height += (y_pos - display->y_pos);
1490
                y_pos = display->y_pos;
1491
            }
1492
1493
            if (display->x_pos + region->width > x_pos + width) {
1494
                width = display->x_pos + region->width - x_pos;
1495
            }
1496
1497
            if (display->y_pos + region->height > y_pos + height) {
1498
                height = display->y_pos + region->height - y_pos;
1499
            }
1500
        }
1501
    }
1502
1503
    if (x_pos >= 0) {
1504
1505
        pbuf = av_malloc(width * height * 4);
1506
        if (!pbuf)
1507
            return -1;
1508
1509
        for (display = ctx->display_list; display; display = display->next) {
1510
            region = get_region(ctx, display->region_id);
1511
1512
            if (!region)
1513
                return -1;
1514
1515
            x_off = display->x_pos - x_pos;
1516
            y_off = display->y_pos - y_pos;
1517
1518
            clut = get_clut(ctx, region->clut);
1519
1520
            if (!clut)
1521
                clut = &default_clut;
1522
1523
            switch (region->depth) {
1524
            case 2:
1525
                clut_table = clut->clut4;
1526
                break;
1527
            case 8:
1528
                clut_table = clut->clut256;
1529
                break;
1530
            case 4:
1531
            default:
1532
                clut_table = clut->clut16;
1533
                break;
1534
            }
1535
1536
            for (y = 0; y < region->height; y++) {
1537
                for (x = 0; x < region->width; x++) {
1538
                    pbuf[((y + y_off) * width) + x_off + x] =
1539
                        clut_table[region->pbuf[y * region->width + x]];
1540
                }
1541
            }
1542
1543
        }
1544
1545
        snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
1546
1547
        png_save(ctx, filename, pbuf, width, height);
1548
1549
        av_freep(&pbuf);
1550
    }
1551
1552
    fileno_index++;
1553
    return 0;
1554
}
1555
#endif /* DEBUG */
1556
1557
static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
1558
                                                   const uint8_t *buf,
1559
                                                   int buf_size)
1560
{
1561
    DVBSubContext *ctx = avctx->priv_data;
1562
    DVBSubDisplayDefinition *display_def = ctx->display_definition;
1563
    int dds_version, info_byte;
1564
1565
    if (buf_size < 5)
1566
        return AVERROR_INVALIDDATA;
1567
1568
    info_byte   = bytestream_get_byte(&buf);
1569
    dds_version = info_byte >> 4;
1570
    if (display_def && display_def->version == dds_version)
1571
        return 0; // already have this display definition version
1572
1573
    if (!display_def) {
1574
        display_def             = av_mallocz(sizeof(*display_def));
1575
        if (!display_def)
1576
            return AVERROR(ENOMEM);
1577
        ctx->display_definition = display_def;
1578
    }
1579
1580
    display_def->version = dds_version;
1581
    display_def->x       = 0;
1582
    display_def->y       = 0;
1583
    display_def->width   = bytestream_get_be16(&buf) + 1;
1584
    display_def->height  = bytestream_get_be16(&buf) + 1;
1585
    if (!avctx->width || !avctx->height) {
1586
        int ret = ff_set_dimensions(avctx, display_def->width, display_def->height);
1587
        if (ret < 0)
1588
            return ret;
1589
    }
1590
1591
    if (info_byte & 1<<3) { // display_window_flag
1592
        if (buf_size < 13)
1593
            return AVERROR_INVALIDDATA;
1594
1595
        display_def->x = bytestream_get_be16(&buf);
1596
        display_def->width  = bytestream_get_be16(&buf) - display_def->x + 1;
1597
        display_def->y = bytestream_get_be16(&buf);
1598
        display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
1599
    }
1600
1601
    return 0;
1602
}
1603
1604
46
static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
1605
                                      int buf_size, AVSubtitle *sub,int *got_output)
1606
{
1607
46
    DVBSubContext *ctx = avctx->priv_data;
1608
1609
46
    if (ctx->compute_edt == 0)
1610
        save_subtitle_set(avctx, sub, got_output);
1611
#ifdef DEBUG
1612
    save_display_set(ctx);
1613
#endif
1614
46
    return 0;
1615
}
1616
1617
46
static int dvbsub_decode(AVCodecContext *avctx,
1618
                         void *data, int *got_sub_ptr,
1619
                         AVPacket *avpkt)
1620
{
1621
46
    const uint8_t *buf = avpkt->data;
1622
46
    int buf_size = avpkt->size;
1623
46
    DVBSubContext *ctx = avctx->priv_data;
1624
46
    AVSubtitle *sub = data;
1625
    const uint8_t *p, *p_end;
1626
    int segment_type;
1627
    int page_id;
1628
    int segment_length;
1629
    int i;
1630
46
    int ret = 0;
1631
46
    int got_segment = 0;
1632
46
    int got_dds = 0;
1633
1634
    ff_dlog(avctx, "DVB sub packet:\n");
1635
1636
51204
    for (i=0; i < buf_size; i++) {
1637
        ff_dlog(avctx, "%02x ", buf[i]);
1638
51158
        if (i % 16 == 15)
1639
            ff_dlog(avctx, "\n");
1640
    }
1641
1642
46
    if (i % 16)
1643
        ff_dlog(avctx, "\n");
1644
1645

46
    if (buf_size <= 6 || *buf != 0x0f) {
1646
        ff_dlog(avctx, "incomplete or broken packet");
1647
        return AVERROR_INVALIDDATA;
1648
    }
1649
1650
46
    p = buf;
1651
46
    p_end = buf + buf_size;
1652
1653

250
    while (p_end - p >= 6 && *p == 0x0f) {
1654
204
        p += 1;
1655
204
        segment_type = *p++;
1656
204
        page_id = AV_RB16(p);
1657
204
        p += 2;
1658
204
        segment_length = AV_RB16(p);
1659
204
        p += 2;
1660
1661
204
        if (avctx->debug & FF_DEBUG_STARTCODE) {
1662
            av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
1663
        }
1664
1665
204
        if (p_end - p < segment_length) {
1666
            ff_dlog(avctx, "incomplete or broken packet");
1667
            ret = -1;
1668
            goto end;
1669
        }
1670
1671

204
        if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||
1672

204
            ctx->composition_id == -1 || ctx->ancillary_id == -1) {
1673
204
            int ret = 0;
1674

204
            switch (segment_type) {
1675
46
            case DVBSUB_PAGE_SEGMENT:
1676
46
                ret = dvbsub_parse_page_segment(avctx, p, segment_length, sub, got_sub_ptr);
1677
46
                got_segment |= 1;
1678
46
                break;
1679
57
            case DVBSUB_REGION_SEGMENT:
1680
57
                ret = dvbsub_parse_region_segment(avctx, p, segment_length);
1681
57
                got_segment |= 2;
1682
57
                break;
1683
13
            case DVBSUB_CLUT_SEGMENT:
1684
13
                ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
1685
13
                if (ret < 0) goto end;
1686
13
                got_segment |= 4;
1687
13
                break;
1688
42
            case DVBSUB_OBJECT_SEGMENT:
1689
42
                ret = dvbsub_parse_object_segment(avctx, p, segment_length);
1690
42
                got_segment |= 8;
1691
42
                break;
1692
            case DVBSUB_DISPLAYDEFINITION_SEGMENT:
1693
                ret = dvbsub_parse_display_definition_segment(avctx, p,
1694
                                                              segment_length);
1695
                got_dds = 1;
1696
                break;
1697
46
            case DVBSUB_DISPLAY_SEGMENT:
1698
46
                ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, got_sub_ptr);
1699


46
                if (got_segment == 15 && !got_dds && !avctx->width && !avctx->height) {
1700
                    // Default from ETSI EN 300 743 V1.3.1 (7.2.1)
1701
1
                    avctx->width  = 720;
1702
1
                    avctx->height = 576;
1703
                }
1704
46
                got_segment |= 16;
1705
46
                break;
1706
            default:
1707
                ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1708
                        segment_type, page_id, segment_length);
1709
                break;
1710
            }
1711
204
            if (ret < 0)
1712
                goto end;
1713
        }
1714
1715
204
        p += segment_length;
1716
    }
1717
    // Some streams do not send a display segment but if we have all the other
1718
    // segments then we need no further data.
1719
46
    if (got_segment == 15) {
1720
        av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");
1721
        dvbsub_display_end_segment(avctx, p, 0, sub, got_sub_ptr);
1722
    }
1723
1724
46
end:
1725
46
    if (ret < 0) {
1726
        *got_sub_ptr = 0;
1727
        avsubtitle_free(sub);
1728
        return ret;
1729
    } else {
1730
46
        if (ctx->compute_edt == 1)
1731
46
            FFSWAP(int64_t, ctx->prev_start, sub->pts);
1732
    }
1733
1734
46
    return p - buf;
1735
}
1736
1737
#define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
1738
#define OFFSET(x) offsetof(DVBSubContext, x)
1739
static const AVOption options[] = {
1740
    {"compute_edt", "compute end of time using pts or timeout", OFFSET(compute_edt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DS},
1741
    {"compute_clut", "compute clut when not available(-1) or only once (-2) or always(1) or never(0)", OFFSET(compute_clut), AV_OPT_TYPE_BOOL, {.i64 = -1}, -2, 1, DS},
1742
    {"dvb_substream", "", OFFSET(substream), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, DS},
1743
    {NULL}
1744
};
1745
static const AVClass dvbsubdec_class = {
1746
    .class_name = "DVB Sub Decoder",
1747
    .item_name  = av_default_item_name,
1748
    .option     = options,
1749
    .version    = LIBAVUTIL_VERSION_INT,
1750
};
1751
1752
AVCodec ff_dvbsub_decoder = {
1753
    .name           = "dvbsub",
1754
    .long_name      = NULL_IF_CONFIG_SMALL("DVB subtitles"),
1755
    .type           = AVMEDIA_TYPE_SUBTITLE,
1756
    .id             = AV_CODEC_ID_DVB_SUBTITLE,
1757
    .priv_data_size = sizeof(DVBSubContext),
1758
    .init           = dvbsub_init_decoder,
1759
    .close          = dvbsub_close_decoder,
1760
    .decode         = dvbsub_decode,
1761
    .priv_class     = &dvbsubdec_class,
1762
};