git.sesse.net Git - ffmpeg/blob - libavcodec/ass_split.c

   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 static int convert_str(void *dest, const char *buf, int len)
 145 {
 146     char *str = av_malloc(len + 1);
 147     if (str) {
 148         memcpy(str, buf, len);
 149         str[len] = 0;
 150         if (*(void **)dest)
 151             av_free(*(void **)dest);
 152         *(char **)dest = str;
 153     }
 154     return !str;
 155 }
 156 static int convert_int(void *dest, const char *buf, int len)
 157 {
 158     return sscanf(buf, "%d", (int *)dest) == 1;
 159 }
 160 static int convert_flt(void *dest, const char *buf, int len)
 161 {
 162     return sscanf(buf, "%f", (float *)dest) == 1;
 163 }
 164 static int convert_color(void *dest, const char *buf, int len)
 165 {
 166     return sscanf(buf, "&H%8x", (int *)dest) == 1 ||
 167            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 static uint8_t *realloc_section_array(ASSSplitContext *ctx)
 206 {
 207     const ASSSection *section = &ass_sections[ctx->current_section];
 208     int *count = (int *)((uint8_t *)&ctx->ass + section->offset_count);
 209     void **section_ptr = (void **)((uint8_t *)&ctx->ass + section->offset);
 210     uint8_t *tmp = av_realloc_array(*section_ptr, (*count+1), section->size);
 211     if (!tmp)
 212         return NULL;
 213     *section_ptr = tmp;
 214     tmp += *count * section->size;
 215     memset(tmp, 0, section->size);
 216     (*count)++;
 217     return tmp;
 218 }
 219
 220 static inline int is_eol(char buf)
 221 {
 222     return buf == '\r' || buf == '\n' || buf == 0;
 223 }
 224
 225 static inline const char *skip_space(const char *buf)
 226 {
 227     while (*buf == ' ')
 228         buf++;
 229     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 static const char *ass_split_section(ASSSplitContext *ctx, const char *buf)
 248 {
 249     const ASSSection *section = &ass_sections[ctx->current_section];
 250     int *number = &ctx->field_number[ctx->current_section];
 251     int *order = ctx->field_order[ctx->current_section];
 252     int i, len;
 253
 254     while (buf && *buf) {
 255         if (buf[0] == '[') {
 256             ctx->current_section = -1;
 257             break;
 258         }
 259         if (buf[0] == ';' || (buf[0] == '!' && buf[1] == ':'))
 260             goto next_line; // skip comments
 261
 262         len = strcspn(buf, ":\r\n");
 263         if (buf[len] == ':' &&
 264             (!section->fields_header || strncmp(buf, section->fields_header, len))) {
 265             for (i = 0; i < FF_ARRAY_ELEMS(ass_sections); i++) {
 266                 if (ass_sections[i].fields_header &&
 267                     !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         if (section->format_header && !order) {
 277             len = strlen(section->format_header);
 278             if (!strncmp(buf, section->format_header, len) && buf[len] == ':') {
 279                 buf += len + 1;
 280                 while (!is_eol(*buf)) {
 281                     buf = skip_space(buf);
 282                     len = strcspn(buf, ", \r\n");
 283                     if (av_reallocp_array(&order, (*number + 1), sizeof(*order)) != 0)
 284                         return NULL;
 285
 286                     order[*number] = -1;
 287                     for (i=0; section->fields[i].name; i++)
 288                         if (!strncmp(buf, section->fields[i].name, len)) {
 289                             order[*number] = i;
 290                             break;
 291                         }
 292                     (*number)++;
 293                     buf = skip_space(buf + len + (buf[len] == ','));
 294                 }
 295                 ctx->field_order[ctx->current_section] = order;
 296                 goto next_line;
 297             }
 298         }
 299         if (section->fields_header) {
 300             len = strlen(section->fields_header);
 301             if (!strncmp(buf, section->fields_header, len) && buf[len] == ':') {
 302                 uint8_t *ptr, *struct_ptr = realloc_section_array(ctx);
 303                 if (!struct_ptr)  return NULL;
 304
 305                 /* No format header line found so far, assume default */
 306                 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                 buf += len + 1;
 314                 for (i=0; !is_eol(*buf) && i < *number; i++) {
 315                     int last = i == *number - 1;
 316                     buf = skip_space(buf);
 317                     len = strcspn(buf, last ? "\r\n" : ",\r\n");
 318                     if (order[i] >= 0) {
 319                         ASSFieldType type = section->fields[order[i]].type;
 320                         ptr = struct_ptr + section->fields[order[i]].offset;
 321                         convert_func[type](ptr, buf, len);
 322                     }
 323                     buf += len;
 324                     if (!last && *buf) buf++;
 325                     buf = skip_space(buf);
 326                 }
 327             }
 328         } else {
 329             len = strcspn(buf, ":\r\n");
 330             if (buf[len] == ':') {
 331                 for (i=0; section->fields[i].name; i++)
 332                     if (!strncmp(buf, section->fields[i].name, len)) {
 333                         ASSFieldType type = section->fields[i].type;
 334                         uint8_t *ptr = (uint8_t *)&ctx->ass + section->offset;
 335                         ptr += section->fields[i].offset;
 336                         buf = skip_space(buf + len + 1);
 337                         convert_func[type](ptr, buf, strcspn(buf, "\r\n"));
 338                         break;
 339                     }
 340             }
 341         }
 342 next_line:
 343         buf += strcspn(buf, "\n");
 344         buf += !!*buf;
 345     }
 346     return buf;
 347 }
 348
 349 static int ass_split(ASSSplitContext *ctx, const char *buf)
 350 {
 351     char c, section[16];
 352     int i;
 353
 354     if (ctx->current_section >= 0)
 355         buf = ass_split_section(ctx, buf);
 356
 357     while (buf && *buf) {
 358         if (sscanf(buf, "[%15[0-9A-Za-z+ ]]%c", section, &c) == 2) {
 359             buf += strcspn(buf, "\n");
 360             buf += !!*buf;
 361             for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++)
 362                 if (!strcmp(section, ass_sections[i].section)) {
 363                     ctx->current_section = i;
 364                     buf = ass_split_section(ctx, buf);
 365                 }
 366         } else {
 367             buf += strcspn(buf, "\n");
 368             buf += !!*buf;
 369         }
 370     }
 371     return buf ? 0 : AVERROR_INVALIDDATA;
 372 }
 373
 374 ASSSplitContext *ff_ass_split(const char *buf)
 375 {
 376     ASSSplitContext *ctx = av_mallocz(sizeof(*ctx));
 377     if (!ctx)
 378         return NULL;
 379     if (buf && !strncmp(buf, "\xef\xbb\xbf", 3)) // Skip UTF-8 BOM header
 380         buf += 3;
 381     ctx->current_section = -1;
 382     if (ass_split(ctx, buf) < 0) {
 383         ff_ass_split_free(ctx);
 384         return NULL;
 385     }
 386     return ctx;
 387 }
 388
 389 static void free_section(ASSSplitContext *ctx, const ASSSection *section)
 390 {
 391     uint8_t *ptr = (uint8_t *)&ctx->ass + section->offset;
 392     int i, j, *count, c = 1;
 393
 394     if (section->format_header) {
 395         ptr   = *(void **)ptr;
 396         count = (int *)((uint8_t *)&ctx->ass + section->offset_count);
 397     } else
 398         count = &c;
 399
 400     if (ptr)
 401         for (i=0; i<*count; i++, ptr += section->size)
 402             for (j=0; section->fields[j].name; j++) {
 403                 const ASSFields *field = &section->fields[j];
 404                 if (field->type == ASS_STR)
 405                     av_freep(ptr + field->offset);
 406             }
 407     *count = 0;
 408
 409     if (section->format_header)
 410         av_freep((uint8_t *)&ctx->ass + section->offset);
 411 }
 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 void ff_ass_free_dialog(ASSDialog **dialogp)
 433 {
 434     ASSDialog *dialog = *dialogp;
 435     if (!dialog)
 436         return;
 437     av_freep(&dialog->style);
 438     av_freep(&dialog->name);
 439     av_freep(&dialog->effect);
 440     av_freep(&dialog->text);
 441     av_freep(dialogp);
 442 }
 443
 444 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     ASSDialog *dialog = av_mallocz(sizeof(*dialog));
 460     if (!dialog)
 461         return NULL;
 462
 463     for (i = 0; i < FF_ARRAY_ELEMS(fields); i++) {
 464         size_t len;
 465         const int last = i == FF_ARRAY_ELEMS(fields) - 1;
 466         const ASSFieldType type = fields[i].type;
 467         uint8_t *ptr = (uint8_t *)dialog + fields[i].offset;
 468         buf = skip_space(buf);
 469         len = last ? strlen(buf) : strcspn(buf, ",");
 470         if (len >= INT_MAX) {
 471             ff_ass_free_dialog(&dialog);
 472             return NULL;
 473         }
 474         convert_func[type](ptr, buf, len);
 475         buf += len;
 476         if (*buf) buf++;
 477     }
 478     return dialog;
 479 }
 480
 481 void ff_ass_split_free(ASSSplitContext *ctx)
 482 {
 483     if (ctx) {
 484         int i;
 485         for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++) {
 486             free_section(ctx, &ass_sections[i]);
 487             av_freep(&(ctx->field_order[i]));
 488         }
 489         av_free(ctx);
 490     }
 491 }
 492
 493
 494 int ff_ass_split_override_codes(const ASSCodesCallbacks *callbacks, void *priv,
 495                                 const char *buf)
 496 {
 497     const char *text = NULL;
 498     char new_line[2];
 499     int text_len = 0;
 500
 501     while (buf && *buf) {
 502         if (text && callbacks->text &&
 503             (sscanf(buf, "\\%1[nN]", new_line) == 1 ||
 504              !strncmp(buf, "{\\", 2))) {
 505             callbacks->text(priv, text, text_len);
 506             text = NULL;
 507         }
 508         if (sscanf(buf, "\\%1[nN]", new_line) == 1) {
 509             if (callbacks->new_line)
 510                 callbacks->new_line(priv, new_line[0] == 'N');
 511             buf += 2;
 512         } else if (!strncmp(buf, "{\\", 2)) {
 513             buf++;
 514             while (*buf == '\\') {
 515                 char style[2], c[2], sep[2], c_num[2] = "0", tmp[128] = {0};
 516                 unsigned int color = 0xFFFFFFFF;
 517                 int len, size = -1, an = -1, alpha = -1;
 518                 int x1, y1, x2, y2, t1 = -1, t2 = -1;
 519                 if (sscanf(buf, "\\%1[bisu]%1[01\\}]%n", style, c, &len) > 1) {
 520                     int close = c[0] == '0' ? 1 : c[0] == '1' ? 0 : -1;
 521                     len += close != -1;
 522                     if (callbacks->style)
 523                         callbacks->style(priv, style[0], close);
 524                 } else if (sscanf(buf, "\\c%1[\\}]%n", sep, &len) > 0 ||
 525                            sscanf(buf, "\\c&H%X&%1[\\}]%n", &color, sep, &len) > 1 ||
 526                            sscanf(buf, "\\%1[1234]c%1[\\}]%n", c_num, sep, &len) > 1 ||
 527                            sscanf(buf, "\\%1[1234]c&H%X&%1[\\}]%n", c_num, &color, sep, &len) > 2) {
 528                     if (callbacks->color)
 529                         callbacks->color(priv, color, c_num[0] - '0');
 530                 } else if (sscanf(buf, "\\alpha%1[\\}]%n", sep, &len) > 0 ||
 531                            sscanf(buf, "\\alpha&H%2X&%1[\\}]%n", &alpha, sep, &len) > 1 ||
 532                            sscanf(buf, "\\%1[1234]a%1[\\}]%n", c_num, sep, &len) > 1 ||
 533                            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                 } else if (sscanf(buf, "\\fn%1[\\}]%n", sep, &len) > 0 ||
 537                            sscanf(buf, "\\fn%127[^\\}]%1[\\}]%n", tmp, sep, &len) > 1) {
 538                     if (callbacks->font_name)
 539                         callbacks->font_name(priv, tmp[0] ? tmp : NULL);
 540                 } else if (sscanf(buf, "\\fs%1[\\}]%n", sep, &len) > 0 ||
 541                            sscanf(buf, "\\fs%u%1[\\}]%n", &size, sep, &len) > 1) {
 542                     if (callbacks->font_size)
 543                         callbacks->font_size(priv, size);
 544                 } else if (sscanf(buf, "\\a%1[\\}]%n", sep, &len) > 0 ||
 545                            sscanf(buf, "\\a%2u%1[\\}]%n", &an, sep, &len) > 1 ||
 546                            sscanf(buf, "\\an%1[\\}]%n", sep, &len) > 0 ||
 547                            sscanf(buf, "\\an%1u%1[\\}]%n", &an, sep, &len) > 1) {
 548                     if (an != -1 && buf[2] != 'n')
 549                         an = (an&3) + (an&4 ? 6 : an&8 ? 3 : 0);
 550                     if (callbacks->alignment)
 551                         callbacks->alignment(priv, an);
 552                 } else if (sscanf(buf, "\\r%1[\\}]%n", sep, &len) > 0 ||
 553                            sscanf(buf, "\\r%127[^\\}]%1[\\}]%n", tmp, sep, &len) > 1) {
 554                     if (callbacks->cancel_overrides)
 555                         callbacks->cancel_overrides(priv, tmp);
 556                 } else if (sscanf(buf, "\\move(%d,%d,%d,%d)%1[\\}]%n", &x1, &y1, &x2, &y2, sep, &len) > 4 ||
 557                            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                 } else if (sscanf(buf, "\\pos(%d,%d)%1[\\}]%n", &x1, &y1, sep, &len) > 2) {
 561                     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                 buf += len - 1;
 570             }
 571             if (*buf++ != '}')
 572                 return AVERROR_INVALIDDATA;
 573         } else {
 574             if (!text) {
 575                 text = buf;
 576                 text_len = 1;
 577             } else
 578                 text_len++;
 579             buf++;
 580         }
 581     }
 582     if (text && callbacks->text)
 583         callbacks->text(priv, text, text_len);
 584     if (callbacks->end)
 585         callbacks->end(priv);
 586     return 0;
 587 }
 588
 589 ASSStyle *ff_ass_style_get(ASSSplitContext *ctx, const char *style)
 590 {
 591     ASS *ass = &ctx->ass;
 592     int i;
 593
 594     if (!style || !*style)
 595         style = "Default";
 596     for (i=0; i<ass->styles_count; i++)
 597         if (ass->styles[i].name && !strcmp(ass->styles[i].name, style))
 598             return ass->styles + i;
 599     return NULL;
 600 }