|
|
@@ -170,6 +170,8 @@ static const AVOption stereo3d_options[] = { |
|
|
|
{ "sbsr", "side by side right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_RL}, 0, 0, FLAGS, "in" }, |
|
|
|
{ "irl", "interleave rows left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_LR}, 0, 0, FLAGS, "in" }, |
|
|
|
{ "irr", "interleave rows right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_RL}, 0, 0, FLAGS, "in" }, |
|
|
|
{ "icl", "interleave columns left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_LR}, 0, 0, FLAGS, "in" }, |
|
|
|
{ "icr", "interleave columns right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_RL}, 0, 0, FLAGS, "in" }, |
|
|
|
{ "out", "set output format", OFFSET(out.format), AV_OPT_TYPE_INT, {.i64=ANAGLYPH_RC_DUBOIS}, 0, STEREO_CODE_COUNT-1, FLAGS, "out"}, |
|
|
|
{ "ab2l", "above below half height left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_LR}, 0, 0, FLAGS, "out" }, |
|
|
|
{ "ab2r", "above below half height right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_RL}, 0, 0, FLAGS, "out" }, |
|
|
@@ -312,6 +314,26 @@ static inline uint8_t ana_convert(const int *coeff, const uint8_t *left, const u |
|
|
|
return av_clip_uint8(sum >> 16); |
|
|
|
} |
|
|
|
|
|
|
|
static void anaglyph_ic(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc, |
|
|
|
ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize, |
|
|
|
int width, int height, |
|
|
|
const int *ana_matrix_r, const int *ana_matrix_g, const int *ana_matrix_b) |
|
|
|
{ |
|
|
|
int x, y, o; |
|
|
|
|
|
|
|
for (y = 0; y < height; y++) { |
|
|
|
for (o = 0, x = 0; x < width; x++, o+= 3) { |
|
|
|
dst[o ] = ana_convert(ana_matrix_r, lsrc + o * 2, rsrc + o * 2); |
|
|
|
dst[o + 1] = ana_convert(ana_matrix_g, lsrc + o * 2, rsrc + o * 2); |
|
|
|
dst[o + 2] = ana_convert(ana_matrix_b, lsrc + o * 2, rsrc + o * 2); |
|
|
|
} |
|
|
|
|
|
|
|
dst += dst_linesize; |
|
|
|
lsrc += l_linesize; |
|
|
|
rsrc += r_linesize; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
static void anaglyph(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc, |
|
|
|
ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize, |
|
|
|
int width, int height, |
|
|
@@ -344,6 +366,8 @@ static int config_output(AVFilterLink *outlink) |
|
|
|
int ret; |
|
|
|
|
|
|
|
switch (s->in.format) { |
|
|
|
case INTERLEAVE_COLS_LR: |
|
|
|
case INTERLEAVE_COLS_RL: |
|
|
|
case SIDE_BY_SIDE_2_LR: |
|
|
|
case SIDE_BY_SIDE_LR: |
|
|
|
case SIDE_BY_SIDE_2_RL: |
|
|
@@ -408,6 +432,10 @@ static int config_output(AVFilterLink *outlink) |
|
|
|
fps.den *= 2; |
|
|
|
tb.num *= 2; |
|
|
|
break; |
|
|
|
case INTERLEAVE_COLS_RL: |
|
|
|
case INTERLEAVE_COLS_LR: |
|
|
|
s->width = inlink->w / 2; |
|
|
|
break; |
|
|
|
case INTERLEAVE_ROWS_LR: |
|
|
|
case INTERLEAVE_ROWS_RL: |
|
|
|
s->in.row_step = 2; |
|
|
@@ -504,8 +532,10 @@ static int config_output(AVFilterLink *outlink) |
|
|
|
s->out.off_lstep = 1; |
|
|
|
break; |
|
|
|
case MONO_R: |
|
|
|
s->in.off_left = s->in.off_right; |
|
|
|
s->in.row_left = s->in.row_right; |
|
|
|
if (s->in.format != INTERLEAVE_COLS_LR) { |
|
|
|
s->in.off_left = s->in.off_right; |
|
|
|
s->in.row_left = s->in.row_right; |
|
|
|
} |
|
|
|
if (s->in.format == INTERLEAVE_ROWS_LR) |
|
|
|
FFSWAP(int, s->in.off_lstep, s->in.off_rstep); |
|
|
|
break; |
|
|
@@ -531,6 +561,17 @@ static int config_output(AVFilterLink *outlink) |
|
|
|
return AVERROR(EINVAL); |
|
|
|
} |
|
|
|
|
|
|
|
if (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) { |
|
|
|
if ((s->in.format & 1) != (s->out.format & 1)) { |
|
|
|
FFSWAP(int, s->in.row_left, s->in.row_right); |
|
|
|
FFSWAP(int, s->in.off_lstep, s->in.off_rstep); |
|
|
|
FFSWAP(int, s->in.off_left, s->in.off_right); |
|
|
|
FFSWAP(int, s->out.row_left, s->out.row_right); |
|
|
|
FFSWAP(int, s->out.off_lstep, s->out.off_rstep); |
|
|
|
FFSWAP(int, s->out.off_left, s->out.off_right); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
outlink->w = s->out.width; |
|
|
|
outlink->h = s->out.height; |
|
|
|
outlink->frame_rate = fps; |
|
|
@@ -582,6 +623,43 @@ static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
static void interleave_cols_to_any(Stereo3DContext *s, int *out_off, int p, AVFrame *in, AVFrame *out, int d) |
|
|
|
{ |
|
|
|
int y, x; |
|
|
|
|
|
|
|
for (y = 0; y < s->pheight[p]; y++) { |
|
|
|
const uint8_t *src = (const uint8_t*)in->data[p] + y * in->linesize[p] + d * s->pixstep[p]; |
|
|
|
uint8_t *dst = out->data[p] + out_off[p] + y * out->linesize[p] * s->out.row_step; |
|
|
|
|
|
|
|
switch (s->pixstep[p]) { |
|
|
|
case 1: |
|
|
|
for (x = 0; x < s->linesize[p]; x++) |
|
|
|
dst[x] = src[x * 2]; |
|
|
|
break; |
|
|
|
case 2: |
|
|
|
for (x = 0; x < s->linesize[p]; x+=2) |
|
|
|
AV_WN16(&dst[x], AV_RN16(&src[x * 2])); |
|
|
|
break; |
|
|
|
case 3: |
|
|
|
for (x = 0; x < s->linesize[p]; x+=3) |
|
|
|
AV_WB24(&dst[x], AV_RB24(&src[x * 2])); |
|
|
|
break; |
|
|
|
case 4: |
|
|
|
for (x = 0; x < s->linesize[p]; x+=4) |
|
|
|
AV_WN32(&dst[x], AV_RN32(&src[x * 2])); |
|
|
|
break; |
|
|
|
case 6: |
|
|
|
for (x = 0; x < s->linesize[p]; x+=6) |
|
|
|
AV_WB48(&dst[x], AV_RB48(&src[x * 2])); |
|
|
|
break; |
|
|
|
case 8: |
|
|
|
for (x = 0; x < s->linesize[p]; x+=8) |
|
|
|
AV_WN64(&dst[x], AV_RN64(&src[x * 2])); |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref) |
|
|
|
{ |
|
|
|
AVFilterContext *ctx = inlink->dst; |
|
|
@@ -761,17 +839,27 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref) |
|
|
|
case INTERLEAVE_ROWS_LR: |
|
|
|
case INTERLEAVE_ROWS_RL: |
|
|
|
copy: |
|
|
|
for (i = 0; i < s->nb_planes; i++) { |
|
|
|
av_image_copy_plane(oleft->data[i] + out_off_left[i], |
|
|
|
oleft->linesize[i] * s->out.row_step, |
|
|
|
ileft->data[i] + s->in_off_left[i], |
|
|
|
ileft->linesize[i] * s->in.row_step, |
|
|
|
s->linesize[i], s->pheight[i]); |
|
|
|
av_image_copy_plane(oright->data[i] + out_off_right[i], |
|
|
|
oright->linesize[i] * s->out.row_step, |
|
|
|
iright->data[i] + s->in_off_right[i], |
|
|
|
iright->linesize[i] * s->in.row_step, |
|
|
|
s->linesize[i], s->pheight[i]); |
|
|
|
if (s->in.format == INTERLEAVE_COLS_LR || |
|
|
|
s->in.format == INTERLEAVE_COLS_RL) { |
|
|
|
for (i = 0; i < s->nb_planes; i++) { |
|
|
|
int d = (s->in.format & 1) != (s->out.format & 1); |
|
|
|
|
|
|
|
interleave_cols_to_any(s, out_off_left, i, ileft, oleft, d); |
|
|
|
interleave_cols_to_any(s, out_off_right, i, iright, oright, !d); |
|
|
|
} |
|
|
|
} else { |
|
|
|
for (i = 0; i < s->nb_planes; i++) { |
|
|
|
av_image_copy_plane(oleft->data[i] + out_off_left[i], |
|
|
|
oleft->linesize[i] * s->out.row_step, |
|
|
|
ileft->data[i] + s->in_off_left[i], |
|
|
|
ileft->linesize[i] * s->in.row_step, |
|
|
|
s->linesize[i], s->pheight[i]); |
|
|
|
av_image_copy_plane(oright->data[i] + out_off_right[i], |
|
|
|
oright->linesize[i] * s->out.row_step, |
|
|
|
iright->data[i] + s->in_off_right[i], |
|
|
|
iright->linesize[i] * s->in.row_step, |
|
|
|
s->linesize[i], s->pheight[i]); |
|
|
|
} |
|
|
|
} |
|
|
|
break; |
|
|
|
case MONO_L: |
|
|
@@ -798,6 +886,14 @@ copy: |
|
|
|
out->data[i] += s->in_off_left[i]; |
|
|
|
} |
|
|
|
break; |
|
|
|
case INTERLEAVE_COLS_LR: |
|
|
|
case INTERLEAVE_COLS_RL: |
|
|
|
for (i = 0; i < s->nb_planes; i++) { |
|
|
|
const int d = (s->in.format & 1) != (s->out.format & 1); |
|
|
|
|
|
|
|
interleave_cols_to_any(s, out_off_right, i, iright, out, d); |
|
|
|
} |
|
|
|
break; |
|
|
|
default: |
|
|
|
for (i = 0; i < s->nb_planes; i++) { |
|
|
|
av_image_copy_plane(out->data[i], out->linesize[i], |
|
|
@@ -822,11 +918,25 @@ copy: |
|
|
|
case ANAGLYPH_YB_HALF: |
|
|
|
case ANAGLYPH_YB_COLOR: |
|
|
|
case ANAGLYPH_YB_DUBOIS: { |
|
|
|
ThreadData td; |
|
|
|
if (s->in.format == INTERLEAVE_COLS_LR || |
|
|
|
s->in.format == INTERLEAVE_COLS_RL) { |
|
|
|
const int d = (s->in.format & 1); |
|
|
|
|
|
|
|
anaglyph_ic(out->data[0], |
|
|
|
ileft ->data[0] + s->in_off_left [0] + d * 3, |
|
|
|
iright->data[0] + s->in_off_right[0] + (!d) * 3, |
|
|
|
out->linesize[0], |
|
|
|
ileft->linesize[0] * s->in.row_step, |
|
|
|
iright->linesize[0] * s->in.row_step, |
|
|
|
s->out.width, s->out.height, |
|
|
|
s->ana_matrix[0], s->ana_matrix[1], s->ana_matrix[2]); |
|
|
|
} else { |
|
|
|
ThreadData td; |
|
|
|
|
|
|
|
td.ileft = ileft; td.iright = iright; td.out = out; |
|
|
|
ctx->internal->execute(ctx, filter_slice, &td, NULL, |
|
|
|
FFMIN(s->out.height, ctx->graph->nb_threads)); |
|
|
|
td.ileft = ileft; td.iright = iright; td.out = out; |
|
|
|
ctx->internal->execute(ctx, filter_slice, &td, NULL, |
|
|
|
FFMIN(s->out.height, ctx->graph->nb_threads)); |
|
|
|
} |
|
|
|
break; |
|
|
|
} |
|
|
|
case CHECKERBOARD_RL: |
|
|
@@ -836,47 +946,50 @@ copy: |
|
|
|
|
|
|
|
for (y = 0; y < s->pheight[i]; y++) { |
|
|
|
uint8_t *dst = out->data[i] + out->linesize[i] * y; |
|
|
|
uint8_t *left = ileft->data[i] + ileft->linesize[i] * y + s->in_off_left[i]; |
|
|
|
uint8_t *right = iright->data[i] + iright->linesize[i] * y + s->in_off_right[i]; |
|
|
|
const int d1 = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) && (s->in.format & 1) != (s->out.format & 1); |
|
|
|
const int d2 = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) ? !d1 : 0; |
|
|
|
const int m = 1 + (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL); |
|
|
|
uint8_t *left = ileft->data[i] + ileft->linesize[i] * y + s->in_off_left[i] + d1 * s->pixstep[i]; |
|
|
|
uint8_t *right = iright->data[i] + iright->linesize[i] * y + s->in_off_right[i] + d2 * s->pixstep[i]; |
|
|
|
int p, b; |
|
|
|
|
|
|
|
if (s->out.format == CHECKERBOARD_RL) |
|
|
|
if (s->out.format == CHECKERBOARD_RL && s->in.format != INTERLEAVE_COLS_LR && s->in.format != INTERLEAVE_COLS_RL) |
|
|
|
FFSWAP(uint8_t*, left, right); |
|
|
|
switch (s->pixstep[i]) { |
|
|
|
case 1: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=2, p++, b++) { |
|
|
|
dst[x ] = (b&1) == (y&1) ? left[p] : right[p]; |
|
|
|
dst[x+1] = (b&1) != (y&1) ? left[p] : right[p]; |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=2, p++, b+=2) { |
|
|
|
dst[x ] = (b&1) == (y&1) ? left[p*m] : right[p*m]; |
|
|
|
dst[x+1] = (b&1) != (y&1) ? left[p*m] : right[p*m]; |
|
|
|
} |
|
|
|
break; |
|
|
|
case 2: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=4, p+=2, b++) { |
|
|
|
AV_WN16(&dst[x ], (b&1) == (y&1) ? AV_RN16(&left[p]) : AV_RN16(&right[p])); |
|
|
|
AV_WN16(&dst[x+2], (b&1) != (y&1) ? AV_RN16(&left[p]) : AV_RN16(&right[p])); |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=4, p+=2, b+=2) { |
|
|
|
AV_WN16(&dst[x ], (b&1) == (y&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m])); |
|
|
|
AV_WN16(&dst[x+2], (b&1) != (y&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 3: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=6, p+=3, b++) { |
|
|
|
AV_WB24(&dst[x ], (b&1) == (y&1) ? AV_RB24(&left[p]) : AV_RB24(&right[p])); |
|
|
|
AV_WB24(&dst[x+3], (b&1) != (y&1) ? AV_RB24(&left[p]) : AV_RB24(&right[p])); |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=6, p+=3, b+=2) { |
|
|
|
AV_WB24(&dst[x ], (b&1) == (y&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m])); |
|
|
|
AV_WB24(&dst[x+3], (b&1) != (y&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 4: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=8, p+=4, b++) { |
|
|
|
AV_WN32(&dst[x ], (b&1) == (y&1) ? AV_RN32(&left[p]) : AV_RN32(&right[p])); |
|
|
|
AV_WN32(&dst[x+4], (b&1) != (y&1) ? AV_RN32(&left[p]) : AV_RN32(&right[p])); |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=8, p+=4, b+=2) { |
|
|
|
AV_WN32(&dst[x ], (b&1) == (y&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m])); |
|
|
|
AV_WN32(&dst[x+4], (b&1) != (y&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 6: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=12, p+=6, b++) { |
|
|
|
AV_WB48(&dst[x ], (b&1) == (y&1) ? AV_RB48(&left[p]) : AV_RB48(&right[p])); |
|
|
|
AV_WB48(&dst[x+6], (b&1) != (y&1) ? AV_RB48(&left[p]) : AV_RB48(&right[p])); |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=12, p+=6, b+=2) { |
|
|
|
AV_WB48(&dst[x ], (b&1) == (y&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m])); |
|
|
|
AV_WB48(&dst[x+6], (b&1) != (y&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 8: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=16, p+=8, b++) { |
|
|
|
AV_WN64(&dst[x ], (b&1) == (y&1) ? AV_RN64(&left[p]) : AV_RN64(&right[p])); |
|
|
|
AV_WN64(&dst[x+8], (b&1) != (y&1) ? AV_RN64(&left[p]) : AV_RN64(&right[p])); |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=16, p+=8, b+=2) { |
|
|
|
AV_WN64(&dst[x ], (b&1) == (y&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m])); |
|
|
|
AV_WN64(&dst[x+8], (b&1) != (y&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
} |
|
|
@@ -886,11 +999,13 @@ copy: |
|
|
|
case INTERLEAVE_COLS_LR: |
|
|
|
case INTERLEAVE_COLS_RL: |
|
|
|
for (i = 0; i < s->nb_planes; i++) { |
|
|
|
const int d = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL); |
|
|
|
const int m = 1 + d; |
|
|
|
int x, y; |
|
|
|
|
|
|
|
for (y = 0; y < s->pheight[i]; y++) { |
|
|
|
uint8_t *dst = out->data[i] + out->linesize[i] * y; |
|
|
|
uint8_t *left = ileft->data[i] + ileft->linesize[i] * y * s->in.row_step + s->in_off_left[i]; |
|
|
|
uint8_t *left = ileft->data[i] + ileft->linesize[i] * y * s->in.row_step + s->in_off_left[i] + d * s->pixstep[i]; |
|
|
|
uint8_t *right = iright->data[i] + iright->linesize[i] * y * s->in.row_step + s->in_off_right[i]; |
|
|
|
int p, b; |
|
|
|
|
|
|
@@ -900,38 +1015,38 @@ copy: |
|
|
|
switch (s->pixstep[i]) { |
|
|
|
case 1: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=2, p++, b+=2) { |
|
|
|
dst[x ] = b&1 ? left[p] : right[p]; |
|
|
|
dst[x+1] = !(b&1) ? left[p] : right[p]; |
|
|
|
dst[x ] = b&1 ? left[p*m] : right[p*m]; |
|
|
|
dst[x+1] = !(b&1) ? left[p*m] : right[p*m]; |
|
|
|
} |
|
|
|
break; |
|
|
|
case 2: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=4, p+=2, b+=2) { |
|
|
|
AV_WN16(&dst[x ], b&1 ? AV_RN16(&left[p]) : AV_RN16(&right[p])); |
|
|
|
AV_WN16(&dst[x+2], !(b&1) ? AV_RN16(&left[p]) : AV_RN16(&right[p])); |
|
|
|
AV_WN16(&dst[x ], b&1 ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m])); |
|
|
|
AV_WN16(&dst[x+2], !(b&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 3: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=6, p+=3, b+=2) { |
|
|
|
AV_WB24(&dst[x ], b&1 ? AV_RB24(&left[p]) : AV_RB24(&right[p])); |
|
|
|
AV_WB24(&dst[x+3], !(b&1) ? AV_RB24(&left[p]) : AV_RB24(&right[p])); |
|
|
|
AV_WB24(&dst[x ], b&1 ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m])); |
|
|
|
AV_WB24(&dst[x+3], !(b&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 4: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=8, p+=4, b+=2) { |
|
|
|
AV_WN32(&dst[x ], b&1 ? AV_RN32(&left[p]) : AV_RN32(&right[p])); |
|
|
|
AV_WN32(&dst[x+4], !(b&1) ? AV_RN32(&left[p]) : AV_RN32(&right[p])); |
|
|
|
AV_WN32(&dst[x ], b&1 ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m])); |
|
|
|
AV_WN32(&dst[x+4], !(b&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 6: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=12, p+=6, b+=2) { |
|
|
|
AV_WB48(&dst[x ], b&1 ? AV_RB48(&left[p]) : AV_RB48(&right[p])); |
|
|
|
AV_WB48(&dst[x+6], !(b&1) ? AV_RB48(&left[p]) : AV_RB48(&right[p])); |
|
|
|
AV_WB48(&dst[x ], b&1 ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m])); |
|
|
|
AV_WB48(&dst[x+6], !(b&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 8: |
|
|
|
for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=16, p+=8, b+=2) { |
|
|
|
AV_WN64(&dst[x ], b&1 ? AV_RN64(&left[p]) : AV_RN64(&right[p])); |
|
|
|
AV_WN64(&dst[x+8], !(b&1) ? AV_RN64(&left[p]) : AV_RN64(&right[p])); |
|
|
|
AV_WN64(&dst[x ], b&1 ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m])); |
|
|
|
AV_WN64(&dst[x+8], !(b&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m])); |
|
|
|
} |
|
|
|
break; |
|
|
|
} |
|
|
|