int ast_channel_make_compatible(struct ast_channel *chan, struct ast_channel *peer)

{

    /* Some callers do not check return code, and we must try to set all call legs correctly */

    int rc = ;

    /* Set up translation from the chan to the peer */

    // modify

    //rc = ast_channel_make_compatible_helper(chan, peer);

    rc = ast_channel_make_compatible_helper(chan, peer, );

    // modify end

    if (rc < )

        return rc;

    /* Set up translation from the peer to the chan */

    // modify

    //rc = ast_channel_make_compatible_helper(peer, chan);

    rc = ast_channel_make_compatible_helper(peer, chan, );

    // modify end

    return rc;

}

/*! \brief Set up translation from one channel to another */

/*     modify :

        Add a 'bool' argument to judge which is a caller channel and which a callee channel.

        if 'bool' is true, then 'from' is a caller channel, 'to' is a callee channel.

        otherwise, 'to' is a caller channel, 'from' is a callee channel.

*/

static int ast_channel_make_compatible_helper(struct ast_channel *from, struct ast_channel *to, int bool)

{

    format_t src, dst;

    //int use_slin;

    /* See if the channel driver can natively make these two channels compatible */

    if (from->tech->bridge && from->tech->bridge == to->tech->bridge &&

        !ast_channel_setoption(from, AST_OPTION_MAKE_COMPATIBLE, to, sizeof(struct ast_channel *), )) {

        return ;

    }

    if (from->readformat == to->writeformat && from->writeformat == to->readformat) {

        /* Already compatible!  Moving on ... */

        ast_log(LOG_NOTICE, "Already compatible!\n");

        return ;

    }

    /* Set up translation from the 'from' channel to the 'to' channel */

    src = from->nativeformats;

    dst = to->nativeformats;

    /* If there's no audio in this call, don't bother with trying to find a translation path */

    if ((src & AST_FORMAT_AUDIO_MASK) ==  || (dst & AST_FORMAT_AUDIO_MASK) == )

        return ;

    if (ast_translator_best_choice(&dst, &src) < ) {         ast_log(LOG_WARNING, "No path to translate from %s to %s\n", from->name, to->name);

        return -;

    }

    /* if the best path is not 'pass through', then

     * transcoding is needed; if desired, force transcode path

     * to use SLINEAR between channels, but only if there is

     * no direct conversion available. If generic PLC is

     * desired, then transcoding via SLINEAR is a requirement

     */

    // modify : comment these

    /*

    use_slin = (src == AST_FORMAT_SLINEAR || dst == AST_FORMAT_SLINEAR);

    if ((src != dst) && (ast_opt_generic_plc || ast_opt_transcode_via_slin) &&

        (ast_translate_path_steps(dst, src) != 1 || use_slin)){

        ast_log(LOG_NOTICE, "dst is AST_FORMAT_SLINEAR!\n");

        dst = AST_FORMAT_SLINEAR;

    }

    */

    // modify end

    // add

    /*

        we only build translation path and do translations in the callee channel.

        to achieve this goal, we set readformat and writeformat of the caller channel

        and the callee channel both to nativeformat of  the caller channel,so the caller

        channel won't execute read-transcode and write-transcode.

    */

    if(bool){

        dst = src;

    }

    // add end

    if (ast_set_read_format(from, dst) < ) {         ast_log(LOG_WARNING, "Unable to set read format on channel %s to %s\n", from->name, ast_getformatname(dst));

        return -;

    }

    if (ast_set_write_format(to, dst) < ) {         ast_log(LOG_WARNING, "Unable to set write format on channel %s to %s\n", to->name, ast_getformatname(dst));

        return -;

    }

    return ;

}

    if (!(p->owner->nativeformats & p->jointcapability) && (p->jointcapability & AST_FORMAT_AUDIO_MASK)) {

        if (debug) {

            char s1[SIPBUFSIZE], s2[SIPBUFSIZE];

            ast_debug(, "Oooh, we need to change our audio formats since our peer supports only %s and not %s\n",

                ast_getformatname_multiple(s1, SIPBUFSIZE, p->jointcapability),

                ast_getformatname_multiple(s2, SIPBUFSIZE, p->owner->nativeformats));

        }

        p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, ) | (p->capability & vpeercapability) | (p->capability & tpeercapability);

        ast_set_read_format(p->owner, p->owner->readformat);

        ast_set_write_format(p->owner, p->owner->writeformat);

    }