← Back to branch summary

~ubuntu-branches/ubuntu/trusty/vice/trusty

« back to all changes in this revision

Viewing changes to src/resid/sid.cc

  • Committer: Package Import Robot
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2013-07-28 20:38:23 UTC
  • mfrom: (1.2.5)
  • mto: This revision was merged to the branch mainline in revision 27.
  • Revision ID: package-import@ubuntu.com-20130728203823-w495rps5wuykespp
Tags: upstream-2.4.dfsg
Import upstream version 2.4.dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/resid/sid.cc
94
94
 
95
95
// ----------------------------------------------------------------------------
96
96
// Write 16-bit sample to audio input.
97
 
// NB! The caller is responsible for keeping the value within 16 bits.
98
97
// Note that to mix in an external audio signal, the signal should be
99
98
// resampled to 1MHz first to avoid sampling noise.
100
99
// ----------------------------------------------------------------------------
104
103
  filter.input(sample);
105
104
}
106
105
 
107
 
// ----------------------------------------------------------------------------
108
 
// Read 16-bit sample from audio output.
109
 
// ----------------------------------------------------------------------------
110
 
short SID::output()
111
 
{
112
 
  return extfilt.output();
113
 
}
114
 
 
115
106
 
116
107
// ----------------------------------------------------------------------------
117
108
// Read registers.
172
163
// ----------------------------------------------------------------------------
173
164
// Write registers.
174
165
// ----------------------------------------------------------------------------
175
 
RESID_INLINE
176
166
void SID::write()
177
167
{
178
168
  switch (write_address) {
527
517
 
528
518
  sample_offset = 0;
529
519
  sample_prev = 0;
 
520
  sample_now = 0;
530
521
 
531
522
  // FIR initialization is only necessary for resampling.
532
523
  if (method != SAMPLE_RESAMPLE && method != SAMPLE_RESAMPLE_FASTMEM)
633
624
 
634
625
 
635
626
// ----------------------------------------------------------------------------
636
 
// SID clocking - 1 cycle.
637
 
// ----------------------------------------------------------------------------
638
 
void SID::clock()
639
 
{
640
 
  int i;
641
 
 
642
 
  // Clock amplitude modulators.
643
 
  for (i = 0; i < 3; i++) {
644
 
    voice[i].envelope.clock();
645
 
  }
646
 
 
647
 
  // Clock oscillators.
648
 
  for (i = 0; i < 3; i++) {
649
 
    voice[i].wave.clock();
650
 
  }
651
 
 
652
 
  // Synchronize oscillators.
653
 
  for (i = 0; i < 3; i++) {
654
 
    voice[i].wave.synchronize();
655
 
  }
656
 
 
657
 
  // Calculate waveform output.
658
 
  for (i = 0; i < 3; i++) {
659
 
    voice[i].wave.set_waveform_output();
660
 
  }
661
 
 
662
 
  // Clock filter.
663
 
  filter.clock(voice[0].output(), voice[1].output(), voice[2].output());
664
 
 
665
 
  // Clock external filter.
666
 
  extfilt.clock(filter.output());
667
 
 
668
 
  // Pipelined writes on the MOS8580.
669
 
  if (unlikely(write_pipeline)) {
670
 
    write();
671
 
  }
672
 
 
673
 
  // Age bus value.
674
 
  if (unlikely(!--bus_value_ttl)) {
675
 
    bus_value = 0;
676
 
  }
677
 
}
678
 
 
679
 
 
680
 
// ----------------------------------------------------------------------------
681
627
// SID clocking - delta_t cycles.
682
628
// ----------------------------------------------------------------------------
683
629
void SID::clock(cycle_count delta_t)
800
746
  }
801
747
}
802
748
 
 
749
 
803
750
// ----------------------------------------------------------------------------
804
751
// SID clocking with audio sampling - delta clocking picking nearest sample.
805
752
// ----------------------------------------------------------------------------
806
 
RESID_INLINE
807
753
int SID::clock_fast(cycle_count& delta_t, short* buf, int n,
808
754
                    int interleave)
809
755
{
810
 
  int s = 0;
 
756
  int s;
811
757
 
812
 
  for (;;) {
 
758
  for (s = 0; s < n; s++) {
813
759
    cycle_count next_sample_offset = sample_offset + cycles_per_sample + (1 << (FIXP_SHIFT - 1));
814
760
    cycle_count delta_t_sample = next_sample_offset >> FIXP_SHIFT;
815
 
    if (unlikely(delta_t_sample > delta_t)) {
816
 
      break;
817
 
    }
818
 
    if (unlikely(s >= n)) {
819
 
      return s;
820
 
    }
 
761
 
 
762
    if (delta_t_sample > delta_t) {
 
763
      delta_t_sample = delta_t;
 
764
    }
 
765
 
821
766
    clock(delta_t_sample);
822
 
    delta_t -= delta_t_sample;
 
767
 
 
768
    if ((delta_t -= delta_t_sample) == 0) {
 
769
      sample_offset -= delta_t_sample << FIXP_SHIFT;
 
770
      break;
 
771
    }
 
772
 
823
773
    sample_offset = (next_sample_offset & FIXP_MASK) - (1 << (FIXP_SHIFT - 1));
824
 
    buf[s++*interleave] = output();
 
774
    buf[s*interleave] = output();
825
775
  }
826
776
 
827
 
  clock(delta_t);
828
 
  sample_offset -= delta_t << FIXP_SHIFT;
829
 
  delta_t = 0;
830
777
  return s;
831
778
}
832
779
 
840
787
// external filter attenuates frequencies above 16kHz, thus reducing
841
788
// sampling noise.
842
789
// ----------------------------------------------------------------------------
843
 
RESID_INLINE
844
790
int SID::clock_interpolate(cycle_count& delta_t, short* buf, int n,
845
791
                           int interleave)
846
792
{
847
 
  int s = 0;
848
 
  int i;
 
793
  int s;
849
794
 
850
 
  for (;;) {
 
795
  for (s = 0; s < n; s++) {
851
796
    cycle_count next_sample_offset = sample_offset + cycles_per_sample;
852
797
    cycle_count delta_t_sample = next_sample_offset >> FIXP_SHIFT;
853
 
    if (unlikely(delta_t_sample > delta_t)) {
 
798
 
 
799
    if (delta_t_sample > delta_t) {
 
800
      delta_t_sample = delta_t;
 
801
    }
 
802
 
 
803
    for (int i = delta_t_sample; i > 0; i--) {
 
804
      clock();
 
805
      if (unlikely(i <= 2)) {
 
806
        sample_prev = sample_now;
 
807
        sample_now = output();
 
808
      }
 
809
    }
 
810
 
 
811
    if ((delta_t -= delta_t_sample) == 0) {
 
812
      sample_offset -= delta_t_sample << FIXP_SHIFT;
854
813
      break;
855
814
    }
856
 
    if (unlikely(s >= n)) {
857
 
      return s;
858
 
    }
859
 
    for (i = 0; i < delta_t_sample - 1; i++) {
860
 
      clock();
861
 
    }
862
 
    if (likely(i < delta_t_sample)) {
863
 
      sample_prev = output();
864
 
      clock();
865
 
    }
866
815
 
867
 
    delta_t -= delta_t_sample;
868
816
    sample_offset = next_sample_offset & FIXP_MASK;
869
817
 
870
 
    short sample_now = output();
871
 
    buf[s++*interleave] =
 
818
    buf[s*interleave] =
872
819
      sample_prev + (sample_offset*(sample_now - sample_prev) >> FIXP_SHIFT);
873
 
    sample_prev = sample_now;
874
820
  }
875
821
 
876
 
  for (i = 0; i < delta_t - 1; i++) {
877
 
    clock();
878
 
  }
879
 
  if (likely(i < delta_t)) {
880
 
    sample_prev = output();
881
 
    clock();
882
 
  }
883
 
  sample_offset -= delta_t << FIXP_SHIFT;
884
 
  delta_t = 0;
885
822
  return s;
886
823
}
887
824
 
922
859
// NB! the result of right shifting negative numbers is really
923
860
// implementation dependent in the C++ standard.
924
861
// ----------------------------------------------------------------------------
925
 
RESID_INLINE
926
862
int SID::clock_resample(cycle_count& delta_t, short* buf, int n,
927
863
                        int interleave)
928
864
{
929
 
  int s = 0;
 
865
  int s;
930
866
 
931
 
  for (;;) {
 
867
  for (s = 0; s < n; s++) {
932
868
    cycle_count next_sample_offset = sample_offset + cycles_per_sample;
933
869
    cycle_count delta_t_sample = next_sample_offset >> FIXP_SHIFT;
934
 
    if (unlikely(delta_t_sample > delta_t)) {
935
 
      break;
936
 
    }
937
 
    if (unlikely(s >= n)) {
938
 
      return s;
939
 
    }
 
870
 
 
871
    if (delta_t_sample > delta_t) {
 
872
      delta_t_sample = delta_t;
 
873
    }
 
874
 
940
875
    for (int i = 0; i < delta_t_sample; i++) {
941
876
      clock();
942
877
      sample[sample_index] = sample[sample_index + RINGSIZE] = output();
943
878
      ++sample_index &= RINGMASK;
944
879
    }
945
 
    delta_t -= delta_t_sample;
 
880
 
 
881
    if ((delta_t -= delta_t_sample) == 0) {
 
882
      sample_offset -= delta_t_sample << FIXP_SHIFT;
 
883
      break;
 
884
    }
 
885
 
946
886
    sample_offset = next_sample_offset & FIXP_MASK;
947
887
 
948
888
    int fir_offset = sample_offset*fir_RES >> FIXP_SHIFT;
979
919
 
980
920
    // Saturated arithmetics to guard against 16 bit sample overflow.
981
921
    const int half = 1 << 15;
982
 
    if (unlikely(v >= half)) {
 
922
    if (v >= half) {
983
923
      v = half - 1;
984
924
    }
985
 
    else if (unlikely(v < -half)) {
 
925
    else if (v < -half) {
986
926
      v = -half;
987
927
    }
988
928
 
989
 
    buf[s++*interleave] = v;
 
929
    buf[s*interleave] = v;
990
930
  }
991
931
 
992
 
  for (int i = 0; i < delta_t; i++) {
993
 
    clock();
994
 
    sample[sample_index] = sample[sample_index + RINGSIZE] = output();
995
 
    ++sample_index &= RINGMASK;
996
 
  }
997
 
  sample_offset -= delta_t << FIXP_SHIFT;
998
 
  delta_t = 0;
999
932
  return s;
1000
933
}
1001
934
 
1003
936
// ----------------------------------------------------------------------------
1004
937
// SID clocking with audio sampling - cycle based with audio resampling.
1005
938
// ----------------------------------------------------------------------------
1006
 
RESID_INLINE
1007
939
int SID::clock_resample_fastmem(cycle_count& delta_t, short* buf, int n,
1008
940
                                int interleave)
1009
941
{
1010
 
  int s = 0;
 
942
  int s;
1011
943
 
1012
 
  for (;;) {
 
944
  for (s = 0; s < n; s++) {
1013
945
    cycle_count next_sample_offset = sample_offset + cycles_per_sample;
1014
946
    cycle_count delta_t_sample = next_sample_offset >> FIXP_SHIFT;
1015
 
    if (unlikely(delta_t_sample > delta_t)) {
1016
 
      break;
1017
 
    }
1018
 
    if (unlikely(s >= n)) {
1019
 
      return s;
1020
 
    }
 
947
 
 
948
    if (delta_t_sample > delta_t) {
 
949
      delta_t_sample = delta_t;
 
950
    }
 
951
 
1021
952
    for (int i = 0; i < delta_t_sample; i++) {
1022
953
      clock();
1023
954
      sample[sample_index] = sample[sample_index + RINGSIZE] = output();
1024
955
      ++sample_index &= RINGMASK;
1025
956
    }
1026
 
    delta_t -= delta_t_sample;
 
957
 
 
958
    if ((delta_t -= delta_t_sample) == 0) {
 
959
      sample_offset -= delta_t_sample << FIXP_SHIFT;
 
960
      break;
 
961
    }
 
962
 
1027
963
    sample_offset = next_sample_offset & FIXP_MASK;
1028
964
 
1029
965
    int fir_offset = sample_offset*fir_RES >> FIXP_SHIFT;
1040
976
 
1041
977
    // Saturated arithmetics to guard against 16 bit sample overflow.
1042
978
    const int half = 1 << 15;
1043
 
    if (unlikely(v >= half)) {
 
979
    if (v >= half) {
1044
980
      v = half - 1;
1045
981
    }
1046
 
    else if (unlikely(v < -half)) {
 
982
    else if (v < -half) {
1047
983
      v = -half;
1048
984
    }
1049
985
 
1050
 
    buf[s++*interleave] = v;
 
986
    buf[s*interleave] = v;
1051
987
  }
1052
988
 
1053
 
  for (int i = 0; i < delta_t; i++) {
1054
 
    clock();
1055
 
    sample[sample_index] = sample[sample_index + RINGSIZE] = output();
1056
 
    ++sample_index &= RINGMASK;
1057
 
  }
1058
 
  sample_offset -= delta_t << FIXP_SHIFT;
1059
 
  delta_t = 0;
1060
989
  return s;
1061
990
}
1062
991