예제 #1
0
 public HomeController(IFloorData floordata,
                       IClinicsData clinicdata,
                       IDoctorsData doctordata,
                       IHttpContextAccessor httpContextAccessor)
 {
     _httpContextAccessor = httpContextAccessor;
     _Floors  = floordata;
     _Clinics = clinicdata;
     _Doctors = doctordata;
 }
예제 #2
0
        public void Apply(IFloorData floorData, int blockSize, float[] residue)
        {
            if (!(floorData is Data data))
            {
                throw new ArgumentException("Incorrect packet data!", "packetData");
            }

            var n = blockSize / 2;

            if (data.PostCount > 0)
            {
                var stepFlags = UnwrapPosts(data);

                var lx = 0;
                var ly = data.Posts[0] * _multiplier;
                for (int i = 1; i < data.PostCount; i++)
                {
                    var idx = _sortIdx[i];

                    if (stepFlags[idx])
                    {
                        var hx = _xList[idx];
                        var hy = data.Posts[idx] * _multiplier;
                        if (lx < n)
                        {
                            RenderLineMulti(lx, ly, Math.Min(hx, n), hy, residue);
                        }
                        lx = hx;
                        ly = hy;
                    }
                    if (lx >= n)
                    {
                        break;
                    }
                }

                if (lx < n)
                {
                    RenderLineMulti(lx, ly, n, ly, residue);
                }
            }
            else
            {
                Array.Clear(residue, 0, n);
            }
        }
예제 #3
0
        public void Apply(IFloorData floorData, int blockSize, float[] residue)
        {
            if (!(floorData is Data data))
            {
                throw new ArgumentException("Incorrect packet data type.", nameof(floorData));
            }

            int n = blockSize / 2;

            if (data.Amp <= 0f)
            {
                Array.Clear(residue, 0, n);
                return;
            }

            // this is pretty well stolen directly from libvorbis...  BSD license
            var barkMap = _barkMaps[blockSize];
            var wMap    = _wMap[blockSize];

            int i;

            for (i = 0; i < _order; i++)
            {
                data.Coeff[i] = 2f * MathF.Cos(data.Coeff[i]);
            }

            i = 0;
            while (i < n)
            {
                int j;
                var k = barkMap[i];
                var p = .5f;
                var q = .5f;
                var w = wMap[k];
                for (j = 1; j < _order; j += 2)
                {
                    q *= w - data.Coeff[j - 1];
                    p *= w - data.Coeff[j];
                }
                if (j == _order)
                {
                    // odd order filter; slightly assymetric
                    q *= w - data.Coeff[j - 1];
                    p *= p * (4f - w * w);
                    q *= q;
                }
                else
                {
                    // even order filter; still symetric
                    p *= p * (2f - w);
                    q *= q * (2f + w);
                }

                // calc the dB of this bark section
                q = data.Amp / MathF.Sqrt(p + q) - _ampOfs;

                // now convert to a linear sample multiplier
                q = MathF.Exp(q * 0.11512925f);

                residue[i] *= q;

                while (barkMap[++i] == k)
                {
                    residue[i] *= q;
                }
            }
        }
예제 #4
0
        public void DecodePacket(IPacket packet, int blockSize, int channels, float[][] buffer)
        {
            var halfBlockSize = blockSize >> 1;

            // read the noise floor data
            var floorData        = new IFloorData[_channelFloor.Length];
            var noExecuteChannel = new bool[_channelFloor.Length];

            for (var i = 0; i < _channelFloor.Length; i++)
            {
                floorData[i]        = _channelFloor[i].Unpack(packet, blockSize, i);
                noExecuteChannel[i] = !floorData[i].ExecuteChannel;

                // pre-clear the residue buffers
                Array.Clear(buffer[i], 0, halfBlockSize);
            }

            // make sure we handle no-energy channels correctly given the couplings..
            for (var i = 0; i < _couplingAngle.Length; i++)
            {
                if (floorData[_couplingAngle[i]].ExecuteChannel || floorData[_couplingMangitude[i]].ExecuteChannel)
                {
                    floorData[_couplingAngle[i]].ForceEnergy     = true;
                    floorData[_couplingMangitude[i]].ForceEnergy = true;
                }
            }

            // decode the submaps into the residue buffer
            for (var i = 0; i < _submapFloor.Length; i++)
            {
                for (var j = 0; j < _channelFloor.Length; j++)
                {
                    if (_submapFloor[i] != _channelFloor[j] || _submapResidue[i] != _channelResidue[j])
                    {
                        // the submap doesn't match, so this floor doesn't contribute
                        floorData[j].ForceNoEnergy = true;
                    }
                }

                _submapResidue[i].Decode(packet, noExecuteChannel, blockSize, buffer);
            }

            // inverse coupling
            for (var i = _couplingAngle.Length - 1; i >= 0; i--)
            {
                if (floorData[_couplingAngle[i]].ExecuteChannel || floorData[_couplingMangitude[i]].ExecuteChannel)
                {
                    var magnitude = buffer[_couplingMangitude[i]];
                    var angle     = buffer[_couplingAngle[i]];

                    // we only have to do the first half; MDCT ignores the last half
                    for (var j = 0; j < halfBlockSize; j++)
                    {
                        float newM, newA;

                        var oldM = magnitude[j];
                        var oldA = angle[j];
                        if (oldM > 0)
                        {
                            if (oldA > 0)
                            {
                                newM = oldM;
                                newA = oldM - oldA;
                            }
                            else
                            {
                                newA = oldM;
                                newM = oldM + oldA;
                            }
                        }
                        else
                        {
                            if (oldA > 0)
                            {
                                newM = oldM;
                                newA = oldM + oldA;
                            }
                            else
                            {
                                newA = oldM;
                                newM = oldM - oldA;
                            }
                        }

                        magnitude[j] = newM;
                        angle[j]     = newA;
                    }
                }
            }

            // apply floor / dot product / MDCT (only run if we have sound energy in that channel)
            for (var c = 0; c < _channelFloor.Length; c++)
            {
                if (floorData[c].ExecuteChannel)
                {
                    _channelFloor[c].Apply(floorData[c], blockSize, buffer[c]);
                    _mdct.Reverse(buffer[c], blockSize);
                }
                else
                {
                    // since we aren't doing the IMDCT, we have to explicitly clear the back half of the block
                    Array.Clear(buffer[c], halfBlockSize, halfBlockSize);
                }
            }
        }