Changeset 3019

Show
Ignore:
Timestamp:
12/20/99 16:11:25 (15 years ago)
Author:
ucaccsp
Message:

Fix (I hope) assertion failure in source.c. It seems that the native
coding in the media unit is not always the last coding in the array.
Also add lots of debugging code, whilst trying to figure out what was
going on.

Location:
rat/trunk
Files:
4 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/MODS

    r3018 r3019  
    10061006        - Update RPM spec file 
    10071007        - Update installation instructions 
     1008        - Fix "-t" option, to set the TTL. The v4.1.2 release would always 
     1009          send with TTL=15, making it useless for wide area. 
     1010        - Fix assertion failures in source.c 
    10081011 
    10091012 
  • rat/trunk/main_control.c

    r3008 r3019  
    214214                tx_port = rx_port; 
    215215        } 
    216  
    217         addr    = mbus_encode_str(addr); 
    218         mbus_qmsgf(m, e_addr, TRUE, "rtp.addr", "%s %d %d %d", addr, rx_port, tx_port, ttl); 
    219         xfree(addr); 
    220216 
    221217        /* Parse command line parameters... */ 
     
    313309        } 
    314310 
     311        addr    = mbus_encode_str(addr); 
     312        mbus_qmsgf(m, e_addr, TRUE, "rtp.addr", "%s %d %d %d", addr, rx_port, tx_port, ttl); 
     313        xfree(addr); 
     314 
    315315        /* Synchronize with the sub-processes... */ 
    316316        do { 
  • rat/trunk/source.c

    r3006 r3019  
    12551255} 
    12561256 
    1257 int 
    1258 source_process(session_t *sp, 
     1257void 
     1258source_process(session_t         *sp, 
    12591259               source            *src,  
    12601260               struct s_mix_info *ms,  
     
    12681268        codec_state *cs; 
    12691269        uint32_t     md_len; 
    1270         ts_t        playout, step; 
    1271         int         i, success, hold_repair = 0; 
     1270        ts_t         playout, step; 
     1271        int          i, success, hold_repair = 0; 
    12721272        uint16_t     sample_rate, channels; 
    12731273 
     
    12771277         * buffer shift occurs in middle of a loss. 
    12781278         */ 
    1279          
     1279 
    12801280        source_process_packets(sp, src, start_ts); 
    12811281 
    12821282        /* Split channel coder units up into media units */ 
    12831283        if (pb_node_count(src->channel)) { 
    1284                 channel_decoder_decode(src->channel_state, 
    1285                                        src->channel, 
    1286                                        src->media, 
    1287                                        end_ts); 
    1288         } 
    1289  
    1290         while (ts_gt(end_ts, src->next_played) &&  
    1291                pb_iterator_advance(src->media_pos)) { 
    1292                 pb_iterator_get_at(src->media_pos,  
    1293                                    (u_char**)&md,  
    1294                                    &md_len,  
    1295                                    &playout); 
    1296                 assert(md != NULL); 
     1284                channel_decoder_decode(src->channel_state, src->channel, src->media, end_ts); 
     1285        } 
     1286 
     1287        while (ts_gt(end_ts, src->next_played) && pb_iterator_advance(src->media_pos)) { 
     1288                pb_iterator_get_at(src->media_pos, (u_char**)&md, &md_len, &playout); 
     1289 
     1290                /* At this point, md is the media data at the current playout point */ 
     1291                assert(md     != NULL); 
    12971292                assert(md_len == sizeof(media_data)); 
    1298                  
    1299                 /* Conditions for repair:                                    */ 
    1300                 /* (a) playout point of unit is further away than expected.  */ 
    1301                 /* (b) playout does not correspond to new talkspurt (don't   */ 
    1302                 /* fill between end of last talkspurt and start of next).    */ 
    1303                 /* NB Use post_talkstart_units as talkspurts maybe longer    */ 
    1304                 /* than timestamp wrap period and want to repair even if     */ 
    1305                 /* timestamps wrap.                                          */ 
    1306                 /* (c) not start of a talkspurt.                             */ 
    1307                 /* (d) don't have a hold on.                                 */ 
    1308  
     1293 
     1294                /* Conditions for repair:                                     */ 
     1295                /* (a) playout point of unit is further away than expected.   */ 
     1296                /* (b) playout does not correspond to new talkspurt (don't    */ 
     1297                /*     fill between end of last talkspurt and start of next). */ 
     1298                /*     NB Use post_talkstart_units as talkspurts maybe longer */ 
     1299                /*     than timestamp wrap period and want to repair even if  */ 
     1300                /*     timestamps wrap.                                       */ 
     1301                /* (c) not start of a talkspurt.                              */ 
     1302                /* (d) don't have a hold on.                                  */ 
    13091303                if (ts_gt(playout, src->next_played) && 
    13101304                    ((ts_gt(src->next_played, src->talkstart) && ts_gt(playout, src->talkstart)) || src->post_talkstart_units > 100) && 
    1311                     hold_repair == 0) { 
     1305                    (hold_repair == 0)) { 
    13121306                        /* If repair was successful media_pos is moved,      */ 
    13131307                        /* so get data at media_pos again.                   */ 
     
    13181312                                          src->next_played.ticks,  
    13191313                                          src->talkstart.ticks); 
    1320                                 success = pb_iterator_get_at(src->media_pos,  
    1321                                                              (u_char**)&md,  
    1322                                                              &md_len,  
    1323                                                              &playout); 
     1314                                success = pb_iterator_get_at(src->media_pos, (u_char**)&md, &md_len, &playout); 
    13241315                                assert(success); 
    13251316                                assert(ts_eq(playout, src->next_played)); 
     
    13431334                } 
    13441335 
     1336                assert(md != NULL); 
     1337                assert(md_len == sizeof(media_data)); 
     1338                assert(md->nrep < MAX_MEDIA_UNITS); 
    13451339                for(i = 0; i < md->nrep; i++) { 
    13461340                        if (codec_is_native_coding(md->rep[i]->id)) { 
     
    13501344 
    13511345                if (i == md->nrep) { 
    1352                         /* We need to decode this unit, may not have to 
    1353                          * when repair has been used. 
    1354                          */ 
     1346                        /* If we've got to here, we have no native coding for this unit */ 
     1347                        /* We need to decode this unit, may not have to when repair has */ 
     1348                        /* been used.                                                   */ 
    13551349#ifdef DEBUG 
    13561350                        for(i = 0; i < md->nrep; i++) { 
    1357                                 /* if there is a native coding this 
    1358                                  * unit has already been decoded and 
    1359                                  * this would be bug */ 
     1351                                /* If there is a native coding this unit has already */ 
     1352                                /* been decoded and this would be a bug */ 
    13601353                                assert(md->rep[i] != NULL); 
    13611354                                assert(codec_id_is_valid(md->rep[i]->id)); 
    13621355                                assert(codec_is_native_coding(md->rep[i]->id) == FALSE); 
    13631356                        } 
    1364 #endif /* DEBUG */ 
    1365                         cu = (coded_unit*)block_alloc(sizeof(coded_unit)); 
     1357#endif 
     1358                        cu = (coded_unit*) block_alloc(sizeof(coded_unit)); 
    13661359                        /* Decode frame */ 
    13671360                        assert(cu != NULL); 
     
    13721365                        md->rep[md->nrep] = cu; 
    13731366                        md->nrep++; 
    1374                 } 
     1367                } 
     1368                assert(md->nrep < MAX_MEDIA_UNITS); 
     1369                for(i = 0; i < md->nrep; i++) { 
     1370                        if (codec_is_native_coding(md->rep[i]->id)) { 
     1371                                break; 
     1372                        } 
     1373                } 
     1374                assert(i != md->nrep); /* Else we don't have a native coding yet, which would make no sense... */ 
     1375                assert(codec_is_native_coding(md->rep[i]->id)); 
    13751376 
    13761377                if (render_3d && src->pdbe->render_3D_data) { 
    13771378                        /* 3d rendering necessary */ 
    13781379                        coded_unit *decoded, *render; 
    1379                         decoded = md->rep[md->nrep - 1]; 
     1380                        decoded = md->rep[i]; 
    13801381                        assert(codec_is_native_coding(decoded->id)); 
    13811382                         
     
    13881389                        md->nrep++; 
    13891390                } 
     1391                assert(md->nrep < MAX_MEDIA_UNITS); 
    13901392 
    13911393                if (src->converter) { 
    13921394                        /* convert frame */ 
    13931395                        coded_unit *decoded, *render; 
    1394                         decoded = md->rep[md->nrep - 1]; 
     1396                        decoded = md->rep[i]; 
    13951397                        assert(codec_is_native_coding(decoded->id)); 
    13961398 
    1397                         render = (coded_unit*)block_alloc(sizeof(coded_unit)); 
     1399                        render = (coded_unit*) block_alloc(sizeof(coded_unit)); 
    13981400                        memset(render, 0, sizeof(coded_unit)); 
    1399                         converter_process(src->converter, 
    1400                                           decoded, 
    1401                                           render); 
     1401                        converter_process(src->converter, decoded, render); 
    14021402                        assert(md->rep[md->nrep] == NULL); 
    14031403                        md->rep[md->nrep] = render; 
    14041404                        md->nrep++; 
    14051405                } 
    1406  
    1407                 if (src->skew != SOURCE_SKEW_NONE &&  
    1408                     source_skew_adapt(src, md, playout) != SOURCE_SKEW_NONE) { 
     1406                assert(md->nrep < MAX_MEDIA_UNITS); 
     1407 
     1408                if (src->skew != SOURCE_SKEW_NONE && source_skew_adapt(src, md, playout) != SOURCE_SKEW_NONE) { 
    14091409                        /* We have skew and we have adjusted playout buffer  */ 
    14101410                        /* timestamps, so re-get unit to get correct         */ 
    14111411                        /* timestamp info.                                   */ 
    1412                         pb_iterator_get_at(src->media_pos,  
    1413                                            (u_char**)&md,  
    1414                                            &md_len,  
    1415                                            &playout); 
     1412                        pb_iterator_get_at(src->media_pos, (u_char**)&md, &md_len, &playout); 
    14161413                        assert(md != NULL); 
    14171414                        assert(md_len == sizeof(media_data)); 
    14181415                } 
    14191416 
    1420                 if (src->pdbe->gain != 1.0 && codec_is_native_coding(md->rep[md->nrep - 1]->id)) { 
    1421                         audio_scale_buffer((sample*)md->rep[md->nrep - 1]->data, 
    1422                                            md->rep[md->nrep - 1]->data_len / sizeof(sample), 
     1417                if (src->pdbe->gain != 1.0 && codec_is_native_coding(md->rep[i]->id)) { 
     1418                        audio_scale_buffer((sample*)md->rep[i]->data, 
     1419                                           md->rep[i]->data_len / sizeof(sample), 
    14231420                                           src->pdbe->gain); 
    14241421                } 
    14251422 
    1426                 assert(codec_is_native_coding(md->rep[md->nrep - 1]->id)); 
    1427                 codec_get_native_info(md->rep[md->nrep - 1]->id, &sample_rate, &channels); 
    1428                 step = ts_map32(sample_rate, md->rep[md->nrep - 1]->data_len / (channels * sizeof(sample))); 
     1423                assert(codec_is_native_coding(md->rep[i]->id)); 
     1424 
     1425                codec_get_native_info(md->rep[i]->id, &sample_rate, &channels); 
     1426                step = ts_map32(sample_rate, md->rep[i]->data_len / (channels * sizeof(sample))); 
    14291427                src->next_played = ts_add(playout, step); 
    1430                 src->samples_played += md->rep[md->nrep - 1]->data_len / (channels * sizeof(sample)); 
    1431  
    1432                 if (mix_process(ms, src->pdbe, md->rep[md->nrep - 1], playout) == FALSE) { 
     1428                src->samples_played += md->rep[i]->data_len / (channels * sizeof(sample)); 
     1429 
     1430                if (mix_process(ms, src->pdbe, md->rep[i], playout) == FALSE) { 
    14331431                        /* Sources sampling rate changed mid-flow? dump data */ 
    14341432                        /* make source look irrelevant, it should get        */ 
     
    14421440                } 
    14431441        } 
    1444  
    14451442        source_update_bps(src, start_ts); 
    1446  
    1447         UNUSED(i); /* Except for debugging */ 
    1448          
    1449         return TRUE; 
     1443        return; 
    14501444} 
    14511445 
  • rat/trunk/source.h

    r2958 r3019  
    5757int              source_check_buffering    (struct s_source   *src); 
    5858 
    59 int              source_process            (struct s_session  *sp, 
     59void             source_process            (struct s_session  *sp, 
    6060                                            struct s_source   *src, 
    6161                                            struct s_mix_info *ms,