vp6.c 21.7 KB
Newer Older
1 2 3 4 5 6
/**
 * @file vp6.c
 * VP6 compatible video decoder
 *
 * Copyright (C) 2006  Aurelien Jacobs <aurel@gnuage.org>
 *
7 8 9 10
 * The VP6F decoder accepts an optional 1 byte extradata. It is composed of:
 *  - upper 4bits: difference between encoded width and visible width
 *  - lower 4bits: difference between encoded height and visible height
 *
11 12 13
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
14 15 16 17
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
18
 * FFmpeg is distributed in the hope that it will be useful,
19 20 21 22 23
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
24
 * License along with FFmpeg; if not, write to the Free Software
25
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 27 28 29 30 31 32
 */

#include <stdlib.h>

#include "avcodec.h"
#include "dsputil.h"
#include "bitstream.h"
33
#include "huffman.h"
34 35 36 37 38 39

#include "vp56.h"
#include "vp56data.h"
#include "vp6data.h"


40 41 42
static void vp6_parse_coeff(vp56_context_t *s);
static void vp6_parse_coeff_huffman(vp56_context_t *s);

Michael Niedermayer's avatar
Michael Niedermayer committed
43
static int vp6_parse_header(vp56_context_t *s, const uint8_t *buf, int buf_size,
44 45 46
                            int *golden_frame)
{
    vp56_range_coder_t *c = &s->c;
47
    int parse_filter_info = 0;
48
    int coeff_offset = 0;
49 50
    int vrt_shift = 0;
    int sub_version;
51 52
    int rows, cols;
    int res = 1;
53
    int separated_coeff = buf[0] & 1;
54

55
    s->framep[VP56_FRAME_CURRENT]->key_frame = !(buf[0] & 0x80);
56 57
    vp56_init_dequant(s, (buf[0] >> 1) & 0x3F);

58
    if (s->framep[VP56_FRAME_CURRENT]->key_frame) {
59 60 61
        sub_version = buf[1] >> 3;
        if (sub_version > 8)
            return 0;
62
        s->filter_header = buf[1] & 0x06;
63 64 65 66
        if (buf[1] & 1) {
            av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n");
            return 0;
        }
67
        if (separated_coeff || !s->filter_header) {
68
            coeff_offset = AV_RB16(buf+2) - 2;
69 70 71
            buf += 2;
            buf_size -= 2;
        }
72 73 74 75 76 77 78 79 80

        rows = buf[2];  /* number of stored macroblock rows */
        cols = buf[3];  /* number of stored macroblock cols */
        /* buf[4] is number of displayed macroblock rows */
        /* buf[5] is number of displayed macroblock cols */

        if (16*cols != s->avctx->coded_width ||
            16*rows != s->avctx->coded_height) {
            avcodec_set_dimensions(s->avctx, 16*cols, 16*rows);
81 82 83 84
            if (s->avctx->extradata_size == 1) {
                s->avctx->width  -= s->avctx->extradata[0] >> 4;
                s->avctx->height -= s->avctx->extradata[0] & 0x0F;
            }
85 86 87 88 89 90
            res = 2;
        }

        vp56_init_range_decoder(c, buf+6, buf_size-6);
        vp56_rac_gets(c, 2);

91
        parse_filter_info = s->filter_header;
92 93 94
        if (sub_version < 8)
            vrt_shift = 5;
        s->sub_version = sub_version;
95
    } else {
96 97 98
        if (!s->sub_version)
            return 0;

99
        if (separated_coeff || !s->filter_header) {
100
            coeff_offset = AV_RB16(buf+1) - 2;
101 102 103
            buf += 2;
            buf_size -= 2;
        }
104 105 106
        vp56_init_range_decoder(c, buf+1, buf_size-1);

        *golden_frame = vp56_rac_get(c);
107
        if (s->filter_header) {
Aurelien Jacobs's avatar
Aurelien Jacobs committed
108 109 110 111 112
            s->deblock_filtering = vp56_rac_get(c);
            if (s->deblock_filtering)
                vp56_rac_get(c);
            if (s->sub_version > 7)
                parse_filter_info = vp56_rac_get(c);
113
        }
114 115 116 117 118
    }

    if (parse_filter_info) {
        if (vp56_rac_get(c)) {
            s->filter_mode = 2;
119
            s->sample_variance_threshold = vp56_rac_gets(c, 5) << vrt_shift;
120 121 122 123 124 125
            s->max_vector_length = 2 << vp56_rac_gets(c, 3);
        } else if (vp56_rac_get(c)) {
            s->filter_mode = 1;
        } else {
            s->filter_mode = 0;
        }
126 127 128 129
        if (s->sub_version > 7)
            s->filter_selection = vp56_rac_gets(c, 4);
        else
            s->filter_selection = 16;
130 131
    }

132
    s->use_huffman = vp56_rac_get(c);
133

134
    s->parse_coeff = vp6_parse_coeff;
135
    if (coeff_offset) {
136 137 138 139
        buf      += coeff_offset;
        buf_size -= coeff_offset;
        if (s->use_huffman) {
            s->parse_coeff = vp6_parse_coeff_huffman;
140
            init_get_bits(&s->gb, buf, buf_size<<3);
141 142 143 144
        } else {
            vp56_init_range_decoder(&s->cc, buf, buf_size);
            s->ccp = &s->cc;
        }
145 146 147 148
    } else {
        s->ccp = &s->c;
    }

149 150 151 152 153 154 155
    return res;
}

static void vp6_coeff_order_table_init(vp56_context_t *s)
{
    int i, pos, idx = 1;

156
    s->modelp->coeff_index_to_pos[0] = 0;
157 158
    for (i=0; i<16; i++)
        for (pos=1; pos<64; pos++)
159 160
            if (s->modelp->coeff_reorder[pos] == i)
                s->modelp->coeff_index_to_pos[idx++] = pos;
161 162 163 164
}

static void vp6_default_models_init(vp56_context_t *s)
{
165
    vp56_model_t *model = s->modelp;
166

167 168 169 170 171 172 173 174 175 176
    model->vector_dct[0] = 0xA2;
    model->vector_dct[1] = 0xA4;
    model->vector_sig[0] = 0x80;
    model->vector_sig[1] = 0x80;

    memcpy(model->mb_types_stats, vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
    memcpy(model->vector_fdv, vp6_def_fdv_vector_model, sizeof(model->vector_fdv));
    memcpy(model->vector_pdv, vp6_def_pdv_vector_model, sizeof(model->vector_pdv));
    memcpy(model->coeff_runv, vp6_def_runv_coeff_model, sizeof(model->coeff_runv));
    memcpy(model->coeff_reorder, vp6_def_coeff_reorder, sizeof(model->coeff_reorder));
177 178 179 180 181 182 183

    vp6_coeff_order_table_init(s);
}

static void vp6_parse_vector_models(vp56_context_t *s)
{
    vp56_range_coder_t *c = &s->c;
184
    vp56_model_t *model = s->modelp;
185 186 187 188
    int comp, node;

    for (comp=0; comp<2; comp++) {
        if (vp56_rac_get_prob(c, vp6_sig_dct_pct[comp][0]))
189
            model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
190
        if (vp56_rac_get_prob(c, vp6_sig_dct_pct[comp][1]))
191
            model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
192 193 194 195 196
    }

    for (comp=0; comp<2; comp++)
        for (node=0; node<7; node++)
            if (vp56_rac_get_prob(c, vp6_pdv_pct[comp][node]))
197
                model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
198 199 200 201

    for (comp=0; comp<2; comp++)
        for (node=0; node<8; node++)
            if (vp56_rac_get_prob(c, vp6_fdv_pct[comp][node]))
202
                model->vector_fdv[comp][node] = vp56_rac_gets_nn(c, 7);
203 204
}

205
/* nodes must ascend by count, but with descending symbol order */
206 207 208
static int vp6_huff_cmp(const void *va, const void *vb)
{
    const Node *a = va, *b = vb;
209
    return (a->count - b->count)*16 + (b->sym - a->sym);
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
}

static void vp6_build_huff_tree(vp56_context_t *s, uint8_t coeff_model[],
                                const uint8_t *map, unsigned size, VLC *vlc)
{
    Node nodes[2*size], *tmp = &nodes[size];
    int a, b, i;

    /* first compute probabilities from model */
    tmp[0].count = 256;
    for (i=0; i<size-1; i++) {
        a = tmp[i].count *        coeff_model[i]  >> 8;
        b = tmp[i].count * (255 - coeff_model[i]) >> 8;
        nodes[map[2*i  ]].count = a + !a;
        nodes[map[2*i+1]].count = b + !b;
    }

    /* then build the huffman tree accodring to probabilities */
228 229
    ff_huff_build_tree(s->avctx, vlc, size, nodes, vp6_huff_cmp,
                       FF_HUFFMAN_FLAG_HNODE_FIRST);
230 231
}

232 233 234
static void vp6_parse_coeff_models(vp56_context_t *s)
{
    vp56_range_coder_t *c = &s->c;
235
    vp56_model_t *model = s->modelp;
236 237 238 239 240 241 242 243 244 245 246
    int def_prob[11];
    int node, cg, ctx, pos;
    int ct;    /* code type */
    int pt;    /* plane type (0 for Y, 1 for U or V) */

    memset(def_prob, 0x80, sizeof(def_prob));

    for (pt=0; pt<2; pt++)
        for (node=0; node<11; node++)
            if (vp56_rac_get_prob(c, vp6_dccv_pct[pt][node])) {
                def_prob[node] = vp56_rac_gets_nn(c, 7);
247
                model->coeff_dccv[pt][node] = def_prob[node];
248
            } else if (s->framep[VP56_FRAME_CURRENT]->key_frame) {
249
                model->coeff_dccv[pt][node] = def_prob[node];
250 251 252 253 254
            }

    if (vp56_rac_get(c)) {
        for (pos=1; pos<64; pos++)
            if (vp56_rac_get_prob(c, vp6_coeff_reorder_pct[pos]))
255
                model->coeff_reorder[pos] = vp56_rac_gets(c, 4);
256 257 258 259 260 261
        vp6_coeff_order_table_init(s);
    }

    for (cg=0; cg<2; cg++)
        for (node=0; node<14; node++)
            if (vp56_rac_get_prob(c, vp6_runv_pct[cg][node]))
262
                model->coeff_runv[cg][node] = vp56_rac_gets_nn(c, 7);
263 264 265 266 267 268 269

    for (ct=0; ct<3; ct++)
        for (pt=0; pt<2; pt++)
            for (cg=0; cg<6; cg++)
                for (node=0; node<11; node++)
                    if (vp56_rac_get_prob(c, vp6_ract_pct[ct][pt][cg][node])) {
                        def_prob[node] = vp56_rac_gets_nn(c, 7);
270
                        model->coeff_ract[pt][ct][cg][node] = def_prob[node];
271
                    } else if (s->framep[VP56_FRAME_CURRENT]->key_frame) {
272
                        model->coeff_ract[pt][ct][cg][node] = def_prob[node];
273 274
                    }

275 276 277 278 279 280 281 282 283 284 285 286 287 288
    if (s->use_huffman) {
        for (pt=0; pt<2; pt++) {
            vp6_build_huff_tree(s, model->coeff_dccv[pt],
                                vp6_huff_coeff_map, 12, &s->dccv_vlc[pt]);
            vp6_build_huff_tree(s, model->coeff_runv[pt],
                                vp6_huff_run_map, 9, &s->runv_vlc[pt]);
            for (ct=0; ct<3; ct++)
                for (cg = 0; cg < 6; cg++)
                    vp6_build_huff_tree(s, model->coeff_ract[pt][ct][cg],
                                        vp6_huff_coeff_map, 12,
                                        &s->ract_vlc[pt][ct][cg]);
        }
        memset(s->nb_null, 0, sizeof(s->nb_null));
    } else {
289
    /* coeff_dcct is a linear combination of coeff_dccv */
290 291 292
    for (pt=0; pt<2; pt++)
        for (ctx=0; ctx<3; ctx++)
            for (node=0; node<5; node++)
293
                model->coeff_dcct[pt][ctx][node] = av_clip(((model->coeff_dccv[pt][node] * vp6_dccv_lc[ctx][node][0] + 128) >> 8) + vp6_dccv_lc[ctx][node][1], 1, 255);
294
    }
295 296
}

297
static void vp6_parse_vector_adjustment(vp56_context_t *s, vp56_mv_t *vect)
298 299
{
    vp56_range_coder_t *c = &s->c;
300
    vp56_model_t *model = s->modelp;
301 302
    int comp;

303
    *vect = (vp56_mv_t) {0,0};
304
    if (s->vector_candidate_pos < 2)
305
        *vect = s->vector_candidate[0];
306 307 308 309

    for (comp=0; comp<2; comp++) {
        int i, delta = 0;

310
        if (vp56_rac_get_prob(c, model->vector_dct[comp])) {
311 312 313
            static const uint8_t prob_order[] = {0, 1, 2, 7, 6, 5, 4};
            for (i=0; i<sizeof(prob_order); i++) {
                int j = prob_order[i];
314
                delta |= vp56_rac_get_prob(c, model->vector_fdv[comp][j])<<j;
315 316
            }
            if (delta & 0xF0)
317
                delta |= vp56_rac_get_prob(c, model->vector_fdv[comp][3])<<3;
318 319 320 321
            else
                delta |= 8;
        } else {
            delta = vp56_rac_get_tree(c, vp56_pva_tree,
322
                                      model->vector_pdv[comp]);
323 324
        }

325
        if (delta && vp56_rac_get_prob(c, model->vector_sig[comp]))
326 327 328
            delta = -delta;

        if (!comp)
329
            vect->x += delta;
330
        else
331
            vect->y += delta;
332 333 334
    }
}

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
/**
 * Read number of consecutive blocks with null DC or AC.
 * This value is < 74.
 */
static unsigned vp6_get_nb_null(vp56_context_t *s)
{
    unsigned val = get_bits(&s->gb, 2);
    if (val == 2)
        val += get_bits(&s->gb, 2);
    else if (val == 3) {
        val = get_bits1(&s->gb) << 2;
        val = 6+val + get_bits(&s->gb, 2+val);
    }
    return val;
}

static void vp6_parse_coeff_huffman(vp56_context_t *s)
{
    vp56_model_t *model = s->modelp;
    uint8_t *permute = s->scantable.permutated;
    VLC *vlc_coeff;
    int coeff, sign, coeff_idx;
    int b, cg, idx;
    int pt = 0;    /* plane type (0 for Y, 1 for U or V) */

    for (b=0; b<6; b++) {
        int ct = 0;    /* code type */
        if (b > 3) pt = 1;
        vlc_coeff = &s->dccv_vlc[pt];

        for (coeff_idx=0; coeff_idx<64; ) {
            int run = 1;
            if (coeff_idx<2 && s->nb_null[coeff_idx][pt]) {
                s->nb_null[coeff_idx][pt]--;
                if (coeff_idx)
                    break;
            } else {
                coeff = get_vlc2(&s->gb, vlc_coeff->table, 9, 3);
                if (coeff == 0) {
                    if (coeff_idx) {
                        int pt = (coeff_idx >= 6);
                        run += get_vlc2(&s->gb, s->runv_vlc[pt].table, 9, 3);
                        if (run >= 9)
                            run += get_bits(&s->gb, 6);
                    } else
                        s->nb_null[0][pt] = vp6_get_nb_null(s);
                    ct = 0;
                } else if (coeff == 11) {  /* end of block */
                    if (coeff_idx == 1)    /* first AC coeff ? */
                        s->nb_null[1][pt] = vp6_get_nb_null(s);
                    break;
                } else {
                    int coeff2 = vp56_coeff_bias[coeff];
                    if (coeff > 4)
                        coeff2 += get_bits(&s->gb, coeff <= 9 ? coeff - 4 : 11);
                    ct = 1 + (coeff2 > 1);
                    sign = get_bits1(&s->gb);
                    coeff2 = (coeff2 ^ -sign) + sign;
                    if (coeff_idx)
                        coeff2 *= s->dequant_ac;
                    idx = model->coeff_index_to_pos[coeff_idx];
                    s->block_coeff[b][permute[idx]] = coeff2;
                }
            }
            coeff_idx+=run;
            cg = FFMIN(vp6_coeff_groups[coeff_idx], 3);
            vlc_coeff = &s->ract_vlc[pt][ct][cg];
        }
    }
}

406 407
static void vp6_parse_coeff(vp56_context_t *s)
{
408
    vp56_range_coder_t *c = s->ccp;
409
    vp56_model_t *model = s->modelp;
410
    uint8_t *permute = s->scantable.permutated;
411
    uint8_t *model1, *model2, *model3;
412 413 414 415 416 417 418 419 420 421 422 423
    int coeff, sign, coeff_idx;
    int b, i, cg, idx, ctx;
    int pt = 0;    /* plane type (0 for Y, 1 for U or V) */

    for (b=0; b<6; b++) {
        int ct = 1;    /* code type */
        int run = 1;

        if (b > 3) pt = 1;

        ctx = s->left_block[vp56_b6to4[b]].not_null_dc
              + s->above_blocks[s->above_block_idx[b]].not_null_dc;
424 425
        model1 = model->coeff_dccv[pt];
        model2 = model->coeff_dcct[pt][ctx];
426 427 428 429 430 431

        for (coeff_idx=0; coeff_idx<64; ) {
            if ((coeff_idx>1 && ct==0) || vp56_rac_get_prob(c, model2[0])) {
                /* parse a coeff */
                if (vp56_rac_get_prob(c, model2[2])) {
                    if (vp56_rac_get_prob(c, model2[3])) {
432
                        idx = vp56_rac_get_tree(c, vp56_pc_tree, model1);
433
                        coeff = vp56_coeff_bias[idx+5];
434 435 436 437
                        for (i=vp56_coeff_bit_length[idx]; i>=0; i--)
                            coeff += vp56_rac_get_prob(c, vp56_coeff_parse_table[idx][i]) << i;
                    } else {
                        if (vp56_rac_get_prob(c, model2[4]))
438
                            coeff = 3 + vp56_rac_get_prob(c, model1[5]);
439 440 441 442 443 444 445 446 447 448 449 450
                        else
                            coeff = 2;
                    }
                    ct = 2;
                } else {
                    ct = 1;
                    coeff = 1;
                }
                sign = vp56_rac_get(c);
                coeff = (coeff ^ -sign) + sign;
                if (coeff_idx)
                    coeff *= s->dequant_ac;
451
                idx = model->coeff_index_to_pos[coeff_idx];
452 453 454 455 456
                s->block_coeff[b][permute[idx]] = coeff;
                run = 1;
            } else {
                /* parse a run */
                ct = 0;
Loren Merritt's avatar
Loren Merritt committed
457
                if (coeff_idx > 0) {
458 459 460
                    if (!vp56_rac_get_prob(c, model2[1]))
                        break;

461
                    model3 = model->coeff_runv[coeff_idx >= 6];
462 463 464 465 466 467 468 469
                    run = vp56_rac_get_tree(c, vp6_pcr_tree, model3);
                    if (!run)
                        for (run=9, i=0; i<6; i++)
                            run += vp56_rac_get_prob(c, model3[i+8]) << i;
                }
            }

            cg = vp6_coeff_groups[coeff_idx+=run];
470
            model1 = model2 = model->coeff_ract[pt][ct][cg];
471
        }
Loren Merritt's avatar
Loren Merritt committed
472 473 474

        s->left_block[vp56_b6to4[b]].not_null_dc =
        s->above_blocks[s->above_block_idx[b]].not_null_dc = !!s->block_coeff[b][0];
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
    }
}

static int vp6_adjust(int v, int t)
{
    int V = v, s = v >> 31;
    V ^= s;
    V -= s;
    if (V-t-1 >= (unsigned)(t-1))
        return v;
    V = 2*t - V;
    V += s;
    V ^= s;
    return V;
}

static int vp6_block_variance(uint8_t *src, int stride)
{
    int sum = 0, square_sum = 0;
    int y, x;

    for (y=0; y<8; y+=2) {
        for (x=0; x<8; x+=2) {
            sum += src[x];
            square_sum += src[x]*src[x];
        }
        src += 2*stride;
    }
Aurelien Jacobs's avatar
Aurelien Jacobs committed
503
    return (16*square_sum - sum*sum) >> 8;
504 505 506 507 508 509 510 511 512
}

static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, int stride,
                           int delta, const int16_t *weights)
{
    int x, y;

    for (y=0; y<8; y++) {
        for (x=0; x<8; x++) {
513
            dst[x] = av_clip_uint8((  src[x-delta  ] * weights[0]
514 515 516 517 518 519 520 521 522 523 524 525 526
                                 + src[x        ] * weights[1]
                                 + src[x+delta  ] * weights[2]
                                 + src[x+2*delta] * weights[3] + 64) >> 7);
        }
        src += stride;
        dst += stride;
    }
}

static void vp6_filter_diag2(vp56_context_t *s, uint8_t *dst, uint8_t *src,
                             int stride, int h_weight, int v_weight)
{
    uint8_t *tmp = s->edge_emu_buffer+16;
527 528
    s->dsp.put_h264_chroma_pixels_tab[0](tmp, src, stride, 9, h_weight, 0);
    s->dsp.put_h264_chroma_pixels_tab[0](dst, tmp, stride, 8, 0, v_weight);
529 530 531 532 533 534 535 536 537 538 539 540 541
}

static void vp6_filter_diag4(uint8_t *dst, uint8_t *src, int stride,
                             const int16_t *h_weights,const int16_t *v_weights)
{
    int x, y;
    int tmp[8*11];
    int *t = tmp;

    src -= stride;

    for (y=0; y<11; y++) {
        for (x=0; x<8; x++) {
542
            t[x] = av_clip_uint8((  src[x-1] * h_weights[0]
543 544 545 546 547 548 549 550 551 552 553
                               + src[x  ] * h_weights[1]
                               + src[x+1] * h_weights[2]
                               + src[x+2] * h_weights[3] + 64) >> 7);
        }
        src += stride;
        t += 8;
    }

    t = tmp + 8;
    for (y=0; y<8; y++) {
        for (x=0; x<8; x++) {
554
            dst[x] = av_clip_uint8((  t[x-8 ] * v_weights[0]
555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
                                 + t[x   ] * v_weights[1]
                                 + t[x+8 ] * v_weights[2]
                                 + t[x+16] * v_weights[3] + 64) >> 7);
        }
        dst += stride;
        t += 8;
    }
}

static void vp6_filter(vp56_context_t *s, uint8_t *dst, uint8_t *src,
                       int offset1, int offset2, int stride,
                       vp56_mv_t mv, int mask, int select, int luma)
{
    int filter4 = 0;
    int x8 = mv.x & mask;
    int y8 = mv.y & mask;

    if (luma) {
        x8 *= 2;
        y8 *= 2;
        filter4 = s->filter_mode;
        if (filter4 == 2) {
            if (s->max_vector_length &&
578 579
                (FFABS(mv.x) > s->max_vector_length ||
                 FFABS(mv.y) > s->max_vector_length)) {
580
                filter4 = 0;
581 582
            } else if (s->sample_variance_threshold
                       && (vp6_block_variance(src+offset1, stride)
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
                           < s->sample_variance_threshold)) {
                filter4 = 0;
            }
        }
    }

    if ((y8 && (offset2-offset1)*s->flip<0) || (!y8 && offset1 > offset2)) {
        offset1 = offset2;
    }

    if (filter4) {
        if (!y8) {                      /* left or right combine */
            vp6_filter_hv4(dst, src+offset1, stride, 1,
                           vp6_block_copy_filter[select][x8]);
        } else if (!x8) {               /* above or below combine */
            vp6_filter_hv4(dst, src+offset1, stride, stride,
                           vp6_block_copy_filter[select][y8]);
Loren Merritt's avatar
Loren Merritt committed
600 601
        } else {
            vp6_filter_diag4(dst, src+offset1 + ((mv.x^mv.y)>>31), stride,
602 603 604 605
                             vp6_block_copy_filter[select][x8],
                             vp6_block_copy_filter[select][y8]);
        }
    } else {
606 607
        if (!x8 || !y8) {
            s->dsp.put_h264_chroma_pixels_tab[0](dst, src+offset1, stride, 8, x8, y8);
Loren Merritt's avatar
Loren Merritt committed
608 609
        } else {
            vp6_filter_diag2(s, dst, src+offset1 + ((mv.x^mv.y)>>31), stride, x8, y8);
610 611 612 613
        }
    }
}

614
static av_cold int vp6_decode_init(AVCodecContext *avctx)
615 616 617
{
    vp56_context_t *s = avctx->priv_data;

618 619
    vp56_init(avctx, avctx->codec->id == CODEC_ID_VP6,
                     avctx->codec->id == CODEC_ID_VP6A);
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
    s->vp56_coord_div = vp6_coord_div;
    s->parse_vector_adjustment = vp6_parse_vector_adjustment;
    s->adjust = vp6_adjust;
    s->filter = vp6_filter;
    s->default_models_init = vp6_default_models_init;
    s->parse_vector_models = vp6_parse_vector_models;
    s->parse_coeff_models = vp6_parse_coeff_models;
    s->parse_header = vp6_parse_header;

    return 0;
}

AVCodec vp6_decoder = {
    "vp6",
    CODEC_TYPE_VIDEO,
    CODEC_ID_VP6,
    sizeof(vp56_context_t),
    vp6_decode_init,
    NULL,
    vp56_free,
    vp56_decode_frame,
641
    CODEC_CAP_DR1,
642
    .long_name = NULL_IF_CONFIG_SMALL("On2 VP6"),
643 644 645 646 647 648 649 650 651 652 653 654
};

/* flash version, not flipped upside-down */
AVCodec vp6f_decoder = {
    "vp6f",
    CODEC_TYPE_VIDEO,
    CODEC_ID_VP6F,
    sizeof(vp56_context_t),
    vp6_decode_init,
    NULL,
    vp56_free,
    vp56_decode_frame,
655
    CODEC_CAP_DR1,
656
    .long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version)"),
657
};
658 659 660 661 662 663 664 665 666 667 668 669

/* flash version, not flipped upside-down, with alpha channel */
AVCodec vp6a_decoder = {
    "vp6a",
    CODEC_TYPE_VIDEO,
    CODEC_ID_VP6A,
    sizeof(vp56_context_t),
    vp6_decode_init,
    NULL,
    vp56_free,
    vp56_decode_frame,
    CODEC_CAP_DR1,
670
    .long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version, with alpha channel)"),
671
};