last_is_connected[signal_num] = userdata->last_is_connected;
last_frame_rate_nom[signal_num] = userdata->last_frame_rate_nom;
last_frame_rate_den[signal_num] = userdata->last_frame_rate_den;
+ last_pixel_format[signal_num] = userdata->pixel_format;
has_last_subtitle[signal_num] = userdata->has_last_subtitle;
last_subtitle[signal_num] = userdata->last_subtitle;
}
{ "new", Scene_new },
{ "__gc", Scene_gc },
{ "add_input", Scene::add_input },
- { "add_auto_white_balance", Scene::add_auto_white_balance },
+ { "add_white_balance", Scene::add_white_balance },
{ "add_effect", Scene::add_effect },
{ "add_optional_effect", Scene::add_optional_effect },
{ "finalize", Scene::finalize },
}
int card_idx = theme->map_signal_to_card(signal_num);
- connect_signal_raw(card_idx, *theme->input_state);
+ connect_card(card_idx, *theme->input_state);
return true;
}
-void LiveInputWrapper::connect_signal_raw(int card_idx, const InputState &input_state)
+void LiveInputWrapper::connect_card(int card_idx, const InputState &input_state)
{
BufferedFrame first_frame = input_state.buffered_frames[card_idx][0];
if (first_frame.frame == nullptr) {
ycbcr_inputs[i]->set_texture_num(0, userdata->tex_y[frame.field_number]);
ycbcr_inputs[i]->set_texture_num(1, userdata->tex_cb[frame.field_number]);
ycbcr_inputs[i]->set_texture_num(2, userdata->tex_cr[frame.field_number]);
- ycbcr_inputs[i]->change_ycbcr_format(userdata->ycbcr_format);
+ // YCbCrPlanar is used for video streams, where we can have metadata from the mux.
+ // Prefer that if there's no override. (Overrides are only available when using
+ // video as SRT cards.)
+ if (input_state.ycbcr_coefficients_auto[card_idx]) {
+ ycbcr_inputs[i]->change_ycbcr_format(userdata->ycbcr_format);
+ } else {
+ ycbcr_inputs[i]->change_ycbcr_format(input_ycbcr_format);
+ }
ycbcr_inputs[i]->set_width(width);
ycbcr_inputs[i]->set_height(height);
break;
return 0;
}
-Theme::Theme(const string &filename, const vector<string> &search_dirs, ResourcePool *resource_pool, unsigned num_cards)
- : resource_pool(resource_pool), num_cards(num_cards), signal_to_card_mapping(global_flags.default_stream_mapping)
+Theme::Theme(const string &filename, const vector<string> &search_dirs, ResourcePool *resource_pool)
+ : resource_pool(resource_pool), signal_to_card_mapping(global_flags.default_stream_mapping)
{
// Defaults.
channel_names[0] = "Live";
// each FFmpeg or CEF input, so we'll do it here.
if (video_signal_connections.count(effect_chain)) {
for (const VideoSignalConnection &conn : video_signal_connections[effect_chain]) {
- conn.wrapper->connect_signal_raw(conn.source->get_card_index(), input_state);
+ conn.wrapper->connect_card(conn.source->get_card_index(), input_state);
}
}
#ifdef HAVE_CEF
if (html_signal_connections.count(effect_chain)) {
for (const CEFSignalConnection &conn : html_signal_connections[effect_chain]) {
- conn.wrapper->connect_signal_raw(conn.source->get_card_index(), input_state);
+ conn.wrapper->connect_card(conn.source->get_card_index(), input_state);
}
}
#endif
// TODO: Can we do better, e.g. by running setup_chain() and seeing what it references?
// Actually, setup_chain does maybe hold all the references we need now anyway?
- chain.input_frames.reserve(num_cards * FRAME_HISTORY_LENGTH);
- for (unsigned card_index = 0; card_index < num_cards; ++card_index) {
+ chain.input_frames.reserve(MAX_VIDEO_CARDS * FRAME_HISTORY_LENGTH);
+ for (unsigned card_index = 0; card_index < MAX_VIDEO_CARDS; ++card_index) {
for (unsigned frame_num = 0; frame_num < FRAME_HISTORY_LENGTH; ++frame_num) {
chain.input_frames.push_back(input_state.buffered_frames[card_index][frame_num].frame);
}
lock_guard<mutex> lock(m);
if (signal != -1) {
- white_balance_for_signal[signal] = RGBTriplet{ r, g, b };
+ int card_idx = map_signal_to_card(signal);
+ white_balance_for_card[card_idx] = RGBTriplet{ r, g, b };
}
call_lua_wb_callback(channel, r, g, b);
}
-void Theme::set_wb_for_signal(int signal, float r, float g, float b)
+void Theme::set_wb_for_card(int card_idx, float r, float g, float b)
{
lock_guard<mutex> lock(m);
- white_balance_for_signal[signal] = RGBTriplet{ r, g, b };
+ white_balance_for_card[card_idx] = RGBTriplet{ r, g, b };
for (const auto &channel_and_signal : channel_signals) {
- if (channel_and_signal.second == signal) {
+ if (map_signal_to_card(channel_and_signal.second) == card_idx) {
call_lua_wb_callback(channel_and_signal.first, r, g, b);
}
}
assert(lua_gettop(L) == 0);
}
-RGBTriplet Theme::get_white_balance_for_signal(int signal)
+RGBTriplet Theme::get_white_balance_for_card(int card_idx)
{
- if (white_balance_for_signal.count(signal)) {
- return white_balance_for_signal[signal];
+ if (white_balance_for_card.count(card_idx)) {
+ return white_balance_for_card[card_idx];
} else {
return RGBTriplet{ 1.0, 1.0, 1.0 };
}
}
int card_index;
- if (global_flags.output_card != -1 && num_cards > 1) {
+ if (global_flags.output_card != -1) {
// Try to exclude the output card from the default card_index.
- card_index = signal_num % (num_cards - 1);
+ card_index = signal_num % (global_flags.max_num_cards - 1);
if (card_index >= global_flags.output_card) {
++card_index;
}
- if (signal_num >= int(num_cards - 1)) {
+ if (signal_num >= int(global_flags.max_num_cards - 1)) {
print_warning(L, "Theme asked for input %d, but we only have %u input card(s) (card %d is busy with output).\n",
- signal_num, num_cards - 1, global_flags.output_card);
+ signal_num, global_flags.max_num_cards - 1, global_flags.output_card);
fprintf(stderr, "Mapping to card %d instead.\n", card_index);
}
} else {
- card_index = signal_num % num_cards;
- if (signal_num >= int(num_cards)) {
- print_warning(L, "Theme asked for input %d, but we only have %u card(s).\n", signal_num, num_cards);
+ card_index = signal_num % global_flags.max_num_cards;
+ if (signal_num >= int(global_flags.max_num_cards)) {
+ print_warning(L, "Theme asked for input %d, but we only have %u card(s).\n", signal_num, global_flags.max_num_cards);
fprintf(stderr, "Mapping to card %d instead.\n", card_index);
}
}
+ global_mixer->force_card_active(card_index);
signal_to_card_mapping[signal_num] = card_index;
return card_index;
}
void Theme::set_signal_mapping(int signal_num, int card_idx)
{
lock_guard<mutex> lock(map_m);
- assert(card_idx < int(num_cards));
+ assert(card_idx < MAX_VIDEO_CARDS);
signal_to_card_mapping[signal_num] = card_idx;
}