FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/vp56.c
Date: 2021-09-22 23:55:11
Exec Total Coverage
Lines: 479 516 92.8%
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
2/2
✓ Branch 0 taken 408 times.
✓ Branch 1 taken 552 times.
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
2/2
✓ Branch 0 taken 2277692 times.
✓ Branch 1 taken 161186 times.
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
4/4
✓ Branch 0 taken 2184666 times.
✓ Branch 1 taken 93026 times.
✓ Branch 2 taken 2130422 times.
✓ Branch 3 taken 54244 times.
2277692 if (mvp.x < 0 || mvp.x >= s->mb_width ||
55
3/4
✓ Branch 0 taken 1915032 times.
✓ Branch 1 taken 215390 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1915032 times.
2130422 mvp.y < 0 || mvp.y >= s->mb_height)
56 362660 continue;
57 1915032 offset = mvp.x + s->mb_width*mvp.y;
58
59
2/2
✓ Branch 0 taken 331615 times.
✓ Branch 1 taken 1583417 times.
1915032 if (ff_vp56_reference_frame[s->macroblocks[offset].type] != ref_frame)
60 331615 continue;
61
2/2
✓ Branch 0 taken 1292994 times.
✓ Branch 1 taken 290423 times.
1583417 if ((s->macroblocks[offset].mv.x == vect[0].x &&
62
2/2
✓ Branch 0 taken 75948 times.
✓ Branch 1 taken 1217046 times.
1292994 s->macroblocks[offset].mv.y == vect[0].y) ||
63
2/2
✓ Branch 0 taken 207738 times.
✓ Branch 1 taken 158633 times.
366371 (s->macroblocks[offset].mv.x == 0 &&
64
2/2
✓ Branch 0 taken 177027 times.
✓ Branch 1 taken 30711 times.
207738 s->macroblocks[offset].mv.y == 0))
65 1394073 continue;
66
67 189344 vect[nb_pred++] = s->macroblocks[offset].mv;
68
2/2
✓ Branch 0 taken 77009 times.
✓ Branch 1 taken 112335 times.
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
2/2
✓ Branch 0 taken 2748 times.
✓ Branch 1 taken 916 times.
3664 for (ctx=0; ctx<3; ctx++) {
88
2/2
✓ Branch 1 taken 730 times.
✓ Branch 2 taken 2018 times.
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
2/2
✓ Branch 1 taken 117 times.
✓ Branch 2 taken 2631 times.
2748 if (vp56_rac_get_prob_branchy(c, 254)) {
95
2/2
✓ Branch 0 taken 1170 times.
✓ Branch 1 taken 117 times.
1287 for (type=0; type<10; type++) {
96
2/2
✓ Branch 0 taken 2340 times.
✓ Branch 1 taken 1170 times.
3510 for(i=0; i<2; i++) {
97
2/2
✓ Branch 1 taken 915 times.
✓ Branch 2 taken 1425 times.
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
2/2
✓ Branch 0 taken 139 times.
✓ Branch 1 taken 776 times.
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
2/2
✓ Branch 0 taken 2748 times.
✓ Branch 1 taken 916 times.
3664 for (ctx=0; ctx<3; ctx++) {
113 int p[10];
114
115
2/2
✓ Branch 0 taken 27480 times.
✓ Branch 1 taken 2748 times.
30228 for (type=0; type<10; type++)
116 27480 p[type] = 100 * model->mb_types_stats[ctx][type][1];
117
118
2/2
✓ Branch 0 taken 27480 times.
✓ Branch 1 taken 2748 times.
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
2/2
✓ Branch 1 taken 178882 times.
✓ Branch 2 taken 56676 times.
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
2/2
✓ Branch 0 taken 42048 times.
✓ Branch 1 taken 10512 times.
52560 for (b=0; b<4; b++) {
172 42048 type[b] = vp56_rac_gets(&s->c, 2);
173
2/2
✓ Branch 0 taken 33489 times.
✓ Branch 1 taken 8559 times.
42048 if (type[b])
174 33489 type[b]++; /* only returns 0, 2, 3 or 4 (all INTER_PF) */
175 }
176
177 /* get vectors */
178
2/2
✓ Branch 0 taken 42048 times.
✓ Branch 1 taken 10512 times.
52560 for (b=0; b<4; b++) {
179
4/5
✓ Branch 0 taken 8559 times.
✓ Branch 1 taken 12581 times.
✓ Branch 2 taken 12468 times.
✓ Branch 3 taken 8440 times.
✗ Branch 4 not taken.
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
2/2
✓ Branch 0 taken 4977 times.
✓ Branch 1 taken 5535 times.
10512 s->mv[4].x = s->mv[5].x = RSHIFT(mv.x,2);
202
2/2
✓ Branch 0 taken 4666 times.
✓ Branch 1 taken 5846 times.
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
8/8
✓ Branch 0 taken 36874 times.
✓ Branch 1 taken 11522 times.
✓ Branch 2 taken 1037 times.
✓ Branch 3 taken 160 times.
✓ Branch 4 taken 14426 times.
✓ Branch 5 taken 1440 times.
✓ Branch 6 taken 10512 times.
✓ Branch 7 taken 159587 times.
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
2/2
✓ Branch 0 taken 1350276 times.
✓ Branch 1 taken 225046 times.
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
2/2
✓ Branch 0 taken 2178 times.
✓ Branch 1 taken 363 times.
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
2/2
✓ Branch 0 taken 1474386 times.
✓ Branch 1 taken 245731 times.
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
2/2
✓ Branch 0 taken 1388770 times.
✓ Branch 1 taken 85616 times.
1474386 if (ref_frame == lb->ref_frame) {
294 1388770 dc += lb->dc_coeff;
295 1388770 count++;
296 }
297
2/2
✓ Branch 0 taken 1357234 times.
✓ Branch 1 taken 117152 times.
1474386 if (ref_frame == ab->ref_frame) {
298 1357234 dc += ab->dc_coeff;
299 1357234 count++;
300 }
301
2/2
✓ Branch 0 taken 901056 times.
✓ Branch 1 taken 573330 times.
1474386 if (s->avctx->codec->id == AV_CODEC_ID_VP5)
302
2/2
✓ Branch 0 taken 1802112 times.
✓ Branch 1 taken 901056 times.
2703168 for (i=0; i<2; i++)
303
4/4
✓ Branch 0 taken 107317 times.
✓ Branch 1 taken 1694795 times.
✓ Branch 2 taken 72112 times.
✓ Branch 3 taken 35205 times.
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
2/2
✓ Branch 0 taken 18280 times.
✓ Branch 1 taken 1456106 times.
1474386 if (count == 0)
308 18280 dc = s->prev_dc[ff_vp56_b2p[b]][ref_frame];
309
2/2
✓ Branch 0 taken 1362010 times.
✓ Branch 1 taken 94096 times.
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
2/2
✓ Branch 0 taken 249618 times.
✓ Branch 1 taken 173620 times.
423238 if (s->avctx->codec->id == AV_CODEC_ID_VP5) {
326 249618 int t = ff_vp56_filter_threshold[s->quantizer];
327
2/2
✓ Branch 0 taken 84139 times.
✓ Branch 1 taken 165479 times.
249618 if (dx) s->vp56dsp.edge_filter_hor(yuv + 10-dx , stride, t);
328
2/2
✓ Branch 0 taken 25724 times.
✓ Branch 1 taken 223894 times.
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
2/2
✓ Branch 0 taken 66268 times.
✓ Branch 1 taken 107352 times.
173620 if (dx)
332 66268 ff_vp3dsp_h_loop_filter_12(yuv + 10-dx, stride, bounding_values);
333
2/2
✓ Branch 0 taken 63282 times.
✓ Branch 1 taken 110338 times.
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
1/2
✓ Branch 0 taken 443512 times.
✗ Branch 1 not taken.
443512 if (s->avctx->skip_loop_filter >= AVDISCARD_ALL ||
351
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 443512 times.
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
2/2
✓ Branch 0 taken 139632 times.
✓ Branch 1 taken 303880 times.
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
6/6
✓ Branch 0 taken 436046 times.
✓ Branch 1 taken 7466 times.
✓ Branch 2 taken 422639 times.
✓ Branch 3 taken 13407 times.
✓ Branch 4 taken 413084 times.
✓ Branch 5 taken 9555 times.
443512 if (x<0 || x+12>=s->plane_width[plane] ||
366
2/2
✓ Branch 0 taken 19408 times.
✓ Branch 1 taken 393676 times.
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
2/2
✓ Branch 0 taken 375220 times.
✓ Branch 1 taken 18456 times.
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
2/2
✓ Branch 0 taken 423238 times.
✓ Branch 1 taken 20274 times.
443512 if (deblock_filtering)
389 423238 vp56_deblock_filter(s, src_block, stride, dx&7, dy&7);
390
391
2/2
✓ Branch 0 taken 282743 times.
✓ Branch 1 taken 160769 times.
443512 if (s->mv[b].x & mask)
392
2/2
✓ Branch 0 taken 158355 times.
✓ Branch 1 taken 124388 times.
282743 overlap_offset += (s->mv[b].x > 0) ? 1 : -1;
393
2/2
✓ Branch 0 taken 277774 times.
✓ Branch 1 taken 165738 times.
443512 if (s->mv[b].y & mask)
394
2/2
✓ Branch 0 taken 125656 times.
✓ Branch 1 taken 152118 times.
277774 overlap_offset += (s->mv[b].y > 0) ? stride : -stride;
395
396
2/2
✓ Branch 0 taken 387371 times.
✓ Branch 1 taken 56141 times.
443512 if (overlap_offset) {
397
2/2
✓ Branch 0 taken 171252 times.
✓ Branch 1 taken 216119 times.
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
3/4
✓ Branch 0 taken 34944 times.
✓ Branch 1 taken 162720 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 34944 times.
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
2/2
✓ Branch 0 taken 865208 times.
✓ Branch 1 taken 369106 times.
1234314 if (selector > 10)
420 865208 s->vp3dsp.idct_add(dest, stride, block);
421
1/2
✓ Branch 0 taken 369106 times.
✗ Branch 1 not taken.
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
3/4
✓ Branch 0 taken 212219 times.
✓ Branch 1 taken 33512 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 212219 times.
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
3/4
✓ Branch 0 taken 33512 times.
✓ Branch 1 taken 136249 times.
✓ Branch 2 taken 75970 times.
✗ Branch 3 not taken.
245731 switch (mb_type) {
444 33512 case VP56_MB_INTRA:
445
2/2
✓ Branch 0 taken 197664 times.
✓ Branch 1 taken 33512 times.
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
2/2
✓ Branch 0 taken 790802 times.
✓ Branch 1 taken 136249 times.
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
2/2
✓ Branch 0 taken 443512 times.
✓ Branch 1 taken 75970 times.
519482 for (b=0; b<b_max; b++) {
473
4/4
✓ Branch 0 taken 367542 times.
✓ Branch 1 taken 75970 times.
✓ Branch 2 taken 75970 times.
✓ Branch 3 taken 291572 times.
443512 int x_off = b==1 || b==3 ? 8 : 0;
474
4/4
✓ Branch 0 taken 367542 times.
✓ Branch 1 taken 75970 times.
✓ Branch 2 taken 75970 times.
✓ Branch 3 taken 291572 times.
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
2/2
✓ Branch 0 taken 21204 times.
✓ Branch 1 taken 224527 times.
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
2/2
✓ Branch 0 taken 9811 times.
✓ Branch 1 taken 235558 times.
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
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 245368 times.
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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 363 times.
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
2/2
✓ Branch 0 taken 56 times.
✓ Branch 1 taken 14 times.
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
2/4
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14 times.
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
3/6
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14 times.
14 if (!s->above_blocks || !s->macroblocks || !s->edge_emu_buffer_alloc)
556 return AVERROR(ENOMEM);
557
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 6 times.
14 if (s->flip < 0)
558 8 s->edge_emu_buffer += 15 * stride;
559
560
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 12 times.
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
2/2
✓ Branch 0 taken 186 times.
✓ Branch 1 taken 681 times.
867 if (s->has_alpha) {
580
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 186 times.
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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 186 times.
186 if (remaining_buf_size < alpha_offset)
585 return AVERROR_INVALIDDATA;
586 }
587
588 867 res = s->parse_header(s, buf, alpha_offset);
589
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 867 times.
867 if (res < 0)
590 return res;
591
592
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 855 times.
867 if (res == VP56_SIZE_CHANGE) {
593
2/2
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 12 times.
60 for (i = 0; i < 4; i++) {
594 48 av_frame_unref(s->frames[i]);
595
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 40 times.
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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 867 times.
867 if (ret < 0) {
602 if (res == VP56_SIZE_CHANGE)
603 ff_set_dimensions(avctx, 0, 0);
604 return ret;
605 }
606
607
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 774 times.
867 if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
608 93 av_frame_unref(s->alpha_context->frames[VP56_FRAME_CURRENT]);
609
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 93 times.
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
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 855 times.
867 if (res == VP56_SIZE_CHANGE) {
618
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
12 if (vp56_size_changed(s)) {
619 av_frame_unref(p);
620 return AVERROR_INVALIDDATA;
621 }
622 }
623
624
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 774 times.
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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
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
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 774 times.
867 avctx->execute2(avctx, ff_vp56_decode_mbs, 0, 0, (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) + 1);
648
649
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 867 times.
867 if (s->discard_frame)
650 return AVERROR_INVALIDDATA;
651
652
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 867 times.
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
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 867 times.
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
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 916 times.
960 if (p->key_frame) {
673 44 p->pict_type = AV_PICTURE_TYPE_I;
674 44 s->default_models_init(s);
675
2/2
✓ Branch 0 taken 9811 times.
✓ Branch 1 taken 44 times.
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
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 960 times.
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
2/2
✓ Branch 0 taken 73488 times.
✓ Branch 1 taken 960 times.
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
2/2
✓ Branch 0 taken 506 times.
✓ Branch 1 taken 454 times.
960 if (s->flip < 0)
703 506 mb_offset = 7;
704
705 /* main macroblocks loop */
706
2/2
✓ Branch 0 taken 11402 times.
✓ Branch 1 taken 960 times.
12362 for (mb_row=0; mb_row<s->mb_height; mb_row++) {
707
2/2
✓ Branch 0 taken 7179 times.
✓ Branch 1 taken 4223 times.
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
2/2
✓ Branch 0 taken 45608 times.
✓ Branch 1 taken 11402 times.
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
2/2
✓ Branch 0 taken 245731 times.
✓ Branch 1 taken 11402 times.
257133 for (mb_col=0; mb_col<s->mb_width; mb_col++) {
735
2/2
✓ Branch 0 taken 245369 times.
✓ Branch 1 taken 362 times.
245731 if (!damaged) {
736 245369 int ret = vp56_decode_mb(s, mb_row, mb_col, is_alpha);
737
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 245368 times.
245369 if (ret < 0) {
738 1 damaged = 1;
739
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
1 if (!s->have_undamaged_frame || !avctx->error_concealment) {
740 s->discard_frame = 1;
741 return AVERROR_INVALIDDATA;
742 }
743 }
744 }
745
2/2
✓ Branch 0 taken 363 times.
✓ Branch 1 taken 245368 times.
245731 if (damaged)
746 363 vp56_conceal_mb(s, mb_row, mb_col, is_alpha);
747
748
2/2
✓ Branch 0 taken 982924 times.
✓ Branch 1 taken 245731 times.
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
2/2
✓ Branch 0 taken 491462 times.
✓ Branch 1 taken 245731 times.
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
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 959 times.
960 if (!damaged)
761 959 s->have_undamaged_frame = 1;
762
763 1 next:
764
4/4
✓ Branch 0 taken 916 times.
✓ Branch 1 taken 44 times.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 883 times.
960 if (p->key_frame || s->golden_frame) {
765 77 av_frame_unref(s->frames[VP56_FRAME_GOLDEN]);
766
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 77 times.
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
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 11 times.
19 avctx->pix_fmt = has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
789
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 15 times.
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
2/2
✓ Branch 0 taken 1216 times.
✓ Branch 1 taken 19 times.
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
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 19 times.
95 for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
802 76 s->frames[i] = av_frame_alloc();
803
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
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
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 10 times.
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
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 19 times.
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 }
854