60 uint8_t *dest_cr,
int mb_x,
int mb_y)
63 int dc, dcu, dcv, y,
i;
64 for (i = 0; i < 4; i++) {
65 dc = s->
dc_val[0][mb_x * 2 + (i & 1) + (mb_y * 2 + (i >> 1)) * s->
b8_stride];
70 for (y = 0; y < 8; y++) {
72 for (x = 0; x < 8; x++)
73 dest_y[x + (i & 1) * 8 + (y + (i >> 1) * 8) * linesize[0]] = dc / 8;
88 for (y = 0; y < 8; y++) {
90 for (x = 0; x < 8; x++) {
91 dest_cb[x + y * linesize[1]] = dcu / 8;
92 dest_cr[x + y * linesize[2]] = dcv / 8;
102 for (y = 1; y < height - 1; y++) {
103 int prev_dc = data[0 + y *
stride];
105 for (x = 1; x < width - 1; x++) {
108 data[x + y *
stride] * 8 -
110 dc = (av_clip(dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16;
111 prev_dc = data[x + y *
stride];
117 for (x = 1; x < width - 1; x++) {
118 int prev_dc = data[x];
120 for (y = 1; y < height - 1; y++) {
124 data[x + y *
stride] * 8 -
125 data[x + (y + 1) * stride];
126 dc = (av_clip(dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16;
127 prev_dc = data[x + y *
stride];
139 int h, ptrdiff_t
stride,
int is_luma)
150 for(b_y=0; b_y<
h; b_y++){
153 for(b_x=0; b_x<
w; b_x++){
154 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
158 color= dc[b_x + b_y*
stride];
162 dist[b_x + b_y*
stride][1]= distance >= 0 ? b_x-distance : 9999;
166 for(b_x=w-1; b_x>=0; b_x--){
167 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
171 color= dc[b_x + b_y*
stride];
175 dist[b_x + b_y*
stride][0]= distance >= 0 ? distance-b_x : 9999;
178 for(b_x=0; b_x<
w; b_x++){
181 for(b_y=0; b_y<
h; b_y++){
182 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
186 color= dc[b_x + b_y*
stride];
190 dist[b_x + b_y*
stride][3]= distance >= 0 ? b_y-distance : 9999;
194 for(b_y=h-1; b_y>=0; b_y--){
195 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
199 color= dc[b_x + b_y*
stride];
203 dist[b_x + b_y*
stride][2]= distance >= 0 ? distance-b_y : 9999;
207 for (b_y = 0; b_y <
h; b_y++) {
208 for (b_x = 0; b_x <
w; b_x++) {
209 int mb_index,
error, j;
210 int64_t guess, weight_sum;
211 mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->
mb_stride;
221 for (j = 0; j < 4; j++) {
222 int64_t
weight = 256 * 256 * 256 * 16 /
FFMAX(dist[b_x + b_y*stride][j], 1);
223 guess += weight*(int64_t)col[b_x + b_y*stride][j];
226 guess = (guess + weight_sum / 2) / weight_sum;
227 dc[b_x + b_y *
stride] = guess;
242 int h, ptrdiff_t
stride,
int is_luma)
245 ptrdiff_t mvx_stride, mvy_stride;
248 mvx_stride >>= is_luma;
249 mvy_stride *= mvx_stride;
251 for (b_y = 0; b_y <
h; b_y++) {
252 for (b_x = 0; b_x < w - 1; b_x++) {
260 int offset = b_x * 8 + b_y * stride * 8;
261 int16_t *left_mv = s->
cur_pic.
motion_val[0][mvy_stride * b_y + mvx_stride * b_x];
262 int16_t *right_mv = s->
cur_pic.
motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)];
263 if (!(left_damage || right_damage))
265 if ((!left_intra) && (!right_intra) &&
266 FFABS(left_mv[0] - right_mv[0]) +
267 FFABS(left_mv[1] + right_mv[1]) < 2)
270 for (y = 0; y < 8; y++) {
273 a = dst[offset + 7 + y *
stride] - dst[offset + 6 + y *
stride];
274 b = dst[offset + 8 + y *
stride] - dst[offset + 7 + y *
stride];
275 c = dst[offset + 9 + y *
stride] - dst[offset + 8 + y *
stride];
285 if (!(left_damage && right_damage))
289 dst[offset + 7 + y *
stride] = cm[dst[offset + 7 + y *
stride] + ((d * 7) >> 4)];
290 dst[offset + 6 + y *
stride] = cm[dst[offset + 6 + y *
stride] + ((d * 5) >> 4)];
291 dst[offset + 5 + y *
stride] = cm[dst[offset + 5 + y *
stride] + ((d * 3) >> 4)];
292 dst[offset + 4 + y *
stride] = cm[dst[offset + 4 + y *
stride] + ((d * 1) >> 4)];
295 dst[offset + 8 + y *
stride] = cm[dst[offset + 8 + y *
stride] - ((d * 7) >> 4)];
296 dst[offset + 9 + y *
stride] = cm[dst[offset + 9 + y *
stride] - ((d * 5) >> 4)];
297 dst[offset + 10+ y *
stride] = cm[dst[offset + 10 + y *
stride] - ((d * 3) >> 4)];
298 dst[offset + 11+ y *
stride] = cm[dst[offset + 11 + y *
stride] - ((d * 1) >> 4)];
311 ptrdiff_t
stride,
int is_luma)
314 ptrdiff_t mvx_stride, mvy_stride;
317 mvx_stride >>= is_luma;
318 mvy_stride *= mvx_stride;
320 for (b_y = 0; b_y < h - 1; b_y++) {
321 for (b_x = 0; b_x <
w; b_x++) {
329 int offset = b_x * 8 + b_y * stride * 8;
332 int16_t *bottom_mv = s->
cur_pic.
motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x];
334 if (!(top_damage || bottom_damage))
337 if ((!top_intra) && (!bottom_intra) &&
338 FFABS(top_mv[0] - bottom_mv[0]) +
339 FFABS(top_mv[1] + bottom_mv[1]) < 2)
342 for (x = 0; x < 8; x++) {
345 a = dst[offset + x + 7 *
stride] - dst[offset + x + 6 *
stride];
346 b = dst[offset + x + 8 *
stride] - dst[offset + x + 7 *
stride];
347 c = dst[offset + x + 9 *
stride] - dst[offset + x + 8 *
stride];
357 if (!(top_damage && bottom_damage))
361 dst[offset + x + 7 *
stride] = cm[dst[offset + x + 7 *
stride] + ((d * 7) >> 4)];
362 dst[offset + x + 6 *
stride] = cm[dst[offset + x + 6 *
stride] + ((d * 5) >> 4)];
363 dst[offset + x + 5 *
stride] = cm[dst[offset + x + 5 *
stride] + ((d * 3) >> 4)];
364 dst[offset + x + 4 *
stride] = cm[dst[offset + x + 4 *
stride] + ((d * 1) >> 4)];
367 dst[offset + x + 8 *
stride] = cm[dst[offset + x + 8 *
stride] - ((d * 7) >> 4)];
368 dst[offset + x + 9 *
stride] = cm[dst[offset + x + 9 *
stride] - ((d * 5) >> 4)];
369 dst[offset + x + 10 *
stride] = cm[dst[offset + x + 10 *
stride] - ((d * 3) >> 4)];
370 dst[offset + x + 11 *
stride] = cm[dst[offset + x + 11 *
stride] - ((d * 1) >> 4)];
379 #define MV_UNCHANGED 2 386 blocklist[ *blocklist_length ][0] = mb_x;
387 blocklist[(*blocklist_length)++][1] = mb_y;
392 int (*blocklist)[2], (*next_blocklist)[2];
394 const ptrdiff_t mb_stride = s->
mb_stride;
397 int i, depth, num_avail;
399 ptrdiff_t mot_step, mot_stride;
400 int blocklist_length, next_blocklist_length;
416 for (i = 0; i < mb_width * mb_height; i++) {
432 const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
440 num_avail <=
FFMAX(mb_width, mb_height) / 2) {
441 for (mb_y = 0; mb_y < mb_height; mb_y++) {
442 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
443 const int mb_xy = mb_x + mb_y * s->
mb_stride;
460 blocklist_length = 0;
461 for (mb_y = 0; mb_y < mb_height; mb_y++) {
462 for (mb_x = 0; mb_x < mb_width; mb_x++) {
463 const int mb_xy = mb_x + mb_y * mb_stride;
465 if (mb_x)
add_blocklist(blocklist, &blocklist_length, fixed, mb_x - 1, mb_y, mb_xy - 1);
466 if (mb_y)
add_blocklist(blocklist, &blocklist_length, fixed, mb_x, mb_y - 1, mb_xy - mb_stride);
467 if (mb_x+1 < mb_width)
add_blocklist(blocklist, &blocklist_length, fixed, mb_x + 1, mb_y, mb_xy + 1);
468 if (mb_y+1 < mb_height)
add_blocklist(blocklist, &blocklist_length, fixed, mb_x, mb_y + 1, mb_xy + mb_stride);
473 for (depth = 0; ; depth++) {
474 int changed,
pass, none_left;
479 for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {
483 for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) {
484 const int mb_x = blocklist[blocklist_index][0];
485 const int mb_y = blocklist[blocklist_index][1];
486 const int mb_xy = mb_x + mb_y * mb_stride;
487 int mv_predictor[8][2];
494 int prev_x, prev_y, prev_ref;
496 if ((mb_x ^ mb_y ^ pass) & 1)
506 j |= fixed[mb_xy - 1];
507 if (mb_x + 1 < mb_width)
508 j |= fixed[mb_xy + 1];
510 j |= fixed[mb_xy - mb_stride];
511 if (mb_y + 1 < mb_height)
512 j |= fixed[mb_xy + mb_stride];
521 mot_index = (mb_x + mb_y * mot_stride) * mot_step;
523 if (mb_x > 0 && fixed[mb_xy - 1] > 1) {
524 mv_predictor[pred_count][0] =
526 mv_predictor[pred_count][1] =
532 if (mb_x + 1 < mb_width && fixed[mb_xy + 1] > 1) {
533 mv_predictor[pred_count][0] =
535 mv_predictor[pred_count][1] =
541 if (mb_y > 0 && fixed[mb_xy - mb_stride] > 1) {
542 mv_predictor[pred_count][0] =
544 mv_predictor[pred_count][1] =
550 if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride] > 1) {
551 mv_predictor[pred_count][0] =
553 mv_predictor[pred_count][1] =
562 if (pred_count > 1) {
563 int sum_x = 0, sum_y = 0, sum_r = 0;
564 int max_x, max_y, min_x, min_y, max_r, min_r;
566 for (j = 0; j < pred_count; j++) {
567 sum_x += mv_predictor[j][0];
568 sum_y += mv_predictor[j][1];
570 if (j && ref[j] != ref[j - 1])
571 goto skip_mean_and_median;
575 mv_predictor[pred_count][0] = sum_x / j;
576 mv_predictor[pred_count][1] = sum_y / j;
577 ref[pred_count] = sum_r / j;
580 if (pred_count >= 3) {
581 min_y = min_x = min_r = 99999;
582 max_y = max_x = max_r = -99999;
584 min_x = min_y = max_x = max_y = min_r = max_r = 0;
586 for (j = 0; j < pred_count; j++) {
587 max_x =
FFMAX(max_x, mv_predictor[j][0]);
588 max_y =
FFMAX(max_y, mv_predictor[j][1]);
589 max_r =
FFMAX(max_r, ref[j]);
590 min_x =
FFMIN(min_x, mv_predictor[j][0]);
591 min_y =
FFMIN(min_y, mv_predictor[j][1]);
592 min_r =
FFMIN(min_r, ref[j]);
594 mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;
595 mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;
596 ref[pred_count + 1] = sum_r - max_r - min_r;
598 if (pred_count == 4) {
599 mv_predictor[pred_count + 1][0] /= 2;
600 mv_predictor[pred_count + 1][1] /= 2;
601 ref[pred_count + 1] /= 2;
606 skip_mean_and_median:
608 mv_predictor[pred_count][0] =
609 mv_predictor[pred_count][1] =
618 mv_predictor[pred_count][0] = prev_x;
619 mv_predictor[pred_count][1] = prev_y;
620 ref[pred_count] = prev_ref;
624 best_score = 256 * 256 * 256 * 64;
625 for (j = 0; j < pred_count; j++) {
629 mb_x * 16 + mb_y * 16 * linesize[0];
632 s->
mv[0][0][0] = mv_predictor[j][0];
634 s->
mv[0][0][1] = mv_predictor[j][1];
643 if (mb_x > 0 && fixed[mb_xy - 1] > 1) {
645 for (k = 0; k < 16; k++)
646 score +=
FFABS(src[k * linesize[0] - 1] -
647 src[k * linesize[0]]);
649 if (mb_x + 1 < mb_width && fixed[mb_xy + 1] > 1) {
651 for (k = 0; k < 16; k++)
652 score +=
FFABS(src[k * linesize[0] + 15] -
653 src[k * linesize[0] + 16]);
655 if (mb_y > 0 && fixed[mb_xy - mb_stride] > 1) {
657 for (k = 0; k < 16; k++)
658 score +=
FFABS(src[k - linesize[0]] - src[k]);
660 if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] > 1) {
662 for (k = 0; k < 16; k++)
663 score +=
FFABS(src[k + linesize[0] * 15] -
664 src[k + linesize[0] * 16]);
667 if (score <= best_score) {
672 score_sum += best_score;
673 s->
mv[0][0][0] = mv_predictor[best_pred][0];
674 s->
mv[0][0][1] = mv_predictor[best_pred][1];
676 for (i = 0; i < mot_step; i++)
677 for (j = 0; j < mot_step; j++) {
686 if (s->
mv[0][0][0] != prev_x || s->
mv[0][0][1] != prev_y) {
697 next_blocklist_length = 0;
699 for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) {
700 const int mb_x = blocklist[blocklist_index][0];
701 const int mb_y = blocklist[blocklist_index][1];
702 const int mb_xy = mb_x + mb_y * mb_stride;
707 add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x - 1, mb_y, mb_xy - 1);
709 add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x, mb_y - 1, mb_xy - mb_stride);
710 if (mb_x + 1 < mb_width)
711 add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x + 1, mb_y, mb_xy + 1);
712 if (mb_y + 1 < mb_height)
713 add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x, mb_y + 1, mb_xy + mb_stride);
716 av_assert0(next_blocklist_length <= mb_height * mb_width);
717 FFSWAP(
int , blocklist_length, next_blocklist_length);
718 FFSWAP(
void*, blocklist, next_blocklist);
724 int is_intra_likely,
i, j, undamaged_count, skip_amount, mb_x, mb_y;
733 for (i = 0; i < s->
mb_num; i++) {
740 if (undamaged_count < 5)
749 skip_amount =
FFMAX(undamaged_count / 50, 1);
753 for (mb_y = 0; mb_y < s->
mb_height - 1; mb_y++) {
754 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
756 const int mb_xy = mb_x + mb_y * s->
mb_stride;
764 if ((j % skip_amount) != 0)
770 mb_x * 16 + mb_y * 16 * linesize[0];
772 mb_x * 16 + mb_y * 16 * linesize[0];
779 is_intra_likely += s->
mecc.
sad[0](
NULL, last_mb_ptr, mb_ptr,
782 is_intra_likely -= s->
mecc.
sad[0](
NULL, last_mb_ptr,
783 last_mb_ptr + linesize[0] * 16,
794 return is_intra_likely > 0;
831 int endx,
int endy,
int status)
833 const int start_i = av_clip(startx + starty * s->
mb_width, 0, s->
mb_num - 1);
834 const int end_i = av_clip(endx + endy * s->
mb_width, 0, s->
mb_num);
842 if (start_i > end_i || start_xy > end_xy) {
844 "internal error, slice end before start\n");
872 (end_xy - start_xy) *
sizeof(
uint8_t));
875 for (i = start_xy; i < end_xy; i++)
902 int *linesize =
NULL;
903 int i, mb_x, mb_y,
error, error_type, dc_error, mv_error, ac_error;
905 int threshold_part[4] = { 100, 100, 100 };
920 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
955 for (i = 0; i < 2; i++) {
964 for (i = 0; i < 2; i++) {
975 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
976 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
987 for (error_type = 1; error_type <= 3; error_type++) {
990 for (i = s->
mb_num - 1; i >= 0; i--) {
994 if (error & (1 << error_type))
996 if (error & (8 << error_type))
1012 for (i = s->
mb_num - 1; i >= 0; i--) {
1060 for (error_type = 1; error_type <= 3; error_type++) {
1061 for (i = s->
mb_num - 1; i >= 0; i--) {
1067 if (error & (1 << error_type))
1071 if (distance < threshold_part[error_type - 1])
1074 if (distance < threshold)
1086 for (i = 0; i < s->
mb_num; i++) {
1100 for (i = 0; i < s->
mb_num; i++) {
1110 dc_error = ac_error = mv_error = 0;
1111 for (i = 0; i < s->
mb_num; i++) {
1129 for (i = 0; i < s->
mb_num; i++) {
1135 if (is_intra_likely)
1144 for (i = 0; i < s->
mb_num; i++) {
1151 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1152 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1153 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1169 int mb_index = mb_x * 2 + mb_y * 2 * s->
b8_stride;
1172 for (j = 0; j < 4; j++) {
1183 mv_dir, mv_type, &s->
mv, mb_x, mb_y, 0, 0);
1189 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1190 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1191 int xy = mb_x * 2 + mb_y * 2 * s->
b8_stride;
1192 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1239 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1240 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1241 int dc, dcu, dcv, y, n;
1243 uint8_t *dest_y, *dest_cb, *dest_cr;
1244 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1254 dest_y = s->
cur_pic.
f->
data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
1255 dest_cb = s->
cur_pic.
f->
data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
1256 dest_cr = s->
cur_pic.
f->
data[2] + mb_x * 8 + mb_y * 8 * linesize[2];
1259 for (n = 0; n < 4; n++) {
1261 for (y = 0; y < 8; y++) {
1263 for (x = 0; x < 8; x++)
1264 dc += dest_y[x + (n & 1) * 8 +
1265 (y + (n >> 1) * 8) * linesize[0]];
1267 dc_ptr[(n & 1) + (n >> 1) * s->
b8_stride] = (dc + 4) >> 3;
1274 for (y = 0; y < 8; y++) {
1276 for (x = 0; x < 8; x++) {
1277 dcu += dest_cb[x + y * linesize[1]];
1278 dcv += dest_cr[x + y * linesize[2]];
1297 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1298 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1299 uint8_t *dest_y, *dest_cb, *dest_cr;
1300 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1310 dest_y = s->
cur_pic.
f->
data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
1311 dest_cb = s->
cur_pic.
f->
data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
1312 dest_cr = s->
cur_pic.
f->
data[2] + mb_x * 8 + mb_y * 8 * linesize[2];
1314 dest_cb = dest_cr =
NULL;
1316 put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
1344 for (i = 0; i < s->
mb_num; i++) {
1356 for (i = 0; i < 2; i++) {
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
#define atomic_store(object, desired)
ptrdiff_t const GLvoid * data
AVBufferRef * motion_val_buf[2]
#define FF_DECODE_ERROR_CONCEALMENT_ACTIVE
#define fixed(width, name, value)
#define AV_LOG_WARNING
Something somehow does not look correct.
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.
void ff_er_frame_end(ERContext *s)
#define VP_START
< current MB is the first after a resync marker
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
static void guess_mv(ERContext *s)
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
static void error(const char *err)
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
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
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
AVBufferRef * ref_index_buf[2]
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
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
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
Multithreading support functions.
static void set_mv_strides(ERContext *s, ptrdiff_t *mv_step, ptrdiff_t *stride)
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Libavcodec version macros.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
static const uint16_t mask[17]
#define atomic_load(object)
int active_thread_type
Which multithreading methods are in use by the codec.
int error_concealment
error concealment flags
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static void filter181(int16_t *data, int width, int height, ptrdiff_t stride)
static float distance(float x, float y, int band)
uint8_t * error_status_table
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
common internal API header
useful rectangle filling function
enum AVPictureType pict_type
Picture type of the frame.
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
#define AV_EF_EXPLODE
abort decoding on minor error detection
int skip_top
Number of macroblock rows at the top which are skipped.
preferred ID for MPEG-1/2 video decoding
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
#define MV_TYPE_16X16
1 vector for the whole mb
#define atomic_fetch_add(object, operand)
#define AV_LOG_INFO
Standard information.
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
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)
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]
uint8_t * data
The data buffer.
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
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
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
static int weight(int i, int blen, int offset)
int skip_bottom
Number of macroblock rows at the bottom which are skipped.
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define FF_EC_FAVOR_INTER
GLint GLenum GLboolean GLsizei stride
static int ref[MAX_W *MAX_W]
static int is_intra_more_likely(ERContext *s)
int16_t(*[2] motion_val)[2]
static int er_supported(ERContext *s)
void ff_er_frame_start(ERContext *s)
#define atomic_init(obj, value)
void(* decode_mb)(struct MpegEncContext *s)
Called for every Macroblock in a slice.
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
void(* decode_mb)(void *opaque, int ref, int mv_dir, int mv_type, int(*mv)[2][4][2], int mb_x, int mb_y, int mb_intra, int mb_skipped)