Changeset 2664

Show
Ignore:
Timestamp:
08/03/99 20:04:44 (15 years ago)
Author:
ucacoxh
Message:

- Added noise subsitution as a repair technique. It does not sound
too good and I hope nobody uses it - it's for reference points with other schemes.

- Moved avg_audio_energy into audio_util.[ch] from parameters.[ch]
since audio_util code is rat independent and parameters is not.

- Miscellaneous formatting.

Location:
rat/trunk
Files:
9 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/audio_util.c

    r2587 r2664  
    241241#endif /* WIN32 */ 
    242242 
    243  
    244  
    245  
     243#define ENERGY_CALC_STEP                 1 
     244u_int16  
     245avg_audio_energy(sample *buf, u_int32 samples, u_int32 channels) 
     246{ 
     247        register u_int32 e1, e2; 
     248        register sample *buf_end = buf + samples; 
     249 
     250        assert (channels > 0); 
     251        e1 = e2 = 0; 
     252        switch (channels) { 
     253        case 1: 
     254                while(buf < buf_end) { 
     255                        e1  += abs(*buf); 
     256                        buf += ENERGY_CALC_STEP; 
     257                } 
     258                break; 
     259        case 2: 
     260                /* SIMD would improve this */ 
     261                while(buf < buf_end) { 
     262                        e1 += abs(*buf++); 
     263                        e2 += abs(*buf); 
     264                        buf += ENERGY_CALC_STEP*channels - 1; 
     265                } 
     266                e1 = max(e1, e2); 
     267                samples /= channels; /* No. of samples to no. of sampling intervals */ 
     268        } 
     269 
     270        /* Return mean sampled energy: 
     271         * no. of sampling points = samples/ENERGY_CALC_STEP; 
     272         */ 
     273        return (u_int16)(e1*ENERGY_CALC_STEP/samples); 
     274} 
     275 
     276 
  • rat/trunk/audio_util.h

    r2314 r2664  
    3535void    bias_remove (struct s_bias_ctl *bc, sample *buf, int len); 
    3636 
     37/* Energy calculation */ 
     38u_int16 avg_audio_energy (sample *buf, u_int32 dur, u_int32 channels); 
     39 
    3740#endif /* __AUDIO_UTIL_H__ */ 
  • rat/trunk/parameters.c

    r2587 r2664  
    2222#include "parameters.h" 
    2323 
    24 #define STEP             1 
     24 
    2525#define SD_MAX_CHANNELS  5 
    26  
    27 u_int16  
    28 avg_audio_energy(sample *buf, u_int32 samples, u_int32 channels) 
    29 { 
    30         register u_int32 e1, e2; 
    31         register sample *buf_end = buf + samples; 
    32  
    33         assert (channels > 0); 
    34         e1 = e2 = 0; 
    35         switch (channels) { 
    36         case 1: 
    37                 while(buf < buf_end) { 
    38                         e1  += abs(*buf); 
    39                         buf += STEP; 
    40                 } 
    41                 break; 
    42         case 2: 
    43                 /* SIMD would improve this */ 
    44                 while(buf < buf_end) { 
    45                         e1 += abs(*buf++); 
    46                         e2 += abs(*buf); 
    47                         buf += STEP*channels - 1; 
    48                 } 
    49                 e1 = max(e1, e2); 
    50                 samples /= channels; /* No. of samples to no. of sampling intervals */ 
    51         } 
    52  
    53         /* Return mean sampled energy: 
    54          * no. of sampling points = samples/step; 
    55          */ 
    56         return (u_int16)(e1*STEP/samples); 
    57 } 
    58  
    5926#define Q3_MAX 4096 
    6027#define L16TOQ3(x) ((x)>>3) 
  • rat/trunk/parameters.h

    r2341 r2664  
    1919struct s_agc; 
    2020struct session_tag; 
    21  
    22 u_int16 avg_audio_energy (sample *buf, u_int32 dur, u_int32 channels); 
    2321 
    2422#define VU_INPUT  0 
  • rat/trunk/repair.c

    r2655 r2664  
    1717#include "util.h" 
    1818#include "debug.h" 
     19 
     20#include "audio_util.h" 
     21 
     22#include <stdlib.h> 
    1923 
    2024/* This is prototype for repair functions - */ 
     
    8690 
    8791static int 
    88 repetition(sample **audio_buf, const audio_format **audio_fmt, int nbufs, 
    89            int missing, int consec_lost) 
     92repetition(sample             **audio_buf,  
     93           const audio_format **audio_fmt,  
     94           int                  nbufs, 
     95           int                  missing, 
     96           int                  consec_lost) 
    9097{ 
    9198        if ((audio_buf[missing - 1] == NULL) ||  
     
    99106               audio_fmt[missing]->bytes_per_block); 
    100107         
     108        if (consec_lost > 0) { 
     109                fade_buffer(audio_buf[missing], audio_fmt[missing], consec_lost); 
     110        } 
     111 
     112        return TRUE; 
     113} 
     114 
     115/* Noise subsitution is about the worst way to repair loss. 
     116 * It's here as a reference point, let's hope nobody uses it! 
     117 */ 
     118 
     119static int 
     120noise_substitution(sample             **audio_buf,  
     121                   const audio_format **audio_fmt,  
     122                   int                  nbufs, 
     123                   int                  missing, 
     124                   int                  consec_lost) 
     125{ 
     126        double e[2]; 
     127        int    i, j, nsamples, step; 
     128 
     129        if ((audio_buf[missing - 1] == NULL) ||  
     130            (nbufs < 2)) { 
     131                debug_msg("no prior audio\n"); 
     132                return FALSE; 
     133        } 
     134 
     135        step     = audio_fmt[missing - 1]->channels; 
     136        nsamples = audio_fmt[missing - 1]->bytes_per_block / sizeof(sample); 
     137 
     138        /* Calculate energy of each channel for previous frame */ 
     139        for(i = 0; i < step; i++) { 
     140                e[i] = 0.0; 
     141                for(j = i; j < nsamples; j += step) { 
     142                        e[i] += (double)(audio_buf[missing - 1][j] * audio_buf[missing - 1][j]); 
     143                } 
     144                e[i] *= (double)step / (double)nsamples; 
     145                e[i] = sqrt(e[i]); 
     146        }         
     147 
     148        nsamples = audio_fmt[missing]->bytes_per_block / sizeof(sample); 
     149 
     150        /* Fill in the noise */ 
     151        for (i = 0; i < step; i++) { 
     152                for(j = i; j < nsamples; j += step) { 
     153                        audio_buf[missing][j] = (sample)(e[i] * 2.0 * (drand48() - 0.5)); 
     154                } 
     155        } 
     156 
    101157        if (consec_lost > 0) { 
    102158                fade_buffer(audio_buf[missing], audio_fmt[missing], consec_lost); 
     
    214270        {"Pattern-Match", single_side_pattern_match}, 
    215271        {"Repeat",        repetition}, 
    216         {"None",          NULL},  /* Special place for scheme none - move at own peril */ 
     272        {"Noise",         noise_substitution}, 
     273        {"None",          NULL}  /* Special place for scheme none - move at own peril */ 
    217274}; 
    218275 
  • rat/trunk/repair.h

    r2655 r2664  
    3232int  repair_get_codec_specific_allowed(void); 
    3333 
    34 /* Zero is no repair mechanism */ 
    35 #define REPAIR_TYPE_NONE 2 
    36  
    3734#endif /* _REPAIR_H_ */ 
    3835 
  • rat/trunk/source.c

    r2642 r2664  
    2323#include "codec_state.h" 
    2424#include "converter.h" 
    25 #include "parameters.h" 
     25#include "audio_util.h" 
    2626#include "render_3D.h" 
    2727#include "repair.h" 
     
    403403        cid = channel_coder_get_by_payload(payload); 
    404404        clayers = channel_coder_get_layers(cid); 
    405         if(clayers>1) { 
     405        if (clayers > 1) { 
    406406                struct s_pb_iterator *pi; 
    407407                u_int8 i; 
     
    870870        int         i, success, hold_repair = 0; 
    871871 
     872        static int repair_none = -1; 
     873        if (repair_none == -1) { 
     874                repair_none = repair_get_by_name("None"); 
     875        } 
     876 
    872877        /* Note: hold_repair is used to stop repair occuring. 
    873878         * Occasionally, there is a race condition when the playout 
     
    905910                if (ts_valid(src->last_played) &&  
    906911                    ts_gt(playout, ts_add(src->last_played, step)) && 
    907                     repair_type != REPAIR_TYPE_NONE && 
     912                    repair_type != repair_none      && 
    908913                    ts_gt(src->last_played, cutoff) && 
    909914                    hold_repair == 0) { 
  • rat/trunk/tests/Makefile

    r2652 r2664  
    1717             ../convert_extra.o ../convert_sinc.o 
    1818 
    19  
    20 REPAIR_OBJS  = ../repair.o 
     19REPAIR_OBJS  = ../repair.o ../audio_util.o 
    2120 
    2221SNDFILE_OBJS = ../sndfile.o ../sndfile_raw.o ../sndfile_au.o ../sndfile_wav.o 
  • rat/trunk/tests/test_repair.c

    r2661 r2664  
    110110        int                         consec_lost = 0; 
    111111        const codec_format_t       *cf; 
     112        int                         repair_none; 
     113 
     114        repair_none = repair_get_by_name("None"); 
     115        if (repair_none != 3) { 
     116                exit(-1); 
     117        } 
    112118 
    113119        codec_encoder_create(cid, &encoder); 
     
    135141 
    136142                        /* Loss happens - invoke repair */ 
    137                         if (repair_type != REPAIR_TYPE_NONE) { 
     143                        if (repair_type != repair_none) { 
    138144                                cu->id = cid; 
    139145                                repair(repair_type,