NTSTATUS NTAPI PropertyHandler_Level ( PPCPROPERTY_REQUEST PropertyRequest ) [friend]
Definition at line 1089 of file mintopo.cpp.
{
    //PAGED_CODE();
    //ASSERT(PropertyRequest);
    DBGPRINT(("[PropertyHandler_Level]"));

    CCMITopology *that = (CCMITopology *) ((PMINIPORTTOPOLOGY) PropertyRequest->MajorTarget);
    NTSTATUS     ntStatus = STATUS_INVALID_PARAMETER;
    UInt32       channel;
    UInt8        mixerValue;

    if ((PropertyRequest->Node == ULONG(-1)) || (PropertyRequest->Node >= KSNODE_TOPO_INVALID) || (PropertyRequest->PropertyItem->Id != KSPROPERTY_AUDIO_VOLUMELEVEL)) {
        return ntStatus;
    }

    if ( ((PropertyRequest->Verb & KSPROPERTY_TYPE_GET) || (PropertyRequest->Verb & KSPROPERTY_TYPE_SET)) && (PropertyRequest->InstanceSize >= sizeof(LONG)) ) {

        channel = *(PLONG(PropertyRequest->Instance));

        if ((PropertyRequest->Node == KSNODE_TOPO_MICOUT_VOLUME) && (channel != CHAN_LEFT)) {
            return STATUS_INVALID_PARAMETER;
        }

        if ( ( (channel == CHAN_LEFT) || (channel == CHAN_RIGHT) ) && (PropertyRequest->ValueSize >= sizeof(LONG))) {

            PLONG Level = (PLONG)PropertyRequest->Value;

            for ( UINT i=0; i <SIZEOF_ARRAY(VolTable); i++ )
            {
                if (VolTable[i].node == PropertyRequest->Node) {
                    if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {

                        mixerValue = (that->CMIAdapter->readMixer(VolTable[i].reg+channel) >> VolTable[i].shift) & VolTable[i].mask;
                        *Level     = that->NodeCache[(2*PropertyRequest->Node)+channel];

                        if (mixerValue != ((*Level >> (VolTable[i].dbshift+16))+VolTable[i].mask)) {
                            *Level = (mixerValue - VolTable[i].mask) << (16+VolTable[i].dbshift);
                            that->NodeCache[(2*PropertyRequest->Node)+channel] = *Level;
                        }
                    } else
                    if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                        if (*Level <= (VolTable[i].min << 16)) {
                            mixerValue = 0;
                            that->NodeCache[(2*PropertyRequest->Node)+channel] = VolTable[i].min << 16;
                        } else
                        if (*Level >= (VolTable[i].max << 16)) {
                            mixerValue = VolTable[i].mask;
                            that->NodeCache[(2*PropertyRequest->Node)+channel] = VolTable[i].max << 16;
                        } else {
                            mixerValue = ((*Level >> (VolTable[i].dbshift+16)) + VolTable[i].mask) & VolTable[i].mask;
                            that->NodeCache[(2*PropertyRequest->Node)+channel] = *Level;
                        }
                        that->CMIAdapter->writeMixer(VolTable[i].reg+channel, mixerValue << VolTable[i].shift);
                    }
                    ntStatus = STATUS_SUCCESS;
                }
            }
            if (PropertyRequest->Node == KSNODE_TOPO_AUX_VOLUME) {
                if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                    mixerValue = that->auxVolumeRegister;
                    *Level     = that->NodeCache[(2*PropertyRequest->Node)+channel];
                    if (channel == CHAN_LEFT) {
                        mixerValue >>= 4;
                    }
                    mixerValue &= 0x0F;
                    if (mixerValue != ((*Level >> 18)+0x0F)) {
                        *Level = (mixerValue - 0x0F) << 18;
                        that->NodeCache[(2*PropertyRequest->Node)+channel] = *Level;
                    }
                } else
                if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                    if (*Level <= (-30 << 16)) {
                        mixerValue = 0;
                        that->NodeCache[(2*PropertyRequest->Node)+channel] = -30 << 16;
                    } else
                    if (*Level >= 0) {
                        mixerValue = 0x0F;
                        that->NodeCache[(2*PropertyRequest->Node)+channel] = 0;
                    } else  {
                        mixerValue = ((*Level >> 18) + 0x0F) & 0x0F;
                        that->NodeCache[(2*PropertyRequest->Node)+channel] = *Level;
                    }

                    if (channel == CHAN_RIGHT) {
                        that->auxVolumeRegister = (that->auxVolumeRegister & 0xF0) | mixerValue;
                    } else if (channel == CHAN_LEFT) {
                        that->auxVolumeRegister = (that->auxVolumeRegister & 0x0F) | (mixerValue << 4);
                    }
                    that->CMIAdapter->writeUInt8(REG_MIXER3, that->auxVolumeRegister);
                }
                ntStatus = STATUS_SUCCESS;
            }
            if ((PropertyRequest->Node == KSNODE_TOPO_MICIN_VOLUME) && (channel == CHAN_LEFT)) {
                if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                    *Level     = that->NodeCache[(2*PropertyRequest->Node)];
                    mixerValue = that->micVolumeRegister >> 1 & 0x7;
                    if (mixerValue != ((*Level >> 19)+0x07)) {
                        *Level = (mixerValue - 0x07) << 19;
                        that->NodeCache[(2*PropertyRequest->Node)] = *Level;
                    }
                } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                    if (*Level <= (-56 << 16)) {
                        mixerValue = 0;
                        that->NodeCache[(2*PropertyRequest->Node)] = -56 << 16;
                    } else if (*Level >= 0) {
                        mixerValue = 0x07;
                        that->NodeCache[(2*PropertyRequest->Node)] = 0;
                    } else {
                        mixerValue = ((*Level >> 19) + 0x07) & 0x07;
                        that->NodeCache[(2*PropertyRequest->Node)] = *Level;
                    }
                    that->micVolumeRegister &= ~(0x07 << 1);
                    that->micVolumeRegister |= mixerValue << 1;
                    that->CMIAdapter->writeUInt8(REG_MIXER2, that->micVolumeRegister);
                }
                ntStatus = STATUS_SUCCESS;
            }
            if ((NT_SUCCESS(ntStatus)) && (PropertyRequest->Verb & KSPROPERTY_TYPE_GET)) {
                PropertyRequest->ValueSize = sizeof(LONG);
            }
        }
    } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_BASICSUPPORT) {
        switch(PropertyRequest->Node) {
            case KSNODE_TOPO_LINEOUT_VOLUME:
            case KSNODE_TOPO_WAVEOUT_VOLUME:
            case KSNODE_TOPO_CD_VOLUME:
            case KSNODE_TOPO_LINEIN_VOLUME:
            case KSNODE_TOPO_MICOUT_VOLUME:
            case KSNODE_TOPO_MICIN_VOLUME:
            case KSNODE_TOPO_AUX_VOLUME:
                ntStatus = BasicSupportHandler(PropertyRequest);
                break;
        }
    }

    return ntStatus;
}
ReactOS Development > Doxygen
