FFmpeg  4.3.9
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);
79  PUTNIBBLE(color);
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 dvdsub_init(AVCodecContext *avctx)
428 {
429  DVDSubtitleContext *dvdc = avctx->priv_data;
430  static const uint32_t default_palette[16] = {
431  0x000000, 0x0000FF, 0x00FF00, 0xFF0000,
432  0xFFFF00, 0xFF00FF, 0x00FFFF, 0xFFFFFF,
433  0x808000, 0x8080FF, 0x800080, 0x80FF80,
434  0x008080, 0xFF8080, 0x555555, 0xAAAAAA,
435  };
436  AVBPrint extradata;
437  int i, ret;
438 
439  av_assert0(sizeof(dvdc->global_palette) == sizeof(default_palette));
440  if (dvdc->palette_str) {
442  } else {
443  memcpy(dvdc->global_palette, default_palette, sizeof(dvdc->global_palette));
444  }
445 
447  if (avctx->width && avctx->height)
448  av_bprintf(&extradata, "size: %dx%d\n", avctx->width, avctx->height);
449  av_bprintf(&extradata, "palette:");
450  for (i = 0; i < 16; i++)
451  av_bprintf(&extradata, " %06"PRIx32"%c",
452  dvdc->global_palette[i] & 0xFFFFFF, i < 15 ? ',' : '\n');
453 
454  ret = avpriv_bprint_to_extradata(avctx, &extradata);
455  if (ret < 0)
456  return ret;
457 
458  return 0;
459 }
460 
461 static int dvdsub_encode(AVCodecContext *avctx,
462  unsigned char *buf, int buf_size,
463  const AVSubtitle *sub)
464 {
465  //DVDSubtitleContext *s = avctx->priv_data;
466  int ret;
467 
468  ret = encode_dvd_subtitles(avctx, buf, buf_size, sub);
469  return ret;
470 }
471 
472 #define OFFSET(x) offsetof(DVDSubtitleContext, x)
473 #define SE AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM
474 static const AVOption options[] = {
475  {"palette", "set the global palette", OFFSET(palette_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, SE },
476  {"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},
477  { NULL },
478 };
479 
480 static const AVClass dvdsubenc_class = {
481  .class_name = "VOBSUB subtitle encoder",
482  .item_name = av_default_item_name,
483  .option = options,
484  .version = LIBAVUTIL_VERSION_INT,
485 };
486 
488  .name = "dvdsub",
489  .long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
490  .type = AVMEDIA_TYPE_SUBTITLE,
492  .init = dvdsub_init,
493  .encode_sub = dvdsub_encode,
494  .priv_class = &dvdsubenc_class,
495  .priv_data_size = sizeof(DVDSubtitleContext),
496 };
#define NULL
Definition: coverity.c:32
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2664
AVOption.
Definition: opt.h:246
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
const char * b
Definition: vf_curves.c:116
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
static int color_distance(uint32_t a, uint32_t b)
Definition: dvdsubenc.c:98
unsigned num_rects
Definition: avcodec.h:2702
static const AVClass dvdsubenc_class
Definition: dvdsubenc.c:480
AVCodec.
Definition: codec.h:190
attribute_deprecated AVPicture pict
Definition: avcodec.h:2675
static void copy_rectangle(AVSubtitleRect *dst, AVSubtitleRect *src, int cmap[])
Definition: dvdsubenc.c:235
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
AVSubtitleRect ** rects
Definition: avcodec.h:2703
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:2666
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t
AVOptions.
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
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
attribute_deprecated int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:2635
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:2667
int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:1976
#define av_log(a,...)
static int dvdsub_encode(AVCodecContext *avctx, unsigned char *buf, int buf_size, const AVSubtitle *sub)
Definition: dvdsubenc.c:461
#define src
Definition: vp8dsp.c:254
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define PTRDIFF_SPECIFIER
Definition: internal.h:263
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2665
#define AVERROR(e)
Definition: error.h:43
AVCodec ff_dvdsub_encoder
Definition: dvdsubenc.c:487
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
const char * r
Definition: vf_curves.c:114
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: codec.h:197
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:123
uint32_t end_display_time
Definition: avcodec.h:2701
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:282
A bitmap, pict will be set.
Definition: avcodec.h:2646
#define AV_SUBTITLE_FLAG_FORCED
Definition: avcodec.h:2661
int linesize[4]
Definition: avcodec.h:2682
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
#define FFMIN(a, b)
Definition: common.h:96
#define AVERROR_BUFFER_TOO_SMALL
Buffer too small.
Definition: error.h:51
int width
picture width / height.
Definition: avcodec.h:699
uint8_t w
Definition: llviddspenc.c:38
attribute_deprecated uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
Definition: avcodec.h:2633
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:2681
char * palette_str
Definition: dvdsubenc.c:32
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
#define AV_BPRINT_SIZE_AUTOMATIC
Libavcodec external API header.
main external API structure.
Definition: avcodec.h:526
static const AVOption options[]
Definition: dvdsubenc.c:474
#define SE
Definition: dvdsubenc.c:473
Describe the class of an AVClass context structure.
Definition: log.h:67
Definition: f_ebur128.c:91
void ff_dvdsub_parse_palette(uint32_t *palette, const char *p)
Definition: dvdsub.c:26
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
#define PUTNIBBLE(val)
Definition: dvdsubenc.c:37
static int encode_dvd_subtitles(AVCodecContext *avctx, uint8_t *outbuf, int outbuf_size, const AVSubtitle *h)
Definition: dvdsubenc.c:251
int
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
uint32_t start_display_time
Definition: avcodec.h:2700
void * priv_data
Definition: avcodec.h:553
#define av_free(p)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int len
#define av_uninit(x)
Definition: attributes.h:154
#define OFFSET(x)
Definition: dvdsubenc.c:472
#define FFSWAP(type, a, b)
Definition: common.h:99
uint32_t global_palette[16]
Definition: dvdsubenc.c:31
enum AVSubtitleType type
Definition: avcodec.h:2684
static int dvdsub_init(AVCodecContext *avctx)
Definition: dvdsubenc.c:427