import qemu

import os

from ctypes import cdll

import ctypes

import datetime

class syborg_usbtest(qemu.devclass):

  REG_ID           = 0

  REG_INT_ENABLE   = 1

  REG_DATA_TYPE    = 2

  REG_DMA_ADDR     = 3

  REG_DMA_SIZE     = 4

  REG_DMA_INFO     = 5

  REG_DMA_INFOSIZE = 6

  REG_DMA_CONNECT  = 7

  REG_DMA_DISCONNECT  = 8

  def loaddll(self):

    #Load DLL

    print "start dll load"

    self.path = r'.\webcamapi.dll'

    self.webcamdll = cdll.LoadLibrary(self.path)

    print "end dll load"

  def connect(self):

    #Connect to USB Camera

    print "Connect to USB Camera"

    if self.infobuffer == 0:

      self.infobuffer = ctypes.create_string_buffer(self.infosize)

    self.DevHandle = self.webcamdll.ConnectDevHandle()

    self.bufSize = ctypes.c_int()

    self.PinHandle = self.webcamdll.ConnectPinHandle(self.DevHandle, ctypes.byref(self.bufSize), ctypes.byref(self.infobuffer))

    infobuf = self.infobuffer

    for x in infobuf:

        ch = ord(x)

        if self.infosize > 0:

            self.dma_writeb(self.dataformat, ch)

            self.dataformat += 1

            self.infosize -= 1

  def readframe(self):

    #Read frame data

    if self.buffer == 0:

      self.buffer = ctypes.create_string_buffer(self.bufSize.value)

    self.timelog("Read frame data Start")

    self.Ret = self.webcamdll.ReadFrameData(self.PinHandle, ctypes.byref(self.buffer), self.bufSize.value)

    self.timelog("Read frame data End")

    #Write frame data. This is for debug.

    #self.Ret = self.webcamdll.WriteFrameData("_frameData.bin", ctypes.byref(self.buffer), self.bufSize.value);

    buf = self.buffer

    length = len(buf)

    count = 0

    for x in range(1, length, 2):

        if self.dma_size > 0:

          self.buf = ord(buf[count+1]) <<  8 | ord(buf[count+0])

          self.dma_writel(self.dma_addr, self.buf)

          self.dma_addr += 2

          self.dma_size -= 2

          count += 2

    self.set_irq_level(0, self.int_enable)

  def timelog(self,buf):

    date = datetime.datetime.today().isoformat()

    print "%(view)s %(time)s" % {"view":buf,"time":date}

  def create(self):

    self.int_enable = 1

    self.dma_addr = 0

    self.dma_size = 0

    self.cha = 0

    self.dataformat = 0

    self.infosize = 0

    self.buffer = 0

    self.infobuffer = 0

  def write_reg(self, offset, value):

  #This func is called when PDD performed WriteReg func.

    offset >>= 2

    if offset==self.REG_INT_ENABLE:

        self.int_enable=value

        if value==1:

          if self.data_type==0:

            self.readframe()

        else:

          if self.data_type==0:

            self.set_irq_level(0, self.int_enable)

            #self.timer_off()

          elif self.data_type==1:

            self.set_irq_level(0, self.int_enable)

    elif offset == self.REG_DATA_TYPE:

      self.data_type = value

    elif offset == self.REG_DMA_ADDR:

      self.dma_addr = value

    elif offset == self.REG_DMA_SIZE:

      self.dma_size = value

    elif offset == self.REG_DMA_INFO:

      self.dataformat = value

    elif offset == self.REG_DMA_INFOSIZE:

      self.infosize = value

    elif offset == self.REG_DMA_CONNECT:

      self.loaddll()

      self.connect()

    elif offset == self.REG_DMA_DISCONNECT:

      self.Ret = self.webcamdll.DisconnectPinHandle(self.PinHandle)

      self.set_irq_level(0, self.int_enable)

  def read_reg(self, offset):

  #This func is called when PDD performed ReadReg func.

    offset >>= 2

    if offset == self.REG_ID:

      return 0xc600f000

    elif offset == self.REG_INT_ENABLE:

      return self.int_enable

    elif offset == self.REG_DMA_ADDR:

      return self.dma_addr

    elif offset == self.REG_DMA_SIZE:

      return self.dma_size

    elif offset == self.REG_DMA_FORMAT:

      return self.dataformat

    return 0

  def save(self, f):

    f.put_u32(self.int_enable)

    f.put_u32(self.dma_addr)

    f.put_u32(self.dma_size)

    f.put_u32(self.dataformat)

    f.put_u32(self.infosize)

    f.put_u32(self.buffer)

    f.put_u32(self.infobuffer)

  def load(self, f):

    self.int_enable = f.get_u32()

    self.dma_addr = f.get_u32()

    self.dma_size = f.get_u32()

    self.dataformat = f.get_u32()

    self.infosize = f.get_u32()

    self.buffer = f.get_u32()

    self.infobuffer = f.get_u32()

  # Device class properties

  regions = [qemu.ioregion(0x1000, readl=read_reg, writel=write_reg)]

  irqs = 1

  name = "syborg,usbtest"

  properties={"chardev":None}

qemu.register_device(syborg_usbtest)