Ignore:
Timestamp:
Feb 10, 2009 4:43:16 AM (12 years ago)
Author:
nanang
Message:
  • Fixed conf switch on reinit-ing conf port TX buf.
  • Updated conf switch to enable RX/TX level adjustment.
  • Added VAD & PLC setting in passthrough codecs.
  • Changed G711 fourcc codes.
  • Updated bits-to-bytes calculations all over the places.
  • Minor update: changed log level for dumping jbuf states in stream.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/branches/projects/aps-direct/pjmedia/src/pjmedia/conf_switch.c

    r2444 r2445  
    5252#define INVALID_SLOT        ((SLOT_TYPE)-1) 
    5353#define BUFFER_SIZE         PJMEDIA_MAX_MTU 
     54#define MAX_LEVEL           (32767) 
     55#define MIN_LEVEL           (-32768) 
    5456 
    5557/* 
     
    153155    conf_port->tx_setting = PJMEDIA_PORT_ENABLE; 
    154156 
     157    /* Default level adjustment is 128 (which means no adjustment) */ 
     158    conf_port->tx_adj_level = NORMAL_LEVEL; 
     159    conf_port->rx_adj_level = NORMAL_LEVEL; 
     160 
    155161    /* Create transmit flag array */ 
    156162    conf_port->listener_slots = (SLOT_TYPE*) 
     
    166172    f = (pjmedia_frame*)conf_port->tx_buf; 
    167173    f->buf = conf_port->tx_buf + sizeof(pjmedia_frame); 
    168     f->size = 0; 
    169174 
    170175    /* Done */ 
     
    673678 
    674679    if (i != src_port->listener_cnt) { 
     680        pjmedia_frame_ext *f; 
     681 
    675682        pj_assert(src_port->listener_cnt > 0 &&  
    676683                  src_port->listener_cnt < conf->max_ports); 
     
    683690        --dst_port->transmitter_cnt; 
    684691         
    685         /* Clean up sink TX buffer. */ 
    686         pj_bzero(dst_port->tx_buf, sizeof(pjmedia_frame_ext)); 
     692        /* Cleanup listener TX buffer. */ 
     693        f = (pjmedia_frame_ext*)dst_port->tx_buf; 
     694        f->base.type = PJMEDIA_FRAME_TYPE_NONE; 
     695        f->base.size = 0; 
     696        f->samples_cnt = 0; 
     697        f->subframe_cnt = 0; 
    687698 
    688699        PJ_LOG(4,(THIS_FILE, 
     
    777788        unsigned dst_slot; 
    778789        struct conf_port *dst_port; 
     790        pjmedia_frame_ext *f; 
    779791 
    780792        dst_slot = conf_port->listener_slots[conf_port->listener_cnt-1]; 
     
    785797        --conf->connect_cnt; 
    786798 
    787         /* Clean up TX buffer. */ 
    788         pj_bzero(dst_port->tx_buf, sizeof(pjmedia_frame_ext)); 
     799        /* Cleanup & reinit listener TX buffer. */ 
     800        f = (pjmedia_frame_ext*)dst_port->tx_buf; 
     801        f->base.type = PJMEDIA_FRAME_TYPE_NONE; 
     802        f->base.size = 0; 
     803        f->samples_cnt = 0; 
     804        f->subframe_cnt = 0; 
    789805    } 
    790806 
     
    857873    info->bits_per_sample = conf_port->info->bits_per_sample; 
    858874    info->format = conf_port->port->info.format; 
     875    info->tx_adj_level = conf_port->tx_adj_level - NORMAL_LEVEL; 
     876    info->rx_adj_level = conf_port->rx_adj_level - NORMAL_LEVEL; 
    859877 
    860878    return PJ_SUCCESS; 
     
    935953    conf_port = conf->ports[slot]; 
    936954 
     955    /* Level adjustment is applicable only for ports that work with raw PCM. */ 
     956    PJ_ASSERT_RETURN(conf_port->info->format.u32 == 0 ||  
     957                     conf_port->info->format.u32 == PJMEDIA_FOURCC_L16, 
     958                     PJ_EIGNORED); 
     959 
    937960    /* Set normalized adjustment level. */ 
    938961    conf_port->rx_adj_level = adj_level + NORMAL_LEVEL; 
     
    964987 
    965988    conf_port = conf->ports[slot]; 
     989 
     990    /* Level adjustment is applicable only for ports that work with raw PCM. */ 
     991    PJ_ASSERT_RETURN(conf_port->info->format.u32 == 0 ||  
     992                     conf_port->info->format.u32 == PJMEDIA_FOURCC_L16, 
     993                     PJ_EIGNORED); 
     994 
     995    /* Set normalized adjustment level. */ 
     996    conf_port->tx_adj_level = adj_level + NORMAL_LEVEL; 
    966997 
    967998    return PJ_SUCCESS; 
     
    10321063            if (nsamples_to_copy > nsamples_req) 
    10331064                nsamples_to_copy = nsamples_req; 
     1065 
     1066            /* Adjust TX level. */ 
     1067            if (cport_dst->tx_adj_level != NORMAL_LEVEL) { 
     1068                pj_int16_t *p, *p_end; 
     1069 
     1070                p = f_start; 
     1071                p_end = p + nsamples_to_copy; 
     1072                while (p < p_end) { 
     1073                    pj_int32_t itemp = *p; 
     1074 
     1075                    /* Adjust the level */ 
     1076                    itemp = (itemp * cport_dst->tx_adj_level) >> 7; 
     1077 
     1078                    /* Clip the signal if it's too loud */ 
     1079                    if (itemp > MAX_LEVEL) itemp = MAX_LEVEL; 
     1080                    else if (itemp < MIN_LEVEL) itemp = MIN_LEVEL; 
     1081 
     1082                    /* Put back in the buffer. */ 
     1083                    *p = (pj_int16_t)itemp; 
     1084                    ++p; 
     1085                } 
     1086            } 
    10341087 
    10351088            pjmedia_copy_samples((pj_int16_t*)frm_dst->buf + (frm_dst->size>>1), 
     
    11321185    unsigned ci, i; 
    11331186     
    1134     PJ_TODO(ADJUST_RX_TX_LEVEL_FOR_PCM_FRAMES); 
    1135  
    11361187    /* Must lock mutex */ 
    11371188    pj_mutex_lock(conf->mutex); 
     
    11741225            pj_status_t status; 
    11751226            unsigned j; 
    1176             pj_int32_t level; 
     1227            pj_int32_t level = 0; 
    11771228 
    11781229            pj_add_timestamp32(&cport->ts_rx, cport->info->samples_per_frame); 
     
    11861237                continue; 
    11871238 
    1188             /* Calculate RX level. */ 
     1239            /* Calculate & adjust RX level. */ 
    11891240            if (f->type == PJMEDIA_FRAME_TYPE_AUDIO) { 
    1190                 level = pjmedia_calc_avg_signal((const pj_int16_t*)f->buf, 
    1191                                                 f->size >>1 ); 
     1241                if (cport->rx_adj_level != NORMAL_LEVEL) { 
     1242                    pj_int16_t *p = (pj_int16_t*)f->buf; 
     1243                    pj_int16_t *end; 
     1244 
     1245                    end = p + (f->size >> 1); 
     1246                    while (p < end) { 
     1247                        pj_int32_t itemp = *p; 
     1248 
     1249                        /* Adjust the level */ 
     1250                        itemp = (itemp * cport->rx_adj_level) >> 7; 
     1251 
     1252                        /* Clip the signal if it's too loud */ 
     1253                        if (itemp > MAX_LEVEL) itemp = MAX_LEVEL; 
     1254                        else if (itemp < MIN_LEVEL) itemp = MIN_LEVEL; 
     1255 
     1256                        level += PJ_ABS(itemp); 
     1257 
     1258                        /* Put back in the buffer. */ 
     1259                        *p = (pj_int16_t)itemp; 
     1260                        ++p; 
     1261                    } 
     1262                    level /= (f->size >> 1); 
     1263                } else { 
     1264                    level = pjmedia_calc_avg_signal((const pj_int16_t*)f->buf, 
     1265                                                    f->size >> 1); 
     1266                } 
    11921267            } else if (f->type == PJMEDIA_FRAME_TYPE_EXTENDED) { 
    11931268                /* For extended frame, TX level is unknown, so we just set  
     
    11951270                 */ 
    11961271                level = NORMAL_LEVEL; 
    1197             } else { /* PJMEDIA_FRAME_TYPE_NONE */ 
    1198                 level = 0; 
    11991272            } 
     1273 
    12001274            cport->rx_level = pjmedia_linear2ulaw(level) ^ 0xff; 
    12011275 
     
    12211295                } 
    12221296 
    1223                 /* Set listener TX level equal to transmitter RX level. */ 
    1224                 listener->tx_level = cport->rx_level; 
     1297                /* Set listener TX level based on transmitter RX level &  
     1298                 * listener TX level. 
     1299                 */ 
     1300                listener->tx_level = (cport->rx_level * listener->tx_adj_level) 
     1301                                     >> 8; 
    12251302            } 
    12261303        } 
     
    12421319        if (cport->tx_setting==PJMEDIA_PORT_MUTE || cport->transmitter_cnt==0) 
    12431320        { 
     1321            pjmedia_frame_ext *f; 
     1322             
    12441323            /* Clear left-over samples in tx_buffer, if any, so that it won't 
    12451324             * be transmitted next time we have audio signal. 
    12461325             */ 
    1247             pj_bzero(cport->tx_buf, sizeof(pjmedia_frame_ext)); 
     1326            f = (pjmedia_frame_ext*)cport->tx_buf; 
     1327            f->base.type = PJMEDIA_FRAME_TYPE_NONE; 
     1328            f->base.size = 0; 
     1329            f->samples_cnt = 0; 
     1330            f->subframe_cnt = 0; 
    12481331             
    12491332            cport->tx_level = 0; 
     
    12801363             
    12811364            if (f_src_->samples_cnt < this_cport->info->samples_per_frame) { 
    1282                 pj_bzero(this_cport->tx_buf, sizeof(pjmedia_frame_ext)); 
    1283                 frame->type = PJMEDIA_FRAME_TYPE_NONE; 
     1365                f_dst->base.type = PJMEDIA_FRAME_TYPE_NONE; 
     1366                f_dst->samples_cnt = 0; 
     1367                f_dst->subframe_cnt = 0; 
    12841368                break; 
    12851369            } 
     
    13031387        } else if (f_src->type == PJMEDIA_FRAME_TYPE_AUDIO) { 
    13041388            if ((f_src->size>>1) < this_cport->info->samples_per_frame) { 
    1305                 pj_bzero(this_cport->tx_buf, sizeof(pjmedia_frame_ext)); 
    13061389                frame->type = PJMEDIA_FRAME_TYPE_NONE; 
     1390                frame->size = 0; 
    13071391                break; 
    13081392            } 
     
    13211405                                     f_src->size >> 1); 
    13221406        } else { /* PJMEDIA_FRAME_TYPE_NONE */ 
     1407            pjmedia_frame_ext *f_dst = (pjmedia_frame_ext*)frame; 
     1408 
    13231409            /* Reset TX buffer */ 
    1324             pj_bzero(this_cport->tx_buf, sizeof(pjmedia_frame_ext)); 
    1325             frame->type = PJMEDIA_FRAME_TYPE_NONE; 
     1410            f_dst->base.type = PJMEDIA_FRAME_TYPE_NONE; 
     1411            f_dst->samples_cnt = 0; 
     1412            f_dst->subframe_cnt = 0; 
    13261413        } 
    13271414    } while (0); 
     
    13421429    struct conf_port *cport = conf->ports[this_port->port_data.ldata]; 
    13431430    unsigned j; 
    1344     pj_int32_t level; 
     1431    pj_int32_t level = 0; 
    13451432 
    13461433    pj_add_timestamp32(&cport->ts_rx, cport->info->samples_per_frame); 
     
    13581445    } 
    13591446 
    1360     /* Calculate RX level. */ 
     1447    /* Calculate & adjust RX level. */ 
    13611448    if (f->type == PJMEDIA_FRAME_TYPE_AUDIO) { 
    1362         level = pjmedia_calc_avg_signal((const pj_int16_t*)f->buf, 
    1363                                         f->size >>1 ); 
     1449        if (cport->rx_adj_level != NORMAL_LEVEL) { 
     1450            pj_int16_t *p = (pj_int16_t*)f->buf; 
     1451            pj_int16_t *end; 
     1452 
     1453            end = p + (f->size >> 1); 
     1454            while (p < end) { 
     1455                pj_int32_t itemp = *p; 
     1456 
     1457                /* Adjust the level */ 
     1458                itemp = (itemp * cport->rx_adj_level) >> 7; 
     1459 
     1460                /* Clip the signal if it's too loud */ 
     1461                if (itemp > MAX_LEVEL) itemp = MAX_LEVEL; 
     1462                else if (itemp < MIN_LEVEL) itemp = MIN_LEVEL; 
     1463 
     1464                level += PJ_ABS(itemp); 
     1465 
     1466                /* Put back in the buffer. */ 
     1467                *p = (pj_int16_t)itemp; 
     1468                ++p; 
     1469            } 
     1470            level /= (f->size >> 1); 
     1471        } else { 
     1472            level = pjmedia_calc_avg_signal((const pj_int16_t*)f->buf, 
     1473                                            f->size >> 1); 
     1474        } 
    13641475    } else if (f->type == PJMEDIA_FRAME_TYPE_EXTENDED) { 
    13651476        /* For extended frame, TX level is unknown, so we just set  
     
    13671478         */ 
    13681479        level = NORMAL_LEVEL; 
    1369     } else { /* PJMEDIA_FRAME_TYPE_NONE. */ 
    1370         level = 0; 
    1371     } 
     1480    } 
     1481 
    13721482    cport->rx_level = pjmedia_linear2ulaw(level) ^ 0xff; 
    13731483 
     
    14021512        } 
    14031513 
    1404         /* Set listener TX level equal to transmitter RX level. */ 
    1405         listener->tx_level = cport->rx_level; 
     1514        /* Set listener TX level based on transmitter RX level & listener 
     1515         * TX level. 
     1516         */ 
     1517        listener->tx_level = (cport->rx_level * listener->tx_adj_level) >> 8; 
    14061518    } 
    14071519 
Note: See TracChangeset for help on using the changeset viewer.