summaryrefslogtreecommitdiff
path: root/libavcodec/dvdsubenc.c (plain)
blob: 26afdc666b4304604e0bfead205a30c72b72d8c1
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
29typedef struct {
30 AVClass *class;
31 uint32_t global_palette[16];
32 int even_rows_fix;
33} DVDSubtitleContext;
34
35// ncnt is the nibble counter
36#define PUTNIBBLE(val)\
37do {\
38 if (ncnt++ & 1)\
39 *q++ = bitbuf | ((val) & 0x0f);\
40 else\
41 bitbuf = (val) << 4;\
42} while(0)
43
44static void dvd_encode_rle(uint8_t **pq,
45 const uint8_t *bitmap, int linesize,
46 int w, int h,
47 const int cmap[256])
48{
49 uint8_t *q;
50 unsigned int bitbuf = 0;
51 int ncnt;
52 int x, y, len, color;
53
54 q = *pq;
55
56 for (y = 0; y < h; ++y) {
57 ncnt = 0;
58 for(x = 0; x < w; x += len) {
59 color = bitmap[x];
60 for (len=1; x+len < w; ++len)
61 if (bitmap[x+len] != color)
62 break;
63 color = cmap[color];
64 av_assert0(color < 4);
65 if (len < 0x04) {
66 PUTNIBBLE((len << 2)|color);
67 } else if (len < 0x10) {
68 PUTNIBBLE(len >> 2);
69 PUTNIBBLE((len << 2)|color);
70 } else if (len < 0x40) {
71 PUTNIBBLE(0);
72 PUTNIBBLE(len >> 2);
73 PUTNIBBLE((len << 2)|color);
74 } else if (x+len == w) {
75 PUTNIBBLE(0);
76 PUTNIBBLE(0);
77 PUTNIBBLE(0);
78 PUTNIBBLE(color);
79 } else {
80 if (len > 0xff)
81 len = 0xff;
82 PUTNIBBLE(0);
83 PUTNIBBLE(len >> 6);
84 PUTNIBBLE(len >> 2);
85 PUTNIBBLE((len << 2)|color);
86 }
87 }
88 /* end of line */
89 if (ncnt & 1)
90 PUTNIBBLE(0);
91 bitmap += linesize;
92 }
93
94 *pq = q;
95}
96
97static int color_distance(uint32_t a, uint32_t b)
98{
99 int r = 0, d, i;
100 int alpha_a = 8, alpha_b = 8;
101
102 for (i = 24; i >= 0; i -= 8) {
103 d = alpha_a * (int)((a >> i) & 0xFF) -
104 alpha_b * (int)((b >> i) & 0xFF);
105 r += d * d;
106 alpha_a = a >> 28;
107 alpha_b = b >> 28;
108 }
109 return r;
110}
111
112/**
113 * Count colors used in a rectangle, quantizing alpha and grouping by
114 * nearest global palette entry.
115 */
116static void count_colors(AVCodecContext *avctx, unsigned hits[33],
117 const AVSubtitleRect *r)
118{
119 DVDSubtitleContext *dvdc = avctx->priv_data;
120 unsigned count[256] = { 0 };
121 uint32_t *palette = (uint32_t *)r->data[1];
122 uint32_t color;
123 int x, y, i, j, match, d, best_d, av_uninit(best_j);
124 uint8_t *p = r->data[0];
125
126 for (y = 0; y < r->h; y++) {
127 for (x = 0; x < r->w; x++)
128 count[*(p++)]++;
129 p += r->linesize[0] - r->w;
130 }
131 for (i = 0; i < 256; i++) {
132 if (!count[i]) /* avoid useless search */
133 continue;
134 color = palette[i];
135 /* 0: transparent, 1-16: semi-transparent, 17-33 opaque */
136 match = color < 0x33000000 ? 0 : color < 0xCC000000 ? 1 : 17;
137 if (match) {
138 best_d = INT_MAX;
139 for (j = 0; j < 16; j++) {
140 d = color_distance(0xFF000000 | color,
141 0xFF000000 | dvdc->global_palette[j]);
142 if (d < best_d) {
143 best_d = d;
144 best_j = j;
145 }
146 }
147 match += best_j;
148 }
149 hits[match] += count[i];
150 }
151}
152
153static void select_palette(AVCodecContext *avctx, int out_palette[4],
154 int out_alpha[4], unsigned hits[33])
155{
156 DVDSubtitleContext *dvdc = avctx->priv_data;
157 int i, j, bright, mult;
158 uint32_t color;
159 int selected[4] = { 0 };
160 uint32_t pseudopal[33] = { 0 };
161 uint32_t refcolor[3] = { 0x00000000, 0xFFFFFFFF, 0xFF000000 };
162
163 /* Bonus for transparent: if the rectangle fits tightly the text, the
164 background color can be quite rare, but it would be ugly without it */
165 hits[0] *= 16;
166 /* Bonus for bright colors */
167 for (i = 0; i < 16; i++) {
168 if (!(hits[1 + i] + hits[17 + i]))
169 continue; /* skip unused colors to gain time */
170 color = dvdc->global_palette[i];
171 bright = 0;
172 for (j = 0; j < 3; j++, color >>= 8)
173 bright += (color & 0xFF) < 0x40 || (color & 0xFF) >= 0xC0;
174 mult = 2 + FFMIN(bright, 2);
175 hits[ 1 + i] *= mult;
176 hits[17 + i] *= mult;
177 }
178
179 /* Select four most frequent colors */
180 for (i = 0; i < 4; i++) {
181 for (j = 0; j < 33; j++)
182 if (hits[j] > hits[selected[i]])
183 selected[i] = j;
184 hits[selected[i]] = 0;
185 }
186
187 /* Order the colors like in most DVDs:
188 0: background, 1: foreground, 2: outline */
189 for (i = 0; i < 16; i++) {
190 pseudopal[ 1 + i] = 0x80000000 | dvdc->global_palette[i];
191 pseudopal[17 + i] = 0xFF000000 | dvdc->global_palette[i];
192 }
193 for (i = 0; i < 3; i++) {
194 int best_d = color_distance(refcolor[i], pseudopal[selected[i]]);
195 for (j = i + 1; j < 4; j++) {
196 int d = color_distance(refcolor[i], pseudopal[selected[j]]);
197 if (d < best_d) {
198 FFSWAP(int, selected[i], selected[j]);
199 best_d = d;
200 }
201 }
202 }
203
204 /* Output */
205 for (i = 0; i < 4; i++) {
206 out_palette[i] = selected[i] ? (selected[i] - 1) & 0xF : 0;
207 out_alpha [i] = !selected[i] ? 0 : selected[i] < 17 ? 0x80 : 0xFF;
208 }
209}
210
211static void build_color_map(AVCodecContext *avctx, int cmap[],
212 const uint32_t palette[],
213 const int out_palette[], unsigned int const out_alpha[])
214{
215 DVDSubtitleContext *dvdc = avctx->priv_data;
216 int i, j, d, best_d;
217 uint32_t pseudopal[4];
218
219 for (i = 0; i < 4; i++)
220 pseudopal[i] = (out_alpha[i] << 24) |
221 dvdc->global_palette[out_palette[i]];
222 for (i = 0; i < 256; i++) {
223 best_d = INT_MAX;
224 for (j = 0; j < 4; j++) {
225 d = color_distance(pseudopal[j], palette[i]);
226 if (d < best_d) {
227 cmap[i] = j;
228 best_d = d;
229 }
230 }
231 }
232}
233
234static void copy_rectangle(AVSubtitleRect *dst, AVSubtitleRect *src, int cmap[])
235{
236 int x, y;
237 uint8_t *p, *q;
238
239 p = src->data[0];
240 q = dst->data[0] + (src->x - dst->x) +
241 (src->y - dst->y) * dst->linesize[0];
242 for (y = 0; y < src->h; y++) {
243 for (x = 0; x < src->w; x++)
244 *(q++) = cmap[*(p++)];
245 p += src->linesize[0] - src->w;
246 q += dst->linesize[0] - src->w;
247 }
248}
249
250static int encode_dvd_subtitles(AVCodecContext *avctx,
251 uint8_t *outbuf, int outbuf_size,
252 const AVSubtitle *h)
253{
254 DVDSubtitleContext *dvdc = avctx->priv_data;
255 uint8_t *q, *qq;
256 int offset1, offset2;
257 int i, rects = h->num_rects, ret;
258 unsigned global_palette_hits[33] = { 0 };
259 int cmap[256];
260 int out_palette[4];
261 int out_alpha[4];
262 AVSubtitleRect vrect;
263 uint8_t *vrect_data = NULL;
264 int x2, y2;
265 int forced = 0;
266
267 if (rects == 0 || !h->rects)
268 return AVERROR(EINVAL);
269 for (i = 0; i < rects; i++)
270 if (h->rects[i]->type != SUBTITLE_BITMAP) {
271 av_log(avctx, AV_LOG_ERROR, "Bitmap subtitle required\n");
272 return AVERROR(EINVAL);
273 }
274 /* Mark this subtitle forced if any of the rectangles is forced. */
275 for (i = 0; i < rects; i++)
276 if ((h->rects[i]->flags & AV_SUBTITLE_FLAG_FORCED) != 0) {
277 forced = 1;
278 break;
279 }
280
281#if FF_API_AVPICTURE
282FF_DISABLE_DEPRECATION_WARNINGS
283 for (i = 0; i < rects; i++)
284 if (!h->rects[i]->data[0]) {
285 AVSubtitleRect *rect = h->rects[i];
286 int j;
287 for (j = 0; j < 4; j++) {
288 rect->data[j] = rect->pict.data[j];
289 rect->linesize[j] = rect->pict.linesize[j];
290 }
291 }
292FF_ENABLE_DEPRECATION_WARNINGS
293#endif
294
295 vrect = *h->rects[0];
296
297 if (rects > 1) {
298 /* DVD subtitles can have only one rectangle: build a virtual
299 rectangle containing all actual rectangles.
300 The data of the rectangles will be copied later, when the palette
301 is decided, because the rectangles may have different palettes. */
302 int xmin = h->rects[0]->x, xmax = xmin + h->rects[0]->w;
303 int ymin = h->rects[0]->y, ymax = ymin + h->rects[0]->h;
304 for (i = 1; i < rects; i++) {
305 xmin = FFMIN(xmin, h->rects[i]->x);
306 ymin = FFMIN(ymin, h->rects[i]->y);
307 xmax = FFMAX(xmax, h->rects[i]->x + h->rects[i]->w);
308 ymax = FFMAX(ymax, h->rects[i]->y + h->rects[i]->h);
309 }
310 vrect.x = xmin;
311 vrect.y = ymin;
312 vrect.w = xmax - xmin;
313 vrect.h = ymax - ymin;
314 if ((ret = av_image_check_size(vrect.w, vrect.h, 0, avctx)) < 0)
315 return ret;
316
317 /* Count pixels outside the virtual rectangle as transparent */
318 global_palette_hits[0] = vrect.w * vrect.h;
319 for (i = 0; i < rects; i++)
320 global_palette_hits[0] -= h->rects[i]->w * h->rects[i]->h;
321 }
322
323 for (i = 0; i < rects; i++)
324 count_colors(avctx, global_palette_hits, h->rects[i]);
325 select_palette(avctx, out_palette, out_alpha, global_palette_hits);
326
327 if (rects > 1) {
328 if (!(vrect_data = av_calloc(vrect.w, vrect.h)))
329 return AVERROR(ENOMEM);
330 vrect.data [0] = vrect_data;
331 vrect.linesize[0] = vrect.w;
332 for (i = 0; i < rects; i++) {
333 build_color_map(avctx, cmap, (uint32_t *)h->rects[i]->data[1],
334 out_palette, out_alpha);
335 copy_rectangle(&vrect, h->rects[i], cmap);
336 }
337 for (i = 0; i < 4; i++)
338 cmap[i] = i;
339 } else {
340 build_color_map(avctx, cmap, (uint32_t *)h->rects[0]->data[1],
341 out_palette, out_alpha);
342 }
343
344 av_log(avctx, AV_LOG_DEBUG, "Selected palette:");
345 for (i = 0; i < 4; i++)
346 av_log(avctx, AV_LOG_DEBUG, " 0x%06"PRIx32"@@%02x (0x%x,0x%x)",
347 dvdc->global_palette[out_palette[i]], out_alpha[i],
348 out_palette[i], out_alpha[i] >> 4);
349 av_log(avctx, AV_LOG_DEBUG, "\n");
350
351 // encode data block
352 q = outbuf + 4;
353 offset1 = q - outbuf;
354 // worst case memory requirement: 1 nibble per pixel..
355 if ((q - outbuf) + vrect.w * vrect.h / 2 + 17 + 21 > outbuf_size) {
356 av_log(NULL, AV_LOG_ERROR, "dvd_subtitle too big\n");
357 ret = AVERROR_BUFFER_TOO_SMALL;
358 goto fail;
359 }
360 dvd_encode_rle(&q, vrect.data[0], vrect.w * 2,
361 vrect.w, (vrect.h + 1) >> 1, cmap);
362 offset2 = q - outbuf;
363 dvd_encode_rle(&q, vrect.data[0] + vrect.w, vrect.w * 2,
364 vrect.w, vrect.h >> 1, cmap);
365
366 if (dvdc->even_rows_fix && (vrect.h & 1)) {
367 // Work-around for some players that want the height to be even.
368 vrect.h++;
369 *q++ = 0x00; // 0x00 0x00 == empty row, i.e. fully transparent
370 *q++ = 0x00;
371 }
372
373 // set data packet size
374 qq = outbuf + 2;
375 bytestream_put_be16(&qq, q - outbuf);
376
377 // send start display command
378 bytestream_put_be16(&q, (h->start_display_time*90) >> 10);
379 bytestream_put_be16(&q, (q - outbuf) /*- 2 */ + 8 + 12 + 2);
380 *q++ = 0x03; // palette - 4 nibbles
381 *q++ = (out_palette[3] << 4) | out_palette[2];
382 *q++ = (out_palette[1] << 4) | out_palette[0];
383 *q++ = 0x04; // alpha - 4 nibbles
384 *q++ = (out_alpha[3] & 0xF0) | (out_alpha[2] >> 4);
385 *q++ = (out_alpha[1] & 0xF0) | (out_alpha[0] >> 4);
386
387 // 12 bytes per rect
388 x2 = vrect.x + vrect.w - 1;
389 y2 = vrect.y + vrect.h - 1;
390
391 *q++ = 0x05;
392 // x1 x2 -> 6 nibbles
393 *q++ = vrect.x >> 4;
394 *q++ = (vrect.x << 4) | ((x2 >> 8) & 0xf);
395 *q++ = x2;
396 // y1 y2 -> 6 nibbles
397 *q++ = vrect.y >> 4;
398 *q++ = (vrect.y << 4) | ((y2 >> 8) & 0xf);
399 *q++ = y2;
400
401 *q++ = 0x06;
402 // offset1, offset2
403 bytestream_put_be16(&q, offset1);
404 bytestream_put_be16(&q, offset2);
405
406 *q++ = forced ? 0x00 : 0x01; // start command
407 *q++ = 0xff; // terminating command
408
409 // send stop display command last
410 bytestream_put_be16(&q, (h->end_display_time*90) >> 10);
411 bytestream_put_be16(&q, (q - outbuf) - 2 /*+ 4*/);
412 *q++ = 0x02; // set end
413 *q++ = 0xff; // terminating command
414
415 qq = outbuf;
416 bytestream_put_be16(&qq, q - outbuf);
417
418 av_log(NULL, AV_LOG_DEBUG, "subtitle_packet size=%"PTRDIFF_SPECIFIER"\n", q - outbuf);
419 ret = q - outbuf;
420
421fail:
422 av_free(vrect_data);
423 return ret;
424}
425
426static int dvdsub_init(AVCodecContext *avctx)
427{
428 DVDSubtitleContext *dvdc = avctx->priv_data;
429 static const uint32_t default_palette[16] = {
430 0x000000, 0x0000FF, 0x00FF00, 0xFF0000,
431 0xFFFF00, 0xFF00FF, 0x00FFFF, 0xFFFFFF,
432 0x808000, 0x8080FF, 0x800080, 0x80FF80,
433 0x008080, 0xFF8080, 0x555555, 0xAAAAAA,
434 };
435 AVBPrint extradata;
436 int i, ret;
437
438 av_assert0(sizeof(dvdc->global_palette) == sizeof(default_palette));
439 memcpy(dvdc->global_palette, default_palette, sizeof(dvdc->global_palette));
440
441 av_bprint_init(&extradata, 0, 1);
442 if (avctx->width && avctx->height)
443 av_bprintf(&extradata, "size: %dx%d\n", avctx->width, avctx->height);
444 av_bprintf(&extradata, "palette:");
445 for (i = 0; i < 16; i++)
446 av_bprintf(&extradata, " %06"PRIx32"%c",
447 dvdc->global_palette[i] & 0xFFFFFF, i < 15 ? ',' : '\n');
448
449 ret = avpriv_bprint_to_extradata(avctx, &extradata);
450 if (ret < 0)
451 return ret;
452
453 return 0;
454}
455
456static int dvdsub_encode(AVCodecContext *avctx,
457 unsigned char *buf, int buf_size,
458 const AVSubtitle *sub)
459{
460 //DVDSubtitleContext *s = avctx->priv_data;
461 int ret;
462
463 ret = encode_dvd_subtitles(avctx, buf, buf_size, sub);
464 return ret;
465}
466
467#define OFFSET(x) offsetof(DVDSubtitleContext, x)
468#define SE AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM
469static const AVOption options[] = {
470 {"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},
471 { NULL },
472};
473
474static const AVClass dvdsubenc_class = {
475 .class_name = "VOBSUB subtitle encoder",
476 .item_name = av_default_item_name,
477 .option = options,
478 .version = LIBAVUTIL_VERSION_INT,
479};
480
481AVCodec ff_dvdsub_encoder = {
482 .name = "dvdsub",
483 .long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
484 .type = AVMEDIA_TYPE_SUBTITLE,
485 .id = AV_CODEC_ID_DVD_SUBTITLE,
486 .init = dvdsub_init,
487 .encode_sub = dvdsub_encode,
488 .priv_class = &dvdsubenc_class,
489 .priv_data_size = sizeof(DVDSubtitleContext),
490};
491
generated by cgit at 2024-05-17 01:49:45 (GMT)