← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/dvdsubdec.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20081226001006-wd8cuqn8d81smkdp
Tags: upstream-1.1.7
Import upstream version 1.1.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/dvdsubdec.c
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
 */
21
21
#include "avcodec.h"
 
22
#include "bitstream.h"
 
23
#include "colorspace.h"
 
24
#include "dsputil.h"
22
25
 
23
26
//#define DEBUG
24
27
 
25
 
static int dvdsub_init_decoder(AVCodecContext *avctx)
26
 
{
27
 
    return 0;
28
 
}
29
 
 
30
 
static int get_nibble(const uint8_t *buf, int nibble_offset)
31
 
{
32
 
    return (buf[nibble_offset >> 1] >> ((1 - (nibble_offset & 1)) << 2)) & 0xf;
 
28
static void yuv_a_to_rgba(const uint8_t *ycbcr, const uint8_t *alpha, uint32_t *rgba, int num_values)
 
29
{
 
30
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
 
31
    uint8_t r, g, b;
 
32
    int i, y, cb, cr;
 
33
    int r_add, g_add, b_add;
 
34
 
 
35
    for (i = num_values; i > 0; i--) {
 
36
        y = *ycbcr++;
 
37
        cb = *ycbcr++;
 
38
        cr = *ycbcr++;
 
39
        YUV_TO_RGB1_CCIR(cb, cr);
 
40
        YUV_TO_RGB2_CCIR(r, g, b, y);
 
41
        *rgba++ = (*alpha++ << 24) | (r << 16) | (g << 8) | b;
 
42
    }
 
43
}
 
44
 
 
45
static int decode_run_2bit(GetBitContext *gb, int *color)
 
46
{
 
47
    unsigned int v, t;
 
48
 
 
49
    v = 0;
 
50
    for (t = 1; v < t && t <= 0x40; t <<= 2)
 
51
        v = (v << 4) | get_bits(gb, 4);
 
52
    *color = v & 3;
 
53
    if (v < 4) { /* Code for fill rest of line */
 
54
        return INT_MAX;
 
55
    }
 
56
    return v >> 2;
 
57
}
 
58
 
 
59
static int decode_run_8bit(GetBitContext *gb, int *color)
 
60
{
 
61
    int len;
 
62
    int has_run = get_bits1(gb);
 
63
    if (get_bits1(gb))
 
64
        *color = get_bits(gb, 8);
 
65
    else
 
66
        *color = get_bits(gb, 2);
 
67
    if (has_run) {
 
68
        if (get_bits1(gb)) {
 
69
            len = get_bits(gb, 7);
 
70
            if (len == 0)
 
71
                len = INT_MAX;
 
72
            else
 
73
                len += 9;
 
74
        } else
 
75
            len = get_bits(gb, 3) + 2;
 
76
    } else
 
77
        len = 1;
 
78
    return len;
33
79
}
34
80
 
35
81
static int decode_rle(uint8_t *bitmap, int linesize, int w, int h,
36
 
                      const uint8_t *buf, int nibble_offset, int buf_size)
 
82
                      const uint8_t *buf, int start, int buf_size, int is_8bit)
37
83
{
38
 
    unsigned int v;
39
 
    int x, y, len, color, nibble_end;
 
84
    GetBitContext gb;
 
85
    int bit_len;
 
86
    int x, y, len, color;
40
87
    uint8_t *d;
41
88
 
42
 
    nibble_end = buf_size * 2;
 
89
    bit_len = (buf_size - start) * 8;
 
90
    init_get_bits(&gb, buf + start, bit_len);
 
91
 
43
92
    x = 0;
44
93
    y = 0;
45
94
    d = bitmap;
46
95
    for(;;) {
47
 
        if (nibble_offset >= nibble_end)
 
96
        if (get_bits_count(&gb) > bit_len)
48
97
            return -1;
49
 
        v = get_nibble(buf, nibble_offset++);
50
 
        if (v < 0x4) {
51
 
            v = (v << 4) | get_nibble(buf, nibble_offset++);
52
 
            if (v < 0x10) {
53
 
                v = (v << 4) | get_nibble(buf, nibble_offset++);
54
 
                if (v < 0x040) {
55
 
                    v = (v << 4) | get_nibble(buf, nibble_offset++);
56
 
                    if (v < 4) {
57
 
                        v |= (w - x) << 2;
58
 
                    }
59
 
                }
60
 
            }
61
 
        }
62
 
        len = v >> 2;
63
 
        if (len > (w - x))
64
 
            len = (w - x);
65
 
        color = v & 0x03;
 
98
        if (is_8bit)
 
99
            len = decode_run_8bit(&gb, &color);
 
100
        else
 
101
            len = decode_run_2bit(&gb, &color);
 
102
        len = FFMIN(len, w - x);
66
103
        memset(d + x, color, len);
67
104
        x += len;
68
105
        if (x >= w) {
72
109
            d += linesize;
73
110
            x = 0;
74
111
            /* byte align */
75
 
            nibble_offset += (nibble_offset & 1);
 
112
            align_get_bits(&gb);
76
113
        }
77
114
    }
78
115
    return 0;
79
116
}
80
117
 
81
118
static void guess_palette(uint32_t *rgba_palette,
82
 
                          uint8_t *palette,
 
119
                          uint8_t *colormap,
83
120
                          uint8_t *alpha,
84
121
                          uint32_t subtitle_color)
85
122
{
92
129
    memset(color_used, 0, 16);
93
130
    nb_opaque_colors = 0;
94
131
    for(i = 0; i < 4; i++) {
95
 
        if (alpha[i] != 0 && !color_used[palette[i]]) {
96
 
            color_used[palette[i]] = 1;
 
132
        if (alpha[i] != 0 && !color_used[colormap[i]]) {
 
133
            color_used[colormap[i]] = 1;
97
134
            nb_opaque_colors++;
98
135
        }
99
136
    }
105
142
    memset(color_used, 0, 16);
106
143
    for(i = 0; i < 4; i++) {
107
144
        if (alpha[i] != 0) {
108
 
            if (!color_used[palette[i]])  {
 
145
            if (!color_used[colormap[i]])  {
109
146
                level = (0xff * j) / nb_opaque_colors;
110
147
                r = (((subtitle_color >> 16) & 0xff) * level) >> 8;
111
148
                g = (((subtitle_color >> 8) & 0xff) * level) >> 8;
112
149
                b = (((subtitle_color >> 0) & 0xff) * level) >> 8;
113
150
                rgba_palette[i] = b | (g << 8) | (r << 16) | ((alpha[i] * 17) << 24);
114
 
                color_used[palette[i]] = (i + 1);
 
151
                color_used[colormap[i]] = (i + 1);
115
152
                j--;
116
153
            } else {
117
 
                rgba_palette[i] = (rgba_palette[color_used[palette[i]] - 1] & 0x00ffffff) |
 
154
                rgba_palette[i] = (rgba_palette[color_used[colormap[i]] - 1] & 0x00ffffff) |
118
155
                                    ((alpha[i] * 17) << 24);
119
156
            }
120
157
        }
121
158
    }
122
159
}
123
160
 
 
161
#define READ_OFFSET(a) (big_offsets ? AV_RB32(a) : AV_RB16(a))
 
162
 
124
163
static int decode_dvd_subtitles(AVSubtitle *sub_header,
125
164
                                const uint8_t *buf, int buf_size)
126
165
{
127
166
    int cmd_pos, pos, cmd, x1, y1, x2, y2, offset1, offset2, next_cmd_pos;
128
 
    uint8_t palette[4], alpha[4];
 
167
    int big_offsets, offset_size, is_8bit = 0;
 
168
    const uint8_t *yuv_palette = 0;
 
169
    uint8_t colormap[4], alpha[256];
129
170
    int date;
130
171
    int i;
131
172
    int is_menu = 0;
132
173
 
133
 
    if (buf_size < 4)
 
174
    if (buf_size < 10)
134
175
        return -1;
135
176
    sub_header->rects = NULL;
136
177
    sub_header->num_rects = 0;
137
178
    sub_header->start_display_time = 0;
138
179
    sub_header->end_display_time = 0;
139
180
 
140
 
    cmd_pos = AV_RB16(buf + 2);
141
 
    while ((cmd_pos + 4) < buf_size) {
 
181
    if (AV_RB16(buf) == 0) {   /* HD subpicture with 4-byte offsets */
 
182
        big_offsets = 1;
 
183
        offset_size = 4;
 
184
        cmd_pos = 6;
 
185
    } else {
 
186
        big_offsets = 0;
 
187
        offset_size = 2;
 
188
        cmd_pos = 2;
 
189
    }
 
190
 
 
191
    cmd_pos = READ_OFFSET(buf + cmd_pos);
 
192
 
 
193
    while ((cmd_pos + 2 + offset_size) < buf_size) {
142
194
        date = AV_RB16(buf + cmd_pos);
143
 
        next_cmd_pos = AV_RB16(buf + cmd_pos + 2);
 
195
        next_cmd_pos = READ_OFFSET(buf + cmd_pos + 2);
144
196
#ifdef DEBUG
145
197
        av_log(NULL, AV_LOG_INFO, "cmd_pos=0x%04x next=0x%04x date=%d\n",
146
198
               cmd_pos, next_cmd_pos, date);
147
199
#endif
148
 
        pos = cmd_pos + 4;
 
200
        pos = cmd_pos + 2 + offset_size;
149
201
        offset1 = -1;
150
202
        offset2 = -1;
151
203
        x1 = y1 = x2 = y2 = 0;
168
220
                sub_header->end_display_time = (date << 10) / 90;
169
221
                break;
170
222
            case 0x03:
171
 
                /* set palette */
 
223
                /* set colormap */
172
224
                if ((buf_size - pos) < 2)
173
225
                    goto fail;
174
 
                palette[3] = buf[pos] >> 4;
175
 
                palette[2] = buf[pos] & 0x0f;
176
 
                palette[1] = buf[pos + 1] >> 4;
177
 
                palette[0] = buf[pos + 1] & 0x0f;
 
226
                colormap[3] = buf[pos] >> 4;
 
227
                colormap[2] = buf[pos] & 0x0f;
 
228
                colormap[1] = buf[pos + 1] >> 4;
 
229
                colormap[0] = buf[pos + 1] & 0x0f;
178
230
                pos += 2;
179
231
                break;
180
232
            case 0x04:
191
243
#endif
192
244
                break;
193
245
            case 0x05:
 
246
            case 0x85:
194
247
                if ((buf_size - pos) < 6)
195
248
                    goto fail;
196
249
                x1 = (buf[pos] << 4) | (buf[pos + 1] >> 4);
197
250
                x2 = ((buf[pos + 1] & 0x0f) << 8) | buf[pos + 2];
198
251
                y1 = (buf[pos + 3] << 4) | (buf[pos + 4] >> 4);
199
252
                y2 = ((buf[pos + 4] & 0x0f) << 8) | buf[pos + 5];
 
253
                if (cmd & 0x80)
 
254
                    is_8bit = 1;
200
255
#ifdef DEBUG
201
256
                av_log(NULL, AV_LOG_INFO, "x1=%d x2=%d y1=%d y2=%d\n",
202
257
                       x1, x2, y1, y2);
213
268
#endif
214
269
                pos += 4;
215
270
                break;
 
271
            case 0x86:
 
272
                if ((buf_size - pos) < 8)
 
273
                    goto fail;
 
274
                offset1 = AV_RB32(buf + pos);
 
275
                offset2 = AV_RB32(buf + pos + 4);
 
276
#ifdef DEBUG
 
277
                av_log(NULL, AV_LOG_INFO, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
 
278
#endif
 
279
                pos += 8;
 
280
                break;
 
281
 
 
282
            case 0x83:
 
283
                /* HD set palette */
 
284
                if ((buf_size - pos) < 768)
 
285
                    goto fail;
 
286
                yuv_palette = buf + pos;
 
287
                pos += 768;
 
288
                break;
 
289
            case 0x84:
 
290
                /* HD set contrast (alpha) */
 
291
                if ((buf_size - pos) < 256)
 
292
                    goto fail;
 
293
                for (i = 0; i < 256; i++)
 
294
                    alpha[i] = 0xFF - buf[pos+i];
 
295
                pos += 256;
 
296
                break;
 
297
 
216
298
            case 0xff:
 
299
                goto the_end;
217
300
            default:
 
301
#ifdef DEBUG
 
302
                av_log(NULL, AV_LOG_INFO, "unrecognised subpicture command 0x%x\n", cmd);
 
303
#endif
218
304
                goto the_end;
219
305
            }
220
306
        }
243
329
                bitmap = av_malloc(w * h);
244
330
                sub_header->rects = av_mallocz(sizeof(AVSubtitleRect));
245
331
                sub_header->num_rects = 1;
246
 
                sub_header->rects[0].rgba_palette = av_malloc(4 * 4);
 
332
                sub_header->rects[0].bitmap = bitmap;
247
333
                decode_rle(bitmap, w * 2, w, (h + 1) / 2,
248
 
                           buf, offset1 * 2, buf_size);
 
334
                           buf, offset1, buf_size, is_8bit);
249
335
                decode_rle(bitmap + w, w * 2, w, h / 2,
250
 
                           buf, offset2 * 2, buf_size);
251
 
                guess_palette(sub_header->rects[0].rgba_palette,
252
 
                              palette, alpha, 0xffff00);
 
336
                           buf, offset2, buf_size, is_8bit);
 
337
                if (is_8bit) {
 
338
                    if (yuv_palette == 0)
 
339
                        goto fail;
 
340
                    sub_header->rects[0].rgba_palette = av_malloc(256 * 4);
 
341
                    sub_header->rects[0].nb_colors = 256;
 
342
                    yuv_a_to_rgba(yuv_palette, alpha, sub_header->rects[0].rgba_palette, 256);
 
343
                } else {
 
344
                    sub_header->rects[0].rgba_palette = av_malloc(4 * 4);
 
345
                    sub_header->rects[0].nb_colors = 4;
 
346
                    guess_palette(sub_header->rects[0].rgba_palette,
 
347
                                  colormap, alpha, 0xffff00);
 
348
                }
253
349
                sub_header->rects[0].x = x1;
254
350
                sub_header->rects[0].y = y1;
255
351
                sub_header->rects[0].w = w;
256
352
                sub_header->rects[0].h = h;
257
 
                sub_header->rects[0].nb_colors = 4;
258
353
                sub_header->rects[0].linesize = w;
259
 
                sub_header->rects[0].bitmap = bitmap;
260
354
            }
261
355
        }
262
356
        if (next_cmd_pos == cmd_pos)
266
360
    if (sub_header->num_rects > 0)
267
361
        return is_menu;
268
362
 fail:
 
363
    if (sub_header->rects != NULL) {
 
364
        for (i = 0; i < sub_header->num_rects; i++) {
 
365
            av_free(sub_header->rects[i].bitmap);
 
366
            av_free(sub_header->rects[i].rgba_palette);
 
367
        }
 
368
        av_freep(&sub_header->rects);
 
369
        sub_header->num_rects = 0;
 
370
    }
269
371
    return -1;
270
372
}
271
373
 
336
438
    return 1;
337
439
}
338
440
 
339
 
static int dvdsub_close_decoder(AVCodecContext *avctx)
340
 
{
341
 
    return 0;
342
 
}
343
 
 
344
441
#ifdef DEBUG
345
442
#undef fprintf
346
443
static void ppm_save(const char *filename, uint8_t *bitmap, int w, int h,
372
469
 
373
470
static int dvdsub_decode(AVCodecContext *avctx,
374
471
                         void *data, int *data_size,
375
 
                         uint8_t *buf, int buf_size)
 
472
                         const uint8_t *buf, int buf_size)
376
473
{
377
474
    AVSubtitle *sub = (void *)data;
378
475
    int is_menu;
405
502
    CODEC_TYPE_SUBTITLE,
406
503
    CODEC_ID_DVD_SUBTITLE,
407
504
    0,
408
 
    dvdsub_init_decoder,
409
 
    NULL,
410
 
    dvdsub_close_decoder,
 
505
    NULL,
 
506
    NULL,
 
507
    NULL,
411
508
    dvdsub_decode,
412
 
};
413
 
 
414
 
/* parser definition */
415
 
typedef struct DVDSubParseContext {
416
 
    uint8_t *packet;
417
 
    int packet_len;
418
 
    int packet_index;
419
 
} DVDSubParseContext;
420
 
 
421
 
static int dvdsub_parse_init(AVCodecParserContext *s)
422
 
{
423
 
    return 0;
424
 
}
425
 
 
426
 
static int dvdsub_parse(AVCodecParserContext *s,
427
 
                        AVCodecContext *avctx,
428
 
                        uint8_t **poutbuf, int *poutbuf_size,
429
 
                        const uint8_t *buf, int buf_size)
430
 
{
431
 
    DVDSubParseContext *pc = s->priv_data;
432
 
 
433
 
    if (pc->packet_index == 0) {
434
 
        if (buf_size < 2)
435
 
            return 0;
436
 
        pc->packet_len = AV_RB16(buf);
437
 
        av_freep(&pc->packet);
438
 
        pc->packet = av_malloc(pc->packet_len);
439
 
    }
440
 
    if (pc->packet) {
441
 
        if (pc->packet_index + buf_size <= pc->packet_len) {
442
 
            memcpy(pc->packet + pc->packet_index, buf, buf_size);
443
 
            pc->packet_index += buf_size;
444
 
            if (pc->packet_index >= pc->packet_len) {
445
 
                *poutbuf = pc->packet;
446
 
                *poutbuf_size = pc->packet_len;
447
 
                pc->packet_index = 0;
448
 
                return buf_size;
449
 
            }
450
 
        } else {
451
 
            /* erroneous size */
452
 
            pc->packet_index = 0;
453
 
        }
454
 
    }
455
 
    *poutbuf = NULL;
456
 
    *poutbuf_size = 0;
457
 
    return buf_size;
458
 
}
459
 
 
460
 
static void dvdsub_parse_close(AVCodecParserContext *s)
461
 
{
462
 
    DVDSubParseContext *pc = s->priv_data;
463
 
    av_freep(&pc->packet);
464
 
}
465
 
 
466
 
AVCodecParser dvdsub_parser = {
467
 
    { CODEC_ID_DVD_SUBTITLE },
468
 
    sizeof(DVDSubParseContext),
469
 
    dvdsub_parse_init,
470
 
    dvdsub_parse,
471
 
    dvdsub_parse_close,
 
509
    .long_name = "DVD subtitles",
472
510
};