GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ass_split.c Lines: 231 305 75.7 %
Date: 2020-11-28 20:53:16 Branches: 175 280 62.5 %

Line Branch Exec Source
1
/*
2
 * SSA/ASS spliting functions
3
 * Copyright (c) 2010  Aurelien Jacobs <aurel@gnuage.org>
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 "ass_split.h"
24
25
typedef enum {
26
    ASS_STR,
27
    ASS_INT,
28
    ASS_FLT,
29
    ASS_COLOR,
30
    ASS_TIMESTAMP,
31
    ASS_ALGN,
32
} ASSFieldType;
33
34
typedef struct {
35
    const char *name;
36
    int type;
37
    int offset;
38
} ASSFields;
39
40
typedef struct {
41
    const char *section;
42
    const char *format_header;
43
    const char *fields_header;
44
    int         size;
45
    int         offset;
46
    int         offset_count;
47
    ASSFields   fields[24];
48
} ASSSection;
49
50
static const ASSSection ass_sections[] = {
51
    { .section       = "Script Info",
52
      .offset        = offsetof(ASS, script_info),
53
      .fields = {{"ScriptType", ASS_STR, offsetof(ASSScriptInfo, script_type)},
54
                 {"Collisions", ASS_STR, offsetof(ASSScriptInfo, collisions) },
55
                 {"PlayResX",   ASS_INT, offsetof(ASSScriptInfo, play_res_x) },
56
                 {"PlayResY",   ASS_INT, offsetof(ASSScriptInfo, play_res_y) },
57
                 {"Timer",      ASS_FLT, offsetof(ASSScriptInfo, timer)      },
58
                 {0},
59
        }
60
    },
61
    { .section       = "V4+ Styles",
62
      .format_header = "Format",
63
      .fields_header = "Style",
64
      .size          = sizeof(ASSStyle),
65
      .offset        = offsetof(ASS, styles),
66
      .offset_count  = offsetof(ASS, styles_count),
67
      .fields = {{"Name",            ASS_STR,   offsetof(ASSStyle, name)           },
68
                 {"Fontname",        ASS_STR,   offsetof(ASSStyle, font_name)      },
69
                 {"Fontsize",        ASS_INT,   offsetof(ASSStyle, font_size)      },
70
                 {"PrimaryColour",   ASS_COLOR, offsetof(ASSStyle, primary_color)  },
71
                 {"SecondaryColour", ASS_COLOR, offsetof(ASSStyle, secondary_color)},
72
                 {"OutlineColour",   ASS_COLOR, offsetof(ASSStyle, outline_color)  },
73
                 {"BackColour",      ASS_COLOR, offsetof(ASSStyle, back_color)     },
74
                 {"Bold",            ASS_INT,   offsetof(ASSStyle, bold)           },
75
                 {"Italic",          ASS_INT,   offsetof(ASSStyle, italic)         },
76
                 {"Underline",       ASS_INT,   offsetof(ASSStyle, underline)      },
77
                 {"StrikeOut",       ASS_INT,   offsetof(ASSStyle, strikeout)      },
78
                 {"ScaleX",          ASS_FLT,   offsetof(ASSStyle, scalex)         },
79
                 {"ScaleY",          ASS_FLT,   offsetof(ASSStyle, scaley)         },
80
                 {"Spacing",         ASS_FLT,   offsetof(ASSStyle, spacing)        },
81
                 {"Angle",           ASS_FLT,   offsetof(ASSStyle, angle)          },
82
                 {"BorderStyle",     ASS_INT,   offsetof(ASSStyle, border_style)   },
83
                 {"Outline",         ASS_FLT,   offsetof(ASSStyle, outline)        },
84
                 {"Shadow",          ASS_FLT,   offsetof(ASSStyle, shadow)         },
85
                 {"Alignment",       ASS_INT,   offsetof(ASSStyle, alignment)      },
86
                 {"MarginL",         ASS_INT,   offsetof(ASSStyle, margin_l)       },
87
                 {"MarginR",         ASS_INT,   offsetof(ASSStyle, margin_r)       },
88
                 {"MarginV",         ASS_INT,   offsetof(ASSStyle, margin_v)       },
89
                 {"Encoding",        ASS_INT,   offsetof(ASSStyle, encoding)       },
90
                 {0},
91
        }
92
    },
93
    { .section       = "V4 Styles",
94
      .format_header = "Format",
95
      .fields_header = "Style",
96
      .size          = sizeof(ASSStyle),
97
      .offset        = offsetof(ASS, styles),
98
      .offset_count  = offsetof(ASS, styles_count),
99
      .fields = {{"Name",            ASS_STR,   offsetof(ASSStyle, name)           },
100
                 {"Fontname",        ASS_STR,   offsetof(ASSStyle, font_name)      },
101
                 {"Fontsize",        ASS_INT,   offsetof(ASSStyle, font_size)      },
102
                 {"PrimaryColour",   ASS_COLOR, offsetof(ASSStyle, primary_color)  },
103
                 {"SecondaryColour", ASS_COLOR, offsetof(ASSStyle, secondary_color)},
104
                 {"TertiaryColour",  ASS_COLOR, offsetof(ASSStyle, outline_color)  },
105
                 {"BackColour",      ASS_COLOR, offsetof(ASSStyle, back_color)     },
106
                 {"Bold",            ASS_INT,   offsetof(ASSStyle, bold)           },
107
                 {"Italic",          ASS_INT,   offsetof(ASSStyle, italic)         },
108
                 {"BorderStyle",     ASS_INT,   offsetof(ASSStyle, border_style)   },
109
                 {"Outline",         ASS_FLT,   offsetof(ASSStyle, outline)        },
110
                 {"Shadow",          ASS_FLT,   offsetof(ASSStyle, shadow)         },
111
                 {"Alignment",       ASS_ALGN,  offsetof(ASSStyle, alignment)      },
112
                 {"MarginL",         ASS_INT,   offsetof(ASSStyle, margin_l)       },
113
                 {"MarginR",         ASS_INT,   offsetof(ASSStyle, margin_r)       },
114
                 {"MarginV",         ASS_INT,   offsetof(ASSStyle, margin_v)       },
115
                 {"AlphaLevel",      ASS_INT,   offsetof(ASSStyle, alpha_level)    },
116
                 {"Encoding",        ASS_INT,   offsetof(ASSStyle, encoding)       },
117
                 {0},
118
        }
119
    },
120
    { .section       = "Events",
121
      .format_header = "Format",
122
      .fields_header = "Dialogue",
123
      .size          = sizeof(ASSDialog),
124
      .offset        = offsetof(ASS, dialogs),
125
      .offset_count  = offsetof(ASS, dialogs_count),
126
      .fields = {{"Layer",   ASS_INT,        offsetof(ASSDialog, layer)   },
127
                 {"Start",   ASS_TIMESTAMP,  offsetof(ASSDialog, start)   },
128
                 {"End",     ASS_TIMESTAMP,  offsetof(ASSDialog, end)     },
129
                 {"Style",   ASS_STR,        offsetof(ASSDialog, style)   },
130
                 {"Name",    ASS_STR,        offsetof(ASSDialog, name)    },
131
                 {"MarginL", ASS_INT,        offsetof(ASSDialog, margin_l)},
132
                 {"MarginR", ASS_INT,        offsetof(ASSDialog, margin_r)},
133
                 {"MarginV", ASS_INT,        offsetof(ASSDialog, margin_v)},
134
                 {"Effect",  ASS_STR,        offsetof(ASSDialog, effect)  },
135
                 {"Text",    ASS_STR,        offsetof(ASSDialog, text)    },
136
                 {0},
137
        }
138
    },
139
};
140
141
142
typedef int (*ASSConvertFunc)(void *dest, const char *buf, int len);
143
144
332
static int convert_str(void *dest, const char *buf, int len)
145
{
146
332
    char *str = av_malloc(len + 1);
147
332
    if (str) {
148
332
        memcpy(str, buf, len);
149
332
        str[len] = 0;
150
332
        if (*(void **)dest)
151
            av_free(*(void **)dest);
152
332
        *(char **)dest = str;
153
    }
154
332
    return !str;
155
}
156
452
static int convert_int(void *dest, const char *buf, int len)
157
{
158
452
    return sscanf(buf, "%d", (int *)dest) == 1;
159
}
160
20
static int convert_flt(void *dest, const char *buf, int len)
161
{
162
20
    return sscanf(buf, "%f", (float *)dest) == 1;
163
}
164
20
static int convert_color(void *dest, const char *buf, int len)
165
{
166
24
    return sscanf(buf, "&H%8x", (int *)dest) == 1 ||
167
4
           sscanf(buf, "%d",    (int *)dest) == 1;
168
}
169
static int convert_timestamp(void *dest, const char *buf, int len)
170
{
171
    int c, h, m, s, cs;
172
    if ((c = sscanf(buf, "%d:%02d:%02d.%02d", &h, &m, &s, &cs)) == 4)
173
        *(int *)dest = 360000*h + 6000*m + 100*s + cs;
174
    return c == 4;
175
}
176
static int convert_alignment(void *dest, const char *buf, int len)
177
{
178
    int a;
179
    if (sscanf(buf, "%d", &a) == 1) {
180
        /* convert V4 Style alignment to V4+ Style */
181
        *(int *)dest = a + ((a&4) >> 1) - 5*!!(a&8);
182
        return 1;
183
    }
184
    return 0;
185
}
186
187
static const ASSConvertFunc convert_func[] = {
188
    [ASS_STR]       = convert_str,
189
    [ASS_INT]       = convert_int,
190
    [ASS_FLT]       = convert_flt,
191
    [ASS_COLOR]     = convert_color,
192
    [ASS_TIMESTAMP] = convert_timestamp,
193
    [ASS_ALGN]      = convert_alignment,
194
};
195
196
197
struct ASSSplitContext {
198
    ASS ass;
199
    int current_section;
200
    int field_number[FF_ARRAY_ELEMS(ass_sections)];
201
    int *field_order[FF_ARRAY_ELEMS(ass_sections)];
202
};
203
204
205
4
static uint8_t *realloc_section_array(ASSSplitContext *ctx)
206
{
207
4
    const ASSSection *section = &ass_sections[ctx->current_section];
208
4
    int *count = (int *)((uint8_t *)&ctx->ass + section->offset_count);
209
4
    void **section_ptr = (void **)((uint8_t *)&ctx->ass + section->offset);
210
4
    uint8_t *tmp = av_realloc_array(*section_ptr, (*count+1), section->size);
211
4
    if (!tmp)
212
        return NULL;
213
4
    *section_ptr = tmp;
214
4
    tmp += *count * section->size;
215
4
    memset(tmp, 0, section->size);
216
4
    (*count)++;
217
4
    return tmp;
218
}
219
220
236
static inline int is_eol(char buf)
221
{
222

236
    return buf == '\r' || buf == '\n' || buf == 0;
223
}
224
225
1180
static inline const char *skip_space(const char *buf)
226
{
227
1328
    while (*buf == ' ')
228
148
        buf++;
229
1180
    return buf;
230
}
231
232
static int *get_default_field_orders(const ASSSection *section, int *number)
233
{
234
    int i;
235
    int *order = av_malloc_array(FF_ARRAY_ELEMS(section->fields), sizeof(*order));
236
237
    if (!order)
238
        return NULL;
239
    for (i = 0; section->fields[i].name; i++)
240
        order[i] = i;
241
    *number = i;
242
    while (i < FF_ARRAY_ELEMS(section->fields))
243
        order[i++] = -1;
244
    return order;
245
}
246
247
12
static const char *ass_split_section(ASSSplitContext *ctx, const char *buf)
248
{
249
12
    const ASSSection *section = &ass_sections[ctx->current_section];
250
12
    int *number = &ctx->field_number[ctx->current_section];
251
12
    int *order = ctx->field_order[ctx->current_section];
252
    int i, len;
253
254

52
    while (buf && *buf) {
255
48
        if (buf[0] == '[') {
256
8
            ctx->current_section = -1;
257
8
            break;
258
        }
259

40
        if (buf[0] == ';' || (buf[0] == '!' && buf[1] == ':'))
260
4
            goto next_line; // skip comments
261
262
36
        len = strcspn(buf, ":\r\n");
263
36
        if (buf[len] == ':' &&
264

28
            (!section->fields_header || strncmp(buf, section->fields_header, len))) {
265
120
            for (i = 0; i < FF_ARRAY_ELEMS(ass_sections); i++) {
266
96
                if (ass_sections[i].fields_header &&
267
72
                    !strncmp(buf, ass_sections[i].fields_header, len)) {
268
                    ctx->current_section = i;
269
                    section = &ass_sections[ctx->current_section];
270
                    number = &ctx->field_number[ctx->current_section];
271
                    order = ctx->field_order[ctx->current_section];
272
                    break;
273
                }
274
            }
275
        }
276

36
        if (section->format_header && !order) {
277
8
            len = strlen(section->format_header);
278

8
            if (!strncmp(buf, section->format_header, len) && buf[len] == ':') {
279
8
                buf += len + 1;
280
140
                while (!is_eol(*buf)) {
281
132
                    buf = skip_space(buf);
282
132
                    len = strcspn(buf, ", \r\n");
283
132
                    if (av_reallocp_array(&order, (*number + 1), sizeof(*order)) != 0)
284
                        return NULL;
285
286
132
                    order[*number] = -1;
287
1280
                    for (i=0; section->fields[i].name; i++)
288
1280
                        if (!strncmp(buf, section->fields[i].name, len)) {
289
132
                            order[*number] = i;
290
132
                            break;
291
                        }
292
132
                    (*number)++;
293
132
                    buf = skip_space(buf + len + (buf[len] == ','));
294
                }
295
8
                ctx->field_order[ctx->current_section] = order;
296
8
                goto next_line;
297
            }
298
        }
299
28
        if (section->fields_header) {
300
8
            len = strlen(section->fields_header);
301

8
            if (!strncmp(buf, section->fields_header, len) && buf[len] == ':') {
302
4
                uint8_t *ptr, *struct_ptr = realloc_section_array(ctx);
303
4
                if (!struct_ptr)  return NULL;
304
305
                /* No format header line found so far, assume default */
306
4
                if (!order) {
307
                    order = get_default_field_orders(section, number);
308
                    if (!order)
309
                        return NULL;
310
                    ctx->field_order[ctx->current_section] = order;
311
                }
312
313
4
                buf += len + 1;
314

96
                for (i=0; !is_eol(*buf) && i < *number; i++) {
315
92
                    int last = i == *number - 1;
316
92
                    buf = skip_space(buf);
317
92
                    len = strcspn(buf, last ? "\r\n" : ",\r\n");
318
92
                    if (order[i] >= 0) {
319
92
                        ASSFieldType type = section->fields[order[i]].type;
320
92
                        ptr = struct_ptr + section->fields[order[i]].offset;
321
92
                        convert_func[type](ptr, buf, len);
322
                    }
323
92
                    buf += len;
324

92
                    if (!last && *buf) buf++;
325
92
                    buf = skip_space(buf);
326
                }
327
            }
328
        } else {
329
20
            len = strcspn(buf, ":\r\n");
330
20
            if (buf[len] == ':') {
331
56
                for (i=0; section->fields[i].name; i++)
332
52
                    if (!strncmp(buf, section->fields[i].name, len)) {
333
12
                        ASSFieldType type = section->fields[i].type;
334
12
                        uint8_t *ptr = (uint8_t *)&ctx->ass + section->offset;
335
12
                        ptr += section->fields[i].offset;
336
12
                        buf = skip_space(buf + len + 1);
337
12
                        convert_func[type](ptr, buf, strcspn(buf, "\r\n"));
338
12
                        break;
339
                    }
340
            }
341
        }
342
8
next_line:
343
40
        buf += strcspn(buf, "\n");
344
40
        buf += !!*buf;
345
    }
346
12
    return buf;
347
}
348
349
4
static int ass_split(ASSSplitContext *ctx, const char *buf)
350
{
351
    char c, section[16];
352
    int i;
353
354
4
    if (ctx->current_section >= 0)
355
        buf = ass_split_section(ctx, buf);
356
357

16
    while (buf && *buf) {
358
12
        if (sscanf(buf, "[%15[0-9A-Za-z+ ]]%c", section, &c) == 2) {
359
12
            buf += strcspn(buf, "\n");
360
12
            buf += !!*buf;
361
60
            for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++)
362
48
                if (!strcmp(section, ass_sections[i].section)) {
363
12
                    ctx->current_section = i;
364
12
                    buf = ass_split_section(ctx, buf);
365
                }
366
        } else {
367
            buf += strcspn(buf, "\n");
368
            buf += !!*buf;
369
        }
370
    }
371
4
    return buf ? 0 : AVERROR_INVALIDDATA;
372
}
373
374
4
ASSSplitContext *ff_ass_split(const char *buf)
375
{
376
4
    ASSSplitContext *ctx = av_mallocz(sizeof(*ctx));
377
4
    if (!ctx)
378
        return NULL;
379

4
    if (buf && !memcmp(buf, "\xef\xbb\xbf", 3)) // Skip UTF-8 BOM header
380
        buf += 3;
381
4
    ctx->current_section = -1;
382
4
    if (ass_split(ctx, buf) < 0) {
383
        ff_ass_split_free(ctx);
384
        return NULL;
385
    }
386
4
    return ctx;
387
}
388
389
16
static void free_section(ASSSplitContext *ctx, const ASSSection *section)
390
{
391
16
    uint8_t *ptr = (uint8_t *)&ctx->ass + section->offset;
392
16
    int i, j, *count, c = 1;
393
394
16
    if (section->format_header) {
395
12
        ptr   = *(void **)ptr;
396
12
        count = (int *)((uint8_t *)&ctx->ass + section->offset_count);
397
    } else
398
4
        count = &c;
399
400
16
    if (ptr)
401
16
        for (i=0; i<*count; i++, ptr += section->size)
402
120
            for (j=0; section->fields[j].name; j++) {
403
112
                const ASSFields *field = &section->fields[j];
404
112
                if (field->type == ASS_STR)
405
16
                    av_freep(ptr + field->offset);
406
            }
407
16
    *count = 0;
408
409
16
    if (section->format_header)
410
12
        av_freep((uint8_t *)&ctx->ass + section->offset);
411
16
}
412
413
ASSDialog *ff_ass_split_dialog(ASSSplitContext *ctx, const char *buf,
414
                               int cache, int *number)
415
{
416
    ASSDialog *dialog = NULL;
417
    int i, count;
418
    if (!cache)
419
        for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++)
420
            if (!strcmp(ass_sections[i].section, "Events")) {
421
                free_section(ctx, &ass_sections[i]);
422
                break;
423
            }
424
    count = ctx->ass.dialogs_count;
425
    if (ass_split(ctx, buf) == 0)
426
        dialog = ctx->ass.dialogs + count;
427
    if (number)
428
        *number = ctx->ass.dialogs_count - count;
429
    return dialog;
430
}
431
432
80
void ff_ass_free_dialog(ASSDialog **dialogp)
433
{
434
80
    ASSDialog *dialog = *dialogp;
435
80
    if (!dialog)
436
        return;
437
80
    av_freep(&dialog->style);
438
80
    av_freep(&dialog->name);
439
80
    av_freep(&dialog->effect);
440
80
    av_freep(&dialog->text);
441
80
    av_freep(dialogp);
442
}
443
444
80
ASSDialog *ff_ass_split_dialog2(ASSSplitContext *ctx, const char *buf)
445
{
446
    int i;
447
    static const ASSFields fields[] = {
448
        {"ReadOrder", ASS_INT, offsetof(ASSDialog, readorder)},
449
        {"Layer",     ASS_INT, offsetof(ASSDialog, layer)    },
450
        {"Style",     ASS_STR, offsetof(ASSDialog, style)    },
451
        {"Name",      ASS_STR, offsetof(ASSDialog, name)     },
452
        {"MarginL",   ASS_INT, offsetof(ASSDialog, margin_l) },
453
        {"MarginR",   ASS_INT, offsetof(ASSDialog, margin_r) },
454
        {"MarginV",   ASS_INT, offsetof(ASSDialog, margin_v) },
455
        {"Effect",    ASS_STR, offsetof(ASSDialog, effect)   },
456
        {"Text",      ASS_STR, offsetof(ASSDialog, text)     },
457
    };
458
459
80
    ASSDialog *dialog = av_mallocz(sizeof(*dialog));
460
80
    if (!dialog)
461
        return NULL;
462
463
800
    for (i = 0; i < FF_ARRAY_ELEMS(fields); i++) {
464
        size_t len;
465
720
        const int last = i == FF_ARRAY_ELEMS(fields) - 1;
466
720
        const ASSFieldType type = fields[i].type;
467
720
        uint8_t *ptr = (uint8_t *)dialog + fields[i].offset;
468
720
        buf = skip_space(buf);
469
720
        len = last ? strlen(buf) : strcspn(buf, ",");
470
720
        if (len >= INT_MAX) {
471
            ff_ass_free_dialog(&dialog);
472
            return NULL;
473
        }
474
720
        convert_func[type](ptr, buf, len);
475
720
        buf += len;
476
720
        if (*buf) buf++;
477
    }
478
80
    return dialog;
479
}
480
481
4
void ff_ass_split_free(ASSSplitContext *ctx)
482
{
483
4
    if (ctx) {
484
        int i;
485
20
        for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++) {
486
16
            free_section(ctx, &ass_sections[i]);
487
16
            av_freep(&(ctx->field_order[i]));
488
        }
489
4
        av_free(ctx);
490
    }
491
4
}
492
493
494
80
int ff_ass_split_override_codes(const ASSCodesCallbacks *callbacks, void *priv,
495
                                const char *buf)
496
{
497
80
    const char *text = NULL;
498
    char new_line[2];
499
80
    int text_len = 0;
500
501

6890
    while (buf && *buf) {
502

6810
        if (text && callbacks->text &&
503
6458
            (sscanf(buf, "\\%1[nN]", new_line) == 1 ||
504
6362
             !strncmp(buf, "{\\", 2))) {
505
148
            callbacks->text(priv, text, text_len);
506
148
            text = NULL;
507
        }
508
6810
        if (sscanf(buf, "\\%1[nN]", new_line) == 1) {
509
134
            if (callbacks->new_line)
510
134
                callbacks->new_line(priv, new_line[0] == 'N');
511
134
            buf += 2;
512
6676
        } else if (!strncmp(buf, "{\\", 2)) {
513
152
            buf++;
514
304
            while (*buf == '\\') {
515
152
                char style[2], c[2], sep[2], c_num[2] = "0", tmp[128] = {0};
516
152
                unsigned int color = 0xFFFFFFFF;
517
152
                int len, size = -1, an = -1, alpha = -1;
518
152
                int x1, y1, x2, y2, t1 = -1, t2 = -1;
519
152
                if (sscanf(buf, "\\%1[bisu]%1[01\\}]%n", style, c, &len) > 1) {
520

56
                    int close = c[0] == '0' ? 1 : c[0] == '1' ? 0 : -1;
521
56
                    len += close != -1;
522
56
                    if (callbacks->style)
523
28
                        callbacks->style(priv, style[0], close);
524
96
                } else if (sscanf(buf, "\\c%1[\\}]%n", sep, &len) > 0 ||
525
82
                           sscanf(buf, "\\c&H%X&%1[\\}]%n", &color, sep, &len) > 1 ||
526
64
                           sscanf(buf, "\\%1[1234]c%1[\\}]%n", c_num, sep, &len) > 1 ||
527
64
                           sscanf(buf, "\\%1[1234]c&H%X&%1[\\}]%n", c_num, &color, sep, &len) > 2) {
528
32
                    if (callbacks->color)
529
                        callbacks->color(priv, color, c_num[0] - '0');
530
64
                } else if (sscanf(buf, "\\alpha%1[\\}]%n", sep, &len) > 0 ||
531
64
                           sscanf(buf, "\\alpha&H%2X&%1[\\}]%n", &alpha, sep, &len) > 1 ||
532
64
                           sscanf(buf, "\\%1[1234]a%1[\\}]%n", c_num, sep, &len) > 1 ||
533
64
                           sscanf(buf, "\\%1[1234]a&H%2X&%1[\\}]%n", c_num, &alpha, sep, &len) > 2) {
534
                    if (callbacks->alpha)
535
                        callbacks->alpha(priv, alpha, c_num[0] - '0');
536
64
                } else if (sscanf(buf, "\\fn%1[\\}]%n", sep, &len) > 0 ||
537
62
                           sscanf(buf, "\\fn%127[^\\}]%1[\\}]%n", tmp, sep, &len) > 1) {
538
4
                    if (callbacks->font_name)
539
                        callbacks->font_name(priv, tmp[0] ? tmp : NULL);
540
60
                } else if (sscanf(buf, "\\fs%1[\\}]%n", sep, &len) > 0 ||
541
46
                           sscanf(buf, "\\fs%u%1[\\}]%n", &size, sep, &len) > 1) {
542
32
                    if (callbacks->font_size)
543
                        callbacks->font_size(priv, size);
544
28
                } else if (sscanf(buf, "\\a%1[\\}]%n", sep, &len) > 0 ||
545
28
                           sscanf(buf, "\\a%2u%1[\\}]%n", &an, sep, &len) > 1 ||
546
28
                           sscanf(buf, "\\an%1[\\}]%n", sep, &len) > 0 ||
547
28
                           sscanf(buf, "\\an%1u%1[\\}]%n", &an, sep, &len) > 1) {
548

26
                    if (an != -1 && buf[2] != 'n')
549
                        an = (an&3) + (an&4 ? 6 : an&8 ? 3 : 0);
550
26
                    if (callbacks->alignment)
551
                        callbacks->alignment(priv, an);
552
2
                } else if (sscanf(buf, "\\r%1[\\}]%n", sep, &len) > 0 ||
553
2
                           sscanf(buf, "\\r%127[^\\}]%1[\\}]%n", tmp, sep, &len) > 1) {
554
                    if (callbacks->cancel_overrides)
555
                        callbacks->cancel_overrides(priv, tmp);
556
2
                } else if (sscanf(buf, "\\move(%d,%d,%d,%d)%1[\\}]%n", &x1, &y1, &x2, &y2, sep, &len) > 4 ||
557
2
                           sscanf(buf, "\\move(%d,%d,%d,%d,%d,%d)%1[\\}]%n", &x1, &y1, &x2, &y2, &t1, &t2, sep, &len) > 6) {
558
                    if (callbacks->move)
559
                        callbacks->move(priv, x1, y1, x2, y2, t1, t2);
560
2
                } else if (sscanf(buf, "\\pos(%d,%d)%1[\\}]%n", &x1, &y1, sep, &len) > 2) {
561
2
                    if (callbacks->move)
562
                        callbacks->move(priv, x1, y1, x1, y1, -1, -1);
563
                } else if (sscanf(buf, "\\org(%d,%d)%1[\\}]%n", &x1, &y1, sep, &len) > 2) {
564
                    if (callbacks->origin)
565
                        callbacks->origin(priv, x1, y1);
566
                } else {
567
                    len = strcspn(buf+1, "\\}") + 2;  /* skip unknown code */
568
                }
569
152
                buf += len - 1;
570
            }
571
152
            if (*buf++ != '}')
572
                return AVERROR_INVALIDDATA;
573
        } else {
574
6524
            if (!text) {
575
214
                text = buf;
576
214
                text_len = 1;
577
            } else
578
6310
                text_len++;
579
6524
            buf++;
580
        }
581
    }
582

80
    if (text && callbacks->text)
583
66
        callbacks->text(priv, text, text_len);
584
80
    if (callbacks->end)
585
43
        callbacks->end(priv);
586
80
    return 0;
587
}
588
589
44
ASSStyle *ff_ass_style_get(ASSSplitContext *ctx, const char *style)
590
{
591
44
    ASS *ass = &ctx->ass;
592
    int i;
593
594

44
    if (!style || !*style)
595
        style = "Default";
596
44
    for (i=0; i<ass->styles_count; i++)
597

44
        if (ass->styles[i].name && !strcmp(ass->styles[i].name, style))
598
44
            return ass->styles + i;
599
    return NULL;
600
}