#include <stdio.h>
#include <i86.h>
#include <dos.h>
#include <conio.h>
#include <mem.h>

#include <lsys.h>
#include <lkey.h>

char  lk_sb_init(short addr,short irq,short dma);
char  lk_sb_rest();
int   lk_sb_play(char *buf,int len,int sample);
///////////////////////////////////////////////////////////////////////////
struct
{ long  phy;
  short size;
  short selector;
  char *data;
} dma_buf[2];
struct 
{ int   sample;
  long  len_to_play;
  char *data_to_play;
} lsnd_buf; 
extern short lk_sb_port,lk_sb_irq,lk_sb_dma;
extern short lk_sb_stereo, lk_sb_16bit, lk_dsp_ver;
static short IntNumbers[] = {
  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77 };
long   int  lk_dma_size=0x10000/8,lk_dma_mix_size;
long   int  lk_sb_sending=0,lk_sb_freq=-1;
static int  sb_bufnum=0,sb_dma_count=0,sb_semaphore=0;
static int  sb_init_flag=0;
static char *sb_card;

static char lsnd_create_buffers(int size,int block);
static char lsnd_release_buffers();
static char set_isr();
static char rest_isr();
static void interrupt interrupt_isr();
static void interrupt far (*old_interrupt)()=NULL;
static char lsnd_play_buffer(char buf,ushort size,int sampleRate);
///////////////////////////////////////////////////////
static char  lsnd_create_buffers(int size,int block)
{ int first_size;
  char i;
  if (size<16384L) size=16384L;
  if (block==1) first_size=size*2; else first_size=size;
  i=lsys_dma_alloc(first_size,&dma_buf[0].phy,&dma_buf[0].selector);
  if (i) { dma_buf[0].phy=0; return -1; }
  dma_buf[0].size=first_size; dma_buf[0].data=(char*)dma_buf[0].phy;
  
  if (block==2)
  { i=lsys_dma_alloc(size,&dma_buf[1].phy,&dma_buf[1].selector);
    if (i) {
      lsys_dma_free(size,dma_buf[0].phy,dma_buf[0].selector);
      dma_buf[0].phy=dma_buf[1].phy=0;
      return -1;
	} dma_buf[1].size=size; dma_buf[1].data=(char*)dma_buf[1].phy;
  } else {
    dma_buf[1].data=dma_buf[0].data+size; 
	dma_buf[1].phy=dma_buf[0].phy+size;
	dma_buf[1].size=0; dma_buf[1].selector=dma_buf[0].selector;
  }
  return 0;
}
static char  lsnd_release_buffers()
{ int i;
  for (i=0;i<2;i++) if (dma_buf[i].phy&&dma_buf[i].size>0) {
    lsys_dma_free(dma_buf[i].size,dma_buf[i].phy,dma_buf[i].selector);
    dma_buf[i].phy=dma_buf[i].size=0;
  }
  return 0;
}
char  lk_sb_init(short addr,short irq,short dma)
{ short dma8,dma16; 
  int max_freq, default_freq,block=2;
  char *msg;

  if (sb_init_flag) return 0;
  if (addr<0||irq<0||dma<0) {
     lsGetBlasterEnv(&addr,&dma8,&dma16,&irq);
     dma=dma8;
  }
  if (addr<0||irq<0||dma<0) return -1;
  lk_sb_port=addr; lk_sb_dma=dma; lk_sb_irq=irq;
  if (lsResetDsp(1)) return -2;

  if (lsnd_create_buffers(lk_dma_size,block)) return -3;
  if (set_isr()) return -4;
  lsWritePortC(0xd1);
  sb_init_flag=1;
  return 0;
}
char  lk_sb_rest()
{ if (sb_init_flag==0) return 0;
  rest_isr();
  lsnd_release_buffers();
  lsWritePortC(0xd3);
  return 0;
}
#define PIC1MODE        0x20    // for irq 0 - 7
#define PIC1MASK        0x21
#define PIC2MODE        0xA0    // for irq 8 - 15
#define PIC2MASK        0xA1
#define PICEOI          0x20    // End Of Interrupt
static char set_isr()
{   int  Intr_num;
    int  Intr_mask;

    if (old_interrupt!=NULL) return -1;
    Intr_num =  IntNumbers[lk_sb_irq];
    Intr_mask = 1 << lk_sb_irq;
    old_interrupt=_dos_getvect(Intr_num);
    _disable();
    _dos_setvect(Intr_num,interrupt_isr);
    _enable();
    outp(PIC1MASK, inp(PIC1MASK) & ~Intr_mask);
    outp(PIC2MASK, inp(PIC2MASK) & ~(Intr_mask >> 8));
    return 0;
}
static char rest_isr()
{   int  Intr_num;
    int  Intr_mask;

    if (old_interrupt==NULL) return -1;
    Intr_num =  IntNumbers[lk_sb_irq];
    Intr_mask = 1 << lk_sb_irq;

    outp(PIC1MASK, inp(PIC1MASK) | Intr_mask);
    outp(PIC2MASK, inp(PIC2MASK) | (Intr_mask >> 8));
    _disable();
    _dos_setvect(Intr_num,old_interrupt);
    _enable();
    old_interrupt=NULL;
    return 0;
}
///////////////////////////////////////////////////////
static void lk_sb_sample_rate(unsigned int rate)
{  lsWritePortC(0x40);
   lsWritePortC((unsigned char)(256-1000000/rate));
}
static void lk_sb_play_buffer(int size)
{  lsWritePortC(0x14);
   lsWritePortC((size-1) & 0xFF);
   lsWritePortC((size-1) >> 8);
   lk_sb_sending=1;
}
static char lsnd_play_buffer(char buf,ushort size,int sampleRate)
{ if (dma_buf[buf].phy==0) return -1;

  lk_sb_sample_rate(sampleRate);
  if (size>dma_buf[buf].size) size=dma_buf[buf].size;
  sb_bufnum=buf;  
  lsys_dma_start(lk_sb_dma,dma_buf[buf].phy,size,0,0);
  lk_sb_play_buffer(size);
  return 0;
}
///////////////////////////////////////////////////////////////////////////
int lk_sb_play(char *buf,int len,int sample)
{ lsnd_buf.sample=sample;
  lsnd_buf.len_to_play=len;
  lsnd_buf.data_to_play=buf;
  memset(dma_buf[0].data,0,lk_dma_size);
  lsnd_play_buffer(0,1,sample);
  lsWritePortC(0xd1);
  return 0;
}
///////////////////////////////////////////////////////
static void interrupt interrupt_isr()
{ int len,cont=1;
  lk_sb_sending=0;
  len=lsnd_buf.len_to_play;
  if (len>lk_dma_size) len=lk_dma_size;
  if (len==0||lsnd_buf.data_to_play==NULL) cont=0;
  if (cont) {
    sb_bufnum = 1 - sb_bufnum; 
    memcpy(dma_buf[sb_bufnum].data,lsnd_buf.data_to_play,len);
    lsys_dma_start(lk_sb_dma, dma_buf[sb_bufnum].phy, lk_dma_size, FALSE, FALSE);
    lsnd_buf.len_to_play-=len;
    lsnd_buf.data_to_play+=len;
    lsnd_play_buffer(sb_bufnum,len,lsnd_buf.sample);
  }
  if (lsnd_buf.len_to_play<=0) {
  }
  outp(0x20, 0x20); 
}