X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=effect_chain.cpp;h=bd039b0113e662a9279976a3d01ed43e2a406102;hp=f6266d741e63c0308ea841952a6ec23816f30406;hb=572e7aaa57028d7eda4bc445a6249637134a2b02;hpb=fc55857d9ccf1edcc141fa0853a8bf2d6b40b4dc

diff --git a/effect_chain.cpp b/effect_chain.cpp
index f6266d7..bd039b0 100644
--- a/effect_chain.cpp
+++ b/effect_chain.cpp
@@ -618,8 +618,8 @@ void EffectChain::inform_input_sizes(Phase *phase)
 	}
 	for (unsigned i = 0; i < phase->inputs.size(); ++i) {
 		Node *input = phase->inputs[i];
-		input->output_width = input->phase->output_width;
-		input->output_height = input->phase->output_height;
+		input->output_width = input->phase->virtual_output_width;
+		input->output_height = input->phase->virtual_output_height;
 		assert(input->output_width != 0);
 		assert(input->output_height != 0);
 	}
@@ -662,14 +662,54 @@ void EffectChain::find_output_size(Phase *phase)
 
 	// If the last effect explicitly sets an output size, use that.
 	if (output_node->effect->changes_output_size()) {
-		output_node->effect->get_output_size(&phase->output_width, &phase->output_height);
+		output_node->effect->get_output_size(&phase->output_width, &phase->output_height,
+		                                     &phase->virtual_output_width, &phase->virtual_output_height);
 		return;
 	}
 
+	// If all effects have the same size, use that.
 	unsigned output_width = 0, output_height = 0;
+	bool all_inputs_same_size = true;
 
-	// If not, look at the input phases and textures.
-	// We select the largest one (by fit into the current aspect).
+	for (unsigned i = 0; i < phase->inputs.size(); ++i) {
+		Node *input = phase->inputs[i];
+		assert(input->phase->output_width != 0);
+		assert(input->phase->output_height != 0);
+		if (output_width == 0 && output_height == 0) {
+			output_width = input->phase->virtual_output_width;
+			output_height = input->phase->virtual_output_height;
+		} else if (output_width != input->phase->virtual_output_width ||
+		           output_height != input->phase->virtual_output_height) {
+			all_inputs_same_size = false;
+		}
+	}
+	for (unsigned i = 0; i < phase->effects.size(); ++i) {
+		Effect *effect = phase->effects[i]->effect;
+		if (effect->num_inputs() != 0) {
+			continue;
+		}
+
+		Input *input = static_cast<Input *>(effect);
+		if (output_width == 0 && output_height == 0) {
+			output_width = input->get_width();
+			output_height = input->get_height();
+		} else if (output_width != input->get_width() ||
+		           output_height != input->get_height()) {
+			all_inputs_same_size = false;
+		}
+	}
+
+	if (all_inputs_same_size) {
+		assert(output_width != 0);
+		assert(output_height != 0);
+		phase->virtual_output_width = phase->output_width = output_width;
+		phase->virtual_output_height = phase->output_height = output_height;
+		return;
+	}
+
+	// If not, fit all the inputs into the current aspect, and select the largest one. 
+	output_width = 0;
+	output_height = 0;
 	for (unsigned i = 0; i < phase->inputs.size(); ++i) {
 		Node *input = phase->inputs[i];
 		assert(input->phase->output_width != 0);
@@ -687,8 +727,8 @@ void EffectChain::find_output_size(Phase *phase)
 	}
 	assert(output_width != 0);
 	assert(output_height != 0);
-	phase->output_width = output_width;
-	phase->output_height = output_height;
+	phase->virtual_output_width = phase->output_width = output_width;
+	phase->virtual_output_height = phase->output_height = output_height;
 }
 
 void EffectChain::sort_all_nodes_topologically()
@@ -736,10 +776,10 @@ void EffectChain::find_color_spaces_for_inputs()
 			case Effect::OUTPUT_BLANK_ALPHA:
 				node->output_alpha_type = ALPHA_BLANK;
 				break;
-			case Effect::INPUT_AND_OUTPUT_ALPHA_PREMULTIPLIED:
+			case Effect::INPUT_AND_OUTPUT_PREMULTIPLIED_ALPHA:
 				node->output_alpha_type = ALPHA_PREMULTIPLIED;
 				break;
-			case Effect::OUTPUT_ALPHA_POSTMULTIPLIED:
+			case Effect::OUTPUT_POSTMULTIPLIED_ALPHA:
 				node->output_alpha_type = ALPHA_POSTMULTIPLIED;
 				break;
 			case Effect::DONT_CARE_ALPHA_TYPE:
@@ -845,7 +885,7 @@ void EffectChain::propagate_alpha()
 		}
 
 		// Only inputs can have unconditional alpha output (OUTPUT_BLANK_ALPHA
-		// or OUTPUT_ALPHA_POSTMULTIPLIED), and they have already been
+		// or OUTPUT_POSTMULTIPLIED_ALPHA), and they have already been
 		// taken care of above. Rationale: Even if you could imagine
 		// e.g. an effect that took in an image and set alpha=1.0
 		// unconditionally, it wouldn't make any sense to have it as
@@ -853,7 +893,7 @@ void EffectChain::propagate_alpha()
 		// got its input pre- or postmultiplied, so it wouldn't know
 		// whether to divide away the old alpha or not.
 		Effect::AlphaHandling alpha_handling = node->effect->alpha_handling();
-		assert(alpha_handling == Effect::INPUT_AND_OUTPUT_ALPHA_PREMULTIPLIED ||
+		assert(alpha_handling == Effect::INPUT_AND_OUTPUT_PREMULTIPLIED_ALPHA ||
 		       alpha_handling == Effect::DONT_CARE_ALPHA_TYPE);
 
 		// If the node has multiple inputs, check that they are all valid and
@@ -893,7 +933,7 @@ void EffectChain::propagate_alpha()
 			continue;
 		}
 
-		if (alpha_handling == Effect::INPUT_AND_OUTPUT_ALPHA_PREMULTIPLIED) {
+		if (alpha_handling == Effect::INPUT_AND_OUTPUT_PREMULTIPLIED_ALPHA) {
 			// If the effect has asked for premultiplied alpha, check that it has got it.
 			if (any_postmultiplied) {
 				node->output_alpha_type = ALPHA_INVALID;
@@ -1101,14 +1141,14 @@ void EffectChain::fix_output_alpha()
 		return;
 	}
 	if (output->output_alpha_type == ALPHA_PREMULTIPLIED &&
-	    output_alpha_format == OUTPUT_ALPHA_POSTMULTIPLIED) {
+	    output_alpha_format == OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED) {
 		Node *conversion = add_node(new AlphaDivisionEffect());
 		connect_nodes(output, conversion);
 		propagate_alpha();
 		propagate_gamma_and_color_space();
 	}
 	if (output->output_alpha_type == ALPHA_POSTMULTIPLIED &&
-	    output_alpha_format == OUTPUT_ALPHA_PREMULTIPLIED) {
+	    output_alpha_format == OUTPUT_ALPHA_FORMAT_PREMULTIPLIED) {
 		Node *conversion = add_node(new AlphaMultiplicationEffect());
 		connect_nodes(output, conversion);
 		propagate_alpha();