FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ass_split.c
Go to the documentation of this file.
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[10];
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  {"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 
113 typedef int (*ASSConvertFunc)(void *dest, const char *buf, int len);
114 
115 static 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 }
127 static int convert_int(void *dest, const char *buf, int len)
128 {
129  return sscanf(buf, "%d", (int *)dest) == 1;
130 }
131 static int convert_flt(void *dest, const char *buf, int len)
132 {
133  return sscanf(buf, "%f", (float *)dest) == 1;
134 }
135 static 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 }
140 static 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 }
147 static 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 
158 static 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 
168 struct 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 
176 static 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 
191 static inline int is_eol(char buf)
192 {
193  return buf == '\r' || buf == '\n' || buf == 0;
194 }
195 
196 static inline const char *skip_space(const char *buf)
197 {
198  while (*buf == ' ')
199  buf++;
200  return buf;
201 }
202 
203 static 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 
278 static 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 
303 ASSSplitContext *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 
314 static 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 
338 ASSDialog *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 
357 void 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 
370 int 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 
465 ASSStyle *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 }
Generated on Sun Sep 14 2014 18:55:52 for FFmpeg by   doxygen 1.8.2