Ignore:
Timestamp:
Mar 9, 2009 12:55:29 PM (12 years ago)
Author:
bennylp
Message:

PJMEDIA/PJMEDIA-AUDIODEV update:

  • pjmedia.h: re-added inclusion of <sound.h> since we have compat

layer now

  • audiodev.h:
    • added input_vol and output_vol in pjmedia_aud_param, and

implement it on WMME dev

  • added pjmedia_aud_dev_cap_name() to see cap name
  • added pjmedia_aud_param_set_cap() and pjmedia_aud_param_get_cap() to set and get specific capability in param
  • conference.h: exported PJMEDIA_CONF_BRIDGE_SIGNATURE and

PJMEDIA_CONF_SWITCH_SIGNATURE since these are needed by PJSUA-LIB

  • WMME: bug due to addition of input_vol and output_vol in param:

volumes are set in flags in default_param(), but the
fields are not set. This would cause audio volume to be set to
zero for example.

  • WMME: some refactoring, removed duplicate settings in param
  • WMME: bug: setting set in set_cap() is not saved to param, so

get_param() will return wrong setting

  • APS: update because of s/out_route/output_route/ in param
  • APS: same bug as WMME due to addition of input_vol and output_vol in

param: flags are set in param but the fields are not

File:
1 edited

Legend:

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

    r2489 r2492  
    4848#define THIS_FILE                       "wmme_dev.c" 
    4949 
    50  
    5150/* WMME device info */ 
    5251struct wmme_dev_info 
     
    8180    DWORD         dwBufIdx; 
    8281    DWORD         dwMaxBufIdx; 
    83     unsigned      latency_ms; 
    8482    pj_timestamp  timestamp; 
    8583}; 
     
    8987struct wmme_stream 
    9088{ 
    91     pjmedia_aud_stream   base; 
    92     pjmedia_dir          dir;               /**< Sound direction.      */ 
    93     int                  play_id;           /**< Playback dev id.      */ 
    94     int                  rec_id;            /**< Recording dev id.     */ 
     89    pjmedia_aud_stream   base;              /**< Base stream           */ 
     90    pjmedia_aud_param    param;             /**< Settings              */ 
    9591    pj_pool_t           *pool;              /**< Memory pool.          */ 
    9692 
     
    105101    pjmedia_format_id    fmt_id;            /**< Frame format          */ 
    106102    pj_uint8_t           silence_char;      /**< Silence pattern       */ 
    107     unsigned             clock_rate;        /**< Clock rate.           */ 
    108103    unsigned             bytes_per_frame;   /**< Bytes per frame       */ 
    109     unsigned             samples_per_frame; /**< Samples per frame.    */ 
    110     unsigned             bits_per_sample;   /**< Bits per sample.      */ 
    111     unsigned             channel_count;     /**< Channel count.        */ 
    112104 
    113105    pjmedia_frame_ext   *xfrm;              /**< Extended frame buffer */ 
     
    438430    param->samples_per_frame = di->info.default_samples_per_sec * 20 / 1000; 
    439431    param->bits_per_sample = 16; 
    440     param->flags = di->info.caps; 
     432    param->flags = PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY | 
     433                   PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY; 
    441434    param->input_latency_ms = PJMEDIA_SND_DEFAULT_REC_LATENCY; 
    442435    param->output_latency_ms = PJMEDIA_SND_DEFAULT_PLAY_LATENCY; 
     
    498491 
    499492    if (id == PJMEDIA_FORMAT_L16) 
    500         return "l16"; 
     493        return "PCM"; 
    501494    pj_memcpy(name, &id, 4); 
    502495    name[4] = '\0'; 
     
    686679    eventCount = 0; 
    687680    events[eventCount++] = strm->thread_quit_event; 
    688     if (strm->dir & PJMEDIA_DIR_PLAYBACK) 
     681    if (strm->param.dir & PJMEDIA_DIR_PLAYBACK) 
    689682        events[eventCount++] = strm->play_strm.hEvent; 
    690     if (strm->dir & PJMEDIA_DIR_CAPTURE) 
     683    if (strm->param.dir & PJMEDIA_DIR_CAPTURE) 
    691684        events[eventCount++] = strm->rec_strm.hEvent; 
    692685 
     
    696689     */ 
    697690#if defined(PJ_WIN32_WINCE) && PJ_WIN32_WINCE != 0 
    698     if (strm->dir & PJMEDIA_DIR_PLAYBACK) 
     691    if (strm->param.dir & PJMEDIA_DIR_PLAYBACK) 
    699692        CeSetThreadPriority(GetCurrentThread(), 153); 
    700693    else 
     
    834827                if (++wmme_strm->dwBufIdx >= wmme_strm->dwMaxBufIdx) 
    835828                    wmme_strm->dwBufIdx = 0; 
    836                 wmme_strm->timestamp.u64 += strm->samples_per_frame /  
    837                                             strm->channel_count; 
     829                wmme_strm->timestamp.u64 += strm->param.samples_per_frame / 
     830                                            strm->param.channel_count; 
    838831            } 
    839832        } 
     
    914907                    strm->xfrm->samples_cnt = 0; 
    915908                    strm->xfrm->subframe_cnt = 0; 
    916                     pjmedia_frame_ext_append_subframe(strm->xfrm, buffer, 
    917                                                       strm->bytes_per_frame *8, 
    918                                                       strm->samples_per_frame); 
     909                    pjmedia_frame_ext_append_subframe( 
     910                        strm->xfrm, buffer, 
     911                        strm->bytes_per_frame *8, 
     912                        strm->param.samples_per_frame 
     913                    ); 
    919914                } 
    920915 
     
    938933                if (++wmme_strm->dwBufIdx >= wmme_strm->dwMaxBufIdx) 
    939934                    wmme_strm->dwBufIdx = 0; 
    940                 wmme_strm->timestamp.u64 += strm->samples_per_frame /  
    941                                             strm->channel_count; 
     935                wmme_strm->timestamp.u64 += strm->param.samples_per_frame / 
     936                                            strm->param.channel_count; 
    942937            } 
    943938        } 
     
    982977 
    983978    strm = PJ_POOL_ZALLOC_T(pool, struct wmme_stream); 
    984     strm->dir = param->dir; 
    985     strm->play_id = param->play_id; 
    986     strm->rec_id = param->rec_id; 
     979    pj_memcpy(&strm->param, param, sizeof(*param)); 
    987980    strm->pool = pool; 
    988981    strm->rec_cb = rec_cb; 
     
    991984    strm->fmt_id = param->ext_fmt.id; 
    992985    strm->silence_char = silence_char; 
    993     strm->clock_rate = param->clock_rate; 
    994     strm->samples_per_frame = param->samples_per_frame; 
    995     strm->bits_per_sample = param->bits_per_sample; 
    996     strm->channel_count = param->channel_count; 
    997986 
    998987    /* Create player stream */ 
     
    1000989        unsigned buf_count; 
    1001990 
    1002         if (param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY) 
    1003             strm->play_strm.latency_ms = param->output_latency_ms; 
    1004         else 
    1005             strm->play_strm.latency_ms = PJMEDIA_SND_DEFAULT_PLAY_LATENCY; 
    1006  
    1007         buf_count = strm->play_strm.latency_ms * param->clock_rate *  
     991        if ((param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY)==0) { 
     992            strm->param.flags |= PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY; 
     993            strm->param.output_latency_ms = PJMEDIA_SND_DEFAULT_PLAY_LATENCY; 
     994        } 
     995 
     996        buf_count = strm->param.output_latency_ms * param->clock_rate *  
    1008997                    param->channel_count / param->samples_per_frame / 1000; 
    1009998 
     
    10241013        unsigned buf_count; 
    10251014 
    1026         if (param->flags & PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY) 
    1027             strm->rec_strm.latency_ms = param->input_latency_ms; 
    1028         else 
    1029             strm->rec_strm.latency_ms = PJMEDIA_SND_DEFAULT_REC_LATENCY; 
    1030  
    1031         buf_count = strm->rec_strm.latency_ms * param->clock_rate *  
     1015        if ((param->flags & PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY)==0) { 
     1016            strm->param.flags |= PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY; 
     1017            strm->param.input_latency_ms = PJMEDIA_SND_DEFAULT_REC_LATENCY; 
     1018        } 
     1019 
     1020        buf_count = strm->param.input_latency_ms * param->clock_rate *  
    10321021                    param->channel_count / param->samples_per_frame / 1000; 
    10331022 
     
    10751064    } 
    10761065 
     1066    /* Apply the remaining settings */ 
     1067    if (param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING) { 
     1068        stream_set_cap(&strm->base, PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING, 
     1069                       &param->output_vol); 
     1070    } 
     1071 
     1072 
    10771073    /* Done */ 
    10781074    strm->base.op = &stream_op; 
     
    10901086    PJ_ASSERT_RETURN(strm && pi, PJ_EINVAL); 
    10911087 
    1092     pj_bzero(pi, sizeof(*pi)); 
    1093     pi->dir = strm->dir; 
    1094     pi->play_id = strm->play_id; 
    1095     pi->rec_id = strm->rec_id; 
    1096     pi->clock_rate = strm->clock_rate; 
    1097     pi->channel_count = strm->channel_count; 
    1098     pi->samples_per_frame = strm->samples_per_frame; 
    1099     pi->bits_per_sample = strm->bits_per_sample; 
     1088    pj_memcpy(pi, &strm->param, sizeof(*pi)); 
    11001089     
    1101     if (pi->dir & PJMEDIA_DIR_CAPTURE) { 
    1102         pi->flags |= PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY; 
    1103         pi->input_latency_ms = strm->rec_strm.latency_ms; 
    1104     } 
    1105  
    1106     if (pi->dir & PJMEDIA_DIR_PLAYBACK) { 
    1107         /* TODO: report the actual latency? */ 
    1108         pi->flags |= PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY; 
    1109         pi->output_latency_ms = strm->play_strm.latency_ms; 
    1110     } 
    1111  
    11121090    return PJ_SUCCESS; 
    11131091} 
     
    11231101 
    11241102    if (cap==PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY &&  
    1125         (strm->dir & PJMEDIA_DIR_CAPTURE))  
     1103        (strm->param.dir & PJMEDIA_DIR_CAPTURE))  
    11261104    { 
    11271105        /* Recording latency */ 
    1128         *(unsigned*)pval = strm->rec_strm.latency_ms; 
     1106        *(unsigned*)pval = strm->param.input_latency_ms; 
    11291107        return PJ_SUCCESS; 
    11301108    } else if (cap==PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY  &&  
    1131                (strm->dir & PJMEDIA_DIR_PLAYBACK)) 
     1109               (strm->param.dir & PJMEDIA_DIR_PLAYBACK)) 
    11321110    { 
    11331111        /* Playback latency */ 
    1134         *(unsigned*)pval = strm->play_strm.latency_ms; 
     1112        *(unsigned*)pval = strm->param.output_latency_ms; 
    11351113        return PJ_SUCCESS; 
    11361114    } else if (cap==PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING && 
     
    11381116    { 
    11391117        /* Output volume setting */ 
    1140         DWORD dwVol; 
     1118        DWORD waveVol; 
    11411119        MMRESULT mr; 
    11421120 
    1143         mr = waveOutGetVolume(strm->play_strm.hWave.Out, &dwVol); 
     1121        mr = waveOutGetVolume(strm->play_strm.hWave.Out, &waveVol); 
    11441122        if (mr != MMSYSERR_NOERROR) { 
    11451123            return PJMEDIA_AUDIODEV_ERRNO_FROM_WMME_OUT(mr); 
    11461124        } 
    11471125 
    1148         dwVol &= 0xFFFF; 
    1149         *(unsigned*)pval = (dwVol * 100) / 0xFFFF; 
     1126        waveVol &= 0xFFFF; 
     1127        *(unsigned*)pval = (waveVol * 100) / 0xFFFF; 
    11501128        return PJ_SUCCESS; 
    11511129    } else { 
     
    11671145    { 
    11681146        /* Output volume setting */ 
    1169         DWORD dwVol; 
     1147        unsigned vol = *(unsigned*)pval; 
     1148        DWORD waveVol; 
    11701149        MMRESULT mr; 
    1171  
    1172         dwVol = ((*(unsigned*)pval) * 0xFFFF) / 100; 
    1173         dwVol |= (dwVol << 16); 
    1174  
    1175         mr = waveOutSetVolume(strm->play_strm.hWave.Out, dwVol); 
    1176         return (mr==MMSYSERR_NOERROR)? PJ_SUCCESS :  
     1150        pj_status_t status; 
     1151 
     1152        if (vol > 100) 
     1153            vol = 100; 
     1154 
     1155        waveVol = (vol * 0xFFFF) / 100; 
     1156        waveVol |= (waveVol << 16); 
     1157 
     1158        mr = waveOutSetVolume(strm->play_strm.hWave.Out, waveVol); 
     1159        status = (mr==MMSYSERR_NOERROR)? PJ_SUCCESS :  
    11771160                                PJMEDIA_AUDIODEV_ERRNO_FROM_WMME_OUT(mr); 
     1161        if (status == PJ_SUCCESS) { 
     1162            strm->param.output_vol = *(unsigned*)pval; 
     1163        } 
     1164        return status; 
    11781165    } 
    11791166 
Note: See TracChangeset for help on using the changeset viewer.