GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vp56.c Lines: 479 516 92.8 %
Date: 2020-08-14 10:39:37 Branches: 247 283 87.3 %

Line Branch Exec Source
1
/*
2
 * Copyright (C) 2006  Aurelien Jacobs <aurel@gnuage.org>
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
/**
22
 * @file
23
 * VP5 and VP6 compatible video decoder (common features)
24
 */
25
26
#include "avcodec.h"
27
#include "bytestream.h"
28
#include "internal.h"
29
#include "h264chroma.h"
30
#include "vp56.h"
31
#include "vp56data.h"
32
33
34
960
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
35
{
36
960
    if (s->quantizer != quantizer)
37
408
        ff_vp3dsp_set_bounding_values(s->bounding_values_array, ff_vp56_filter_threshold[quantizer]);
38
960
    s->quantizer = quantizer;
39
960
    s->dequant_dc = ff_vp56_dc_dequant[quantizer] << 2;
40
960
    s->dequant_ac = ff_vp56_ac_dequant[quantizer] << 2;
41
960
}
42
43
238195
static int vp56_get_vectors_predictors(VP56Context *s, int row, int col,
44
                                       VP56Frame ref_frame)
45
{
46
238195
    int nb_pred = 0;
47
238195
    VP56mv vect[2] = {{0,0}, {0,0}};
48
    int pos, offset;
49
    VP56mv mvp;
50
51
2438878
    for (pos=0; pos<12; pos++) {
52
2277692
        mvp.x = col + ff_vp56_candidate_predictor_pos[pos][0];
53
2277692
        mvp.y = row + ff_vp56_candidate_predictor_pos[pos][1];
54

2277692
        if (mvp.x < 0 || mvp.x >= s->mb_width ||
55

2130422
            mvp.y < 0 || mvp.y >= s->mb_height)
56
362660
            continue;
57
1915032
        offset = mvp.x + s->mb_width*mvp.y;
58
59
1915032
        if (ff_vp56_reference_frame[s->macroblocks[offset].type] != ref_frame)
60
331615
            continue;
61
1583417
        if ((s->macroblocks[offset].mv.x == vect[0].x &&
62
1292994
             s->macroblocks[offset].mv.y == vect[0].y) ||
63
366371
            (s->macroblocks[offset].mv.x == 0 &&
64
207738
             s->macroblocks[offset].mv.y == 0))
65
1394073
            continue;
66
67
189344
        vect[nb_pred++] = s->macroblocks[offset].mv;
68
189344
        if (nb_pred > 1) {
69
77009
            nb_pred = -1;
70
77009
            break;
71
        }
72
112335
        s->vector_candidate_pos = pos;
73
    }
74
75
238195
    s->vector_candidate[0] = vect[0];
76
238195
    s->vector_candidate[1] = vect[1];
77
78
238195
    return nb_pred+1;
79
}
80
81
916
static void vp56_parse_mb_type_models(VP56Context *s)
82
{
83
916
    VP56RangeCoder *c = &s->c;
84
916
    VP56Model *model = s->modelp;
85
    int i, ctx, type;
86
87
3664
    for (ctx=0; ctx<3; ctx++) {
88
2748
        if (vp56_rac_get_prob_branchy(c, 174)) {
89
730
            int idx = vp56_rac_gets(c, 4);
90
730
            memcpy(model->mb_types_stats[ctx],
91
730
                   ff_vp56_pre_def_mb_type_stats[idx][ctx],
92
                   sizeof(model->mb_types_stats[ctx]));
93
        }
94
2748
        if (vp56_rac_get_prob_branchy(c, 254)) {
95
1287
            for (type=0; type<10; type++) {
96
3510
                for(i=0; i<2; i++) {
97
2340
                    if (vp56_rac_get_prob_branchy(c, 205)) {
98
915
                        int delta, sign = vp56_rac_get(c);
99
100
915
                        delta = vp56_rac_get_tree(c, ff_vp56_pmbtm_tree,
101
                                                  ff_vp56_mb_type_model_model);
102
915
                        if (!delta)
103
139
                            delta = 4 * vp56_rac_gets(c, 7);
104
915
                        model->mb_types_stats[ctx][type][i] += (delta ^ -sign) + sign;
105
                    }
106
                }
107
            }
108
        }
109
    }
110
111
    /* compute MB type probability tables based on previous MB type */
112
3664
    for (ctx=0; ctx<3; ctx++) {
113
        int p[10];
114
115
30228
        for (type=0; type<10; type++)
116
27480
            p[type] = 100 * model->mb_types_stats[ctx][type][1];
117
118
30228
        for (type=0; type<10; type++) {
119
            int p02, p34, p0234, p17, p56, p89, p5689, p156789;
120
121
            /* conservative MB type probability */
122
27480
            model->mb_type[ctx][type][0] = 255 - (255 * model->mb_types_stats[ctx][type][0]) / (1 + model->mb_types_stats[ctx][type][0] + model->mb_types_stats[ctx][type][1]);
123
124
27480
            p[type] = 0;    /* same MB type => weight is null */
125
126
            /* binary tree parsing probabilities */
127
27480
            p02 = p[0] + p[2];
128
27480
            p34 = p[3] + p[4];
129
27480
            p0234 = p02 + p34;
130
27480
            p17 = p[1] + p[7];
131
27480
            p56 = p[5] + p[6];
132
27480
            p89 = p[8] + p[9];
133
27480
            p5689 = p56 + p89;
134
27480
            p156789 = p17 + p5689;
135
136
27480
            model->mb_type[ctx][type][1] = 1 + 255 * p0234/(1+p0234+p156789);
137
27480
            model->mb_type[ctx][type][2] = 1 + 255 * p02  / (1+p0234);
138
27480
            model->mb_type[ctx][type][3] = 1 + 255 * p17  / (1+p156789);
139
27480
            model->mb_type[ctx][type][4] = 1 + 255 * p[0] / (1+p02);
140
27480
            model->mb_type[ctx][type][5] = 1 + 255 * p[3] / (1+p34);
141
27480
            model->mb_type[ctx][type][6] = 1 + 255 * p[1] / (1+p17);
142
27480
            model->mb_type[ctx][type][7] = 1 + 255 * p56  / (1+p5689);
143
27480
            model->mb_type[ctx][type][8] = 1 + 255 * p[5] / (1+p56);
144
27480
            model->mb_type[ctx][type][9] = 1 + 255 * p[8] / (1+p89);
145
146
            /* restore initial value */
147
27480
            p[type] = 100 * model->mb_types_stats[ctx][type][1];
148
        }
149
    }
150
916
}
151
152
235558
static VP56mb vp56_parse_mb_type(VP56Context *s,
153
                                 VP56mb prev_type, int ctx)
154
{
155
235558
    uint8_t *mb_type_model = s->modelp->mb_type[ctx][prev_type];
156
235558
    VP56RangeCoder *c = &s->c;
157
158
235558
    if (vp56_rac_get_prob_branchy(c, mb_type_model[0]))
159
178882
        return prev_type;
160
    else
161
56676
        return vp56_rac_get_tree(c, ff_vp56_pmbt_tree, mb_type_model);
162
}
163
164
10512
static void vp56_decode_4mv(VP56Context *s, int row, int col)
165
{
166
10512
    VP56mv mv = {0,0};
167
    int type[4];
168
    int b;
169
170
    /* parse each block type */
171
52560
    for (b=0; b<4; b++) {
172
42048
        type[b] = vp56_rac_gets(&s->c, 2);
173
42048
        if (type[b])
174
33489
            type[b]++;  /* only returns 0, 2, 3 or 4 (all INTER_PF) */
175
    }
176
177
    /* get vectors */
178
52560
    for (b=0; b<4; b++) {
179

42048
        switch (type[b]) {
180
8559
            case VP56_MB_INTER_NOVEC_PF:
181
8559
                s->mv[b] = (VP56mv) {0,0};
182
8559
                break;
183
12581
            case VP56_MB_INTER_DELTA_PF:
184
12581
                s->parse_vector_adjustment(s, &s->mv[b]);
185
12581
                break;
186
12468
            case VP56_MB_INTER_V1_PF:
187
12468
                s->mv[b] = s->vector_candidate[0];
188
12468
                break;
189
8440
            case VP56_MB_INTER_V2_PF:
190
8440
                s->mv[b] = s->vector_candidate[1];
191
8440
                break;
192
        }
193
42048
        mv.x += s->mv[b].x;
194
42048
        mv.y += s->mv[b].y;
195
    }
196
197
    /* this is the one selected for the whole MB for prediction */
198
10512
    s->macroblocks[row * s->mb_width + col].mv = s->mv[3];
199
200
    /* chroma vectors are average luma vectors */
201
10512
    s->mv[4].x = s->mv[5].x = RSHIFT(mv.x,2);
202
10512
    s->mv[4].y = s->mv[5].y = RSHIFT(mv.y,2);
203
10512
}
204
205
235558
static VP56mb vp56_decode_mv(VP56Context *s, int row, int col)
206
{
207
235558
    VP56mv *mv, vect = {0,0};
208
    int ctx, b;
209
210
235558
    ctx = vp56_get_vectors_predictors(s, row, col, VP56_FRAME_PREVIOUS);
211
235558
    s->mb_type = vp56_parse_mb_type(s, s->mb_type, ctx);
212
235558
    s->macroblocks[row * s->mb_width + col].type = s->mb_type;
213
214


235558
    switch (s->mb_type) {
215
36874
        case VP56_MB_INTER_V1_PF:
216
36874
            mv = &s->vector_candidate[0];
217
36874
            break;
218
219
11522
        case VP56_MB_INTER_V2_PF:
220
11522
            mv = &s->vector_candidate[1];
221
11522
            break;
222
223
1037
        case VP56_MB_INTER_V1_GF:
224
1037
            vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
225
1037
            mv = &s->vector_candidate[0];
226
1037
            break;
227
228
160
        case VP56_MB_INTER_V2_GF:
229
160
            vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
230
160
            mv = &s->vector_candidate[1];
231
160
            break;
232
233
14426
        case VP56_MB_INTER_DELTA_PF:
234
14426
            s->parse_vector_adjustment(s, &vect);
235
14426
            mv = &vect;
236
14426
            break;
237
238
1440
        case VP56_MB_INTER_DELTA_GF:
239
1440
            vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
240
1440
            s->parse_vector_adjustment(s, &vect);
241
1440
            mv = &vect;
242
1440
            break;
243
244
10512
        case VP56_MB_INTER_4V:
245
10512
            vp56_decode_4mv(s, row, col);
246
10512
            return s->mb_type;
247
248
159587
        default:
249
159587
            mv = &vect;
250
159587
            break;
251
    }
252
253
225046
    s->macroblocks[row*s->mb_width + col].mv = *mv;
254
255
    /* same vector for all blocks */
256
1575322
    for (b=0; b<6; b++)
257
1350276
        s->mv[b] = *mv;
258
259
225046
    return s->mb_type;
260
}
261
262
363
static VP56mb vp56_conceal_mv(VP56Context *s, int row, int col)
263
{
264
363
    VP56mv *mv, vect = {0,0};
265
    int b;
266
267
363
    s->mb_type = VP56_MB_INTER_NOVEC_PF;
268
363
    s->macroblocks[row * s->mb_width + col].type = s->mb_type;
269
270
363
    mv = &vect;
271
272
363
    s->macroblocks[row*s->mb_width + col].mv = *mv;
273
274
    /* same vector for all blocks */
275
2541
    for (b=0; b<6; b++)
276
2178
        s->mv[b] = *mv;
277
278
363
    return s->mb_type;
279
}
280
281
245731
static void vp56_add_predictors_dc(VP56Context *s, VP56Frame ref_frame)
282
{
283
245731
    int idx = s->idct_scantable[0];
284
    int b;
285
286
1720117
    for (b=0; b<6; b++) {
287
1474386
        VP56RefDc *ab = &s->above_blocks[s->above_block_idx[b]];
288
1474386
        VP56RefDc *lb = &s->left_block[ff_vp56_b6to4[b]];
289
1474386
        int count = 0;
290
1474386
        int dc = 0;
291
        int i;
292
293
1474386
        if (ref_frame == lb->ref_frame) {
294
1388770
            dc += lb->dc_coeff;
295
1388770
            count++;
296
        }
297
1474386
        if (ref_frame == ab->ref_frame) {
298
1357234
            dc += ab->dc_coeff;
299
1357234
            count++;
300
        }
301
1474386
        if (s->avctx->codec->id == AV_CODEC_ID_VP5)
302
2703168
            for (i=0; i<2; i++)
303

1802112
                if (count < 2 && ref_frame == ab[-1+2*i].ref_frame) {
304
72112
                    dc += ab[-1+2*i].dc_coeff;
305
72112
                    count++;
306
                }
307
1474386
        if (count == 0)
308
18280
            dc = s->prev_dc[ff_vp56_b2p[b]][ref_frame];
309
1456106
        else if (count == 2)
310
1362010
            dc /= 2;
311
312
1474386
        s->block_coeff[b][idx] += dc;
313
1474386
        s->prev_dc[ff_vp56_b2p[b]][ref_frame] = s->block_coeff[b][idx];
314
1474386
        ab->dc_coeff = s->block_coeff[b][idx];
315
1474386
        ab->ref_frame = ref_frame;
316
1474386
        lb->dc_coeff = s->block_coeff[b][idx];
317
1474386
        lb->ref_frame = ref_frame;
318
1474386
        s->block_coeff[b][idx] *= s->dequant_dc;
319
    }
320
245731
}
321
322
423238
static void vp56_deblock_filter(VP56Context *s, uint8_t *yuv,
323
                                ptrdiff_t stride, int dx, int dy)
324
{
325
423238
    if (s->avctx->codec->id == AV_CODEC_ID_VP5) {
326
249618
    int t = ff_vp56_filter_threshold[s->quantizer];
327
249618
    if (dx)  s->vp56dsp.edge_filter_hor(yuv +         10-dx , stride, t);
328
249618
    if (dy)  s->vp56dsp.edge_filter_ver(yuv + stride*(10-dy), stride, t);
329
    } else {
330
173620
        int * bounding_values = s->bounding_values_array + 127;
331
173620
        if (dx)
332
66268
            ff_vp3dsp_h_loop_filter_12(yuv +         10-dx, stride, bounding_values);
333
173620
        if (dy)
334
63282
            ff_vp3dsp_v_loop_filter_12(yuv + stride*(10-dy), stride, bounding_values);
335
    }
336
423238
}
337
338
443512
static void vp56_mc(VP56Context *s, int b, int plane, uint8_t *src,
339
                    ptrdiff_t stride, int x, int y)
340
{
341
443512
    uint8_t *dst = s->frames[VP56_FRAME_CURRENT]->data[plane] + s->block_offset[b];
342
    uint8_t *src_block;
343
    int src_offset;
344
443512
    int overlap_offset = 0;
345
443512
    int mask = s->vp56_coord_div[b] - 1;
346
443512
    int deblock_filtering = s->deblock_filtering;
347
    int dx;
348
    int dy;
349
350
443512
    if (s->avctx->skip_loop_filter >= AVDISCARD_ALL ||
351
443512
        (s->avctx->skip_loop_filter >= AVDISCARD_NONKEY
352
         && !s->frames[VP56_FRAME_CURRENT]->key_frame))
353
        deblock_filtering = 0;
354
355
443512
    dx = s->mv[b].x / s->vp56_coord_div[b];
356
443512
    dy = s->mv[b].y / s->vp56_coord_div[b];
357
358
443512
    if (b >= 4) {
359
139632
        x /= 2;
360
139632
        y /= 2;
361
    }
362
443512
    x += dx - 2;
363
443512
    y += dy - 2;
364
365

443512
    if (x<0 || x+12>=s->plane_width[plane] ||
366
413084
        y<0 || y+12>=s->plane_height[plane]) {
367
49836
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
368
49836
                                 src + s->block_offset[b] + (dy-2)*stride + (dx-2),
369
                                 stride, stride,
370
                                 12, 12, x, y,
371
                                 s->plane_width[plane],
372
                                 s->plane_height[plane]);
373
49836
        src_block = s->edge_emu_buffer;
374
49836
        src_offset = 2 + 2*stride;
375
393676
    } else if (deblock_filtering) {
376
        /* only need a 12x12 block, but there is no such dsp function, */
377
        /* so copy a 16x12 block */
378
375220
        s->hdsp.put_pixels_tab[0][0](s->edge_emu_buffer,
379
375220
                                     src + s->block_offset[b] + (dy-2)*stride + (dx-2),
380
                                     stride, 12);
381
375220
        src_block = s->edge_emu_buffer;
382
375220
        src_offset = 2 + 2*stride;
383
    } else {
384
18456
        src_block = src;
385
18456
        src_offset = s->block_offset[b] + dy*stride + dx;
386
    }
387
388
443512
    if (deblock_filtering)
389
423238
        vp56_deblock_filter(s, src_block, stride, dx&7, dy&7);
390
391
443512
    if (s->mv[b].x & mask)
392
282743
        overlap_offset += (s->mv[b].x > 0) ? 1 : -1;
393
443512
    if (s->mv[b].y & mask)
394
277774
        overlap_offset += (s->mv[b].y > 0) ? stride : -stride;
395
396
443512
    if (overlap_offset) {
397
387371
        if (s->filter)
398
171252
            s->filter(s, dst, src_block, src_offset, src_offset+overlap_offset,
399
                      stride, s->mv[b], mask, s->filter_selection, b<4);
400
        else
401
216119
            s->vp3dsp.put_no_rnd_pixels_l2(dst, src_block+src_offset,
402
216119
                                           src_block+src_offset+overlap_offset,
403
                                           stride, 8);
404
    } else {
405
56141
        s->hdsp.put_pixels_tab[1][0](dst, src_block+src_offset, stride, 8);
406
    }
407
443512
}
408
409
197664
static void vp56_idct_put(VP56Context *s, uint8_t * dest, ptrdiff_t stride, int16_t *block, int selector)
410
{
411

197664
    if (selector > 10 || selector == 1)
412
162720
        s->vp3dsp.idct_put(dest, stride, block);
413
    else
414
34944
        ff_vp3dsp_idct10_put(dest, stride, block);
415
197664
}
416
417
1234314
static void vp56_idct_add(VP56Context *s, uint8_t * dest, ptrdiff_t stride, int16_t *block, int selector)
418
{
419
1234314
    if (selector > 10)
420
865208
        s->vp3dsp.idct_add(dest, stride, block);
421
369106
    else if (selector > 1)
422
369106
        ff_vp3dsp_idct10_add(dest, stride, block);
423
    else
424
        s->vp3dsp.idct_dc_add(dest, stride, block);
425
1234314
}
426
427
245731
static av_always_inline void vp56_render_mb(VP56Context *s, int row, int col, int is_alpha, VP56mb mb_type)
428
{
429
    int b, ab, b_max, plane, off;
430
    AVFrame *frame_current, *frame_ref;
431
245731
    VP56Frame ref_frame = ff_vp56_reference_frame[mb_type];
432
433
245731
    vp56_add_predictors_dc(s, ref_frame);
434
435
245731
    frame_current = s->frames[VP56_FRAME_CURRENT];
436
245731
    frame_ref = s->frames[ref_frame];
437

245731
    if (mb_type != VP56_MB_INTRA && !frame_ref->data[0])
438
        return;
439
440
245731
    ab = 6*is_alpha;
441
245731
    b_max = 6 - 2*is_alpha;
442
443

245731
    switch (mb_type) {
444
33512
        case VP56_MB_INTRA:
445
231176
            for (b=0; b<b_max; b++) {
446
197664
                plane = ff_vp56_b2p[b+ab];
447
197664
                vp56_idct_put(s, frame_current->data[plane] + s->block_offset[b],
448
197664
                                s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
449
            }
450
33512
            break;
451
452
136249
        case VP56_MB_INTER_NOVEC_PF:
453
        case VP56_MB_INTER_NOVEC_GF:
454
927051
            for (b=0; b<b_max; b++) {
455
790802
                plane = ff_vp56_b2p[b+ab];
456
790802
                off = s->block_offset[b];
457
790802
                s->hdsp.put_pixels_tab[1][0](frame_current->data[plane] + off,
458
790802
                                             frame_ref->data[plane] + off,
459
                                             s->stride[plane], 8);
460
790802
                vp56_idct_add(s, frame_current->data[plane] + off,
461
790802
                              s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
462
            }
463
136249
            break;
464
465
75970
        case VP56_MB_INTER_DELTA_PF:
466
        case VP56_MB_INTER_V1_PF:
467
        case VP56_MB_INTER_V2_PF:
468
        case VP56_MB_INTER_DELTA_GF:
469
        case VP56_MB_INTER_4V:
470
        case VP56_MB_INTER_V1_GF:
471
        case VP56_MB_INTER_V2_GF:
472
519482
            for (b=0; b<b_max; b++) {
473

443512
                int x_off = b==1 || b==3 ? 8 : 0;
474

443512
                int y_off = b==2 || b==3 ? 8 : 0;
475
443512
                plane = ff_vp56_b2p[b+ab];
476
443512
                vp56_mc(s, b, plane, frame_ref->data[plane], s->stride[plane],
477
443512
                        16*col+x_off, 16*row+y_off);
478
443512
                vp56_idct_add(s, frame_current->data[plane] + s->block_offset[b],
479
443512
                              s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
480
            }
481
75970
            break;
482
    }
483
484
245731
    if (is_alpha) {
485
21204
        s->block_coeff[4][0] = 0;
486
21204
        s->block_coeff[5][0] = 0;
487
    }
488
}
489
490
245369
static int vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha)
491
{
492
    VP56mb mb_type;
493
    int ret;
494
495
245369
    if (s->frames[VP56_FRAME_CURRENT]->key_frame)
496
9811
        mb_type = VP56_MB_INTRA;
497
    else
498
235558
        mb_type = vp56_decode_mv(s, row, col);
499
500
245369
    ret = s->parse_coeff(s);
501
245369
    if (ret < 0)
502
1
        return ret;
503
504
245368
    vp56_render_mb(s, row, col, is_alpha, mb_type);
505
506
245368
    return 0;
507
}
508
509
363
static int vp56_conceal_mb(VP56Context *s, int row, int col, int is_alpha)
510
{
511
    VP56mb mb_type;
512
513
363
    if (s->frames[VP56_FRAME_CURRENT]->key_frame)
514
        mb_type = VP56_MB_INTRA;
515
    else
516
363
        mb_type = vp56_conceal_mv(s, row, col);
517
518
363
    vp56_render_mb(s, row, col, is_alpha, mb_type);
519
520
363
    return 0;
521
}
522
523
14
static int vp56_size_changed(VP56Context *s)
524
{
525
14
    AVCodecContext *avctx = s->avctx;
526
14
    int stride = s->frames[VP56_FRAME_CURRENT]->linesize[0];
527
    int i;
528
529
14
    s->plane_width[0]  = s->plane_width[3]  = avctx->coded_width;
530
14
    s->plane_width[1]  = s->plane_width[2]  = avctx->coded_width/2;
531
14
    s->plane_height[0] = s->plane_height[3] = avctx->coded_height;
532
14
    s->plane_height[1] = s->plane_height[2] = avctx->coded_height/2;
533
534
14
    s->have_undamaged_frame = 0;
535
536
70
    for (i=0; i<4; i++)
537
56
        s->stride[i] = s->flip * s->frames[VP56_FRAME_CURRENT]->linesize[i];
538
539
14
    s->mb_width  = (avctx->coded_width +15) / 16;
540
14
    s->mb_height = (avctx->coded_height+15) / 16;
541
542

14
    if (s->mb_width > 1000 || s->mb_height > 1000) {
543
        ff_set_dimensions(avctx, 0, 0);
544
        av_log(avctx, AV_LOG_ERROR, "picture too big\n");
545
        return AVERROR_INVALIDDATA;
546
    }
547
548
14
    av_reallocp_array(&s->above_blocks, 4*s->mb_width+6,
549
                      sizeof(*s->above_blocks));
550
14
    av_reallocp_array(&s->macroblocks, s->mb_width*s->mb_height,
551
                      sizeof(*s->macroblocks));
552
14
    av_free(s->edge_emu_buffer_alloc);
553
14
    s->edge_emu_buffer_alloc = av_malloc(16*stride);
554
14
    s->edge_emu_buffer = s->edge_emu_buffer_alloc;
555

14
    if (!s->above_blocks || !s->macroblocks || !s->edge_emu_buffer_alloc)
556
        return AVERROR(ENOMEM);
557
14
    if (s->flip < 0)
558
8
        s->edge_emu_buffer += 15 * stride;
559
560
14
    if (s->alpha_context)
561
2
        return vp56_size_changed(s->alpha_context);
562
563
12
    return 0;
564
}
565
566
static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *, int, int);
567
568
867
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
569
                         AVPacket *avpkt)
570
{
571
867
    const uint8_t *buf = avpkt->data;
572
867
    VP56Context *s = avctx->priv_data;
573
867
    AVFrame *const p = s->frames[VP56_FRAME_CURRENT];
574
867
    int remaining_buf_size = avpkt->size;
575
867
    int alpha_offset = remaining_buf_size;
576
    int i, res;
577
    int ret;
578
579
867
    if (s->has_alpha) {
580
186
        if (remaining_buf_size < 3)
581
            return AVERROR_INVALIDDATA;
582
186
        alpha_offset = bytestream_get_be24(&buf);
583
186
        remaining_buf_size -= 3;
584
186
        if (remaining_buf_size < alpha_offset)
585
            return AVERROR_INVALIDDATA;
586
    }
587
588
867
    res = s->parse_header(s, buf, alpha_offset);
589
867
    if (res < 0)
590
        return res;
591
592
867
    if (res == VP56_SIZE_CHANGE) {
593
60
        for (i = 0; i < 4; i++) {
594
48
            av_frame_unref(s->frames[i]);
595
48
            if (s->alpha_context)
596
8
                av_frame_unref(s->alpha_context->frames[i]);
597
        }
598
    }
599
600
867
    ret = ff_get_buffer(avctx, p, AV_GET_BUFFER_FLAG_REF);
601
867
    if (ret < 0) {
602
        if (res == VP56_SIZE_CHANGE)
603
            ff_set_dimensions(avctx, 0, 0);
604
        return ret;
605
    }
606
607
867
    if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
608
93
        av_frame_unref(s->alpha_context->frames[VP56_FRAME_CURRENT]);
609
93
        if ((ret = av_frame_ref(s->alpha_context->frames[VP56_FRAME_CURRENT], p)) < 0) {
610
            av_frame_unref(p);
611
            if (res == VP56_SIZE_CHANGE)
612
                ff_set_dimensions(avctx, 0, 0);
613
            return ret;
614
        }
615
    }
616
617
867
    if (res == VP56_SIZE_CHANGE) {
618
12
        if (vp56_size_changed(s)) {
619
            av_frame_unref(p);
620
            return AVERROR_INVALIDDATA;
621
        }
622
    }
623
624
867
    if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
625
93
        int bak_w = avctx->width;
626
93
        int bak_h = avctx->height;
627
93
        int bak_cw = avctx->coded_width;
628
93
        int bak_ch = avctx->coded_height;
629
93
        buf += alpha_offset;
630
93
        remaining_buf_size -= alpha_offset;
631
632
93
        res = s->alpha_context->parse_header(s->alpha_context, buf, remaining_buf_size);
633
93
        if (res != 0) {
634
            if(res==VP56_SIZE_CHANGE) {
635
                av_log(avctx, AV_LOG_ERROR, "Alpha reconfiguration\n");
636
                avctx->width  = bak_w;
637
                avctx->height = bak_h;
638
                avctx->coded_width  = bak_cw;
639
                avctx->coded_height = bak_ch;
640
            }
641
            av_frame_unref(p);
642
            return AVERROR_INVALIDDATA;
643
        }
644
    }
645
646
867
    s->discard_frame = 0;
647
867
    avctx->execute2(avctx, ff_vp56_decode_mbs, 0, 0, (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) + 1);
648
649
867
    if (s->discard_frame)
650
        return AVERROR_INVALIDDATA;
651
652
867
    if ((res = av_frame_ref(data, p)) < 0)
653
        return res;
654
867
    *got_frame = 1;
655
656
867
    return avpkt->size;
657
}
658
659
960
static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *data,
660
                              int jobnr, int threadnr)
661
{
662
960
    VP56Context *s0 = avctx->priv_data;
663
960
    int is_alpha = (jobnr == 1);
664
960
    VP56Context *s = is_alpha ? s0->alpha_context : s0;
665
960
    AVFrame *const p = s->frames[VP56_FRAME_CURRENT];
666
960
    int mb_row, mb_col, mb_row_flip, mb_offset = 0;
667
    int block, y, uv;
668
    ptrdiff_t stride_y, stride_uv;
669
    int res;
670
960
    int damaged = 0;
671
672
960
    if (p->key_frame) {
673
44
        p->pict_type = AV_PICTURE_TYPE_I;
674
44
        s->default_models_init(s);
675
9855
        for (block=0; block<s->mb_height*s->mb_width; block++)
676
9811
            s->macroblocks[block].type = VP56_MB_INTRA;
677
    } else {
678
916
        p->pict_type = AV_PICTURE_TYPE_P;
679
916
        vp56_parse_mb_type_models(s);
680
916
        s->parse_vector_models(s);
681
916
        s->mb_type = VP56_MB_INTER_NOVEC_PF;
682
    }
683
684
960
    if (s->parse_coeff_models(s))
685
        goto next;
686
687
960
    memset(s->prev_dc, 0, sizeof(s->prev_dc));
688
960
    s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
689
960
    s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
690
691
74448
    for (block=0; block < 4*s->mb_width+6; block++) {
692
73488
        s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
693
73488
        s->above_blocks[block].dc_coeff = 0;
694
73488
        s->above_blocks[block].not_null_dc = 0;
695
    }
696
960
    s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
697
960
    s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
698
699
960
    stride_y  = p->linesize[0];
700
960
    stride_uv = p->linesize[1];
701
702
960
    if (s->flip < 0)
703
506
        mb_offset = 7;
704
705
    /* main macroblocks loop */
706
12362
    for (mb_row=0; mb_row<s->mb_height; mb_row++) {
707
11402
        if (s->flip < 0)
708
7179
            mb_row_flip = s->mb_height - mb_row - 1;
709
        else
710
4223
            mb_row_flip = mb_row;
711
712
57010
        for (block=0; block<4; block++) {
713
45608
            s->left_block[block].ref_frame = VP56_FRAME_NONE;
714
45608
            s->left_block[block].dc_coeff = 0;
715
45608
            s->left_block[block].not_null_dc = 0;
716
        }
717
11402
        memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
718
11402
        memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
719
720
11402
        s->above_block_idx[0] = 1;
721
11402
        s->above_block_idx[1] = 2;
722
11402
        s->above_block_idx[2] = 1;
723
11402
        s->above_block_idx[3] = 2;
724
11402
        s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
725
11402
        s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
726
727
11402
        s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
728
11402
        s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
729
11402
        s->block_offset[1] = s->block_offset[0] + 8;
730
11402
        s->block_offset[3] = s->block_offset[2] + 8;
731
11402
        s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
732
11402
        s->block_offset[5] = s->block_offset[4];
733
734
257133
        for (mb_col=0; mb_col<s->mb_width; mb_col++) {
735
245731
            if (!damaged) {
736
245369
                int ret = vp56_decode_mb(s, mb_row, mb_col, is_alpha);
737
245369
                if (ret < 0) {
738
1
                    damaged = 1;
739

1
                    if (!s->have_undamaged_frame || !avctx->error_concealment) {
740
                        s->discard_frame = 1;
741
                        return AVERROR_INVALIDDATA;
742
                    }
743
                }
744
            }
745
245731
            if (damaged)
746
363
                vp56_conceal_mb(s, mb_row, mb_col, is_alpha);
747
748
1228655
            for (y=0; y<4; y++) {
749
982924
                s->above_block_idx[y] += 2;
750
982924
                s->block_offset[y] += 16;
751
            }
752
753
737193
            for (uv=4; uv<6; uv++) {
754
491462
                s->above_block_idx[uv] += 1;
755
491462
                s->block_offset[uv] += 8;
756
            }
757
        }
758
    }
759
760
960
    if (!damaged)
761
959
        s->have_undamaged_frame = 1;
762
763
1
next:
764

960
    if (p->key_frame || s->golden_frame) {
765
77
        av_frame_unref(s->frames[VP56_FRAME_GOLDEN]);
766
77
        if ((res = av_frame_ref(s->frames[VP56_FRAME_GOLDEN], p)) < 0)
767
            return res;
768
    }
769
770
960
    av_frame_unref(s->frames[VP56_FRAME_PREVIOUS]);
771
960
    FFSWAP(AVFrame *, s->frames[VP56_FRAME_CURRENT],
772
                      s->frames[VP56_FRAME_PREVIOUS]);
773
960
    return 0;
774
}
775
776
15
av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
777
{
778
15
    VP56Context *s = avctx->priv_data;
779
15
    return ff_vp56_init_context(avctx, s, flip, has_alpha);
780
}
781
782
19
av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s,
783
                                  int flip, int has_alpha)
784
{
785
    int i;
786
787
19
    s->avctx = avctx;
788
19
    avctx->pix_fmt = has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
789
19
    if (avctx->skip_alpha) avctx->pix_fmt = AV_PIX_FMT_YUV420P;
790
791
19
    ff_h264chroma_init(&s->h264chroma, 8);
792
19
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
793
19
    ff_videodsp_init(&s->vdsp, 8);
794
19
    ff_vp3dsp_init(&s->vp3dsp, avctx->flags);
795
1235
    for (i = 0; i < 64; i++) {
796
#define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))
797
1216
        s->idct_scantable[i] = TRANSPOSE(ff_zigzag_direct[i]);
798
#undef TRANSPOSE
799
    }
800
801
95
    for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
802
76
        s->frames[i] = av_frame_alloc();
803
76
        if (!s->frames[i]) {
804
            ff_vp56_free(avctx);
805
            return AVERROR(ENOMEM);
806
        }
807
    }
808
19
    s->edge_emu_buffer_alloc = NULL;
809
810
19
    s->above_blocks = NULL;
811
19
    s->macroblocks = NULL;
812
19
    s->quantizer = -1;
813
19
    s->deblock_filtering = 1;
814
19
    s->golden_frame = 0;
815
816
19
    s->filter = NULL;
817
818
19
    s->has_alpha = has_alpha;
819
820
19
    s->modelp = &s->model;
821
822
19
    if (flip) {
823
9
        s->flip = -1;
824
9
        s->frbi = 2;
825
9
        s->srbi = 0;
826
    } else {
827
10
        s->flip = 1;
828
10
        s->frbi = 0;
829
10
        s->srbi = 2;
830
    }
831
832
19
    return 0;
833
}
834
835
15
av_cold int ff_vp56_free(AVCodecContext *avctx)
836
{
837
15
    VP56Context *s = avctx->priv_data;
838
15
    return ff_vp56_free_context(s);
839
}
840
841
19
av_cold int ff_vp56_free_context(VP56Context *s)
842
{
843
    int i;
844
845
19
    av_freep(&s->above_blocks);
846
19
    av_freep(&s->macroblocks);
847
19
    av_freep(&s->edge_emu_buffer_alloc);
848
849
95
    for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
850
76
        av_frame_free(&s->frames[i]);
851
852
19
    return 0;
853
}