Statistics
| Branch: | Revision:

ffmpeg / libavcodec / indeo2.c @ f66e4f5f

History | View | Annotate | Download (6.42 KB)

1
/*
2
 * Intel Indeo 2 codec
3
 * Copyright (c) 2005 Konstantin Shishkov
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
 */
22

    
23
/**
24
 * @file indeo2.c
25
 * Intel Indeo 2 decoder.
26
 */
27
#define ALT_BITSTREAM_READER_LE
28
#include "avcodec.h"
29
#include "bitstream.h"
30
#include "indeo2data.h"
31

    
32
typedef struct Ir2Context{
33
    AVCodecContext *avctx;
34
    AVFrame picture;
35
    GetBitContext gb;
36
    int decode_delta;
37
} Ir2Context;
38

    
39
#define CODE_VLC_BITS 14
40
static VLC ir2_vlc;
41

    
42
/* Indeo 2 codes are in range 0x01..0x7F and 0x81..0x90 */
43
static inline int ir2_get_code(GetBitContext *gb)
44
{
45
    return get_vlc2(gb, ir2_vlc.table, CODE_VLC_BITS, 1) + 1;
46
}
47

    
48
static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst, int stride,
49
                             const uint8_t *table)
50
{
51
    int i;
52
    int j;
53
    int out = 0;
54
    int c;
55
    int t;
56

    
57
    if(width&1)
58
        return -1;
59

    
60
    /* first line contain absolute values, other lines contain deltas */
61
    while (out < width){
62
        c = ir2_get_code(&ctx->gb);
63
        if(c >= 0x80) { /* we have a run */
64
            c -= 0x7F;
65
            if(out + c*2 > width)
66
                return -1;
67
            for (i = 0; i < c * 2; i++)
68
                dst[out++] = 0x80;
69
        } else { /* copy two values from table */
70
            dst[out++] = table[c * 2];
71
            dst[out++] = table[(c * 2) + 1];
72
        }
73
    }
74
    dst += stride;
75

    
76
    for (j = 1; j < height; j++){
77
        out = 0;
78
        while (out < width){
79
            c = ir2_get_code(&ctx->gb);
80
            if(c >= 0x80) { /* we have a skip */
81
                c -= 0x7F;
82
                if(out + c*2 > width)
83
                    return -1;
84
                for (i = 0; i < c * 2; i++) {
85
                    dst[out] = dst[out - stride];
86
                    out++;
87
                }
88
            } else { /* add two deltas from table */
89
                t = dst[out - stride] + (table[c * 2] - 128);
90
                t= av_clip_uint8(t);
91
                dst[out] = t;
92
                out++;
93
                t = dst[out - stride] + (table[(c * 2) + 1] - 128);
94
                t= av_clip_uint8(t);
95
                dst[out] = t;
96
                out++;
97
            }
98
        }
99
        dst += stride;
100
    }
101
    return 0;
102
}
103

    
104
static int ir2_decode_plane_inter(Ir2Context *ctx, int width, int height, uint8_t *dst, int stride,
105
                             const uint8_t *table)
106
{
107
    int j;
108
    int out = 0;
109
    int c;
110
    int t;
111

    
112
    if(width&1)
113
        return -1;
114

    
115
    for (j = 0; j < height; j++){
116
        out = 0;
117
        while (out < width){
118
            c = ir2_get_code(&ctx->gb);
119
            if(c >= 0x80) { /* we have a skip */
120
                c -= 0x7F;
121
                out += c * 2;
122
            } else { /* add two deltas from table */
123
                t = dst[out] + (((table[c * 2] - 128)*3) >> 2);
124
                t= av_clip_uint8(t);
125
                dst[out] = t;
126
                out++;
127
                t = dst[out] + (((table[(c * 2) + 1] - 128)*3) >> 2);
128
                t= av_clip_uint8(t);
129
                dst[out] = t;
130
                out++;
131
            }
132
        }
133
        dst += stride;
134
    }
135
    return 0;
136
}
137

    
138
static int ir2_decode_frame(AVCodecContext *avctx,
139
                        void *data, int *data_size,
140
                        uint8_t *buf, int buf_size)
141
{
142
    Ir2Context * const s = avctx->priv_data;
143
    AVFrame *picture = data;
144
    AVFrame * const p= (AVFrame*)&s->picture;
145
    int start;
146

    
147
    if(p->data[0])
148
        avctx->release_buffer(avctx, p);
149

    
150
    p->reference = 1;
151
    p->buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
152
    if (avctx->reget_buffer(avctx, p)) {
153
        av_log(s->avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
154
        return -1;
155
    }
156

    
157
    s->decode_delta = buf[18];
158

    
159
    /* decide whether frame uses deltas or not */
160
#ifndef ALT_BITSTREAM_READER_LE
161
    for (i = 0; i < buf_size; i++)
162
        buf[i] = ff_reverse[buf[i]];
163
#endif
164
    start = 48; /* hardcoded for now */
165

    
166
    init_get_bits(&s->gb, buf + start, buf_size - start);
167

    
168
    if (s->decode_delta) { /* intraframe */
169
        ir2_decode_plane(s, avctx->width, avctx->height,
170
                         s->picture.data[0], s->picture.linesize[0], ir2_luma_table);
171
        /* swapped U and V */
172
        ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
173
                         s->picture.data[2], s->picture.linesize[2], ir2_luma_table);
174
        ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
175
                         s->picture.data[1], s->picture.linesize[1], ir2_luma_table);
176
    } else { /* interframe */
177
        ir2_decode_plane_inter(s, avctx->width, avctx->height,
178
                         s->picture.data[0], s->picture.linesize[0], ir2_luma_table);
179
        /* swapped U and V */
180
        ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
181
                         s->picture.data[2], s->picture.linesize[2], ir2_luma_table);
182
        ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
183
                         s->picture.data[1], s->picture.linesize[1], ir2_luma_table);
184
    }
185

    
186
    *picture= *(AVFrame*)&s->picture;
187
    *data_size = sizeof(AVPicture);
188

    
189
    return buf_size;
190
}
191

    
192
static int ir2_decode_init(AVCodecContext *avctx){
193
    Ir2Context * const ic = avctx->priv_data;
194

    
195
    ic->avctx = avctx;
196

    
197
    avctx->pix_fmt= PIX_FMT_YUV410P;
198

    
199
    if (!ir2_vlc.table)
200
        init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,
201
                 &ir2_codes[0][1], 4, 2,
202
#ifdef ALT_BITSTREAM_READER_LE
203
                 &ir2_codes[0][0], 4, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
204
#else
205
                 &ir2_codes[0][0], 4, 2, INIT_VLC_USE_STATIC);
206
#endif
207

    
208
    return 0;
209
}
210

    
211
AVCodec indeo2_decoder = {
212
    "indeo2",
213
    CODEC_TYPE_VIDEO,
214
    CODEC_ID_INDEO2,
215
    sizeof(Ir2Context),
216
    ir2_decode_init,
217
    NULL,
218
    NULL,
219
    ir2_decode_frame,
220
    CODEC_CAP_DR1,
221
};