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
25typedef enum {
26    ASS_STR,
27    ASS_INT,
28    ASS_FLT,
29    ASS_COLOR,
30    ASS_TIMESTAMP,
31    ASS_ALGN,
32} ASSFieldType;
33
34typedef struct {
35    const char *name;
36    int type;
37    int offset;
38} ASSFields;
39
40typedef 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[10];
48} ASSSection;
49
50static 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                 {"BackColour",   ASS_COLOR,offsetof(ASSStyle, back_color)   },
72                 {"Bold",         ASS_INT,  offsetof(ASSStyle, bold)         },
73                 {"Italic",       ASS_INT,  offsetof(ASSStyle, italic)       },
74                 {"Underline",    ASS_INT,  offsetof(ASSStyle, underline)    },
75                 {"Alignment",    ASS_INT,  offsetof(ASSStyle, alignment)    },
76                 {0},
77        }
78    },
79    { .section       = "V4 Styles",
80      .format_header = "Format",
81      .fields_header = "Style",
82      .size          = sizeof(ASSStyle),
83      .offset        = offsetof(ASS, styles),
84      .offset_count  = offsetof(ASS, styles_count),
85      .fields = {{"Name",         ASS_STR,  offsetof(ASSStyle, name)         },
86                 {"Fontname",     ASS_STR,  offsetof(ASSStyle, font_name)    },
87                 {"Fontsize",     ASS_INT,  offsetof(ASSStyle, font_size)    },
88                 {"PrimaryColour",ASS_COLOR,offsetof(ASSStyle, primary_color)},
89                 {"BackColour",   ASS_COLOR,offsetof(ASSStyle, back_color)   },
90                 {"Bold",         ASS_INT,  offsetof(ASSStyle, bold)         },
91                 {"Italic",       ASS_INT,  offsetof(ASSStyle, italic)       },
92                 {"Alignment",    ASS_ALGN, offsetof(ASSStyle, alignment)    },
93                 {0},
94        }
95    },
96    { .section       = "Events",
97      .format_header = "Format",
98      .fields_header = "Dialogue",
99      .size          = sizeof(ASSDialog),
100      .offset        = offsetof(ASS, dialogs),
101      .offset_count  = offsetof(ASS, dialogs_count),
102      .fields = {{"Layer",  ASS_INT,        offsetof(ASSDialog, layer)       },
103                 {"Start",  ASS_TIMESTAMP,  offsetof(ASSDialog, start)       },
104                 {"End",    ASS_TIMESTAMP,  offsetof(ASSDialog, end)         },
105                 {"Style",  ASS_STR,        offsetof(ASSDialog, style)       },
106                 {"Text",   ASS_STR,        offsetof(ASSDialog, text)        },
107                 {0},
108        }
109    },
110};
111
112
113typedef int (*ASSConvertFunc)(void *dest, const char *buf, int len);
114
115static int convert_str(void *dest, const char *buf, int len)
116{
117    char *str = av_malloc(len + 1);
118    if (str) {
119        memcpy(str, buf, len);
120        str[len] = 0;
121        if (*(void **)dest)
122            av_free(*(void **)dest);
123        *(char **)dest = str;
124    }
125    return !str;
126}
127static int convert_int(void *dest, const char *buf, int len)
128{
129    return sscanf(buf, "%d", (int *)dest) == 1;
130}
131static int convert_flt(void *dest, const char *buf, int len)
132{
133    return sscanf(buf, "%f", (float *)dest) == 1;
134}
135static int convert_color(void *dest, const char *buf, int len)
136{
137    return sscanf(buf, "&H%8x", (int *)dest) == 1 ||
138           sscanf(buf, "%d",    (int *)dest) == 1;
139}
140static int convert_timestamp(void *dest, const char *buf, int len)
141{
142    int c, h, m, s, cs;
143    if ((c = sscanf(buf, "%d:%02d:%02d.%02d", &h, &m, &s, &cs)) == 4)
144        *(int *)dest = 360000*h + 6000*m + 100*s + cs;
145    return c == 4;
146}
147static int convert_alignment(void *dest, const char *buf, int len)
148{
149    int a;
150    if (sscanf(buf, "%d", &a) == 1) {
151        /* convert V4 Style alignment to V4+ Style */
152        *(int *)dest = a + ((a&4) >> 1) - 5*!!(a&8);
153        return 1;
154    }
155    return 0;
156}
157
158static const ASSConvertFunc convert_func[] = {
159    [ASS_STR]       = convert_str,
160    [ASS_INT]       = convert_int,
161    [ASS_FLT]       = convert_flt,
162    [ASS_COLOR]     = convert_color,
163    [ASS_TIMESTAMP] = convert_timestamp,
164    [ASS_ALGN]      = convert_alignment,
165};
166
167
168struct ASSSplitContext {
169    ASS ass;
170    int current_section;
171    int field_number[FF_ARRAY_ELEMS(ass_sections)];
172    int *field_order[FF_ARRAY_ELEMS(ass_sections)];
173};
174
175
176static uint8_t *realloc_section_array(ASSSplitContext *ctx)
177{
178    const ASSSection *section = &ass_sections[ctx->current_section];
179    int *count = (int *)((uint8_t *)&ctx->ass + section->offset_count);
180    void **section_ptr = (void **)((uint8_t *)&ctx->ass + section->offset);
181    uint8_t *tmp = av_realloc(*section_ptr, (*count+1)*section->size);
182    if (!tmp)
183        return NULL;
184    *section_ptr = tmp;
185    tmp += *count * section->size;
186    memset(tmp, 0, section->size);
187    (*count)++;
188    return tmp;
189}
190
191static inline int is_eol(char buf)
192{
193    return buf == '\r' || buf == '\n' || buf == 0;
194}
195
196static inline const char *skip_space(const char *buf)
197{
198    while (*buf == ' ')
199        buf++;
200    return buf;
201}
202
203static const char *ass_split_section(ASSSplitContext *ctx, const char *buf)
204{
205    const ASSSection *section = &ass_sections[ctx->current_section];
206    int *number = &ctx->field_number[ctx->current_section];
207    int *order = ctx->field_order[ctx->current_section];
208    int *tmp, i, len;
209
210    while (buf && *buf) {
211        if (buf[0] == '[') {
212            ctx->current_section = -1;
213            break;
214        }
215        if (buf[0] == ';' || (buf[0] == '!' && buf[1] == ':')) {
216            /* skip comments */
217        } else if (section->format_header && !order) {
218            len = strlen(section->format_header);
219            if (strncmp(buf, section->format_header, len) || buf[len] != ':')
220                return NULL;
221            buf += len + 1;
222            while (!is_eol(*buf)) {
223                buf = skip_space(buf);
224                len = strcspn(buf, ", \r\n");
225                if (!(tmp = av_realloc(order, (*number + 1) * sizeof(*order))))
226                    return NULL;
227                order = tmp;
228                order[*number] = -1;
229                for (i=0; section->fields[i].name; i++)
230                    if (!strncmp(buf, section->fields[i].name, len)) {
231                        order[*number] = i;
232                        break;
233                    }
234                (*number)++;
235                buf = skip_space(buf + len + (buf[len] == ','));
236            }
237            ctx->field_order[ctx->current_section] = order;
238        } else if (section->fields_header) {
239            len = strlen(section->fields_header);
240            if (!strncmp(buf, section->fields_header, len) && buf[len] == ':') {
241                uint8_t *ptr, *struct_ptr = realloc_section_array(ctx);
242                if (!struct_ptr)  return NULL;
243                buf += len + 1;
244                for (i=0; !is_eol(*buf) && i < *number; i++) {
245                    int last = i == *number - 1;
246                    buf = skip_space(buf);
247                    len = strcspn(buf, last ? "\r\n" : ",\r\n");
248                    if (order[i] >= 0) {
249                        ASSFieldType type = section->fields[order[i]].type;
250                        ptr = struct_ptr + section->fields[order[i]].offset;
251                        convert_func[type](ptr, buf, len);
252                    }
253                    buf += len;
254                    if (!last && *buf) buf++;
255                    buf = skip_space(buf);
256                }
257            }
258        } else {
259            len = strcspn(buf, ":\r\n");
260            if (buf[len] == ':') {
261                for (i=0; section->fields[i].name; i++)
262                    if (!strncmp(buf, section->fields[i].name, len)) {
263                        ASSFieldType type = section->fields[i].type;
264                        uint8_t *ptr = (uint8_t *)&ctx->ass + section->offset;
265                        ptr += section->fields[i].offset;
266                        buf = skip_space(buf + len + 1);
267                        convert_func[type](ptr, buf, strcspn(buf, "\r\n"));
268                        break;
269                    }
270            }
271        }
272        buf += strcspn(buf, "\n");
273        buf += !!*buf;
274    }
275    return buf;
276}
277
278static int ass_split(ASSSplitContext *ctx, const char *buf)
279{
280    char c, section[16];
281    int i;
282
283    if (ctx->current_section >= 0)
284        buf = ass_split_section(ctx, buf);
285
286    while (buf && *buf) {
287        if (sscanf(buf, "[%15[0-9A-Za-z+ ]]%c", section, &c) == 2) {
288            buf += strcspn(buf, "\n");
289            buf += !!*buf;
290            for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++)
291                if (!strcmp(section, ass_sections[i].section)) {
292                    ctx->current_section = i;
293                    buf = ass_split_section(ctx, buf);
294                }
295        } else {
296            buf += strcspn(buf, "\n");
297            buf += !!*buf;
298        }
299    }
300    return buf ? 0 : AVERROR_INVALIDDATA;
301}
302
303ASSSplitContext *ff_ass_split(const char *buf)
304{
305    ASSSplitContext *ctx = av_mallocz(sizeof(*ctx));
306    ctx->current_section = -1;
307    if (ass_split(ctx, buf) < 0) {
308        ff_ass_split_free(ctx);
309        return NULL;
310    }
311    return ctx;
312}
313
314static void free_section(ASSSplitContext *ctx, const ASSSection *section)
315{
316    uint8_t *ptr = (uint8_t *)&ctx->ass + section->offset;
317    int i, j, *count, c = 1;
318
319    if (section->format_header) {
320        ptr   = *(void **)ptr;
321        count = (int *)((uint8_t *)&ctx->ass + section->offset_count);
322    } else
323        count = &c;
324
325    if (ptr)
326        for (i=0; i<*count; i++, ptr += section->size)
327            for (j=0; section->fields[j].name; j++) {
328                const ASSFields *field = &section->fields[j];
329                if (field->type == ASS_STR)
330                    av_freep(ptr + field->offset);
331            }
332    *count = 0;
333
334    if (section->format_header)
335        av_freep((uint8_t *)&ctx->ass + section->offset);
336}
337
338ASSDialog *ff_ass_split_dialog(ASSSplitContext *ctx, const char *buf,
339                               int cache, int *number)
340{
341    ASSDialog *dialog = NULL;
342    int i, count;
343    if (!cache)
344        for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++)
345            if (!strcmp(ass_sections[i].section, "Events")) {
346                free_section(ctx, &ass_sections[i]);
347                break;
348            }
349    count = ctx->ass.dialogs_count;
350    if (ass_split(ctx, buf) == 0)
351        dialog = ctx->ass.dialogs + count;
352    if (number)
353        *number = ctx->ass.dialogs_count - count;
354    return dialog;
355}
356
357void ff_ass_split_free(ASSSplitContext *ctx)
358{
359    if (ctx) {
360        int i;
361        for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++) {
362            free_section(ctx, &ass_sections[i]);
363            av_freep(&(ctx->field_order[i]));
364        }
365        av_free(ctx);
366    }
367}
368
369
370int ff_ass_split_override_codes(const ASSCodesCallbacks *callbacks, void *priv,
371                                const char *buf)
372{
373    const char *text = NULL;
374    char new_line[2];
375    int text_len = 0;
376
377    while (buf && *buf) {
378        if (text && callbacks->text &&
379            (sscanf(buf, "\\%1[nN]", new_line) == 1 ||
380             !strncmp(buf, "{\\", 2))) {
381            callbacks->text(priv, text, text_len);
382            text = NULL;
383        }
384        if (sscanf(buf, "\\%1[nN]", new_line) == 1) {
385            if (callbacks->new_line)
386                callbacks->new_line(priv, new_line[0] == 'N');
387            buf += 2;
388        } else if (!strncmp(buf, "{\\", 2)) {
389            buf++;
390            while (*buf == '\\') {
391                char style[2], c[2], sep[2], c_num[2] = "0", tmp[128] = {0};
392                unsigned int color = 0xFFFFFFFF;
393                int len, size = -1, an = -1, alpha = -1;
394                int x1, y1, x2, y2, t1 = -1, t2 = -1;
395                if (sscanf(buf, "\\%1[bisu]%1[01\\}]%n", style, c, &len) > 1) {
396                    int close = c[0] == '0' ? 1 : c[0] == '1' ? 0 : -1;
397                    len += close != -1;
398                    if (callbacks->style)
399                        callbacks->style(priv, style[0], close);
400                } else if (sscanf(buf, "\\c%1[\\}]%n", sep, &len) > 0 ||
401                           sscanf(buf, "\\c&H%X&%1[\\}]%n", &color, sep, &len) > 1 ||
402                           sscanf(buf, "\\%1[1234]c%1[\\}]%n", c_num, sep, &len) > 1 ||
403                           sscanf(buf, "\\%1[1234]c&H%X&%1[\\}]%n", c_num, &color, sep, &len) > 2) {
404                    if (callbacks->color)
405                        callbacks->color(priv, color, c_num[0] - '0');
406                } else if (sscanf(buf, "\\alpha%1[\\}]%n", sep, &len) > 0 ||
407                           sscanf(buf, "\\alpha&H%2X&%1[\\}]%n", &alpha, sep, &len) > 1 ||
408                           sscanf(buf, "\\%1[1234]a%1[\\}]%n", c_num, sep, &len) > 1 ||
409                           sscanf(buf, "\\%1[1234]a&H%2X&%1[\\}]%n", c_num, &alpha, sep, &len) > 2) {
410                    if (callbacks->alpha)
411                        callbacks->alpha(priv, alpha, c_num[0] - '0');
412                } else if (sscanf(buf, "\\fn%1[\\}]%n", sep, &len) > 0 ||
413                           sscanf(buf, "\\fn%127[^\\}]%1[\\}]%n", tmp, sep, &len) > 1) {
414                    if (callbacks->font_name)
415                        callbacks->font_name(priv, tmp[0] ? tmp : NULL);
416                } else if (sscanf(buf, "\\fs%1[\\}]%n", sep, &len) > 0 ||
417                           sscanf(buf, "\\fs%u%1[\\}]%n", &size, sep, &len) > 1) {
418                    if (callbacks->font_size)
419                        callbacks->font_size(priv, size);
420                } else if (sscanf(buf, "\\a%1[\\}]%n", sep, &len) > 0 ||
421                           sscanf(buf, "\\a%2u%1[\\}]%n", &an, sep, &len) > 1 ||
422                           sscanf(buf, "\\an%1[\\}]%n", sep, &len) > 0 ||
423                           sscanf(buf, "\\an%1u%1[\\}]%n", &an, sep, &len) > 1) {
424                    if (an != -1 && buf[2] != 'n')
425                        an = (an&3) + (an&4 ? 6 : an&8 ? 3 : 0);
426                    if (callbacks->alignment)
427                        callbacks->alignment(priv, an);
428                } else if (sscanf(buf, "\\r%1[\\}]%n", sep, &len) > 0 ||
429                           sscanf(buf, "\\r%127[^\\}]%1[\\}]%n", tmp, sep, &len) > 1) {
430                    if (callbacks->cancel_overrides)
431                        callbacks->cancel_overrides(priv, tmp);
432                } else if (sscanf(buf, "\\move(%d,%d,%d,%d)%1[\\}]%n", &x1, &y1, &x2, &y2, sep, &len) > 4 ||
433                           sscanf(buf, "\\move(%d,%d,%d,%d,%d,%d)%1[\\}]%n", &x1, &y1, &x2, &y2, &t1, &t2, sep, &len) > 6) {
434                    if (callbacks->move)
435                        callbacks->move(priv, x1, y1, x2, y2, t1, t2);
436                } else if (sscanf(buf, "\\pos(%d,%d)%1[\\}]%n", &x1, &y1, sep, &len) > 2) {
437                    if (callbacks->move)
438                        callbacks->move(priv, x1, y1, x1, y1, -1, -1);
439                } else if (sscanf(buf, "\\org(%d,%d)%1[\\}]%n", &x1, &y1, sep, &len) > 2) {
440                    if (callbacks->origin)
441                        callbacks->origin(priv, x1, y1);
442                } else {
443                    len = strcspn(buf+1, "\\}") + 2;  /* skip unknown code */
444                }
445                buf += len - 1;
446            }
447            if (*buf++ != '}')
448                return AVERROR_INVALIDDATA;
449        } else {
450            if (!text) {
451                text = buf;
452                text_len = 1;
453            } else
454                text_len++;
455            buf++;
456        }
457    }
458    if (text && callbacks->text)
459        callbacks->text(priv, text, text_len);
460    if (callbacks->end)
461        callbacks->end(priv);
462    return 0;
463}
464
465ASSStyle *ff_ass_style_get(ASSSplitContext *ctx, const char *style)
466{
467    ASS *ass = &ctx->ass;
468    int i;
469
470    if (!style || !*style)
471        style = "Default";
472    for (i=0; i<ass->styles_count; i++)
473        if (!strcmp(ass->styles[i].name, style))
474            return ass->styles + i;
475    return NULL;
476}
477