FFmpeg
avtextformat.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) The FFmpeg developers
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <limits.h>
22 #include <stdarg.h>
23 #include <stdint.h>
24 #include <stdio.h>
25 #include <string.h>
26 
27 #include "libavutil/mem.h"
28 #include "libavutil/avassert.h"
29 #include "libavutil/base64.h"
30 #include "libavutil/bprint.h"
31 #include "libavutil/error.h"
32 #include "libavutil/hash.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/macros.h"
35 #include "libavutil/opt.h"
36 #include "avtextformat.h"
37 
38 #define SECTION_ID_NONE (-1)
39 
40 #define SHOW_OPTIONAL_FIELDS_AUTO (-1)
41 #define SHOW_OPTIONAL_FIELDS_NEVER 0
42 #define SHOW_OPTIONAL_FIELDS_ALWAYS 1
43 
44 static const struct {
45  double bin_val;
46  double dec_val;
47  char bin_str[4];
48  char dec_str[4];
49 } si_prefixes[] = {
50  { 1.0, 1.0, "", "" },
51  { 1.024e3, 1e3, "Ki", "K" },
52  { 1.048576e6, 1e6, "Mi", "M" },
53  { 1.073741824e9, 1e9, "Gi", "G" },
54  { 1.099511627776e12, 1e12, "Ti", "T" },
55  { 1.125899906842624e15, 1e15, "Pi", "P" },
56 };
57 
58 static const char *textcontext_get_formatter_name(void *p)
59 {
60  AVTextFormatContext *tctx = p;
61  return tctx->formatter->name;
62 }
63 
64 #define OFFSET(x) offsetof(AVTextFormatContext, x)
65 
66 static const AVOption textcontext_options[] = {
67  { "string_validation", "set string validation mode",
68  OFFSET(string_validation), AV_OPT_TYPE_INT, { .i64 = AV_TEXTFORMAT_STRING_VALIDATION_REPLACE }, 0, AV_TEXTFORMAT_STRING_VALIDATION_NB - 1, .unit = "sv" },
69  { "sv", "set string validation mode",
70  OFFSET(string_validation), AV_OPT_TYPE_INT, { .i64 = AV_TEXTFORMAT_STRING_VALIDATION_REPLACE }, 0, AV_TEXTFORMAT_STRING_VALIDATION_NB - 1, .unit = "sv" },
71  { "ignore", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_TEXTFORMAT_STRING_VALIDATION_IGNORE }, .unit = "sv" },
72  { "replace", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_TEXTFORMAT_STRING_VALIDATION_REPLACE }, .unit = "sv" },
73  { "fail", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_TEXTFORMAT_STRING_VALIDATION_FAIL }, .unit = "sv" },
74  { "string_validation_replacement", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, { .str = "" } },
75  { "svr", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, { .str = "\xEF\xBF\xBD" } },
76  { NULL }
77 };
78 
79 static void *textcontext_child_next(void *obj, void *prev)
80 {
81  AVTextFormatContext *ctx = obj;
82  if (!prev && ctx->formatter && ctx->formatter->priv_class && ctx->priv)
83  return ctx->priv;
84  return NULL;
85 }
86 
87 static const AVClass textcontext_class = {
88  .class_name = "AVTextContext",
89  .item_name = textcontext_get_formatter_name,
90  .option = textcontext_options,
91  .version = LIBAVUTIL_VERSION_INT,
92  .child_next = textcontext_child_next,
93 };
94 
95 static void bprint_bytes(AVBPrint *bp, const uint8_t *ubuf, size_t ubuf_size)
96 {
97  av_bprintf(bp, "0X");
98  for (unsigned i = 0; i < ubuf_size; i++)
99  av_bprintf(bp, "%02X", ubuf[i]);
100 }
101 
102 int avtext_context_close(AVTextFormatContext **ptctx)
103 {
104  AVTextFormatContext *tctx = *ptctx;
105  int ret = 0;
106 
107  if (!tctx)
108  return AVERROR(EINVAL);
109 
110  av_hash_freep(&tctx->hash);
111 
112  if (tctx->formatter) {
113  if (tctx->formatter->uninit)
114  ret = tctx->formatter->uninit(tctx);
115  if (tctx->formatter->priv_class)
116  av_opt_free(tctx->priv);
117  }
118  for (int i = 0; i < SECTION_MAX_NB_LEVELS; i++)
119  av_bprint_finalize(&tctx->section_pbuf[i], NULL);
120  av_freep(&tctx->priv);
121  av_opt_free(tctx);
122  av_freep(ptctx);
123  return ret;
124 }
125 
126 
127 int avtext_context_open(AVTextFormatContext **ptctx, const AVTextFormatter *formatter, AVTextWriterContext *writer_context, const char *args,
128  const AVTextFormatSection *sections, int nb_sections, AVTextFormatOptions options, char *show_data_hash)
129 {
130  AVTextFormatContext *tctx;
131  int ret = 0;
132 
133  av_assert0(ptctx && formatter);
134 
135  if (!(tctx = av_mallocz(sizeof(AVTextFormatContext)))) {
136  ret = AVERROR(ENOMEM);
137  goto fail;
138  }
139 
140  for (int i = 0; i < SECTION_MAX_NB_LEVELS; i++)
141  av_bprint_init(&tctx->section_pbuf[i], 1, AV_BPRINT_SIZE_UNLIMITED);
142 
143  tctx->class = &textcontext_class;
144  av_opt_set_defaults(tctx);
145 
146  if (!(tctx->priv = av_mallocz(formatter->priv_size))) {
147  ret = AVERROR(ENOMEM);
148  goto fail;
149  }
150 
151  tctx->opts = options;
152 
153  if (nb_sections > SECTION_MAX_NB_SECTIONS) {
154  av_log(tctx, AV_LOG_ERROR, "The number of section definitions (%d) is larger than the maximum allowed (%d)\n", nb_sections, SECTION_MAX_NB_SECTIONS);
155  ret = AVERROR(EINVAL);
156  goto fail;
157  }
158 
159  tctx->formatter = formatter;
160  tctx->level = -1;
161  tctx->sections = sections;
162  tctx->nb_sections = nb_sections;
163  tctx->writer = writer_context;
164 
165  if (formatter->priv_class) {
166  void *priv_ctx = tctx->priv;
167  *(const AVClass **)priv_ctx = formatter->priv_class;
168  av_opt_set_defaults(priv_ctx);
169  }
170 
171  /* convert options to dictionary */
172  if (args) {
173  AVDictionary *opts = NULL;
174  const AVDictionaryEntry *opt = NULL;
175 
176  if ((ret = av_dict_parse_string(&opts, args, "=", ":", 0)) < 0) {
177  av_log(tctx, AV_LOG_ERROR, "Failed to parse option string '%s' provided to textformat context\n", args);
178  av_dict_free(&opts);
179  goto fail;
180  }
181 
182  while ((opt = av_dict_iterate(opts, opt))) {
183  if ((ret = av_opt_set(tctx, opt->key, opt->value, AV_OPT_SEARCH_CHILDREN)) < 0) {
184  av_log(tctx, AV_LOG_ERROR, "Failed to set option '%s' with value '%s' provided to textformat context\n",
185  opt->key, opt->value);
186  av_dict_free(&opts);
187  goto fail;
188  }
189  }
190 
191  av_dict_free(&opts);
192  }
193 
194  if (show_data_hash) {
195  if ((ret = av_hash_alloc(&tctx->hash, show_data_hash)) < 0) {
196  if (ret == AVERROR(EINVAL)) {
197  const char *n;
198  av_log(NULL, AV_LOG_ERROR, "Unknown hash algorithm '%s'\nKnown algorithms:", show_data_hash);
199  for (unsigned i = 0; (n = av_hash_names(i)); i++)
200  av_log(NULL, AV_LOG_ERROR, " %s", n);
201  av_log(NULL, AV_LOG_ERROR, "\n");
202  }
203  goto fail;
204  }
205  }
206 
207  /* validate replace string */
208  {
209  const uint8_t *p = (uint8_t *)tctx->string_validation_replacement;
210  const uint8_t *endp = p + strlen((const char *)p);
211  while (*p) {
212  const uint8_t *p0 = p;
213  int32_t code;
214  ret = av_utf8_decode(&code, &p, endp, tctx->string_validation_utf8_flags);
215  if (ret < 0) {
216  AVBPrint bp;
217  av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
218  bprint_bytes(&bp, p0, p - p0);
219  av_log(tctx, AV_LOG_ERROR,
220  "Invalid UTF8 sequence %s found in string validation replace '%s'\n",
221  bp.str, tctx->string_validation_replacement);
222  goto fail;
223  }
224  }
225  }
226 
227  if (tctx->formatter->init)
228  ret = tctx->formatter->init(tctx);
229  if (ret < 0)
230  goto fail;
231 
232  *ptctx = tctx;
233 
234  return 0;
235 
236 fail:
237  avtext_context_close(&tctx);
238  return ret;
239 }
240 
241 /* Temporary definitions during refactoring */
242 static const char unit_second_str[] = "s";
243 static const char unit_hertz_str[] = "Hz";
244 static const char unit_byte_str[] = "byte";
245 static const char unit_bit_per_second_str[] = "bit/s";
246 
247 
248 void avtext_print_section_header(AVTextFormatContext *tctx, const void *data, int section_id)
249 {
250  if (section_id < 0 || section_id >= tctx->nb_sections) {
251  av_log(tctx, AV_LOG_ERROR, "Invalid section_id for section_header: %d\n", section_id);
252  return;
253  }
254 
255  tctx->level++;
256  av_assert0(tctx->level < SECTION_MAX_NB_LEVELS);
257 
258  tctx->nb_item[tctx->level] = 0;
259  memset(tctx->nb_item_type[tctx->level], 0, sizeof(tctx->nb_item_type[tctx->level]));
260  tctx->section[tctx->level] = &tctx->sections[section_id];
261 
262  if (tctx->formatter->print_section_header)
263  tctx->formatter->print_section_header(tctx, data);
264 }
265 
266 void avtext_print_section_footer(AVTextFormatContext *tctx)
267 {
268  if (tctx->level < 0 || tctx->level >= SECTION_MAX_NB_LEVELS) {
269  av_log(tctx, AV_LOG_ERROR, "Invalid level for section_footer: %d\n", tctx->level);
270  return;
271  }
272 
273  int section_id = tctx->section[tctx->level]->id;
274  int parent_section_id = tctx->level ?
275  tctx->section[tctx->level - 1]->id : SECTION_ID_NONE;
276 
277  if (parent_section_id != SECTION_ID_NONE) {
278  tctx->nb_item[tctx->level - 1]++;
279  tctx->nb_item_type[tctx->level - 1][section_id]++;
280  }
281 
282  if (tctx->formatter->print_section_footer)
283  tctx->formatter->print_section_footer(tctx);
284  tctx->level--;
285 }
286 
287 void avtext_print_integer(AVTextFormatContext *tctx, const char *key, int64_t val, int flags)
288 {
289  av_assert0(tctx);
290 
291  if (tctx->opts.show_optional_fields == SHOW_OPTIONAL_FIELDS_NEVER)
292  return;
293 
294  if (tctx->opts.show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO
295  && (flags & AV_TEXTFORMAT_PRINT_STRING_OPTIONAL)
296  && !(tctx->formatter->flags & AV_TEXTFORMAT_FLAG_SUPPORTS_OPTIONAL_FIELDS))
297  return;
298 
299  av_assert0(key && tctx->level >= 0 && tctx->level < SECTION_MAX_NB_LEVELS);
300 
301  if (!tctx->opts.is_key_selected || tctx->opts.is_key_selected(tctx, key)) {
302  tctx->formatter->print_integer(tctx, key, val);
303  tctx->nb_item[tctx->level]++;
304  }
305 }
306 
307 static inline int validate_string(AVTextFormatContext *tctx, char **dstp, const char *src)
308 {
309  const uint8_t *p, *endp, *srcp = (const uint8_t *)src;
310  AVBPrint dstbuf;
311  AVBPrint invalid_seq;
312  int invalid_chars_nb = 0, ret = 0;
313 
314  *dstp = NULL;
315  av_bprint_init(&dstbuf, 0, AV_BPRINT_SIZE_UNLIMITED);
316  av_bprint_init(&invalid_seq, 0, AV_BPRINT_SIZE_UNLIMITED);
317 
318  endp = srcp + strlen(src);
319  for (p = srcp; *p;) {
320  int32_t code;
321  int invalid = 0;
322  const uint8_t *p0 = p;
323 
324  if (av_utf8_decode(&code, &p, endp, tctx->string_validation_utf8_flags) < 0) {
325 
326  av_bprint_clear(&invalid_seq);
327 
328  bprint_bytes(&invalid_seq, p0, p - p0);
329 
330  av_log(tctx, AV_LOG_DEBUG, "Invalid UTF-8 sequence '%s' found in string '%s'\n", invalid_seq.str, src);
331  invalid = 1;
332  }
333 
334  if (invalid) {
335  invalid_chars_nb++;
336 
337  switch (tctx->string_validation) {
338  case AV_TEXTFORMAT_STRING_VALIDATION_FAIL:
339  av_log(tctx, AV_LOG_ERROR, "Invalid UTF-8 sequence found in string '%s'\n", src);
340  ret = AVERROR_INVALIDDATA;
341  goto end;
342 
343  case AV_TEXTFORMAT_STRING_VALIDATION_REPLACE:
344  av_bprintf(&dstbuf, "%s", tctx->string_validation_replacement);
345  break;
346  }
347  }
348 
349  if (!invalid || tctx->string_validation == AV_TEXTFORMAT_STRING_VALIDATION_IGNORE)
350  av_bprint_append_data(&dstbuf, p0, p-p0);
351  }
352 
353  if (invalid_chars_nb && tctx->string_validation == AV_TEXTFORMAT_STRING_VALIDATION_REPLACE)
354  av_log(tctx, AV_LOG_WARNING,
355  "%d invalid UTF-8 sequence(s) found in string '%s', replaced with '%s'\n",
356  invalid_chars_nb, src, tctx->string_validation_replacement);
357 
358 end:
359  av_bprint_finalize(&dstbuf, dstp);
360  av_bprint_finalize(&invalid_seq, NULL);
361  return ret;
362 }
363 
364 struct unit_value {
365  union {
366  double d;
367  int64_t i;
368  } val;
369 
370  const char *unit;
371 };
372 
373 static char *value_string(const AVTextFormatContext *tctx, char *buf, int buf_size, struct unit_value uv)
374 {
375  double vald;
376  int64_t vali = 0;
377  int show_float = 0;
378 
379  if (uv.unit == unit_second_str) {
380  vald = uv.val.d;
381  show_float = 1;
382  } else {
383  vald = (double)uv.val.i;
384  vali = uv.val.i;
385  }
386 
387  if (uv.unit == unit_second_str && tctx->opts.use_value_sexagesimal_format) {
388  double secs;
389  int hours, mins;
390  secs = vald;
391  mins = (int)secs / 60;
392  secs = secs - mins * 60;
393  hours = mins / 60;
394  mins %= 60;
395  snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);
396  } else {
397  const char *prefix_string = "";
398 
399  if (tctx->opts.use_value_prefix && vald > 1) {
400  int64_t index;
401 
402  if (uv.unit == unit_byte_str && tctx->opts.use_byte_value_binary_prefix) {
403  index = (int64_t)(log2(vald) / 10);
404  index = av_clip64(index, 0, FF_ARRAY_ELEMS(si_prefixes) - 1);
405  vald /= si_prefixes[index].bin_val;
406  prefix_string = si_prefixes[index].bin_str;
407  } else {
408  index = (int64_t)(log10(vald) / 3);
409  index = av_clip64(index, 0, FF_ARRAY_ELEMS(si_prefixes) - 1);
410  vald /= si_prefixes[index].dec_val;
411  prefix_string = si_prefixes[index].dec_str;
412  }
413  vali = (int64_t)vald;
414  }
415 
416  if (show_float || (tctx->opts.use_value_prefix && vald != (int64_t)vald))
417  snprintf(buf, buf_size, "%f", vald);
418  else
419  snprintf(buf, buf_size, "%"PRId64, vali);
420 
421  av_strlcatf(buf, buf_size, "%s%s%s", *prefix_string || tctx->opts.show_value_unit ? " " : "",
422  prefix_string, tctx->opts.show_value_unit ? uv.unit : "");
423  }
424 
425  return buf;
426 }
427 
428 
429 void avtext_print_unit_integer(AVTextFormatContext *tctx, const char *key, int64_t val, const char *unit)
430 {
431  char val_str[128];
432  struct unit_value uv;
433  uv.val.i = val;
434  uv.unit = unit;
435  avtext_print_string(tctx, key, value_string(tctx, val_str, sizeof(val_str), uv), 0);
436 }
437 
438 
439 int avtext_print_string(AVTextFormatContext *tctx, const char *key, const char *val, int flags)
440 {
441  const AVTextFormatSection *section;
442  int ret = 0;
443 
444  av_assert0(key && val && tctx->level >= 0 && tctx->level < SECTION_MAX_NB_LEVELS);
445 
446  section = tctx->section[tctx->level];
447 
448  if (tctx->opts.show_optional_fields == SHOW_OPTIONAL_FIELDS_NEVER)
449  return 0;
450 
451  if (tctx->opts.show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO
452  && (flags & AV_TEXTFORMAT_PRINT_STRING_OPTIONAL)
453  && !(tctx->formatter->flags & AV_TEXTFORMAT_FLAG_SUPPORTS_OPTIONAL_FIELDS))
454  return 0;
455 
456  if (!tctx->opts.is_key_selected || tctx->opts.is_key_selected(tctx, key)) {
457  if (flags & AV_TEXTFORMAT_PRINT_STRING_VALIDATE) {
458  char *key1 = NULL, *val1 = NULL;
459  ret = validate_string(tctx, &key1, key);
460  if (ret < 0) goto end;
461  ret = validate_string(tctx, &val1, val);
462  if (ret < 0) goto end;
463  tctx->formatter->print_string(tctx, key1, val1);
464  end:
465  if (ret < 0)
466  av_log(tctx, AV_LOG_ERROR,
467  "Invalid key=value string combination %s=%s in section %s\n",
468  key, val, section->unique_name);
469  av_free(key1);
470  av_free(val1);
471  } else {
472  tctx->formatter->print_string(tctx, key, val);
473  }
474 
475  tctx->nb_item[tctx->level]++;
476  }
477 
478  return ret;
479 }
480 
481 void avtext_print_rational(AVTextFormatContext *tctx, const char *key, AVRational q, char sep)
482 {
483  char buf[44];
484  snprintf(buf, sizeof(buf), "%d%c%d", q.num, sep, q.den);
485  avtext_print_string(tctx, key, buf, 0);
486 }
487 
488 void avtext_print_time(AVTextFormatContext *tctx, const char *key,
489  int64_t ts, const AVRational *time_base, int is_duration)
490 {
491  if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
492  avtext_print_string(tctx, key, "N/A", AV_TEXTFORMAT_PRINT_STRING_OPTIONAL);
493  } else {
494  char buf[128];
495  double d = av_q2d(*time_base) * ts;
496  struct unit_value uv;
497  uv.val.d = d;
498  uv.unit = unit_second_str;
499  value_string(tctx, buf, sizeof(buf), uv);
500  avtext_print_string(tctx, key, buf, 0);
501  }
502 }
503 
504 void avtext_print_ts(AVTextFormatContext *tctx, const char *key, int64_t ts, int is_duration)
505 {
506  if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0))
507  avtext_print_string(tctx, key, "N/A", AV_TEXTFORMAT_PRINT_STRING_OPTIONAL);
508  else
509  avtext_print_integer(tctx, key, ts, 0);
510 }
511 
512 static void print_data_xxd(AVBPrint *bp, const uint8_t *data, int size)
513 {
514  unsigned offset = 0;
515  int i;
516 
517  av_bprintf(bp, "\n");
518  while (size) {
519  av_bprintf(bp, "%08x: ", offset);
520  int l = FFMIN(size, 16);
521  for (i = 0; i < l; i++) {
522  av_bprintf(bp, "%02x", data[i]);
523  if (i & 1)
524  av_bprintf(bp, " ");
525  }
526  av_bprint_chars(bp, ' ', 41 - 2 * i - i / 2);
527  for (i = 0; i < l; i++)
528  av_bprint_chars(bp, data[i] - 32U < 95 ? data[i] : '.', 1);
529  av_bprintf(bp, "\n");
530  offset += l;
531  data += l;
532  size -= l;
533  }
534 }
535 
536 static void print_data_base64(AVBPrint *bp, const uint8_t *data, int size)
537 {
538  char buf[AV_BASE64_SIZE(60)];
539 
540  av_bprintf(bp, "\n");
541  while (size) {
542  int l = FFMIN(size, 60);
543  av_base64_encode(buf, sizeof(buf), data, l);
544  av_bprintf(bp, "%s\n", buf);
545  data += l;
546  size -= l;
547  }
548 }
549 void avtext_print_data(AVTextFormatContext *tctx, const char *key,
550  const uint8_t *data, int size)
551 {
552  AVBPrint bp;
553  av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
554  switch (tctx->opts.data_dump_format) {
555  case AV_TEXTFORMAT_DATADUMP_XXD:
556  print_data_xxd(&bp, data, size);
557  break;
558  case AV_TEXTFORMAT_DATADUMP_BASE64:
559  print_data_base64(&bp, data, size);
560  break;
561  default:
562  av_unreachable("Invalid data dump type");
563  }
564  avtext_print_string(tctx, key, bp.str, 0);
565  av_bprint_finalize(&bp, NULL);
566 }
567 
568 void avtext_print_data_hash(AVTextFormatContext *tctx, const char *key,
569  const uint8_t *data, int size)
570 {
571  char buf[AV_HASH_MAX_SIZE * 2 + 64] = { 0 };
572  int len;
573 
574  if (!tctx->hash)
575  return;
576 
577  av_hash_init(tctx->hash);
578  av_hash_update(tctx->hash, data, size);
579  len = snprintf(buf, sizeof(buf), "%s:", av_hash_get_name(tctx->hash));
580  av_hash_final_hex(tctx->hash, (uint8_t *)&buf[len], (int)sizeof(buf) - len);
581  avtext_print_string(tctx, key, buf, 0);
582 }
583 
584 static const char *writercontext_get_writer_name(void *p)
585 {
586  AVTextWriterContext *wctx = p;
587  return wctx->writer->name;
588 }
589 
590 static void *writercontext_child_next(void *obj, void *prev)
591 {
592  AVTextFormatContext *ctx = obj;
593  if (!prev && ctx->formatter && ctx->formatter->priv_class && ctx->priv)
594  return ctx->priv;
595  return NULL;
596 }
597 
598 static const AVClass textwriter_class = {
599  .class_name = "AVTextWriterContext",
600  .item_name = writercontext_get_writer_name,
601  .version = LIBAVUTIL_VERSION_INT,
602  .child_next = writercontext_child_next,
603 };
604 
605 
606 int avtextwriter_context_close(AVTextWriterContext **pwctx)
607 {
608  AVTextWriterContext *wctx = *pwctx;
609  int ret = 0;
610 
611  if (!wctx)
612  return AVERROR(EINVAL);
613 
614  if (wctx->writer) {
615  if (wctx->writer->uninit)
616  ret = wctx->writer->uninit(wctx);
617  if (wctx->writer->priv_class)
618  av_opt_free(wctx->priv);
619  }
620  av_freep(&wctx->priv);
621  av_freep(pwctx);
622  return ret;
623 }
624 
625 
626 int avtextwriter_context_open(AVTextWriterContext **pwctx, const AVTextWriter *writer)
627 {
628  AVTextWriterContext *wctx;
629  int ret = 0;
630 
631  if (!pwctx || !writer)
632  return AVERROR(EINVAL);
633 
634  if (!((wctx = av_mallocz(sizeof(AVTextWriterContext))))) {
635  ret = AVERROR(ENOMEM);
636  goto fail;
637  }
638 
639  if (writer->priv_size && !((wctx->priv = av_mallocz(writer->priv_size)))) {
640  ret = AVERROR(ENOMEM);
641  goto fail;
642  }
643 
644  if (writer->priv_class) {
645  void *priv_ctx = wctx->priv;
646  *(const AVClass **)priv_ctx = writer->priv_class;
647  av_opt_set_defaults(priv_ctx);
648  }
649 
650  wctx->class = &textwriter_class;
651  wctx->writer = writer;
652 
653  av_opt_set_defaults(wctx);
654 
655 
656  if (wctx->writer->init)
657  ret = wctx->writer->init(wctx);
658  if (ret < 0)
659  goto fail;
660 
661  *pwctx = wctx;
662 
663  return 0;
664 
665 fail:
666  avtextwriter_context_close(&wctx);
667  return ret;
668 }
669 
670 static const AVTextFormatter *const registered_formatters[] =
671 {
672  &avtextformatter_default,
673  &avtextformatter_compact,
674  &avtextformatter_csv,
675  &avtextformatter_flat,
676  &avtextformatter_ini,
677  &avtextformatter_json,
678  &avtextformatter_xml,
679  &avtextformatter_mermaid,
680  &avtextformatter_mermaidhtml,
681  NULL
682 };
683 
684 const AVTextFormatter *avtext_get_formatter_by_name(const char *name)
685 {
686  for (int i = 0; registered_formatters[i]; i++) {
687  const char *end;
688  if (av_strstart(name, registered_formatters[i]->name, &end) &&
689  (*end == '\0' || *end == '='))
690  return registered_formatters[i];
691  }
692 
693  return NULL;
694 }
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
flags
const SwsFlags flags[]
Definition: swscale.c:61
AVTextFormatOptions::use_value_prefix
int use_value_prefix
Definition: avtextformat.h:127
value_string
static char * value_string(const AVTextFormatContext *tctx, char *buf, int buf_size, struct unit_value uv)
Definition: avtextformat.c:373
validate_string
static int validate_string(AVTextFormatContext *tctx, char **dstp, const char *src)
Definition: avtextformat.c:307
avtext_print_time
void avtext_print_time(AVTextFormatContext *tctx, const char *key, int64_t ts, const AVRational *time_base, int is_duration)
Definition: avtextformat.c:488
AVTextWriter::init
int(* init)(AVTextWriterContext *wctx)
Definition: avtextwriters.h:35
av_utf8_decode
int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end, unsigned int flags)
Read and decode a single UTF-8 code point (character) from the buffer in *buf, and update *buf to poi...
Definition: avstring.c:369
writercontext_get_writer_name
static const char * writercontext_get_writer_name(void *p)
Definition: avtextformat.c:584
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AV_TEXTFORMAT_PRINT_STRING_OPTIONAL
#define AV_TEXTFORMAT_PRINT_STRING_OPTIONAL
Definition: avtextformat.h:164
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
avtext_print_ts
void avtext_print_ts(AVTextFormatContext *tctx, const char *key, int64_t ts, int is_duration)
Definition: avtextformat.c:504
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1678
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
si_prefixes
static const struct @15 si_prefixes[]
unit_value::i
int64_t i
Definition: avtextformat.c:367
textcontext_options
static const AVOption textcontext_options[]
Definition: avtextformat.c:66
opt.h
AVTextFormatContext::opts
AVTextFormatOptions opts
Definition: avtextformat.h:155
AVTextWriter::priv_size
int priv_size
private size for the writer private class
Definition: avtextwriters.h:32
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AV_HASH_MAX_SIZE
#define AV_HASH_MAX_SIZE
Maximum value that av_hash_get_size() will currently return.
Definition: hash.h:156
AVTextFormatContext::nb_item_type
unsigned int nb_item_type[SECTION_MAX_NB_LEVELS][SECTION_MAX_NB_SECTIONS]
Definition: avtextformat.h:148
int64_t
long long int64_t
Definition: coverity.c:34
avtext_print_integer
void avtext_print_integer(AVTextFormatContext *tctx, const char *key, int64_t val, int flags)
Definition: avtextformat.c:287
avtextformatter_compact
const AVTextFormatter avtextformatter_compact
Definition: tf_compact.c:239
AV_TEXTFORMAT_STRING_VALIDATION_NB
@ AV_TEXTFORMAT_STRING_VALIDATION_NB
Definition: avtextformat.h:77
AVOption
AVOption.
Definition: opt.h:429
data
const char data[16]
Definition: mxf.c:149
AVTextWriterContext
Definition: avtextwriters.h:42
avtextformat.h
avtext_print_unit_integer
void avtext_print_unit_integer(AVTextFormatContext *tctx, const char *key, int64_t val, const char *unit)
Definition: avtextformat.c:429
AVTextFormatContext
Definition: avtextformat.h:133
dec_str
char dec_str[4]
Definition: avtextformat.c:48
AVTextWriterContext::priv
void * priv
private data for use by the writer
Definition: avtextwriters.h:46
AVDictionary
Definition: dict.c:32
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
textcontext_class
static const AVClass textcontext_class
Definition: avtextformat.c:87
AVTextFormatSection::id
int id
unique id identifying a section
Definition: avtextformat.h:42
avtextformatter_mermaid
const AVTextFormatter avtextformatter_mermaid
Definition: tf_mermaid.c:651
AVTextFormatContext::level
int level
current level, starting from 0
Definition: avtextformat.h:144
AVTextWriter::uninit
int(* uninit)(AVTextWriterContext *wctx)
Definition: avtextwriters.h:36
macros.h
fail
#define fail()
Definition: checkasm.h:218
av_hash_get_name
const char * av_hash_get_name(const AVHashContext *ctx)
Definition: hash.c:104
textcontext_get_formatter_name
static const char * textcontext_get_formatter_name(void *p)
Definition: avtextformat.c:58
AV_TEXTFORMAT_DATADUMP_BASE64
@ AV_TEXTFORMAT_DATADUMP_BASE64
Definition: avtextformat.h:94
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1949
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
val
static double val(void *priv, double ch)
Definition: aeval.c:77
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
AV_TEXTFORMAT_PRINT_STRING_VALIDATE
#define AV_TEXTFORMAT_PRINT_STRING_VALIDATE
Definition: avtextformat.h:165
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_clip64
#define av_clip64
Definition: common.h:103
AVTextFormatContext::writer
AVTextWriterContext * writer
the AVTextWriterContext
Definition: avtextformat.h:136
AVTextFormatOptions::data_dump_format
AVTextFormatDataDump data_dump_format
Definition: avtextformat.h:130
avassert.h
SECTION_ID_NONE
#define SECTION_ID_NONE
Definition: avtextformat.c:38
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
AVTextFormatOptions::is_key_selected
int(* is_key_selected)(struct AVTextFormatContext *tctx, const char *key)
Callback to discard certain elements based upon the key used.
Definition: avtextformat.h:124
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
registered_formatters
static const AVTextFormatter *const registered_formatters[]
Definition: avtextformat.c:670
avtextformatter_default
const AVTextFormatter avtextformatter_default
Definition: tf_default.c:127
print_data_base64
static void print_data_base64(AVBPrint *bp, const uint8_t *data, int size)
Definition: avtextformat.c:536
unit_bit_per_second_str
static const char unit_bit_per_second_str[]
Definition: avtextformat.c:245
AVTextFormatter::print_string
void(* print_string)(AVTextFormatContext *tctx, const char *, const char *)
Definition: avtextformat.h:108
textcontext_child_next
static void * textcontext_child_next(void *obj, void *prev)
Definition: avtextformat.c:79
intreadwrite.h
AVTextFormatter
Definition: avtextformat.h:97
SECTION_MAX_NB_SECTIONS
#define SECTION_MAX_NB_SECTIONS
Definition: avtextformat.h:113
unit_value::val
union unit_value::@16 val
avtext_print_data_hash
void avtext_print_data_hash(AVTextFormatContext *tctx, const char *key, const uint8_t *data, int size)
Definition: avtextformat.c:568
AVTextWriterContext::class
const AVClass * class
class of the writer
Definition: avtextwriters.h:43
AVDictionaryEntry::key
char * key
Definition: dict.h:91
avtextwriter_context_close
int avtextwriter_context_close(AVTextWriterContext **pwctx)
Definition: avtextformat.c:606
AVTextFormatSection
Definition: avtextformat.h:41
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_hash_alloc
int av_hash_alloc(AVHashContext **ctx, const char *name)
Allocate a hash context for the algorithm specified by name.
Definition: hash.c:114
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
static AVFormatContext * ctx
Definition: movenc.c:49
bin_str
char bin_str[4]
Definition: avtextformat.c:47
avtextformatter_ini
const AVTextFormatter avtextformatter_ini
Definition: tf_ini.c:141
avtext_context_open
int avtext_context_open(AVTextFormatContext **ptctx, const AVTextFormatter *formatter, AVTextWriterContext *writer_context, const char *args, const AVTextFormatSection *sections, int nb_sections, AVTextFormatOptions options, char *show_data_hash)
Definition: avtextformat.c:127
limits.h
AVTextWriter::priv_class
const AVClass * priv_class
private class of the writer, if any
Definition: avtextwriters.h:31
AV_TEXTFORMAT_DATADUMP_XXD
@ AV_TEXTFORMAT_DATADUMP_XXD
Definition: avtextformat.h:93
AVTextFormatContext::priv
void * priv
private data for use by the filter
Definition: avtextformat.h:139
key
const char * key
Definition: hwcontext_opencl.c:189
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
AVTextFormatter::priv_size
int priv_size
private size for the formatter context
Definition: avtextformat.h:99
dec_val
double dec_val
Definition: avtextformat.c:46
AVTextFormatSection::unique_name
const char * unique_name
unique section name, in case the name is ambiguous
Definition: avtextformat.h:59
opts
static AVDictionary * opts
Definition: movenc.c:51
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
avtext_print_string
int avtext_print_string(AVTextFormatContext *tctx, const char *key, const char *val, int flags)
Definition: avtextformat.c:439
av_hash_names
const char * av_hash_names(int i)
Get the names of available hash algorithms.
Definition: hash.c:98
AVTextFormatContext::section
const AVTextFormatSection * section[SECTION_MAX_NB_LEVELS]
section per each level
Definition: avtextformat.h:151
unit_second_str
static const char unit_second_str[]
Definition: avtextformat.c:242
av_hash_init
void av_hash_init(AVHashContext *ctx)
Initialize or reset a hash context.
Definition: hash.c:151
SHOW_OPTIONAL_FIELDS_AUTO
#define SHOW_OPTIONAL_FIELDS_AUTO
Definition: avtextformat.c:40
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_unreachable
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition: avassert.h:108
bprint_bytes
static void bprint_bytes(AVBPrint *bp, const uint8_t *ubuf, size_t ubuf_size)
Definition: avtextformat.c:95
AVTextWriter::name
const char * name
Definition: avtextwriters.h:33
options
Definition: swscale.c:43
AVTextFormatter::print_section_header
void(* print_section_header)(AVTextFormatContext *tctx, const void *data)
Definition: avtextformat.h:105
AV_TEXTFORMAT_STRING_VALIDATION_IGNORE
@ AV_TEXTFORMAT_STRING_VALIDATION_IGNORE
Definition: avtextformat.h:76
double
double
Definition: af_crystalizer.c:132
AVTextFormatContext::formatter
const AVTextFormatter * formatter
the AVTextFormatter of which this is an instance
Definition: avtextformat.h:135
av_hash_update
void av_hash_update(AVHashContext *ctx, const uint8_t *src, size_t len)
Update a hash context with additional data.
Definition: hash.c:172
avtext_get_formatter_by_name
const AVTextFormatter * avtext_get_formatter_by_name(const char *name)
Definition: avtextformat.c:684
base64.h
index
int index
Definition: gxfenc.c:90
SECTION_MAX_NB_LEVELS
#define SECTION_MAX_NB_LEVELS
Definition: avtextformat.h:112
av_hash_freep
void av_hash_freep(AVHashContext **ctx)
Free hash context and set hash context pointer to NULL.
Definition: hash.c:248
error.h
avtextformatter_flat
const AVTextFormatter avtextformatter_flat
Definition: tf_flat.c:151
options
const OptionDef options[]
avtextwriter_context_open
int avtextwriter_context_open(AVTextWriterContext **pwctx, const AVTextWriter *writer)
Definition: avtextformat.c:626
AVTextWriter
Definition: avtextwriters.h:30
unit_hertz_str
static const char unit_hertz_str[]
Definition: avtextformat.c:243
AV_TEXTFORMAT_STRING_VALIDATION_FAIL
@ AV_TEXTFORMAT_STRING_VALIDATION_FAIL
Definition: avtextformat.h:74
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
AVTextFormatter::name
const char * name
Definition: avtextformat.h:100
avtext_print_section_footer
void avtext_print_section_footer(AVTextFormatContext *tctx)
Definition: avtextformat.c:266
AVTextWriterContext::writer
const AVTextWriter * writer
Definition: avtextwriters.h:44
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
AVTextFormatContext::section_pbuf
AVBPrint section_pbuf[SECTION_MAX_NB_LEVELS]
generic print buffer dedicated to each section, used by various formatters
Definition: avtextformat.h:152
unit_value
Definition: avtextformat.c:364
SHOW_OPTIONAL_FIELDS_NEVER
#define SHOW_OPTIONAL_FIELDS_NEVER
Definition: avtextformat.c:41
AVTextFormatter::flags
int flags
a combination or AV_TEXTFORMAT__FLAG_*
Definition: avtextformat.h:109
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:233
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:36
textwriter_class
static const AVClass textwriter_class
Definition: avtextformat.c:598
AVTextFormatContext::sections
const AVTextFormatSection * sections
array containing all sections
Definition: avtextformat.h:141
avtext_print_rational
void avtext_print_rational(AVTextFormatContext *tctx, const char *key, AVRational q, char sep)
Definition: avtextformat.c:481
unit_value::unit
const char * unit
Definition: avtextformat.c:370
AVTextFormatContext::class
const AVClass * class
class of the formatter
Definition: avtextformat.h:134
bprint.h
AV_BASE64_SIZE
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
avtextformatter_xml
const AVTextFormatter avtextformatter_xml
Definition: tf_xml.c:202
AVTextFormatter::uninit
int(* uninit)(AVTextFormatContext *tctx)
Definition: avtextformat.h:103
AVTextFormatContext::string_validation_utf8_flags
unsigned int string_validation_utf8_flags
Definition: avtextformat.h:161
len
int len
Definition: vorbis_enc_data.h:426
writercontext_child_next
static void * writercontext_child_next(void *obj, void *prev)
Definition: avtextformat.c:590
avtextformatter_json
const AVTextFormatter avtextformatter_json
Definition: tf_json.c:203
log2
#define log2(x)
Definition: libm.h:406
AVTextFormatter::print_section_footer
void(* print_section_footer)(AVTextFormatContext *tctx)
Definition: avtextformat.h:106
AVTextFormatOptions::use_value_sexagesimal_format
int use_value_sexagesimal_format
Definition: avtextformat.h:129
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:122
U
#define U(x)
Definition: vpx_arith.h:37
hash.h
AVTextFormatter::priv_class
const AVClass * priv_class
private class of the formatter, if any
Definition: avtextformat.h:98
AVTextFormatter::print_integer
void(* print_integer)(AVTextFormatContext *tctx, const char *, int64_t)
Definition: avtextformat.h:107
AVTextFormatOptions::show_optional_fields
int show_optional_fields
Definition: avtextformat.h:125
AVTextFormatContext::string_validation
int string_validation
Definition: avtextformat.h:159
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVTextFormatOptions
Definition: avtextformat.h:115
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:227
sections
static const AVTextFormatSection sections[]
Definition: ffprobe.c:256
av_dict_parse_string
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:210
AVTextFormatter::init
int(* init)(AVTextFormatContext *tctx)
Definition: avtextformat.h:102
unit_byte_str
static const char unit_byte_str[]
Definition: avtextformat.c:244
av_base64_encode
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Definition: base64.c:147
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
AVTextFormatOptions::show_value_unit
int show_value_unit
Definition: avtextformat.h:126
print_data_xxd
static void print_data_xxd(AVBPrint *bp, const uint8_t *data, int size)
Definition: avtextformat.c:512
mem.h
avtextformatter_csv
const AVTextFormatter avtextformatter_csv
Definition: tf_compact.c:270
av_hash_final_hex
void av_hash_final_hex(struct AVHashContext *ctx, uint8_t *dst, int size)
Finalize a hash context and store the hexadecimal representation of the actual hash value as a string...
Definition: hash.c:225
AVTextFormatContext::nb_item
unsigned int nb_item[SECTION_MAX_NB_LEVELS]
number of the item printed in the given section, starting from 0
Definition: avtextformat.h:147
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
int32_t
int32_t
Definition: audioconvert.c:56
OFFSET
#define OFFSET(x)
Definition: avtextformat.c:64
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
avtext_print_data
void avtext_print_data(AVTextFormatContext *tctx, const char *key, const uint8_t *data, int size)
Definition: avtextformat.c:549
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:130
AV_TEXTFORMAT_STRING_VALIDATION_REPLACE
@ AV_TEXTFORMAT_STRING_VALIDATION_REPLACE
Definition: avtextformat.h:75
AVDictionaryEntry::value
char * value
Definition: dict.h:92
show_data_hash
static char * show_data_hash
Definition: ffprobe.c:146
bin_val
double bin_val
Definition: avtextformat.c:45
AV_TEXTFORMAT_FLAG_SUPPORTS_OPTIONAL_FIELDS
#define AV_TEXTFORMAT_FLAG_SUPPORTS_OPTIONAL_FIELDS
Definition: avtextformat.h:69
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
unit_value::d
double d
Definition: avtextformat.c:366
avtext_context_close
int avtext_context_close(AVTextFormatContext **ptctx)
Definition: avtextformat.c:102
av_bprint_append_data
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:148
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
avtextformatter_mermaidhtml
const AVTextFormatter avtextformatter_mermaidhtml
Definition: tf_mermaid.c:665
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
src
#define src
Definition: vp8dsp.c:248
AVTextFormatOptions::use_byte_value_binary_prefix
int use_byte_value_binary_prefix
Definition: avtextformat.h:128
AVTextFormatContext::nb_sections
int nb_sections
number of sections
Definition: avtextformat.h:142
AVTextFormatContext::hash
struct AVHashContext * hash
Definition: avtextformat.h:157
avtext_print_section_header
void avtext_print_section_header(AVTextFormatContext *tctx, const void *data, int section_id)
Definition: avtextformat.c:248
AVTextFormatContext::string_validation_replacement
char * string_validation_replacement
Definition: avtextformat.h:160
Generated on Thu Feb 5 2026 19:22:10 for FFmpeg by   doxygen 1.8.17