view src/adplug/core/bmf.cxx @ 166:a118245b88c7 trunk

[svn] - use a quantized variance instead of a fast fft sum for beat detection with thresholding

/*
 * Adplug - Replayer for many OPL2/OPL3 audio file formats.
 * Copyright (C) 1999 - 2003, 2006 Simon Peter, <[e-mail]>, et al.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * [xad] BMF player, by Riven the Mage <[e-mail]>
 */

/*
    - discovery -

  file(s) : GAMESNET.COM
     type : GamesNet advertising intro
     tune : by (?)The Brain [Razor 1911]
   player : ver.0.9b by Hammer

  file(s) : 2FAST4U.COM
     type : Ford Knox BBStro
     tune : by The Brain [Razor 1911]
   player : ver.1.1 by ?
  comment : in original player at 9th channel the feedback adlib register is not C8 but C6.

  file(s) : DATURA.COM
     type : Datura BBStro
     tune : by The Brain [Razor 1911]
   player : ver.1.2 by ?
  comment : inaccurate replaying, because constant outport; in original player it can be 380 or 382.
*/

#include "bmf.h"
#include "debug.h"

const unsigned char CxadbmfPlayer::bmf_adlib_registers[117] =
{
  0x20, 0x23, 0x40, 0x43, 0x60, 0x63, 0x80, 0x83, 0xA0, 0xB0, 0xC0, 0xE0, 0xE3,
  0x21, 0x24, 0x41, 0x44, 0x61, 0x64, 0x81, 0x84, 0xA1, 0xB1, 0xC1, 0xE1, 0xE4,
  0x22, 0x25, 0x42, 0x45, 0x62, 0x65, 0x82, 0x85, 0xA2, 0xB2, 0xC2, 0xE2, 0xE5,
  0x28, 0x2B, 0x48, 0x4B, 0x68, 0x6B, 0x88, 0x8B, 0xA3, 0xB3, 0xC3, 0xE8, 0xEB,
  0x29, 0x2C, 0x49, 0x4C, 0x69, 0x6C, 0x89, 0x8C, 0xA4, 0xB4, 0xC4, 0xE9, 0xEC,
  0x2A, 0x2D, 0x4A, 0x4D, 0x6A, 0x6D, 0x8A, 0x8D, 0xA5, 0xB5, 0xC5, 0xEA, 0xED,
  0x30, 0x33, 0x50, 0x53, 0x70, 0x73, 0x90, 0x93, 0xA6, 0xB6, 0xC6, 0xF0, 0xF3,
  0x31, 0x34, 0x51, 0x54, 0x71, 0x74, 0x91, 0x94, 0xA7, 0xB7, 0xC7, 0xF1, 0xF4,
  0x32, 0x35, 0x52, 0x55, 0x72, 0x75, 0x92, 0x95, 0xA8, 0xB8, 0xC8, 0xF2, 0xF5
};

const unsigned short CxadbmfPlayer::bmf_notes[12] =
{
  0x157, 0x16B, 0x181, 0x198, 0x1B0, 0x1CA, 0x1E5, 0x202, 0x220, 0x241, 0x263, 0x287
};

/* for 1.1 */
const unsigned short CxadbmfPlayer::bmf_notes_2[12] =
{
  0x159, 0x16D, 0x183, 0x19A, 0x1B2, 0x1CC, 0x1E8, 0x205, 0x223, 0x244, 0x267, 0x28B
};

const unsigned char CxadbmfPlayer::bmf_default_instrument[13] =
{
  0x01, 0x01, 0x3F, 0x3F, 0x00, 0x00, 0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00
};

CPlayer *CxadbmfPlayer::factory(Copl *newopl)
{
  return new CxadbmfPlayer(newopl);
}

bool CxadbmfPlayer::xadplayer_load()
{
  unsigned short ptr = 0;
  int i;

  if(xad.fmt != BMF)
    return false;

#ifdef DEBUG
  AdPlug_LogWrite("\nbmf_load():\n\n");
#endif
  if (!strncmp((char *)&tune[0],"BMF1.2",6))
  {
    bmf.version = BMF1_2;
    bmf.timer = 70.0f;
  }
  else if (!strncmp((char *)&tune[0],"BMF1.1",6))
  {
    bmf.version = BMF1_1;
    bmf.timer = 60.0f;
  }
  else
  {
    bmf.version = BMF0_9B;
    bmf.timer = 18.2f;
  }

  // copy title & author
  if (bmf.version > BMF0_9B)
  {
    ptr = 6;

    strncpy(bmf.title,(char *)&tune[ptr],36);

    while (tune[ptr]) { ptr++; }
	ptr++;

    strncpy(bmf.author,(char *)&tune[ptr],36);

    while (tune[ptr]) { ptr++; }
	ptr++;
  }
  else
  {
    strncpy(bmf.title,xad.title,36);
    strncpy(bmf.author,xad.author,36);
  }

  // speed
  if (bmf.version > BMF0_9B)
    bmf.speed = tune[ptr++];
  else
    bmf.speed = ((tune[ptr++] << 8) / 3) >> 8; // strange, yeh ?

  // load instruments
  if (bmf.version > BMF0_9B)
  {
    unsigned long iflags = (tune[ptr] << 24) | (tune[ptr+1] << 16) | (tune[ptr+2] << 8) | tune[ptr+3];
    ptr+=4;

    for(i=0;i<32;i++)
      if (iflags & (1 << (31-i)))
	  {
        strcpy(bmf.instruments[i].name, (char *)&tune[ptr]);
        memcpy(bmf.instruments[i].data, &tune[ptr+11], 13);
        ptr += 24;
	  }
      else
	  {
        bmf.instruments[i].name[0] = 0;
		
        if (bmf.version == BMF1_1)
		  for(int j=0;j<13;j++)
			bmf.instruments[i].data[j] = bmf_default_instrument[j];
        else
		  for(int j=0;j<13;j++)
			bmf.instruments[i].data[j] = 0;
	  }
  }
  else
  {
    ptr = 6;

    for(i=0;i<32;i++)
    {
      bmf.instruments[i].name[0] = 0;
      memcpy(bmf.instruments[tune[ptr]].data, &tune[ptr+2],13); // bug no.1 (no instrument-table-end detection)
      ptr+=15;
    }
  }
  
  // load streams
  if (bmf.version > BMF0_9B)
  {
    unsigned long sflags = (tune[ptr] << 24) | (tune[ptr+1] << 16) | (tune[ptr+2] << 8) | tune[ptr+3];
    ptr+=4;

    for(i=0;i<9;i++)
      if (sflags & (1 << (31-i)))
        ptr+=__bmf_convert_stream(&tune[ptr],i);
      else
        bmf.streams[i][0].cmd = 0xFF;
  }
  else
  {
    for(i=0;i<tune[5];i++)
      ptr+=__bmf_convert_stream(&tune[ptr],i);

	for(i=tune[5];i<9;i++)
      bmf.streams[i][0].cmd = 0xFF;
  }

  return true;
}

void CxadbmfPlayer::xadplayer_rewind(int subsong)
{
  int i,j;

  for(i=0; i<9; i++)
  {
    bmf.channel[i].stream_position = 0;
    bmf.channel[i].delay = 0;
    bmf.channel[i].loop_position = 0;
    bmf.channel[i].loop_counter = 0;
  }

  plr.speed = bmf.speed;
#ifdef DEBUG
  AdPlug_LogWrite("speed: %x\n",plr.speed);
#endif

  bmf.active_streams = 9;

  // OPL initialization
  if (bmf.version > BMF0_9B)
  {
    opl_write(0x01, 0x20);
    
    /* 1.1 */
    if (bmf.version == BMF1_1)
      for(i=0;i<9;i++)
        for(j=0;j<13;j++)
          opl_write(bmf_adlib_registers[13*i+j], bmf_default_instrument[j]);
    /* 1.2 */
    else if (bmf.version == BMF1_2)
      for(i=0x20; i<0x100; i++)
        opl_write(i,0xFF); // very interesting, really!
  }

  /* ALL */

  opl_write(0x08, 0x00);
  opl_write(0xBD, 0xC0);
}

void CxadbmfPlayer::xadplayer_update()
{
  for(int i=0;i<9;i++)
    if (bmf.channel[i].stream_position != 0xFFFF)
    if (bmf.channel[i].delay)
      bmf.channel[i].delay--;
	else
	{
#ifdef DEBUG
   AdPlug_LogWrite("channel %02X:\n", i);
#endif
      bmf_event event;

      // process so-called cross-events
  	  while (true)
	  {
        memcpy(&event, &bmf.streams[i][bmf.channel[i].stream_position], sizeof(bmf_event));
#ifdef DEBUG
   AdPlug_LogWrite("%02X %02X %02X %02X %02X %02X\n",
		   event.note,event.delay,event.volume,event.instrument,
		   event.cmd,event.cmd_data);
#endif

        if (event.cmd == 0xFF)
		{
          bmf.channel[i].stream_position = 0xFFFF;
          bmf.active_streams--;
          break;
		}
        else if (event.cmd == 0xFE)
		{
          bmf.channel[i].loop_position = bmf.channel[i].stream_position+1;
          bmf.channel[i].loop_counter = event.cmd_data;
		}
        else if (event.cmd == 0xFD)
		{
          if (bmf.channel[i].loop_counter)
          {
            bmf.channel[i].stream_position = bmf.channel[i].loop_position-1;
            bmf.channel[i].loop_counter--;
          }
		}
        else
          break;

        bmf.channel[i].stream_position++;
	  } // while (true)

      // process normal event
      unsigned short pos = bmf.channel[i].stream_position;

      if (pos != 0xFFFF)
      {
        bmf.channel[i].delay = bmf.streams[i][pos].delay;

        // command ?
        if (bmf.streams[i][pos].cmd)
		{
          unsigned char cmd = bmf.streams[i][pos].cmd;

          // 0x01: Set Modulator Volume
          if (cmd == 0x01)
		  {
            unsigned char reg = bmf_adlib_registers[13*i+2];

            opl_write(reg, (adlib[reg] | 0x3F) - bmf.streams[i][pos].cmd_data);
		  }
          // 0x10: Set Speed
		  else if (cmd == 0x10)
		  {
            plr.speed = bmf.streams[i][pos].cmd_data;
		    plr.speed_counter = plr.speed;
		  }
		} // if (bmf.streams[i][pos].cmd)

        // instrument ?
        if (bmf.streams[i][pos].instrument)
		{
          unsigned char ins = bmf.streams[i][pos].instrument-1;

          if (bmf.version != BMF1_1)
            opl_write(0xB0+i, adlib[0xB0+i] & 0xDF);

          for(int j=0;j<13;j++)
            opl_write(bmf_adlib_registers[i*13+j], bmf.instruments[ins].data[j]);
		} // if (bmf.streams[i][pos].instrument)

        // volume ?
        if (bmf.streams[i][pos].volume)
		{
          unsigned char vol = bmf.streams[i][pos].volume-1;
          unsigned char reg = bmf_adlib_registers[13*i+3];

          opl_write(reg, (adlib[reg] | 0x3F) - vol);
		} // if (bmf.streams[i][pos].volume)

	    // note ?
        if (bmf.streams[i][pos].note)
		{
          unsigned short note = bmf.streams[i][pos].note;
          unsigned short freq = 0;

          // mute channel
          opl_write(0xB0+i, adlib[0xB0+i] & 0xDF);

          // get frequency
          if (bmf.version == BMF1_1)
          {
            if (note <= 0x60)
              freq = bmf_notes_2[--note % 12];
          }
          else
		  {
            if (note != 0x7F)
              freq = bmf_notes[--note % 12];
		  }

          // play note
		  if (freq)
          {
            opl_write(0xB0+i, (freq >> 8) | ((note / 12) << 2) | 0x20);
            opl_write(0xA0+i, freq & 0xFF);
          }
		} // if (bmf.streams[i][pos].note)

        bmf.channel[i].stream_position++;
      } // if (pos != 0xFFFF)

	} // if (!bmf.channel[i].delay)

  // is module loop ?
  if (!bmf.active_streams)
  {
    for(int j=0;j<9;j++)
      bmf.channel[j].stream_position = 0;

	bmf.active_streams = 9;

    plr.looping = 1;
  }
}

float CxadbmfPlayer::xadplayer_getrefresh()
{
  return bmf.timer;
}

std::string CxadbmfPlayer::xadplayer_gettype()
{
  return std::string("xad: BMF Adlib Tracker");
}

std::string CxadbmfPlayer::xadplayer_gettitle()
{
  return std::string(bmf.title);
}

std::string CxadbmfPlayer::xadplayer_getauthor()
{
  return std::string(bmf.author);
}

unsigned int CxadbmfPlayer::xadplayer_getinstruments()
{
  return 32;
}

std::string CxadbmfPlayer::xadplayer_getinstrument(unsigned int i)
{
  return std::string(bmf.instruments[i].name);
}

/* -------- Internal Functions ---------------------------- */

int CxadbmfPlayer::__bmf_convert_stream(unsigned char *stream, int channel)
{
#ifdef DEBUG
  AdPlug_LogWrite("channel %02X (note,delay,volume,instrument,command,command_data):\n",channel);
  unsigned char *last = stream;
#endif
  unsigned char *stream_start = stream;

  int pos = 0;

  while (true)
  {
    memset(&bmf.streams[channel][pos], 0, sizeof(bmf_event));

    bool is_cmd = false;

    if (*stream == 0xFE)
	{
      // 0xFE -> 0xFF: End of Stream
      bmf.streams[channel][pos].cmd = 0xFF;

	  stream++;

      break;
	}
    else if (*stream == 0xFC)
	{
      // 0xFC -> 0xFE xx: Save Loop Position
      bmf.streams[channel][pos].cmd = 0xFE;
      bmf.streams[channel][pos].cmd_data = (*(stream+1) & ((bmf.version == BMF0_9B) ? 0x7F : 0x3F)) - 1;

	  stream+=2;
    }
    else if (*stream == 0x7D)
	{
      // 0x7D -> 0xFD: Loop Saved Position
      bmf.streams[channel][pos].cmd = 0xFD;

	  stream++;
	}
	else
    {
      if (*stream & 0x80)                           
      {
		if (*(stream+1) & 0x80)
        {
		  if (*(stream+1) & 0x40)
          {
            // byte0: 1aaaaaaa = NOTE
            bmf.streams[channel][pos].note = *stream & 0x7F;
            // byte1: 11bbbbbb = DELAY
            bmf.streams[channel][pos].delay = *(stream+1) & 0x3F;
            // byte2: cccccccc = COMMAND

            stream+=2;

            is_cmd = true;
          }
		  else
          {
            // byte0: 1aaaaaaa = NOTE
            bmf.streams[channel][pos].note = *stream & 0x7F;
            // byte1: 11bbbbbb = DELAY
            bmf.streams[channel][pos].delay = *(stream+1) & 0x3F;

			stream+=2;
          } // if (*(stream+1) & 0x40)
		}
        else
        {
          // byte0: 1aaaaaaa = NOTE
          bmf.streams[channel][pos].note = *stream & 0x7F;
          // byte1: 0bbbbbbb = COMMAND

          stream++;

          is_cmd = true;
        } // if (*(stream+1) & 0x80)
	  }
	  else
      {
        // byte0: 0aaaaaaa = NOTE
        bmf.streams[channel][pos].note = *stream & 0x7F;

		stream++;
      } // if (*stream & 0x80)
    } // if (*stream == 0xFE)

	// is command ?
    if (is_cmd)
    {

      /* ALL */

      if ((0x20 <= *stream) && (*stream <= 0x3F))
      {
        // 0x20 or higher; 0x3F or lower: Set Instrument 
        bmf.streams[channel][pos].instrument = *stream - 0x20 + 1;

		stream++;
      }
      else if (0x40 <= *stream)
      {
        // 0x40 or higher: Set Volume
        bmf.streams[channel][pos].volume = *stream - 0x40 + 1;

		stream++;
      }
      else
      {

        /* 0.9b */

        if (bmf.version == BMF0_9B)
        if (*stream < 0x20)
		{
          // 0x1F or lower: ?
		  stream++;
		}

        /* 1.2 */

        if (bmf.version == BMF1_2)
        if (*stream == 0x01)
		{
          // 0x01: Set Modulator Volume -> 0x01
          bmf.streams[channel][pos].cmd = 0x01;
          bmf.streams[channel][pos].cmd_data = *(stream+1);

		  stream+=2;
		}
        else if (*stream == 0x02)
		{
          // 0x02: ?
		  stream+=2;
		}
        else if (*stream == 0x03)
		{
          // 0x03: ?
		  stream+=2;
		}
        else if (*stream == 0x04)
		{
          // 0x04: Set Speed -> 0x10
          bmf.streams[channel][pos].cmd = 0x10;
          bmf.streams[channel][pos].cmd_data = *(stream+1);

          stream+=2;
		}
        else if (*stream == 0x05)
		{
          // 0x05: Set Carrier Volume (port 380)
          bmf.streams[channel][pos].volume = *(stream+1) + 1;

		  stream+=2;
		}
        else if (*stream == 0x06)
		{
          // 0x06: Set Carrier Volume (port 382)
          bmf.streams[channel][pos].volume = *(stream+1) + 1;

		  stream+=2;
		} // if (bmf.version == BMF1_2)

      } // if ((0x20 <= *stream) && (*stream <= 0x3F))

    } // if (is_cmd)

#ifdef DEBUG
   AdPlug_LogWrite("%02X %02X %02X %02X %02X %02X  <----  ", 
			bmf.streams[channel][pos].note,	
			bmf.streams[channel][pos].delay,
			bmf.streams[channel][pos].volume, 
			bmf.streams[channel][pos].instrument,
			bmf.streams[channel][pos].cmd, 
			bmf.streams[channel][pos].cmd_data
		   );
   for(int zz=0;zz<(stream-last);zz++)
     AdPlug_LogWrite("%02X ",last[zz]);
   AdPlug_LogWrite("\n");
   last=stream;
#endif
    pos++;
  } // while (true)

  return (stream - stream_start);
}