package jAudioTransmitter;

import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.TargetDataLine;

public class Main {
   static List<Sender> senderList = new ArrayList<Sender>();
   static MicrophoneReader mr;
   static volatile Integer sendersCreated = 0;
   static volatile Integer numBytesRead;
   static volatile Integer senderNotReady = 0;
   static volatile byte[] data;
   static final Object monitor = new Object();
   
   public static void main(String[] args) {
      try {
         mr = new MicrophoneReader();
         mr.start();
         
         ServerSocket ss = new ServerSocket(7373);
         
         Scanner sc = new Scanner(System.in);
         
         //while (!sc.next().equals("quit")) {
         while (true) {
            Socket s = ss.accept();
            
            Sender sndr = new Sender(s);
            senderList.add(sndr);
            sndr.start();
         }
         
      } catch (Exception e) {
         e.printStackTrace();
      } finally {
         mr.setFinishFlag();
         for (Sender sndr: senderList) {
            sndr.setFinishFlag();
         }
      }
   }

   static class Sender extends Thread {
      Socket s;
      volatile boolean finishFlag;
      int position;
      int senderNumber;
   
      public Sender(Socket s) {
         this.s = s;
         finishFlag = false;
         System.out.print("Sender started: #");
         senderNumber = ++sendersCreated;
         System.out.println(senderNumber);
      }
      
      public void setFinishFlag() {
         finishFlag = true;
      }
      
      public void run() {
         try {
            OutputStream os = s.getOutputStream();
            
            while (!finishFlag) {
               synchronized (monitor) {
                  senderNotReady++;
               
                  monitor.wait();
                  
                  os.write(data, 0, numBytesRead);
                  os.flush();
            
                  senderNotReady--;
               }
               System.out.print("Sender #");
               System.out.print(senderNumber);
               System.out.print(": ");
               System.out.print(numBytesRead);
               System.out.println(" bytes sent");
            }
         } catch (Exception e) {
            e.printStackTrace();
         }
      }
   }
   
   static class MicrophoneReader extends Thread {
      volatile boolean finishFlag;
      
      AudioFormat format = new AudioFormat(16000.0f, 16, 2, true, false);
      //AudioFormat format = new AudioFormat(8000.0f, 8, 1, true, false);
      int CHUNK_SIZE = 10240;
       TargetDataLine microphone;
      
      public MicrophoneReader() {
         finishFlag = false;
         System.out.println("Microphone reader started");
      }

      public void setFinishFlag() {
         finishFlag = true;
      }
      
      public void run() {
         try {
            microphone = AudioSystem.getTargetDataLine(format);
            
            DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
              microphone = (TargetDataLine) AudioSystem.getLine(info);
              microphone.open(format);
            
             
              data = new byte[CHUNK_SIZE];
              microphone.start();
                           
              while (!finishFlag) {
                 synchronized (monitor) {
                    if (senderNotReady==sendersCreated) {
                       monitor.notifyAll();
                       continue;
                    }
                    
                    numBytesRead = microphone.read(data, 0, CHUNK_SIZE);   
                 }

                 System.out.print("Microphone reader: ");
                 System.out.print(numBytesRead);
                 System.out.println(" bytes read");
              }
         } catch (LineUnavailableException e) {
            e.printStackTrace();
         }
      }
   }
}

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.TargetDataLine;


static int TX_flag_AudioFormat = 0;   //

static byte[] mic_byte_wavt = new byte[1024];//(микрофон)
static int [] TX_int_wavt = new int[1024];   //UDP

////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////поток 1 TX_wav:
Thread Thready_1 = new Thread(new Runnable()
{
  public void run() // поток 1
  {
    while(true)   
    {
      //////////////////////////////////////////////////////// TX_wav:
       //8000,11025,16000,22050,44100
       int TX_sampleRate = 8000;    //8000
     //int TX_sampleRate = 11025;   //11025
     //int TX_sampleRate = 16000;   //16000
       //int TX_sampleRate = 22050;   //22050
       //int TX_sampleRate = 44100;   //44100
     //////////////////////////////////////////////////////// TX_wav:
       int TX_sampleSizeInBits = 8; //8 бит
          //int TX_sampleSizeInBits = 16;//16 бит
     //////////////////////////////////////////////////////// TX_wav:
          int TX_channels = 1;           //1 моно, 2 стерео
          //true-знак(-127...+127/-32768...+32767)(8 бит/16 бит-PCM_SIGNED)
          //boolean TX_signed = true;       
          boolean TX_signed = false;   //false-без знака(0...255)(только 8бит-PCM_UNSIGNED) 
     //////////////////////////////////////////////////////// TX_wav:
          //boolean TX_bigEndian = false;//false little-endian//порядок байт
          boolean TX_bigEndian = true;   //true big-endian;//порядок байт
          AudioFormat TX_format =
          new AudioFormat(TX_sampleRate, TX_sampleSizeInBits, TX_channels, TX_signed, TX_bigEndian);
     //////////////////////////////////////////////////////// TX_wav:
          //строка данных - для чтения захваченных данные из буфера целевой строки данных.
          TargetDataLine TX_line = null;
          DataLine.Info TX_info = new DataLine.Info(TargetDataLine.class, TX_format); 
          //////////////////////////////////////////////////////// TX_wav:
     try {
      TX_line = (TargetDataLine)AudioSystem.getLine(TX_info);
     } catch (LineUnavailableException e) {
      e.printStackTrace();
     }
     //////////////////////////////////////////////////////// TX_wav:
     try {
       TX_line.open(TX_format);
     } catch (LineUnavailableException e) {
      e.printStackTrace();
     }
     //////////////////////////////////////////////////////// TX_wav: start:
          TX_line.start();   
         //TX_line.stop();
         //TX_line.close();
         //////////////////////////////////////////////////////// TX_wav: run:
         while(TX_flag_AudioFormat == 1) 
     {
         //////////////////////////////////////////////////// TX_wav: TX_line:
              //Считывает аудиоданные из входного буфера линии передачи данных.// ждём...
         TX_line.read(mic_byte_wavt, 0, TX_len_wavt);//(микрофон)
         //////////////////////////////////////////////////// TX_wavt: mic(микрофон) > int:
         for (xTX_wavt=0; xTX_wavt<1024; xTX_wavt++) {         
             TX_int_wavt[xTX_wavt] = mic_byte_wavt[xTX_wavt];    //byte 0...127|-127...0 > int 0...255     
         if (TX_int_wavt[xTX_wavt] < 0){TX_int_wavt[xTX_wavt] += 256;}
         };
         //////////////////////////////////////////////////// TX_wavt: Ethernet
//         TX_Ethernet_wavt(socket_wav);   // > TX_Ethernet_wavt
              ////////////////////////////////////////////////////
     }//while(TX_flag_AudioFormat == 1) 
      //////////////////////////////////////////////////////// stop, close:
      TX_line.stop();
      TX_line.close();
      }//while(TX_flag_AudioFormat)
      //////////////////////////////////////////////////////// control_wavt: run END
     
    //////////////////////////////////////////////////////////
    }//while(true)
  } //run()
});//Thread(new Runnable()
Thready_1.start();   // start поток 1
////////////////////////////////////////////////////////////////////////////////