FFmpeg
error_resilience.c
Go to the documentation of this file.
1 /*
2  * Error resilience / concealment
3  *
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Error resilience / concealment.
26  */
27 
28 #include <limits.h>
29 
30 #include "libavutil/internal.h"
31 #include "avcodec.h"
32 #include "error_resilience.h"
33 #include "me_cmp.h"
34 #include "mpegutils.h"
35 #include "mpegvideo.h"
36 #include "rectangle.h"
37 #include "threadframe.h"
38 
39 /**
40  * @param stride the number of MVs to get to the next row
41  * @param mv_step the number of MVs per row or column in a macroblock
42  */
43 static void set_mv_strides(ERContext *s, ptrdiff_t *mv_step, ptrdiff_t *stride)
44 {
45  if (s->avctx->codec_id == AV_CODEC_ID_H264) {
46  av_assert0(s->quarter_sample);
47  *mv_step = 4;
48  *stride = s->mb_width * 4;
49  } else {
50  *mv_step = 2;
51  *stride = s->b8_stride;
52  }
53 }
54 
55 /**
56  * Replace the current MB with a flat dc-only version.
57  */
58 static void put_dc(ERContext *s, uint8_t *dest_y, uint8_t *dest_cb,
59  uint8_t *dest_cr, int mb_x, int mb_y)
60 {
61  int *linesize = s->cur_pic.f->linesize;
62  int dc, dcu, dcv, y, i;
63  for (i = 0; i < 4; i++) {
64  dc = s->dc_val[0][mb_x * 2 + (i & 1) + (mb_y * 2 + (i >> 1)) * s->b8_stride];
65  if (dc < 0)
66  dc = 0;
67  else if (dc > 2040)
68  dc = 2040;
69  for (y = 0; y < 8; y++) {
70  int x;
71  for (x = 0; x < 8; x++)
72  dest_y[x + (i & 1) * 8 + (y + (i >> 1) * 8) * linesize[0]] = dc / 8;
73  }
74  }
75  dcu = s->dc_val[1][mb_x + mb_y * s->mb_stride];
76  dcv = s->dc_val[2][mb_x + mb_y * s->mb_stride];
77  if (dcu < 0)
78  dcu = 0;
79  else if (dcu > 2040)
80  dcu = 2040;
81  if (dcv < 0)
82  dcv = 0;
83  else if (dcv > 2040)
84  dcv = 2040;
85 
86  if (dest_cr)
87  for (y = 0; y < 8; y++) {
88  int x;
89  for (x = 0; x < 8; x++) {
90  dest_cb[x + y * linesize[1]] = dcu / 8;
91  dest_cr[x + y * linesize[2]] = dcv / 8;
92  }
93  }
94 }
95 
96 static void filter181(int16_t *data, int width, int height, ptrdiff_t stride)
97 {
98  int x, y;
99 
100  /* horizontal filter */
101  for (y = 1; y < height - 1; y++) {
102  int prev_dc = data[0 + y * stride];
103 
104  for (x = 1; x < width - 1; x++) {
105  int dc;
106  dc = -prev_dc +
107  data[x + y * stride] * 8 -
108  data[x + 1 + y * stride];
109  dc = (av_clip(dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16;
110  prev_dc = data[x + y * stride];
111  data[x + y * stride] = dc;
112  }
113  }
114 
115  /* vertical filter */
116  for (x = 1; x < width - 1; x++) {
117  int prev_dc = data[x];
118 
119  for (y = 1; y < height - 1; y++) {
120  int dc;
121 
122  dc = -prev_dc +
123  data[x + y * stride] * 8 -
124  data[x + (y + 1) * stride];
125  dc = (av_clip(dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16;
126  prev_dc = data[x + y * stride];
127  data[x + y * stride] = dc;
128  }
129  }
130 }
131 
132 /**
133  * guess the dc of blocks which do not have an undamaged dc
134  * @param w width in 8 pixel blocks
135  * @param h height in 8 pixel blocks
136  */
137 static void guess_dc(ERContext *s, int16_t *dc, int w,
138  int h, ptrdiff_t stride, int is_luma)
139 {
140  int b_x, b_y;
141  int16_t (*col )[4] = av_malloc_array(stride, h*sizeof( int16_t)*4);
142  uint32_t (*dist)[4] = av_malloc_array(stride, h*sizeof(uint32_t)*4);
143 
144  if(!col || !dist) {
145  av_log(s->avctx, AV_LOG_ERROR, "guess_dc() is out of memory\n");
146  goto fail;
147  }
148 
149  for(b_y=0; b_y<h; b_y++){
150  int color= 1024;
151  int distance= -1;
152  for(b_x=0; b_x<w; b_x++){
153  int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
154  int error_j= s->error_status_table[mb_index_j];
155  int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
156  if(intra_j==0 || !(error_j&ER_DC_ERROR)){
157  color= dc[b_x + b_y*stride];
158  distance= b_x;
159  }
160  col [b_x + b_y*stride][1]= color;
161  dist[b_x + b_y*stride][1]= distance >= 0 ? b_x-distance : 9999;
162  }
163  color= 1024;
164  distance= -1;
165  for(b_x=w-1; b_x>=0; b_x--){
166  int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
167  int error_j= s->error_status_table[mb_index_j];
168  int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
169  if(intra_j==0 || !(error_j&ER_DC_ERROR)){
170  color= dc[b_x + b_y*stride];
171  distance= b_x;
172  }
173  col [b_x + b_y*stride][0]= color;
174  dist[b_x + b_y*stride][0]= distance >= 0 ? distance-b_x : 9999;
175  }
176  }
177  for(b_x=0; b_x<w; b_x++){
178  int color= 1024;
179  int distance= -1;
180  for(b_y=0; b_y<h; b_y++){
181  int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
182  int error_j= s->error_status_table[mb_index_j];
183  int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
184  if(intra_j==0 || !(error_j&ER_DC_ERROR)){
185  color= dc[b_x + b_y*stride];
186  distance= b_y;
187  }
188  col [b_x + b_y*stride][3]= color;
189  dist[b_x + b_y*stride][3]= distance >= 0 ? b_y-distance : 9999;
190  }
191  color= 1024;
192  distance= -1;
193  for(b_y=h-1; b_y>=0; b_y--){
194  int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
195  int error_j= s->error_status_table[mb_index_j];
196  int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
197  if(intra_j==0 || !(error_j&ER_DC_ERROR)){
198  color= dc[b_x + b_y*stride];
199  distance= b_y;
200  }
201  col [b_x + b_y*stride][2]= color;
202  dist[b_x + b_y*stride][2]= distance >= 0 ? distance-b_y : 9999;
203  }
204  }
205 
206  for (b_y = 0; b_y < h; b_y++) {
207  for (b_x = 0; b_x < w; b_x++) {
208  int mb_index, error, j;
209  int64_t guess, weight_sum;
210  mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride;
211  error = s->error_status_table[mb_index];
212 
213  if (IS_INTER(s->cur_pic.mb_type[mb_index]))
214  continue; // inter
215  if (!(error & ER_DC_ERROR))
216  continue; // dc-ok
217 
218  weight_sum = 0;
219  guess = 0;
220  for (j = 0; j < 4; j++) {
221  int64_t weight = 256 * 256 * 256 * 16 / FFMAX(dist[b_x + b_y*stride][j], 1);
222  guess += weight*(int64_t)col[b_x + b_y*stride][j];
223  weight_sum += weight;
224  }
225  guess = (guess + weight_sum / 2) / weight_sum;
226  dc[b_x + b_y * stride] = guess;
227  }
228  }
229 
230 fail:
231  av_freep(&col);
232  av_freep(&dist);
233 }
234 
235 /**
236  * simple horizontal deblocking filter used for error resilience
237  * @param w width in 8 pixel blocks
238  * @param h height in 8 pixel blocks
239  */
240 static void h_block_filter(ERContext *s, uint8_t *dst, int w,
241  int h, ptrdiff_t stride, int is_luma)
242 {
243  int b_x, b_y;
244  ptrdiff_t mvx_stride, mvy_stride;
245  const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
246  set_mv_strides(s, &mvx_stride, &mvy_stride);
247  mvx_stride >>= is_luma;
248  mvy_stride *= mvx_stride;
249 
250  for (b_y = 0; b_y < h; b_y++) {
251  for (b_x = 0; b_x < w - 1; b_x++) {
252  int y;
253  int left_status = s->error_status_table[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride];
254  int right_status = s->error_status_table[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride];
255  int left_intra = IS_INTRA(s->cur_pic.mb_type[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]);
256  int right_intra = IS_INTRA(s->cur_pic.mb_type[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]);
257  int left_damage = left_status & ER_MB_ERROR;
258  int right_damage = right_status & ER_MB_ERROR;
259  int offset = b_x * 8 + b_y * stride * 8;
260  int16_t *left_mv = s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * b_x];
261  int16_t *right_mv = s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)];
262  if (!(left_damage || right_damage))
263  continue; // both undamaged
264  if ((!left_intra) && (!right_intra) &&
265  FFABS(left_mv[0] - right_mv[0]) +
266  FFABS(left_mv[1] + right_mv[1]) < 2)
267  continue;
268 
269  for (y = 0; y < 8; y++) {
270  int a, b, c, d;
271 
272  a = dst[offset + 7 + y * stride] - dst[offset + 6 + y * stride];
273  b = dst[offset + 8 + y * stride] - dst[offset + 7 + y * stride];
274  c = dst[offset + 9 + y * stride] - dst[offset + 8 + y * stride];
275 
276  d = FFABS(b) - ((FFABS(a) + FFABS(c) + 1) >> 1);
277  d = FFMAX(d, 0);
278  if (b < 0)
279  d = -d;
280 
281  if (d == 0)
282  continue;
283 
284  if (!(left_damage && right_damage))
285  d = d * 16 / 9;
286 
287  if (left_damage) {
288  dst[offset + 7 + y * stride] = cm[dst[offset + 7 + y * stride] + ((d * 7) >> 4)];
289  dst[offset + 6 + y * stride] = cm[dst[offset + 6 + y * stride] + ((d * 5) >> 4)];
290  dst[offset + 5 + y * stride] = cm[dst[offset + 5 + y * stride] + ((d * 3) >> 4)];
291  dst[offset + 4 + y * stride] = cm[dst[offset + 4 + y * stride] + ((d * 1) >> 4)];
292  }
293  if (right_damage) {
294  dst[offset + 8 + y * stride] = cm[dst[offset + 8 + y * stride] - ((d * 7) >> 4)];
295  dst[offset + 9 + y * stride] = cm[dst[offset + 9 + y * stride] - ((d * 5) >> 4)];
296  dst[offset + 10+ y * stride] = cm[dst[offset + 10 + y * stride] - ((d * 3) >> 4)];
297  dst[offset + 11+ y * stride] = cm[dst[offset + 11 + y * stride] - ((d * 1) >> 4)];
298  }
299  }
300  }
301  }
302 }
303 
304 /**
305  * simple vertical deblocking filter used for error resilience
306  * @param w width in 8 pixel blocks
307  * @param h height in 8 pixel blocks
308  */
309 static void v_block_filter(ERContext *s, uint8_t *dst, int w, int h,
310  ptrdiff_t stride, int is_luma)
311 {
312  int b_x, b_y;
313  ptrdiff_t mvx_stride, mvy_stride;
314  const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
315  set_mv_strides(s, &mvx_stride, &mvy_stride);
316  mvx_stride >>= is_luma;
317  mvy_stride *= mvx_stride;
318 
319  for (b_y = 0; b_y < h - 1; b_y++) {
320  for (b_x = 0; b_x < w; b_x++) {
321  int x;
322  int top_status = s->error_status_table[(b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride];
323  int bottom_status = s->error_status_table[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride];
324  int top_intra = IS_INTRA(s->cur_pic.mb_type[(b_x >> is_luma) + ( b_y >> is_luma) * s->mb_stride]);
325  int bottom_intra = IS_INTRA(s->cur_pic.mb_type[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]);
326  int top_damage = top_status & ER_MB_ERROR;
327  int bottom_damage = bottom_status & ER_MB_ERROR;
328  int offset = b_x * 8 + b_y * stride * 8;
329 
330  int16_t *top_mv = s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * b_x];
331  int16_t *bottom_mv = s->cur_pic.motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x];
332 
333  if (!(top_damage || bottom_damage))
334  continue; // both undamaged
335 
336  if ((!top_intra) && (!bottom_intra) &&
337  FFABS(top_mv[0] - bottom_mv[0]) +
338  FFABS(top_mv[1] + bottom_mv[1]) < 2)
339  continue;
340 
341  for (x = 0; x < 8; x++) {
342  int a, b, c, d;
343 
344  a = dst[offset + x + 7 * stride] - dst[offset + x + 6 * stride];
345  b = dst[offset + x + 8 * stride] - dst[offset + x + 7 * stride];
346  c = dst[offset + x + 9 * stride] - dst[offset + x + 8 * stride];
347 
348  d = FFABS(b) - ((FFABS(a) + FFABS(c) + 1) >> 1);
349  d = FFMAX(d, 0);
350  if (b < 0)
351  d = -d;
352 
353  if (d == 0)
354  continue;
355 
356  if (!(top_damage && bottom_damage))
357  d = d * 16 / 9;
358 
359  if (top_damage) {
360  dst[offset + x + 7 * stride] = cm[dst[offset + x + 7 * stride] + ((d * 7) >> 4)];
361  dst[offset + x + 6 * stride] = cm[dst[offset + x + 6 * stride] + ((d * 5) >> 4)];
362  dst[offset + x + 5 * stride] = cm[dst[offset + x + 5 * stride] + ((d * 3) >> 4)];
363  dst[offset + x + 4 * stride] = cm[dst[offset + x + 4 * stride] + ((d * 1) >> 4)];
364  }
365  if (bottom_damage) {
366  dst[offset + x + 8 * stride] = cm[dst[offset + x + 8 * stride] - ((d * 7) >> 4)];
367  dst[offset + x + 9 * stride] = cm[dst[offset + x + 9 * stride] - ((d * 5) >> 4)];
368  dst[offset + x + 10 * stride] = cm[dst[offset + x + 10 * stride] - ((d * 3) >> 4)];
369  dst[offset + x + 11 * stride] = cm[dst[offset + x + 11 * stride] - ((d * 1) >> 4)];
370  }
371  }
372  }
373  }
374 }
375 
376 #define MV_FROZEN 8
377 #define MV_CHANGED 4
378 #define MV_UNCHANGED 2
379 #define MV_LISTED 1
380 static av_always_inline void add_blocklist(int (*blocklist)[2], int *blocklist_length, uint8_t *fixed, int mb_x, int mb_y, int mb_xy)
381 {
382  if (fixed[mb_xy])
383  return;
384  fixed[mb_xy] = MV_LISTED;
385  blocklist[ *blocklist_length ][0] = mb_x;
386  blocklist[(*blocklist_length)++][1] = mb_y;
387 }
388 
389 static void guess_mv(ERContext *s)
390 {
391  int (*blocklist)[2], (*next_blocklist)[2];
392  uint8_t *fixed;
393  const ptrdiff_t mb_stride = s->mb_stride;
394  const int mb_width = s->mb_width;
395  int mb_height = s->mb_height;
396  int i, depth, num_avail;
397  int mb_x, mb_y;
398  ptrdiff_t mot_step, mot_stride;
399  int blocklist_length, next_blocklist_length;
400 
401  if (s->last_pic.f && s->last_pic.f->data[0])
402  mb_height = FFMIN(mb_height, (s->last_pic.f->height+15)>>4);
403  if (s->next_pic.f && s->next_pic.f->data[0])
404  mb_height = FFMIN(mb_height, (s->next_pic.f->height+15)>>4);
405 
406  blocklist = (int (*)[2])s->er_temp_buffer;
407  next_blocklist = blocklist + s->mb_stride * s->mb_height;
408  fixed = (uint8_t *)(next_blocklist + s->mb_stride * s->mb_height);
409 
410  set_mv_strides(s, &mot_step, &mot_stride);
411 
412  num_avail = 0;
413  if (s->last_pic.motion_val[0])
414  ff_thread_await_progress(s->last_pic.tf, mb_height-1, 0);
415  for (i = 0; i < mb_width * mb_height; i++) {
416  const int mb_xy = s->mb_index2xy[i];
417  int f = 0;
418  int error = s->error_status_table[mb_xy];
419 
420  if (IS_INTRA(s->cur_pic.mb_type[mb_xy]))
421  f = MV_FROZEN; // intra // FIXME check
422  if (!(error & ER_MV_ERROR))
423  f = MV_FROZEN; // inter with undamaged MV
424 
425  fixed[mb_xy] = f;
426  if (f == MV_FROZEN)
427  num_avail++;
428  else if(s->last_pic.f->data[0] && s->last_pic.motion_val[0]){
429  const int mb_y= mb_xy / s->mb_stride;
430  const int mb_x= mb_xy % s->mb_stride;
431  const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
432  s->cur_pic.motion_val[0][mot_index][0]= s->last_pic.motion_val[0][mot_index][0];
433  s->cur_pic.motion_val[0][mot_index][1]= s->last_pic.motion_val[0][mot_index][1];
434  s->cur_pic.ref_index[0][4*mb_xy] = s->last_pic.ref_index[0][4*mb_xy];
435  }
436  }
437 
438  if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) ||
439  num_avail <= FFMAX(mb_width, mb_height) / 2) {
440  for (mb_y = 0; mb_y < mb_height; mb_y++) {
441  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
442  const int mb_xy = mb_x + mb_y * s->mb_stride;
443  int mv_dir = (s->last_pic.f && s->last_pic.f->data[0]) ? MV_DIR_FORWARD : MV_DIR_BACKWARD;
444 
445  if (IS_INTRA(s->cur_pic.mb_type[mb_xy]))
446  continue;
447  if (!(s->error_status_table[mb_xy] & ER_MV_ERROR))
448  continue;
449 
450  s->mv[0][0][0] = 0;
451  s->mv[0][0][1] = 0;
452  s->decode_mb(s->opaque, 0, mv_dir, MV_TYPE_16X16, &s->mv,
453  mb_x, mb_y, 0, 0);
454  }
455  }
456  return;
457  }
458 
459  blocklist_length = 0;
460  for (mb_y = 0; mb_y < mb_height; mb_y++) {
461  for (mb_x = 0; mb_x < mb_width; mb_x++) {
462  const int mb_xy = mb_x + mb_y * mb_stride;
463  if (fixed[mb_xy] == MV_FROZEN) {
464  if (mb_x) add_blocklist(blocklist, &blocklist_length, fixed, mb_x - 1, mb_y, mb_xy - 1);
465  if (mb_y) add_blocklist(blocklist, &blocklist_length, fixed, mb_x, mb_y - 1, mb_xy - mb_stride);
466  if (mb_x+1 < mb_width) add_blocklist(blocklist, &blocklist_length, fixed, mb_x + 1, mb_y, mb_xy + 1);
467  if (mb_y+1 < mb_height) add_blocklist(blocklist, &blocklist_length, fixed, mb_x, mb_y + 1, mb_xy + mb_stride);
468  }
469  }
470  }
471 
472  for (depth = 0; ; depth++) {
473  int changed, pass, none_left;
474  int blocklist_index;
475 
476  none_left = 1;
477  changed = 1;
478  for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {
479  changed = 0;
480  for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) {
481  const int mb_x = blocklist[blocklist_index][0];
482  const int mb_y = blocklist[blocklist_index][1];
483  const int mb_xy = mb_x + mb_y * mb_stride;
484  int mv_predictor[8][2];
485  int ref[8];
486  int pred_count;
487  int j;
488  int best_score;
489  int best_pred;
490  int mot_index;
491  int prev_x, prev_y, prev_ref;
492 
493  if ((mb_x ^ mb_y ^ pass) & 1)
494  continue;
495  av_assert2(fixed[mb_xy] != MV_FROZEN);
496 
497 
498  av_assert1(!IS_INTRA(s->cur_pic.mb_type[mb_xy]));
499  av_assert1(s->last_pic.f && s->last_pic.f->data[0]);
500 
501  j = 0;
502  if (mb_x > 0)
503  j |= fixed[mb_xy - 1];
504  if (mb_x + 1 < mb_width)
505  j |= fixed[mb_xy + 1];
506  if (mb_y > 0)
507  j |= fixed[mb_xy - mb_stride];
508  if (mb_y + 1 < mb_height)
509  j |= fixed[mb_xy + mb_stride];
510 
511  av_assert2(j & MV_FROZEN);
512 
513  if (!(j & MV_CHANGED) && pass > 1)
514  continue;
515 
516  none_left = 0;
517  pred_count = 0;
518  mot_index = (mb_x + mb_y * mot_stride) * mot_step;
519 
520  if (mb_x > 0 && fixed[mb_xy - 1] > 1) {
521  mv_predictor[pred_count][0] =
522  s->cur_pic.motion_val[0][mot_index - mot_step][0];
523  mv_predictor[pred_count][1] =
524  s->cur_pic.motion_val[0][mot_index - mot_step][1];
525  ref[pred_count] =
526  s->cur_pic.ref_index[0][4 * (mb_xy - 1)];
527  pred_count++;
528  }
529  if (mb_x + 1 < mb_width && fixed[mb_xy + 1] > 1) {
530  mv_predictor[pred_count][0] =
531  s->cur_pic.motion_val[0][mot_index + mot_step][0];
532  mv_predictor[pred_count][1] =
533  s->cur_pic.motion_val[0][mot_index + mot_step][1];
534  ref[pred_count] =
535  s->cur_pic.ref_index[0][4 * (mb_xy + 1)];
536  pred_count++;
537  }
538  if (mb_y > 0 && fixed[mb_xy - mb_stride] > 1) {
539  mv_predictor[pred_count][0] =
540  s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][0];
541  mv_predictor[pred_count][1] =
542  s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][1];
543  ref[pred_count] =
544  s->cur_pic.ref_index[0][4 * (mb_xy - s->mb_stride)];
545  pred_count++;
546  }
547  if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride] > 1) {
548  mv_predictor[pred_count][0] =
549  s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][0];
550  mv_predictor[pred_count][1] =
551  s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][1];
552  ref[pred_count] =
553  s->cur_pic.ref_index[0][4 * (mb_xy + s->mb_stride)];
554  pred_count++;
555  }
556  if (pred_count == 0)
557  continue;
558 
559  if (pred_count > 1) {
560  int sum_x = 0, sum_y = 0, sum_r = 0;
561  int max_x, max_y, min_x, min_y, max_r, min_r;
562 
563  for (j = 0; j < pred_count; j++) {
564  sum_x += mv_predictor[j][0];
565  sum_y += mv_predictor[j][1];
566  sum_r += ref[j];
567  if (j && ref[j] != ref[j - 1])
568  goto skip_mean_and_median;
569  }
570 
571  /* mean */
572  mv_predictor[pred_count][0] = sum_x / j;
573  mv_predictor[pred_count][1] = sum_y / j;
574  ref[pred_count] = sum_r / j;
575 
576  /* median */
577  if (pred_count >= 3) {
578  min_y = min_x = min_r = 99999;
579  max_y = max_x = max_r = -99999;
580  } else {
581  min_x = min_y = max_x = max_y = min_r = max_r = 0;
582  }
583  for (j = 0; j < pred_count; j++) {
584  max_x = FFMAX(max_x, mv_predictor[j][0]);
585  max_y = FFMAX(max_y, mv_predictor[j][1]);
586  max_r = FFMAX(max_r, ref[j]);
587  min_x = FFMIN(min_x, mv_predictor[j][0]);
588  min_y = FFMIN(min_y, mv_predictor[j][1]);
589  min_r = FFMIN(min_r, ref[j]);
590  }
591  mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;
592  mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;
593  ref[pred_count + 1] = sum_r - max_r - min_r;
594 
595  if (pred_count == 4) {
596  mv_predictor[pred_count + 1][0] /= 2;
597  mv_predictor[pred_count + 1][1] /= 2;
598  ref[pred_count + 1] /= 2;
599  }
600  pred_count += 2;
601  }
602 
603 skip_mean_and_median:
604  /* zero MV */
605  mv_predictor[pred_count][0] =
606  mv_predictor[pred_count][1] =
607  ref[pred_count] = 0;
608  pred_count++;
609 
610  prev_x = s->cur_pic.motion_val[0][mot_index][0];
611  prev_y = s->cur_pic.motion_val[0][mot_index][1];
612  prev_ref = s->cur_pic.ref_index[0][4 * mb_xy];
613 
614  /* last MV */
615  mv_predictor[pred_count][0] = prev_x;
616  mv_predictor[pred_count][1] = prev_y;
617  ref[pred_count] = prev_ref;
618  pred_count++;
619 
620  best_pred = 0;
621  best_score = 256 * 256 * 256 * 64;
622  for (j = 0; j < pred_count; j++) {
623  int *linesize = s->cur_pic.f->linesize;
624  int score = 0;
625  uint8_t *src = s->cur_pic.f->data[0] +
626  mb_x * 16 + mb_y * 16 * linesize[0];
627 
628  s->cur_pic.motion_val[0][mot_index][0] =
629  s->mv[0][0][0] = mv_predictor[j][0];
630  s->cur_pic.motion_val[0][mot_index][1] =
631  s->mv[0][0][1] = mv_predictor[j][1];
632 
633  // predictor intra or otherwise not available
634  if (ref[j] < 0)
635  continue;
636 
637  s->decode_mb(s->opaque, ref[j], MV_DIR_FORWARD,
638  MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0);
639 
640  if (mb_x > 0 && fixed[mb_xy - 1] > 1) {
641  int k;
642  for (k = 0; k < 16; k++)
643  score += FFABS(src[k * linesize[0] - 1] -
644  src[k * linesize[0]]);
645  }
646  if (mb_x + 1 < mb_width && fixed[mb_xy + 1] > 1) {
647  int k;
648  for (k = 0; k < 16; k++)
649  score += FFABS(src[k * linesize[0] + 15] -
650  src[k * linesize[0] + 16]);
651  }
652  if (mb_y > 0 && fixed[mb_xy - mb_stride] > 1) {
653  int k;
654  for (k = 0; k < 16; k++)
655  score += FFABS(src[k - linesize[0]] - src[k]);
656  }
657  if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] > 1) {
658  int k;
659  for (k = 0; k < 16; k++)
660  score += FFABS(src[k + linesize[0] * 15] -
661  src[k + linesize[0] * 16]);
662  }
663 
664  if (score <= best_score) { // <= will favor the last MV
665  best_score = score;
666  best_pred = j;
667  }
668  }
669  s->mv[0][0][0] = mv_predictor[best_pred][0];
670  s->mv[0][0][1] = mv_predictor[best_pred][1];
671 
672  for (i = 0; i < mot_step; i++)
673  for (j = 0; j < mot_step; j++) {
674  s->cur_pic.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0];
675  s->cur_pic.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1];
676  }
677 
678  s->decode_mb(s->opaque, ref[best_pred], MV_DIR_FORWARD,
679  MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0);
680 
681 
682  if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) {
683  fixed[mb_xy] = MV_CHANGED;
684  changed++;
685  } else
686  fixed[mb_xy] = MV_UNCHANGED;
687  }
688  }
689 
690  if (none_left)
691  return;
692 
693  next_blocklist_length = 0;
694 
695  for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) {
696  const int mb_x = blocklist[blocklist_index][0];
697  const int mb_y = blocklist[blocklist_index][1];
698  const int mb_xy = mb_x + mb_y * mb_stride;
699 
700  if (fixed[mb_xy] & (MV_CHANGED|MV_UNCHANGED|MV_FROZEN)) {
701  fixed[mb_xy] = MV_FROZEN;
702  if (mb_x > 0)
703  add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x - 1, mb_y, mb_xy - 1);
704  if (mb_y > 0)
705  add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x, mb_y - 1, mb_xy - mb_stride);
706  if (mb_x + 1 < mb_width)
707  add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x + 1, mb_y, mb_xy + 1);
708  if (mb_y + 1 < mb_height)
709  add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x, mb_y + 1, mb_xy + mb_stride);
710  }
711  }
712  av_assert0(next_blocklist_length <= mb_height * mb_width);
713  FFSWAP(int , blocklist_length, next_blocklist_length);
714  FFSWAP(void*, blocklist, next_blocklist);
715  }
716 }
717 
718 static int is_intra_more_likely(ERContext *s)
719 {
720  int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;
721 
722  if (!s->last_pic.f || !s->last_pic.f->data[0])
723  return 1; // no previous frame available -> use spatial prediction
724 
725  if (s->avctx->error_concealment & FF_EC_FAVOR_INTER)
726  return 0;
727 
728  undamaged_count = 0;
729  for (i = 0; i < s->mb_num; i++) {
730  const int mb_xy = s->mb_index2xy[i];
731  const int error = s->error_status_table[mb_xy];
732  if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR)))
733  undamaged_count++;
734  }
735 
736  if (undamaged_count < 5)
737  return 0; // almost all MBs damaged -> use temporal prediction
738 
739  skip_amount = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs
740  is_intra_likely = 0;
741 
742  j = 0;
743  for (mb_y = 0; mb_y < s->mb_height - 1; mb_y++) {
744  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
745  int error;
746  const int mb_xy = mb_x + mb_y * s->mb_stride;
747 
748  error = s->error_status_table[mb_xy];
749  if ((error & ER_DC_ERROR) && (error & ER_MV_ERROR))
750  continue; // skip damaged
751 
752  j++;
753  // skip a few to speed things up
754  if ((j % skip_amount) != 0)
755  continue;
756 
757  if (s->cur_pic.f->pict_type == AV_PICTURE_TYPE_I) {
758  int *linesize = s->cur_pic.f->linesize;
759  uint8_t *mb_ptr = s->cur_pic.f->data[0] +
760  mb_x * 16 + mb_y * 16 * linesize[0];
761  uint8_t *last_mb_ptr = s->last_pic.f->data[0] +
762  mb_x * 16 + mb_y * 16 * linesize[0];
763 
764  if (s->avctx->codec_id == AV_CODEC_ID_H264) {
765  // FIXME
766  } else {
767  ff_thread_await_progress(s->last_pic.tf, mb_y, 0);
768  }
769  is_intra_likely += s->sad(NULL, last_mb_ptr, mb_ptr,
770  linesize[0], 16);
771  // FIXME need await_progress() here
772  is_intra_likely -= s->sad(NULL, last_mb_ptr,
773  last_mb_ptr + linesize[0] * 16,
774  linesize[0], 16);
775  } else {
776  if (IS_INTRA(s->cur_pic.mb_type[mb_xy]))
777  is_intra_likely++;
778  else
779  is_intra_likely--;
780  }
781  }
782  }
783 // av_log(NULL, AV_LOG_ERROR, "is_intra_likely: %d type:%d\n", is_intra_likely, s->pict_type);
784  return is_intra_likely > 0;
785 }
786 
787 void ff_er_frame_start(ERContext *s)
788 {
789  if (!s->avctx->error_concealment)
790  return;
791 
792  if (!s->mecc_inited) {
793  MECmpContext mecc;
794  ff_me_cmp_init(&mecc, s->avctx);
795  s->sad = mecc.sad[0];
796  s->mecc_inited = 1;
797  }
798 
799  memset(s->error_status_table, ER_MB_ERROR | VP_START | ER_MB_END,
800  s->mb_stride * s->mb_height * sizeof(uint8_t));
801  atomic_init(&s->error_count, 3 * s->mb_num);
802  s->error_occurred = 0;
803 }
804 
805 static int er_supported(ERContext *s)
806 {
807  if(s->avctx->hwaccel && s->avctx->hwaccel->decode_slice ||
808  !s->cur_pic.f ||
809  s->cur_pic.field_picture
810  )
811  return 0;
812  return 1;
813 }
814 
815 /**
816  * Add a slice.
817  * @param endx x component of the last macroblock, can be -1
818  * for the last of the previous line
819  * @param status the status at the end (ER_MV_END, ER_AC_ERROR, ...), it is
820  * assumed that no earlier end or error of the same type occurred
821  */
822 void ff_er_add_slice(ERContext *s, int startx, int starty,
823  int endx, int endy, int status)
824 {
825  const int start_i = av_clip(startx + starty * s->mb_width, 0, s->mb_num - 1);
826  const int end_i = av_clip(endx + endy * s->mb_width, 0, s->mb_num);
827  const int start_xy = s->mb_index2xy[start_i];
828  const int end_xy = s->mb_index2xy[end_i];
829  int mask = -1;
830 
831  if (s->avctx->hwaccel && s->avctx->hwaccel->decode_slice)
832  return;
833 
834  if (start_i > end_i || start_xy > end_xy) {
835  av_log(s->avctx, AV_LOG_ERROR,
836  "internal error, slice end before start\n");
837  return;
838  }
839 
840  if (!s->avctx->error_concealment)
841  return;
842 
843  mask &= ~VP_START;
844  if (status & (ER_AC_ERROR | ER_AC_END)) {
845  mask &= ~(ER_AC_ERROR | ER_AC_END);
846  atomic_fetch_add(&s->error_count, start_i - end_i - 1);
847  }
848  if (status & (ER_DC_ERROR | ER_DC_END)) {
849  mask &= ~(ER_DC_ERROR | ER_DC_END);
850  atomic_fetch_add(&s->error_count, start_i - end_i - 1);
851  }
852  if (status & (ER_MV_ERROR | ER_MV_END)) {
853  mask &= ~(ER_MV_ERROR | ER_MV_END);
854  atomic_fetch_add(&s->error_count, start_i - end_i - 1);
855  }
856 
857  if (status & ER_MB_ERROR) {
858  s->error_occurred = 1;
859  atomic_store(&s->error_count, INT_MAX);
860  }
861 
862  if (mask == ~0x7F) {
863  memset(&s->error_status_table[start_xy], 0,
864  (end_xy - start_xy) * sizeof(uint8_t));
865  } else {
866  int i;
867  for (i = start_xy; i < end_xy; i++)
868  s->error_status_table[i] &= mask;
869  }
870 
871  if (end_i == s->mb_num)
872  atomic_store(&s->error_count, INT_MAX);
873  else {
874  s->error_status_table[end_xy] &= mask;
875  s->error_status_table[end_xy] |= status;
876  }
877 
878  s->error_status_table[start_xy] |= VP_START;
879 
880  if (start_xy > 0 && !(s->avctx->active_thread_type & FF_THREAD_SLICE) &&
881  er_supported(s) && s->avctx->skip_top * s->mb_width < start_i) {
882  int prev_status = s->error_status_table[s->mb_index2xy[start_i - 1]];
883 
884  prev_status &= ~ VP_START;
885  if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END)) {
886  s->error_occurred = 1;
887  atomic_store(&s->error_count, INT_MAX);
888  }
889  }
890 }
891 
892 void ff_er_frame_end(ERContext *s)
893 {
894  int *linesize = NULL;
895  int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;
896  int distance;
897  int threshold_part[4] = { 100, 100, 100 };
898  int threshold = 50;
899  int is_intra_likely;
900  int size = s->b8_stride * 2 * s->mb_height;
901 
902  /* We do not support ER of field pictures yet,
903  * though it should not crash if enabled. */
904  if (!s->avctx->error_concealment || !atomic_load(&s->error_count) ||
905  s->avctx->lowres ||
906  !er_supported(s) ||
907  atomic_load(&s->error_count) == 3 * s->mb_width *
908  (s->avctx->skip_top + s->avctx->skip_bottom)) {
909  return;
910  }
911  linesize = s->cur_pic.f->linesize;
912 
913  if ( s->avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO
914  && (FFALIGN(s->avctx->height, 16)&16)
915  && atomic_load(&s->error_count) == 3 * s->mb_width * (s->avctx->skip_top + s->avctx->skip_bottom + 1)) {
916  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
917  int status = s->error_status_table[mb_x + (s->mb_height - 1) * s->mb_stride];
918  if (status != 0x7F)
919  break;
920  }
921 
922  if (mb_x == s->mb_width) {
923  av_log(s->avctx, AV_LOG_DEBUG, "ignoring last missing slice\n");
924  return;
925  }
926  }
927 
928  if (s->last_pic.f) {
929  if (s->last_pic.f->width != s->cur_pic.f->width ||
930  s->last_pic.f->height != s->cur_pic.f->height ||
931  s->last_pic.f->format != s->cur_pic.f->format) {
932  av_log(s->avctx, AV_LOG_WARNING, "Cannot use previous picture in error concealment\n");
933  memset(&s->last_pic, 0, sizeof(s->last_pic));
934  }
935  }
936  if (s->next_pic.f) {
937  if (s->next_pic.f->width != s->cur_pic.f->width ||
938  s->next_pic.f->height != s->cur_pic.f->height ||
939  s->next_pic.f->format != s->cur_pic.f->format) {
940  av_log(s->avctx, AV_LOG_WARNING, "Cannot use next picture in error concealment\n");
941  memset(&s->next_pic, 0, sizeof(s->next_pic));
942  }
943  }
944 
945  if (!s->cur_pic.motion_val[0] || !s->cur_pic.ref_index[0]) {
946  av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n");
947 
948  for (i = 0; i < 2; i++) {
949  s->ref_index[i] = av_calloc(s->mb_stride * s->mb_height, 4 * sizeof(uint8_t));
950  s->motion_val_base[i] = av_calloc(size + 4, 2 * sizeof(uint16_t));
951  if (!s->ref_index[i] || !s->motion_val_base[i])
952  break;
953  s->cur_pic.ref_index[i] = s->ref_index[i];
954  s->cur_pic.motion_val[i] = s->motion_val_base[i] + 4;
955  }
956  if (i < 2) {
957  for (i = 0; i < 2; i++) {
958  av_freep(&s->ref_index[i]);
959  av_freep(&s->motion_val_base[i]);
960  s->cur_pic.ref_index[i] = NULL;
961  s->cur_pic.motion_val[i] = NULL;
962  }
963  return;
964  }
965  }
966 
967  if (s->avctx->debug & FF_DEBUG_ER) {
968  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
969  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
970  int status = s->error_status_table[mb_x + mb_y * s->mb_stride];
971 
972  av_log(s->avctx, AV_LOG_DEBUG, "%2X ", status);
973  }
974  av_log(s->avctx, AV_LOG_DEBUG, "\n");
975  }
976  }
977 
978 #if 1
979  /* handle overlapping slices */
980  for (error_type = 1; error_type <= 3; error_type++) {
981  int end_ok = 0;
982 
983  for (i = s->mb_num - 1; i >= 0; i--) {
984  const int mb_xy = s->mb_index2xy[i];
985  int error = s->error_status_table[mb_xy];
986 
987  if (error & (1 << error_type))
988  end_ok = 1;
989  if (error & (8 << error_type))
990  end_ok = 1;
991 
992  if (!end_ok)
993  s->error_status_table[mb_xy] |= 1 << error_type;
994 
995  if (error & VP_START)
996  end_ok = 0;
997  }
998  }
999 #endif
1000 #if 1
1001  /* handle slices with partitions of different length */
1002  if (s->partitioned_frame) {
1003  int end_ok = 0;
1004 
1005  for (i = s->mb_num - 1; i >= 0; i--) {
1006  const int mb_xy = s->mb_index2xy[i];
1007  int error = s->error_status_table[mb_xy];
1008 
1009  if (error & ER_AC_END)
1010  end_ok = 0;
1011  if ((error & ER_MV_END) ||
1012  (error & ER_DC_END) ||
1013  (error & ER_AC_ERROR))
1014  end_ok = 1;
1015 
1016  if (!end_ok)
1017  s->error_status_table[mb_xy]|= ER_AC_ERROR;
1018 
1019  if (error & VP_START)
1020  end_ok = 0;
1021  }
1022  }
1023 #endif
1024  /* handle missing slices */
1025  if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1026  int end_ok = 1;
1027 
1028  // FIXME + 100 hack
1029  for (i = s->mb_num - 2; i >= s->mb_width + 100; i--) {
1030  const int mb_xy = s->mb_index2xy[i];
1031  int error1 = s->error_status_table[mb_xy];
1032  int error2 = s->error_status_table[s->mb_index2xy[i + 1]];
1033 
1034  if (error1 & VP_START)
1035  end_ok = 1;
1036 
1037  if (error2 == (VP_START | ER_MB_ERROR | ER_MB_END) &&
1038  error1 != (VP_START | ER_MB_ERROR | ER_MB_END) &&
1039  ((error1 & ER_AC_END) || (error1 & ER_DC_END) ||
1040  (error1 & ER_MV_END))) {
1041  // end & uninit
1042  end_ok = 0;
1043  }
1044 
1045  if (!end_ok)
1046  s->error_status_table[mb_xy] |= ER_MB_ERROR;
1047  }
1048  }
1049 
1050 #if 1
1051  /* backward mark errors */
1052  distance = 9999999;
1053  for (error_type = 1; error_type <= 3; error_type++) {
1054  for (i = s->mb_num - 1; i >= 0; i--) {
1055  const int mb_xy = s->mb_index2xy[i];
1056  int error = s->error_status_table[mb_xy];
1057 
1058  if (!s->mbskip_table || !s->mbskip_table[mb_xy]) // FIXME partition specific
1059  distance++;
1060  if (error & (1 << error_type))
1061  distance = 0;
1062 
1063  if (s->partitioned_frame) {
1064  if (distance < threshold_part[error_type - 1])
1065  s->error_status_table[mb_xy] |= 1 << error_type;
1066  } else {
1067  if (distance < threshold)
1068  s->error_status_table[mb_xy] |= 1 << error_type;
1069  }
1070 
1071  if (error & VP_START)
1072  distance = 9999999;
1073  }
1074  }
1075 #endif
1076 
1077  /* forward mark errors */
1078  error = 0;
1079  for (i = 0; i < s->mb_num; i++) {
1080  const int mb_xy = s->mb_index2xy[i];
1081  int old_error = s->error_status_table[mb_xy];
1082 
1083  if (old_error & VP_START) {
1084  error = old_error & ER_MB_ERROR;
1085  } else {
1086  error |= old_error & ER_MB_ERROR;
1087  s->error_status_table[mb_xy] |= error;
1088  }
1089  }
1090 #if 1
1091  /* handle not partitioned case */
1092  if (!s->partitioned_frame) {
1093  for (i = 0; i < s->mb_num; i++) {
1094  const int mb_xy = s->mb_index2xy[i];
1095  int error = s->error_status_table[mb_xy];
1096  if (error & ER_MB_ERROR)
1097  error |= ER_MB_ERROR;
1098  s->error_status_table[mb_xy] = error;
1099  }
1100  }
1101 #endif
1102 
1103  dc_error = ac_error = mv_error = 0;
1104  for (i = 0; i < s->mb_num; i++) {
1105  const int mb_xy = s->mb_index2xy[i];
1106  int error = s->error_status_table[mb_xy];
1107  if (error & ER_DC_ERROR)
1108  dc_error++;
1109  if (error & ER_AC_ERROR)
1110  ac_error++;
1111  if (error & ER_MV_ERROR)
1112  mv_error++;
1113  }
1114  av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors in %c frame\n",
1115  dc_error, ac_error, mv_error, av_get_picture_type_char(s->cur_pic.f->pict_type));
1116 
1117  s->cur_pic.f->decode_error_flags |= FF_DECODE_ERROR_CONCEALMENT_ACTIVE;
1118 
1119  is_intra_likely = is_intra_more_likely(s);
1120 
1121  /* set unknown mb-type to most likely */
1122  for (i = 0; i < s->mb_num; i++) {
1123  const int mb_xy = s->mb_index2xy[i];
1124  int error = s->error_status_table[mb_xy];
1125  if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR)))
1126  continue;
1127 
1128  if (is_intra_likely)
1129  s->cur_pic.mb_type[mb_xy] = MB_TYPE_INTRA4x4;
1130  else
1131  s->cur_pic.mb_type[mb_xy] = MB_TYPE_16x16 | MB_TYPE_L0;
1132  }
1133 
1134  // change inter to intra blocks if no reference frames are available
1135  if (!(s->last_pic.f && s->last_pic.f->data[0]) &&
1136  !(s->next_pic.f && s->next_pic.f->data[0]))
1137  for (i = 0; i < s->mb_num; i++) {
1138  const int mb_xy = s->mb_index2xy[i];
1139  if (!IS_INTRA(s->cur_pic.mb_type[mb_xy]))
1140  s->cur_pic.mb_type[mb_xy] = MB_TYPE_INTRA4x4;
1141  }
1142 
1143  /* handle inter blocks with damaged AC */
1144  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1145  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1146  const int mb_xy = mb_x + mb_y * s->mb_stride;
1147  const int mb_type = s->cur_pic.mb_type[mb_xy];
1148  const int dir = !(s->last_pic.f && s->last_pic.f->data[0]);
1149  const int mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD;
1150  int mv_type;
1151 
1152  int error = s->error_status_table[mb_xy];
1153 
1154  if (IS_INTRA(mb_type))
1155  continue; // intra
1156  if (error & ER_MV_ERROR)
1157  continue; // inter with damaged MV
1158  if (!(error & ER_AC_ERROR))
1159  continue; // undamaged inter
1160 
1161  if (IS_8X8(mb_type)) {
1162  int mb_index = mb_x * 2 + mb_y * 2 * s->b8_stride;
1163  int j;
1164  mv_type = MV_TYPE_8X8;
1165  for (j = 0; j < 4; j++) {
1166  s->mv[0][j][0] = s->cur_pic.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][0];
1167  s->mv[0][j][1] = s->cur_pic.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][1];
1168  }
1169  } else {
1170  mv_type = MV_TYPE_16X16;
1171  s->mv[0][0][0] = s->cur_pic.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][0];
1172  s->mv[0][0][1] = s->cur_pic.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][1];
1173  }
1174 
1175  s->decode_mb(s->opaque, 0 /* FIXME H.264 partitioned slices need this set */,
1176  mv_dir, mv_type, &s->mv, mb_x, mb_y, 0, 0);
1177  }
1178  }
1179 
1180  /* guess MVs */
1181  if (s->cur_pic.f->pict_type == AV_PICTURE_TYPE_B) {
1182  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1183  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1184  int xy = mb_x * 2 + mb_y * 2 * s->b8_stride;
1185  const int mb_xy = mb_x + mb_y * s->mb_stride;
1186  const int mb_type = s->cur_pic.mb_type[mb_xy];
1187  int mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
1188 
1189  int error = s->error_status_table[mb_xy];
1190 
1191  if (IS_INTRA(mb_type))
1192  continue;
1193  if (!(error & ER_MV_ERROR))
1194  continue; // inter with undamaged MV
1195  if (!(error & ER_AC_ERROR))
1196  continue; // undamaged inter
1197 
1198  if (!(s->last_pic.f && s->last_pic.f->data[0]))
1199  mv_dir &= ~MV_DIR_FORWARD;
1200  if (!(s->next_pic.f && s->next_pic.f->data[0]))
1201  mv_dir &= ~MV_DIR_BACKWARD;
1202 
1203  if (s->pp_time) {
1204  int time_pp = s->pp_time;
1205  int time_pb = s->pb_time;
1206 
1207  av_assert0(s->avctx->codec_id != AV_CODEC_ID_H264);
1208  ff_thread_await_progress(s->next_pic.tf, mb_y, 0);
1209 
1210  s->mv[0][0][0] = s->next_pic.motion_val[0][xy][0] * time_pb / time_pp;
1211  s->mv[0][0][1] = s->next_pic.motion_val[0][xy][1] * time_pb / time_pp;
1212  s->mv[1][0][0] = s->next_pic.motion_val[0][xy][0] * (time_pb - time_pp) / time_pp;
1213  s->mv[1][0][1] = s->next_pic.motion_val[0][xy][1] * (time_pb - time_pp) / time_pp;
1214  } else {
1215  s->mv[0][0][0] = 0;
1216  s->mv[0][0][1] = 0;
1217  s->mv[1][0][0] = 0;
1218  s->mv[1][0][1] = 0;
1219  }
1220 
1221  s->decode_mb(s->opaque, 0, mv_dir, MV_TYPE_16X16, &s->mv,
1222  mb_x, mb_y, 0, 0);
1223  }
1224  }
1225  } else
1226  guess_mv(s);
1227 
1228  /* fill DC for inter blocks */
1229  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1230  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1231  int dc, dcu, dcv, y, n;
1232  int16_t *dc_ptr;
1233  uint8_t *dest_y, *dest_cb, *dest_cr;
1234  const int mb_xy = mb_x + mb_y * s->mb_stride;
1235  const int mb_type = s->cur_pic.mb_type[mb_xy];
1236 
1237  // error = s->error_status_table[mb_xy];
1238 
1239  if (IS_INTRA(mb_type) && s->partitioned_frame)
1240  continue;
1241  // if (error & ER_MV_ERROR)
1242  // continue; // inter data damaged FIXME is this good?
1243 
1244  dest_y = s->cur_pic.f->data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
1245  dest_cb = s->cur_pic.f->data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
1246  dest_cr = s->cur_pic.f->data[2] + mb_x * 8 + mb_y * 8 * linesize[2];
1247 
1248  dc_ptr = &s->dc_val[0][mb_x * 2 + mb_y * 2 * s->b8_stride];
1249  for (n = 0; n < 4; n++) {
1250  dc = 0;
1251  for (y = 0; y < 8; y++) {
1252  int x;
1253  for (x = 0; x < 8; x++)
1254  dc += dest_y[x + (n & 1) * 8 +
1255  (y + (n >> 1) * 8) * linesize[0]];
1256  }
1257  dc_ptr[(n & 1) + (n >> 1) * s->b8_stride] = (dc + 4) >> 3;
1258  }
1259 
1260  if (!s->cur_pic.f->data[2])
1261  continue;
1262 
1263  dcu = dcv = 0;
1264  for (y = 0; y < 8; y++) {
1265  int x;
1266  for (x = 0; x < 8; x++) {
1267  dcu += dest_cb[x + y * linesize[1]];
1268  dcv += dest_cr[x + y * linesize[2]];
1269  }
1270  }
1271  s->dc_val[1][mb_x + mb_y * s->mb_stride] = (dcu + 4) >> 3;
1272  s->dc_val[2][mb_x + mb_y * s->mb_stride] = (dcv + 4) >> 3;
1273  }
1274  }
1275 #if 1
1276  /* guess DC for damaged blocks */
1277  guess_dc(s, s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride, 1);
1278  guess_dc(s, s->dc_val[1], s->mb_width , s->mb_height , s->mb_stride, 0);
1279  guess_dc(s, s->dc_val[2], s->mb_width , s->mb_height , s->mb_stride, 0);
1280 #endif
1281 
1282  /* filter luma DC */
1283  filter181(s->dc_val[0], s->mb_width * 2, s->mb_height * 2, s->b8_stride);
1284 
1285 #if 1
1286  /* render DC only intra */
1287  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1288  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1289  uint8_t *dest_y, *dest_cb, *dest_cr;
1290  const int mb_xy = mb_x + mb_y * s->mb_stride;
1291  const int mb_type = s->cur_pic.mb_type[mb_xy];
1292 
1293  int error = s->error_status_table[mb_xy];
1294 
1295  if (IS_INTER(mb_type))
1296  continue;
1297  if (!(error & ER_AC_ERROR))
1298  continue; // undamaged
1299 
1300  dest_y = s->cur_pic.f->data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
1301  dest_cb = s->cur_pic.f->data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
1302  dest_cr = s->cur_pic.f->data[2] + mb_x * 8 + mb_y * 8 * linesize[2];
1303  if (!s->cur_pic.f->data[2])
1304  dest_cb = dest_cr = NULL;
1305 
1306  put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
1307  }
1308  }
1309 #endif
1310 
1311  if (s->avctx->error_concealment & FF_EC_DEBLOCK) {
1312  /* filter horizontal block boundaries */
1313  h_block_filter(s, s->cur_pic.f->data[0], s->mb_width * 2,
1314  s->mb_height * 2, linesize[0], 1);
1315 
1316  /* filter vertical block boundaries */
1317  v_block_filter(s, s->cur_pic.f->data[0], s->mb_width * 2,
1318  s->mb_height * 2, linesize[0], 1);
1319 
1320  if (s->cur_pic.f->data[2]) {
1321  h_block_filter(s, s->cur_pic.f->data[1], s->mb_width,
1322  s->mb_height, linesize[1], 0);
1323  h_block_filter(s, s->cur_pic.f->data[2], s->mb_width,
1324  s->mb_height, linesize[2], 0);
1325  v_block_filter(s, s->cur_pic.f->data[1], s->mb_width,
1326  s->mb_height, linesize[1], 0);
1327  v_block_filter(s, s->cur_pic.f->data[2], s->mb_width,
1328  s->mb_height, linesize[2], 0);
1329  }
1330  }
1331 
1332  /* clean a few tables */
1333  for (i = 0; i < s->mb_num; i++) {
1334  const int mb_xy = s->mb_index2xy[i];
1335  int error = s->error_status_table[mb_xy];
1336 
1337  if (s->mbskip_table && s->cur_pic.f->pict_type != AV_PICTURE_TYPE_B &&
1338  (error & (ER_DC_ERROR | ER_MV_ERROR | ER_AC_ERROR))) {
1339  s->mbskip_table[mb_xy] = 0;
1340  }
1341  if (s->mbintra_table)
1342  s->mbintra_table[mb_xy] = 1;
1343  }
1344 
1345  for (i = 0; i < 2; i++) {
1346  av_freep(&s->ref_index[i]);
1347  av_freep(&s->motion_val_base[i]);
1348  s->cur_pic.ref_index[i] = NULL;
1349  s->cur_pic.motion_val[i] = NULL;
1350  }
1351 
1352  memset(&s->cur_pic, 0, sizeof(ERPicture));
1353  memset(&s->last_pic, 0, sizeof(ERPicture));
1354  memset(&s->next_pic, 0, sizeof(ERPicture));
1355 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
FF_DECODE_ERROR_CONCEALMENT_ACTIVE
#define FF_DECODE_ERROR_CONCEALMENT_ACTIVE
Definition: frame.h:637
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:82
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:60
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:263
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
av_clip
#define av_clip
Definition: common.h:95
atomic_store
#define atomic_store(object, desired)
Definition: stdatomic.h:85
MV_UNCHANGED
#define MV_UNCHANGED
Definition: error_resilience.c:378
color
Definition: vf_paletteuse.c:601
MV_CHANGED
#define MV_CHANGED
Definition: error_resilience.c:377
is_intra_more_likely
static int is_intra_more_likely(ERContext *s)
Definition: error_resilience.c:718
set_mv_strides
static void set_mv_strides(ERContext *s, ptrdiff_t *mv_step, ptrdiff_t *stride)
Definition: error_resilience.c:43
w
uint8_t w
Definition: llviddspenc.c:38
MB_TYPE_INTRA4x4
#define MB_TYPE_INTRA4x4
Definition: mpegutils.h:44
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:146
MV_FROZEN
#define MV_FROZEN
Definition: error_resilience.c:376
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:47
ff_er_frame_start
void ff_er_frame_start(ERContext *s)
Definition: error_resilience.c:787
ERContext
Definition: error_resilience.h:53
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:822
FF_EC_GUESS_MVS
#define FF_EC_GUESS_MVS
Definition: avcodec.h:1318
mpegvideo.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ER_DC_END
#define ER_DC_END
Definition: error_resilience.h:35
h_block_filter
static void h_block_filter(ERContext *s, uint8_t *dst, int w, int h, ptrdiff_t stride, int is_luma)
simple horizontal deblocking filter used for error resilience
Definition: error_resilience.c:240
mpegutils.h
ER_MV_ERROR
#define ER_MV_ERROR
Definition: error_resilience.h:33
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
ff_crop_tab
#define ff_crop_tab
Definition: motionpixels_tablegen.c:26
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:260
ERPicture
Definition: error_resilience.h:41
fail
#define fail()
Definition: checkasm.h:134
FF_DEBUG_ER
#define FF_DEBUG_ER
Definition: avcodec.h:1336
ff_me_cmp_init
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:1003
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ER_DC_ERROR
#define ER_DC_ERROR
Definition: error_resilience.h:32
mask
static const uint16_t mask[17]
Definition: lzw.c:38
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:256
FF_EC_DEBLOCK
#define FF_EC_DEBLOCK
Definition: avcodec.h:1319
er_supported
static int er_supported(ERContext *s)
Definition: error_resilience.c:805
guess_mv
static void guess_mv(ERContext *s)
Definition: error_resilience.c:389
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
limits.h
IS_INTRA
#define IS_INTRA(x, y)
atomic_load
#define atomic_load(object)
Definition: stdatomic.h:93
v_block_filter
static void v_block_filter(ERContext *s, uint8_t *dst, int w, int h, ptrdiff_t stride, int is_luma)
simple vertical deblocking filter used for error resilience
Definition: error_resilience.c:309
pass
#define pass
Definition: fft_template.c:608
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
add_blocklist
static av_always_inline void add_blocklist(int(*blocklist)[2], int *blocklist_length, uint8_t *fixed, int mb_x, int mb_y, int mb_xy)
Definition: error_resilience.c:380
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
if
if(ret)
Definition: filter_design.txt:179
threadframe.h
MECmpContext
Definition: me_cmp.h:55
NULL
#define NULL
Definition: coverity.c:32
ER_AC_ERROR
#define ER_AC_ERROR
Definition: error_resilience.h:31
MECmpContext::sad
me_cmp_func sad[6]
Definition: me_cmp.h:58
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:38
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
guess_dc
static void guess_dc(ERContext *s, int16_t *dc, int w, int h, ptrdiff_t stride, int is_luma)
guess the dc of blocks which do not have an undamaged dc
Definition: error_resilience.c:137
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
weight
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1561
MV_TYPE_8X8
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:264
f
f
Definition: af_crystalizer.c:122
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
rectangle.h
VP_START
#define VP_START
< current MB is the first after a resync marker
Definition: error_resilience.h:30
size
int size
Definition: twinvq_data.h:10344
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:94
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1478
height
#define height
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
internal.h
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
me_cmp.h
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
error_resilience.h
atomic_fetch_add
#define atomic_fetch_add(object, operand)
Definition: stdatomic.h:131
cm
#define cm
Definition: dvbsubdec.c:39
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
MV_LISTED
#define MV_LISTED
Definition: error_resilience.c:379
put_dc
static void put_dc(ERContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
Replace the current MB with a flat dc-only version.
Definition: error_resilience.c:58
IS_INTER
#define IS_INTER(a)
Definition: mpegutils.h:72
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:39
ER_MV_END
#define ER_MV_END
Definition: error_resilience.h:36
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:259
ff_er_frame_end
void ff_er_frame_end(ERContext *s)
Definition: error_resilience.c:892
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
d
d
Definition: ffmpeg_filter.c:156
fixed
#define fixed(width, name, value)
Definition: cbs_av1.c:566
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:230
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:34
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
MAX_NEG_CROP
#define MAX_NEG_CROP
Definition: mathops.h:31
FF_EC_FAVOR_INTER
#define FF_EC_FAVOR_INTER
Definition: avcodec.h:1320
int
int
Definition: ffmpeg_filter.c:156
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
filter181
static void filter181(int16_t *data, int width, int height, ptrdiff_t stride)
Definition: error_resilience.c:96
Generated on Sun Nov 27 2022 19:20:58 for FFmpeg by   doxygen 1.8.17