From 93c572c33c9e0e1aab6b17aa8776b19ce9588035 Mon Sep 17 00:00:00 2001 From: Alex J Lennon Date: Mon, 29 Apr 2024 17:58:31 +0100 Subject: [PATCH] gst1-plugins-bad-openipc: Shadow gst1-plugins-bad to support disabling nvcodec This plugin can't be disabled via OpenIPC with the upstream buildroot package. When we pull in the package building for the Ingenic T31 we get an error building nvcodec. So shadow and add a new set of buildroot configuration options to support disabling build of nvcodec Signed-off-by: Alex J Lennon --- general/package/Config.in | 1 + ...e-code-for-webrtc-audio-processing-1.patch | 883 ++++++++++++++++++ .../gst1-plugins-bad-openipc/Config.in | 760 +++++++++++++++ .../gst1-plugins-bad-openipc.hash | 3 + .../gst1-plugins-bad-openipc.mk | 850 +++++++++++++++++ 5 files changed, 2497 insertions(+) create mode 100644 general/package/gst1-plugins-bad-openipc/0001-webrtcdsp-Update-code-for-webrtc-audio-processing-1.patch create mode 100644 general/package/gst1-plugins-bad-openipc/Config.in create mode 100644 general/package/gst1-plugins-bad-openipc/gst1-plugins-bad-openipc.hash create mode 100644 general/package/gst1-plugins-bad-openipc/gst1-plugins-bad-openipc.mk diff --git a/general/package/Config.in b/general/package/Config.in index 3bd3de86..98fa89c6 100644 --- a/general/package/Config.in +++ b/general/package/Config.in @@ -22,6 +22,7 @@ source "$BR2_EXTERNAL_GENERAL_PATH/package/go2rtc/Config.in" source "$BR2_EXTERNAL_GENERAL_PATH/package/goke-osdrv-gk710x/Config.in" source "$BR2_EXTERNAL_GENERAL_PATH/package/goke-osdrv-gk7205v200/Config.in" source "$BR2_EXTERNAL_GENERAL_PATH/package/grainmedia-osdrv-gm8136/Config.in" +source "$BR2_EXTERNAL_GENERAL_PATH/package/gst1-plugins-bad-openipc/Config.in" source "$BR2_EXTERNAL_GENERAL_PATH/package/hisi-gpio/Config.in" source "$BR2_EXTERNAL_GENERAL_PATH/package/hisilicon-opensdk/Config.in" source "$BR2_EXTERNAL_GENERAL_PATH/package/hisilicon-osdrv-hi3516av100/Config.in" diff --git a/general/package/gst1-plugins-bad-openipc/0001-webrtcdsp-Update-code-for-webrtc-audio-processing-1.patch b/general/package/gst1-plugins-bad-openipc/0001-webrtcdsp-Update-code-for-webrtc-audio-processing-1.patch new file mode 100644 index 00000000..a2ab0ef6 --- /dev/null +++ b/general/package/gst1-plugins-bad-openipc/0001-webrtcdsp-Update-code-for-webrtc-audio-processing-1.patch @@ -0,0 +1,883 @@ +From d5755744c3e2b70e9f04704ae9d18b928d9fa456 Mon Sep 17 00:00:00 2001 +From: Arun Raghavan +Date: Wed, 2 Dec 2020 18:31:44 -0500 +Subject: [PATCH] webrtcdsp: Update code for webrtc-audio-processing-1 + +Updated API usage appropriately, and now we have a versioned package to +track breaking vs. non-breaking updates. + +Deprecates a number of properties (and we have to plug in our own values +for related enums which are now gone): + + * echo-suprression-level + * experimental-agc + * extended-filter + * delay-agnostic + * voice-detection-frame-size-ms + * voice-detection-likelihood + +Part-of: +Signed-off-by: James Hilliard +Upstream: https://gitlab.freedesktop.org/gstreamer/gstreamer/-/commit/d5755744c3e2b70e9f04704ae9d18b928d9fa456 +--- + .../ext/webrtcdsp/gstwebrtcdsp.cpp | 271 +++++++----------- + .../ext/webrtcdsp/gstwebrtcechoprobe.cpp | 87 +++--- + .../ext/webrtcdsp/gstwebrtcechoprobe.h | 9 +- + .../gst-plugins-bad/ext/webrtcdsp/meson.build | 4 +- + 4 files changed, 164 insertions(+), 207 deletions(-) + +diff --git a/ext/webrtcdsp/gstwebrtcdsp.cpp b/ext/webrtcdsp/gstwebrtcdsp.cpp +index 7ee09488fb..c9a7cdae2f 100644 +--- a/ext/webrtcdsp/gstwebrtcdsp.cpp ++++ b/ext/webrtcdsp/gstwebrtcdsp.cpp +@@ -71,9 +71,7 @@ + #include "gstwebrtcdsp.h" + #include "gstwebrtcechoprobe.h" + +-#include +-#include +-#include ++#include + + GST_DEBUG_CATEGORY (webrtc_dsp_debug); + #define GST_CAT_DEFAULT (webrtc_dsp_debug) +@@ -82,10 +80,9 @@ GST_DEBUG_CATEGORY (webrtc_dsp_debug); + #define DEFAULT_COMPRESSION_GAIN_DB 9 + #define DEFAULT_STARTUP_MIN_VOLUME 12 + #define DEFAULT_LIMITER TRUE +-#define DEFAULT_GAIN_CONTROL_MODE webrtc::GainControl::kAdaptiveDigital ++#define DEFAULT_GAIN_CONTROL_MODE webrtc::AudioProcessing::Config::GainController1::Mode::kAdaptiveDigital + #define DEFAULT_VOICE_DETECTION FALSE + #define DEFAULT_VOICE_DETECTION_FRAME_SIZE_MS 10 +-#define DEFAULT_VOICE_DETECTION_LIKELIHOOD webrtc::VoiceDetection::kLowLikelihood + + static GstStaticPadTemplate gst_webrtc_dsp_sink_template = + GST_STATIC_PAD_TEMPLATE ("sink", +@@ -119,7 +116,7 @@ GST_STATIC_PAD_TEMPLATE ("src", + "channels = (int) [1, MAX]") + ); + +-typedef webrtc::EchoCancellation::SuppressionLevel GstWebrtcEchoSuppressionLevel; ++typedef int GstWebrtcEchoSuppressionLevel; + #define GST_TYPE_WEBRTC_ECHO_SUPPRESSION_LEVEL \ + (gst_webrtc_echo_suppression_level_get_type ()) + static GType +@@ -127,10 +124,9 @@ gst_webrtc_echo_suppression_level_get_type (void) + { + static GType suppression_level_type = 0; + static const GEnumValue level_types[] = { +- {webrtc::EchoCancellation::kLowSuppression, "Low Suppression", "low"}, +- {webrtc::EchoCancellation::kModerateSuppression, +- "Moderate Suppression", "moderate"}, +- {webrtc::EchoCancellation::kHighSuppression, "high Suppression", "high"}, ++ {1, "Low Suppression", "low"}, ++ {2, "Moderate Suppression", "moderate"}, ++ {3, "high Suppression", "high"}, + {0, NULL, NULL} + }; + +@@ -141,7 +137,7 @@ gst_webrtc_echo_suppression_level_get_type (void) + return suppression_level_type; + } + +-typedef webrtc::NoiseSuppression::Level GstWebrtcNoiseSuppressionLevel; ++typedef webrtc::AudioProcessing::Config::NoiseSuppression::Level GstWebrtcNoiseSuppressionLevel; + #define GST_TYPE_WEBRTC_NOISE_SUPPRESSION_LEVEL \ + (gst_webrtc_noise_suppression_level_get_type ()) + static GType +@@ -149,10 +145,10 @@ gst_webrtc_noise_suppression_level_get_type (void) + { + static GType suppression_level_type = 0; + static const GEnumValue level_types[] = { +- {webrtc::NoiseSuppression::kLow, "Low Suppression", "low"}, +- {webrtc::NoiseSuppression::kModerate, "Moderate Suppression", "moderate"}, +- {webrtc::NoiseSuppression::kHigh, "High Suppression", "high"}, +- {webrtc::NoiseSuppression::kVeryHigh, "Very High Suppression", ++ {webrtc::AudioProcessing::Config::NoiseSuppression::Level::kLow, "Low Suppression", "low"}, ++ {webrtc::AudioProcessing::Config::NoiseSuppression::Level::kModerate, "Moderate Suppression", "moderate"}, ++ {webrtc::AudioProcessing::Config::NoiseSuppression::Level::kHigh, "High Suppression", "high"}, ++ {webrtc::AudioProcessing::Config::NoiseSuppression::Level::kVeryHigh, "Very High Suppression", + "very-high"}, + {0, NULL, NULL} + }; +@@ -164,7 +160,7 @@ gst_webrtc_noise_suppression_level_get_type (void) + return suppression_level_type; + } + +-typedef webrtc::GainControl::Mode GstWebrtcGainControlMode; ++typedef webrtc::AudioProcessing::Config::GainController1::Mode GstWebrtcGainControlMode; + #define GST_TYPE_WEBRTC_GAIN_CONTROL_MODE \ + (gst_webrtc_gain_control_mode_get_type ()) + static GType +@@ -172,8 +168,9 @@ gst_webrtc_gain_control_mode_get_type (void) + { + static GType gain_control_mode_type = 0; + static const GEnumValue mode_types[] = { +- {webrtc::GainControl::kAdaptiveDigital, "Adaptive Digital", "adaptive-digital"}, +- {webrtc::GainControl::kFixedDigital, "Fixed Digital", "fixed-digital"}, ++ {webrtc::AudioProcessing::Config::GainController1::kAdaptiveDigital, "Adaptive Digital", "adaptive-digital"}, ++ {webrtc::AudioProcessing::Config::GainController1::kFixedDigital, "Fixed Digital", "fixed-digital"}, ++ {webrtc::AudioProcessing::Config::GainController1::kAdaptiveAnalog, "Adaptive Analog", "adaptive-analog"}, + {0, NULL, NULL} + }; + +@@ -184,7 +181,7 @@ gst_webrtc_gain_control_mode_get_type (void) + return gain_control_mode_type; + } + +-typedef webrtc::VoiceDetection::Likelihood GstWebrtcVoiceDetectionLikelihood; ++typedef int GstWebrtcVoiceDetectionLikelihood; + #define GST_TYPE_WEBRTC_VOICE_DETECTION_LIKELIHOOD \ + (gst_webrtc_voice_detection_likelihood_get_type ()) + static GType +@@ -192,10 +189,10 @@ gst_webrtc_voice_detection_likelihood_get_type (void) + { + static GType likelihood_type = 0; + static const GEnumValue likelihood_types[] = { +- {webrtc::VoiceDetection::kVeryLowLikelihood, "Very Low Likelihood", "very-low"}, +- {webrtc::VoiceDetection::kLowLikelihood, "Low Likelihood", "low"}, +- {webrtc::VoiceDetection::kModerateLikelihood, "Moderate Likelihood", "moderate"}, +- {webrtc::VoiceDetection::kHighLikelihood, "High Likelihood", "high"}, ++ {1, "Very Low Likelihood", "very-low"}, ++ {2, "Low Likelihood", "low"}, ++ {3, "Moderate Likelihood", "moderate"}, ++ {4, "High Likelihood", "high"}, + {0, NULL, NULL} + }; + +@@ -227,6 +224,7 @@ enum + PROP_VOICE_DETECTION, + PROP_VOICE_DETECTION_FRAME_SIZE_MS, + PROP_VOICE_DETECTION_LIKELIHOOD, ++ PROP_EXTRA_DELAY_MS, + }; + + /** +@@ -248,7 +246,7 @@ struct _GstWebrtcDsp + /* Protected by the stream lock */ + GstAdapter *adapter; + GstPlanarAudioAdapter *padapter; +- webrtc::AudioProcessing * apm; ++ webrtc::AudioProcessing *apm; + + /* Protected by the object lock */ + gchar *probe_name; +@@ -257,21 +255,15 @@ struct _GstWebrtcDsp + /* Properties */ + gboolean high_pass_filter; + gboolean echo_cancel; +- webrtc::EchoCancellation::SuppressionLevel echo_suppression_level; + gboolean noise_suppression; +- webrtc::NoiseSuppression::Level noise_suppression_level; ++ webrtc::AudioProcessing::Config::NoiseSuppression::Level noise_suppression_level; + gboolean gain_control; +- gboolean experimental_agc; +- gboolean extended_filter; +- gboolean delay_agnostic; + gint target_level_dbfs; + gint compression_gain_db; + gint startup_min_volume; + gboolean limiter; +- webrtc::GainControl::Mode gain_control_mode; ++ webrtc::AudioProcessing::Config::GainController1::Mode gain_control_mode; + gboolean voice_detection; +- gint voice_detection_frame_size_ms; +- webrtc::VoiceDetection::Likelihood voice_detection_likelihood; + }; + + G_DEFINE_TYPE_WITH_CODE (GstWebrtcDsp, gst_webrtc_dsp, GST_TYPE_AUDIO_FILTER, +@@ -376,9 +368,9 @@ gst_webrtc_dsp_analyze_reverse_stream (GstWebrtcDsp * self, + GstClockTime rec_time) + { + GstWebrtcEchoProbe *probe = NULL; +- webrtc::AudioProcessing * apm; +- webrtc::AudioFrame frame; ++ webrtc::AudioProcessing *apm; + GstBuffer *buf = NULL; ++ GstAudioBuffer abuf; + GstFlowReturn ret = GST_FLOW_OK; + gint err, delay; + +@@ -391,48 +383,44 @@ gst_webrtc_dsp_analyze_reverse_stream (GstWebrtcDsp * self, + if (!probe) + return GST_FLOW_OK; + ++ webrtc::StreamConfig config (probe->info.rate, probe->info.channels, ++ false); + apm = self->apm; + +- if (self->delay_agnostic) +- rec_time = GST_CLOCK_TIME_NONE; +- +-again: +- delay = gst_webrtc_echo_probe_read (probe, rec_time, (gpointer) &frame, &buf); ++ delay = gst_webrtc_echo_probe_read (probe, rec_time, &buf); + apm->set_stream_delay_ms (delay); + ++ g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR); ++ + if (delay < 0) + goto done; + +- if (frame.sample_rate_hz_ != self->info.rate) { ++ if (probe->info.rate != self->info.rate) { + GST_ELEMENT_ERROR (self, STREAM, FORMAT, + ("Echo Probe has rate %i , while the DSP is running at rate %i," + " use a caps filter to ensure those are the same.", +- frame.sample_rate_hz_, self->info.rate), (NULL)); ++ probe->info.rate, self->info.rate), (NULL)); + ret = GST_FLOW_ERROR; + goto done; + } + +- if (buf) { +- webrtc::StreamConfig config (frame.sample_rate_hz_, frame.num_channels_, +- false); +- GstAudioBuffer abuf; +- float * const * data; ++ gst_audio_buffer_map (&abuf, &self->info, buf, GST_MAP_READWRITE); ++ ++ if (probe->interleaved) { ++ int16_t * const data = (int16_t * const) abuf.planes[0]; + +- gst_audio_buffer_map (&abuf, &self->info, buf, GST_MAP_READWRITE); +- data = (float * const *) abuf.planes; + if ((err = apm->ProcessReverseStream (data, config, config, data)) < 0) + GST_WARNING_OBJECT (self, "Reverse stream analyses failed: %s.", + webrtc_error_to_string (err)); +- gst_audio_buffer_unmap (&abuf); +- gst_buffer_replace (&buf, NULL); + } else { +- if ((err = apm->AnalyzeReverseStream (&frame)) < 0) ++ float * const * data = (float * const *) abuf.planes; ++ ++ if ((err = apm->ProcessReverseStream (data, config, config, data)) < 0) + GST_WARNING_OBJECT (self, "Reverse stream analyses failed: %s.", + webrtc_error_to_string (err)); + } + +- if (self->delay_agnostic) +- goto again; ++ gst_audio_buffer_unmap (&abuf); + + done: + gst_object_unref (probe); +@@ -443,16 +431,14 @@ done: + + static void + gst_webrtc_vad_post_activity (GstWebrtcDsp *self, GstBuffer *buffer, +- gboolean stream_has_voice) ++ gboolean stream_has_voice, guint8 level) + { + GstClockTime timestamp = GST_BUFFER_PTS (buffer); + GstBaseTransform *trans = GST_BASE_TRANSFORM_CAST (self); + GstStructure *s; + GstClockTime stream_time; + GstAudioLevelMeta *meta; +- guint8 level; + +- level = self->apm->level_estimator ()->RMS (); + meta = gst_buffer_get_audio_level_meta (buffer); + if (meta) { + meta->voice_activity = stream_has_voice; +@@ -481,6 +467,7 @@ gst_webrtc_dsp_process_stream (GstWebrtcDsp * self, + { + GstAudioBuffer abuf; + webrtc::AudioProcessing * apm = self->apm; ++ webrtc::StreamConfig config (self->info.rate, self->info.channels, false); + gint err; + + if (!gst_audio_buffer_map (&abuf, &self->info, buffer, +@@ -490,19 +477,10 @@ gst_webrtc_dsp_process_stream (GstWebrtcDsp * self, + } + + if (self->interleaved) { +- webrtc::AudioFrame frame; +- frame.num_channels_ = self->info.channels; +- frame.sample_rate_hz_ = self->info.rate; +- frame.samples_per_channel_ = self->period_samples; +- +- memcpy (frame.data_, abuf.planes[0], self->period_size); +- err = apm->ProcessStream (&frame); +- if (err >= 0) +- memcpy (abuf.planes[0], frame.data_, self->period_size); ++ int16_t * const data = (int16_t * const) abuf.planes[0]; ++ err = apm->ProcessStream (data, config, config, data); + } else { + float * const * data = (float * const *) abuf.planes; +- webrtc::StreamConfig config (self->info.rate, self->info.channels, false); +- + err = apm->ProcessStream (data, config, config, data); + } + +@@ -511,10 +489,13 @@ gst_webrtc_dsp_process_stream (GstWebrtcDsp * self, + webrtc_error_to_string (err)); + } else { + if (self->voice_detection) { +- gboolean stream_has_voice = apm->voice_detection ()->stream_has_voice (); ++ webrtc::AudioProcessingStats stats = apm->GetStatistics (); ++ gboolean stream_has_voice = stats.voice_detected && *stats.voice_detected; ++ // The meta takes the value as -dbov, so we negate ++ guint8 level = stats.output_rms_dbfs ? (guint8) -(*stats.output_rms_dbfs) : 127; + + if (stream_has_voice != self->stream_has_voice) +- gst_webrtc_vad_post_activity (self, buffer, stream_has_voice); ++ gst_webrtc_vad_post_activity (self, buffer, stream_has_voice, level); + + self->stream_has_voice = stream_has_voice; + } +@@ -583,21 +564,9 @@ static gboolean + gst_webrtc_dsp_start (GstBaseTransform * btrans) + { + GstWebrtcDsp *self = GST_WEBRTC_DSP (btrans); +- webrtc::Config config; + + GST_OBJECT_LOCK (self); + +- config.Set < webrtc::ExtendedFilter > +- (new webrtc::ExtendedFilter (self->extended_filter)); +- config.Set < webrtc::ExperimentalAgc > +- (new webrtc::ExperimentalAgc (self->experimental_agc, self->startup_min_volume)); +- config.Set < webrtc::DelayAgnostic > +- (new webrtc::DelayAgnostic (self->delay_agnostic)); +- +- /* TODO Intelligibility enhancer, Beamforming, etc. */ +- +- self->apm = webrtc::AudioProcessing::Create (config); +- + if (self->echo_cancel) { + self->probe = gst_webrtc_acquire_echo_probe (self->probe_name); + +@@ -618,10 +587,8 @@ static gboolean + gst_webrtc_dsp_setup (GstAudioFilter * filter, const GstAudioInfo * info) + { + GstWebrtcDsp *self = GST_WEBRTC_DSP (filter); +- webrtc::AudioProcessing * apm; +- webrtc::ProcessingConfig pconfig; ++ webrtc::AudioProcessing::Config config; + GstAudioInfo probe_info = *info; +- gint err = 0; + + GST_LOG_OBJECT (self, "setting format to %s with %i Hz and %i channels", + info->finfo->description, info->rate, info->channels); +@@ -633,7 +600,7 @@ gst_webrtc_dsp_setup (GstAudioFilter * filter, const GstAudioInfo * info) + + self->info = *info; + self->interleaved = (info->layout == GST_AUDIO_LAYOUT_INTERLEAVED); +- apm = self->apm; ++ self->apm = webrtc::AudioProcessingBuilder().Create(); + + if (!self->interleaved) + gst_planar_audio_adapter_configure (self->padapter, info); +@@ -642,8 +609,7 @@ gst_webrtc_dsp_setup (GstAudioFilter * filter, const GstAudioInfo * info) + self->period_samples = info->rate / 100; + self->period_size = self->period_samples * info->bpf; + +- if (self->interleaved && +- (webrtc::AudioFrame::kMaxDataSizeSamples * 2) < self->period_size) ++ if (self->interleaved && (self->period_size > MAX_DATA_SIZE_SAMPLES * 2)) + goto period_too_big; + + if (self->probe) { +@@ -658,40 +624,31 @@ gst_webrtc_dsp_setup (GstAudioFilter * filter, const GstAudioInfo * info) + GST_WEBRTC_ECHO_PROBE_UNLOCK (self->probe); + } + +- /* input stream */ +- pconfig.streams[webrtc::ProcessingConfig::kInputStream] = +- webrtc::StreamConfig (info->rate, info->channels, false); +- /* output stream */ +- pconfig.streams[webrtc::ProcessingConfig::kOutputStream] = +- webrtc::StreamConfig (info->rate, info->channels, false); +- /* reverse input stream */ +- pconfig.streams[webrtc::ProcessingConfig::kReverseInputStream] = +- webrtc::StreamConfig (probe_info.rate, probe_info.channels, false); +- /* reverse output stream */ +- pconfig.streams[webrtc::ProcessingConfig::kReverseOutputStream] = +- webrtc::StreamConfig (probe_info.rate, probe_info.channels, false); +- +- if ((err = apm->Initialize (pconfig)) < 0) +- goto initialize_failed; +- + /* Setup Filters */ ++ // TODO: expose pre_amplifier ++ + if (self->high_pass_filter) { + GST_DEBUG_OBJECT (self, "Enabling High Pass filter"); +- apm->high_pass_filter ()->Enable (true); ++ config.high_pass_filter.enabled = true; + } + + if (self->echo_cancel) { + GST_DEBUG_OBJECT (self, "Enabling Echo Cancellation"); +- apm->echo_cancellation ()->enable_drift_compensation (false); +- apm->echo_cancellation () +- ->set_suppression_level (self->echo_suppression_level); +- apm->echo_cancellation ()->Enable (true); ++ config.echo_canceller.enabled = true; + } + + if (self->noise_suppression) { + GST_DEBUG_OBJECT (self, "Enabling Noise Suppression"); +- apm->noise_suppression ()->set_level (self->noise_suppression_level); +- apm->noise_suppression ()->Enable (true); ++ config.noise_suppression.enabled = true; ++ config.noise_suppression.level = self->noise_suppression_level; ++ } ++ ++ // TODO: expose transient suppression ++ ++ if (self->voice_detection) { ++ GST_DEBUG_OBJECT (self, "Enabling Voice Activity Detection"); ++ config.voice_detection.enabled = true; ++ self->stream_has_voice = FALSE; + } + + if (self->gain_control) { +@@ -706,30 +663,17 @@ gst_webrtc_dsp_setup (GstAudioFilter * filter, const GstAudioInfo * info) + + g_type_class_unref (mode_class); + +- apm->gain_control ()->set_mode (self->gain_control_mode); +- apm->gain_control ()->set_target_level_dbfs (self->target_level_dbfs); +- apm->gain_control ()->set_compression_gain_db (self->compression_gain_db); +- apm->gain_control ()->enable_limiter (self->limiter); +- apm->gain_control ()->Enable (true); ++ config.gain_controller1.enabled = true; ++ config.gain_controller1.target_level_dbfs = self->target_level_dbfs; ++ config.gain_controller1.compression_gain_db = self->compression_gain_db; ++ config.gain_controller1.enable_limiter = self->limiter; ++ config.level_estimation.enabled = true; + } + +- if (self->voice_detection) { +- GEnumClass *likelihood_class = (GEnumClass *) +- g_type_class_ref (GST_TYPE_WEBRTC_VOICE_DETECTION_LIKELIHOOD); +- GST_DEBUG_OBJECT (self, "Enabling Voice Activity Detection, frame size " +- "%d milliseconds, likelihood: %s", self->voice_detection_frame_size_ms, +- g_enum_get_value (likelihood_class, +- self->voice_detection_likelihood)->value_name); +- g_type_class_unref (likelihood_class); ++ // TODO: expose gain controller 2 ++ // TODO: expose residual echo detector + +- self->stream_has_voice = FALSE; +- +- apm->voice_detection ()->Enable (true); +- apm->voice_detection ()->set_likelihood (self->voice_detection_likelihood); +- apm->voice_detection ()->set_frame_size_ms ( +- self->voice_detection_frame_size_ms); +- apm->level_estimator ()->Enable (true); +- } ++ self->apm->ApplyConfig (config); + + GST_OBJECT_UNLOCK (self); + +@@ -738,9 +682,9 @@ gst_webrtc_dsp_setup (GstAudioFilter * filter, const GstAudioInfo * info) + period_too_big: + GST_OBJECT_UNLOCK (self); + GST_WARNING_OBJECT (self, "webrtcdsp format produce too big period " +- "(maximum is %" G_GSIZE_FORMAT " samples and we have %u samples), " ++ "(maximum is %d samples and we have %u samples), " + "reduce the number of channels or the rate.", +- webrtc::AudioFrame::kMaxDataSizeSamples, self->period_size / 2); ++ MAX_DATA_SIZE_SAMPLES, self->period_size / 2); + return FALSE; + + probe_has_wrong_rate: +@@ -751,14 +695,6 @@ probe_has_wrong_rate: + " use a caps filter to ensure those are the same.", + probe_info.rate, info->rate), (NULL)); + return FALSE; +- +-initialize_failed: +- GST_OBJECT_UNLOCK (self); +- GST_ELEMENT_ERROR (self, LIBRARY, INIT, +- ("Failed to initialize WebRTC Audio Processing library"), +- ("webrtc::AudioProcessing::Initialize() failed: %s", +- webrtc_error_to_string (err))); +- return FALSE; + } + + static gboolean +@@ -803,8 +739,6 @@ gst_webrtc_dsp_set_property (GObject * object, + self->echo_cancel = g_value_get_boolean (value); + break; + case PROP_ECHO_SUPPRESSION_LEVEL: +- self->echo_suppression_level = +- (GstWebrtcEchoSuppressionLevel) g_value_get_enum (value); + break; + case PROP_NOISE_SUPPRESSION: + self->noise_suppression = g_value_get_boolean (value); +@@ -817,13 +751,10 @@ gst_webrtc_dsp_set_property (GObject * object, + self->gain_control = g_value_get_boolean (value); + break; + case PROP_EXPERIMENTAL_AGC: +- self->experimental_agc = g_value_get_boolean (value); + break; + case PROP_EXTENDED_FILTER: +- self->extended_filter = g_value_get_boolean (value); + break; + case PROP_DELAY_AGNOSTIC: +- self->delay_agnostic = g_value_get_boolean (value); + break; + case PROP_TARGET_LEVEL_DBFS: + self->target_level_dbfs = g_value_get_int (value); +@@ -845,11 +776,8 @@ gst_webrtc_dsp_set_property (GObject * object, + self->voice_detection = g_value_get_boolean (value); + break; + case PROP_VOICE_DETECTION_FRAME_SIZE_MS: +- self->voice_detection_frame_size_ms = g_value_get_int (value); + break; + case PROP_VOICE_DETECTION_LIKELIHOOD: +- self->voice_detection_likelihood = +- (GstWebrtcVoiceDetectionLikelihood) g_value_get_enum (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); +@@ -876,7 +804,7 @@ gst_webrtc_dsp_get_property (GObject * object, + g_value_set_boolean (value, self->echo_cancel); + break; + case PROP_ECHO_SUPPRESSION_LEVEL: +- g_value_set_enum (value, self->echo_suppression_level); ++ g_value_set_enum (value, (GstWebrtcEchoSuppressionLevel) 2); + break; + case PROP_NOISE_SUPPRESSION: + g_value_set_boolean (value, self->noise_suppression); +@@ -888,13 +816,13 @@ gst_webrtc_dsp_get_property (GObject * object, + g_value_set_boolean (value, self->gain_control); + break; + case PROP_EXPERIMENTAL_AGC: +- g_value_set_boolean (value, self->experimental_agc); ++ g_value_set_boolean (value, false); + break; + case PROP_EXTENDED_FILTER: +- g_value_set_boolean (value, self->extended_filter); ++ g_value_set_boolean (value, false); + break; + case PROP_DELAY_AGNOSTIC: +- g_value_set_boolean (value, self->delay_agnostic); ++ g_value_set_boolean (value, false); + break; + case PROP_TARGET_LEVEL_DBFS: + g_value_set_int (value, self->target_level_dbfs); +@@ -915,10 +843,10 @@ gst_webrtc_dsp_get_property (GObject * object, + g_value_set_boolean (value, self->voice_detection); + break; + case PROP_VOICE_DETECTION_FRAME_SIZE_MS: +- g_value_set_int (value, self->voice_detection_frame_size_ms); ++ g_value_set_int (value, 0); + break; + case PROP_VOICE_DETECTION_LIKELIHOOD: +- g_value_set_enum (value, self->voice_detection_likelihood); ++ g_value_set_enum (value, 2); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); +@@ -1005,13 +933,13 @@ gst_webrtc_dsp_class_init (GstWebrtcDspClass * klass) + + g_object_class_install_property (gobject_class, + PROP_ECHO_SUPPRESSION_LEVEL, +- g_param_spec_enum ("echo-suppression-level", "Echo Suppression Level", ++ g_param_spec_enum ("echo-suppression-level", ++ "Echo Suppression Level (does nothing)", + "Controls the aggressiveness of the suppressor. A higher level " + "trades off double-talk performance for increased echo suppression.", +- GST_TYPE_WEBRTC_ECHO_SUPPRESSION_LEVEL, +- webrtc::EchoCancellation::kModerateSuppression, ++ GST_TYPE_WEBRTC_ECHO_SUPPRESSION_LEVEL, 2, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | +- G_PARAM_CONSTRUCT))); ++ G_PARAM_CONSTRUCT | G_PARAM_DEPRECATED))); + + g_object_class_install_property (gobject_class, + PROP_NOISE_SUPPRESSION, +@@ -1026,7 +954,7 @@ gst_webrtc_dsp_class_init (GstWebrtcDspClass * klass) + "Controls the aggressiveness of the suppression. Increasing the " + "level will reduce the noise level at the expense of a higher " + "speech distortion.", GST_TYPE_WEBRTC_NOISE_SUPPRESSION_LEVEL, +- webrtc::EchoCancellation::kModerateSuppression, ++ webrtc::AudioProcessing::Config::NoiseSuppression::Level::kModerate, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | + G_PARAM_CONSTRUCT))); + +@@ -1039,24 +967,26 @@ gst_webrtc_dsp_class_init (GstWebrtcDspClass * klass) + + g_object_class_install_property (gobject_class, + PROP_EXPERIMENTAL_AGC, +- g_param_spec_boolean ("experimental-agc", "Experimental AGC", ++ g_param_spec_boolean ("experimental-agc", ++ "Experimental AGC (does nothing)", + "Enable or disable experimental automatic gain control.", + FALSE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | +- G_PARAM_CONSTRUCT))); ++ G_PARAM_CONSTRUCT | G_PARAM_DEPRECATED))); + + g_object_class_install_property (gobject_class, + PROP_EXTENDED_FILTER, + g_param_spec_boolean ("extended-filter", "Extended Filter", + "Enable or disable the extended filter.", + TRUE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | +- G_PARAM_CONSTRUCT))); ++ G_PARAM_CONSTRUCT | G_PARAM_DEPRECATED))); + + g_object_class_install_property (gobject_class, + PROP_DELAY_AGNOSTIC, +- g_param_spec_boolean ("delay-agnostic", "Delay Agnostic", ++ g_param_spec_boolean ("delay-agnostic", ++ "Delay agnostic mode (does nothing)", + "Enable or disable the delay agnostic mode.", + FALSE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | +- G_PARAM_CONSTRUCT))); ++ G_PARAM_CONSTRUCT | G_PARAM_DEPRECATED))); + + g_object_class_install_property (gobject_class, + PROP_TARGET_LEVEL_DBFS, +@@ -1111,24 +1041,23 @@ gst_webrtc_dsp_class_init (GstWebrtcDspClass * klass) + g_object_class_install_property (gobject_class, + PROP_VOICE_DETECTION_FRAME_SIZE_MS, + g_param_spec_int ("voice-detection-frame-size-ms", +- "Voice Detection Frame Size Milliseconds", ++ "Voice detection frame size in milliseconds (does nothing)", + "Sets the |size| of the frames in ms on which the VAD will operate. " + "Larger frames will improve detection accuracy, but reduce the " + "frequency of updates", + 10, 30, DEFAULT_VOICE_DETECTION_FRAME_SIZE_MS, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | +- G_PARAM_CONSTRUCT))); ++ G_PARAM_CONSTRUCT | G_PARAM_DEPRECATED))); + + g_object_class_install_property (gobject_class, + PROP_VOICE_DETECTION_LIKELIHOOD, + g_param_spec_enum ("voice-detection-likelihood", +- "Voice Detection Likelihood", ++ "Voice detection likelihood (does nothing)", + "Specifies the likelihood that a frame will be declared to contain " + "voice.", +- GST_TYPE_WEBRTC_VOICE_DETECTION_LIKELIHOOD, +- DEFAULT_VOICE_DETECTION_LIKELIHOOD, ++ GST_TYPE_WEBRTC_VOICE_DETECTION_LIKELIHOOD, 2, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | +- G_PARAM_CONSTRUCT))); ++ G_PARAM_CONSTRUCT | G_PARAM_DEPRECATED))); + + gst_type_mark_as_plugin_api (GST_TYPE_WEBRTC_GAIN_CONTROL_MODE, (GstPluginAPIFlags) 0); + gst_type_mark_as_plugin_api (GST_TYPE_WEBRTC_NOISE_SUPPRESSION_LEVEL, (GstPluginAPIFlags) 0); +diff --git a/ext/webrtcdsp/gstwebrtcechoprobe.cpp b/ext/webrtcdsp/gstwebrtcechoprobe.cpp +index acdb3d8a7d..8e8ca064c4 100644 +--- a/ext/webrtcdsp/gstwebrtcechoprobe.cpp ++++ b/ext/webrtcdsp/gstwebrtcechoprobe.cpp +@@ -33,7 +33,8 @@ + + #include "gstwebrtcechoprobe.h" + +-#include ++#include ++ + #include + + GST_DEBUG_CATEGORY_EXTERN (webrtc_dsp_debug); +@@ -102,7 +103,7 @@ gst_webrtc_echo_probe_setup (GstAudioFilter * filter, const GstAudioInfo * info) + self->period_size = self->period_samples * info->bpf; + + if (self->interleaved && +- (webrtc::AudioFrame::kMaxDataSizeSamples * 2) < self->period_size) ++ (MAX_DATA_SIZE_SAMPLES * 2) < self->period_size) + goto period_too_big; + + GST_WEBRTC_ECHO_PROBE_UNLOCK (self); +@@ -112,9 +113,9 @@ gst_webrtc_echo_probe_setup (GstAudioFilter * filter, const GstAudioInfo * info) + period_too_big: + GST_WEBRTC_ECHO_PROBE_UNLOCK (self); + GST_WARNING_OBJECT (self, "webrtcdsp format produce too big period " +- "(maximum is %" G_GSIZE_FORMAT " samples and we have %u samples), " ++ "(maximum is %d samples and we have %u samples), " + "reduce the number of channels or the rate.", +- webrtc::AudioFrame::kMaxDataSizeSamples, self->period_size / 2); ++ MAX_DATA_SIZE_SAMPLES, self->period_size / 2); + return FALSE; + } + +@@ -303,18 +304,20 @@ gst_webrtc_release_echo_probe (GstWebrtcEchoProbe * probe) + + gint + gst_webrtc_echo_probe_read (GstWebrtcEchoProbe * self, GstClockTime rec_time, +- gpointer _frame, GstBuffer ** buf) ++ GstBuffer ** buf) + { +- webrtc::AudioFrame * frame = (webrtc::AudioFrame *) _frame; + GstClockTimeDiff diff; +- gsize avail, skip, offset, size; ++ gsize avail, skip, offset, size = 0; + gint delay = -1; + + GST_WEBRTC_ECHO_PROBE_LOCK (self); + ++ /* We always return a buffer -- if don't have data (size == 0), we generate a ++ * silence buffer */ ++ + if (!GST_CLOCK_TIME_IS_VALID (self->latency) || + !GST_AUDIO_INFO_IS_VALID (&self->info)) +- goto done; ++ goto copy; + + if (self->interleaved) + avail = gst_adapter_available (self->adapter) / self->info.bpf; +@@ -324,7 +327,7 @@ gst_webrtc_echo_probe_read (GstWebrtcEchoProbe * self, GstClockTime rec_time, + /* In delay agnostic mode, just return 10ms of data */ + if (!GST_CLOCK_TIME_IS_VALID (rec_time)) { + if (avail < self->period_samples) +- goto done; ++ goto copy; + + size = self->period_samples; + skip = 0; +@@ -371,23 +374,51 @@ gst_webrtc_echo_probe_read (GstWebrtcEchoProbe * self, GstClockTime rec_time, + size = MIN (avail - offset, self->period_samples - skip); + + copy: +- if (self->interleaved) { +- skip *= self->info.bpf; +- offset *= self->info.bpf; +- size *= self->info.bpf; +- +- if (size < self->period_size) +- memset (frame->data_, 0, self->period_size); +- +- if (size) { +- gst_adapter_copy (self->adapter, (guint8 *) frame->data_ + skip, +- offset, size); +- gst_adapter_flush (self->adapter, offset + size); +- } ++ if (!size) { ++ /* No data, provide a period's worth of silence */ ++ *buf = gst_buffer_new_allocate (NULL, self->period_size, NULL); ++ gst_buffer_memset (*buf, 0, 0, self->period_size); ++ gst_buffer_add_audio_meta (*buf, &self->info, self->period_samples, ++ NULL); + } else { ++ /* We have some actual data, pop period_samples' worth if have it, else pad ++ * with silence and provide what we do have */ + GstBuffer *ret, *taken, *tmp; + +- if (size) { ++ if (self->interleaved) { ++ skip *= self->info.bpf; ++ offset *= self->info.bpf; ++ size *= self->info.bpf; ++ ++ gst_adapter_flush (self->adapter, offset); ++ ++ /* we need to fill silence at the beginning and/or the end of the ++ * buffer in order to have period_samples in the buffer */ ++ if (size < self->period_size) { ++ gsize padding = self->period_size - (skip + size); ++ ++ taken = gst_adapter_take_buffer (self->adapter, size); ++ ret = gst_buffer_new (); ++ ++ /* need some silence at the beginning */ ++ if (skip) { ++ tmp = gst_buffer_new_allocate (NULL, skip, NULL); ++ gst_buffer_memset (tmp, 0, 0, skip); ++ ret = gst_buffer_append (ret, tmp); ++ } ++ ++ ret = gst_buffer_append (ret, taken); ++ ++ /* need some silence at the end */ ++ if (padding) { ++ tmp = gst_buffer_new_allocate (NULL, padding, NULL); ++ gst_buffer_memset (tmp, 0, 0, padding); ++ ret = gst_buffer_append (ret, tmp); ++ } ++ } else { ++ ret = gst_adapter_take_buffer (self->adapter, size); ++ } ++ } else { + gst_planar_audio_adapter_flush (self->padapter, offset); + + /* we need to fill silence at the beginning and/or the end of each +@@ -430,23 +461,13 @@ copy: + ret = gst_planar_audio_adapter_take_buffer (self->padapter, size, + GST_MAP_READWRITE); + } +- } else { +- ret = gst_buffer_new_allocate (NULL, self->period_size, NULL); +- gst_buffer_memset (ret, 0, 0, self->period_size); +- gst_buffer_add_audio_meta (ret, &self->info, self->period_samples, +- NULL); + } + + *buf = ret; + } + +- frame->num_channels_ = self->info.channels; +- frame->sample_rate_hz_ = self->info.rate; +- frame->samples_per_channel_ = self->period_samples; +- + delay = self->delay; + +-done: + GST_WEBRTC_ECHO_PROBE_UNLOCK (self); + + return delay; +diff --git a/ext/webrtcdsp/gstwebrtcechoprobe.h b/ext/webrtcdsp/gstwebrtcechoprobe.h +index 36fd34f179..488c0e958f 100644 +--- a/ext/webrtcdsp/gstwebrtcechoprobe.h ++++ b/ext/webrtcdsp/gstwebrtcechoprobe.h +@@ -45,6 +45,12 @@ G_BEGIN_DECLS + #define GST_WEBRTC_ECHO_PROBE_LOCK(obj) g_mutex_lock (&GST_WEBRTC_ECHO_PROBE (obj)->lock) + #define GST_WEBRTC_ECHO_PROBE_UNLOCK(obj) g_mutex_unlock (&GST_WEBRTC_ECHO_PROBE (obj)->lock) + ++/* From the webrtc audio_frame.h definition of kMaxDataSizeSamples: ++ * Stereo, 32 kHz, 120 ms (2 * 32 * 120) ++ * Stereo, 192 kHz, 20 ms (2 * 192 * 20) ++ */ ++#define MAX_DATA_SIZE_SAMPLES 7680 ++ + typedef struct _GstWebrtcEchoProbe GstWebrtcEchoProbe; + typedef struct _GstWebrtcEchoProbeClass GstWebrtcEchoProbeClass; + +@@ -71,6 +77,7 @@ struct _GstWebrtcEchoProbe + GstClockTime latency; + gint delay; + gboolean interleaved; ++ gint extra_delay; + + GstSegment segment; + GstAdapter *adapter; +@@ -92,7 +99,7 @@ GST_ELEMENT_REGISTER_DECLARE (webrtcechoprobe); + GstWebrtcEchoProbe *gst_webrtc_acquire_echo_probe (const gchar * name); + void gst_webrtc_release_echo_probe (GstWebrtcEchoProbe * probe); + gint gst_webrtc_echo_probe_read (GstWebrtcEchoProbe * self, +- GstClockTime rec_time, gpointer frame, GstBuffer ** buf); ++ GstClockTime rec_time, GstBuffer ** buf); + + G_END_DECLS + #endif /* __GST_WEBRTC_ECHO_PROBE_H__ */ +diff --git a/ext/webrtcdsp/meson.build b/ext/webrtcdsp/meson.build +index 5aeae69a44..09565e27c7 100644 +--- a/ext/webrtcdsp/meson.build ++++ b/ext/webrtcdsp/meson.build +@@ -4,7 +4,7 @@ webrtc_sources = [ + 'gstwebrtcdspplugin.cpp' + ] + +-webrtc_dep = dependency('webrtc-audio-processing', version : ['>= 0.2', '< 0.4'], ++webrtc_dep = dependency('webrtc-audio-processing-1', version : ['>= 1.0'], + required : get_option('webrtcdsp')) + + if not gnustl_dep.found() and get_option('webrtcdsp').enabled() +@@ -20,7 +20,7 @@ if webrtc_dep.found() and gnustl_dep.found() + dependencies : [gstbase_dep, gstaudio_dep, gstbadaudio_dep, webrtc_dep, gnustl_dep], + install : true, + install_dir : plugins_install_dir, +- override_options : ['cpp_std=c++11'], ++ override_options : ['cpp_std=c++17'], + ) + plugins += [gstwebrtcdsp] + endif +-- +2.34.1 + diff --git a/general/package/gst1-plugins-bad-openipc/Config.in b/general/package/gst1-plugins-bad-openipc/Config.in new file mode 100644 index 00000000..46be54df --- /dev/null +++ b/general/package/gst1-plugins-bad-openipc/Config.in @@ -0,0 +1,760 @@ +menuconfig BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC + bool "gst1-plugins-bad-openipc" + depends on BR2_INSTALL_LIBSTDCPP + select BR2_PACKAGE_GST1_PLUGINS_BASE + help + A set of plug-ins for GStreamer that may be of poor quality + or lacking some features. + + Shadowed for OpenIPC + + https://gstreamer.freedesktop.org/ + +if BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC + +comment "dependency-less plugins" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ACCURIP + bool "accurip" + help + Accurip plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ADPCMDEC + bool "adpcmdec" + help + ADPCM decoder + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ADPCMENC + bool "adpcmenc" + help + ADPCM encoder + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AIFF + bool "aiff" + help + Create and parse Audio interchange File Format (AIFF) files + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ASFMUX + bool "asfmux" + help + ASF Muxer Plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOBUFFERSPLIT + bool "audiobuffersplit" + help + Audio buffersplit plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOFXBAD + bool "audiofxbad" + help + Audio filters plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOLATENCY + bool "audiolatency" + help + Audio latency plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOMIXMATRIX + bool "audiomixmatrix" + help + Audio N:M mixer plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOVISUALIZERS + bool "audiovisualizers" + help + Creates video visualizations of audio input + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUTOCONVERT + bool "autoconvert" + help + Selects convertor element based on caps + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_BAYER + bool "bayer" + help + Elements to convert Bayer images + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_CAMERABIN2 + bool "camerabin2" + help + Take image snapshots and record movies from camera + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_CODECALPHA + bool "codecalpha" + help + Elements for VP8/VP9 alpha support (codecalphademux, + alphacombine, vp8alphadecodebin, vp9alphadecodebin) + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_COLOREFFECTS + bool "coloreffects" + help + Color Look-up Table filters + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DEBUGUTILS + bool "debugutils" + help + Collection of elements that may or may not be useful for + debugging + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DVBSUBENC + bool "dvbsubenc" + help + DVB subpicture encoding support + +config BR2_PACKAGE_GST1_PLUGINS_BAD_PLUGIN_DVBSUBOVERLAY + bool "dvbsuboverlay" + help + DVB subtitle renderer plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DVDSPU + bool "dvdspu" + help + DVD Sub-picture Overlay element + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FACEOVERLAY + bool "faceoverlay" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FESTIVAL + bool "festival" + help + Synthesizes plain text into audio + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FIELDANALYSIS + bool "fieldanalysis" + help + Video field analysis + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FREEVERB + bool "freeverb" + help + Reverberation/room effect + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FREI0R + bool "frei0r" + help + frei0r plugin library + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_GAUDIEFFECTS + bool "gaudieffects" + help + Gaudi video effects + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_GEOMETRICTRANSFORM + bool "geometrictransform" + help + Various geometric image transform elements + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_GDP + bool "gdp" + help + Payload/depayload GDP packets + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ID3TAG + bool "id3tag" + help + ID3 v1 and v2 muxing plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_INTER + bool "inter" + help + plugin for inter-pipeline communication + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_INTERLACE + bool "interlace" + help + Create an interlaced video stream + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_IVFPARSE + bool "ivfparse" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_IVTC + bool "ivtc" + help + Inverse Telecine plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_JP2KDECIMATOR + bool "jp2kdecimator" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC-PLUGIN_JPEGFORMAT + bool "jpegformat" + help + JPEG interchange format plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_LIBRFB + bool "librfb" + help + Connects to a VNC server and decodes RFB stream + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MIDI + bool "midi" + help + MIDI plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEGDEMUX + bool "mpegdemux" + help + MPEG-PS demuxer + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEGTSDEMUX + bool "mpegtsdemux" + help + MPEG TS demuxer + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEGTSMUX + bool "mpegtsmux" + help + MPEG-TS muxer + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEGPSMUX + bool "mpegpsmux" + help + MPEG-PS muxer + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MXF + bool "mxf" + help + MXF plugin library + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_NETSIM + bool "netsim" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ONVIF + bool "onvif" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_PCAPPARSE + bool "pcapparse" + help + Element parsing raw pcap streams + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_PNM + bool "pnm" + help + PNM plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_PROXY + bool "proxy" + help + Proxy plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RAWPARSE + bool "rawparse" + help + Parses byte streams into raw frames + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_REMOVESILENCE + bool "removesilence" + help + Removes silence from an audio stream + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RIST + bool "rist" + help + RIST streaming + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RTMP2 + bool "rtmp2" + help + RTMP sink/source (rtmp2sink, rtmp2src) + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RTP2 + bool "rtp" + help + RTP (rtpsrc/rtpsink) + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RTMP + bool "rtmp" + select BR2_PACKAGE_RTMPDUMP + help + RTMP plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SDP + bool "sdp" + help + configure streaming sessions using SDP + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SEGMENTCLIP + bool "segmentclip" + help + Segment clip elements + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SIREN + bool "siren" + help + Siren encoder/decoder/payloader/depayloader plugins + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SMOOTH + bool "smooth" + help + Apply a smooth filter to an image + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SPEED + bool "speed" + help + Set speed/pitch on audio/raw streams (resampler) + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SUBENC + bool "subenc" + help + subtitle encoders + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SWITCHBIN + bool "switchbin" + help + Switching between paths based on input caps + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_TIMECODE + bool "timecode" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VIDEOFILTERS + bool "videofilters" + help + Video filters in gst-plugins-bad + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VIDEOFRAME_AUDIOLEVEL + bool "videoframe_audiolevel" + help + videoframe_audiolevel + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VIDEOPARSERS + bool "videoparsers" + help + videoparsers + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VIDEOSIGNAL + bool "videosignal" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VMNC + bool "vmnc" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_Y4M + bool "y4m" + help + Demuxes/decodes YUV4MPEG streams + +comment "plugins with external dependencies" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AES + bool "aes" + select BR2_PACKAGE_OPENSSL + help + "AES encryption/decryption plugin" + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ASSRENDER + bool "assrender" + depends on BR2_INSTALL_LIBSTDCPP # libass -> harfbuzz + depends on BR2_TOOLCHAIN_HAS_SYNC_4 # libass -> harfbuzz + depends on BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 # libass -> harfbuzz + select BR2_PACKAGE_LIBASS + +comment "assrender plugin needs a toolchain w/ C++, gcc >= 4.9" + depends on BR2_TOOLCHAIN_HAS_SYNC_4 + depends on !BR2_INSTALL_LIBSTDCPP || \ + !BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_BLUEZ + bool "bluez" + depends on BR2_USE_WCHAR # bluez5_utils -> libglib2 + depends on BR2_TOOLCHAIN_HAS_THREADS # bluez5_utils -> dbus, libglib2 + depends on BR2_USE_MMU # bluez5_utils -> dbus + depends on !BR2_STATIC_LIBS # bluez5_utils -> uses dlfcn + depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_4 # bluez5_utils + depends on BR2_TOOLCHAIN_HAS_SYNC_4 # bluez5_utils + select BR2_PACKAGE_BLUEZ5_UTILS + select BR2_PACKAGE_BLUEZ5_UTILS_PLUGINS_AUDIO # runtime + help + Bluetooth audio A2DP/AVDTP sink, AVDTP source plugin + +comment "bluez plugin needs a toolchain w/ wchar, threads, headers >= 3.4, dynamic library" + depends on !BR2_USE_WCHAR || !BR2_TOOLCHAIN_HAS_THREADS || \ + !BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_4 || BR2_STATIC_LIBS + depends on BR2_TOOLCHAIN_HAS_SYNC_4 + depends on BR2_USE_MMU + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_BZ2 + bool "bz2" + select BR2_PACKAGE_BZIP2 + help + Compress or decompress streams + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_CURL + bool "curl" + select BR2_PACKAGE_LIBCURL + help + libcurl-based elements + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DASH + bool "dash" + select BR2_PACKAGE_LIBXML2 + help + DASH demuxer plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DECKLINK + bool "decklink" + depends on BR2_INSTALL_LIBSTDCPP + depends on !BR2_STATIC_LIBS # + help + Blackmagic Decklink plugin + +comment "decklink needs a toolchain w/ C++, dynamic library" + depends on !BR2_INSTALL_LIBSTDCPP || BR2_STATIC_LIBS + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DIRECTFB + bool "directfb" + default y + depends on BR2_PACKAGE_DIRECTFB + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DVB + bool "dvb" + # FEC_2_5 / QAM_4_NR definitions + depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_7 + select BR2_PACKAGE_DTV_SCAN_TABLES + help + DVB elements + +comment "dvb needs a toolchain w/ headers >= 3.7" + depends on !BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_7 + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FAAD + bool "faad" + select BR2_PACKAGE_FAAD2 + help + Free AAC Decoder (FAAD) + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FBDEV + bool "fbdev" + help + Linux framebuffer video sink + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FDK_AAC + bool "fdk-aac" + depends on BR2_PACKAGE_FDK_AAC_ARCH_SUPPORTS + depends on BR2_INSTALL_LIBSTDCPP + select BR2_PACKAGE_FDK_AAC + help + MPEG AAC encoder/decoder + +comment "fdk-aac needs a toolchain w/ C++" + depends on BR2_PACKAGE_FDK_AAC_ARCH_SUPPORTS + depends on !BR2_INSTALL_LIBSTDCPP + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FLUIDSYNTH + bool "fluidsynth" + depends on !BR2_STATIC_LIBS # fluidsynth + depends on BR2_USE_WCHAR # fluidsynth + depends on BR2_TOOLCHAIN_HAS_THREADS # fluidsynth + depends on BR2_USE_MMU # fluidsynth + select BR2_PACKAGE_FLUIDSYNTH + help + Fluidsynth MIDI decoder plugin + +comment "fluidsynth needs a toolchain w/ threads, wchar, dynamic library" + depends on BR2_USE_MMU + depends on !BR2_USE_WCHAR || !BR2_TOOLCHAIN_HAS_THREADS || \ + BR2_STATIC_LIBS + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_GL + bool "gl" + default y + depends on BR2_PACKAGE_GST1_PLUGINS_BASE_HAS_LIB_OPENGL + +comment "gl needs the gst1-plugins-base opengl library" + depends on !BR2_PACKAGE_GST1_PLUGINS_BASE_HAS_LIB_OPENGL + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_HLS + bool "hls" + select BR2_PACKAGE_NETTLE if !(BR2_PACKAGE_LIBGCRYPT || BR2_PACKAGE_OPENSSL) + help + Fragmented streaming plugins + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_KMS + bool "kmssink" + depends on BR2_TOOLCHAIN_HAS_THREADS # libdrm -> libpthread-stubs + select BR2_PACKAGE_LIBDRM + help + KMS video sink + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DTLS + bool "dtls" + select BR2_PACKAGE_OPENSSL + help + DTLS plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_TTML + bool "ttml" + depends on BR2_USE_WCHAR # pango -> glib2 + depends on BR2_TOOLCHAIN_HAS_THREADS # pango -> glib2 + depends on BR2_USE_MMU # pango -> glib2 + depends on BR2_INSTALL_LIBSTDCPP # pango -> freetype + depends on BR2_TOOLCHAIN_HAS_SYNC_4 # pango -> harfbuzz + depends on BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 # pango -> harfbuzz + select BR2_PACKAGE_CAIRO + select BR2_PACKAGE_LIBXML2 + select BR2_PACKAGE_PANGO + help + Timed Text Markup Language (TTML) subtitle plugin + +comment "ttml needs a toolchain w/ wchar, threads, C++, gcc >= 4.9" + depends on BR2_TOOLCHAIN_HAS_SYNC_4 + depends on BR2_USE_MMU + depends on !BR2_USE_WCHAR || !BR2_TOOLCHAIN_HAS_THREADS || \ + !BR2_INSTALL_LIBSTDCPP || !BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEG2ENC + bool "mpeg2enc" + depends on BR2_USE_MMU # fork + depends on BR2_INSTALL_LIBSTDCPP + depends on BR2_TOOLCHAIN_HAS_THREADS + select BR2_PACKAGE_LIBMPEG2 + select BR2_PACKAGE_MJPEGTOOLS + help + High-quality MPEG-1/2 video encoder + +comment "mpeg2enc needs a toolchain w/ threads, C++" + depends on BR2_USE_MMU + depends on !BR2_TOOLCHAIN_HAS_THREADS \ + || !BR2_INSTALL_LIBSTDCPP + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MUSEPACK + bool "musepack" + select BR2_PACKAGE_MUSEPACK + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_NEON + bool "neon" + select BR2_PACKAGE_NEON + help + lib neon http client src + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_OPENAL + bool "openal" + depends on BR2_INSTALL_LIBSTDCPP + depends on BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 + depends on BR2_TOOLCHAIN_HAS_THREADS_NPTL + depends on BR2_PACKAGE_OPENAL_ARCH_SUPPORTS + select BR2_PACKAGE_OPENAL + +comment "openal plugin needs a toolchain w/ NPTL, C++, gcc >= 4.9" + depends on BR2_PACKAGE_OPENAL_ARCH_SUPPORTS + depends on !BR2_TOOLCHAIN_HAS_THREADS_NPTL \ + || !BR2_INSTALL_LIBSTDCPP \ + || !BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_OPENH264 + bool "openh264" + depends on BR2_PACKAGE_LIBOPENH264_ARCH_SUPPORTS + depends on BR2_INSTALL_LIBSTDCPP # libopenh264 + depends on !BR2_STATIC_LIBS # libopenh264 + depends on BR2_TOOLCHAIN_HAS_THREADS # libopenh264 + select BR2_PACKAGE_LIBOPENH264 + help + OpenH264 based encoding/decoding plugin + +comment "openh264 plugin needs a toolchain w/ C++, dynamic library, threads" + depends on !BR2_INSTALL_LIBSTDCPP || !BR2_TOOLCHAIN_HAS_THREADS || \ + BR2_STATIC_LIBS + depends on BR2_PACKAGE_LIBOPENH264_ARCH_SUPPORTS + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_OPENJPEG + bool "openjpeg" + select BR2_PACKAGE_OPENJPEG + help + GStreamer OpenJPEG plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_OPUS + bool "opus" + select BR2_PACKAGE_OPUS + help + OPUS plugin library + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_QROVERLAY + bool "qroverlay" + select BR2_PACKAGE_JSON_GLIB + select BR2_PACKAGE_LIBQRENCODE + help + Elements qroverlay, debugqroverlay (overlay data on top of + video in the form of a QR code) + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RSVG + bool "rsvg" + depends on BR2_PACKAGE_HOST_RUSTC_TARGET_ARCH_SUPPORTS # librsvg + depends on BR2_INSTALL_LIBSTDCPP # librsvg -> pango + depends on BR2_TOOLCHAIN_HAS_SYNC_4 # librsvg -> pango -> harfbuzz + depends on BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 # librsvg -> pango -> harfbuzz + select BR2_PACKAGE_LIBRSVG + help + RSVG plugin library + +comment "rsvg plugin needs a toolchain w/ C++, gcc >= 4.9" + depends on BR2_PACKAGE_HOST_RUSTC_TARGET_ARCH_SUPPORTS + depends on !BR2_INSTALL_LIBSTDCPP || \ + !BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 + depends on BR2_TOOLCHAIN_HAS_SYNC_4 + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SBC + bool "sbc" + select BR2_PACKAGE_SBC + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SCTP + bool "sctp" + depends on BR2_TOOLCHAIN_HAS_SYNC_4 # __sync_*_4 intrinsics + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SHM + bool "shm" + help + shared memory sink source + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SNDFILE + bool "sndfile" + select BR2_PACKAGE_LIBSNDFILE + +config BR2_PACKAGE_GST1_PLUGINS_BAD_PLUGIN_SRTP + bool "srtp" + select BR2_PACKAGE_LIBSRTP + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_UVCH264 + bool "uvch264" + depends on BR2_PACKAGE_HAS_UDEV # libgudev + depends on BR2_TOOLCHAIN_HAS_THREADS # libgudev, libusb + depends on BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 # libusb + depends on BR2_USE_MMU # libgudev + depends on BR2_USE_WCHAR # libgudev + select BR2_PACKAGE_LIBGUDEV + select BR2_PACKAGE_LIBUSB + help + UVC compliant H.264 camera source plugin + +comment "uvch264 needs udev /dev management" + depends on BR2_USE_MMU + depends on !BR2_PACKAGE_HAS_UDEV + +comment "uvch264 needs a toolchain w/ threads, wchar, gcc >= 4.9" + depends on BR2_USE_MMU + depends on !BR2_USE_WCHAR || !BR2_TOOLCHAIN_HAS_THREADS || \ + !BR2_TOOLCHAIN_GCC_AT_LEAST_4_9 + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VA + bool "va" + depends on !BR2_STATIC_LIBS # libva + depends on BR2_TOOLCHAIN_HAS_THREADS # libva + select BR2_PACKAGE_LIBVA + help + VA-API new plugin + +comment "va needs a toolchain w/ threads, dynamic library" + depends on BR2_STATIC_LIBS || !BR2_TOOLCHAIN_HAS_THREADS + +config BR2_PACKAGE_GST1_PLUGINS_BAD_PLUGIN_OPENIPC_VOAACENC + bool "voaacenc" + select BR2_PACKAGE_VO_AACENC + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WAYLAND + bool "wayland" + default y + depends on BR2_PACKAGE_WAYLAND + depends on BR2_TOOLCHAIN_HAS_THREADS # libdrm -> libpthread-stubs + select BR2_PACKAGE_LIBDRM + select BR2_PACKAGE_WAYLAND_PROTOCOLS + help + Wayland Video Sink + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WEBP + bool "webp" + select BR2_PACKAGE_WEBP + help + Webp image format plugin + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WEBRTC + bool "webrtc" + depends on !BR2_STATIC_LIBS # libnice -> gnutls + select BR2_PACKAGE_GST1_PLUGINS_BASE # libgstsdp + select BR2_PACKAGE_LIBNICE + help + WebRTC plugins (webrtcbin - a bin for webrtc connections) + +comment "webrtc needs a toolchain w/ dynamic library" + depends on BR2_STATIC_LIBS + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WEBRTCDSP + bool "webrtcdsp" + # All depends from webrtc-audio-processing + depends on BR2_PACKAGE_WEBRTC_AUDIO_PROCESSING_ARCH_SUPPORTS + depends on BR2_PACKAGE_LIBABSEIL_CPP_ARCH_SUPPORTS + depends on BR2_INSTALL_LIBSTDCPP + depends on BR2_TOOLCHAIN_GCC_AT_LEAST_8 + depends on BR2_TOOLCHAIN_HAS_THREADS_NPTL + depends on !BR2_STATIC_LIBS + select BR2_PACKAGE_WEBRTC_AUDIO_PROCESSING + help + WebRTC echo-cancellation, gain control and noise suppression + +comment "webrtcdsp needs a toolchain w/ C++, NPTL, dynamic library, gcc >= 8" + depends on BR2_PACKAGE_WEBRTC_AUDIO_PROCESSING_ARCH_SUPPORTS + depends on BR2_PACKAGE_LIBABSEIL_CPP_ARCH_SUPPORTS + depends on !BR2_INSTALL_LIBSTDCPP || !BR2_TOOLCHAIN_HAS_THREADS_NPTL \ + || BR2_STATIC_LIBS || !BR2_TOOLCHAIN_GCC_AT_LEAST_8 + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WPE + bool "wpe" + default y + depends on BR2_PACKAGE_WPEWEBKIT + depends on BR2_PACKAGE_GST1_PLUGINS_BASE_HAS_LIB_OPENGL + depends on !BR2_PACKAGE_WPEWEBKIT_MEDIA_STREAM + +comment "wpe needs the gst1-plugins-base opengl library and wpewebkit" + depends on !BR2_PACKAGE_WPEWEBKIT \ + || !BR2_PACKAGE_GST1_PLUGINS_BASE_HAS_LIB_OPENGL + +comment "wpe is incompatible w/ wpewebkit media-stream support" + depends on BR2_PACKAGE_WPEWEBKIT + depends on BR2_PACKAGE_GST1_PLUGINS_BASE_HAS_LIB_OPENGL + depends on BR2_PACKAGE_WPEWEBKIT_MEDIA_STREAM + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_V4L2CODECS + bool "v4l2codecs" + depends on BR2_PACKAGE_HAS_UDEV # libgudev + select BR2_PACKAGE_LIBGUDEV + help + Video4Linux Stateless CODECs support + +comment "v4l2codecs need udev /dev management" + depends on !BR2_PACKAGE_HAS_UDEV + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_X265 + bool "x265" + depends on BR2_INSTALL_LIBSTDCPP + depends on !BR2_STATIC_LIBS + depends on BR2_TOOLCHAIN_HAS_SYNC_4 # x265 + select BR2_PACKAGE_X265 + help + x265 encoding plugin + +comment "x265 needs a toolchain w/ C++, dynamic library" + depends on !BR2_INSTALL_LIBSTDCPP || BR2_STATIC_LIBS + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_ZBAR + bool "zbar" + depends on BR2_TOOLCHAIN_HAS_THREADS # zbar-> libv4l + depends on BR2_USE_MMU # zbar-> libv4l + depends on BR2_INSTALL_LIBSTDCPP # zbar-> libv4l + depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_0 # zbar -> libv4l + select BR2_PACKAGE_ZBAR + +comment "zbar plugin needs a toolchain w/ threads, C++ and headers >= 3.0" + depends on BR2_USE_MMU + depends on !BR2_TOOLCHAIN_HAS_THREADS \ + || !BR2_INSTALL_LIBSTDCPP || !BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_0 + +config BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_ZXING + bool "zxing" + depends on !BR2_STATIC_LIBS # zxing-cpp + depends on BR2_USE_WCHAR # zxing-cpp + depends on BR2_INSTALL_LIBSTDCPP # zxing-cpp + select BR2_PACKAGE_ZXING_CPP + +comment "zxing plugin needs a toolchain w/ C++, wchar, dynamic library" + depends on BR2_STATIC_LIBS || !BR2_USE_WCHAR || \ + !BR2_INSTALL_LIBSTDCPP + +endif + +comment "gst1-plugins-bad-openipc needs a toolchain w/ C++" + depends on !BR2_INSTALL_LIBSTDCPP diff --git a/general/package/gst1-plugins-bad-openipc/gst1-plugins-bad-openipc.hash b/general/package/gst1-plugins-bad-openipc/gst1-plugins-bad-openipc.hash new file mode 100644 index 00000000..174c4ad5 --- /dev/null +++ b/general/package/gst1-plugins-bad-openipc/gst1-plugins-bad-openipc.hash @@ -0,0 +1,3 @@ +# From https://gstreamer.freedesktop.org/src/gst-plugins-bad/gst-plugins-bad-1.22.9.tar.xz.sha256sum +sha256 1bc65d0fd5f53a3636564efd3fcf318c3edcdec39c4109a503c1fc8203840a1d gst-plugins-bad-1.22.9.tar.xz +sha256 dc626520dcd53a22f727af3ee42c770e56c97a64fe3adb063799d8ab032fe551 COPYING diff --git a/general/package/gst1-plugins-bad-openipc/gst1-plugins-bad-openipc.mk b/general/package/gst1-plugins-bad-openipc/gst1-plugins-bad-openipc.mk new file mode 100644 index 00000000..2f3158a6 --- /dev/null +++ b/general/package/gst1-plugins-bad-openipc/gst1-plugins-bad-openipc.mk @@ -0,0 +1,850 @@ +################################################################################ +# +# gst1-plugins-bad-openipc +# +# Changes from upstream +# - disable build of nvcodec +################################################################################ + +GST1_PLUGINS_BAD_OPENIPC_VERSION = 1.22.9 +GST1_PLUGINS_BAD_OPENIPC_SOURCE = gst-plugins-bad-$(GST1_PLUGINS_BAD_VERSION).tar.xz +GST1_PLUGINS_BAD_OPENIPC_SITE = https://gstreamer.freedesktop.org/src/gst-plugins-bad +GST1_PLUGINS_BAD_OPENIPC_INSTALL_STAGING = YES +# Additional plugin licenses will be appended to GST1_PLUGINS_BAD_OPENIPC_LICENSE and +# GST1_PLUGINS_BAD_OPENIPC_LICENSE_FILES if enabled. +GST1_PLUGINS_BAD_OPENIPC_LICENSE_FILES = COPYING +GST1_PLUGINS_BAD_OPENIPC_LICENSE = LGPL-2.0+ +GST1_PLUGINS_BAD_OPENIPC_CPE_ID_VENDOR = freedesktop +GST1_PLUGINS_BAD_OPENIPC_CPE_ID_PRODUCT = gst-plugins-bad + +GST1_PLUGINS_BAD_OPENIPC_CFLAGS = $(TARGET_CFLAGS) -std=c99 -D_GNU_SOURCE +GST1_PLUGINS_BAD_OPENIPC_LDFLAGS = $(TARGET_LDFLAGS) $(TARGET_NLS_LIBS) + +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS = \ + -Dexamples=disabled \ + -Dtests=disabled \ + -Ddirectsound=disabled \ + -Dd3dvideosink=disabled \ + -Dwinks=disabled \ + -Dandroidmedia=disabled \ + -Dapplemedia=disabled \ + -Dgobject-cast-checks=disabled \ + -Dglib-asserts=disabled \ + -Dglib-checks=disabled \ + -Dextra-checks=disabled \ + -Ddoc=disabled \ + +# Options which require currently unpackaged libraries +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += \ + -Dasio=disabled \ + -Davtp=disabled \ + -Dopensles=disabled \ + -Dmsdk=disabled \ + -Dvoamrwbenc=disabled \ + -Dbs2b=disabled \ + -Dchromaprint=disabled \ + -Dd3d11=disabled \ + -Ddc1394=disabled \ + -Ddts=disabled \ + -Dresindvd=disabled \ + -Dfaac=disabled \ + -Dflite=disabled \ + -Dgs=disabled \ + -Dgsm=disabled \ + -Dkate=disabled \ + -Dladspa=disabled \ + -Dldac=disabled \ + -Dlv2=disabled \ + -Dmediafoundation=disabled \ + -Dmicrodns=disabled \ + -Dlibde265=disabled \ + -Dmodplug=disabled \ + -Dmplex=disabled \ + -Donnx=disabled \ + -Dopenexr=disabled \ + -Dopenni2=disabled \ + -Dteletext=disabled \ + -Dwildmidi=disabled \ + -Dsmoothstreaming=disabled \ + -Dsoundtouch=disabled \ + -Dgme=disabled \ + -Dspandsp=disabled \ + -Dsvthevcenc=disabled \ + -Dtranscode=disabled \ + -Dwasapi2=disabled \ + -Dmagicleap=disabled \ + -Disac=disabled \ + -Diqa=disabled \ + -Dopencv=disabled + +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES = gst1-plugins-base gstreamer1 + +ifeq ($(BR2_PACKAGE_GOBJECT_INTROSPECTION),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dintrospection=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += gobject-introspection +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dintrospection=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WAYLAND),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwayland=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libdrm wayland wayland-protocols +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwayland=disabled +endif + +ifeq ($(BR2_PACKAGE_ORC),y) +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += orc +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dorc=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dorc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_BLUEZ),y) +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += bluez5_utils +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dbluez=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dbluez=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ACCURIP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daccurip=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daccurip=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ADPCMDEC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dadpcmdec=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dadpcmdec=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ADPCMENC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dadpcmenc=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dadpcmenc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AIFF),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daiff=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daiff=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ASFMUX),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dasfmux=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dasfmux=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOBUFFERSPLIT),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiobuffersplit=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiobuffersplit=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOFXBAD),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiofxbad=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiofxbad=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOLATENCY),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiolatency=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiolatency=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOMIXMATRIX),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiomixmatrix=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiomixmatrix=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUDIOVISUALIZERS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiovisualizers=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daudiovisualizers=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AUTOCONVERT),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dautoconvert=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dautoconvert=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_OPENIPC_BAD_PLUGIN_BAYER),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dbayer=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dbayer=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_CAMERABIN2),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dcamerabin2=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dcamerabin2=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_CODECALPHA),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dcodecalpha=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dcodecalpha=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_COLOREFFECTS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dcoloreffects=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dcoloreffects=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DEBUGUTILS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddebugutils=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddebugutils=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DVBSUBENC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddvbsubenc=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddvbsubenc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DVBSUBOVERLAY),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddvbsuboverlay=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddvbsuboverlay=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DVDSPU),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddvdspu=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddvdspu=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FACEOVERLAY),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfaceoverlay=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfaceoverlay=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FESTIVAL),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfestival=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfestival=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FIELDANALYSIS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfieldanalysis=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfieldanalysis=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FREEVERB),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfreeverb=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfreeverb=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FREI0R),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfrei0r=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfrei0r=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_GAUDIEFFECTS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgaudieffects=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgaudieffects=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_GEOMETRICTRANSFORM),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgeometrictransform=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgeometrictransform=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_GDP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgdp=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgdp=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ID3TAG),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Did3tag=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Did3tag=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_INTER),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dinter=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dinter=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_INTERLACE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dinterlace=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dinterlace=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_IVFPARSE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Divfparse=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Divfparse=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_IVTC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Divtc=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Divtc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_JP2KDECIMATOR),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Djp2kdecimator=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Djp2kdecimator=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_JPEGFORMAT),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Djpegformat=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Djpegformat=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_LIBRFB),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dlibrfb=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dlibrfb=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MIDI),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmidi=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmidi=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEGDEMUX),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpegdemux=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpegdemux=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEGPSMUX),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpegpsmux=enabled +GST1_PLUGINS_BAD_OPENIPC_HAS_UNKNOWN_LICENSE = y +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpegpsmux=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEGTSMUX),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpegtsmux=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpegtsmux=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEGTSDEMUX),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpegtsdemux=enabled +GST1_PLUGINS_BAD_OPENIPC_HAS_UNKNOWN_LICENSE = y +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpegtsdemux=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MXF),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmxf=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmxf=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_NETSIM),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dnetsim=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dnetsim=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ONVIF),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Donvif=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Donvif=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_PCAPPARSE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dpcapparse=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dpcapparse=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_PNM),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dpnm=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dpnm=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_PROXY),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dproxy=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dproxy=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RAWPARSE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drawparse=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drawparse=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_REMOVESILENCE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dremovesilence=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dremovesilence=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RIST),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drist=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drist=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RTMP2),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drtmp2=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drtmp2=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RTP2),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drtp=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drtp=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RTMP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drtmp=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += rtmpdump +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drtmp=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SDP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsdp=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsdp=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SEGMENTCLIP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsegmentclip=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsegmentclip=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SIREN),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsiren=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsiren=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SMOOTH),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsmooth=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsmooth=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SPEED),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dspeed=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dspeed=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SUBENC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsubenc=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsubenc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SWITCHBIN),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dswitchbin=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dswitchbin=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_TIMECODE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dtimecode=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dtimecode=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VIDEOFILTERS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvideofilters=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvideofilters=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VIDEOFRAME_AUDIOLEVEL),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvideoframe_audiolevel=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvideoframe_audiolevel=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VIDEOPARSERS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvideoparsers=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvideoparsers=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VIDEOSIGNAL),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvideosignal=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvideosignal=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VMNC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvmnc=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvmnc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_Y4M),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dy4m=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dy4m=disabled +endif + +# Plugins with dependencies + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_AES),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daes=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += openssl +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Daes=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_ASSRENDER),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dassrender=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libass +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dassrender=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_BZ2),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dbz2=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += bzip2 +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dbz2=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_CURL),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dcurl=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libcurl +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dcurl=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DASH),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddash=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libxml2 +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddash=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DECKLINK),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddecklink=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddecklink=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DIRECTFB),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddirectfb=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += directfb +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddirectfb=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DVB),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddvb=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += dtv-scan-tables +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddvb=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FAAD),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfaad=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += faad2 +GST1_PLUGINS_BAD_OPENIPC_HAS_GPL_LICENSE = y +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfaad=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FBDEV),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfbdev=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfbdev=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FDK_AAC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfdkaac=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += fdk-aac +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfdkaac=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_FLUIDSYNTH),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfluidsynth=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += fluidsynth +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dfluidsynth=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_GL),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgl=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgl=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_HLS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dhls=enabled + +ifeq ($(BR2_PACKAGE_NETTLE),y) +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += nettle +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dhls-crypto='nettle' +else ifeq ($(BR2_PACKAGE_LIBGCRYPT),y) +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libgcrypt +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dhls-crypto='libgcrypt' +else +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += openssl +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dhls-crypto='openssl' +endif + +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dhls=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_KMS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dkms=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libdrm +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dkms=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_DTLS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddtls=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += openssl +GST1_PLUGINS_BAD_OPENIPC_HAS_BSD2C_LICENSE = y +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Ddtls=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_TTML),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dttml=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += cairo libxml2 pango +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dttml=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MPEG2ENC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpeg2enc=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libmpeg2 mjpegtools +GST1_PLUGINS_BAD_OPENIPC_HAS_GPL_LICENSE = y +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmpeg2enc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_MUSEPACK),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmusepack=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += musepack +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dmusepack=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_NEON),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dneon=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += neon +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dneon=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_NVCODEC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dnvcodec=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += nvcodec +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dnvcodec=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_OPENAL),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dopenal=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += openal +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dopenal=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_OPENH264),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dopenh264=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libopenh264 +GST1_PLUGINS_BAD_OPENIPC_HAS_BSD2C_LICENSE = y +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dopenh264=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_OPENJPEG),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dopenjpeg=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += openjpeg +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dopenjpeg=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_OPUS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dopus=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += opus +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dopus=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_QROVERLAY),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dqroverlay=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += json-glib libqrencode +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dqroverlay=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_RSVG),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drsvg=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += librsvg +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Drsvg=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SBC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsbc=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += sbc +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsbc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SCTP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += \ + -Dsctp=enabled \ + -Dsctp-internal-usrsctp=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += \ + -Dsctp=disabled \ + -Dsctp-internal-usrsctp=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SHM),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dshm=enabled +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dshm=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS__BAD_OPENIPC_PLUGIN_SNDFILE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsndfile=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libsndfile +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsndfile=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_SRTP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsrtp=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libsrtp +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dsrtp=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_UVCH264),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Duvch264=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libgudev libusb +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Duvch264=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VA),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dva=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libva +ifeq ($(BR2_PACKAGE_LIBDRM),y) +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libdrm +endif +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dva=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_VOAACENC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvoaacenc=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += vo-aacenc +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dvoaacenc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WEBP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwebp=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += webp +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwebp=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WEBRTC),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwebrtc=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += gst1-plugins-base libnice +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwebrtc=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WEBRTCDSP),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwebrtcdsp=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += webrtc-audio-processing +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwebrtcdsp=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_WPE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwpe=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libwpe wpewebkit wpebackend-fdo +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dwpe=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_V4L2CODECS),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dv4l2codecs=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += libgudev +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dv4l2codecs=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_PLUGIN_X265),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dx265=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += x265 +GST1_PLUGINS_BAD_OPENIPC_HAS_GPL_LICENSE = y +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dx265=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_ZBAR),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dzbar=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += zbar +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dzbar=disabled +endif + +ifeq ($(BR2_PACKAGE_GST1_PLUGINS_BAD_OPENIPC_ZXING),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dzxing=enabled +GST1_PLUGINS_BAD_OPENIPC_DEPENDENCIES += zxing-cpp +else +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dzxing=disabled +endif + +# Add GPL license if GPL licensed plugins enabled. +ifeq ($(GST1_PLUGINS_BAD_OPENIPC_HAS_GPL_LICENSE),y) +GST1_PLUGINS_BAD_OPENIPC_CONF_OPTS += -Dgpl=enabled +GST1_PLUGINS_BAD_OPENIPC_LICENSE += , GPL-2.0+ +GST1_PLUGINS_BAD_OPENIPC_LICENSE_FILES += COPYING +endif + +# Add BSD license if BSD licensed plugins enabled. +ifeq ($(GST1_PLUGINS_BAD_OPENIPC_HAS_BSD2C_LICENSE),y) +GST1_PLUGINS_BAD_OPENIPC_LICENSE += , BSD-2-Clause +endif + +# Add Unknown license if Unknown licensed plugins enabled. +ifeq ($(GST1_PLUGINS_BAD_OPENIPC_HAS_UNKNOWN_LICENSE),y) +GST1_PLUGINS_BAD_OPENIPC_LICENSE += , UNKNOWN +endif + +# Use the following command to extract license info for plugins. +# # find . -name 'plugin-*.xml' | xargs grep license + +$(eval $(meson-package))