[FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory

Git Inbox Mirror of the ffmpeg-devel mailing list - see https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
 help / color / mirror / Atom feed

* [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory
@ 2023-07-11 21:18 Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 02/12] avradio/rds: Implement burst error decoder Michael Niedermayer
                   ` (11 more replies)
  0 siblings, 12 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:18 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/sdrdemux.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index a34f784e63..a37018fd2f 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -1144,7 +1144,7 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
 
             sst->rds_ring_size = ceil((2*105 / 1187.5 + 2.0*block_time) * sst->block_size_p2 / block_time);
 
-            sst->rds_ring  = av_malloc(sizeof(*sst->rds_ring ) * sst->rds_ring_size);
+            sst->rds_ring  = av_mallocz(sizeof(*sst->rds_ring ) * sst->rds_ring_size);
             sst->window_p2 = av_malloc(sizeof(*sst->window_p2)* 2 * sst->block_size_p2);
             sst->iside     = av_malloc(sizeof(*sst->iside)    * 2 * sst->block_size_p2);
             if (!sst->iside || !sst->window_p2 || !sst->rds_ring)
@@ -1156,7 +1156,7 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
             }
         }
 
-        sst->out_buf   = av_malloc(sizeof(*sst->out_buf)  * 2 * sst->block_size);
+        sst->out_buf   = av_mallocz(sizeof(*sst->out_buf) * 2 * sst->block_size);
         sst->block     = av_malloc(sizeof(*sst-> block)   * 2 * sst->block_size);
         sst->iblock    = av_malloc(sizeof(*sst->iblock)   * 2 * sst->block_size);
         sst->icarrier  = av_malloc(sizeof(*sst->icarrier) * 2 * sst->block_size);
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 02/12] avradio/rds: Implement burst error decoder
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 03/12] avradio/rds: Keep track of program_id Michael Niedermayer
                   ` (10 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/rds.c | 55 ++++++++++++++++++++++++++++++------------------
 1 file changed, 34 insertions(+), 21 deletions(-)

diff --git a/libavradio/rds.c b/libavradio/rds.c
index dd9a934c3c..2cb7942bbd 100644
--- a/libavradio/rds.c
+++ b/libavradio/rds.c
@@ -35,29 +35,42 @@
 #include "libavformat/avformat.h"
 #include "libavformat/demux.h"
 
+#define MAX_BURST 5 // Tradeoff between undetected errors and correction capacity values from 2 to 5 are reasonable
+
+static int burst_len(unsigned u)
+{
+    if (!u)
+        return 0;
+
+    while(!(u&1))
+        u>>=1;
+    return 1+av_log2(u);
+}
+
 /**
  * Check and correct RDS block
  * @param[out] group the data bits are returned here
  * @param block block nu,ber (0 to 3)
  * @return 1 if correctable single bit error, 0 if no error, >99 if non correctable errors
  */
-static int check_rds_block(uint16_t group[4], const float diff[104], int block)
+static int check_rds_block(Station *station, uint16_t group[4], const float diff[104], const int block)
 {
 #define RDS_G 0x5B9 //101 1011 1001
     static const uint16_t offset[4] = {0x0FC, 0x198, 0x168, 0x1B4};
     unsigned codeword = 0;
-    unsigned syndrom = 0;
-    //we carry floats through to here so we can do a soft decission decoder
-    //ATM lets just do hard decission decoding that should be more than good enough
+    unsigned syndrom  = 0;
+    const float *blockdiff = diff + block*26;
 
     //FIXME we could do this more efficiently but does it matter?
     for(int i=0; i<26; i++) {
-        int bit = (diff[i + block*26]<0);
+        int bit = blockdiff[i] < 0;
+
         codeword += codeword + bit;
         syndrom += syndrom + bit;
         if (syndrom & (1<<10))
             syndrom ^= RDS_G;
     }
+
     if (block==2 && (group[1]&0x800)) {
         syndrom ^= 0x350;
     }else
@@ -66,25 +79,24 @@ static int check_rds_block(uint16_t group[4], const float diff[104], int block)
 
     group[block] = codeword >> 10;
 
-    // try correcting some basic errors
-    if (syndrom) {
-        for (unsigned e = 1; e <= 2; e ++) {
-            unsigned mask = 255 >> (8-e);
-            unsigned syndrom1 = mask;
-            for(int i=0; i<27-e; i++) {
-                if (syndrom == syndrom1) {
-                    group[block] ^= (mask<<i) >> 10;
-                    return e;
+    // try correcting the most common error patterns
+    for (int i=0; i<27-MAX_BURST; i++) {
+        if (!(syndrom>>MAX_BURST)) {
+            int ret = burst_len(syndrom);
+            group[block] ^= (syndrom << i) >> 10;
+
+                    return ret;
                 }
-                syndrom1 += syndrom1;
-                if (syndrom1 & (1<<10))
-                    syndrom1 ^= RDS_G;
             }
+
+            return ret;
         }
-        return 100; // this is a good place do a 2nd pass with a soft decssion multi bit decoder
+        if (syndrom&1)
+            syndrom ^= RDS_G;
+        syndrom >>= 1;
     }
 
-    return 0;
+    return 20;
 }
 
 static int decode_rds_group(SDRContext *sdr, SDRStream *sst, uint16_t group[4])
@@ -131,6 +143,7 @@ int ff_sdr_decode_rds(SDRContext *sdr, SDRStream *sst, AVComplexFloat *signal)
     uint16_t group[4];
     int64_t num_step_in_p2 = sdr->sdr_sample_rate * (int64_t)sst->block_size_p2;
     int64_t den_step_on_p2 = sdr->block_size * 2375LL;
+    Station *station = sst->station;
 #define IDX(I) ((I)*num_step_in_p2/den_step_on_p2)
 
     av_assert0(sst->rds_ring_pos <= sst->rds_ring_size - 2*sst->block_size_p2);
@@ -171,7 +184,7 @@ int ff_sdr_decode_rds(SDRContext *sdr, SDRStream *sst, AVComplexFloat *signal)
         for (phase = 0; phase < 104; phase++) {
             int error = 0;
             for (int block = 0; block < 4; block++) {
-                error += check_rds_block(group, diff + phase, block);
+                error += check_rds_block(station, group, diff + phase, block);
             }
             if (error < best_errors) {
                 best_errors = error;
@@ -184,7 +197,7 @@ int ff_sdr_decode_rds(SDRContext *sdr, SDRStream *sst, AVComplexFloat *signal)
         if (best_errors < 10) {
             int error = 0;
             for (int block = 0; block < 4; block++) {
-                error += check_rds_block(group, diff + best_phase, block);
+                error += check_rds_block(station, group, diff + best_phase, block);
             }
             //have to recheck because of floats
             if (error < 10) {
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 03/12] avradio/rds: Keep track of program_id
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 02/12] avradio/rds: Implement burst error decoder Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 04/12] avradio/sdr: Move rds_ring to Station Michael Niedermayer
                   ` (9 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

This allows detecting more damaged blocks

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/rds.c | 16 ++++++++++++++++
 libavradio/sdr.h |  1 +
 2 files changed, 17 insertions(+)

diff --git a/libavradio/rds.c b/libavradio/rds.c
index 2cb7942bbd..dc7124cab3 100644
--- a/libavradio/rds.c
+++ b/libavradio/rds.c
@@ -85,7 +85,13 @@ static int check_rds_block(Station *station, uint16_t group[4], const float diff
             int ret = burst_len(syndrom);
             group[block] ^= (syndrom << i) >> 10;
 
+            if (block == 0 && station->program_id[0]) {
+                if (group[0] == station->program_id[0]) {
                     return ret;
+                } else if (group[0] == station->program_id[1]) {
+                    return ret;
+                } else if (ret) {
+                    return 20; //PI change is uncommon, so dont accept this in a damaged block, PI is repeated alot so we can wait for a clean block
                 }
             }
 
@@ -108,6 +114,16 @@ static int decode_rds_group(SDRContext *sdr, SDRStream *sst, uint16_t group[4])
     int tp = group[1] & 0x400;
     int pty= (group[1] >> 5) & 0x1F;
 
+    if (station->program_id[0] && station->program_id[0] != pi)
+        av_log(sdr->avfmt, AV_LOG_INFO, "PI changed to %X\n", pi);
+
+    if (station->program_id[1] == pi) {
+        FFSWAP(int, station->program_id[1], station->program_id[0]);
+    } else if (station->program_id[0] != pi) {
+        station->program_id[1] = pi;
+        return 0; // skip first packet with new PI, likely its just damaged
+    }
+
     switch(a) {
     case 0:
         AV_WB16(station->name + 2*(group[1]&3), group[3]);
diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index 212358fad9..b83264ae0d 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -74,6 +74,7 @@ typedef struct Station {
     char name[9];
     char radiotext[65];
     char programm_type_name[9];
+    int program_id[2];
     enum Modulation modulation;
     double frequency;
     int nb_frequency;       ///< number of detections which are used to compute the frequency
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 04/12] avradio/sdr: Move rds_ring to Station
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 02/12] avradio/rds: Implement burst error decoder Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 03/12] avradio/rds: Keep track of program_id Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 05/12] avradio/rds: move phase 2 window to main context Michael Niedermayer
                   ` (8 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

Other changes are needed to be done in this commit because of
dependancies

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/rds.c      | 36 +++++++++---------
 libavradio/sdr.h      | 12 +++---
 libavradio/sdrdemux.c | 88 ++++++++++++++++++++++++-------------------
 3 files changed, 74 insertions(+), 62 deletions(-)

diff --git a/libavradio/rds.c b/libavradio/rds.c
index dc7124cab3..e16685be18 100644
--- a/libavradio/rds.c
+++ b/libavradio/rds.c
@@ -105,9 +105,8 @@ static int check_rds_block(Station *station, uint16_t group[4], const float diff
     return 20;
 }
 
-static int decode_rds_group(SDRContext *sdr, SDRStream *sst, uint16_t group[4])
+static int decode_rds_group(SDRContext *sdr, Station *station, uint16_t group[4])
 {
-    Station *station = sst->station;
     int pi = group[0];
     int a  = group[1] >> 12;
     int b  = group[1] & 0x800;
@@ -154,26 +153,25 @@ static int decode_rds_group(SDRContext *sdr, SDRStream *sst, uint16_t group[4])
 int ff_sdr_decode_rds(SDRContext *sdr, SDRStream *sst, AVComplexFloat *signal)
 {
     int i, phase;
-    float (*ring)[2] = sst->rds_ring;
+    Station *station = sst->station;
+    float (*ring)[2] = station->rds_ring;
     float diff[2*104 - 1];
     uint16_t group[4];
-    int64_t num_step_in_p2 = sdr->sdr_sample_rate * (int64_t)sst->block_size_p2;
+    int64_t num_step_in_p2 = sdr->sdr_sample_rate * (int64_t)sdr->fm_block_size_p2;
     int64_t den_step_on_p2 = sdr->block_size * 2375LL;
-    Station *station = sst->station;
 #define IDX(I) ((I)*num_step_in_p2/den_step_on_p2)
-
-    av_assert0(sst->rds_ring_pos <= sst->rds_ring_size - 2*sst->block_size_p2);
+    av_assert0(station->rds_ring_pos <= sdr->rds_ring_size - 2*sdr->fm_block_size_p2);
 
     //For reasons that are beyond me, RDS spec allows inphase and quadrature so we have to compute and check both
-    for (int i=0; i < sst->block_size_p2; i++) {
-        ring[ sst->rds_ring_pos + i                      ][0] += signal[i].re * sst->window_p2[i];
-        ring[ sst->rds_ring_pos + i + sst->block_size_p2 ][0]  = signal[i + sst->block_size_p2].re * sst->window_p2[i + sst->block_size_p2];
-        ring[ sst->rds_ring_pos + i                      ][1] += signal[i].im * sst->window_p2[i];
-        ring[ sst->rds_ring_pos + i + sst->block_size_p2 ][1]  = signal[i + sst->block_size_p2].im * sst->window_p2[i + sst->block_size_p2];
+    for (int i=0; i < sdr->fm_block_size_p2; i++) {
+        ring[ station->rds_ring_pos + i                         ][0] += signal[i].re * sst->window_p2[i];
+        ring[ station->rds_ring_pos + i + sdr->fm_block_size_p2 ][0]  = signal[i + sdr->fm_block_size_p2].re * sst->window_p2[i + sdr->fm_block_size_p2];
+        ring[ station->rds_ring_pos + i                         ][1] += signal[i].im * sst->window_p2[i];
+        ring[ station->rds_ring_pos + i + sdr->fm_block_size_p2 ][1]  = signal[i + sdr->fm_block_size_p2].im * sst->window_p2[i + sdr->fm_block_size_p2];
     }
-    sst->rds_ring_pos += sst->block_size_p2;
+    station->rds_ring_pos += sdr->fm_block_size_p2;
 
-    while (sst->rds_ring_pos > IDX(2) + IDX(4*104-1)) {
+    while (station->rds_ring_pos > IDX(2) + IDX(4*104-1)) {
         int best_phase;
         float best_amplitude = -1;
         for (phase = 0; phase < 2*IDX(2); phase++) {
@@ -217,16 +215,16 @@ int ff_sdr_decode_rds(SDRContext *sdr, SDRStream *sst, AVComplexFloat *signal)
             }
             //have to recheck because of floats
             if (error < 10) {
-                decode_rds_group(sdr, sst, group);
+                decode_rds_group(sdr, station, group);
             }
         }
         int step = IDX(2*(best_phase + 103));
 
-        av_assert0(sst->rds_ring_pos >= step);
-        memmove(ring, ring + step, (sst->rds_ring_pos + sst->block_size_p2 - step) * sizeof(*sst->rds_ring));
-        sst->rds_ring_pos -= step;
+        av_assert0(station->rds_ring_pos >= step);
+        memmove(ring, ring + step, (station->rds_ring_pos + sdr->fm_block_size_p2 - step) * sizeof(*station->rds_ring));
+        station->rds_ring_pos -= step;
     }
-    av_assert0 (sst->rds_ring_pos + 2*sst->block_size_p2 <= sst->rds_ring_size);
+    av_assert0 (station->rds_ring_pos + 2*sdr->fm_block_size_p2 <= sdr->rds_ring_size);
 
     return 0;
 }
diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index b83264ae0d..7d951334f9 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -79,7 +79,6 @@ typedef struct Station {
     double frequency;
     int nb_frequency;       ///< number of detections which are used to compute the frequency
     int64_t bandwidth;
-    int64_t bandwidth_p2;
     float score;
     int in_station_list;    ///< non zero if this station is in the station list
     int timeout;            //since how many blocks was this detectable but not detected
@@ -88,6 +87,9 @@ typedef struct Station {
     int detection_per_mix_frequency[HISTOGRAMM_SIZE];
     int non_detection_per_mix_frequency[HISTOGRAMM_SIZE];
 
+    float (*rds_ring)[2];
+    int rds_ring_pos;
+
     struct SDRStream *stream;
 } Station;
 
@@ -104,7 +106,6 @@ typedef struct SDRStream {
     av_tx_fn fft;
     av_tx_fn ifft_p2;
     int block_size;
-    int block_size_p2;
     int processing_index;
     float *out_buf;
     AVComplexFloat *block;
@@ -113,9 +114,6 @@ typedef struct SDRStream {
     AVComplexFloat *iside;
     float *window;
     float *window_p2;
-    float (*rds_ring)[2];
-    int rds_ring_size;
-    int rds_ring_pos;
     Station *station;
     float am_amplitude;
 
@@ -162,6 +160,10 @@ typedef struct SDRContext {
     int sample_size;
     double sample_scale;
 
+    int64_t fm_bandwidth_p2;
+    int fm_block_size_p2;
+    int rds_ring_size;
+
     int am_mode;                            ///< AMMode but using int for generic option access
     int emphasis_mode;
     int am_fft_ref;
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index a37018fd2f..762328aebe 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -101,6 +101,8 @@ static void free_station(Station *station)
 {
     if (station->stream)
         station->stream->station = NULL;
+
+    av_freep(&station->rds_ring);
     av_free(station);
 }
 
@@ -174,7 +176,6 @@ static int create_station(SDRContext *sdr, Station *candidate_station) {
     enum Modulation modulation  = candidate_station->modulation;
     double freq                 = candidate_station->frequency;
     int64_t bandwidth           = candidate_station->bandwidth;
-    int64_t bandwidth_p2        = candidate_station->bandwidth_p2;
     float score                 = candidate_station->score;
     void *tmp;
     int i;
@@ -277,7 +278,7 @@ static int create_station(SDRContext *sdr, Station *candidate_station) {
 
     candidate_station->in_station_list = 1;
 
-    av_log(sdr, AV_LOG_INFO, "create_station %d f:%f bw:%"PRId64"/%"PRId64" score: %f\n", modulation, freq, bandwidth, bandwidth_p2, score);
+    av_log(sdr, AV_LOG_INFO, "create_station %d f:%f bw:%"PRId64" score: %f\n", modulation, freq, bandwidth, score);
 
     return 1;
 }
@@ -373,7 +374,7 @@ static void decay_stations(SDRContext *sdr)
     }
 }
 
-static int create_candidate_station(SDRContext *sdr, enum Modulation modulation, double freq, int64_t bandwidth, int64_t bandwidth_p2, float score) {
+static int create_candidate_station(SDRContext *sdr, enum Modulation modulation, double freq, int64_t bandwidth, float score) {
     Station *station;
     void *tmp;
     struct AVTreeNode *next = NULL;
@@ -391,10 +392,20 @@ static int create_candidate_station(SDRContext *sdr, enum Modulation modulation,
     }
 
     if (!nb_stations) {
+        double block_time = sdr->block_size / (double)sdr->sdr_sample_rate;
         station = av_mallocz(sizeof(*station));
         if (!station)
             return AVERROR(ENOMEM);
         station->frequency = freq;
+
+
+        if (!sdr->rds_ring_size)
+            sdr->rds_ring_size = ceil((2*105 / 1187.5 + 2.0*block_time) * sdr->fm_block_size_p2 / block_time);
+
+        station->rds_ring  = av_mallocz(sizeof(*station->rds_ring ) * sdr->rds_ring_size);
+
+        if (!station->rds_ring)
+            goto fail;
     } else {
         station = station_list[0];
         // We will update the frequency so we need to reinsert
@@ -407,7 +418,6 @@ static int create_candidate_station(SDRContext *sdr, enum Modulation modulation,
     station->detection_per_mix_frequency[histogram_index(sdr, freq)] ++;
     station->modulation   = modulation;
     station->bandwidth    = bandwidth;
-    station->bandwidth_p2 = bandwidth_p2;
     station->score        = score;
 
     tmp = tree_insert(&sdr->station_root, station, station_cmp, &next);
@@ -418,6 +428,10 @@ static int create_candidate_station(SDRContext *sdr, enum Modulation modulation,
     av_freep(&next);
 
     return 1;
+fail: // only call from the branch that allocated station
+    av_freep(&station->rds_ring);
+    av_freep(&station);
+    return AVERROR(ENOMEM);
 }
 
 static void probe_common(SDRContext *sdr)
@@ -564,7 +578,7 @@ static int probe_am(SDRContext *sdr)
                     continue;
                 }
 
-                create_candidate_station(sdr, AM, INDEX2F(peak_i), bandwidth_f, 0, score);
+                create_candidate_station(sdr, AM, INDEX2F(peak_i), bandwidth_f, score);
             }
         }
     }
@@ -836,7 +850,6 @@ static int probe_fm(SDRContext *sdr)
 {
     int i;
     int bandwidth_f  = 180*1000;
-    int bandwidth_p2 =  18*1000; //phase 2 bandwidth
     int half_bw_i = bandwidth_f * (int64_t)sdr->block_size / sdr->sdr_sample_rate;
     float last_score[3] = {FLT_MAX, FLT_MAX, FLT_MAX};
     int border_i = (sdr->sdr_sample_rate - FFMIN(sdr->bandwidth, sdr->sdr_sample_rate*7/8)) * sdr->block_size / sdr->sdr_sample_rate;
@@ -912,7 +925,7 @@ static int probe_fm(SDRContext *sdr)
                         f2 = f3;
                     }
 
-                    create_candidate_station(sdr, FM, f2, bandwidth_f, bandwidth_p2, score);
+                    create_candidate_station(sdr, FM, f2, bandwidth_f, score);
                 }
             }
         }
@@ -932,7 +945,7 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
     float *newbuf;
     float scale;
     int sample_rate    = sdr->sdr_sample_rate * (int64_t)sst->block_size    / sdr->block_size;
-    int sample_rate_p2 = sdr->sdr_sample_rate * (int64_t)sst->block_size_p2 / sdr->block_size;
+    int sample_rate_p2 = sdr->sdr_sample_rate * (int64_t)sdr->fm_block_size_p2 / sdr->block_size;
     int ret, i;
     float clip = 1.0;
     int carrier19_i = 2L*sst->block_size*19000 / sample_rate;
@@ -972,7 +985,7 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
     sst->iblock[i].re = 0;
     sst->iblock[i].im = 0;
 
-    av_assert0(sst->block_size_p2 * 2 < sst->block_size);
+    av_assert0(sdr->fm_block_size_p2 * 2 < sst->block_size);
     //FIXME this only needs to be a RDFT
     //CONSIDER, this and in fact alot can be done with bandpass and lowpass filters instead of FFTs, find out which is better
     //CONSIDER synthesizing the carrier instead of IFFT, we have all parameters for that
@@ -984,39 +997,39 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
 
     if (carrier19_i >= 0) {
         i = sst->block_size;
-        memset(sst->block + i, 0, 2*sst->block_size_p2 * sizeof(AVComplexFloat));
+        memset(sst->block + i, 0, 2*sdr->fm_block_size_p2 * sizeof(AVComplexFloat));
         memcpy(sst->block + i, sst->block + carrier19_i, sizeof(AVComplexFloat)*(W+1));
-        memcpy(sst->block + i + 2*sst->block_size_p2 - W, sst->block + carrier19_i - W, sizeof(AVComplexFloat)*W);
+        memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - W, sst->block + carrier19_i - W, sizeof(AVComplexFloat)*W);
         sst->ifft_p2(sst->ifft_p2_ctx, sst->icarrier, sst->block + i, sizeof(AVComplexFloat));
 
         memcpy(sst->block + i, sst->block + 3*carrier19_i, sizeof(AVComplexFloat)*len2_4_i);
-        memcpy(sst->block + i + 2*sst->block_size_p2 - len2_4_i, sst->block + 3*carrier19_i - len2_4_i, sizeof(AVComplexFloat)*len2_4_i);
+        memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - len2_4_i, sst->block + 3*carrier19_i - len2_4_i, sizeof(AVComplexFloat)*len2_4_i);
         sst->ifft_p2(sst->ifft_p2_ctx, sst->iside   , sst->block + i, sizeof(AVComplexFloat));
-        synchronous_am_demodulationN(sst->iside, sst->icarrier, sst->window_p2, 2*sst->block_size_p2, 3);
+        synchronous_am_demodulationN(sst->iside, sst->icarrier, sst->window_p2, 2*sdr->fm_block_size_p2, 3);
         ff_sdr_decode_rds(sdr, sst, sst->iside);
 
         memcpy(sst->block + i, sst->block + 2*carrier19_i, sizeof(AVComplexFloat)*len17_i);
-        memcpy(sst->block + i + 2*sst->block_size_p2 - len17_i, sst->block + 2*carrier19_i - len17_i, sizeof(AVComplexFloat)*len17_i);
-        apply_deemphasis(sdr, sst->block + i, sst->block_size_p2, sample_rate_p2, + 1);
-        apply_deemphasis(sdr, sst->block + i + 2*sst->block_size_p2, sst->block_size_p2, sample_rate_p2, - 1);
+        memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - len17_i, sst->block + 2*carrier19_i - len17_i, sizeof(AVComplexFloat)*len17_i);
+        apply_deemphasis(sdr, sst->block + i, sdr->fm_block_size_p2, sample_rate_p2, + 1);
+        apply_deemphasis(sdr, sst->block + i + 2*sdr->fm_block_size_p2, sdr->fm_block_size_p2, sample_rate_p2, - 1);
         sst->ifft_p2(sst->ifft_p2_ctx, sst->iside   , sst->block + i, sizeof(AVComplexFloat));
-        synchronous_am_demodulationN(sst->iside, sst->icarrier, sst->window_p2, 2*sst->block_size_p2, 2);
+        synchronous_am_demodulationN(sst->iside, sst->icarrier, sst->window_p2, 2*sdr->fm_block_size_p2, 2);
     }
-    memset(sst->block + len17_i, 0, (2*sst->block_size_p2 - len17_i) * sizeof(AVComplexFloat));
-    apply_deemphasis(sdr, sst->block, 2*sst->block_size_p2, sample_rate_p2, + 1);
+    memset(sst->block + len17_i, 0, (2*sdr->fm_block_size_p2 - len17_i) * sizeof(AVComplexFloat));
+    apply_deemphasis(sdr, sst->block, 2*sdr->fm_block_size_p2, sample_rate_p2, + 1);
     sst->ifft_p2(sst->ifft_p2_ctx, sst->iblock  , sst->block, sizeof(AVComplexFloat));
-    memset(sst->iblock + 2*sst->block_size_p2, 0 ,(2*sst->block_size -2*sst->block_size_p2) * sizeof(AVComplexFloat));
+    memset(sst->iblock + 2*sdr->fm_block_size_p2, 0 ,(2*sst->block_size -2*sdr->fm_block_size_p2) * sizeof(AVComplexFloat));
 
     scale      = 5 / (M_PI * 2*sst->block_size);
-    for(i = 0; i<sst->block_size_p2; i++) {
+    for(i = 0; i<sdr->fm_block_size_p2; i++) {
         float m, q;
 
         m = sst->out_buf[2*i+0] + (sst->iblock[i                     ].re) * sst->window_p2[i                     ] * scale;
-        newbuf[2*i+0]           = (sst->iblock[i + sst->block_size_p2].re) * sst->window_p2[i + sst->block_size_p2] * scale;
+        newbuf[2*i+0]           = (sst->iblock[i + sdr->fm_block_size_p2].re) * sst->window_p2[i + sdr->fm_block_size_p2] * scale;
 
         if (carrier19_i >= 0) {
             q = sst->out_buf[2*i+1] +  sst->iside[i                     ].im * sst->window_p2[i                     ] * scale;
-            newbuf[2*i+1]           =  sst->iside[i + sst->block_size_p2].im * sst->window_p2[i + sst->block_size_p2] * scale;
+            newbuf[2*i+1]           =  sst->iside[i + sdr->fm_block_size_p2].im * sst->window_p2[i + sdr->fm_block_size_p2] * scale;
 
             sst->out_buf[2*i+0] = m + q;
             sst->out_buf[2*i+1] = m - q;
@@ -1031,7 +1044,7 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
         }
     }
 
-    ret = av_packet_from_data(pkt, (void*)sst->out_buf, sizeof(*sst->out_buf) * 2 * sst->block_size_p2);
+    ret = av_packet_from_data(pkt, (void*)sst->out_buf, sizeof(*sst->out_buf) * 2 * sdr->fm_block_size_p2);
     if (ret < 0)
         av_free(sst->out_buf);
     sst->out_buf = newbuf;
@@ -1096,7 +1109,6 @@ static void free_stream(SDRContext *sdr, int stream_index)
     av_freep(&sst->iside);
     av_freep(&sst->window);
     av_freep(&sst->window_p2);
-    av_freep(&sst->rds_ring);
 }
 
 static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
@@ -1130,29 +1142,24 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
         if (ret < 0)
             return ret;
 
-        if (sst->station->bandwidth_p2) {
+        if (sst->station->modulation == FM) {
             //Allocate 2nd stage demodulation fields if needed
             ret = av_tx_init(&sst-> fft_ctx, &sst-> fft, AV_TX_FLOAT_FFT, 0, 2*sst->block_size   , NULL, 0);
             if (ret < 0)
                 return ret;
 
-            for (sst->block_size_p2 = 4; 2ll *sst->station->bandwidth_p2 * block_time > sst->block_size_p2; sst->block_size_p2 <<= 1)
-                ;
-            ret = av_tx_init(&sst->ifft_p2_ctx, &sst->ifft_p2, AV_TX_FLOAT_FFT, 1, 2*sst->block_size_p2, NULL, 0);
+            ret = av_tx_init(&sst->ifft_p2_ctx, &sst->ifft_p2, AV_TX_FLOAT_FFT, 1, 2*sdr->fm_block_size_p2, NULL, 0);
             if (ret < 0)
                 return ret;
 
-            sst->rds_ring_size = ceil((2*105 / 1187.5 + 2.0*block_time) * sst->block_size_p2 / block_time);
-
-            sst->rds_ring  = av_mallocz(sizeof(*sst->rds_ring ) * sst->rds_ring_size);
-            sst->window_p2 = av_malloc(sizeof(*sst->window_p2)* 2 * sst->block_size_p2);
-            sst->iside     = av_malloc(sizeof(*sst->iside)    * 2 * sst->block_size_p2);
-            if (!sst->iside || !sst->window_p2 || !sst->rds_ring)
+            sst->window_p2 = av_malloc(sizeof(*sst->window_p2)* 2 * sdr->fm_block_size_p2);
+            sst->iside     = av_malloc(sizeof(*sst->iside)    * 2 * sdr->fm_block_size_p2);
+            if (!sst->iside || !sst->window_p2)
                 return AVERROR(ENOMEM);
 
-            avpriv_kbd_window_init(sst->window_p2, sdr->kbd_alpha, sst->block_size_p2);
-            for(int i = sst->block_size_p2; i < 2 * sst->block_size_p2; i++) {
-                sst->window_p2[i] = sst->window_p2[2*sst->block_size_p2 - i - 1];
+            avpriv_kbd_window_init(sst->window_p2, sdr->kbd_alpha, sdr->fm_block_size_p2);
+            for(int i = sdr->fm_block_size_p2; i < 2 * sdr->fm_block_size_p2; i++) {
+                sst->window_p2[i] = sst->window_p2[2*sdr->fm_block_size_p2 - i - 1];
             }
         }
 
@@ -1491,6 +1498,11 @@ int ff_sdr_common_init(AVFormatContext *s)
     }
     av_log(s, AV_LOG_INFO, "Block size %d\n", sdr->block_size);
 
+    double block_time = sdr->block_size / (double)sdr->sdr_sample_rate;
+    sdr->fm_bandwidth_p2 = 18 * 1000;
+    if (!sdr->fm_block_size_p2)
+        for (sdr->fm_block_size_p2 = 4; 2ll *sdr->fm_bandwidth_p2 * block_time > sdr->fm_block_size_p2; sdr->fm_block_size_p2 <<= 1)
+            ;
 
     sdr->windowed_block = av_malloc(sizeof(*sdr->windowed_block) * 2 * sdr->block_size);
     sdr->block     = av_malloc(sizeof(*sdr->block    ) * 2 * sdr->block_size);
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 05/12] avradio/rds: move phase 2 window to main context
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (2 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 04/12] avradio/sdr: Move rds_ring to Station Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 06/12] avradio/sdr: Warnings cleanup Michael Niedermayer
                   ` (7 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

Its the same for all FM stations and channels so we dont need more than
1

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/rds.c      | 11 +++++------
 libavradio/sdr.h      |  4 ++--
 libavradio/sdrdemux.c | 33 +++++++++++++++++----------------
 3 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/libavradio/rds.c b/libavradio/rds.c
index e16685be18..1392bb0874 100644
--- a/libavradio/rds.c
+++ b/libavradio/rds.c
@@ -150,10 +150,9 @@ static int decode_rds_group(SDRContext *sdr, Station *station, uint16_t group[4]
     return 0;
 }
 
-int ff_sdr_decode_rds(SDRContext *sdr, SDRStream *sst, AVComplexFloat *signal)
+int ff_sdr_decode_rds(SDRContext *sdr, Station *station, AVComplexFloat *signal)
 {
     int i, phase;
-    Station *station = sst->station;
     float (*ring)[2] = station->rds_ring;
     float diff[2*104 - 1];
     uint16_t group[4];
@@ -164,10 +163,10 @@ int ff_sdr_decode_rds(SDRContext *sdr, SDRStream *sst, AVComplexFloat *signal)
 
     //For reasons that are beyond me, RDS spec allows inphase and quadrature so we have to compute and check both
     for (int i=0; i < sdr->fm_block_size_p2; i++) {
-        ring[ station->rds_ring_pos + i                         ][0] += signal[i].re * sst->window_p2[i];
-        ring[ station->rds_ring_pos + i + sdr->fm_block_size_p2 ][0]  = signal[i + sdr->fm_block_size_p2].re * sst->window_p2[i + sdr->fm_block_size_p2];
-        ring[ station->rds_ring_pos + i                         ][1] += signal[i].im * sst->window_p2[i];
-        ring[ station->rds_ring_pos + i + sdr->fm_block_size_p2 ][1]  = signal[i + sdr->fm_block_size_p2].im * sst->window_p2[i + sdr->fm_block_size_p2];
+        ring[ station->rds_ring_pos + i                         ][0] += signal[i].re * sdr->fm_window_p2[i];
+        ring[ station->rds_ring_pos + i + sdr->fm_block_size_p2 ][0]  = signal[i + sdr->fm_block_size_p2].re * sdr->fm_window_p2[i + sdr->fm_block_size_p2];
+        ring[ station->rds_ring_pos + i                         ][1] += signal[i].im * sdr->fm_window_p2[i];
+        ring[ station->rds_ring_pos + i + sdr->fm_block_size_p2 ][1]  = signal[i + sdr->fm_block_size_p2].im * sdr->fm_window_p2[i + sdr->fm_block_size_p2];
     }
     station->rds_ring_pos += sdr->fm_block_size_p2;
 
diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index 7d951334f9..f966a16e2e 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -113,7 +113,6 @@ typedef struct SDRStream {
     AVComplexFloat *icarrier;
     AVComplexFloat *iside;
     float *window;
-    float *window_p2;
     Station *station;
     float am_amplitude;
 
@@ -163,6 +162,7 @@ typedef struct SDRContext {
     int64_t fm_bandwidth_p2;
     int fm_block_size_p2;
     int rds_ring_size;
+    float *fm_window_p2;
 
     int am_mode;                            ///< AMMode but using int for generic option access
     int emphasis_mode;
@@ -278,7 +278,7 @@ int ff_sdr_histogram_score(Station *s);
  * Decode RDS
  * @param signal the time domain RDS signal
  */
-int ff_sdr_decode_rds(SDRContext *sdr, SDRStream *sst, AVComplexFloat *signal);
+int ff_sdr_decode_rds(SDRContext *sdr, Station *station, AVComplexFloat *signal);
 
 static inline float len2(AVComplexFloat c)
 {
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index 762328aebe..93e48c2cdf 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -1005,15 +1005,15 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
         memcpy(sst->block + i, sst->block + 3*carrier19_i, sizeof(AVComplexFloat)*len2_4_i);
         memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - len2_4_i, sst->block + 3*carrier19_i - len2_4_i, sizeof(AVComplexFloat)*len2_4_i);
         sst->ifft_p2(sst->ifft_p2_ctx, sst->iside   , sst->block + i, sizeof(AVComplexFloat));
-        synchronous_am_demodulationN(sst->iside, sst->icarrier, sst->window_p2, 2*sdr->fm_block_size_p2, 3);
-        ff_sdr_decode_rds(sdr, sst, sst->iside);
+        synchronous_am_demodulationN(sst->iside, sst->icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 3);
+        ff_sdr_decode_rds(sdr, sst->station, sst->iside);
 
         memcpy(sst->block + i, sst->block + 2*carrier19_i, sizeof(AVComplexFloat)*len17_i);
         memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - len17_i, sst->block + 2*carrier19_i - len17_i, sizeof(AVComplexFloat)*len17_i);
         apply_deemphasis(sdr, sst->block + i, sdr->fm_block_size_p2, sample_rate_p2, + 1);
         apply_deemphasis(sdr, sst->block + i + 2*sdr->fm_block_size_p2, sdr->fm_block_size_p2, sample_rate_p2, - 1);
         sst->ifft_p2(sst->ifft_p2_ctx, sst->iside   , sst->block + i, sizeof(AVComplexFloat));
-        synchronous_am_demodulationN(sst->iside, sst->icarrier, sst->window_p2, 2*sdr->fm_block_size_p2, 2);
+        synchronous_am_demodulationN(sst->iside, sst->icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 2);
     }
     memset(sst->block + len17_i, 0, (2*sdr->fm_block_size_p2 - len17_i) * sizeof(AVComplexFloat));
     apply_deemphasis(sdr, sst->block, 2*sdr->fm_block_size_p2, sample_rate_p2, + 1);
@@ -1024,12 +1024,12 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
     for(i = 0; i<sdr->fm_block_size_p2; i++) {
         float m, q;
 
-        m = sst->out_buf[2*i+0] + (sst->iblock[i                     ].re) * sst->window_p2[i                     ] * scale;
-        newbuf[2*i+0]           = (sst->iblock[i + sdr->fm_block_size_p2].re) * sst->window_p2[i + sdr->fm_block_size_p2] * scale;
+        m = sst->out_buf[2*i+0] + (sst->iblock[i                     ].re) * sdr->fm_window_p2[i                     ] * scale;
+        newbuf[2*i+0]           = (sst->iblock[i + sdr->fm_block_size_p2].re) * sdr->fm_window_p2[i + sdr->fm_block_size_p2] * scale;
 
         if (carrier19_i >= 0) {
-            q = sst->out_buf[2*i+1] +  sst->iside[i                     ].im * sst->window_p2[i                     ] * scale;
-            newbuf[2*i+1]           =  sst->iside[i + sdr->fm_block_size_p2].im * sst->window_p2[i + sdr->fm_block_size_p2] * scale;
+            q = sst->out_buf[2*i+1] +  sst->iside[i                     ].im * sdr->fm_window_p2[i                     ] * scale;
+            newbuf[2*i+1]           =  sst->iside[i + sdr->fm_block_size_p2].im * sdr->fm_window_p2[i + sdr->fm_block_size_p2] * scale;
 
             sst->out_buf[2*i+0] = m + q;
             sst->out_buf[2*i+1] = m - q;
@@ -1108,7 +1108,6 @@ static void free_stream(SDRContext *sdr, int stream_index)
     av_freep(&sst->icarrier);
     av_freep(&sst->iside);
     av_freep(&sst->window);
-    av_freep(&sst->window_p2);
 }
 
 static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
@@ -1152,15 +1151,9 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
             if (ret < 0)
                 return ret;
 
-            sst->window_p2 = av_malloc(sizeof(*sst->window_p2)* 2 * sdr->fm_block_size_p2);
             sst->iside     = av_malloc(sizeof(*sst->iside)    * 2 * sdr->fm_block_size_p2);
-            if (!sst->iside || !sst->window_p2)
+            if (!sst->iside)
                 return AVERROR(ENOMEM);
-
-            avpriv_kbd_window_init(sst->window_p2, sdr->kbd_alpha, sdr->fm_block_size_p2);
-            for(int i = sdr->fm_block_size_p2; i < 2 * sdr->fm_block_size_p2; i++) {
-                sst->window_p2[i] = sst->window_p2[2*sdr->fm_block_size_p2 - i - 1];
-            }
         }
 
         sst->out_buf   = av_mallocz(sizeof(*sst->out_buf) * 2 * sst->block_size);
@@ -1508,7 +1501,9 @@ int ff_sdr_common_init(AVFormatContext *s)
     sdr->block     = av_malloc(sizeof(*sdr->block    ) * 2 * sdr->block_size);
     sdr->len2block = av_malloc(sizeof(*sdr->len2block) * 2 * sdr->block_size);
     sdr->window    = av_malloc(sizeof(*sdr->window   ) * 2 * sdr->block_size);
-    if (!sdr->windowed_block || !sdr->len2block || !sdr->block || !sdr->window)
+    sdr->fm_window_p2 = av_malloc(sizeof(*sdr->fm_window_p2)* 2 * sdr->fm_block_size_p2);
+
+    if (!sdr->windowed_block || !sdr->len2block || !sdr->block || !sdr->window || !sdr->fm_window_p2)
         return AVERROR(ENOMEM);
 
     ret = av_tx_init(&sdr->fft_ctx, &sdr->fft, AV_TX_FLOAT_FFT, 0, 2*sdr->block_size, NULL, 0);
@@ -1523,6 +1518,11 @@ int ff_sdr_common_init(AVFormatContext *s)
     for (int i = 0; i < 2 * sdr->block_size; i++)
         sdr->window[i] *= ((i&1) ? 1:-1) * scale;
 
+    avpriv_kbd_window_init(sdr->fm_window_p2, sdr->kbd_alpha, sdr->fm_block_size_p2);
+    for(int i = sdr->fm_block_size_p2; i < 2 * sdr->fm_block_size_p2; i++) {
+        sdr->fm_window_p2[i] = sdr->fm_window_p2[2*sdr->fm_block_size_p2 - i - 1];
+    }
+
     if (sdr->waterfall_st_index >= 0) {
         AVStream *st = s->streams[sdr->waterfall_st_index];
         SDRStream *sst = st->priv_data;
@@ -1971,6 +1971,7 @@ int ff_sdr_read_close(AVFormatContext *s)
     av_freep(&sdr->block);
     av_freep(&sdr->len2block);
     av_freep(&sdr->window);
+    av_freep(&sdr->fm_window_p2);
 
     av_tx_uninit(&sdr->fft_ctx);
     sdr->fft = NULL;
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 06/12] avradio/sdr: Warnings cleanup
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (3 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 05/12] avradio/rds: move phase 2 window to main context Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 07/12] avradio/rds: warnings cleanup Michael Niedermayer
                   ` (6 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/sdr.h      |  1 +
 libavradio/sdrdemux.c | 29 ++++++++++++++---------------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index f966a16e2e..834b1f40b4 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -152,6 +152,7 @@ typedef struct SDRContext {
     int64_t last_pts;
     int64_t pts;
     int block_size;
+    double block_time;
     int kbd_alpha;
     AVComplexFloat *windowed_block;
     int64_t block_center_freq;              ///< center frequency the current block contains
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index 93e48c2cdf..8b8c126380 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -177,14 +177,15 @@ static int create_station(SDRContext *sdr, Station *candidate_station) {
     double freq                 = candidate_station->frequency;
     int64_t bandwidth           = candidate_station->bandwidth;
     float score                 = candidate_station->score;
-    void *tmp;
-    int i;
+    int i, nb_stations;
     Station *best_station = NULL;
     float drift = bandwidth/3.0;
     double best_distance = drift;
     int conflict = INT_MAX;
     int nb_candidate_conflict = 0;
     int nb_candidate_match = 0;
+    Station *station_list[1000];
+
 
     if (candidate_station->in_station_list)
         return 0;
@@ -193,8 +194,7 @@ static int create_station(SDRContext *sdr, Station *candidate_station) {
     if (ff_sdr_histogram_score(candidate_station) <= 0)
         return 0;
 
-    Station *station_list[1000];
-    int nb_stations = ff_sdr_find_stations(sdr, sdr->block_center_freq, sdr->sdr_sample_rate*0.5, station_list, FF_ARRAY_ELEMS(station_list));
+    nb_stations = ff_sdr_find_stations(sdr, sdr->block_center_freq, sdr->sdr_sample_rate*0.5, station_list, FF_ARRAY_ELEMS(station_list));
     for (i=0; i<nb_stations; i++) {
         Station *s = station_list[i];
         double delta = fabs(s->frequency - freq);
@@ -286,11 +286,12 @@ static int create_station(SDRContext *sdr, Station *candidate_station) {
 static void create_stations(SDRContext *sdr)
 {
     Station *station_list[1000];
+    int nb_stations;
 
     if (!sdr->block_center_freq)
         return;
 
-    int nb_stations = ff_sdr_find_stations(sdr, sdr->block_center_freq, sdr->sdr_sample_rate*0.5, station_list, FF_ARRAY_ELEMS(station_list));
+    nb_stations = ff_sdr_find_stations(sdr, sdr->block_center_freq, sdr->sdr_sample_rate*0.5, station_list, FF_ARRAY_ELEMS(station_list));
 
     for(int i = 0; i<nb_stations; i++) {
         create_station(sdr, station_list[i]);
@@ -392,7 +393,6 @@ static int create_candidate_station(SDRContext *sdr, enum Modulation modulation,
     }
 
     if (!nb_stations) {
-        double block_time = sdr->block_size / (double)sdr->sdr_sample_rate;
         station = av_mallocz(sizeof(*station));
         if (!station)
             return AVERROR(ENOMEM);
@@ -400,7 +400,7 @@ static int create_candidate_station(SDRContext *sdr, enum Modulation modulation,
 
 
         if (!sdr->rds_ring_size)
-            sdr->rds_ring_size = ceil((2*105 / 1187.5 + 2.0*block_time) * sdr->fm_block_size_p2 / block_time);
+            sdr->rds_ring_size = ceil((2*105 / 1187.5 + 2.0*sdr->block_time) * sdr->fm_block_size_p2 / sdr->block_time);
 
         station->rds_ring  = av_mallocz(sizeof(*station->rds_ring ) * sdr->rds_ring_size);
 
@@ -901,7 +901,7 @@ static int probe_fm(SDRContext *sdr)
 
                     float rmax   = max_in_range(sdr, i-half_bw_i/4, i+half_bw_i/4);
                     int lowcount = countbelow(sdr, i-half_bw_i/4, i+half_bw_i/4, rmax / 100);
-                    double peak_i;
+                    double peak_i, f, f2;
 
                     if (lowcount / (half_bw_i*0.5) > 0.99)
                         continue;
@@ -912,8 +912,8 @@ static int probe_fm(SDRContext *sdr)
                     if (peak_i < 0)
                         continue;
                     av_assert0(fabs(peak_i-i) < 2);
-                    double f = peak_i * 0.5 * sdr->sdr_sample_rate / sdr->block_size + sdr->block_center_freq - sdr->sdr_sample_rate/2;
-                    double f2 = center * 0.5 * sdr->sdr_sample_rate / sdr->block_size + sdr->block_center_freq - sdr->sdr_sample_rate/2;
+                    f = peak_i * 0.5 * sdr->sdr_sample_rate / sdr->block_size + sdr->block_center_freq - sdr->sdr_sample_rate/2;
+                    f2 = center * 0.5 * sdr->sdr_sample_rate / sdr->block_size + sdr->block_center_freq - sdr->sdr_sample_rate/2;
 
                     if (fabs(f2 - f) > 1000)
                         continue;
@@ -1115,7 +1115,6 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
     AVFormatContext *s = sdr->avfmt;
     AVStream *st = s->streams[stream_index];
     SDRStream *sst = st->priv_data;
-    double block_time = sdr->block_size / (double)sdr->sdr_sample_rate;
     int ret;
 
     //For now we expect each station to be only demodulated once, nothing should break though if its done more often
@@ -1133,7 +1132,7 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
         free_stream(sdr, stream_index);
 
-        for (sst->block_size = 4; 2ll *sst->station->bandwidth * block_time > sst->block_size; sst->block_size <<= 1)
+        for (sst->block_size = 4; 2ll *sst->station->bandwidth * sdr->block_time > sst->block_size; sst->block_size <<= 1)
             ;
         sst->block_size = FFMIN(sdr->block_size,  sst->block_size);
 
@@ -1491,10 +1490,10 @@ int ff_sdr_common_init(AVFormatContext *s)
     }
     av_log(s, AV_LOG_INFO, "Block size %d\n", sdr->block_size);
 
-    double block_time = sdr->block_size / (double)sdr->sdr_sample_rate;
+    sdr->block_time = sdr->block_size / (double)sdr->sdr_sample_rate;
     sdr->fm_bandwidth_p2 = 18 * 1000;
     if (!sdr->fm_block_size_p2)
-        for (sdr->fm_block_size_p2 = 4; 2ll *sdr->fm_bandwidth_p2 * block_time > sdr->fm_block_size_p2; sdr->fm_block_size_p2 <<= 1)
+        for (sdr->fm_block_size_p2 = 4; 2ll *sdr->fm_bandwidth_p2 * sdr->block_time > sdr->fm_block_size_p2; sdr->fm_block_size_p2 <<= 1)
             ;
 
     sdr->windowed_block = av_malloc(sizeof(*sdr->windowed_block) * 2 * sdr->block_size);
@@ -1836,9 +1835,9 @@ process_next_block:
                     return ret;
             }
         } else {
-            av_assert0(sdr->mode == AllStationMode);
             Station *station_list[1000];
             int nb_stations = ff_sdr_find_stations(sdr, sdr->block_center_freq, sdr->sdr_sample_rate*0.5, station_list, FF_ARRAY_ELEMS(station_list));
+            av_assert0(sdr->mode == AllStationMode);
             for(int i = 0; i<nb_stations; i++) {
                 Station *station = station_list[i];
                 if (!station->stream && station->in_station_list) {
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 07/12] avradio/rds: warnings cleanup
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (4 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 06/12] avradio/sdr: Warnings cleanup Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 08/12] avradio/sdr: Move IFFT and block size to main context Michael Niedermayer
                   ` (5 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/rds.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/libavradio/rds.c b/libavradio/rds.c
index 1392bb0874..99e5360b72 100644
--- a/libavradio/rds.c
+++ b/libavradio/rds.c
@@ -171,8 +171,10 @@ int ff_sdr_decode_rds(SDRContext *sdr, Station *station, AVComplexFloat *signal)
     station->rds_ring_pos += sdr->fm_block_size_p2;
 
     while (station->rds_ring_pos > IDX(2) + IDX(4*104-1)) {
-        int best_phase;
+        int best_phase, step;
         float best_amplitude = -1;
+        float last_bpsk = 0;
+        int best_errors = INT_MAX;
         for (phase = 0; phase < 2*IDX(2); phase++) {
             double a = 0;
             for (i = 0; i<2*104; i++) {
@@ -185,7 +187,6 @@ int ff_sdr_decode_rds(SDRContext *sdr, Station *station, AVComplexFloat *signal)
         }
 
         phase = best_phase;
-        float last_bpsk = 0;
         for (i = 0; i<2*104; i++) {
             float bpsk = ring[IDX(2*i+1)][phase] - ring[IDX(2*i)][phase];
             if (i)
@@ -193,7 +194,6 @@ int ff_sdr_decode_rds(SDRContext *sdr, Station *station, AVComplexFloat *signal)
             last_bpsk = bpsk;
         }
 
-        int best_errors = INT_MAX;
         for (phase = 0; phase < 104; phase++) {
             int error = 0;
             for (int block = 0; block < 4; block++) {
@@ -217,7 +217,7 @@ int ff_sdr_decode_rds(SDRContext *sdr, Station *station, AVComplexFloat *signal)
                 decode_rds_group(sdr, station, group);
             }
         }
-        int step = IDX(2*(best_phase + 103));
+        step = IDX(2*(best_phase + 103));
 
         av_assert0(station->rds_ring_pos >= step);
         memmove(ring, ring + step, (station->rds_ring_pos + sdr->fm_block_size_p2 - step) * sizeof(*station->rds_ring));
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 08/12] avradio/sdr: Move IFFT and block size to main context
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (5 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 07/12] avradio/rds: warnings cleanup Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 09/12] avradio/sdr: Move per stream arraies " Michael Niedermayer
                   ` (4 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

This avoids duplicating this per stream instance

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/sdr.h      |  12 +++-
 libavradio/sdrdemux.c | 144 ++++++++++++++++++++++++------------------
 2 files changed, 91 insertions(+), 65 deletions(-)

diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index 834b1f40b4..79e48e6162 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -99,13 +99,10 @@ typedef struct FIFOElement {
 } FIFOElement;
 
 typedef struct SDRStream {
-    AVTXContext *ifft_ctx;
     AVTXContext *fft_ctx;
     AVTXContext *ifft_p2_ctx;
-    av_tx_fn ifft;
     av_tx_fn fft;
     av_tx_fn ifft_p2;
-    int block_size;
     int processing_index;
     float *out_buf;
     AVComplexFloat *block;
@@ -160,11 +157,20 @@ typedef struct SDRContext {
     int sample_size;
     double sample_scale;
 
+    int64_t am_bandwidth;
+    int64_t fm_bandwidth;
     int64_t fm_bandwidth_p2;
+    int am_block_size;
+    int fm_block_size;
     int fm_block_size_p2;
     int rds_ring_size;
     float *fm_window_p2;
 
+    AVTXContext *am_ifft_ctx;
+    AVTXContext *fm_ifft_ctx;
+    av_tx_fn am_ifft;
+    av_tx_fn fm_ifft;
+
     int am_mode;                            ///< AMMode but using int for generic option access
     int emphasis_mode;
     int am_fft_ref;
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index 8b8c126380..443f48aebb 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -541,7 +541,7 @@ static double find_peak_macleod(const SDRContext *sdr, const AVComplexFloat *dat
 static int probe_am(SDRContext *sdr)
 {
     int i;
-    int bandwidth_f = 6000;
+    int bandwidth_f = sdr->am_bandwidth;
     int half_bw_i = bandwidth_f * (int64_t)sdr->block_size / sdr->sdr_sample_rate;
     int border_i = (sdr->sdr_sample_rate - sdr->bandwidth) * sdr->block_size / sdr->sdr_sample_rate;
     double avg = 0;
@@ -675,7 +675,7 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
     int len   = (bandwidth * 2ll * sdr->block_size + sdr->sdr_sample_rate/2) / sdr->sdr_sample_rate;
     float *newbuf;
     float scale;
-    int sample_rate = sdr->sdr_sample_rate * (int64_t)sst->block_size / sdr->block_size;
+    int sample_rate = sdr->sdr_sample_rate * (int64_t)sdr->am_block_size / sdr->block_size;
     int ret, i;
     double current_station_i;
     float limits[2] = {-0.0, 0.0};
@@ -685,7 +685,7 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
 #define CARRIER_SEARCH 2
     if (index + len + CARRIER_SEARCH>= 2*sdr->block_size ||
         index - len - CARRIER_SEARCH < 0 ||
-        2*len + 1 > 2*sst->block_size)
+        2*len + 1 > 2*sdr->am_block_size)
         return AVERROR(ERANGE);
 
     current_station_i = find_am_carrier(sdr, sdr->block, 2*sdr->block_size, sdr->len2block, index, CARRIER_SEARCH, len);
@@ -699,21 +699,21 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
         am_mode = AMEnvelope;
     }
 
-    newbuf = av_malloc(sizeof(*sst->out_buf) * 2 * sst->block_size);
+    newbuf = av_malloc(sizeof(*sst->out_buf) * 2 * sdr->am_block_size);
     if (!newbuf)
         return AVERROR(ENOMEM);
 #define SEPC 4
 
     i = 2*len+1;
     memcpy(sst->block, sdr->block + index - len, sizeof(*sst->block) * i);
-    memset(sst->block + i, 0, sizeof(*sst->block) * (2 * sst->block_size - i));
+    memset(sst->block + i, 0, sizeof(*sst->block) * (2 * sdr->am_block_size - i));
 
-    sst->ifft(sst->ifft_ctx, sst->iblock  , sst->block, sizeof(AVComplexFloat));
+    sdr->am_ifft(sdr->am_ifft_ctx, sst->iblock  , sst->block, sizeof(AVComplexFloat));
 
     if (am_mode == AMEnvelope) {
         double vdotw = 0;
         double wdot = 0; // could be precalculated
-        for (i = 0; i<2*sst->block_size; i++) {
+        for (i = 0; i<2*sdr->am_block_size; i++) {
             float w = sst->window[i];
             float v = sqrt(len2(sst->iblock[i]));
             sst->iblock[i].re = v;
@@ -724,7 +724,7 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
         }
 
         vdotw /= wdot ;
-        for (i = 0; i<2*sst->block_size; i++) {
+        for (i = 0; i<2*sdr->am_block_size; i++) {
             float w = sst->window[i];
             sst->iblock[i].re -= w*vdotw;
         }
@@ -735,14 +735,14 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
         memset(sst->block, 0, sizeof(*sst->block) * i);
         for (i = len-SEPC+1; i<len+SEPC; i++)
             sst->block[i] = sdr->block[index + i - len];
-        sst->ifft(sst->ifft_ctx, sst->icarrier, sst->block, sizeof(AVComplexFloat));
+        sdr->am_ifft(sdr->am_ifft_ctx, sst->icarrier, sst->block, sizeof(AVComplexFloat));
 
-        synchronous_am_demodulationN(sst->iblock, sst->icarrier, sst->window, 2*sst->block_size, 1);
+        synchronous_am_demodulationN(sst->iblock, sst->icarrier, sst->window, 2*sdr->am_block_size, 1);
         scale = 0.9;
     } else {
         // Synchronous demodulation using Macleod based systhesized carrier
         double fcorr = F2INDEX(freq) - index + len;
-        double theta = -M_PI*fcorr / sst->block_size;
+        double theta = -M_PI*fcorr / sdr->am_block_size;
         AVComplexDouble mdelta = {cos(theta), sin(theta)};
         AVComplexDouble m = {1,0};
         AVComplexDouble dc1 = {0,0};
@@ -751,7 +751,7 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
         double dcw = 0;
         float amp, stamp, wamp;
 
-        for(i = 0; i<2*sst->block_size; i++) {
+        for(i = 0; i<2*sdr->am_block_size; i++) {
             double tmp;
             AVComplexFloat v = sst->iblock[i];
             sst->iblock[i].re = v.re*m.re - v.im*m.im;
@@ -773,7 +773,7 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
         wamp = amp/stamp;
 
         mm = (AVComplexFloat){dc1.re * amp, -dc1.im * amp};
-        for(i = 0; i<2*sst->block_size; i++) {
+        for(i = 0; i<2*sdr->am_block_size; i++) {
             AVComplexFloat v = sst->iblock[i];
             sst->iblock[i].re = v.re*mm.re - v.im*mm.im - sst->window[i] * wamp;
             sst->iblock[i].im = v.re*mm.im + v.im*mm.re;
@@ -782,7 +782,7 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
         scale = 0.9;
     }
 
-    for(i = 0; i<2*sst->block_size; i++) {
+    for(i = 0; i<2*sdr->am_block_size; i++) {
         av_assert0(isfinite(sst->iblock[i].re));
         av_assert0(isfinite(sst->iblock[i].im));
         limits[0] = FFMIN(limits[0], FFMIN(sst->iblock[i].re - sst->iblock[i].im,  sst->iblock[i].re + sst->iblock[i].im));
@@ -791,17 +791,17 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
     av_assert1(FFMAX(limits[1], -limits[0]) >= 0);
     scale = FFMIN(scale, 0.98 / FFMAX(limits[1], -limits[0]));
 
-    for(i = 0; i<sst->block_size; i++) {
+    for(i = 0; i<sdr->am_block_size; i++) {
         float m, q;
 
         m = sst->out_buf[2*i+0] + (sst->iblock[i                  ].re) * sst->window[i                  ] * scale;
-        newbuf[2*i+0]           = (sst->iblock[i + sst->block_size].re) * sst->window[i + sst->block_size] * scale;
+        newbuf[2*i+0]           = (sst->iblock[i + sdr->am_block_size].re) * sst->window[i + sdr->am_block_size] * scale;
 
         switch(am_mode) {
         case AMMidSide:
         case AMLeftRight:
             q = sst->out_buf[2*i+1] +  sst->iblock[i                  ].im * sst->window[i                  ] * scale;
-            newbuf[2*i+1]           =  sst->iblock[i + sst->block_size].im * sst->window[i + sst->block_size] * scale;
+            newbuf[2*i+1]           =  sst->iblock[i + sdr->am_block_size].im * sst->window[i + sdr->am_block_size] * scale;
             switch(am_mode) {
             case AMMidSide:
                 q *= 0.5;
@@ -828,7 +828,7 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
         }
     }
 
-    ret = av_packet_from_data(pkt, (void*)sst->out_buf, sizeof(*sst->out_buf) * 2 * sst->block_size);
+    ret = av_packet_from_data(pkt, (void*)sst->out_buf, sizeof(*sst->out_buf) * 2 * sdr->am_block_size);
     if (ret < 0)
         av_free(sst->out_buf);
     sst->out_buf = newbuf;
@@ -849,7 +849,7 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
 static int probe_fm(SDRContext *sdr)
 {
     int i;
-    int bandwidth_f  = 180*1000;
+    int bandwidth_f  = sdr->fm_bandwidth;
     int half_bw_i = bandwidth_f * (int64_t)sdr->block_size / sdr->sdr_sample_rate;
     float last_score[3] = {FLT_MAX, FLT_MAX, FLT_MAX};
     int border_i = (sdr->sdr_sample_rate - FFMIN(sdr->bandwidth, sdr->sdr_sample_rate*7/8)) * sdr->block_size / sdr->sdr_sample_rate;
@@ -938,19 +938,21 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
 {
     AVStream *st   = sdr->avfmt->streams[stream_index];
     SDRStream *sst = st->priv_data;
-    double freq    = sst->station->frequency;
-    int64_t bandwidth = sst->station->bandwidth;
+    Station *station = sst->station;
+
+    double freq    = station->frequency;
+    int64_t bandwidth = station->bandwidth;
     int index = lrint(F2INDEX(freq));
     int len   = (bandwidth * 2ll * sdr->block_size + sdr->sdr_sample_rate/2) / sdr->sdr_sample_rate;
     float *newbuf;
     float scale;
-    int sample_rate    = sdr->sdr_sample_rate * (int64_t)sst->block_size    / sdr->block_size;
+    int sample_rate    = sdr->sdr_sample_rate * (int64_t)sdr->fm_block_size    / sdr->block_size;
     int sample_rate_p2 = sdr->sdr_sample_rate * (int64_t)sdr->fm_block_size_p2 / sdr->block_size;
     int ret, i;
     float clip = 1.0;
-    int carrier19_i = 2L*sst->block_size*19000 / sample_rate;
-    int len17_i     = 2L*sst->block_size*16500 / sample_rate;
-    int len2_4_i    = 2L*sst->block_size* 2400 / sample_rate;
+    int carrier19_i = 2L*sdr->fm_block_size*19000 / sample_rate;
+    int len17_i     = 2L*sdr->fm_block_size*16500 / sample_rate;
+    int len2_4_i    = 2L*sdr->fm_block_size* 2400 / sample_rate;
     double carrier19_i_exact;
     int W= 5;
 
@@ -961,21 +963,21 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
 
     if (index + len >= 2*sdr->block_size ||
         index - len < 0 ||
-        2*len + 1   > 2*sst->block_size)
+        2*len + 1   > 2*sdr->fm_block_size)
     return AVERROR(ERANGE);
 
-    newbuf = av_malloc(sizeof(*sst->out_buf) * 2 * sst->block_size);
+    newbuf = av_malloc(sizeof(*sst->out_buf) * 2 * sdr->fm_block_size);
     if (!newbuf)
         return AVERROR(ENOMEM);
 
     i = 2*len+1;
     memcpy(sst->block, sdr->block + index, sizeof(*sst->block) * (len + 1));
-    memcpy(sst->block + 2 * sst->block_size - len, sdr->block + index - len, sizeof(*sst->block) * len);
-    memset(sst->block + len + 1, 0, sizeof(*sst->block) * (2 * sst->block_size - i));
+    memcpy(sst->block + 2 * sdr->fm_block_size - len, sdr->block + index - len, sizeof(*sst->block) * len);
+    memset(sst->block + len + 1, 0, sizeof(*sst->block) * (2 * sdr->fm_block_size - i));
 
-    sst->ifft(sst->ifft_ctx, sst->iblock, sst->block, sizeof(AVComplexFloat));
+    sdr->fm_ifft(sdr->fm_ifft_ctx, sst->iblock, sst->block, sizeof(AVComplexFloat));
 
-    for (i = 0; i<2*sst->block_size - 1; i++) {
+    for (i = 0; i<2*sdr->fm_block_size - 1; i++) {
         AVComplexFloat x = sst->iblock[i];
         AVComplexFloat y = sst->iblock[i+1];
         sst->iblock[i].re = atan2(x.im * y.re - x.re * y.im,
@@ -985,18 +987,18 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
     sst->iblock[i].re = 0;
     sst->iblock[i].im = 0;
 
-    av_assert0(sdr->fm_block_size_p2 * 2 < sst->block_size);
+    av_assert0(sdr->fm_block_size_p2 * 2 < sdr->fm_block_size);
     //FIXME this only needs to be a RDFT
     //CONSIDER, this and in fact alot can be done with bandpass and lowpass filters instead of FFTs, find out which is better
     //CONSIDER synthesizing the carrier instead of IFFT, we have all parameters for that
     sst->fft(sst->fft_ctx, sst->block, sst->iblock, sizeof(AVComplexFloat));
     // Only the low N/2+1 are used the upper is just a reflection
 
-    carrier19_i_exact = find_am_carrier(sdr, sst->block, 2*sst->block_size, (void*)(sst->block + 1 + sst->block_size), carrier19_i, 10, 10);
+    carrier19_i_exact = find_am_carrier(sdr, sst->block, 2*sdr->fm_block_size, (void*)(sst->block + 1 + sdr->fm_block_size), carrier19_i, 10, 10);
     carrier19_i = lrint(carrier19_i_exact);
 
     if (carrier19_i >= 0) {
-        i = sst->block_size;
+        i = sdr->fm_block_size;
         memset(sst->block + i, 0, 2*sdr->fm_block_size_p2 * sizeof(AVComplexFloat));
         memcpy(sst->block + i, sst->block + carrier19_i, sizeof(AVComplexFloat)*(W+1));
         memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - W, sst->block + carrier19_i - W, sizeof(AVComplexFloat)*W);
@@ -1018,9 +1020,9 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
     memset(sst->block + len17_i, 0, (2*sdr->fm_block_size_p2 - len17_i) * sizeof(AVComplexFloat));
     apply_deemphasis(sdr, sst->block, 2*sdr->fm_block_size_p2, sample_rate_p2, + 1);
     sst->ifft_p2(sst->ifft_p2_ctx, sst->iblock  , sst->block, sizeof(AVComplexFloat));
-    memset(sst->iblock + 2*sdr->fm_block_size_p2, 0 ,(2*sst->block_size -2*sdr->fm_block_size_p2) * sizeof(AVComplexFloat));
+    memset(sst->iblock + 2*sdr->fm_block_size_p2, 0 ,(2*sdr->fm_block_size -2*sdr->fm_block_size_p2) * sizeof(AVComplexFloat));
 
-    scale      = 5 / (M_PI * 2*sst->block_size);
+    scale      = 5 / (M_PI * 2*sdr->fm_block_size);
     for(i = 0; i<sdr->fm_block_size_p2; i++) {
         float m, q;
 
@@ -1094,13 +1096,10 @@ static void free_stream(SDRContext *sdr, int stream_index)
     AVStream *st = s->streams[stream_index];
     SDRStream *sst = st->priv_data;
 
-    av_tx_uninit(&sst->ifft_ctx);
     av_tx_uninit(&sst->fft_ctx);
     av_tx_uninit(&sst->ifft_p2_ctx);
-    sst->ifft = NULL;
     sst->fft  = NULL;
     sst->ifft_p2 = NULL;
-    sst->block_size = 0;
 
     av_freep(&sst->out_buf);
     av_freep(&sst->block);
@@ -1110,6 +1109,16 @@ static void free_stream(SDRContext *sdr, int stream_index)
     av_freep(&sst->window);
 }
 
+static int find_block_size(SDRContext *sdr, int64_t bandwidth)
+{
+    int block_size;
+
+    for (block_size = 4; 2ll * bandwidth * sdr->block_time > block_size; block_size <<= 1)
+        ;
+
+    return FFMIN(sdr->block_size,  block_size);
+}
+
 static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
 {
     AVFormatContext *s = sdr->avfmt;
@@ -1132,17 +1141,10 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
         free_stream(sdr, stream_index);
 
-        for (sst->block_size = 4; 2ll *sst->station->bandwidth * sdr->block_time > sst->block_size; sst->block_size <<= 1)
-            ;
-        sst->block_size = FFMIN(sdr->block_size,  sst->block_size);
-
-        ret = av_tx_init(&sst->ifft_ctx, &sst->ifft, AV_TX_FLOAT_FFT, 1, 2*sst->block_size, NULL, 0);
-        if (ret < 0)
-            return ret;
-
+        int block_size;
         if (sst->station->modulation == FM) {
             //Allocate 2nd stage demodulation fields if needed
-            ret = av_tx_init(&sst-> fft_ctx, &sst-> fft, AV_TX_FLOAT_FFT, 0, 2*sst->block_size   , NULL, 0);
+            ret = av_tx_init(&sst-> fft_ctx, &sst-> fft, AV_TX_FLOAT_FFT, 0, 2*sdr->fm_block_size   , NULL, 0);
             if (ret < 0)
                 return ret;
 
@@ -1153,19 +1155,21 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
             sst->iside     = av_malloc(sizeof(*sst->iside)    * 2 * sdr->fm_block_size_p2);
             if (!sst->iside)
                 return AVERROR(ENOMEM);
-        }
-
-        sst->out_buf   = av_mallocz(sizeof(*sst->out_buf) * 2 * sst->block_size);
-        sst->block     = av_malloc(sizeof(*sst-> block)   * 2 * sst->block_size);
-        sst->iblock    = av_malloc(sizeof(*sst->iblock)   * 2 * sst->block_size);
-        sst->icarrier  = av_malloc(sizeof(*sst->icarrier) * 2 * sst->block_size);
-        sst->window    = av_malloc(sizeof(*sst->window)   * 2 * sst->block_size);
+            block_size = sdr->fm_block_size;
+        } else
+            block_size = sdr->am_block_size;
+
+        sst->out_buf   = av_mallocz(sizeof(*sst->out_buf) * 2 * block_size);
+        sst->block     = av_malloc(sizeof(*sst-> block)   * 2 * block_size);
+        sst->iblock    = av_malloc(sizeof(*sst->iblock)   * 2 * block_size);
+        sst->icarrier  = av_malloc(sizeof(*sst->icarrier) * 2 * block_size);
+        sst->window    = av_malloc(sizeof(*sst->window)   * 2 * block_size);
         if (!sst->out_buf || !sst->block || !sst->iblock || !sst->icarrier || !sst->window)
             return AVERROR(ENOMEM);
 
-        avpriv_kbd_window_init(sst->window, sdr->kbd_alpha, sst->block_size);
-        for(int i = sst->block_size; i < 2 * sst->block_size; i++) {
-            sst->window[i] = sst->window[2*sst->block_size - i - 1];
+        avpriv_kbd_window_init(sst->window, sdr->kbd_alpha, block_size);
+        for(int i = block_size; i < 2 * block_size; i++) {
+            sst->window[i] = sst->window[2*block_size - i - 1];
         }
 
         sst->am_amplitude = 0;
@@ -1491,10 +1495,13 @@ int ff_sdr_common_init(AVFormatContext *s)
     av_log(s, AV_LOG_INFO, "Block size %d\n", sdr->block_size);
 
     sdr->block_time = sdr->block_size / (double)sdr->sdr_sample_rate;
-    sdr->fm_bandwidth_p2 = 18 * 1000;
-    if (!sdr->fm_block_size_p2)
-        for (sdr->fm_block_size_p2 = 4; 2ll *sdr->fm_bandwidth_p2 * sdr->block_time > sdr->fm_block_size_p2; sdr->fm_block_size_p2 <<= 1)
-            ;
+    sdr->am_bandwidth    =   6 * 1000;
+    sdr->fm_bandwidth    = 180 * 1000;
+    sdr->fm_bandwidth_p2 =  18 * 1000;
+
+    sdr->am_block_size    = find_block_size(sdr, sdr->am_bandwidth);
+    sdr->fm_block_size    = find_block_size(sdr, sdr->fm_bandwidth);
+    sdr->fm_block_size_p2 = find_block_size(sdr, sdr->fm_bandwidth_p2);
 
     sdr->windowed_block = av_malloc(sizeof(*sdr->windowed_block) * 2 * sdr->block_size);
     sdr->block     = av_malloc(sizeof(*sdr->block    ) * 2 * sdr->block_size);
@@ -1509,6 +1516,15 @@ int ff_sdr_common_init(AVFormatContext *s)
     if (ret < 0)
         return ret;
 
+    ret = av_tx_init(&sdr->am_ifft_ctx, &sdr->am_ifft, AV_TX_FLOAT_FFT, 1, 2*sdr->am_block_size, NULL, 0);
+    if (ret < 0)
+        return ret;
+
+    ret = av_tx_init(&sdr->fm_ifft_ctx, &sdr->fm_ifft, AV_TX_FLOAT_FFT, 1, 2*sdr->fm_block_size, NULL, 0);
+    if (ret < 0)
+        return ret;
+
+
     avpriv_kbd_window_init(sdr->window, sdr->kbd_alpha, sdr->block_size);
 
     for(int i = sdr->block_size; i < 2 * sdr->block_size; i++) {
@@ -1973,7 +1989,11 @@ int ff_sdr_read_close(AVFormatContext *s)
     av_freep(&sdr->fm_window_p2);
 
     av_tx_uninit(&sdr->fft_ctx);
+    av_tx_uninit(&sdr->am_ifft_ctx);
+    av_tx_uninit(&sdr->fm_ifft_ctx);
     sdr->fft = NULL;
+    sdr->am_ifft = NULL;
+    sdr->fm_ifft = NULL;
 
     avio_close(sdr->dump_avio);
 
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 09/12] avradio/sdr: Move per stream arraies to main context
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (6 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 08/12] avradio/sdr: Move IFFT and block size to main context Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 10/12] avradio/sdr: Move tx contexts out of stream so its not duplicated Michael Niedermayer
                   ` (3 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

This avoids allocating them per stream instance

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/sdr.h      |  15 ++--
 libavradio/sdrdemux.c | 204 ++++++++++++++++++++++--------------------
 2 files changed, 116 insertions(+), 103 deletions(-)

diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index 79e48e6162..8d7ab803d4 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -105,11 +105,7 @@ typedef struct SDRStream {
     av_tx_fn ifft_p2;
     int processing_index;
     float *out_buf;
-    AVComplexFloat *block;
-    AVComplexFloat *iblock;
-    AVComplexFloat *icarrier;
-    AVComplexFloat *iside;
-    float *window;
+
     Station *station;
     float am_amplitude;
 
@@ -164,6 +160,15 @@ typedef struct SDRContext {
     int fm_block_size;
     int fm_block_size_p2;
     int rds_ring_size;
+    AVComplexFloat *am_block;
+    AVComplexFloat *am_iblock;
+    AVComplexFloat *am_icarrier;
+    float *am_window;
+    AVComplexFloat *fm_iside;
+    AVComplexFloat *fm_block;
+    AVComplexFloat *fm_iblock;
+    AVComplexFloat *fm_icarrier;
+    float *fm_window;
     float *fm_window_p2;
 
     AVTXContext *am_ifft_ctx;
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index 443f48aebb..6442d251f6 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -705,19 +705,19 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
 #define SEPC 4
 
     i = 2*len+1;
-    memcpy(sst->block, sdr->block + index - len, sizeof(*sst->block) * i);
-    memset(sst->block + i, 0, sizeof(*sst->block) * (2 * sdr->am_block_size - i));
+    memcpy(sdr->am_block, sdr->block + index - len, sizeof(*sdr->am_block) * i);
+    memset(sdr->am_block + i, 0, sizeof(*sdr->am_block) * (2 * sdr->am_block_size - i));
 
-    sdr->am_ifft(sdr->am_ifft_ctx, sst->iblock  , sst->block, sizeof(AVComplexFloat));
+    sdr->am_ifft(sdr->am_ifft_ctx, sdr->am_iblock  , sdr->am_block, sizeof(AVComplexFloat));
 
     if (am_mode == AMEnvelope) {
         double vdotw = 0;
         double wdot = 0; // could be precalculated
         for (i = 0; i<2*sdr->am_block_size; i++) {
-            float w = sst->window[i];
-            float v = sqrt(len2(sst->iblock[i]));
-            sst->iblock[i].re = v;
-            sst->iblock[i].im = 0;
+            float w = sdr->am_window[i];
+            float v = sqrt(len2(sdr->am_iblock[i]));
+            sdr->am_iblock[i].re = v;
+            sdr->am_iblock[i].im = 0;
 
             vdotw += w*v;
             wdot += w*w;
@@ -725,19 +725,19 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
 
         vdotw /= wdot ;
         for (i = 0; i<2*sdr->am_block_size; i++) {
-            float w = sst->window[i];
-            sst->iblock[i].re -= w*vdotw;
+            float w = sdr->am_window[i];
+            sdr->am_iblock[i].re -= w*vdotw;
         }
 
         scale = 0.9/vdotw;
     } else if (sdr->am_fft_ref) {
         // Synchronous demodulation using FFT
-        memset(sst->block, 0, sizeof(*sst->block) * i);
+        memset(sdr->am_block, 0, sizeof(*sdr->am_block) * i);
         for (i = len-SEPC+1; i<len+SEPC; i++)
-            sst->block[i] = sdr->block[index + i - len];
-        sdr->am_ifft(sdr->am_ifft_ctx, sst->icarrier, sst->block, sizeof(AVComplexFloat));
+            sdr->am_block[i] = sdr->block[index + i - len];
+        sdr->am_ifft(sdr->am_ifft_ctx, sdr->am_icarrier, sdr->am_block, sizeof(AVComplexFloat));
 
-        synchronous_am_demodulationN(sst->iblock, sst->icarrier, sst->window, 2*sdr->am_block_size, 1);
+        synchronous_am_demodulationN(sdr->am_iblock, sdr->am_icarrier, sdr->am_window, 2*sdr->am_block_size, 1);
         scale = 0.9;
     } else {
         // Synchronous demodulation using Macleod based systhesized carrier
@@ -753,16 +753,16 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
 
         for(i = 0; i<2*sdr->am_block_size; i++) {
             double tmp;
-            AVComplexFloat v = sst->iblock[i];
-            sst->iblock[i].re = v.re*m.re - v.im*m.im;
-            sst->iblock[i].im = v.re*m.im + v.im*m.re;
+            AVComplexFloat v = sdr->am_iblock[i];
+            sdr->am_iblock[i].re = v.re*m.re - v.im*m.im;
+            sdr->am_iblock[i].im = v.re*m.im + v.im*m.re;
             tmp  = m.re*mdelta.im + m.im*mdelta.re;
             m.re = m.re*mdelta.re - m.im*mdelta.im;
             m.im = tmp;
-            dc1.re += sst->iblock[i].re * sst->window[i];
-            dc1.im += sst->iblock[i].im * sst->window[i];
-            s2     += len2(sst->iblock[i]);
-            dcw    += sst->window[i] * sst->window[i];
+            dc1.re += sdr->am_iblock[i].re * sdr->am_window[i];
+            dc1.im += sdr->am_iblock[i].im * sdr->am_window[i];
+            s2     += len2(sdr->am_iblock[i]);
+            dcw    += sdr->am_window[i] * sdr->am_window[i];
         }
 
         stamp = dcw / (dc1.re*dc1.re + dc1.im*dc1.im);
@@ -774,19 +774,19 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
 
         mm = (AVComplexFloat){dc1.re * amp, -dc1.im * amp};
         for(i = 0; i<2*sdr->am_block_size; i++) {
-            AVComplexFloat v = sst->iblock[i];
-            sst->iblock[i].re = v.re*mm.re - v.im*mm.im - sst->window[i] * wamp;
-            sst->iblock[i].im = v.re*mm.im + v.im*mm.re;
+            AVComplexFloat v = sdr->am_iblock[i];
+            sdr->am_iblock[i].re = v.re*mm.re - v.im*mm.im - sdr->am_window[i] * wamp;
+            sdr->am_iblock[i].im = v.re*mm.im + v.im*mm.re;
         }
 
         scale = 0.9;
     }
 
     for(i = 0; i<2*sdr->am_block_size; i++) {
-        av_assert0(isfinite(sst->iblock[i].re));
-        av_assert0(isfinite(sst->iblock[i].im));
-        limits[0] = FFMIN(limits[0], FFMIN(sst->iblock[i].re - sst->iblock[i].im,  sst->iblock[i].re + sst->iblock[i].im));
-        limits[1] = FFMAX(limits[1], FFMAX(sst->iblock[i].re - sst->iblock[i].im,  sst->iblock[i].re + sst->iblock[i].im));
+        av_assert0(isfinite(sdr->am_iblock[i].re));
+        av_assert0(isfinite(sdr->am_iblock[i].im));
+        limits[0] = FFMIN(limits[0], FFMIN(sdr->am_iblock[i].re - sdr->am_iblock[i].im,  sdr->am_iblock[i].re + sdr->am_iblock[i].im));
+        limits[1] = FFMAX(limits[1], FFMAX(sdr->am_iblock[i].re - sdr->am_iblock[i].im,  sdr->am_iblock[i].re + sdr->am_iblock[i].im));
     }
     av_assert1(FFMAX(limits[1], -limits[0]) >= 0);
     scale = FFMIN(scale, 0.98 / FFMAX(limits[1], -limits[0]));
@@ -794,14 +794,14 @@ static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
     for(i = 0; i<sdr->am_block_size; i++) {
         float m, q;
 
-        m = sst->out_buf[2*i+0] + (sst->iblock[i                  ].re) * sst->window[i                  ] * scale;
-        newbuf[2*i+0]           = (sst->iblock[i + sdr->am_block_size].re) * sst->window[i + sdr->am_block_size] * scale;
+        m = sst->out_buf[2*i+0] + (sdr->am_iblock[i                     ].re) * sdr->am_window[i                     ] * scale;
+        newbuf[2*i+0]           = (sdr->am_iblock[i + sdr->am_block_size].re) * sdr->am_window[i + sdr->am_block_size] * scale;
 
         switch(am_mode) {
         case AMMidSide:
         case AMLeftRight:
-            q = sst->out_buf[2*i+1] +  sst->iblock[i                  ].im * sst->window[i                  ] * scale;
-            newbuf[2*i+1]           =  sst->iblock[i + sdr->am_block_size].im * sst->window[i + sdr->am_block_size] * scale;
+            q = sst->out_buf[2*i+1] +  sdr->am_iblock[i                     ].im * sdr->am_window[i                     ] * scale;
+            newbuf[2*i+1]           =  sdr->am_iblock[i + sdr->am_block_size].im * sdr->am_window[i + sdr->am_block_size] * scale;
             switch(am_mode) {
             case AMMidSide:
                 q *= 0.5;
@@ -971,67 +971,67 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
         return AVERROR(ENOMEM);
 
     i = 2*len+1;
-    memcpy(sst->block, sdr->block + index, sizeof(*sst->block) * (len + 1));
-    memcpy(sst->block + 2 * sdr->fm_block_size - len, sdr->block + index - len, sizeof(*sst->block) * len);
-    memset(sst->block + len + 1, 0, sizeof(*sst->block) * (2 * sdr->fm_block_size - i));
+    memcpy(sdr->fm_block, sdr->block + index, sizeof(*sdr->fm_block) * (len + 1));
+    memcpy(sdr->fm_block + 2 * sdr->fm_block_size - len, sdr->block + index - len, sizeof(*sdr->fm_block) * len);
+    memset(sdr->fm_block + len + 1, 0, sizeof(*sdr->fm_block) * (2 * sdr->fm_block_size - i));
 
-    sdr->fm_ifft(sdr->fm_ifft_ctx, sst->iblock, sst->block, sizeof(AVComplexFloat));
+    sdr->fm_ifft(sdr->fm_ifft_ctx, sdr->fm_iblock, sdr->fm_block, sizeof(AVComplexFloat));
 
     for (i = 0; i<2*sdr->fm_block_size - 1; i++) {
-        AVComplexFloat x = sst->iblock[i];
-        AVComplexFloat y = sst->iblock[i+1];
-        sst->iblock[i].re = atan2(x.im * y.re - x.re * y.im,
-                                  x.re * y.re + x.im * y.im) * sst->window[i];
-        sst->iblock[i].im = 0;
+        AVComplexFloat x = sdr->fm_iblock[i];
+        AVComplexFloat y = sdr->fm_iblock[i+1];
+        sdr->fm_iblock[i].re = atan2(x.im * y.re - x.re * y.im,
+                                     x.re * y.re + x.im * y.im) * sdr->fm_window[i];
+        sdr->fm_iblock[i].im = 0;
     }
-    sst->iblock[i].re = 0;
-    sst->iblock[i].im = 0;
+    sdr->fm_iblock[i].re = 0;
+    sdr->fm_iblock[i].im = 0;
 
     av_assert0(sdr->fm_block_size_p2 * 2 < sdr->fm_block_size);
     //FIXME this only needs to be a RDFT
     //CONSIDER, this and in fact alot can be done with bandpass and lowpass filters instead of FFTs, find out which is better
     //CONSIDER synthesizing the carrier instead of IFFT, we have all parameters for that
-    sst->fft(sst->fft_ctx, sst->block, sst->iblock, sizeof(AVComplexFloat));
+    sst->fft(sst->fft_ctx, sdr->fm_block, sdr->fm_iblock, sizeof(AVComplexFloat));
     // Only the low N/2+1 are used the upper is just a reflection
 
-    carrier19_i_exact = find_am_carrier(sdr, sst->block, 2*sdr->fm_block_size, (void*)(sst->block + 1 + sdr->fm_block_size), carrier19_i, 10, 10);
+    carrier19_i_exact = find_am_carrier(sdr, sdr->fm_block, 2*sdr->fm_block_size, (void*)(sdr->fm_block + 1 + sdr->fm_block_size), carrier19_i, 10, 10);
     carrier19_i = lrint(carrier19_i_exact);
 
     if (carrier19_i >= 0) {
         i = sdr->fm_block_size;
-        memset(sst->block + i, 0, 2*sdr->fm_block_size_p2 * sizeof(AVComplexFloat));
-        memcpy(sst->block + i, sst->block + carrier19_i, sizeof(AVComplexFloat)*(W+1));
-        memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - W, sst->block + carrier19_i - W, sizeof(AVComplexFloat)*W);
-        sst->ifft_p2(sst->ifft_p2_ctx, sst->icarrier, sst->block + i, sizeof(AVComplexFloat));
-
-        memcpy(sst->block + i, sst->block + 3*carrier19_i, sizeof(AVComplexFloat)*len2_4_i);
-        memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - len2_4_i, sst->block + 3*carrier19_i - len2_4_i, sizeof(AVComplexFloat)*len2_4_i);
-        sst->ifft_p2(sst->ifft_p2_ctx, sst->iside   , sst->block + i, sizeof(AVComplexFloat));
-        synchronous_am_demodulationN(sst->iside, sst->icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 3);
-        ff_sdr_decode_rds(sdr, sst->station, sst->iside);
-
-        memcpy(sst->block + i, sst->block + 2*carrier19_i, sizeof(AVComplexFloat)*len17_i);
-        memcpy(sst->block + i + 2*sdr->fm_block_size_p2 - len17_i, sst->block + 2*carrier19_i - len17_i, sizeof(AVComplexFloat)*len17_i);
-        apply_deemphasis(sdr, sst->block + i, sdr->fm_block_size_p2, sample_rate_p2, + 1);
-        apply_deemphasis(sdr, sst->block + i + 2*sdr->fm_block_size_p2, sdr->fm_block_size_p2, sample_rate_p2, - 1);
-        sst->ifft_p2(sst->ifft_p2_ctx, sst->iside   , sst->block + i, sizeof(AVComplexFloat));
-        synchronous_am_demodulationN(sst->iside, sst->icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 2);
+        memset(sdr->fm_block + i, 0, 2*sdr->fm_block_size_p2 * sizeof(AVComplexFloat));
+        memcpy(sdr->fm_block + i, sdr->fm_block + carrier19_i, sizeof(AVComplexFloat)*(W+1));
+        memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - W, sdr->fm_block + carrier19_i - W, sizeof(AVComplexFloat)*W);
+        sst->ifft_p2(sst->ifft_p2_ctx, sdr->fm_icarrier, sdr->fm_block + i, sizeof(AVComplexFloat));
+
+        memcpy(sdr->fm_block + i, sdr->fm_block + 3*carrier19_i, sizeof(AVComplexFloat)*len2_4_i);
+        memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - len2_4_i, sdr->fm_block + 3*carrier19_i - len2_4_i, sizeof(AVComplexFloat)*len2_4_i);
+        sst->ifft_p2(sst->ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
+        synchronous_am_demodulationN(sdr->fm_iside, sdr->fm_icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 3);
+        ff_sdr_decode_rds(sdr, sst->station, sdr->fm_iside);
+
+        memcpy(sdr->fm_block + i, sdr->fm_block + 2*carrier19_i, sizeof(AVComplexFloat)*len17_i);
+        memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - len17_i, sdr->fm_block + 2*carrier19_i - len17_i, sizeof(AVComplexFloat)*len17_i);
+        apply_deemphasis(sdr, sdr->fm_block + i, sdr->fm_block_size_p2, sample_rate_p2, + 1);
+        apply_deemphasis(sdr, sdr->fm_block + i + 2*sdr->fm_block_size_p2, sdr->fm_block_size_p2, sample_rate_p2, - 1);
+        sst->ifft_p2(sst->ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
+        synchronous_am_demodulationN(sdr->fm_iside, sdr->fm_icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 2);
     }
-    memset(sst->block + len17_i, 0, (2*sdr->fm_block_size_p2 - len17_i) * sizeof(AVComplexFloat));
-    apply_deemphasis(sdr, sst->block, 2*sdr->fm_block_size_p2, sample_rate_p2, + 1);
-    sst->ifft_p2(sst->ifft_p2_ctx, sst->iblock  , sst->block, sizeof(AVComplexFloat));
-    memset(sst->iblock + 2*sdr->fm_block_size_p2, 0 ,(2*sdr->fm_block_size -2*sdr->fm_block_size_p2) * sizeof(AVComplexFloat));
+    memset(sdr->fm_block + len17_i, 0, (2*sdr->fm_block_size_p2 - len17_i) * sizeof(AVComplexFloat));
+    apply_deemphasis(sdr, sdr->fm_block, 2*sdr->fm_block_size_p2, sample_rate_p2, + 1);
+    sst->ifft_p2(sst->ifft_p2_ctx, sdr->fm_iblock  , sdr->fm_block, sizeof(AVComplexFloat));
+    memset(sdr->fm_iblock + 2*sdr->fm_block_size_p2, 0 ,(2*sdr->fm_block_size -2*sdr->fm_block_size_p2) * sizeof(AVComplexFloat));
 
     scale      = 5 / (M_PI * 2*sdr->fm_block_size);
     for(i = 0; i<sdr->fm_block_size_p2; i++) {
         float m, q;
 
-        m = sst->out_buf[2*i+0] + (sst->iblock[i                     ].re) * sdr->fm_window_p2[i                     ] * scale;
-        newbuf[2*i+0]           = (sst->iblock[i + sdr->fm_block_size_p2].re) * sdr->fm_window_p2[i + sdr->fm_block_size_p2] * scale;
+        m = sst->out_buf[2*i+0] + (sdr->fm_iblock[i                        ].re) * sdr->fm_window_p2[i                        ] * scale;
+        newbuf[2*i+0]           = (sdr->fm_iblock[i + sdr->fm_block_size_p2].re) * sdr->fm_window_p2[i + sdr->fm_block_size_p2] * scale;
 
         if (carrier19_i >= 0) {
-            q = sst->out_buf[2*i+1] +  sst->iside[i                     ].im * sdr->fm_window_p2[i                     ] * scale;
-            newbuf[2*i+1]           =  sst->iside[i + sdr->fm_block_size_p2].im * sdr->fm_window_p2[i + sdr->fm_block_size_p2] * scale;
+            q = sst->out_buf[2*i+1] +  sdr->fm_iside[i                        ].im * sdr->fm_window_p2[i                        ] * scale;
+            newbuf[2*i+1]           =  sdr->fm_iside[i + sdr->fm_block_size_p2].im * sdr->fm_window_p2[i + sdr->fm_block_size_p2] * scale;
 
             sst->out_buf[2*i+0] = m + q;
             sst->out_buf[2*i+1] = m - q;
@@ -1102,11 +1102,6 @@ static void free_stream(SDRContext *sdr, int stream_index)
     sst->ifft_p2 = NULL;
 
     av_freep(&sst->out_buf);
-    av_freep(&sst->block);
-    av_freep(&sst->iblock);
-    av_freep(&sst->icarrier);
-    av_freep(&sst->iside);
-    av_freep(&sst->window);
 }
 
 static int find_block_size(SDRContext *sdr, int64_t bandwidth)
@@ -1152,26 +1147,14 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
             if (ret < 0)
                 return ret;
 
-            sst->iside     = av_malloc(sizeof(*sst->iside)    * 2 * sdr->fm_block_size_p2);
-            if (!sst->iside)
-                return AVERROR(ENOMEM);
             block_size = sdr->fm_block_size;
         } else
             block_size = sdr->am_block_size;
 
         sst->out_buf   = av_mallocz(sizeof(*sst->out_buf) * 2 * block_size);
-        sst->block     = av_malloc(sizeof(*sst-> block)   * 2 * block_size);
-        sst->iblock    = av_malloc(sizeof(*sst->iblock)   * 2 * block_size);
-        sst->icarrier  = av_malloc(sizeof(*sst->icarrier) * 2 * block_size);
-        sst->window    = av_malloc(sizeof(*sst->window)   * 2 * block_size);
-        if (!sst->out_buf || !sst->block || !sst->iblock || !sst->icarrier || !sst->window)
+        if (!sst->out_buf)
             return AVERROR(ENOMEM);
 
-        avpriv_kbd_window_init(sst->window, sdr->kbd_alpha, block_size);
-        for(int i = block_size; i < 2 * block_size; i++) {
-            sst->window[i] = sst->window[2*block_size - i - 1];
-        }
-
         sst->am_amplitude = 0;
     }
 
@@ -1430,6 +1413,14 @@ static void *soapy_needs_bigger_buffers_worker(SDRContext *sdr)
     return NULL;
 }
 
+static void init_window(SDRContext *sdr, float *window, int block_size)
+{
+    avpriv_kbd_window_init(window, sdr->kbd_alpha, block_size);
+    for(int i = block_size; i < 2 * block_size; i++) {
+        window[i] = window[2 * block_size - i - 1];
+    }
+}
+
 int ff_sdr_common_init(AVFormatContext *s)
 {
     SDRContext *sdr = s->priv_data;
@@ -1507,9 +1498,21 @@ int ff_sdr_common_init(AVFormatContext *s)
     sdr->block     = av_malloc(sizeof(*sdr->block    ) * 2 * sdr->block_size);
     sdr->len2block = av_malloc(sizeof(*sdr->len2block) * 2 * sdr->block_size);
     sdr->window    = av_malloc(sizeof(*sdr->window   ) * 2 * sdr->block_size);
+    sdr->am_block     = av_malloc(sizeof(*sdr->am_block)    * 2 * sdr->am_block_size);
+    sdr->am_iblock    = av_malloc(sizeof(*sdr->am_iblock)   * 2 * sdr->am_block_size);
+    sdr->am_icarrier  = av_malloc(sizeof(*sdr->am_icarrier) * 2 * sdr->am_block_size);
+    sdr->am_window    = av_malloc(sizeof(*sdr->am_window)   * 2 * sdr->am_block_size);
     sdr->fm_window_p2 = av_malloc(sizeof(*sdr->fm_window_p2)* 2 * sdr->fm_block_size_p2);
-
-    if (!sdr->windowed_block || !sdr->len2block || !sdr->block || !sdr->window || !sdr->fm_window_p2)
+    sdr->fm_iside     = av_malloc(sizeof(*sdr->fm_iside)    * 2 * sdr->fm_block_size_p2);
+    sdr->fm_block     = av_malloc(sizeof(*sdr->fm_block)    * 2 * sdr->fm_block_size);
+    sdr->fm_iblock    = av_malloc(sizeof(*sdr->fm_iblock)   * 2 * sdr->fm_block_size);
+    sdr->fm_icarrier  = av_malloc(sizeof(*sdr->fm_icarrier) * 2 * sdr->fm_block_size);
+    sdr->fm_window    = av_malloc(sizeof(*sdr->fm_window)   * 2 * sdr->fm_block_size);
+
+    if (!sdr->windowed_block || !sdr->len2block || !sdr->block || !sdr->window || !sdr->fm_window_p2 || !sdr->fm_iside ||
+        !sdr->am_block || !sdr->am_iblock || !sdr->am_icarrier || !sdr->am_window || !sdr->fm_window_p2 || !sdr->fm_iside ||
+        !sdr->fm_block || !sdr->fm_iblock || !sdr->fm_icarrier || !sdr->fm_window
+    )
         return AVERROR(ENOMEM);
 
     ret = av_tx_init(&sdr->fft_ctx, &sdr->fft, AV_TX_FLOAT_FFT, 0, 2*sdr->block_size, NULL, 0);
@@ -1524,19 +1527,14 @@ int ff_sdr_common_init(AVFormatContext *s)
     if (ret < 0)
         return ret;
 
+    init_window(sdr, sdr->window, sdr->block_size);
 
-    avpriv_kbd_window_init(sdr->window, sdr->kbd_alpha, sdr->block_size);
-
-    for(int i = sdr->block_size; i < 2 * sdr->block_size; i++) {
-        sdr->window[i] = sdr->window[2*sdr->block_size - i - 1];
-    }
     for (int i = 0; i < 2 * sdr->block_size; i++)
         sdr->window[i] *= ((i&1) ? 1:-1) * scale;
 
-    avpriv_kbd_window_init(sdr->fm_window_p2, sdr->kbd_alpha, sdr->fm_block_size_p2);
-    for(int i = sdr->fm_block_size_p2; i < 2 * sdr->fm_block_size_p2; i++) {
-        sdr->fm_window_p2[i] = sdr->fm_window_p2[2*sdr->fm_block_size_p2 - i - 1];
-    }
+    init_window(sdr, sdr->am_window, sdr->am_block_size);
+    init_window(sdr, sdr->fm_window, sdr->fm_block_size);
+    init_window(sdr, sdr->fm_window_p2, sdr->fm_block_size_p2);
 
     if (sdr->waterfall_st_index >= 0) {
         AVStream *st = s->streams[sdr->waterfall_st_index];
@@ -1986,6 +1984,16 @@ int ff_sdr_read_close(AVFormatContext *s)
     av_freep(&sdr->block);
     av_freep(&sdr->len2block);
     av_freep(&sdr->window);
+
+    av_freep(&sdr->am_block);
+    av_freep(&sdr->am_iblock);
+    av_freep(&sdr->am_icarrier);
+    av_freep(&sdr->am_window);
+    av_freep(&sdr->fm_iside);
+    av_freep(&sdr->fm_block);
+    av_freep(&sdr->fm_iblock);
+    av_freep(&sdr->fm_icarrier);
+    av_freep(&sdr->fm_window);
     av_freep(&sdr->fm_window_p2);
 
     av_tx_uninit(&sdr->fft_ctx);
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 10/12] avradio/sdr: Move tx contexts out of stream so its not duplicated
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (7 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 09/12] avradio/sdr: Move per stream arraies " Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 11/12] avradio/sdr: Pass AVStream instead of int to demodulate Michael Niedermayer
                   ` (2 subsequent siblings)
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/sdr.h      | 10 +++++----
 libavradio/sdrdemux.c | 48 +++++++++++++++++++++++--------------------
 2 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index 8d7ab803d4..cb4b6dc68b 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -99,10 +99,6 @@ typedef struct FIFOElement {
 } FIFOElement;
 
 typedef struct SDRStream {
-    AVTXContext *fft_ctx;
-    AVTXContext *ifft_p2_ctx;
-    av_tx_fn fft;
-    av_tx_fn ifft_p2;
     int processing_index;
     float *out_buf;
 
@@ -172,9 +168,15 @@ typedef struct SDRContext {
     float *fm_window_p2;
 
     AVTXContext *am_ifft_ctx;
+    AVTXContext *am_fft_ctx;
     AVTXContext *fm_ifft_ctx;
+    AVTXContext *fm_fft_ctx;
+    AVTXContext *fm_ifft_p2_ctx;
     av_tx_fn am_ifft;
+    av_tx_fn am_fft;
     av_tx_fn fm_ifft;
+    av_tx_fn fm_fft;
+    av_tx_fn fm_ifft_p2;
 
     int am_mode;                            ///< AMMode but using int for generic option access
     int emphasis_mode;
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index 6442d251f6..5d58d81843 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -991,7 +991,7 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
     //FIXME this only needs to be a RDFT
     //CONSIDER, this and in fact alot can be done with bandpass and lowpass filters instead of FFTs, find out which is better
     //CONSIDER synthesizing the carrier instead of IFFT, we have all parameters for that
-    sst->fft(sst->fft_ctx, sdr->fm_block, sdr->fm_iblock, sizeof(AVComplexFloat));
+    sdr->fm_fft(sdr->fm_fft_ctx, sdr->fm_block, sdr->fm_iblock, sizeof(AVComplexFloat));
     // Only the low N/2+1 are used the upper is just a reflection
 
     carrier19_i_exact = find_am_carrier(sdr, sdr->fm_block, 2*sdr->fm_block_size, (void*)(sdr->fm_block + 1 + sdr->fm_block_size), carrier19_i, 10, 10);
@@ -1002,11 +1002,11 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
         memset(sdr->fm_block + i, 0, 2*sdr->fm_block_size_p2 * sizeof(AVComplexFloat));
         memcpy(sdr->fm_block + i, sdr->fm_block + carrier19_i, sizeof(AVComplexFloat)*(W+1));
         memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - W, sdr->fm_block + carrier19_i - W, sizeof(AVComplexFloat)*W);
-        sst->ifft_p2(sst->ifft_p2_ctx, sdr->fm_icarrier, sdr->fm_block + i, sizeof(AVComplexFloat));
+        sdr->fm_ifft_p2(sdr->fm_ifft_p2_ctx, sdr->fm_icarrier, sdr->fm_block + i, sizeof(AVComplexFloat));
 
         memcpy(sdr->fm_block + i, sdr->fm_block + 3*carrier19_i, sizeof(AVComplexFloat)*len2_4_i);
         memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - len2_4_i, sdr->fm_block + 3*carrier19_i - len2_4_i, sizeof(AVComplexFloat)*len2_4_i);
-        sst->ifft_p2(sst->ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
+        sdr->fm_ifft_p2(sdr->fm_ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
         synchronous_am_demodulationN(sdr->fm_iside, sdr->fm_icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 3);
         ff_sdr_decode_rds(sdr, sst->station, sdr->fm_iside);
 
@@ -1014,12 +1014,12 @@ static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
         memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - len17_i, sdr->fm_block + 2*carrier19_i - len17_i, sizeof(AVComplexFloat)*len17_i);
         apply_deemphasis(sdr, sdr->fm_block + i, sdr->fm_block_size_p2, sample_rate_p2, + 1);
         apply_deemphasis(sdr, sdr->fm_block + i + 2*sdr->fm_block_size_p2, sdr->fm_block_size_p2, sample_rate_p2, - 1);
-        sst->ifft_p2(sst->ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
+        sdr->fm_ifft_p2(sdr->fm_ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
         synchronous_am_demodulationN(sdr->fm_iside, sdr->fm_icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 2);
     }
     memset(sdr->fm_block + len17_i, 0, (2*sdr->fm_block_size_p2 - len17_i) * sizeof(AVComplexFloat));
     apply_deemphasis(sdr, sdr->fm_block, 2*sdr->fm_block_size_p2, sample_rate_p2, + 1);
-    sst->ifft_p2(sst->ifft_p2_ctx, sdr->fm_iblock  , sdr->fm_block, sizeof(AVComplexFloat));
+    sdr->fm_ifft_p2(sdr->fm_ifft_p2_ctx, sdr->fm_iblock  , sdr->fm_block, sizeof(AVComplexFloat));
     memset(sdr->fm_iblock + 2*sdr->fm_block_size_p2, 0 ,(2*sdr->fm_block_size -2*sdr->fm_block_size_p2) * sizeof(AVComplexFloat));
 
     scale      = 5 / (M_PI * 2*sdr->fm_block_size);
@@ -1096,11 +1096,6 @@ static void free_stream(SDRContext *sdr, int stream_index)
     AVStream *st = s->streams[stream_index];
     SDRStream *sst = st->priv_data;
 
-    av_tx_uninit(&sst->fft_ctx);
-    av_tx_uninit(&sst->ifft_p2_ctx);
-    sst->fft  = NULL;
-    sst->ifft_p2 = NULL;
-
     av_freep(&sst->out_buf);
 }
 
@@ -1138,15 +1133,6 @@ static int setup_stream(SDRContext *sdr, int stream_index, Station *station)
 
         int block_size;
         if (sst->station->modulation == FM) {
-            //Allocate 2nd stage demodulation fields if needed
-            ret = av_tx_init(&sst-> fft_ctx, &sst-> fft, AV_TX_FLOAT_FFT, 0, 2*sdr->fm_block_size   , NULL, 0);
-            if (ret < 0)
-                return ret;
-
-            ret = av_tx_init(&sst->ifft_p2_ctx, &sst->ifft_p2, AV_TX_FLOAT_FFT, 1, 2*sdr->fm_block_size_p2, NULL, 0);
-            if (ret < 0)
-                return ret;
-
             block_size = sdr->fm_block_size;
         } else
             block_size = sdr->am_block_size;
@@ -1523,10 +1509,22 @@ int ff_sdr_common_init(AVFormatContext *s)
     if (ret < 0)
         return ret;
 
+    ret = av_tx_init(&sdr->am_fft_ctx, &sdr->am_fft, AV_TX_FLOAT_FFT, 0, 2*sdr->am_block_size   , NULL, 0);
+    if (ret < 0)
+        return ret;
+
     ret = av_tx_init(&sdr->fm_ifft_ctx, &sdr->fm_ifft, AV_TX_FLOAT_FFT, 1, 2*sdr->fm_block_size, NULL, 0);
     if (ret < 0)
         return ret;
 
+    ret = av_tx_init(&sdr->fm_fft_ctx, &sdr->fm_fft, AV_TX_FLOAT_FFT, 0, 2*sdr->fm_block_size   , NULL, 0);
+    if (ret < 0)
+        return ret;
+
+    ret = av_tx_init(&sdr->fm_ifft_p2_ctx, &sdr->fm_ifft_p2, AV_TX_FLOAT_FFT, 1, 2*sdr->fm_block_size_p2, NULL, 0);
+    if (ret < 0)
+        return ret;
+
     init_window(sdr, sdr->window, sdr->block_size);
 
     for (int i = 0; i < 2 * sdr->block_size; i++)
@@ -1998,10 +1996,16 @@ int ff_sdr_read_close(AVFormatContext *s)
 
     av_tx_uninit(&sdr->fft_ctx);
     av_tx_uninit(&sdr->am_ifft_ctx);
+    av_tx_uninit(&sdr->am_fft_ctx);
     av_tx_uninit(&sdr->fm_ifft_ctx);
-    sdr->fft = NULL;
-    sdr->am_ifft = NULL;
-    sdr->fm_ifft = NULL;
+    av_tx_uninit(&sdr->fm_fft_ctx);
+    av_tx_uninit(&sdr->fm_ifft_p2_ctx);
+    sdr->fft        = NULL;
+    sdr->am_ifft    = NULL;
+    sdr->am_fft     = NULL;
+    sdr->fm_ifft    = NULL;
+    sdr->fm_fft     = NULL;
+    sdr->fm_ifft_p2 = NULL;
 
     avio_close(sdr->dump_avio);
 
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 11/12] avradio/sdr: Pass AVStream instead of int to demodulate
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (8 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 10/12] avradio/sdr: Move tx contexts out of stream so its not duplicated Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 12/12] avradio/sdr: Process RDS of all stations not just the current one Michael Niedermayer
  2023-07-12 23:26 ` [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

thats less errror prone and simpler

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/sdr.h      | 2 +-
 libavradio/sdrdemux.c | 8 +++-----
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index cb4b6dc68b..3297584eae 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -241,7 +241,7 @@ typedef struct ModulationDescriptor {
     /**
      * Demodulate given station into packet
      */
-    int (*demodulate)(SDRContext *sdr, int stream_index, AVPacket *pkt);
+    int (*demodulate)(SDRContext *sdr, AVStream *st, AVPacket *pkt);
 } ModulationDescriptor;
 
 typedef struct BandDescriptor {
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index 5d58d81843..19dd0ef381 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -665,9 +665,8 @@ static av_always_inline void synchronous_am_demodulationN(AVComplexFloat *iblock
     }
 }
 
-static int demodulate_am(SDRContext *sdr, int stream_index, AVPacket *pkt)
+static int demodulate_am(SDRContext *sdr, AVStream *st, AVPacket *pkt)
 {
-    AVStream *st   = sdr->avfmt->streams[stream_index];
     SDRStream *sst = st->priv_data;
     double freq    = sst->station->frequency;
     int64_t bandwidth = sst->station->bandwidth;
@@ -934,9 +933,8 @@ static int probe_fm(SDRContext *sdr)
     return 0;
 }
 
-static int demodulate_fm(SDRContext *sdr, int stream_index, AVPacket *pkt)
+static int demodulate_fm(SDRContext *sdr, AVStream *st, AVPacket *pkt)
 {
-    AVStream *st   = sdr->avfmt->streams[stream_index];
     SDRStream *sst = st->priv_data;
     Station *station = sst->station;
 
@@ -1653,7 +1651,7 @@ process_next_block:
             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
                 if (sst->station) {
                     skip = 0;
-                    ret = ff_sdr_modulation_descs[ sst->station->modulation ].demodulate(sdr, stream_index, pkt);
+                    ret = ff_sdr_modulation_descs[ sst->station->modulation ].demodulate(sdr, st, pkt);
                     if (ret < 0) {
                         av_log(s, AV_LOG_ERROR, "demodulation failed ret = %d\n", ret);
                     }
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [FFmpeg-devel] [PATCH 12/12] avradio/sdr: Process RDS of all stations not just the current one
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (9 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 11/12] avradio/sdr: Pass AVStream instead of int to demodulate Michael Niedermayer
@ 2023-07-11 21:19 ` Michael Niedermayer
  2023-07-12 23:26 ` [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-11 21:19 UTC (permalink / raw)
  To: FFmpeg development discussions and patches

Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
---
 libavradio/sdr.h      |  3 +-
 libavradio/sdrdemux.c | 69 +++++++++++++++++++++++++++++--------------
 2 files changed, 49 insertions(+), 23 deletions(-)

diff --git a/libavradio/sdr.h b/libavradio/sdr.h
index 3297584eae..6c4647823e 100644
--- a/libavradio/sdr.h
+++ b/libavradio/sdr.h
@@ -91,6 +91,7 @@ typedef struct Station {
     int rds_ring_pos;
 
     struct SDRStream *stream;
+    int processing_index;
 } Station;
 
 typedef struct FIFOElement {
@@ -241,7 +242,7 @@ typedef struct ModulationDescriptor {
     /**
      * Demodulate given station into packet
      */
-    int (*demodulate)(SDRContext *sdr, AVStream *st, AVPacket *pkt);
+    int (*demodulate)(SDRContext *sdr, Station *station, AVStream *st, AVPacket *pkt);
 } ModulationDescriptor;
 
 typedef struct BandDescriptor {
diff --git a/libavradio/sdrdemux.c b/libavradio/sdrdemux.c
index 19dd0ef381..e93cf4dd98 100644
--- a/libavradio/sdrdemux.c
+++ b/libavradio/sdrdemux.c
@@ -665,11 +665,11 @@ static av_always_inline void synchronous_am_demodulationN(AVComplexFloat *iblock
     }
 }
 
-static int demodulate_am(SDRContext *sdr, AVStream *st, AVPacket *pkt)
+static int demodulate_am(SDRContext *sdr, Station *station, AVStream *st, AVPacket *pkt)
 {
     SDRStream *sst = st->priv_data;
-    double freq    = sst->station->frequency;
-    int64_t bandwidth = sst->station->bandwidth;
+    double freq    = station->frequency;
+    int64_t bandwidth = station->bandwidth;
     int index = lrint(F2INDEX(freq));
     int len   = (bandwidth * 2ll * sdr->block_size + sdr->sdr_sample_rate/2) / sdr->sdr_sample_rate;
     float *newbuf;
@@ -933,10 +933,9 @@ static int probe_fm(SDRContext *sdr)
     return 0;
 }
 
-static int demodulate_fm(SDRContext *sdr, AVStream *st, AVPacket *pkt)
+static int demodulate_fm(SDRContext *sdr, Station *station, AVStream *st, AVPacket *pkt)
 {
-    SDRStream *sst = st->priv_data;
-    Station *station = sst->station;
+    SDRStream *sst = st ? st->priv_data : NULL;
 
     double freq    = station->frequency;
     int64_t bandwidth = station->bandwidth;
@@ -954,6 +953,8 @@ static int demodulate_fm(SDRContext *sdr, AVStream *st, AVPacket *pkt)
     double carrier19_i_exact;
     int W= 5;
 
+    av_assert0(!st || (sst == station->stream && sst->station == station));
+
     //If only some of the bandwidth is available, just try with less
     int len2 = FFMIN(index, 2*sdr->block_size - index);
     if (len2 < len && len2 > len/2)
@@ -962,11 +963,7 @@ static int demodulate_fm(SDRContext *sdr, AVStream *st, AVPacket *pkt)
     if (index + len >= 2*sdr->block_size ||
         index - len < 0 ||
         2*len + 1   > 2*sdr->fm_block_size)
-    return AVERROR(ERANGE);
-
-    newbuf = av_malloc(sizeof(*sst->out_buf) * 2 * sdr->fm_block_size);
-    if (!newbuf)
-        return AVERROR(ENOMEM);
+        return AVERROR(ERANGE);
 
     i = 2*len+1;
     memcpy(sdr->fm_block, sdr->block + index, sizeof(*sdr->fm_block) * (len + 1));
@@ -1006,20 +1003,29 @@ static int demodulate_fm(SDRContext *sdr, AVStream *st, AVPacket *pkt)
         memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - len2_4_i, sdr->fm_block + 3*carrier19_i - len2_4_i, sizeof(AVComplexFloat)*len2_4_i);
         sdr->fm_ifft_p2(sdr->fm_ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
         synchronous_am_demodulationN(sdr->fm_iside, sdr->fm_icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 3);
-        ff_sdr_decode_rds(sdr, sst->station, sdr->fm_iside);
-
-        memcpy(sdr->fm_block + i, sdr->fm_block + 2*carrier19_i, sizeof(AVComplexFloat)*len17_i);
-        memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - len17_i, sdr->fm_block + 2*carrier19_i - len17_i, sizeof(AVComplexFloat)*len17_i);
-        apply_deemphasis(sdr, sdr->fm_block + i, sdr->fm_block_size_p2, sample_rate_p2, + 1);
-        apply_deemphasis(sdr, sdr->fm_block + i + 2*sdr->fm_block_size_p2, sdr->fm_block_size_p2, sample_rate_p2, - 1);
-        sdr->fm_ifft_p2(sdr->fm_ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
-        synchronous_am_demodulationN(sdr->fm_iside, sdr->fm_icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 2);
+        ff_sdr_decode_rds(sdr, station, sdr->fm_iside);
+
+        if (st) {
+            memcpy(sdr->fm_block + i, sdr->fm_block + 2*carrier19_i, sizeof(AVComplexFloat)*len17_i);
+            memcpy(sdr->fm_block + i + 2*sdr->fm_block_size_p2 - len17_i, sdr->fm_block + 2*carrier19_i - len17_i, sizeof(AVComplexFloat)*len17_i);
+            apply_deemphasis(sdr, sdr->fm_block + i, sdr->fm_block_size_p2, sample_rate_p2, + 1);
+            apply_deemphasis(sdr, sdr->fm_block + i + 2*sdr->fm_block_size_p2, sdr->fm_block_size_p2, sample_rate_p2, - 1);
+            sdr->fm_ifft_p2(sdr->fm_ifft_p2_ctx, sdr->fm_iside   , sdr->fm_block + i, sizeof(AVComplexFloat));
+            synchronous_am_demodulationN(sdr->fm_iside, sdr->fm_icarrier, sdr->fm_window_p2, 2*sdr->fm_block_size_p2, 2);
+        }
     }
+    if (!st)
+        return 0;
+
     memset(sdr->fm_block + len17_i, 0, (2*sdr->fm_block_size_p2 - len17_i) * sizeof(AVComplexFloat));
     apply_deemphasis(sdr, sdr->fm_block, 2*sdr->fm_block_size_p2, sample_rate_p2, + 1);
     sdr->fm_ifft_p2(sdr->fm_ifft_p2_ctx, sdr->fm_iblock  , sdr->fm_block, sizeof(AVComplexFloat));
     memset(sdr->fm_iblock + 2*sdr->fm_block_size_p2, 0 ,(2*sdr->fm_block_size -2*sdr->fm_block_size_p2) * sizeof(AVComplexFloat));
 
+    newbuf = av_malloc(sizeof(*sst->out_buf) * 2 * sdr->fm_block_size);
+    if (!newbuf)
+        return AVERROR(ENOMEM);
+
     scale      = 5 / (M_PI * 2*sdr->fm_block_size);
     for(i = 0; i<sdr->fm_block_size_p2; i++) {
         float m, q;
@@ -1651,7 +1657,7 @@ process_next_block:
             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
                 if (sst->station) {
                     skip = 0;
-                    ret = ff_sdr_modulation_descs[ sst->station->modulation ].demodulate(sdr, st, pkt);
+                    ret = ff_sdr_modulation_descs[ sst->station->modulation ].demodulate(sdr, sst->station, st, pkt);
                     if (ret < 0) {
                         av_log(s, AV_LOG_ERROR, "demodulation failed ret = %d\n", ret);
                     }
@@ -1659,6 +1665,8 @@ process_next_block:
             } else
                 av_assert0(0);
             sst->processing_index = 0;
+            if (sst->station)
+                sst->station->processing_index = 0;
             if (pkt && !skip) {
                 pkt->stream_index = stream_index;
                 pkt->dts = (sdr->pts & (-1<<FREQ_BITS));
@@ -1671,6 +1679,18 @@ process_next_block:
         }
     }
 
+    if (sdr->width > 1) {
+        Station *station_list[1000];
+        int nb_stations = ff_sdr_find_stations(sdr, sdr->block_center_freq, sdr->sdr_sample_rate*0.5, station_list, FF_ARRAY_ELEMS(station_list));
+        for (int i= 0; i<nb_stations; i++) {
+            Station *station = station_list[i];
+            if (station->stream || station->modulation != FM || !station->processing_index || !station->in_station_list)
+                continue;
+            ff_sdr_modulation_descs[ FM ].demodulate(sdr, station, NULL, NULL);
+            station->processing_index = 0;
+        }
+    }
+
     pthread_mutex_lock(&sdr->mutex);
     full_blocks = av_fifo_can_read(sdr->full_block_fifo) - 1;
     ret = av_fifo_peek(sdr->full_block_fifo, &fifo_element, 2, 0);
@@ -1820,6 +1840,8 @@ process_next_block:
     // windowed_block is unused now, we can fill it with the next blocks data
 
     if (sdr->block_center_freq) {
+        Station *station_list[1000];
+        int nb_stations;
         if (sdr->skip_probe-- <= 0) {
             //Probing takes a bit of time, lets not do it every time
             sdr->skip_probe = 5;
@@ -1835,6 +1857,7 @@ process_next_block:
             create_stations(sdr);
         }
 
+        nb_stations = ff_sdr_find_stations(sdr, sdr->block_center_freq, sdr->sdr_sample_rate*0.5, station_list, FF_ARRAY_ELEMS(station_list));
         if (sdr->mode == SingleStationMode) {
             AVStream *st = s->streams[sdr->single_ch_audio_st_index];
             SDRStream *sst = st->priv_data;
@@ -1845,8 +1868,6 @@ process_next_block:
                     return ret;
             }
         } else {
-            Station *station_list[1000];
-            int nb_stations = ff_sdr_find_stations(sdr, sdr->block_center_freq, sdr->sdr_sample_rate*0.5, station_list, FF_ARRAY_ELEMS(station_list));
             av_assert0(sdr->mode == AllStationMode);
             for(int i = 0; i<nb_stations; i++) {
                 Station *station = station_list[i];
@@ -1881,6 +1902,10 @@ process_next_block:
             SDRStream *sst = st->priv_data;
             sst->processing_index += sdr->block_size;
         }
+        for(int i = 0; i<nb_stations; i++) {
+            Station *station = station_list[i];
+            station->processing_index += sdr->block_size;
+        }
     }
 
     sdr->last_pts = sdr->pts;
-- 
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-request@ffmpeg.org with subject "unsubscribe".

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory
  2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
                   ` (10 preceding siblings ...)
  2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 12/12] avradio/sdr: Process RDS of all stations not just the current one Michael Niedermayer
@ 2023-07-12 23:26 ` Michael Niedermayer
  11 siblings, 0 replies; 13+ messages in thread
From: Michael Niedermayer @ 2023-07-12 23:26 UTC (permalink / raw)
  To: FFmpeg development discussions and patches


[-- Attachment #1.1: Type: text/plain, Size: 424 bytes --]

On Tue, Jul 11, 2023 at 11:18:59PM +0200, Michael Niedermayer wrote:
> Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
> ---
>  libavradio/sdrdemux.c | 4 ++--
>  1 file changed, 2 insertions(+), 2 deletions(-)

Will apply patchset

[...]
-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

Opposition brings concord. Out of discord comes the fairest harmony.
-- Heraclitus

[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

[-- Attachment #2: Type: text/plain, Size: 251 bytes --]

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

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

^ permalink raw reply	[flat|nested] 13+ messages in thread

end of thread, other threads:[~2023-07-12 23:26 UTC | newest]

Thread overview: 13+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-07-11 21:18 [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 02/12] avradio/rds: Implement burst error decoder Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 03/12] avradio/rds: Keep track of program_id Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 04/12] avradio/sdr: Move rds_ring to Station Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 05/12] avradio/rds: move phase 2 window to main context Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 06/12] avradio/sdr: Warnings cleanup Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 07/12] avradio/rds: warnings cleanup Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 08/12] avradio/sdr: Move IFFT and block size to main context Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 09/12] avradio/sdr: Move per stream arraies " Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 10/12] avradio/sdr: Move tx contexts out of stream so its not duplicated Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 11/12] avradio/sdr: Pass AVStream instead of int to demodulate Michael Niedermayer
2023-07-11 21:19 ` [FFmpeg-devel] [PATCH 12/12] avradio/sdr: Process RDS of all stations not just the current one Michael Niedermayer
2023-07-12 23:26 ` [FFmpeg-devel] [PATCH 01/12] avradio/sdrdemux: Fix use of uninitialized memory Michael Niedermayer

Git Inbox Mirror of the ffmpeg-devel mailing list - see https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://master.gitmailbox.com/ffmpegdev/0 ffmpegdev/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 ffmpegdev ffmpegdev/ https://master.gitmailbox.com/ffmpegdev \
		ffmpegdev@gitmailbox.com
	public-inbox-index ffmpegdev

Example config snippet for mirrors.


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git