GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dvbsubdec.c Lines: 478 842 56.8 %
Date: 2020-11-28 20:53:16 Branches: 268 587 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 == -1) || 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
    region->has_computed_clut = 0;
983
}
984
985
42
static int dvbsub_parse_object_segment(AVCodecContext *avctx,
986
                                       const uint8_t *buf, int buf_size)
987
{
988
42
    DVBSubContext *ctx = avctx->priv_data;
989
990
42
    const uint8_t *buf_end = buf + buf_size;
991
    int object_id;
992
    DVBSubObject *object;
993
    DVBSubObjectDisplay *display;
994
    int top_field_len, bottom_field_len;
995
996
    int coding_method, non_modifying_color;
997
998
42
    object_id = AV_RB16(buf);
999
42
    buf += 2;
1000
1001
42
    object = get_object(ctx, object_id);
1002
1003
42
    if (!object)
1004
        return AVERROR_INVALIDDATA;
1005
1006
42
    coding_method = ((*buf) >> 2) & 3;
1007
42
    non_modifying_color = ((*buf++) >> 1) & 1;
1008
1009
42
    if (coding_method == 0) {
1010
42
        top_field_len = AV_RB16(buf);
1011
42
        buf += 2;
1012
42
        bottom_field_len = AV_RB16(buf);
1013
42
        buf += 2;
1014
1015
42
        if (buf + top_field_len + bottom_field_len > buf_end) {
1016
            av_log(avctx, AV_LOG_ERROR, "Field data size %d+%d too large\n", top_field_len, bottom_field_len);
1017
            return AVERROR_INVALIDDATA;
1018
        }
1019
1020
84
        for (display = object->display_list; display; display = display->object_list_next) {
1021
42
            const uint8_t *block = buf;
1022
42
            int bfl = bottom_field_len;
1023
1024
42
            dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
1025
                                            non_modifying_color);
1026
1027
42
            if (bottom_field_len > 0)
1028
42
                block = buf + top_field_len;
1029
            else
1030
                bfl = top_field_len;
1031
1032
42
            dvbsub_parse_pixel_data_block(avctx, display, block, bfl, 1,
1033
                                            non_modifying_color);
1034
        }
1035
    } else if (coding_method == 1) {
1036
        avpriv_report_missing_feature(avctx, "coded as a string of characters");
1037
        return AVERROR_PATCHWELCOME;
1038
    } else if (coding_method == 2) {
1039
        avpriv_report_missing_feature(avctx, "progressive coding of pixels");
1040
        return AVERROR_PATCHWELCOME;
1041
    } else {
1042
        av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
1043
        return AVERROR_INVALIDDATA;
1044
    }
1045
1046
42
    return 0;
1047
}
1048
1049
13
static int dvbsub_parse_clut_segment(AVCodecContext *avctx,
1050
                                     const uint8_t *buf, int buf_size)
1051
{
1052
13
    DVBSubContext *ctx = avctx->priv_data;
1053
1054
13
    const uint8_t *buf_end = buf + buf_size;
1055
    int i, clut_id;
1056
    int version;
1057
    DVBSubCLUT *clut;
1058
    int entry_id, depth , full_range;
1059
    int y, cr, cb, alpha;
1060
    int r, g, b, r_add, g_add, b_add;
1061
1062
    ff_dlog(avctx, "DVB clut packet:\n");
1063
1064
741
    for (i=0; i < buf_size; i++) {
1065
        ff_dlog(avctx, "%02x ", buf[i]);
1066
728
        if (i % 16 == 15)
1067
            ff_dlog(avctx, "\n");
1068
    }
1069
1070
13
    if (i % 16)
1071
        ff_dlog(avctx, "\n");
1072
1073
13
    clut_id = *buf++;
1074
13
    version = ((*buf)>>4)&15;
1075
13
    buf += 1;
1076
1077
13
    clut = get_clut(ctx, clut_id);
1078
1079
13
    if (!clut) {
1080
13
        clut = av_malloc(sizeof(*clut));
1081
13
        if (!clut)
1082
            return AVERROR(ENOMEM);
1083
1084
13
        memcpy(clut, &default_clut, sizeof(*clut));
1085
1086
13
        clut->id = clut_id;
1087
13
        clut->version = -1;
1088
1089
13
        clut->next = ctx->clut_list;
1090
13
        ctx->clut_list = clut;
1091
    }
1092
1093
13
    if (clut->version != version) {
1094
1095
13
        clut->version = version;
1096
1097
130
        while (buf + 4 < buf_end) {
1098
117
            entry_id = *buf++;
1099
1100
117
            depth = (*buf) & 0xe0;
1101
1102
117
            if (depth == 0) {
1103
                av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
1104
            }
1105
1106
117
            full_range = (*buf++) & 1;
1107
1108
117
            if (full_range) {
1109
117
                y     = *buf++;
1110
117
                cr    = *buf++;
1111
117
                cb    = *buf++;
1112
117
                alpha = *buf++;
1113
            } else {
1114
                y     = buf[0] & 0xfc;
1115
                cr    = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
1116
                cb    = (buf[1] << 2) & 0xf0;
1117
                alpha = (buf[1] << 6) & 0xc0;
1118
1119
                buf += 2;
1120
            }
1121
1122
117
            if (y == 0)
1123
13
                alpha = 0xff;
1124
1125
117
            YUV_TO_RGB1_CCIR(cb, cr);
1126
117
            YUV_TO_RGB2_CCIR(r, g, b, y);
1127
1128
            ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
1129
117
            if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
1130
                ff_dlog(avctx, "More than one bit level marked: %x\n", depth);
1131
                if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)
1132
                    return AVERROR_INVALIDDATA;
1133
            }
1134
1135

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

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

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

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

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

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

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

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

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

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

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

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

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


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