ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/Frodo4/Src/SID.cpp
(Generate patch)

Comparing Frodo4/Src/SID.cpp (file contents):
Revision 1.1 by cebix, 2003-07-01T17:09:43Z vs.
Revision 1.10 by cebix, 2010-04-22T09:09:28Z

# Line 1 | Line 1
1   /*
2   *  SID.cpp - 6581 emulation
3   *
4 < *  Frodo (C) 1994-1997,2002 Christian Bauer
4 > *  Frodo Copyright (C) Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 23 | Line 23
23   * ------------------
24   *
25   *  - Lots of empirically determined constants in the filter calculations
26 – *  - Voice 3 cannot be muted
26   */
27  
28   #include "sysdeps.h"
# Line 33 | Line 32
32   #include "Prefs.h"
33  
34   #ifdef __BEOS__
35 < #include <MediaKit.h>
35 > #include <media/SoundPlayer.h>
36   #endif
37  
38   #ifdef AMIGA
# Line 349 | Line 348 | struct DRVoice {
348                                          // The following bit is set for the modulating
349                                          // voice, not for the modulated one (as the SID bits)
350          bool sync;              // Sync modulation bit
351 +        bool mute;              // Voice muted (voice 3 only)
352   };
353  
354   // Renderer class
355   class DigitalRenderer : public SIDRenderer {
356   public:
357 – #if defined(__BEOS__) || defined(__riscos__)
357          DigitalRenderer(C64 *c64);
359 – #else
360 –        DigitalRenderer();
361 – #endif
358          virtual ~DigitalRenderer();
359  
360          virtual void Reset(void);
# Line 377 | Line 373 | private:
373          void calc_buffer(int16 *buf, long count);
374   #endif
375  
376 +        C64 *the_c64;                                   // Pointer to C64 object
377 +
378          bool ready;                                             // Flag: Renderer has initialized and is ready
379          uint8 volume;                                   // Master volume
382 –        bool v3_mute;                                   // Voice 3 muted
380  
381          static uint16 TriTable[0x1000*2];       // Tables for certain waveforms
382          static const uint16 TriSawTable[0x100];
# Line 418 | Line 415 | private:
415          int sample_in_ptr;                              // Index in sample_buf for writing
416  
417   #ifdef __BEOS__
418 <        static bool stream_func(void *arg, char *buf, size_t count, void *header);
419 <        C64 *the_c64;                                   // Pointer to C64 object
420 <        BDACStream *the_stream;                 // Pointer to stream
424 <        BSubscriber *the_sub;                   // Pointer to subscriber
425 <        bool in_stream;                                 // Flag: Subscriber has entered stream
418 >        static void buffer_proc(void *cookie, void *buffer, size_t size, const media_raw_audio_format &format);
419 >        BSoundPlayer *the_player;               // Pointer to sound player
420 >        bool player_stopped;                    // Flag: player stopped
421   #endif
422  
423   #ifdef AMIGA
# Line 442 | Line 437 | private:
437          int play_buf;                                   // Number of buffer currently playing
438   #endif
439  
440 < #ifdef __linux__
440 >
441 > #ifdef HAVE_SDL
442 >        static void buffer_proc(void *cookie, uint8 *buffer, int size);
443 > #else
444 >
445 > # ifdef __linux__
446          int devfd, sndbufsize, buffer_rate;
447          int16 *sound_buffer;
448 < #endif
448 > # endif
449  
450 < #ifdef SUN
450 > # ifdef SUN
451          int fd;
452          audio_info status;
453          uint_t sent_samples,delta_samples;
454 <        WORD *sound_calc_buf;
455 < #endif
454 >        int16 *sound_calc_buf;
455 > # endif
456  
457 < #ifdef __hpux
457 > # ifdef __hpux
458          int fd;
459          audio_status status;
460 <        int16 * sound_calc_buf;
460 >        int16 *sound_calc_buf;
461          int linecnt;
462 < #endif
462 > # endif
463 >
464 > #endif // ndef HAVE_SDL
465 >
466  
467   #ifdef __mac__
468          SndChannelPtr chan1;
# Line 493 | Line 496 | private:
496   #ifdef __riscos__
497          int linecnt, sndbufsize;
498          uint8 *sound_buffer;
496 –        C64 *the_c64;
499   #endif
500   };
501  
# Line 824 | Line 826 | const int16 DigitalRenderer::SampleTab[1
826   *  Constructor
827   */
828  
827 – #if defined(__BEOS__) || defined(__riscos__)
829   DigitalRenderer::DigitalRenderer(C64 *c64) : the_c64(c64)
829 – #else
830 – DigitalRenderer::DigitalRenderer()
831 – #endif
830   {
831          // Link voices together
832          voice[0].mod_by = &voice[2];
# Line 877 | Line 875 | DigitalRenderer::DigitalRenderer()
875   void DigitalRenderer::Reset(void)
876   {
877          volume = 0;
880 –        v3_mute = false;
878  
879          for (int v=0; v<3; v++) {
880                  voice[v].wave = WAVE_NONE;
# Line 887 | Line 884 | void DigitalRenderer::Reset(void)
884                  voice[v].eg_level = voice[v].s_level = 0;
885                  voice[v].a_add = voice[v].d_sub = voice[v].r_sub = EGTable[0];
886                  voice[v].gate = voice[v].ring = voice[v].test = false;
887 <                voice[v].filter = voice[v].sync = false;
887 >                voice[v].filter = voice[v].sync = voice[v].mute = false;
888          }
889  
890          f_type = FILT_NONE;
# Line 966 | Line 963 | void DigitalRenderer::WriteRegister(uint
963                          voice[v].gate = byte & 1;
964                          voice[v].mod_by->sync = byte & 2;
965                          voice[v].ring = byte & 4;
966 <                        if ((voice[v].test = byte & 8))
966 >                        if ((voice[v].test = byte & 8) != 0)
967                                  voice[v].count = 0;
968                          break;
969  
# Line 1005 | Line 1002 | void DigitalRenderer::WriteRegister(uint
1002  
1003                  case 24:
1004                          volume = byte & 0xf;
1005 <                        v3_mute = byte & 0x80;
1005 >                        voice[2].mute = byte & 0x80;
1006                          if (((byte >> 4) & 7) != f_type) {
1007                                  f_type = (byte >> 4) & 7;
1008   #ifdef USE_FIXPOINT_MATHS
# Line 1201 | Line 1198 | void DigitalRenderer::calc_buffer(int16
1198   #ifdef __riscos__       // on RISC OS we have 8 bit logarithmic sound
1199          DigitalRenderer_GetTables(&LinToLog, &LogScale);        // get translation tables
1200   #else
1204 – #ifdef __BEOS__
1205 –        count >>= 2;    // 16 bit stereo output, count is in bytes
1206 – #else
1201          count >>= 1;    // 16 bit mono output, count is in bytes
1202   #endif
1209 – #endif
1203          while (count--) {
1211 –                int32 sum_output;
1212 –                int32 sum_output_filter = 0;
1213 –
1204                  // Get current master volume from sample buffer,
1205                  // calculate sampled voice
1206                  uint8 master_volume = sample_buf[(sample_count >> 16) % SAMPLE_BUF_SIZE];
1207                  sample_count += ((0x138 * 50) << 16) / SAMPLE_FREQ;
1208 <                sum_output = SampleTab[master_volume] << 8;
1208 >                int32 sum_output = SampleTab[master_volume] << 8;
1209 >                int32 sum_output_filter = 0;
1210  
1211                  // Loop for all three voices
1212                  for (int j=0; j<3; j++) {
# Line 1255 | Line 1246 | void DigitalRenderer::calc_buffer(int16
1246                          envelope = (v->eg_level * master_volume) >> 20;
1247  
1248                          // Waveform generator
1249 +                        if (v->mute)
1250 +                                continue;
1251                          uint16 output;
1252  
1253                          if (!v->test)
# Line 1335 | Line 1328 | void DigitalRenderer::calc_buffer(int16
1328                  }
1329  
1330                  // Write to buffer
1331 < #ifdef __BEOS__
1339 <                int16 audio_data = (sum_output + sum_output_filter) >> 10;
1340 <                int val = *buf + audio_data;
1341 <                if (val > 32767)
1342 <                        val = 32767;
1343 <                if (val < -32768)
1344 <                        val = -32768;
1345 <                *buf++ = val;
1346 <                val = *buf + audio_data;
1347 <                if (val > 32767)
1348 <                        val = 32767;
1349 <                if (val < -32768)
1350 <                        val = -32768;
1351 <                *buf++ = val;
1352 < #elif defined(__riscos__)       // lookup in 8k (13bit) translation table
1331 > #if defined(__riscos__) // lookup in 8k (13bit) translation table
1332                  *buf++ = LinToLog[((sum_output + sum_output_filter) >> 13) & 0x1fff];
1333   #else
1334                  *buf++ = (sum_output + sum_output_filter) >> 10;
# Line 1365 | Line 1344 | void DigitalRenderer::calc_buffer(int16
1344   #elif defined(AMIGA)
1345   #include "SID_Amiga.h"
1346  
1347 + #elif defined(HAVE_SDL)
1348 + #include "SID_SDL.h"
1349 + # if defined(__linux__)
1350 + # include "SID_catweasel.h"
1351 + # endif
1352 +
1353   #elif defined(__linux__)
1354   #include "SID_linux.h"
1355 + #include "SID_catweasel.h"
1356  
1357   #elif defined(SUN)
1358   #include "SID_sun.h"
# Line 1405 | Line 1391 | void MOS6581::open_close_renderer(int ol
1391          delete the_renderer;
1392  
1393          // Create new renderer
1394 <        if (new_type == SIDTYPE_DIGITAL)
1409 < #if defined(__BEOS__) || defined(__riscos__)
1394 >        if (new_type == SIDTYPE_DIGITAL) {
1395                  the_renderer = new DigitalRenderer(the_c64);
1411 – #else
1412 –                the_renderer = new DigitalRenderer();
1413 – #endif
1396   #ifdef AMIGA
1397 <        else if (new_type == SIDTYPE_SIDCARD)
1398 <                the_renderer = new SIDCardRenderer();
1397 >        } else if (new_type == SIDTYPE_SIDCARD) {
1398 >                the_renderer = new SIDCardRenderer;
1399   #endif
1400 <        else
1400 > #ifdef __linux__
1401 >        } else if (new_type == SIDTYPE_SIDCARD) {
1402 >                the_renderer = new CatweaselRenderer;
1403 > #endif
1404 >        } else {
1405                  the_renderer = NULL;
1406 +        }
1407  
1408          // Stuff the current register values into the new renderer
1409          if (the_renderer != NULL)

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines