FFmpeg  4.4.5
dvdsubenc.c
Go to the documentation of this file.
1 /*
2  * DVD subtitle encoding
3  * Copyright (c) 2005 Wolfram Gloger
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 #include "avcodec.h"
22 #include "bytestream.h"
23 #include "internal.h"
24 #include "libavutil/avassert.h"
25 #include "libavutil/bprint.h"
26 #include "libavutil/imgutils.h"
27 #include "libavutil/opt.h"
28 
29 typedef struct {
30  AVClass *class;
31  uint32_t global_palette[16];
32  char *palette_str;
35 
36 // ncnt is the nibble counter
37 #define PUTNIBBLE(val)\
38 do {\
39  if (ncnt++ & 1)\
40  *q++ = bitbuf | ((val) & 0x0f);\
41  else\
42  bitbuf = (val) << 4;\
43 } while(0)
44 
45 static void dvd_encode_rle(uint8_t **pq,
46  const uint8_t *bitmap, int linesize,
47  int w, int h,
48  const int cmap[256])
49 {
50  uint8_t *q;
51  unsigned int bitbuf = 0;
52  int ncnt;
53  int x, y, len, color;
54 
55  q = *pq;
56 
57  for (y = 0; y < h; ++y) {
58  ncnt = 0;
59  for(x = 0; x < w; x += len) {
60  color = bitmap[x];
61  for (len=1; x+len < w; ++len)
62  if (bitmap[x+len] != color)
63  break;
64  color = cmap[color];
65  av_assert0(color < 4);
66  if (len < 0x04) {
67  PUTNIBBLE((len << 2)|color);
68  } else if (len < 0x10) {
69  PUTNIBBLE(len >> 2);
70  PUTNIBBLE((len << 2)|color);
71  } else if (len < 0x40) {
72  PUTNIBBLE(0);
73  PUTNIBBLE(len >> 2);
74  PUTNIBBLE((len << 2)|color);
75  } else if (x+len == w) {
76  PUTNIBBLE(0);
77  PUTNIBBLE(0);
78  PUTNIBBLE(0);
80  } else {
81  if (len > 0xff)
82  len = 0xff;
83  PUTNIBBLE(0);
84  PUTNIBBLE(len >> 6);
85  PUTNIBBLE(len >> 2);
86  PUTNIBBLE((len << 2)|color);
87  }
88  }
89  /* end of line */
90  if (ncnt & 1)
91  PUTNIBBLE(0);
92  bitmap += linesize;
93  }
94 
95  *pq = q;
96 }
97 
98 static int color_distance(uint32_t a, uint32_t b)
99 {
100  int r = 0, d, i;
101  int alpha_a = 8, alpha_b = 8;
102 
103  for (i = 24; i >= 0; i -= 8) {
104  d = alpha_a * (int)((a >> i) & 0xFF) -
105  alpha_b * (int)((b >> i) & 0xFF);
106  r += d * d;
107  alpha_a = a >> 28;
108  alpha_b = b >> 28;
109  }
110  return r;
111 }
112 
113 /**
114  * Count colors used in a rectangle, quantizing alpha and grouping by
115  * nearest global palette entry.
116  */
117 static void count_colors(AVCodecContext *avctx, unsigned hits[33],
118  const AVSubtitleRect *r)
119 {
120  DVDSubtitleContext *dvdc = avctx->priv_data;
121  unsigned count[256] = { 0 };
122  uint32_t *palette = (uint32_t *)r->data[1];
123  uint32_t color;
124  int x, y, i, j, match, d, best_d, av_uninit(best_j);
125  uint8_t *p = r->data[0];
126 
127  for (y = 0; y < r->h; y++) {
128  for (x = 0; x < r->w; x++)
129  count[*(p++)]++;
130  p += r->linesize[0] - r->w;
131  }
132  for (i = 0; i < 256; i++) {
133  if (!count[i]) /* avoid useless search */
134  continue;
135  color = palette[i];
136  /* 0: transparent, 1-16: semi-transparent, 17-33 opaque */
137  match = color < 0x33000000 ? 0 : color < 0xCC000000 ? 1 : 17;
138  if (match) {
139  best_d = INT_MAX;
140  for (j = 0; j < 16; j++) {
141  d = color_distance(0xFF000000 | color,
142  0xFF000000 | dvdc->global_palette[j]);
143  if (d < best_d) {
144  best_d = d;
145  best_j = j;
146  }
147  }
148  match += best_j;
149  }
150  hits[match] += count[i];
151  }
152 }
153 
154 static void select_palette(AVCodecContext *avctx, int out_palette[4],
155  int out_alpha[4], unsigned hits[33])
156 {
157  DVDSubtitleContext *dvdc = avctx->priv_data;
158  int i, j, bright, mult;
159  uint32_t color;
160  int selected[4] = { 0 };
161  uint32_t pseudopal[33] = { 0 };
162  uint32_t refcolor[3] = { 0x00000000, 0xFFFFFFFF, 0xFF000000 };
163 
164  /* Bonus for transparent: if the rectangle fits tightly the text, the
165  background color can be quite rare, but it would be ugly without it */
166  hits[0] *= 16;
167  /* Bonus for bright colors */
168  for (i = 0; i < 16; i++) {
169  if (!(hits[1 + i] + hits[17 + i]))
170  continue; /* skip unused colors to gain time */
171  color = dvdc->global_palette[i];
172  bright = 0;
173  for (j = 0; j < 3; j++, color >>= 8)
174  bright += (color & 0xFF) < 0x40 || (color & 0xFF) >= 0xC0;
175  mult = 2 + FFMIN(bright, 2);
176  hits[ 1 + i] *= mult;
177  hits[17 + i] *= mult;
178  }
179 
180  /* Select four most frequent colors */
181  for (i = 0; i < 4; i++) {
182  for (j = 0; j < 33; j++)
183  if (hits[j] > hits[selected[i]])
184  selected[i] = j;
185  hits[selected[i]] = 0;
186  }
187 
188  /* Order the colors like in most DVDs:
189  0: background, 1: foreground, 2: outline */
190  for (i = 0; i < 16; i++) {
191  pseudopal[ 1 + i] = 0x80000000 | dvdc->global_palette[i];
192  pseudopal[17 + i] = 0xFF000000 | dvdc->global_palette[i];
193  }
194  for (i = 0; i < 3; i++) {
195  int best_d = color_distance(refcolor[i], pseudopal[selected[i]]);
196  for (j = i + 1; j < 4; j++) {
197  int d = color_distance(refcolor[i], pseudopal[selected[j]]);
198  if (d < best_d) {
199  FFSWAP(int, selected[i], selected[j]);
200  best_d = d;
201  }
202  }
203  }
204 
205  /* Output */
206  for (i = 0; i < 4; i++) {
207  out_palette[i] = selected[i] ? (selected[i] - 1) & 0xF : 0;
208  out_alpha [i] = !selected[i] ? 0 : selected[i] < 17 ? 0x80 : 0xFF;
209  }
210 }
211 
212 static void build_color_map(AVCodecContext *avctx, int cmap[],
213  const uint32_t palette[],
214  const int out_palette[], unsigned int const out_alpha[])
215 {
216  DVDSubtitleContext *dvdc = avctx->priv_data;
217  int i, j, d, best_d;
218  uint32_t pseudopal[4];
219 
220  for (i = 0; i < 4; i++)
221  pseudopal[i] = (out_alpha[i] << 24) |
222  dvdc->global_palette[out_palette[i]];
223  for (i = 0; i < 256; i++) {
224  best_d = INT_MAX;
225  for (j = 0; j < 4; j++) {
226  d = color_distance(pseudopal[j], palette[i]);
227  if (d < best_d) {
228  cmap[i] = j;
229  best_d = d;
230  }
231  }
232  }
233 }
234 
235 static void copy_rectangle(AVSubtitleRect *dst, AVSubtitleRect *src, int cmap[])
236 {
237  int x, y;
238  uint8_t *p, *q;
239 
240  p = src->data[0];
241  q = dst->data[0] + (src->x - dst->x) +
242  (src->y - dst->y) * dst->linesize[0];
243  for (y = 0; y < src->h; y++) {
244  for (x = 0; x < src->w; x++)
245  *(q++) = cmap[*(p++)];
246  p += src->linesize[0] - src->w;
247  q += dst->linesize[0] - src->w;
248  }
249 }
250 
252  uint8_t *outbuf, int outbuf_size,
253  const AVSubtitle *h)
254 {
255  DVDSubtitleContext *dvdc = avctx->priv_data;
256  uint8_t *q, *qq;
257  int offset1, offset2;
258  int i, rects = h->num_rects, ret;
259  unsigned global_palette_hits[33] = { 0 };
260  int cmap[256];
261  int out_palette[4];
262  int out_alpha[4];
263  AVSubtitleRect vrect;
264  uint8_t *vrect_data = NULL;
265  int x2, y2;
266  int forced = 0;
267 
268  if (rects == 0 || !h->rects)
269  return AVERROR(EINVAL);
270  for (i = 0; i < rects; i++)
271  if (h->rects[i]->type != SUBTITLE_BITMAP) {
272  av_log(avctx, AV_LOG_ERROR, "Bitmap subtitle required\n");
273  return AVERROR(EINVAL);
274  }
275  /* Mark this subtitle forced if any of the rectangles is forced. */
276  for (i = 0; i < rects; i++)
277  if ((h->rects[i]->flags & AV_SUBTITLE_FLAG_FORCED) != 0) {
278  forced = 1;
279  break;
280  }
281 
282 #if FF_API_AVPICTURE
284  for (i = 0; i < rects; i++)
285  if (!h->rects[i]->data[0]) {
286  AVSubtitleRect *rect = h->rects[i];
287  int j;
288  for (j = 0; j < 4; j++) {
289  rect->data[j] = rect->pict.data[j];
290  rect->linesize[j] = rect->pict.linesize[j];
291  }
292  }
294 #endif
295 
296  vrect = *h->rects[0];
297 
298  if (rects > 1) {
299  /* DVD subtitles can have only one rectangle: build a virtual
300  rectangle containing all actual rectangles.
301  The data of the rectangles will be copied later, when the palette
302  is decided, because the rectangles may have different palettes. */
303  int xmin = h->rects[0]->x, xmax = xmin + h->rects[0]->w;
304  int ymin = h->rects[0]->y, ymax = ymin + h->rects[0]->h;
305  for (i = 1; i < rects; i++) {
306  xmin = FFMIN(xmin, h->rects[i]->x);
307  ymin = FFMIN(ymin, h->rects[i]->y);
308  xmax = FFMAX(xmax, h->rects[i]->x + h->rects[i]->w);
309  ymax = FFMAX(ymax, h->rects[i]->y + h->rects[i]->h);
310  }
311  vrect.x = xmin;
312  vrect.y = ymin;
313  vrect.w = xmax - xmin;
314  vrect.h = ymax - ymin;
315  if ((ret = av_image_check_size(vrect.w, vrect.h, 0, avctx)) < 0)
316  return ret;
317 
318  /* Count pixels outside the virtual rectangle as transparent */
319  global_palette_hits[0] = vrect.w * vrect.h;
320  for (i = 0; i < rects; i++)
321  global_palette_hits[0] -= h->rects[i]->w * h->rects[i]->h;
322  }
323 
324  for (i = 0; i < rects; i++)
325  count_colors(avctx, global_palette_hits, h->rects[i]);
326  select_palette(avctx, out_palette, out_alpha, global_palette_hits);
327 
328  if (rects > 1) {
329  if (!(vrect_data = av_calloc(vrect.w, vrect.h)))
330  return AVERROR(ENOMEM);
331  vrect.data [0] = vrect_data;
332  vrect.linesize[0] = vrect.w;
333  for (i = 0; i < rects; i++) {
334  build_color_map(avctx, cmap, (uint32_t *)h->rects[i]->data[1],
335  out_palette, out_alpha);
336  copy_rectangle(&vrect, h->rects[i], cmap);
337  }
338  for (i = 0; i < 4; i++)
339  cmap[i] = i;
340  } else {
341  build_color_map(avctx, cmap, (uint32_t *)h->rects[0]->data[1],
342  out_palette, out_alpha);
343  }
344 
345  av_log(avctx, AV_LOG_DEBUG, "Selected palette:");
346  for (i = 0; i < 4; i++)
347  av_log(avctx, AV_LOG_DEBUG, " 0x%06"PRIx32"@@%02x (0x%x,0x%x)",
348  dvdc->global_palette[out_palette[i]], out_alpha[i],
349  out_palette[i], out_alpha[i] >> 4);
350  av_log(avctx, AV_LOG_DEBUG, "\n");
351 
352  // encode data block
353  q = outbuf + 4;
354  offset1 = q - outbuf;
355  // worst case memory requirement: 1 nibble per pixel..
356  if ((q - outbuf) + vrect.w * vrect.h / 2 + 17 + 21 > outbuf_size) {
357  av_log(NULL, AV_LOG_ERROR, "dvd_subtitle too big\n");
359  goto fail;
360  }
361  dvd_encode_rle(&q, vrect.data[0], vrect.w * 2,
362  vrect.w, (vrect.h + 1) >> 1, cmap);
363  offset2 = q - outbuf;
364  dvd_encode_rle(&q, vrect.data[0] + vrect.w, vrect.w * 2,
365  vrect.w, vrect.h >> 1, cmap);
366 
367  if (dvdc->even_rows_fix && (vrect.h & 1)) {
368  // Work-around for some players that want the height to be even.
369  vrect.h++;
370  *q++ = 0x00; // 0x00 0x00 == empty row, i.e. fully transparent
371  *q++ = 0x00;
372  }
373 
374  // set data packet size
375  qq = outbuf + 2;
376  bytestream_put_be16(&qq, q - outbuf);
377 
378  // send start display command
379  bytestream_put_be16(&q, (h->start_display_time*90) >> 10);
380  bytestream_put_be16(&q, (q - outbuf) /*- 2 */ + 8 + 12 + 2);
381  *q++ = 0x03; // palette - 4 nibbles
382  *q++ = (out_palette[3] << 4) | out_palette[2];
383  *q++ = (out_palette[1] << 4) | out_palette[0];
384  *q++ = 0x04; // alpha - 4 nibbles
385  *q++ = (out_alpha[3] & 0xF0) | (out_alpha[2] >> 4);
386  *q++ = (out_alpha[1] & 0xF0) | (out_alpha[0] >> 4);
387 
388  // 12 bytes per rect
389  x2 = vrect.x + vrect.w - 1;
390  y2 = vrect.y + vrect.h - 1;
391 
392  *q++ = 0x05;
393  // x1 x2 -> 6 nibbles
394  *q++ = vrect.x >> 4;
395  *q++ = (vrect.x << 4) | ((x2 >> 8) & 0xf);
396  *q++ = x2;
397  // y1 y2 -> 6 nibbles
398  *q++ = vrect.y >> 4;
399  *q++ = (vrect.y << 4) | ((y2 >> 8) & 0xf);
400  *q++ = y2;
401 
402  *q++ = 0x06;
403  // offset1, offset2
404  bytestream_put_be16(&q, offset1);
405  bytestream_put_be16(&q, offset2);
406 
407  *q++ = forced ? 0x00 : 0x01; // start command
408  *q++ = 0xff; // terminating command
409 
410  // send stop display command last
411  bytestream_put_be16(&q, (h->end_display_time*90) >> 10);
412  bytestream_put_be16(&q, (q - outbuf) - 2 /*+ 4*/);
413  *q++ = 0x02; // set end
414  *q++ = 0xff; // terminating command
415 
416  qq = outbuf;
417  bytestream_put_be16(&qq, q - outbuf);
418 
419  av_log(NULL, AV_LOG_DEBUG, "subtitle_packet size=%"PTRDIFF_SPECIFIER"\n", q - outbuf);
420  ret = q - outbuf;
421 
422 fail:
423  av_free(vrect_data);
424  return ret;
425 }
426 
427 static int bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
428 {
429  int ret;
430  char *str;
431 
432  ret = av_bprint_finalize(buf, &str);
433  if (ret < 0)
434  return ret;
435  if (!av_bprint_is_complete(buf)) {
436  av_free(str);
437  return AVERROR(ENOMEM);
438  }
439 
440  avctx->extradata = str;
441  /* Note: the string is NUL terminated (so extradata can be read as a
442  * string), but the ending character is not accounted in the size (in
443  * binary formats you are likely not supposed to mux that character). When
444  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
445  * zeros. */
446  avctx->extradata_size = buf->len;
447  return 0;
448 }
449 
450 static int dvdsub_init(AVCodecContext *avctx)
451 {
452  DVDSubtitleContext *dvdc = avctx->priv_data;
453  static const uint32_t default_palette[16] = {
454  0x000000, 0x0000FF, 0x00FF00, 0xFF0000,
455  0xFFFF00, 0xFF00FF, 0x00FFFF, 0xFFFFFF,
456  0x808000, 0x8080FF, 0x800080, 0x80FF80,
457  0x008080, 0xFF8080, 0x555555, 0xAAAAAA,
458  };
459  AVBPrint extradata;
460  int i, ret;
461 
462  av_assert0(sizeof(dvdc->global_palette) == sizeof(default_palette));
463  if (dvdc->palette_str) {
465  } else {
466  memcpy(dvdc->global_palette, default_palette, sizeof(dvdc->global_palette));
467  }
468 
470  if (avctx->width && avctx->height)
471  av_bprintf(&extradata, "size: %dx%d\n", avctx->width, avctx->height);
472  av_bprintf(&extradata, "palette:");
473  for (i = 0; i < 16; i++)
474  av_bprintf(&extradata, " %06"PRIx32"%c",
475  dvdc->global_palette[i] & 0xFFFFFF, i < 15 ? ',' : '\n');
476 
477  ret = bprint_to_extradata(avctx, &extradata);
478  if (ret < 0)
479  return ret;
480 
481  return 0;
482 }
483 
484 static int dvdsub_encode(AVCodecContext *avctx,
485  unsigned char *buf, int buf_size,
486  const AVSubtitle *sub)
487 {
488  //DVDSubtitleContext *s = avctx->priv_data;
489  int ret;
490 
491  ret = encode_dvd_subtitles(avctx, buf, buf_size, sub);
492  return ret;
493 }
494 
495 #define OFFSET(x) offsetof(DVDSubtitleContext, x)
496 #define SE AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM
497 static const AVOption options[] = {
498  {"palette", "set the global palette", OFFSET(palette_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, SE },
499  {"even_rows_fix", "Make number of rows even (workaround for some players)", OFFSET(even_rows_fix), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, SE},
500  { NULL },
501 };
502 
503 static const AVClass dvdsubenc_class = {
504  .class_name = "VOBSUB subtitle encoder",
505  .item_name = av_default_item_name,
506  .option = options,
507  .version = LIBAVUTIL_VERSION_INT,
508 };
509 
511  .name = "dvdsub",
512  .long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
513  .type = AVMEDIA_TYPE_SUBTITLE,
515  .init = dvdsub_init,
516  .encode_sub = dvdsub_encode,
517  .priv_class = &dvdsubenc_class,
518  .priv_data_size = sizeof(DVDSubtitleContext),
519 };
#define av_uninit(x)
Definition: attributes.h:154
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
#define AV_BPRINT_SIZE_AUTOMATIC
#define fail()
Definition: checkasm.h:133
#define FFSWAP(type, a, b)
Definition: common.h:108
#define FFMIN(a, b)
Definition: common.h:105
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
static float sub(float src0, float src1)
void ff_dvdsub_parse_palette(uint32_t *palette, const char *p)
Definition: dvdsub.c:26
#define SE
Definition: dvdsubenc.c:496
static const AVOption options[]
Definition: dvdsubenc.c:497
static int dvdsub_init(AVCodecContext *avctx)
Definition: dvdsubenc.c:450
static int encode_dvd_subtitles(AVCodecContext *avctx, uint8_t *outbuf, int outbuf_size, const AVSubtitle *h)
Definition: dvdsubenc.c:251
static int dvdsub_encode(AVCodecContext *avctx, unsigned char *buf, int buf_size, const AVSubtitle *sub)
Definition: dvdsubenc.c:484
static int bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
Definition: dvdsubenc.c:427
static const AVClass dvdsubenc_class
Definition: dvdsubenc.c:503
static int color_distance(uint32_t a, uint32_t b)
Definition: dvdsubenc.c:98
static void select_palette(AVCodecContext *avctx, int out_palette[4], int out_alpha[4], unsigned hits[33])
Definition: dvdsubenc.c:154
static void count_colors(AVCodecContext *avctx, unsigned hits[33], const AVSubtitleRect *r)
Count colors used in a rectangle, quantizing alpha and grouping by nearest global palette entry.
Definition: dvdsubenc.c:117
static void dvd_encode_rle(uint8_t **pq, const uint8_t *bitmap, int linesize, int w, int h, const int cmap[256])
Definition: dvdsubenc.c:45
#define OFFSET(x)
Definition: dvdsubenc.c:495
static void build_color_map(AVCodecContext *avctx, int cmap[], const uint32_t palette[], const int out_palette[], unsigned int const out_alpha[])
Definition: dvdsubenc.c:212
static void copy_rectangle(AVSubtitleRect *dst, AVSubtitleRect *src, int cmap[])
Definition: dvdsubenc.c:235
#define PUTNIBBLE(val)
Definition: dvdsubenc.c:37
AVCodec ff_dvdsub_encoder
Definition: dvdsubenc.c:510
int
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
#define AV_SUBTITLE_FLAG_FORCED
Definition: avcodec.h:2685
@ SUBTITLE_BITMAP
A bitmap, pict will be set.
Definition: avcodec.h:2670
@ AV_CODEC_ID_DVD_SUBTITLE
Definition: codec_id.h:523
#define AVERROR_BUFFER_TOO_SMALL
Buffer too small.
Definition: error.h:51
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
misc image utilities
int i
Definition: input.c:407
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define PTRDIFF_SPECIFIER
Definition: internal.h:192
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
uint8_t w
Definition: llviddspenc.c:39
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
AVOptions.
Describe the class of an AVClass context structure.
Definition: log.h:67
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:72
main external API structure.
Definition: avcodec.h:536
int width
picture width / height.
Definition: avcodec.h:709
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
int extradata_size
Definition: avcodec.h:638
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVOption.
Definition: opt.h:248
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2688
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:2690
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:2705
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2689
int linesize[4]
Definition: avcodec.h:2706
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:2691
uint32_t global_palette[16]
Definition: dvdsubenc.c:31
char * palette_str
Definition: dvdsubenc.c:32
Definition: f_ebur128.c:91
#define av_free(p)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
const char * b
Definition: vf_curves.c:118
const char * r
Definition: vf_curves.c:116
int len