Statistics
| Branch: | Revision:

ffmpeg / libavcodec / indeo2.c @ bd4110f9

History | View | Annotate | Download (6.75 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
 * @file libavcodec/indeo2.c
24
 * Intel Indeo 2 decoder.
25
 */
26
#define ALT_BITSTREAM_READER_LE
27
#include "avcodec.h"
28
#include "get_bits.h"
29
#include "indeo2data.h"
30

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

    
38
#define CODE_VLC_BITS 14
39
static VLC ir2_vlc;
40

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
190
    return buf_size;
191
}
192

    
193
static av_cold int ir2_decode_init(AVCodecContext *avctx){
194
    Ir2Context * const ic = avctx->priv_data;
195
    static VLC_TYPE vlc_tables[1 << CODE_VLC_BITS][2];
196

    
197
    ic->avctx = avctx;
198

    
199
    avctx->pix_fmt= PIX_FMT_YUV410P;
200

    
201
    ir2_vlc.table = vlc_tables;
202
    ir2_vlc.table_allocated = 1 << CODE_VLC_BITS;
203
#ifdef ALT_BITSTREAM_READER_LE
204
        init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,
205
                 &ir2_codes[0][1], 4, 2,
206
                 &ir2_codes[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
207
#else
208
        init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,
209
                 &ir2_codes[0][1], 4, 2,
210
                 &ir2_codes[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC);
211
#endif
212

    
213
    return 0;
214
}
215

    
216
AVCodec indeo2_decoder = {
217
    "indeo2",
218
    CODEC_TYPE_VIDEO,
219
    CODEC_ID_INDEO2,
220
    sizeof(Ir2Context),
221
    ir2_decode_init,
222
    NULL,
223
    NULL,
224
    ir2_decode_frame,
225
    CODEC_CAP_DR1,
226
    .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 2"),
227
};