From 32b7856c1bbb70e8577ac81fabbbd2518424590b Mon Sep 17 00:00:00 2001 From: Alex Lennon Date: Mon, 29 Apr 2024 19:15:01 +0100 Subject: [PATCH] gst1-plugins-bad-openipc: Shadow gst1-plugins-bad (#1424) 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 3bd3de867..98fa89c6e 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 000000000..a2ab0ef6d --- /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 000000000..46be54dfb --- /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 000000000..174c4ad57 --- /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 000000000..2f3158a66 --- /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))