This is an automated email from the git hooks/post-receive script. Git pushed a commit to branch master in repository ffmpeg.
commit 900d91b541fb8b173362012f85a40d6b8a05381b Author: Niklas Haas <[email protected]> AuthorDate: Mon Dec 15 17:36:54 2025 +0100 Commit: Niklas Haas <[email protected]> CommitDate: Sat Dec 20 13:52:45 2025 +0000 swscale/ops_optimizer: apply optimizations in a more predictable order Instead of blindly interleaving re-ordering and minimizing optimizations, separate this loop into several passes - the first pass will minimize the operation list in-place as much as possible, and the second pass will apply any desired re-orderings. (We also want to try pushing clear back before any other re-orderings, as this can trigger more phase 1 optimizations) This restructuring leads to significantly more predictable and stable behavior, especially when introducing more operation types going forwards. Does not actually affect the current results, but matters with some upcoming changes I have planned. --- libswscale/ops_optimizer.c | 102 +++++++++++++++++++++++++++++---------------- 1 file changed, 65 insertions(+), 37 deletions(-) diff --git a/libswscale/ops_optimizer.c b/libswscale/ops_optimizer.c index c4a75820d3..3b57c76130 100644 --- a/libswscale/ops_optimizer.c +++ b/libswscale/ops_optimizer.c @@ -500,6 +500,7 @@ int ff_sws_op_list_optimize(SwsOpList *ops) retry: ff_sws_op_list_update_comps(ops); + /* Apply all in-place optimizations (that do not re-order the list) */ for (int n = 0; n < ops->num_ops;) { SwsOp dummy = {0}; SwsOp *op = &ops->ops[n]; @@ -604,25 +605,14 @@ retry: ff_sws_op_list_remove_at(ops, n + 1, 1); goto retry; } - - /* Prefer to clear as late as possible, to avoid doing - * redundant work */ - if (op_commute_clear(op, next)) { - FFSWAP(SwsOp, *op, *next); - goto retry; - } break; - case SWS_OP_SWIZZLE: { - bool seen[4] = {0}; - bool has_duplicates = false; + case SWS_OP_SWIZZLE: for (int i = 0; i < 4; i++) { if (next->comps.unused[i]) continue; if (op->swizzle.in[i] != i) noop = false; - has_duplicates |= seen[op->swizzle.in[i]]; - seen[op->swizzle.in[i]] = true; } /* Identity swizzle */ @@ -639,22 +629,7 @@ retry: ff_sws_op_list_remove_at(ops, n + 1, 1); goto retry; } - - /* Try to push swizzles with duplicates towards the output */ - if (has_duplicates && op_commute_swizzle(op, next)) { - FFSWAP(SwsOp, *op, *next); - goto retry; - } - - /* Move swizzle out of the way between two converts so that - * they may be merged */ - if (prev->op == SWS_OP_CONVERT && next->op == SWS_OP_CONVERT) { - op->type = next->convert.to; - FFSWAP(SwsOp, *op, *next); - goto retry; - } break; - } case SWS_OP_CONVERT: /* No-op conversion */ @@ -813,16 +788,6 @@ retry: goto retry; } - /* Scaling by integer before conversion to int */ - if (op->c.q.den == 1 && - next->op == SWS_OP_CONVERT && - ff_sws_pixel_type_is_int(next->convert.to)) - { - op->type = next->convert.to; - FFSWAP(SwsOp, *op, *next); - goto retry; - } - /* Scaling by exact power of two */ if (factor2 && ff_sws_pixel_type_is_int(op->type)) { op->op = factor2 > 0 ? SWS_OP_LSHIFT : SWS_OP_RSHIFT; @@ -837,6 +802,69 @@ retry: n++; } + /* Push clears to the back to void any unused components */ + for (int n = 1; n < ops->num_ops - 1; n++) { /* exclude READ/WRITE */ + SwsOp *op = &ops->ops[n]; + SwsOp *next = &ops->ops[n + 1]; + + switch (op->op) { + case SWS_OP_CLEAR: + if (op_commute_clear(op, next)) { + FFSWAP(SwsOp, *op, *next); + goto retry; + } + break; + } + } + + /* Apply any remaining preferential re-ordering optimizations; do these + * last because they are more likely to block other optimizations if done + * too aggressively */ + for (int n = 1; n < ops->num_ops - 1; n++) { /* exclude READ/WRITE */ + SwsOp *op = &ops->ops[n]; + SwsOp *prev = &ops->ops[n - 1]; + SwsOp *next = &ops->ops[n + 1]; + + switch (op->op) { + case SWS_OP_SWIZZLE: { + bool seen[4] = {0}; + bool has_duplicates = false; + for (int i = 0; i < 4; i++) { + if (next->comps.unused[i]) + continue; + has_duplicates |= seen[op->swizzle.in[i]]; + seen[op->swizzle.in[i]] = true; + } + + /* Try to push swizzles with duplicates towards the output */ + if (has_duplicates && op_commute_swizzle(op, next)) { + FFSWAP(SwsOp, *op, *next); + goto retry; + } + + /* Move swizzle out of the way between two converts so that + * they may be merged */ + if (prev->op == SWS_OP_CONVERT && next->op == SWS_OP_CONVERT) { + op->type = next->convert.to; + FFSWAP(SwsOp, *op, *next); + goto retry; + } + break; + } + + case SWS_OP_SCALE: + /* Scaling by integer before conversion to int */ + if (op->c.q.den == 1 && next->op == SWS_OP_CONVERT && + ff_sws_pixel_type_is_int(next->convert.to)) + { + op->type = next->convert.to; + FFSWAP(SwsOp, *op, *next); + goto retry; + } + break; + } + } + return 0; } _______________________________________________ ffmpeg-cvslog mailing list -- [email protected] To unsubscribe send an email to [email protected]
