Signed-off-by: Michael Niedermayer <mich...@niedermayer.cc>
---
 libavradio/sdr.h        | 23 +++++++++++++++++-
 libavradio/sdrdemux.c   | 53 ++++++++++++++++++++++++++++++++++++++++-
 libavradio/sdrinradio.c | 41 +++++++++++++++++++++++++++++--
 3 files changed, 113 insertions(+), 4 deletions(-)

diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index dc20415457..395b056531 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -68,6 +68,12 @@ typedef enum Modulation {
     //QAM, PSK, ...
 } Modulation;
 
+typedef enum SDR_GAIN {
+    GAIN_DEFAULT = -3,
+    GAIN_SW_AGC = -2,
+    GAIN_SDR_AGC = -1,
+} SDR_GAIN;
+
 #define HISTOGRAMM_SIZE 9
 
 typedef struct Station {
@@ -105,6 +111,7 @@ typedef struct Station {
 
 typedef struct FIFOElement {
     int64_t center_frequency;
+    float gain;
     void *halfblock;
 } FIFOElement;
 
@@ -146,7 +153,15 @@ typedef struct SDRContext {
     int64_t min_center_freq;
     int64_t max_center_freq;
     int sdr_sample_rate;
-    int sdr_agc;
+    float min_gain;
+    float max_gain;
+    int sdr_gain;
+    float agc_min_headroom;
+    float agc_max_headroom;
+    float agc_max_headroom_time;
+    int agc_low_time;
+    float agc_gain;                         ///< current gain, should be 
accessed only by buffer thread after init
+    atomic_int wanted_gain;
     int sdr_adcc;
     int64_t bandwidth;
     int64_t last_pts;
@@ -212,6 +227,12 @@ typedef struct SDRContext {
      */
     int64_t (*set_frequency_callback)(struct SDRContext *sdr, int64_t 
frequency);
 
+    /**
+     * Setup the hardware for the requested gain
+     * This must only be called from the buffer thread after setup (or more 
mutex calls are needed)
+     */
+    int (*set_gain_callback)(struct SDRContext *sdr, float gain);
+
     /**
      * Read from the hardware, block if nothing available with a reasonable 
timeout
      *
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index a0b80785ef..5214aea7be 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -1409,6 +1409,7 @@ static void *soapy_needs_bigger_buffers_worker(SDRContext 
*sdr)
         FIFOElement fifo_element;
         int remaining, ret;
         int empty_blocks, full_blocks;
+        float wanted_gain = atomic_load(&sdr->wanted_gain) / 65536.0;
 
         //i wish av_fifo was thread safe
         pthread_mutex_lock(&sdr->mutex);
@@ -1444,9 +1445,17 @@ static void 
*soapy_needs_bigger_buffers_worker(SDRContext *sdr)
             //And theres not much else we can do, an error message was already 
printed by ff_sdr_set_freq() in that case
             block_counter = 0; // we just changed the frequency, do not trust 
the next blocks content
         }
+        if (sdr->sdr_gain == GAIN_SW_AGC &&
+            fabs(wanted_gain - sdr->agc_gain) > 0.001 &&
+            sdr->set_gain_callback
+        ) {
+            sdr->set_gain_callback(sdr, wanted_gain);
+            sdr->agc_gain = wanted_gain;
+        }
         pthread_mutex_unlock(&sdr->mutex);
 
         fifo_element.center_frequency = block_counter > 0 ? sdr->freq : 0;
+        fifo_element.gain             = sdr->agc_gain; //we make only small 
changes so slightly mixing should be ok
 
         remaining = sdr->block_size;
         while (remaining && !atomic_load(&sdr->close_requested)) {
@@ -1624,6 +1633,7 @@ int ff_sdr_common_init(AVFormatContext *s)
     av_fifo_auto_grow_limit(sdr-> full_block_fifo, sdr->sdr_sample_rate / 
sdr->block_size);
 
     atomic_init(&sdr->close_requested, 0);
+    atomic_init(&sdr->wanted_gain, lrint((sdr->min_gain + sdr->max_gain) * 
65536 / 2));
     ret = pthread_mutex_init(&sdr->mutex, NULL);
     if (ret) {
         av_log(s, AV_LOG_ERROR, "pthread_mutex_init failed: %s\n", 
strerror(ret));
@@ -1886,6 +1896,37 @@ process_next_block:
         }
     }
 
+    float smaller_block_gain = FFMIN(fifo_element[0].gain, 
fifo_element[1].gain);
+    float  bigger_block_gain = FFMAX(fifo_element[0].gain, 
fifo_element[1].gain);
+
+    if (sdr->sdr_gain == GAIN_SW_AGC) {
+        float inmax = 0;
+        float wanted_gain = atomic_load(&sdr->wanted_gain) / 65536.0;
+        // We only check 25% of the data to safe computations
+        int start = 3*sdr->block_size / 4;
+        int end   = 5*sdr->block_size / 4;
+        for (i = start; i < end; i++) {
+            float v = fmaxf(fabsf(sdr->windowed_block[i].re), 
fabsf(sdr->windowed_block[i].im));
+            inmax = fmaxf(inmax, v);
+        }
+
+        if (inmax > 1.0 - sdr->agc_min_headroom && wanted_gain > 
sdr->min_gain) {
+            //according to docs this is a dB scale, in reality it beheaves 
differnt to that
+            //Because of this we will try to just make small changes and not 
assume too much
+            wanted_gain = FFMIN(wanted_gain, FFMAX(smaller_block_gain - 1.0, 
smaller_block_gain * 0.9));
+
+            sdr->agc_low_time = 0;
+        } else if (inmax < 1.0 - sdr->agc_max_headroom && wanted_gain < 
sdr->max_gain) {
+            sdr->agc_low_time += sdr->block_size;
+            if (sdr->agc_low_time > sdr->agc_max_headroom_time * 
sdr->sdr_sample_rate) {
+                sdr->agc_low_time = 0;
+                wanted_gain = FFMAX(wanted_gain, FFMIN(bigger_block_gain + 
1.0, bigger_block_gain * 1.1));
+            }
+        } else
+            sdr->agc_low_time = 0;
+        atomic_store(&sdr->wanted_gain, (int)lrint(wanted_gain * 65536));
+    }
+
     inject_block_into_fifo(sdr, sdr->empty_block_fifo, &fifo_element[0], 
"Cannot pass next buffer, freeing it\n");
 #ifdef SYN_TEST //synthetic test signal
     static int64_t synp=0;
@@ -2141,7 +2182,17 @@ const AVOption ff_sdr_options[] = {
     { "rtlsdr_fixes" , "workaround rtlsdr issues", OFFSET(rtlsdr_fixes), 
AV_OPT_TYPE_INT , {.i64 = -1}, -1, 1, DEC},
     { "sdr_sr"  , "sdr sample rate"  , OFFSET(sdr_sample_rate ), 
AV_OPT_TYPE_INT , {.i64 = 0}, 0, INT_MAX, DEC},
     { "sdr_freq", "sdr frequency"    , OFFSET(wanted_freq), AV_OPT_TYPE_INT64 
, {.i64 = 9000000}, 0, INT64_MAX, DEC},
-    { "sdr_agc" , "sdr automatic gain control",  OFFSET(sdr_agc),  
AV_OPT_TYPE_BOOL , {.i64 =  1}, -1, 1, DEC},
+    { "gain" , "sdr overall gain",  OFFSET(sdr_gain),  AV_OPT_TYPE_INT , {.i64 
=  GAIN_SDR_AGC}, -3, INT_MAX, DEC, "gain"},
+        { "sdr_agc", "SDR AGC (if supported)", 0, AV_OPT_TYPE_CONST, {.i64 = 
GAIN_SDR_AGC}, 0, 0, DEC, "gain"},
+        { "sw_agc", "Software AGC", 0, AV_OPT_TYPE_CONST, {.i64 = 
GAIN_SW_AGC}, 0, 0, DEC, "gain"},
+        { "default_gain", "Never touch gain", 0, AV_OPT_TYPE_CONST, {.i64 = 
GAIN_DEFAULT}, 0, 0, DEC, "gain"},
+
+    { "agc_min_headroom",  "AGC min headroom",  OFFSET(agc_min_headroom),  
AV_OPT_TYPE_FLOAT, {.dbl = 0.4}, 0, 1.0, DEC},
+    { "agc_max_headroom",  "AGC max headroom",  OFFSET(agc_max_headroom),  
AV_OPT_TYPE_FLOAT, {.dbl = 0.8}, 0, 1.0, DEC},
+    { "agc_max_headroom_time",  "AGC max headroom time",  
OFFSET(agc_max_headroom_time),  AV_OPT_TYPE_FLOAT, {.dbl = 0.1}, 0, INT_MAX, 
DEC},
+    { "min_gain", "minimum gain", OFFSET(min_gain   ), AV_OPT_TYPE_FLOAT , 
{.dbl = 0}, 0, INT_MAX, DEC},
+    { "max_gain", "maximum gain", OFFSET(max_gain   ), AV_OPT_TYPE_FLOAT , 
{.dbl = 0}, 0, INT_MAX, DEC},
+
     { "sdr_adcc" ,"sdr automatic dc correction", OFFSET(sdr_adcc), 
AV_OPT_TYPE_BOOL , {.i64 = -1}, -1, 1, DEC},
     { "min_freq", "minimum frequency", OFFSET(min_freq   ), AV_OPT_TYPE_INT64 
, {.i64 = 0}, 0, INT64_MAX, DEC},
     { "max_freq", "maximum frequency", OFFSET(max_freq   ), AV_OPT_TYPE_INT64 
, {.i64 = 0}, 0, INT64_MAX, DEC},
diff --git a/libavradio/sdrinradio.c b/libavradio/sdrinradio.c
index 3956c18375..63a9cade78 100644
--- a/libavradio/sdrinradio.c
+++ b/libavradio/sdrinradio.c
@@ -68,6 +68,30 @@ static int sdrindev_read_callback(SDRContext *sdr, 
FIFOElement *fifo_element, in
     return ret;
 }
 
+static int sdrindev_set_gain_callback(SDRContext *sdr, float gain)
+{
+    AVFormatContext *avfmt = sdr->avfmt;
+    SoapySDRDevice *soapy = sdr->soapy;
+
+    if (sdr->sdr_gain == GAIN_DEFAULT)
+        return 0;
+
+    if (soapy) {
+        int ret = SoapySDRDevice_setGainMode(soapy, SOAPY_SDR_RX, 0, 
sdr->sdr_gain == GAIN_SDR_AGC);
+        if (ret) {
+            av_log(avfmt, AV_LOG_WARNING, "Failed to set gain mode %d (%s)\n", 
sdr->sdr_gain == GAIN_SDR_AGC, SoapySDRDevice_lastError());
+        }
+
+        if (sdr->sdr_gain != GAIN_SDR_AGC) {
+            ret = SoapySDRDevice_setGain(soapy, SOAPY_SDR_RX, 0, gain);
+            if (ret) {
+                av_log(avfmt, AV_LOG_WARNING, "Failed to set gain to %f 
(%s)\n", gain, SoapySDRDevice_lastError());
+            }
+        }
+    }
+    return 0;
+}
+
 static int64_t sdrindev_set_frequency_callback(SDRContext *sdr, int64_t freq)
 {
     AVFormatContext *avfmt = sdr->avfmt;
@@ -135,6 +159,7 @@ static int sdrindev_initial_hw_setup(AVFormatContext *s)
 
     sdr->read_callback          = sdrindev_read_callback;
     sdr->set_frequency_callback = sdrindev_set_frequency_callback;
+    sdr->set_gain_callback      = sdrindev_set_gain_callback;
 
     // Go over all available soapy devices
     // Print the usable ones, and choose one unless the user has choosen one
@@ -195,8 +220,10 @@ static int sdrindev_initial_hw_setup(AVFormatContext *s)
     //Inform the user if AGC is supported and setup AGC as requested by the 
user
     has_agc = SoapySDRDevice_hasGainMode(soapy, SOAPY_SDR_RX, 0);
     av_log(s, AV_LOG_INFO, "RX AGC Supported: %s\n", has_agc ? "yes" : "no");
-    if (has_agc && sdr->sdr_agc >= 0)
-        SoapySDRDevice_setGainMode(soapy, SOAPY_SDR_RX, 0, sdr->sdr_agc);
+    if (!has_agc &&  sdr->sdr_gain == GAIN_SDR_AGC) {
+        av_log(s, AV_LOG_WARNING, "hardware AGC unsupported switching to 
software AGC\n");
+        sdr->sdr_gain = GAIN_SW_AGC;
+    }
 
     //Inform the user if automatic DC correction is supported and setup DC 
correction as requested by the user
     has_adcc = SoapySDRDevice_hasDCOffsetMode(soapy, SOAPY_SDR_RX, 0);
@@ -208,6 +235,16 @@ static int sdrindev_initial_hw_setup(AVFormatContext *s)
     range = SoapySDRDevice_getGainRange(soapy, SOAPY_SDR_RX, 0);
     av_log(s, AV_LOG_INFO, "Rx Gain range: %f dB - %f dB\n", range.minimum, 
range.maximum);
 
+    if (!sdr->min_gain)
+        sdr->min_gain = range.minimum;
+
+    if (!sdr->max_gain)
+        sdr->max_gain = range.maximum;
+    if (sdr->min_gain > sdr->max_gain) {
+        av_log(s, AV_LOG_ERROR, "Invalid gain range\n");
+        return AVERROR(EINVAL);
+    }
+
     //Inform the user about the Frequency ranges available, verify the range 
requested by the user and set the range if the user has not specified one
     ranges = SoapySDRDevice_getFrequencyRange(soapy, SOAPY_SDR_RX, 0, &length);
     av_log(s, AV_LOG_INFO, "Rx freq ranges: ");
-- 
2.31.1

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-requ...@ffmpeg.org with subject "unsubscribe".

Reply via email to