voip_client

import socket
import threading
import time
import pyaudio
import xml.etree.ElementTree as ET
import atexit
import traceback
import sys
import wave

p = pyaudio.PyAudio()
CHUNK = 0
FORMAT = pyaudio.paInt16
O_CHANNELS = 0
O_RATE = 0
I_CHANNELS = 0
I_RATE = 0
client_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
running = True
frames = []


def initialize():
    # CHANNELS * CHUNK * 2 = 1024
    global O_CHANNELS, O_RATE, I_RATE, I_CHANNELS, CHUNK
    d_input = p.get_default_input_device_info()
    d_output = p.get_default_output_device_info()
    print(d_input)
    print(d_output)
    I_CHANNELS = d_input['maxInputChannels']
    I_RATE = int(d_input['defaultSampleRate'])
    O_CHANNELS = d_output['maxOutputChannels']
    O_RATE = int(d_output['defaultSampleRate'])
    CHUNK = int(4096 / (O_CHANNELS * 2))
    print("CHUNK IS: " + str(CHUNK))


def exit_handler():
    try:
        print('My application is ending!')
        client_sock.sendto("EXIT".encode(), (HOST, PORT))
        print("closing p object")
        p.terminate()
        client_sock.close()
    except Exception as ex:
        print("exit error: ")
        print(ex)


def parseXML(xmlfile):
    # create element tree object
    tree = ET.parse(xmlfile)
    # get root element
    root = tree.getroot()
    # create empty list for news items
    newsitems = []
    ip = root.findall("./socket/ip")
    port = root.findall("./socket/port")
    print(type(ip[0].text))
    return ip[0].text, int(port[0].text)


def send_audio_udp(stream):
    try:
        print("* recording" + "\r\n")
        wf = wave.open("hello.wav", 'wb')
        wf.setnchannels(O_CHANNELS)
        wf.setsampwidth(p.get_sample_size(FORMAT))
        wf.setframerate(O_RATE)
        frfr = []
        #print("len of read is: " + str(len(stream.read(CHUNK))) + "\r\n")
        while running:
            try:
                data = stream.read(CHUNK, exception_on_overflow=False)
                client_sock.sendto(data, (HOST, PORT))
                frfr.append(data)
            except socket.error as ex:
                print(ex)
                break
        wf.writeframes(b''.join(frfr))
        wf.close()
    except Exception as exx:
        print("send audio udp exception: \r\n")
        print(exx)
    print("finished sending audio\r\n")


def play(stream):
    try:
        BUFFER = 10
        print("chunk is: " + str(CHUNK) + "\r\n")
        while running:
            try:
                while len(frames) > BUFFER:
                    fr = frames.pop(0)
                    stream.write(fr, CHUNK)
            except Exception as ex:
                print("error while streaming data into speaker:\r\n")
                print(ex)
                break
        #wf.close()

    except Exception as exx:
        print("play exception: \r\n")
        print(exx)
    print("finished play audio\r\n")


def recv_audio_udp():
    global running
    try:
        while running:
            data, ip = client_sock.recvfrom(CHUNK * O_CHANNELS * 2)
            frames.append(data)
    except socket.error as ex:
        print("got a socket error: \r\n")
        running = False
        print(ex)

    except Exception as exx:
        print("other error: \r\n")
        print(exx)
        return
    print("finish recv\r\n")


def command():
    global running
    while running:
        try:
            msg = input("enter a command: ")
            if msg == "exit":
                running = False
                sys.exit()
        except Exception as ex:
            print("command exception: r\n")
            print(ex)
    print("finish command\r\n")


def main():
    try:
        initialize()
        client_sock.sendto("im here".encode(), (HOST, PORT))
        print(HOST, PORT)
        data, ip = client_sock.recvfrom(1024)
        data = data.decode()
        print("data is: " + data)
        if data == "recv":
            print("login success\r\n")
            input_stream = p.open(format=FORMAT,
                                channels=I_CHANNELS,
                                rate=I_RATE,
                                input=True,  # input_device_index=device_index,
                                frames_per_buffer=CHUNK)
            ts = threading.Thread(target=send_audio_udp, args=(input_stream,))
            ts.setDaemon(True)

            output_stream = p.open(format=FORMAT,
                            channels=O_CHANNELS,
                            rate=O_RATE,
                            output=True,
                            frames_per_buffer=CHUNK)
            print("after send audio thread\r\n")
            tp = threading.Thread(target=play, args=(output_stream,))
            tp.setDaemon(True)
            tr = threading.Thread(target=recv_audio_udp)
            tr.setDaemon(True)
            tc = threading.Thread(target=command)
            tc.setDaemon(True)

            ts.start()
            tp.start()
            tr.start()
            tc.start()

            ts.join()
            tp.join()
            tr.join()
            tc.join()
        else:
            print("error")
    except socket.error as ex:
        print("got a socket error in main: \r\n")
        print(ex)

    except Exception as exx:
        print("main other error: \r\n")
        print(exx)
        return


if __name__ == "__main__":
    try:
        HOST, PORT = parseXML("config.xml")
        atexit.register(exit_handler)
        main()
    except Exception as ex:
        print("main error: \r\n")
        print(traceback.format_exc())