falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
101841 Commits
32 Branches
424MB
Tree: f38f791a23
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f38f791a23'
${ noResults }
FFmpeg/libavcodec/ass_split.c

601 lines
23KB
Raw Blame History 

  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. }