Go to the documentation of this file.
52 #define MAX_REFERENCE_FRAMES 8
54 #define MAX_FRAMES (MAX_REFERENCE_FRAMES + MAX_DELAY + 1)
56 #define MAX_BLOCKSIZE 32
61 #define DIRAC_REF_MASK_REF1 1
62 #define DIRAC_REF_MASK_REF2 2
63 #define DIRAC_REF_MASK_GLOBAL 4
69 #define DELAYED_PIC_REF 4
71 #define CALC_PADDING(size, depth) \
72 (((size + (1 << depth) - 1) >> depth) << depth)
74 #define DIVRNDUP(a, b) (((a) + (b) - 1) / (b))
80 uint8_t *hpel_base[3][4];
109 typedef struct Plane {
255 return (
int)((x+1
U)*21845 + 10922) >> 16;
261 int i, remove_idx = -1;
263 for (
i = 0; framelist[
i];
i++)
264 if (framelist[
i]->picture_number == picnum) {
265 remove_pic = framelist[
i];
270 for (
i = remove_idx; framelist[
i];
i++)
271 framelist[
i] = framelist[
i+1];
279 for (
i = 0;
i < maxframes;
i++)
290 int sbheight =
DIVRNDUP(
s->seq.height, 4);
291 int i,
w,
h, top_padding;
294 for (
i = 0;
i < 3;
i++) {
297 w =
s->seq.width >> (
i ?
s->chroma_x_shift : 0);
298 h =
s->seq.height >> (
i ?
s->chroma_y_shift : 0);
309 s->plane[
i].idwt.buf_base =
av_calloc(
w + max_xblen,
h * (2 <<
s->pshift));
311 s->plane[
i].idwt.buf =
s->plane[
i].idwt.buf_base + (top_padding*
w)*(2 <<
s->pshift);
312 if (!
s->plane[
i].idwt.buf_base || !
s->plane[
i].idwt.tmp)
320 if (!
s->sbsplit || !
s->blmotion)
327 int w =
s->seq.width;
328 int h =
s->seq.height;
333 if (
s->buffer_stride >=
stride)
335 s->buffer_stride = 0;
338 memset(
s->edge_emu_buffer, 0,
sizeof(
s->edge_emu_buffer));
347 if (!
s->edge_emu_buffer_base || !
s->mctmp || !
s->mcscratch)
359 if (
s->all_frames[
i].avframe->data[0]) {
361 memset(
s->all_frames[
i].interpolated, 0,
sizeof(
s->all_frames[
i].interpolated));
364 for (j = 0; j < 3; j++)
365 for (k = 1; k < 4; k++)
369 memset(
s->ref_frames, 0,
sizeof(
s->ref_frames));
370 memset(
s->delay_frames, 0,
sizeof(
s->delay_frames));
372 for (
i = 0;
i < 3;
i++) {
377 s->buffer_stride = 0;
394 s->frame_number = -1;
396 s->thread_buf =
NULL;
397 s->threads_num_buf = -1;
398 s->thread_buf_size = -1;
406 if (!
s->all_frames[
i].avframe) {
423 s->seen_sequence_header = 0;
424 s->frame_number = -1;
447 coeff = sign*((sign *
coeff * qfactor + qoffset) >> 2);
451 #define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
453 #define UNPACK_ARITH(n, type) \
454 static inline void coeff_unpack_arith_##n(DiracArith *c, int qfactor, int qoffset, \
455 SubBand *b, type *buf, int x, int y) \
457 int sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
459 const int mstride = -(b->stride >> (1+b->pshift)); \
461 const type *pbuf = (type *)b->parent->ibuf; \
462 const int stride = b->parent->stride >> (1+b->parent->pshift); \
463 pred_ctx += !!pbuf[stride * (y>>1) + (x>>1)] << 1; \
465 if (b->orientation == subband_hl) \
466 sign_pred = buf[mstride]; \
468 pred_ctx += !(buf[-1] | buf[mstride] | buf[-1 + mstride]); \
469 if (b->orientation == subband_lh) \
470 sign_pred = buf[-1]; \
472 pred_ctx += !buf[mstride]; \
474 coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA); \
476 coeff = (coeff * qfactor + qoffset) >> 2; \
477 sign = dirac_get_arith_bit(c, SIGN_CTX(sign_pred)); \
478 coeff = (coeff ^ -sign) + sign; \
492 int left,
int right,
int top,
int bottom,
493 int blockcnt_one,
int is_arith)
495 int x, y, zero_block;
496 int qoffset, qfactor;
510 if (
s->codeblock_mode && !(
s->old_delta_quant && blockcnt_one)) {
516 if (
quant > INT_MAX -
b->quant ||
b->quant +
quant < 0) {
536 buf =
b->ibuf + top *
b->stride;
538 for (y = top; y < bottom; y++) {
541 for (x =
left; x < right; x++) {
543 coeff_unpack_arith_10(
c, qfactor, qoffset,
b, (
int32_t*)(buf)+x, x, y);
545 coeff_unpack_arith_8(
c, qfactor, qoffset,
b, (int16_t*)(buf)+x, x, y);
551 for (y = top; y < bottom; y++) {
554 for (x =
left; x < right; x++) {
572 #define INTRA_DC_PRED(n, type) \
573 static inline void intra_dc_prediction_##n(SubBand *b) \
575 type *buf = (type*)b->ibuf; \
578 for (x = 1; x < b->width; x++) \
579 buf[x] += buf[x-1]; \
580 buf += (b->stride >> (1+b->pshift)); \
582 for (y = 1; y < b->height; y++) { \
583 buf[0] += buf[-(b->stride >> (1+b->pshift))]; \
585 for (x = 1; x < b->width; x++) { \
586 int pred = buf[x - 1] + buf[x - (b->stride >> (1+b->pshift))] + buf[x - (b->stride >> (1+b->pshift))-1]; \
587 buf[x] += divide3(pred); \
589 buf += (b->stride >> (1+b->pshift)); \
603 int cb_x, cb_y,
left, right, top, bottom;
608 int blockcnt_one = (cb_width + cb_height) == 2;
620 for (cb_y = 0; cb_y < cb_height; cb_y++) {
621 bottom = (
b->height * (cb_y+1LL)) / cb_height;
623 for (cb_x = 0; cb_x < cb_width; cb_x++) {
624 right = (
b->width * (cb_x+1LL)) / cb_width;
635 intra_dc_prediction_10(
b);
637 intra_dc_prediction_8(
b);
665 int level, num_bands = 0;
668 int damaged_count = 0;
672 for (orientation = !!
level; orientation < 4; orientation++) {
704 for (
i = 0;
i <
s->wavelet_depth * 3 + 1;
i++) {
708 if (damaged_count > (
s->wavelet_depth * 3 + 1) /2)
714 #define PARSE_VALUES(type, x, gb, ebits, buf1, buf2) \
715 type *buf = (type *)buf1; \
716 buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
717 if (get_bits_count(gb) >= ebits) \
720 buf = (type *)buf2; \
721 buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
722 if (get_bits_count(gb) >= ebits) \
727 int slice_x,
int slice_y,
int bits_end,
730 int left =
b1->width * slice_x /
s->num_x;
731 int right =
b1->width *(slice_x+1) /
s->num_x;
732 int top =
b1->height * slice_y /
s->num_y;
733 int bottom =
b1->height *(slice_y+1) /
s->num_y;
735 int qfactor, qoffset;
737 uint8_t *buf1 =
b1->ibuf + top *
b1->stride;
738 uint8_t *buf2 =
b2 ?
b2->ibuf + top *
b2->stride:
NULL;
753 for (y = top; y < bottom; y++) {
754 for (x =
left; x < right; x++) {
763 for (y = top; y < bottom; y++) {
764 for (x =
left; x < right; x++) {
793 for (orientation = !!
level; orientation < 4; orientation++) {
802 chroma_bits = 8*slice->
bytes - 7 - length_bits - luma_bits;
806 for (orientation = !!
level; orientation < 4; orientation++) {
809 &
s->plane[1].band[
level][orientation],
810 &
s->plane[2].band[
level][orientation]);
831 o->
top =
b->height * y /
s->num_y;
832 o->
left =
b->width * x /
s->num_x;
833 o->
tot_h = ((
b->width * (x + 1)) /
s->num_x) - o->
left;
834 o->
tot_v = ((
b->height * (y + 1)) /
s->num_y) - o->
top;
847 int i,
level, orientation, quant_idx;
862 for (orientation = !!
level; orientation < 4; orientation++) {
863 const int quant =
FFMAX(quant_idx -
s->lowdelay.quant[
level][orientation], 0);
870 for (
i = 0;
i < 3;
i++) {
871 int coef_num, coef_par, off = 0;
872 int64_t length =
s->highquality.size_scaler*
get_bits(gb, 8);
890 if (coef_num > coef_par) {
891 const int start_b = coef_par * (1 << (
s->pshift + 1));
892 const int end_b = coef_num * (1 << (
s->pshift + 1));
893 memset(&tmp_buf[start_b], 0, end_b - start_b);
898 for (orientation = !!
level; orientation < 4; orientation++) {
900 uint8_t *buf =
b1->ibuf +
c->top *
b1->stride + (
c->left << (
s->pshift + 1));
903 const int qfunc =
s->pshift + 2*(
c->tot_h <= 2);
904 s->diracdsp.dequant_subband[qfunc](&tmp_buf[off], buf,
b1->stride,
905 qfactor[
level][orientation],
906 qoffset[
level][orientation],
909 off +=
c->tot << (
s->pshift + 1);
924 uint8_t *thread_buf = &
s->thread_buf[
s->thread_buf_size*threadnr];
925 for (
i = 0;
i <
s->num_x;
i++)
937 int slice_x, slice_y, bufsize;
938 int64_t coef_buf_size, bytes = 0;
944 if (
s->slice_params_num_buf != (
s->num_x *
s->num_y)) {
946 if (!
s->slice_params_buf) {
948 s->slice_params_num_buf = 0;
951 s->slice_params_num_buf =
s->num_x *
s->num_y;
953 slices =
s->slice_params_buf;
958 coef_buf_size = (coef_buf_size << (1 +
s->pshift)) + 512;
961 s->thread_buf_size != coef_buf_size) {
963 s->thread_buf_size = coef_buf_size;
965 if (!
s->thread_buf) {
979 for (slice_y = 0; bufsize > 0 && slice_y <
s->num_y; slice_y++) {
980 for (slice_x = 0; bufsize > 0 && slice_x <
s->num_x; slice_x++) {
981 bytes =
s->highquality.prefix_bytes + 1;
982 for (
i = 0;
i < 3;
i++) {
983 if (bytes <= bufsize/8)
984 bytes += buf[bytes] *
s->highquality.size_scaler + 1;
986 if (bytes >= INT_MAX || bytes*8 > bufsize) {
991 slices[slice_num].
bytes = bytes;
992 slices[slice_num].
slice_x = slice_x;
993 slices[slice_num].
slice_y = slice_y;
998 if (bufsize/8 >= bytes)
1005 if (
s->num_x*
s->num_y != slice_num) {
1012 for (slice_y = 0; bufsize > 0 && slice_y <
s->num_y; slice_y++) {
1013 for (slice_x = 0; bufsize > 0 && slice_x <
s->num_x; slice_x++) {
1014 bytes = (slice_num+1) * (int64_t)
s->lowdelay.bytes.num /
s->lowdelay.bytes.den
1015 - slice_num * (int64_t)
s->lowdelay.bytes.num /
s->lowdelay.bytes.den;
1016 if (bytes >= INT_MAX || bytes*8 > bufsize) {
1020 slices[slice_num].
bytes = bytes;
1021 slices[slice_num].
slice_x = slice_x;
1022 slices[slice_num].
slice_y = slice_y;
1027 if (bufsize/8 >= bytes)
1037 if (
s->dc_prediction) {
1039 intra_dc_prediction_10(&
s->plane[0].band[0][0]);
1040 intra_dc_prediction_10(&
s->plane[1].band[0][0]);
1041 intra_dc_prediction_10(&
s->plane[2].band[0][0]);
1043 intra_dc_prediction_8(&
s->plane[0].band[0][0]);
1044 intra_dc_prediction_8(&
s->plane[1].band[0][0]);
1045 intra_dc_prediction_8(&
s->plane[2].band[0][0]);
1056 for (
i = 0;
i < 3;
i++) {
1059 p->
width =
s->seq.width >> (
i ?
s->chroma_x_shift : 0);
1060 p->
height =
s->seq.height >> (
i ?
s->chroma_y_shift : 0);
1068 for (orientation = !!
level; orientation < 4; orientation++) {
1071 b->pshift =
s->pshift;
1077 b->orientation = orientation;
1079 if (orientation & 1)
1080 b->ibuf +=
w << (1+
b->pshift);
1081 if (orientation > 1)
1082 b->ibuf += (
b->stride>>1);
1090 p->
xblen =
s->plane[0].xblen >>
s->chroma_x_shift;
1091 p->
yblen =
s->plane[0].yblen >>
s->chroma_y_shift;
1092 p->
xbsep =
s->plane[0].xbsep >>
s->chroma_x_shift;
1093 p->
ybsep =
s->plane[0].ybsep >>
s->chroma_y_shift;
1108 static const uint8_t default_blen[] = { 4, 12, 16, 24 };
1130 s->plane[0].xblen = default_blen[idx-1];
1131 s->plane[0].yblen = default_blen[idx-1];
1132 s->plane[0].xbsep = 4 * idx;
1133 s->plane[0].ybsep = 4 * idx;
1138 if (
s->plane[0].xblen % (1 <<
s->chroma_x_shift) != 0 ||
1139 s->plane[0].yblen % (1 <<
s->chroma_y_shift) != 0 ||
1140 !
s->plane[0].xblen || !
s->plane[0].yblen) {
1142 "invalid x/y block length (%d/%d) for x/y chroma shift (%d/%d)\n",
1143 s->plane[0].xblen,
s->plane[0].yblen,
s->chroma_x_shift,
s->chroma_y_shift);
1146 if (!
s->plane[0].xbsep || !
s->plane[0].ybsep ||
s->plane[0].xbsep <
s->plane[0].xblen/2 ||
s->plane[0].ybsep <
s->plane[0].yblen/2) {
1150 if (
s->plane[0].xbsep >
s->plane[0].xblen ||
s->plane[0].ybsep >
s->plane[0].yblen) {
1162 if (
s->mv_precision > 3) {
1170 if (
s->globalmc_flag) {
1171 memset(
s->globalmc, 0,
sizeof(
s->globalmc));
1187 s->globalmc[
ref].zrs[0][0] = 1;
1188 s->globalmc[
ref].zrs[1][1] = 1;
1196 if (
s->globalmc[
ref].perspective_exp + (uint64_t)
s->globalmc[
ref].zrs_exp > 30) {
1212 s->weight_log2denom = 1;
1218 if (
s->weight_log2denom < 1 ||
s->weight_log2denom > 8) {
1220 s->weight_log2denom = 1;
1224 if (
s->num_refs == 2)
1240 #define CHECKEDREAD(dst, cond, errmsg) \
1241 tmp = get_interleaved_ue_golomb(gb); \
1243 av_log(s->avctx, AV_LOG_ERROR, errmsg); \
1244 return AVERROR_INVALIDDATA; \
1259 if (!
s->low_delay) {
1262 for (
i = 0;
i <=
s->wavelet_depth;
i++) {
1263 CHECKEDREAD(
s->codeblock[
i].width , tmp < 1 || tmp > (
s->avctx->width >>
s->wavelet_depth-
i),
"codeblock width invalid\n")
1264 CHECKEDREAD(
s->codeblock[
i].height, tmp < 1 || tmp > (
s->avctx->height>>
s->wavelet_depth-
i),
"codeblock height invalid\n")
1270 for (
i = 0;
i <=
s->wavelet_depth;
i++)
1271 s->codeblock[
i].width =
s->codeblock[
i].height = 1;
1277 if (
s->num_x *
s->num_y == 0 ||
s->num_x * (uint64_t)
s->num_y > INT_MAX ||
1278 s->num_x * (uint64_t)
s->avctx->width > INT_MAX ||
1279 s->num_y * (uint64_t)
s->avctx->height > INT_MAX ||
1280 s->num_x >
s->avctx->width ||
1281 s->num_y >
s->avctx->height
1284 s->num_x =
s->num_y = 0;
1287 if (
s->ld_picture) {
1290 if (
s->lowdelay.bytes.den <= 0) {
1294 }
else if (
s->hq_picture) {
1297 if (
s->highquality.prefix_bytes >= INT_MAX / 8) {
1313 if (
s->wavelet_depth > 4) {
1314 av_log(
s->avctx,
AV_LOG_ERROR,
"Mandatory custom low delay matrix missing for depth %d\n",
s->wavelet_depth);
1319 for (
i = 0;
i < 4;
i++) {
1322 if (
s->wavelet_idx == 3)
1323 s->lowdelay.quant[
level][
i] += 4*(
s->wavelet_depth-1 -
level);
1332 static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1341 return avgsplit[sbsplit[-1] + sbsplit[-
stride] + sbsplit[-
stride-1]];
1351 return block[-1].ref & refmask;
1357 return (
pred >> 1) & refmask;
1367 for (
i = 0;
i < 3;
i++)
1373 for (
i = 0;
i < 3;
i++)
1379 for (
i = 0;
i < 3;
i++)
1385 for (
i = 0;
i < 3;
i++)
1387 }
else if (n == 3) {
1388 for (
i = 0;
i < 3;
i++)
1396 int refmask =
ref+1;
1431 int ez =
s->globalmc[
ref].zrs_exp;
1432 int ep =
s->globalmc[
ref].perspective_exp;
1433 int (*
A)[2] =
s->globalmc[
ref].zrs;
1434 int *
b =
s->globalmc[
ref].pan_tilt;
1435 int *
c =
s->globalmc[
ref].perspective;
1437 int64_t m = (1<<ep) - (
c[0]*(int64_t)x +
c[1]*(int64_t)y);
1438 int64_t mx = m * (uint64_t)((
A[0][0] * (int64_t)x +
A[0][1]*(int64_t)y) + (1LL<<ez) *
b[0]);
1439 int64_t my = m * (uint64_t)((
A[1][0] * (int64_t)x +
A[1][1]*(int64_t)y) + (1LL<<ez) *
b[1]);
1441 block->u.mv[
ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1442 block->u.mv[
ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1446 int stride,
int x,
int y)
1453 if (
s->num_refs == 2) {
1460 for (
i = 0;
i < 3;
i++)
1465 if (
s->globalmc_flag) {
1470 for (
i = 0;
i <
s->num_refs;
i++)
1471 if (
block->ref & (
i+1)) {
1490 for (x = 1; x <
size; x++)
1493 for (y = 1; y <
size; y++) {
1495 for (x = 0; x <
size; x++)
1507 uint8_t *sbsplit =
s->sbsplit;
1514 s->sbwidth =
DIVRNDUP(
s->seq.width, 4*
s->plane[0].xbsep);
1515 s->sbheight =
DIVRNDUP(
s->seq.height, 4*
s->plane[0].ybsep);
1516 s->blwidth = 4 *
s->sbwidth;
1517 s->blheight = 4 *
s->sbheight;
1522 for (y = 0; y <
s->sbheight; y++) {
1523 for (x = 0; x <
s->sbwidth; x++) {
1529 sbsplit +=
s->sbwidth;
1534 for (
i = 0;
i <
s->num_refs;
i++) {
1538 for (
i = 0;
i < 3;
i++)
1541 for (y = 0; y <
s->sbheight; y++)
1542 for (x = 0; x <
s->sbwidth; x++) {
1543 int blkcnt = 1 <<
s->sbsplit[y *
s->sbwidth + x];
1544 int step = 4 >>
s->sbsplit[y *
s->sbwidth + x];
1546 for (q = 0; q < blkcnt; q++)
1547 for (p = 0; p < blkcnt; p++) {
1548 int bx = 4 * x + p*
step;
1549 int by = 4 * y + q*
step;
1556 for (
i = 0;
i < 4 + 2*
s->num_refs;
i++) {
1566 #define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) : \
1567 (1 + (6*(i) + offset - 1) / (2*offset - 1))
1571 else if (
i > blen-1 - 2*
offset)
1577 int left,
int right,
int wy)
1580 for (x = 0;
left && x < p->
xblen >> 1; x++)
1581 obmc_weight[x] = wy*8;
1582 for (; x < p->
xblen >> right; x++)
1584 for (; x < p->
xblen; x++)
1585 obmc_weight[x] = wy*8;
1591 int left,
int right,
int top,
int bottom)
1594 for (y = 0; top && y < p->
yblen >> 1; y++) {
1598 for (; y < p->
yblen >> bottom; y++) {
1603 for (; y < p->
yblen; y++) {
1612 int bottom = by ==
s->blheight-1;
1615 if (top || bottom || by == 1) {
1650 int x,
int y,
int ref,
int plane)
1652 Plane *p = &
s->plane[plane];
1653 uint8_t **ref_hpel =
s->ref_pics[
ref]->hpel[plane];
1654 int motion_x =
block->u.mv[
ref][0];
1655 int motion_y =
block->u.mv[
ref][1];
1656 int mx, my,
i, epel, nplanes = 0;
1659 motion_x >>=
s->chroma_x_shift;
1660 motion_y >>=
s->chroma_y_shift;
1663 mx = motion_x & ~(-1
U <<
s->mv_precision);
1664 my = motion_y & ~(-1
U <<
s->mv_precision);
1665 motion_x >>=
s->mv_precision;
1666 motion_y >>=
s->mv_precision;
1669 mx <<= 3 -
s->mv_precision;
1670 my <<= 3 -
s->mv_precision;
1679 src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->
stride + x;
1683 for (
i = 0;
i < 4;
i++)
1708 src[!mx] =
src[2 + !!mx];
1710 }
else if (!(my&3)) {
1733 for (
i = 0;
i < nplanes;
i++) {
1734 s->vdsp.emulated_edge_mc(
s->edge_emu_buffer[
i],
src[
i],
1738 src[
i] =
s->edge_emu_buffer[
i];
1741 return (nplanes>>1) + epel;
1745 uint8_t *obmc_weight,
int xblen,
int yblen)
1750 for (y = 0; y < yblen; y++) {
1751 for (x = 0; x < xblen; x += 2) {
1752 dst[x ] +=
dc * obmc_weight[x ];
1753 dst[x+1] +=
dc * obmc_weight[x+1];
1761 uint16_t *mctmp, uint8_t *obmc_weight,
1762 int plane,
int dstx,
int dsty)
1764 Plane *p = &
s->plane[plane];
1765 const uint8_t *
src[5];
1768 switch (
block->ref&3) {
1777 s->weight_func(
s->mcscratch, p->
stride,
s->weight_log2denom,
1778 s->weight[0] +
s->weight[1], p->
yblen);
1784 if (
s->biweight_func) {
1787 s->biweight_func(
s->mcscratch,
s->mcscratch+32, p->
stride,
s->weight_log2denom,
1788 s->weight[0],
s->weight[1], p->
yblen);
1793 s->add_obmc(mctmp,
s->mcscratch, p->
stride, obmc_weight, p->
yblen);
1798 Plane *p = &
s->plane[plane];
1804 for (x = 1; x <
s->blwidth-1; x++) {
1820 memcpy(
s->put_pixels_tab,
s->diracdsp.put_dirac_pixels_tab[idx],
sizeof(
s->put_pixels_tab));
1821 memcpy(
s->avg_pixels_tab,
s->diracdsp.avg_dirac_pixels_tab[idx],
sizeof(
s->avg_pixels_tab));
1822 s->add_obmc =
s->diracdsp.add_dirac_obmc[idx];
1823 if (
s->weight_log2denom > 1 ||
s->weight[0] != 1 ||
s->weight[1] != 1) {
1824 s->weight_func =
s->diracdsp.weight_dirac_pixels_tab[idx];
1825 s->biweight_func =
s->diracdsp.biweight_dirac_pixels_tab[idx];
1827 s->weight_func =
NULL;
1828 s->biweight_func =
NULL;
1839 ref->hpel[plane][0] =
ref->avframe->data[plane];
1843 if (!
s->mv_precision)
1846 for (
i = 1;
i < 4;
i++) {
1847 if (!
ref->hpel_base[plane][
i])
1849 if (!
ref->hpel_base[plane][
i]) {
1853 ref->hpel[plane][
i] =
ref->hpel_base[plane][
i] + edge*
ref->avframe->linesize[plane] + 16;
1856 if (!
ref->interpolated[plane]) {
1857 s->diracdsp.dirac_hpel_filter(
ref->hpel[plane][1],
ref->hpel[plane][2],
1858 ref->hpel[plane][3],
ref->hpel[plane][0],
1864 ref->interpolated[plane] = 1;
1876 int y,
i,
comp, dsty;
1881 if (!
s->hq_picture) {
1895 uint8_t *
frame =
s->current_picture->avframe->data[
comp];
1898 for (
i = 0;
i < 4;
i++)
1901 if (!
s->zero_res && !
s->low_delay)
1909 s->wavelet_depth,
s->bit_depth);
1914 for (y = 0; y < p->
height; y += 16) {
1915 int idx = (
s->bit_depth - 8) >> 1;
1917 s->diracdsp.put_signed_rect_clamped[idx](
frame + y*p->
stride,
1927 for (
i = 0;
i <
s->num_refs;
i++) {
1936 for (y = 0; y <
s->blheight; y++) {
1938 start =
FFMAX(dsty, 0);
1939 uint16_t *mctmp =
s->mctmp + y*rowheight;
1947 h = p->
ybsep - (start - dsty);
1973 int chroma_x_shift, chroma_y_shift;
1985 for (
i = 0;
f->data[
i];
i++) {
1987 f->linesize[
i] + 32;
2002 unsigned retire, picnum;
2004 int64_t refdist, refnum;
2008 picnum =
s->current_picture->picture_number =
get_bits_long(gb, 32);
2015 if (
s->frame_number < 0)
2016 s->frame_number = picnum;
2018 s->ref_pics[0] =
s->ref_pics[1] =
NULL;
2019 for (
i = 0;
i <
s->num_refs;
i++) {
2021 refdist = INT64_MAX;
2026 if (
s->ref_frames[j]
2027 &&
FFABS(
s->ref_frames[j]->picture_number - refnum) < refdist) {
2028 s->ref_pics[
i] =
s->ref_frames[j];
2029 refdist =
FFABS(
s->ref_frames[j]->picture_number - refnum);
2032 if (!
s->ref_pics[
i] || refdist)
2036 if (!
s->ref_pics[
i])
2038 if (!
s->all_frames[j].avframe->data[0]) {
2039 s->ref_pics[
i] = &
s->all_frames[j];
2046 if (!
s->ref_pics[
i]) {
2054 if (
s->current_picture->reference) {
2056 if (retire != picnum) {
2095 for (
i = 1;
s->delay_frames[
i];
i++)
2096 if (
s->delay_frames[
i]->picture_number <
out->picture_number) {
2097 out =
s->delay_frames[
i];
2101 for (
i = out_idx;
s->delay_frames[
i];
i++)
2102 s->delay_frames[
i] =
s->delay_frames[
i+1];
2119 #define DATA_UNIT_HEADER_SIZE 13
2135 parse_code = buf[4];
2140 if (
s->seen_sequence_header)
2174 s->pshift =
s->bit_depth > 8;
2178 &
s->chroma_y_shift);
2186 s->seen_sequence_header = 1;
2189 s->seen_sequence_header = 0;
2195 if (sscanf(buf+14,
"Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
2196 if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
2197 s->old_delta_quant = 1;
2199 }
else if (parse_code & 0x8) {
2200 if (!
s->seen_sequence_header) {
2207 if (
s->all_frames[
i].avframe->data[0] ==
NULL)
2208 pic = &
s->all_frames[
i];
2217 tmp = parse_code & 0x03;
2223 s->is_arith = (parse_code & 0x48) == 0x08;
2224 s->low_delay = (parse_code & 0x88) == 0x88;
2225 s->core_syntax = (parse_code & 0x88) == 0x08;
2226 s->ld_picture = (parse_code & 0xF8) == 0xC8;
2227 s->hq_picture = (parse_code & 0xF8) == 0xE8;
2228 s->dc_prediction = (parse_code & 0x28) == 0x08;
2229 pic->
reference = (parse_code & 0x0C) == 0x0C;
2230 if (
s->num_refs == 0)
2237 if (
s->version.minor == 2 && parse_code == 0x88)
2240 if (
s->low_delay && !(
s->ld_picture ||
s->hq_picture) ) {
2247 s->current_picture = pic;
2272 const uint8_t *buf =
pkt->
data;
2276 unsigned data_unit_size;
2280 if (
s->all_frames[
i].avframe->data[0] && !
s->all_frames[
i].reference) {
2282 memset(
s->all_frames[
i].interpolated, 0,
sizeof(
s->all_frames[
i].interpolated));
2285 s->current_picture =
NULL;
2297 if (buf[buf_idx ] ==
'B' && buf[buf_idx+1] ==
'B' &&
2298 buf[buf_idx+2] ==
'C' && buf[buf_idx+3] ==
'D')
2305 data_unit_size =
AV_RB32(buf+buf_idx+5);
2306 if (data_unit_size > buf_size - buf_idx || !data_unit_size) {
2307 if(data_unit_size > buf_size - buf_idx)
2309 "Data unit with size %d is larger than input buffer, discarding\n",
2321 buf_idx += data_unit_size;
2324 if (!
s->current_picture)
2327 if (
s->current_picture->picture_number >
s->frame_number) {
2333 unsigned min_num =
s->delay_frames[0]->picture_number;
2337 for (
i = 1;
s->delay_frames[
i];
i++)
2338 if (
s->delay_frames[
i]->picture_number < min_num)
2339 min_num =
s->delay_frames[
i]->picture_number;
2345 if (delayed_frame) {
2352 }
else if (
s->current_picture->picture_number ==
s->frame_number) {
2356 s->frame_number =
s->current_picture->picture_number + 1LL;
static void error(const char *err)
#define DATA_UNIT_HEADER_SIZE
Dirac Specification -> 9.6 Parse Info Header Syntax.
void(* put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
int av_dirac_parse_sequence_header(AVDiracSeqHeader **pdsh, const uint8_t *buf, size_t buf_size, void *log_ctx)
Parse a Dirac sequence header.
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
static int get_bits_left(GetBitContext *gb)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
enum AVColorSpace colorspace
YUV colorspace type.
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
#define u(width, name, range_min, range_max)
#define MAX_DWT_LEVELS
The spec limits the number of wavelet decompositions to 4 for both level 1 (VC-2) and 128 (long-gop d...
static void free_sequence_buffers(DiracContext *s)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static const uint8_t epel_weights[4][4][4]
static int dirac_decode_picture_header(DiracContext *s)
Dirac Specification -> 11.1.1 Picture Header.
static const int8_t mv[256][2]
static int get_bits_count(const GetBitContext *s)
static int dirac_unpack_prediction_parameters(DiracContext *s)
Unpack the motion compensation parameters Dirac Specification -> 11.2 Picture prediction data.
#define DIRAC_REF_MASK_REF1
DiracBlock->ref flags, if set then the block does MC from the given ref.
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
dirac_biweight_func biweight_func
static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
Dirac Specification -> 13.5.2 Slices.
MpegvideoEncDSPContext mpvencdsp
void(* dirac_biweight_func)(uint8_t *dst, const uint8_t *src, int stride, int log2_denom, int weightd, int weights, int h)
static void init_planes(DiracContext *s)
struct DiracContext::@89 lowdelay
#define DIRAC_REF_MASK_GLOBAL
static AVOnce dirac_arith_init
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
DiracFrame * delay_frames[MAX_DELAY+1]
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
const int32_t ff_dirac_qscale_tab[116]
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
static int dirac_get_arith_int(DiracArith *c, int follow_ctx, int data_ctx)
#define CHECKEDREAD(dst, cond, errmsg)
static void decode_subband(const DiracContext *s, GetBitContext *gb, int quant, int slice_x, int slice_y, int bits_end, const SubBand *b1, const SubBand *b2)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
DiracFrame * current_picture
static int alloc_buffers(DiracContext *s, int stride)
const uint8_t ff_dirac_default_qmat[7][4][4]
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
static int decode_subband_arith(AVCodecContext *avctx, void *b)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static int codeblock(const DiracContext *s, SubBand *b, GetBitContext *gb, DiracArith *c, int left, int right, int top, int bottom, int blockcnt_one, int is_arith)
Decode the coeffs in the rectangle defined by left, right, top, bottom [DIRAC_STD] 13....
AVCodec p
The public AVCodec.
static double b1(void *priv, double x, double y)
uint8_t * edge_emu_buffer[4]
int ff_spatial_idwt_init(DWTContext *d, DWTPlane *p, enum dwt_type type, int decomposition_count, int bit_depth)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
static double val(void *priv, double ch)
static int dirac_unpack_block_motion_data(DiracContext *s)
Dirac Specification ->
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
static int decode_component(DiracContext *s, int comp)
Dirac Specification -> [DIRAC_STD] 13.4.1 core_transform_data()
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
static int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
static void pred_block_dc(DiracBlock *block, int stride, int x, int y)
static av_always_inline int decode_subband_internal(const DiracContext *s, SubBand *b, int is_arith)
Dirac Specification -> 13.4.2 Non-skipped subbands.
static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static const uint8_t quant[64]
void(* dirac_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int h)
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static int ff_thread_once(char *control, void(*routine)(void))
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
static const uint16_t mask[17]
const FFCodec ff_dirac_decoder
#define FF_CODEC_DECODE_CB(func)
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
#define MAX_REFERENCE_FRAMES
The spec limits this to 3 for frame coding, but in practice can be as high as 6.
void ff_dirac_init_arith_decoder(DiracArith *c, GetBitContext *gb, int length)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int64_t max_pixels
The number of pixels per image to maximally accept.
static const float bands[]
#define CODEC_LONG_NAME(str)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define av_realloc_f(p, o, n)
DiracSlice * slice_params_buf
uint8_t * edge_emu_buffer_base
static int dirac_get_arith_bit(DiracArith *c, int ctx)
static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
const int ff_dirac_qoffset_inter_tab[122]
static int decode_hq_slice_row(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
dirac_weight_func weight_func
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static int dirac_decode_frame_internal(DiracContext *s)
Dirac Specification -> 13.0 Transform data syntax.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
static int decode_lowdelay(DiracContext *s)
Dirac Specification -> 13.5.1 low_delay_transform_data()
static int subband_coeffs(const DiracContext *s, int x, int y, int p, SliceCoeffs c[MAX_DWT_LEVELS])
Rational number (pair of numerator and denominator).
DiracFrame * ref_frames[MAX_REFERENCE_FRAMES+1]
static unsigned int get_bits1(GetBitContext *s)
unsigned old_delta_quant
schroedinger older than 1.0.8 doesn't store quant delta if only one codebook exists in a band
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
static int dirac_get_arith_uint(DiracArith *c, int follow_ctx, int data_ctx)
#define DIRAC_MAX_QUANT_INDEX
struct DiracContext::@90 highquality
int level
Encoding level descriptor.
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
static int weight(int i, int blen, int offset)
void ff_spatial_idwt_slice2(DWTContext *d, int y)
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output.
static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
#define INTRA_DC_PRED(n, type)
Dirac Specification -> 13.3 intra_dc_prediction(band)
static av_cold int dirac_decode_end(AVCodecContext *avctx)
enum AVPictureType pict_type
Picture type of the frame.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
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]
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
#define DECLARE_ALIGNED(n, t, v)
static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride, int left, int right, int wy)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
unsigned weight_log2denom
static char * split(char *message, char delim)
static double b2(void *priv, double x, double y)
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
static int dirac_get_se_golomb(GetBitContext *gb)
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
static void add_dc(uint16_t *dst, int dc, int stride, uint8_t *obmc_weight, int xblen, int yblen)
static int get_buffer_with_edge(AVCodecContext *avctx, AVFrame *f, int flags)
static int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
static void init_obmc_weights(DiracContext *s, Plane *p, int by)
struct DiracContext::@88 codeblock[MAX_DWT_LEVELS+1]
static int dirac_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *pkt)
#define i(width, name, range_min, range_max)
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
#define UNPACK_ARITH(n, type)
static int alloc_sequence_buffers(DiracContext *s)
#define DIRAC_REF_MASK_REF2
#define PARSE_VALUES(type, x, gb, ebits, buf1, buf2)
static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block, int stride, int x, int y)
static int decode_hq_slice(const DiracContext *s, DiracSlice *slice, uint8_t *tmp_buf)
VC-2 Specification -> 13.5.3 hq_slice(sx,sy)
int ff_dirac_golomb_read_16bit(const uint8_t *buf, int bytes, uint8_t *_dst, int coeffs)
#define av_malloc_array(a, b)
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
av_cold void ff_dirac_init_arith_tables(void)
const char * name
Name of the codec implementation.
static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5], int x, int y, int ref, int plane)
For block x,y, determine which of the hpel planes to do bilinear interpolation from and set src[] to ...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void * av_calloc(size_t nmemb, size_t size)
static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
const uint8_t * coeff_data
static const float pred[4]
#define FFSWAP(type, a, b)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static const uint8_t * align_get_bits(GetBitContext *s)
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 left
static DiracFrame * remove_frame(DiracFrame *framelist[], unsigned picnum)
int ff_dirac_golomb_read_32bit(const uint8_t *buf, int bytes, uint8_t *_dst, int coeffs)
static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
const int32_t ff_dirac_qoffset_intra_tab[120]
void(* add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen)
main external API structure.
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
DiracFrame all_frames[MAX_FRAMES]
#define CALC_PADDING(size, depth)
static int ref[MAX_W *MAX_W]
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
struct DiracContext::@91 globalmc[2]
static int divide3(int x)
uint8_t quant[MAX_DWT_LEVELS][4]
SubBand band[DWT_LEVELS_3D][4]
static void propagate_block_data(DiracBlock *block, int stride, int size)
Copies the current block to the other blocks covered by the current superblock split mode.
This structure stores compressed data.
static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
void(* avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
int width
picture width / height.
#define flags(name, subs,...)
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
The exact code depends on how similar the blocks are and how related they are to the block
static const double coeff[2][5]
static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static av_cold int dirac_decode_init(AVCodecContext *avctx)
av_cold void ff_diracdsp_init(DiracDSPContext *c)
static int dirac_unpack_idwt_params(DiracContext *s)
Dirac Specification -> 11.3 Wavelet transform data.
uint8_t obmc_weight[3][MAX_BLOCKSIZE *MAX_BLOCKSIZE]
static void dirac_decode_flush(AVCodecContext *avctx)
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride, int left, int right, int top, int bottom)
static void block_mc(DiracContext *s, DiracBlock *block, uint16_t *mctmp, uint8_t *obmc_weight, int plane, int dstx, int dsty)