Ticket #8257: adlib-sfx.diff

File adlib-sfx.diff, 26.5 KB (added by SF/hoenicke, 21 years ago)

Patch against 12.08 CVS with working distaff tunes

  • backends/midi/adlib.cpp 

    RCS file: /cvsroot/scummvm/scummvm/backends/midi/adlib.cpp,v
retrieving revision 1.43
diff -u -r1.43 adlib.cpp
     
    618618        void mc_init_stuff(AdlibVoice *voice, Struct10 * s10, Struct11 * s11, byte flags,
    619619                           InstrumentExtra * ie);
    620620
    621         static void struct10_init(Struct10 * s10, InstrumentExtra * ie);
     621        void struct10_init(Struct10 * s10, InstrumentExtra * ie);
    622622        static byte struct10_ontimer(Struct10 * s10, Struct11 * s11);
    623623        static void struct10_setup(Struct10 * s10);
    624624        static int random_nr(int a);
    … …  
    644644}
    645645
    646646void AdlibPart::noteOff(byte note) {
     647  debug (4, "%10d: noteOff(%d)", tick, note);
    647648        _owner->part_key_off(this, note);
    648649}
    649650
    650651void AdlibPart::noteOn(byte note, byte velocity) {
     652  debug (4, "%10d: noteOn(%d,%d)", tick, note, velocity);
    651653        _owner->part_key_on(this, &_part_instr, note, velocity);
    652654}
    653655
    … …  
    982984void MidiDriver_ADLIB::adlib_write(byte port, byte value) {
    983985        if (_adlib_reg_cache[port] == value)
    984986                return;
     987  debug (4, "%10d: adlib_write[%x] = %x", tick, port, value);
    985988        _adlib_reg_cache[port] = value;
    986989
    987990        OPLWriteReg(_opl, port, value);
    … …  
    9981001
    9991002                _next_tick -= step;
    10001003                if (!_next_tick) {
    1001                         tick++;
    10021004                        if (_timer_proc)
    10031005                                (*_timer_proc)(_timer_param);
    10041006                        on_timer();
    … …  
    10211023        while (_adlib_timer_counter >= 0x411B) {
    10221024                _adlib_timer_counter -= 0x411B;
    10231025                voice = _voices;
     1026                tick++;
    10241027                for (i = 0; i != ARRAYSIZE(_voices); i++, voice++) {
    10251028                        if (!voice->_part)
    10261029                                continue;
    … …  
    10641067                switch (s11->param) {
    10651068                case 0:
    10661069                        voice->_vol_2 = s10->start_value + s11->modify_val;
    1067                         adlib_set_param(voice->_channel, 0,
    1068                                                                                         volume_table[lookup_table[voice->_vol_2]
    1069                                                                                         [part->_vol_eff >> 2]]);
     1070                        if (!_game_SmallHeader) {
     1071                                adlib_set_param(voice->_channel, 0,
     1072                                                                                                volume_table[lookup_table[voice->_vol_2]
     1073                                                                                                                                                 [part->_vol_eff >> 2]]);
     1074                        } else {
     1075                                adlib_set_param(voice->_channel, 0, voice->_vol_2);
     1076                        }
    10701077                        break;
    10711078                case 13:
    10721079                        voice->_vol_1 = s10->start_value + s11->modify_val;
    1073                         if (voice->_twochan) {
     1080                        if (voice->_twochan && !_game_SmallHeader) {
    10741081                                adlib_set_param(voice->_channel, 13,
    10751082                                                                                                volume_table[lookup_table[voice->_vol_1]
    10761083                                                                                                [part->_vol_eff >> 2]]);
    … …  
    13521359        if (voice->_duration != 0)
    13531360                voice->_duration *= 63;
    13541361
    1355         vol_1 = (instr->oplvl_1 & 0x3F) + lookup_table[velocity >> 1][instr->waveform_1 >> 2];
     1362        if (!_game_SmallHeader)
     1363                vol_1 = (instr->oplvl_1 & 0x3F) + lookup_table[velocity >> 1][instr->waveform_1 >> 2];
     1364        else
     1365                vol_1 = 0x3f - (instr->oplvl_1 & 0x3F);
    13561366        if (vol_1 > 0x3F)
    13571367                vol_1 = 0x3F;
    13581368        voice->_vol_1 = vol_1;
    13591369
    1360         vol_2 = (instr->oplvl_2 & 0x3F) + lookup_table[velocity >> 1][instr->waveform_2 >> 2];
     1370        if (!_game_SmallHeader)
     1371                vol_2 = (instr->oplvl_2 & 0x3F) + lookup_table[velocity >> 1][instr->waveform_2 >> 2];
     1372        else
     1373                vol_2 = 0x3f - (instr->oplvl_2 & 0x3F);
    13611374        if (vol_2 > 0x3F)
    13621375                vol_2 = 0x3F;
    13631376        voice->_vol_2 = vol_2;
    13641377
    13651378        c = part->_vol_eff >> 2;
    13661379
    1367         vol_2 = volume_table[lookup_table[vol_2][c]];
    1368         if (voice->_twochan)
    1369                 vol_1 = volume_table[lookup_table[vol_1][c]];
     1380        if (!_game_SmallHeader) {
     1381                vol_2 = volume_table[lookup_table[vol_2][c]];
     1382                if (voice->_twochan)
     1383                        vol_1 = volume_table[lookup_table[vol_1][c]];
     1384        }
    13701385
    13711386        adlib_setup_channel(voice->_channel, instr, vol_1, vol_2);
    13721387        adlib_note_on_ex(voice->_channel, part->_transpose_eff + note, part->_detune_eff + (part->_pitchbend * part->_pitchbend_factor >> 6));
    … …  
    13911406
    13921407        port = channel_mappings[chan];
    13931408        adlib_write(port + 0x20, instr->flags_1);
    1394 
    1395         if (!_game_SmallHeader)
    1396                 adlib_write(port + 0x40, (instr->oplvl_1 | 0x3F) - vol_1 );
    1397         else
    1398                 adlib_write(port + 0x40, instr->oplvl_1);
    1399 
     1409        adlib_write(port + 0x40, (instr->oplvl_1 | 0x3F) - vol_1 );
    14001410        adlib_write(port + 0x60, 0xff & (~instr->atdec_1));
    14011411        adlib_write(port + 0x80, 0xff & (~instr->sustrel_1));
    14021412        adlib_write(port + 0xE0, instr->waveform_1);
    14031413
    14041414        port = channel_mappings_2[chan];
    14051415        adlib_write(port + 0x20, instr->flags_2);
    1406         if (!_game_SmallHeader)
    1407                 adlib_write(port + 0x40, (instr->oplvl_2 | 0x3F) - vol_2 );
    1408         else
    1409                 adlib_write(port + 0x40, instr->oplvl_2 );
     1416        adlib_write(port + 0x40, (instr->oplvl_2 | 0x3F) - vol_2 );
    14101417        adlib_write(port + 0x60, 0xff & (~instr->atdec_2));
    14111418        adlib_write(port + 0x80, 0xff & (~instr->sustrel_2));
    14121419        adlib_write(port + 0xE0, instr->waveform_2);
    … …  
    14641471
    14651472void MidiDriver_ADLIB::struct10_init(Struct10 *s10, InstrumentExtra *ie) {
    14661473        s10->active = 1;
    1467         s10->cur_val = 0;
     1474        if (!_game_SmallHeader) {
     1475                s10->cur_val = 0;
     1476        } else {
     1477                s10->cur_val = s10->start_value;
     1478                s10->start_value = 0;
     1479        }
    14681480        s10->modwheel_last = 31;
    14691481        s10->count = ie->a;
    14701482        if (s10->count)

  • scumm/resource.cpp 

    cvs server: Diffing backends/morphos
cvs server: Diffing backends/null
cvs server: Diffing backends/sdl
cvs server: Diffing backends/wince
cvs server: Diffing backends/wince/icons
cvs server: Diffing backends/wince/missing
cvs server: Diffing backends/wince/missing/sys
cvs server: Diffing backends/wince/scumm
cvs server: Diffing backends/wince/scummvm
cvs server: Diffing backends/wince/simon
cvs server: Diffing backends/wince/sky
cvs server: Diffing backends/x11
cvs server: Diffing bs2
cvs server: Diffing bs2/driver
cvs server: Diffing common
cvs server: Diffing dists
cvs server: Diffing dists/debian
cvs server: Diffing dists/redhat
cvs server: Diffing gui
cvs server: Diffing scumm
RCS file: /cvsroot/scummvm/scummvm/scumm/resource.cpp,v
retrieving revision 1.118
diff -u -r1.118 resource.cpp
     
    641641        _fileHandle.seek(fileOffs + _fileOffset, SEEK_SET);
    642642
    643643        if (_features & GF_OLD_BUNDLE) {
    644                 size = _fileHandle.readUint16LE();
    645                 _fileHandle.seek(-2, SEEK_CUR);
     644                if ((_version == 3) && !(_features & GF_AMIGA) && (type == rtSound)) {
     645                        return readSoundResourceSmallHeader(type, idx);
     646                } else {
     647                        size = _fileHandle.readUint16LE();
     648                        _fileHandle.seek(-2, SEEK_CUR);
     649                }
    646650        } else if (_features & GF_SMALL_HEADER) {
    647651                if (!(_features & GF_SMALL_NAMES))
    648652                        _fileHandle.seek(8, SEEK_CUR);
    … …  
    895899        0x00, 0x00, 0x07, 0x0f, 0x00, 0x00, 0x08, 0x00,
    896900        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0xf7,
    897901        0x04, 0xf0, 0x41, 0x7d, 0x10,  // sysex 16: set instrument
    898         0x00,                          // part/channel  (offset 28)
    899         0x01, 0x06, 0x02, 0x0a, 0x08, 0x09, 0x0d, 0x08, 0x04, 0x04,
    900         0x04, 0x06, 0x02, 0x02, 0x03, 0x07, 0x0f, 0x0d,
    901         0x05, 0x04, 0x0c, 0x00, 0x03, 0x01, 0x01, 0x00,
    902         0x00, 0x00, 0x01, 0x01, 0x0e, 0x00, 0x02, 0x02,
    903         0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x01,
    904         0x08, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x00,
    905         0x06, 0x02, 0x00, 0x00, 0x04, 0x00, 0x03, 0x02,
    906         0x04, 0x00, 0x00, 0xf7,
     902        0x00, 0x01,                    // part/channel  (offset 28)
     903        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     904        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     905        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     906        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     907        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     908        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     909        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     910        0x00, 0x00, 0xf7,
    907911        0x00, 0xb0, 0x07, 0x64        // Controller 7 = 100 (offset 92)
    908912};
    909913                       
    910 int Scumm::convertADResource(int type, int idx, byte * src_ptr, int size) {
     914static const byte map_param[7] = {
     915        0, 2, 3, 4, 8, 9, 0,
     916};
    911917
    912         byte * ptr;
    913         byte ticks, play_once;
    914         byte music_type, num_instr;
    915         byte *channel, *instr, *track;
    916         int i, ch;
     918static const byte freq2note[128] = {
     919        /*128*/ 6, 6, 6, 6, 
     920        /*132*/ 7, 7, 7, 7, 7, 7, 7,
     921        /*139*/ 8, 8, 8, 8, 8, 8, 8, 8, 8,
     922        /*148*/ 9, 9, 9, 9, 9, 9, 9, 9, 9,
     923        /*157*/ 10, 10, 10, 10, 10, 10, 10, 10, 10,
     924        /*166*/ 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
     925        /*176*/ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
     926        /*186*/ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
     927        /*197*/ 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
     928        /*209*/ 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
     929        /*222*/ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
     930        /*235*/ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
     931        /*249*/ 18, 18, 18, 18, 18, 18, 18
     932};
     933                       
     934static const uint16 num_steps_table[] = {
     935        1, 2, 4, 5,
     936        6, 7, 8, 9,
     937        10, 12, 14, 16,
     938        18, 21, 24, 30,
     939        36, 50, 64, 82,
     940        100, 136, 160, 192,
     941        240, 276, 340, 460,
     942        600, 860, 1200, 1600
     943};
     944int Scumm::convert_extraflags(byte * ptr, byte * src_ptr) {
     945        int flags = src_ptr[0];
     946
     947        int t1, t2, t3, t4, time;
     948        int v1, v2, v3;
     949
     950        if (!(flags & 0x80))
     951                return -1;
     952
     953        t1 = (src_ptr[1] & 0xf0) >> 3;
     954        t2 = (src_ptr[2] & 0xf0) >> 3;
     955        t3 = (src_ptr[3] & 0xf0) >> 3 | (flags & 0x40 ? 0x80 : 0);
     956        t4 = (src_ptr[3] & 0x0f) << 1;
     957        v1 = (src_ptr[1] & 0x0f);
     958        v2 = (src_ptr[2] & 0x0f);
     959        v3 = 31;
     960        if ((flags & 0x7) == 0) {
     961          v1 = v1 + 31 + 8;
     962          v2 = v2 + 31 + 8;
     963        } else {
     964          v1 = v1 * 2 + 31;
     965          v2 = v2 * 2 + 31;
     966        }
    917967       
    918         src_ptr += 2;
    919         size -= 2;
    920         music_type = *(src_ptr);        // 0x80: is music; otherwise not.
    921         if (music_type != 0x80) {
    922                 // It's an SFX; we don't know how to handle those yet
    923                 debug(4, "Sound %d not played, format not yet supported", idx);
    924                 res.roomoffs[type][idx] = 0xFFFFFFFF;
    925                 return 0;
     968        /* flags a */
     969        if ((flags & 0x7) == 6)
     970                ptr[0] = 0;
     971        else {
     972                ptr[0] = (flags >> 4) & 0xb;
     973                ptr[1] = map_param[flags & 0x7];
    926974        }
    927975
    928         // The "speed" of the song
    929         ticks = *(src_ptr + 1);
    930        
    931         // Flag that tells us whether we should loop the song (0) or play it only once (1)
    932         play_once = *(src_ptr + 2);
    933        
    934         // Number of instruments used
    935         num_instr = *(src_ptr + 8);     // Normally 8
    936        
    937         // copy the pointer to instrument data
    938         channel = src_ptr + 9;
    939         instr   = src_ptr + 0x11;
     976        /* extra a */
     977        ptr[2] = 0;
     978        ptr[3] = 0;
     979        ptr[4] = t1 >> 4;
     980        ptr[5] = t1 & 0xf;
     981        ptr[6] = v1 >> 4;
     982        ptr[7] = v1 & 0xf;
     983        ptr[8] = t2 >> 4;
     984        ptr[9] = t2 & 0xf;
     985        ptr[10] = v2 >> 4;
     986        ptr[11] = v2 & 0xf;
     987        ptr[12] = t3 >> 4;
     988        ptr[13] = t3 & 0xf;
     989        ptr[14] = t4 >> 4;
     990        ptr[15] = t4 & 0xf;
     991        ptr[16] = v3 >> 4;
     992        ptr[17] = v3 & 0xf;
     993
     994        time = num_steps_table[t1] + num_steps_table[t2]
     995                + num_steps_table[t3 & 0x7f] + num_steps_table[t4];
     996        if (flags & 0x20) {
     997                int playtime = ((src_ptr[4] >> 4) & 0xf) * 118 +
     998                        (src_ptr[4] & 0xf) * 8;
     999                if (playtime > time)
     1000                        time = playtime;
     1001        }
     1002        /*
     1003        time = ((src_ptr[4] >> 4) & 0xf) * 118 +
     1004                (src_ptr[4] & 0xf) * 8;
     1005        */
     1006        return time;
     1007}
    9401008
    941         // skip over the rest of the header and copy the MIDI data into a buffer
    942         src_ptr  += 0x11 + 8 * 16;
    943         size -= 0x11 + 8 * 16;
     1009int Scumm::convertADResource(int type, int idx, byte * src_ptr, int size) {
    9441010
    945         CHECK_HEAP
    946                        
    947         track = src_ptr;
    948                        
     1011        byte * ptr;
     1012        byte ticks, play_once;
     1013        byte num_instr;
     1014        byte *channel, *instr, *track;
     1015        byte *tracks[3];
     1016        int delay, delay2, olddelay;
     1017        int i, ch;
    9491018        int total_size = 8 + 16 + 14 + 8 + 7 + 8*sizeof(ADLIB_INSTR_MIDI_HACK) + size;
    9501019        total_size += 24;       // Up to 24 additional bytes are needed for the jump sysex
    9511020
     1021        printf("Resource %d:\n", idx);
     1022        hexdump(src_ptr, size);
     1023
    9521024        ptr = createResource(type, idx, total_size);
     1025        byte *start_ptr = ptr;
    9531026        memcpy(ptr, "ADL ", 4); ptr += 4;
    9541027        uint32 dw = READ_BE_UINT32(&total_size);
    9551028        memcpy(ptr, &dw, 4); ptr += 4;
    … …  
    9731046        dw = READ_BE_UINT32(&total_size);
    9741047        memcpy(ptr, &dw, 4); ptr += 4;
    9751048
    976         // Conver the ticks into a MIDI tempo.
    977         dw = (500000 * 256) / ticks;
    978         debug(4, "  ticks = %d, speed = %ld", ticks, dw);
    979        
    980         // Write a tempo change SysEx
    981         memcpy(ptr, "\x00\xFF\x51\x03", 4); ptr += 4;
    982         *ptr++ = (byte)((dw >> 16) & 0xFF);
    983         *ptr++ = (byte)((dw >> 8) & 0xFF);
    984         *ptr++ = (byte)(dw & 0xFF);
    985                
    986         // Copy our hardcoded instrument table into it
    987         // Then, convert the instrument table as given in this song resource
    988         // And write it *over* the hardcoded table.
    989         // Note: we deliberately.
    990 
    991         /* now fill in the instruments */
    992         for (i = 0; i < num_instr; i++) {
    993                 ch = channel[i] - 1;
    994 
    995                 debug(4, "Sound %d: instrument %d on channel %d.",
    996                           idx, i, ch);
    997 
    998             memcpy(ptr, ADLIB_INSTR_MIDI_HACK,
    999                            sizeof(ADLIB_INSTR_MIDI_HACK));
    1000 
    1001                 ptr[5]  += ch;
    1002                 ptr[28] += ch;
    1003                 ptr[92] += ch;
    1004        
    1005                 /* flags_1 */
    1006                 ptr[30 + 0] = (instr[i * 16 + 3] >> 4) & 0xf;
    1007                 ptr[30 + 1] = instr[i * 16 + 3] & 0xf;
    1008                
    1009                 /* oplvl_1 */
    1010                 ptr[30 + 2] = (instr[i * 16 + 4] >> 4) & 0xf;
    1011                 ptr[30 + 3] = instr[i * 16 + 4] & 0xf;
    1012                
    1013                 /* atdec_1 */
    1014                 ptr[30 + 4] = ((~instr[i * 16 + 5]) >> 4) & 0xf;
    1015                 ptr[30 + 5] = (~instr[i * 16 + 5]) & 0xf;
    1016                
    1017                 /* sustrel_1 */
    1018                 ptr[30 + 6] = ((~instr[i * 16 + 6]) >> 4) & 0xf;
    1019                 ptr[30 + 7] = (~instr[i * 16 + 6]) & 0xf;
    1020                
    1021                 /* waveform_1 */
    1022                 ptr[30 + 8] = (instr[i * 16 + 7] >> 4) & 0xf;
    1023                 ptr[30 + 9] = instr[i * 16 + 7] & 0xf;
    1024                
    1025                 /* flags_2 */
    1026                 ptr[30 + 10] = (instr[i * 16 + 8] >> 4) & 0xf;
    1027                 ptr[30 + 11] = instr[i * 16 + 8] & 0xf;
    1028                
    1029                 /* oplvl_2 */
    1030                 ptr[30 + 12] = (instr[i * 16 + 9] >> 4) & 0xf;
    1031                 ptr[30 + 13] = instr[i * 16 + 9] & 0xf;
    1032                
    1033                 /* atdec_2 */
    1034                 ptr[30 + 14] = ((~instr[i * 16 + 10]) >> 4) & 0xf;
    1035                 ptr[30 + 15] = (~instr[i * 16 + 10]) & 0xf;
    1036                
    1037                 /* sustrel_2 */
    1038                 ptr[30 + 16] = ((~instr[i * 16 + 11]) >> 4) & 0xf;
    1039                 ptr[30 + 17] = (~instr[i * 16 + 11]) & 0xf;
    1040                
    1041                 /* waveform_2 */
    1042                 ptr[30 + 18] = (instr[i * 16 + 12] >> 4) & 0xf;
    1043                 ptr[30 + 19] = instr[i * 16 + 12] & 0xf;
    1044                
    1045                 /* feedback */
    1046                 ptr[30 + 20] = (instr[i * 16 + 2] >> 4) & 0xf;
    1047                 ptr[30 + 21] = instr[i * 16 + 2] & 0xf;
    1048                 ptr += sizeof(ADLIB_INSTR_MIDI_HACK);
     1049        src_ptr += 2;
     1050        size -= 2;
     1051
     1052        if (*src_ptr == 0x80) {
     1053                // 0x80: is music; otherwise not.
     1054
     1055                // The "speed" of the song
     1056                ticks = *(src_ptr + 1);
     1057               
     1058                // Flag that tells us whether we should loop the song (0) or play it only once (1)
     1059                play_once = *(src_ptr + 2);
     1060               
     1061                // Number of instruments used
     1062                num_instr = *(src_ptr + 8);     // Normally 8
     1063               
     1064                // copy the pointer to instrument data
     1065                channel = src_ptr + 9;
     1066                instr   = src_ptr + 0x11;
     1067               
     1068                // skip over the rest of the header and copy the MIDI data into a buffer
     1069                src_ptr  += 0x11 + 8 * 16;
     1070                size -= 0x11 + 8 * 16;
     1071
     1072                CHECK_HEAP
     1073                       
     1074                track = src_ptr;
     1075               
     1076                // Conver the ticks into a MIDI tempo.
     1077                dw = (500000 * 256) / ticks;
     1078                debug(4, "  ticks = %d, speed = %ld", ticks, dw);
     1079                       
     1080                // Write a tempo change SysEx
     1081                memcpy(ptr, "\x00\xFF\x51\x03", 4); ptr += 4;
     1082                *ptr++ = (byte)((dw >> 16) & 0xFF);
     1083                *ptr++ = (byte)((dw >> 8) & 0xFF);
     1084                *ptr++ = (byte)(dw & 0xFF);
     1085               
     1086                // Copy our hardcoded instrument table into it
     1087                // Then, convert the instrument table as given in this song resource
     1088                // And write it *over* the hardcoded table.
     1089                // Note: we deliberately.
     1090               
     1091                /* now fill in the instruments */
     1092                for (i = 0; i < num_instr; i++) {
     1093                        ch = channel[i] - 1;
     1094                       
     1095                        debug(4, "Sound %d: instrument %d on channel %d.",
     1096                                  idx, i, ch);
     1097                       
     1098                        memcpy(ptr, ADLIB_INSTR_MIDI_HACK,
     1099                                   sizeof(ADLIB_INSTR_MIDI_HACK));
     1100
     1101                        ptr[5]  += ch;
     1102                        ptr[28] += ch;
     1103                        ptr[92] += ch;
     1104                       
     1105                        /* flags_1 */
     1106                        ptr[30 + 0] = (instr[i * 16 + 3] >> 4) & 0xf;
     1107                        ptr[30 + 1] = instr[i * 16 + 3] & 0xf;
     1108                       
     1109                        /* oplvl_1 */
     1110                        ptr[30 + 2] = (instr[i * 16 + 4] >> 4) & 0xf;
     1111                        ptr[30 + 3] = instr[i * 16 + 4] & 0xf;
     1112                       
     1113                        /* atdec_1 */
     1114                        ptr[30 + 4] = ((~instr[i * 16 + 5]) >> 4) & 0xf;
     1115                        ptr[30 + 5] = (~instr[i * 16 + 5]) & 0xf;
     1116                       
     1117                        /* sustrel_1 */
     1118                        ptr[30 + 6] = ((~instr[i * 16 + 6]) >> 4) & 0xf;
     1119                        ptr[30 + 7] = (~instr[i * 16 + 6]) & 0xf;
     1120                       
     1121                        /* waveform_1 */
     1122                        ptr[30 + 8] = (instr[i * 16 + 7] >> 4) & 0xf;
     1123                        ptr[30 + 9] = instr[i * 16 + 7] & 0xf;
     1124                       
     1125                        /* flags_2 */
     1126                        ptr[30 + 10] = (instr[i * 16 + 8] >> 4) & 0xf;
     1127                        ptr[30 + 11] = instr[i * 16 + 8] & 0xf;
     1128                       
     1129                        /* oplvl_2 */
     1130                        ptr[30 + 12] = (instr[i * 16 + 9] >> 4) & 0xf;
     1131                        ptr[30 + 13] = instr[i * 16 + 9] & 0xf;
     1132                       
     1133                        /* atdec_2 */
     1134                        ptr[30 + 14] = ((~instr[i * 16 + 10]) >> 4) & 0xf;
     1135                        ptr[30 + 15] = (~instr[i * 16 + 10]) & 0xf;
     1136                       
     1137                        /* sustrel_2 */
     1138                        ptr[30 + 16] = ((~instr[i * 16 + 11]) >> 4) & 0xf;
     1139                        ptr[30 + 17] = (~instr[i * 16 + 11]) & 0xf;
     1140                       
     1141                        /* waveform_2 */
     1142                        ptr[30 + 18] = (instr[i * 16 + 12] >> 4) & 0xf;
     1143                        ptr[30 + 19] = instr[i * 16 + 12] & 0xf;
     1144                       
     1145                        /* feedback */
     1146                        ptr[30 + 20] = (instr[i * 16 + 2] >> 4) & 0xf;
     1147                        ptr[30 + 21] = instr[i * 16 + 2] & 0xf;
     1148                        ptr += sizeof(ADLIB_INSTR_MIDI_HACK);
     1149                }
     1150               
     1151                *ptr++ = 0;  // delay 0;
     1152               
     1153                // Now copy the actual music data
     1154                memcpy(ptr, track, size);
     1155                ptr += size;
     1156               
     1157                if (!play_once) {
     1158                        // The song is meant to be looped. We achieve this by inserting just
     1159                        // before the song end a jump to the song start. More precisely we abuse
     1160                        // a S&M sysex, "maybe_jump" to achieve this effect. We could also
     1161                        // use a set_loop sysex, but it's a bit longer, a little more complicated,
     1162                        // and has no advantage either.
     1163                       
     1164                        // First, find the track end
     1165                        byte *end = ptr;
     1166                        ptr -= size;
     1167                        for (; ptr < end; ptr++) {
     1168                                if (*ptr == 0xff && *(ptr + 1) == 0x2f)
     1169                                        break;
     1170                        }
     1171                        assert(ptr < end);
     1172                       
     1173                        // Now insert the jump. The jump offset is measured in ticks, and
     1174                        // each instrument definition spans 4 ticks... so we jump to tick
     1175                        // 8*4, although jumping to tick 0 would probably work fine, too.
     1176                        // Note: it's possible that some musics don't loop from the start...
     1177                        // in that case we'll have to figure out how the loop range is specified
     1178                        // and then how to handle it appropriately (if it's specified in
     1179                        // ticks, we are fine; but if it's a byte offset, it'll be nasty).
     1180                        const int jump_offset = 8 * 4;
     1181                        memcpy(ptr, "\xf0\x13\x7d\x30\00", 5); ptr += 5;        // maybe_jump
     1182                        memcpy(ptr, "\x00\x00", 2); ptr += 2;                   // cmd -> 0 means always jump
     1183                        memcpy(ptr, "\x00\x00\x00\x00", 4); ptr += 4;   // track -> there is only one track, 0
     1184                        memcpy(ptr, "\x00\x00\x00\x01", 4); ptr += 4;   // beat -> for now, 1 (first beat)
     1185                        // Ticks
     1186                        *ptr++ = (byte)((jump_offset >> 12) & 0x0F);
     1187                        *ptr++ = (byte)((jump_offset >> 8) & 0x0F);
     1188                        *ptr++ = (byte)((jump_offset >> 4) & 0x0F);
     1189                        *ptr++ = (byte)(jump_offset & 0x0F);
     1190                        memcpy(ptr, "\x00\xf7", 2); ptr += 2;   // sysex end marker
     1191                }
     1192                // Finally we reinsert the end of song sysex, just in case
     1193                memcpy(ptr, "\x00\xff\x2f\x00\x00", 5); ptr += 5;
     1194               
     1195                return 1;
    10491196        }
    1050        
    1051         *ptr++ = 0;  // delay 0;
    1052        
    1053         // Now copy the actual music data
    1054         memcpy(ptr, track, size);
    1055         ptr += size;
    1056        
    1057         if (!play_once) {
    1058                 // The song is meant to be looped. We achieve this by inserting just
    1059                 // before the song end a jump to the song start. More precisely we abuse
    1060                 // a S&M sysex, "maybe_jump" to achieve this effect. We could also
    1061                 // use a set_loop sysex, but it's a bit longer, a little more complicated,
    1062                 // and has no advantage either.
    1063                
    1064                 // First, find the track end
    1065                 byte *end = ptr;
    1066                 ptr -= size;
    1067                 for (; ptr < end; ptr++) {
    1068                         if (*ptr == 0xff && *(ptr + 1) == 0x2f)
     1197
     1198
     1199        /* This is a sfx resource.  First parse it quickly to find the parallel
     1200         * tracks.
     1201         */
     1202        byte current_instr[3][14];
     1203        int  current_note[3];
     1204        int track_time[3];
     1205
     1206        int track_ctr = 0;
     1207        byte chunk_type = 0;
     1208
     1209        for (i = 0; i < 3; i++) {
     1210                track_time[i] = -1;
     1211                current_note[i] = -1;
     1212        }
     1213        while (size > 0) {
     1214                tracks[track_ctr] = src_ptr;
     1215                track_time[track_ctr] = 0;
     1216                track_ctr++;
     1217                while (size > 0) {
     1218                        chunk_type = *(src_ptr);
     1219                        if (chunk_type == 1) {
     1220                                src_ptr += 15;
     1221                                size -= 15;
     1222                        } else if (chunk_type == 2) {
     1223                                src_ptr += 11;
     1224                                size -= 11;
     1225                        } else if (chunk_type == 0x80) {
     1226                                src_ptr ++;
     1227                                size --;
     1228                        } else {
    10691229                                break;
     1230                        }
     1231                }
     1232                if (chunk_type == 0xff)
     1233                        break;
     1234                src_ptr++;
     1235        }
     1236       
     1237        int curtime = 0;
     1238        for (;;) {
     1239                int mintime = -1;
     1240                ch = -1;
     1241                for (i = 0; i < 3; i++) {
     1242                        if (track_time[i] >= 0 &&
     1243                                (mintime == -1 || mintime > track_time[i])) {
     1244                                mintime = track_time[i];
     1245                                ch = i;
     1246                        }
     1247                }
     1248                if (mintime < 0)
     1249                        break;
     1250
     1251                src_ptr = tracks[ch];
     1252                chunk_type = *(src_ptr);
     1253
     1254
     1255                if (current_note[ch] >= 0) {
     1256                        delay = mintime - curtime;
     1257                        curtime = mintime;
     1258                        if (delay > 0x7f) {
     1259                                if (delay > 0x3fff) {
     1260                                        *ptr++ = (delay >> 14) | 0x80;
     1261                                        delay &= 0x3fff;
     1262                                }
     1263                                *ptr++ = (delay >> 7) | 0x80;
     1264                                delay &= 0x7f;
     1265                        }
     1266                        *ptr++ = delay;
     1267                        *ptr++ = 0x80 + ch; // key off channel;
     1268                        *ptr++ = current_note[ch];
     1269                        *ptr++ = 0;
     1270                        current_note[ch] = -1;
    10701271                }
    1071                 assert(ptr < end);
    10721272               
    1073                 // Now insert the jump. The jump offset is measured in ticks, and
    1074                 // each instrument definition spans 4 ticks... so we jump to tick
    1075                 // 8*4, although jumping to tick 0 would probably work fine, too.
    1076                 // Note: it's possible that some musics don't loop from the start...
    1077                 // in that case we'll have to figure out how the loop range is specified
    1078                 // and then how to handle it appropriately (if it's specified in
    1079                 // ticks, we are fine; but if it's a byte offset, it'll be nasty).
    1080                 const int jump_offset = 8 * 4;
    1081                 memcpy(ptr, "\xf0\x13\x7d\x30\00", 5); ptr += 5;        // maybe_jump
    1082                 memcpy(ptr, "\x00\x00", 2); ptr += 2;                   // cmd -> 0 means always jump
    1083                 memcpy(ptr, "\x00\x00\x00\x00", 4); ptr += 4;   // track -> there is only one track, 0
    1084                 memcpy(ptr, "\x00\x00\x00\x01", 4); ptr += 4;   // beat -> for now, 1 (first beat)
    1085                 // Ticks
    1086                 *ptr++ = (byte)((jump_offset >> 12) & 0x0F);
    1087                 *ptr++ = (byte)((jump_offset >> 8) & 0x0F);
    1088                 *ptr++ = (byte)((jump_offset >> 4) & 0x0F);
    1089                 *ptr++ = (byte)(jump_offset & 0x0F);
    1090                 memcpy(ptr, "\x00\xf7", 2); ptr += 2;   // sysex end marker
     1273
     1274                switch (chunk_type) {
     1275                case 1:
     1276                        /* Instrument definition */
     1277                        memcpy(current_instr[ch], src_ptr+1, 14);
     1278                        src_ptr += 15;
     1279                        break;
     1280
     1281                case 2:
     1282                        /* tone/parammodulation */
     1283                        memcpy(ptr, ADLIB_INSTR_MIDI_HACK,
     1284                                   sizeof(ADLIB_INSTR_MIDI_HACK));
     1285                       
     1286                        ptr[5]  += ch;
     1287                        ptr[28] += ch;
     1288                        ptr[92] += ch;
     1289
     1290                        /* flags_1 */
     1291                        ptr[30 + 0] = (current_instr[ch][3] >> 4) & 0xf;
     1292                        ptr[30 + 1] = current_instr[ch][3] & 0xf;
     1293                       
     1294                        /* oplvl_1 */
     1295                        ptr[30 + 2] = (current_instr[ch][4] >> 4) & 0xf;
     1296                        ptr[30 + 3] = current_instr[ch][4] & 0xf;
     1297                       
     1298                        /* atdec_1 */
     1299                        ptr[30 + 4] = ((~current_instr[ch][5]) >> 4) & 0xf;
     1300                        ptr[30 + 5] = (~current_instr[ch][5]) & 0xf;
     1301                       
     1302                        /* sustrel_1 */
     1303                        ptr[30 + 6] = ((~current_instr[ch][6]) >> 4) & 0xf;
     1304                        ptr[30 + 7] = (~current_instr[ch][6]) & 0xf;
     1305                               
     1306                        /* waveform_1 */
     1307                        ptr[30 + 8] = (current_instr[ch][7] >> 4) & 0xf;
     1308                        ptr[30 + 9] = current_instr[ch][7] & 0xf;
     1309                               
     1310                        /* flags_2 */
     1311                        ptr[30 + 10] = (current_instr[ch][8] >> 4) & 0xf;
     1312                        ptr[30 + 11] = current_instr[ch][8] & 0xf;
     1313                       
     1314                        /* oplvl_2 */
     1315                        ptr[30 + 12] = ((current_instr[ch][9]) >> 4) & 0xf;
     1316                        ptr[30 + 13] = (current_instr[ch][9]) & 0xf;
     1317                       
     1318                        /* atdec_2 */
     1319                        ptr[30 + 14] = ((~current_instr[ch][10]) >> 4) & 0xf;
     1320                        ptr[30 + 15] = (~current_instr[ch][10]) & 0xf;
     1321                       
     1322                        /* sustrel_2 */
     1323                        ptr[30 + 16] = ((~current_instr[ch][11]) >> 4) & 0xf;
     1324                        ptr[30 + 17] = (~current_instr[ch][11]) & 0xf;
     1325                       
     1326                        /* waveform_2 */
     1327                        ptr[30 + 18] = (current_instr[ch][12] >> 4) & 0xf;
     1328                        ptr[30 + 19] = current_instr[ch][12] & 0xf;
     1329                       
     1330                        /* feedback */
     1331                        ptr[30 + 20] = (current_instr[ch][2] >> 4) & 0xf;
     1332                        ptr[30 + 21] = current_instr[ch][2] & 0xf;
     1333
     1334                        delay = mintime - curtime;
     1335                        curtime = mintime;
     1336
     1337
     1338                       
     1339                        {
     1340                                delay = convert_extraflags(ptr + 30 + 22, src_ptr + 1);
     1341                                delay2 = convert_extraflags(ptr + 30 + 40, src_ptr + 6);
     1342                                debug(4, "delays: %d / %d", delay, delay2);
     1343                                if (delay2 >= 0 && delay2 < delay)
     1344                                        delay = delay2;
     1345                                if (delay == -1)
     1346                                        delay = 0;
     1347                        }
     1348                                                       
     1349                        /* duration */
     1350                        ptr[30 + 58] = 0; // ((delay * 17 / 63) >> 4) & 0xf;
     1351                        ptr[30 + 59] = 0; // (delay * 17 / 63) & 0xf;
     1352                               
     1353                        ptr += sizeof(ADLIB_INSTR_MIDI_HACK);
     1354
     1355                        olddelay = mintime - curtime;
     1356                        curtime = mintime;
     1357                        if (olddelay > 0x7f) {
     1358                                if (olddelay > 0x3fff) {
     1359                                        *ptr++ = (olddelay >> 14) | 0x80;
     1360                                        olddelay &= 0x3fff;
     1361                                }
     1362                                *ptr++ = (olddelay >> 7) | 0x80;
     1363                                olddelay &= 0x7f;
     1364                        }
     1365                        *ptr++ = olddelay;
     1366
     1367
     1368                        /* FIXME:  delay factor found by try and error */
     1369                        delay = (delay + 1) * 240 / 13;
     1370                       
     1371                        {
     1372                                int freq = ((current_instr[ch][1] & 3) << 8)
     1373                                        | current_instr[ch][0];
     1374                                freq <<= ((current_instr[ch][1] >> 2) & 7) + 1;
     1375                                int note = -11;
     1376                                while (freq >= 0x100) {
     1377                                        note += 12;
     1378                                        freq >>= 1;
     1379                                }
     1380                                debug(4, "Freq: %d (%x) Note: %d", freq, freq, note);
     1381                                if (freq < 0x80)
     1382                                        note = 0;
     1383                                else
     1384                                        note += freq2note[freq - 0x80];
     1385
     1386                                debug(4, "Note: %d", note);
     1387                                if (note < 0)
     1388                                    note = 0;
     1389                                else if (note > 127)
     1390                                    note = 127;
     1391                               
     1392                                // Insert a note on event
     1393                                *ptr++ = 0x90 + ch; // key on channel
     1394                                *ptr++ = note;
     1395                                *ptr++ = 63;
     1396                                current_note[ch] = note;
     1397                                track_time[ch] = curtime + delay;                               
     1398                        }
     1399                        src_ptr += 11;
     1400                        break;
     1401                       
     1402                case 0x80:
     1403                        track_time[ch] = -1;
     1404                        src_ptr ++;
     1405                        break;
     1406                       
     1407                default:
     1408                        track_time[ch] = -1;
     1409                }
     1410                tracks[ch] = src_ptr;
    10911411        }
    1092         // Finally we reinsert the end of song sysex, just in case
     1412
     1413        /* insert end of song sysex */
    10931414        memcpy(ptr, "\x00\xff\x2f\x00\x00", 5); ptr += 5;
    1094        
     1415
     1416        printf("Converted To:\n");
     1417        hexdump(start_ptr, ptr - start_ptr);
     1418                       
    10951419        return 1;
    10961420}
    10971421

  • scumm/scummvm.cpp 

    RCS file: /cvsroot/scummvm/scummvm/scumm/scummvm.cpp,v
retrieving revision 2.322
diff -u -r2.322 scummvm.cpp
     
    619619                _imuseDigital = new IMuseDigital(this);
    620620        } else if ((_features & GF_AMIGA) && (_features & GF_OLD_BUNDLE)) {
    621621                _playerV2 = NULL;
    622         } else if (_features & GF_OLD_BUNDLE) {
     622                _imuse = NULL;
     623                _imuseDigital = NULL;
     624        } else if (_version <= 2) {
    623625                if ((_version == 1) && (_gameId == GID_MANIAC))
    624626                        _playerV2 = NULL;
    625627                else
    626628                        _playerV2 = new Player_V2(this);
     629                _imuse = NULL;
     630                _imuseDigital = NULL;
    627631        } else {
    628632                _imuse = IMuse::create (syst, _mixer, detector->createMidi());
    629633                if (_imuse) {

  • scumm/sound.cpp 

    RCS file: /cvsroot/scummvm/scummvm/scumm/sound.cpp,v
retrieving revision 1.195
diff -u -r1.195 sound.cpp
     
    512512                return;
    513513        }
    514514
    515         if (_scumm->_features & GF_OLD_BUNDLE) {
     515        if (_scumm->_version <= 2) {
    516516                //TODO: support maniac v1 sounds
    517517                if ((_scumm->_version == 1) && (_scumm->_gameId == GID_MANIAC))
    518518                        return;