def get_process_id(
window_class: str = None,
window_title: str = None,
) -> Tuple[int, int]:
"""Gets process ID by finding the window either via
its class or title.
Args:
window_class (str, optional): Window class
window_title (str, optional): Window title
Returns:
Tuple[int, int]: PID, HWND
"""
try:
arg1 = LPCSTR(window_class.encode("utf-8"))
except AttributeError:
arg1 = None
try:
arg2 = LPCSTR(window_title.encode("utf-8"))
except AttributeError:
arg2 = None
hwnd = FindWindow(arg1, arg2)
pid = DWORD()
GetWindowThreadProcessId(hwnd, byref(pid))
return pid.value, hwnd
def find_window(name):
"""
Find the window with the given class or "name" (text).
\returns
PyWnd for the window.
"""
if name.startswith(CLASS_NAME):
name = name[len(CLASS_NAME):]
if name.startswith(TEXT_NAME):
name = name[len(TEXT_NAME):]
w = None
if user32:
try:
w = user32.FindWindowA(LPCSTR(name), 0)
if w:
w = a_window(w)
else:
w = None
w = user32.FindWindowA(0, LPCSTR(name))
if w:
w = a_window(w)
else:
w = None
pass
pass
except:
w = None
pass
elif X:
wa = get_windows()
for ww in wa:
if name == ww.get_wm_name():
w = ww
break
pass
if not w:
for ww in wa:
cl = ww.get_wm_class()
if name in cl:
w = ww
break
pass
pass
pass
return (w)
def _getExpandedCounterPaths(processName, counterName):
'''
Get list of expanded counter paths given a counter name. Returns a
list of strings or None, if no counter paths can be created
'''
pcchPathListLength = DWORD(0)
szWildCardPath = LPSTR('\\process(%s)\\%s' % (processName, counterName))
if pdh.PdhExpandCounterPathA(szWildCardPath, LPSTR(None),
pointer(pcchPathListLength)) != _PDH_MORE_DATA:
return None
pathListLength = pcchPathListLength.value
szExpandedPathList = LPCSTR('\0' * pathListLength)
if pdh.PdhExpandCounterPathA(szWildCardPath, szExpandedPathList,
pointer(pcchPathListLength)) != 0:
return None
buffer = create_string_buffer(pcchPathListLength.value)
memmove(buffer, szExpandedPathList, pcchPathListLength.value)
paths = []
i=0
path = ''
for j in range(0, pcchPathListLength.value):
c = struct.unpack_from('c', buffer, offset=j)[0]
if c == '\0':
if j == i:
# double null: we're done
break
paths.append(path)
path = ''
i = j + 1
else:
path += c
return paths
def __write(self, write_buffer, write_overlap):
self.__debug('writing pipe')
result = WriteFile(
self.__pipe_handle,
LPCSTR(write_buffer),
len(write_buffer),
NULL,
ctypes.byref(write_overlap)
)
err = GetLastError()
if result:
self.__debug('data written')
return False
if err == ERROR_IO_PENDING:
self.__debug('data pending write')
return True
elif err:
try:
raise PipeError(err)
except PipeError:
LOGGING.error(traceback.format_exc())
CloseHandle(write_overlap.hEvent)
self.reconnect()
return True
def main(argv):
import datetime
if len(argv)==1:
from xpra.platform.win32.printing import get_printers
printers = get_printers()
log("printers: %s", printers)
printer_name = printers.keys()[0]
elif len(argv)==2:
printer_name = argv[1]
else:
log.error("usage: %s [printer-name]", argv[0])
return 1
title = "Test Page"
log.warn("HELLO1")
x = GDIPrinterContext(printer_name)
log.warn("HELLO GDIPrinterContext: %s", x)
with GDIPrinterContext(printer_name) as hdc:
log("hdc=%s", hdc)
docinfo = DOCINFO()
docinfo.lpszDocName = LPCSTR("%s\0" % title)
log("StartDocA(%#x, %s)", hdc, docinfo)
r = StartDocA(hdc, pointer(docinfo))
if r<0:
log.error("StartDocA failed: %i", r)
return r
log("StartDocA()=%i" % r)
r = StartPage(hdc)
if r<0:
log.error("StartPage failed: %i", r)
return r
x, y = 100, 100
s = "Test Page printed at %s" % (datetime.datetime.now())
if not TextOutA(hdc, x, y, LPCSTR(s), len(s)):
log.error("TextOutA failed")
return 1
r = EndPage(hdc)
if r<0:
log.error("EndPage failed: %i", r)
return r
r = EndDoc(hdc)
if r<0:
log.error("EndDoc failed: %i" % r)
return r
log("EndDoc()=%i" % r)
return 0
def _addCounter(self, processName, counterType, counterName):
pCounterPathElements = _PDH_COUNTER_PATH_ELEMENTS_A(
LPSTR(None),
LPSTR(counterType),
LPSTR(processName),
LPSTR(None),
DWORD(-1),
LPSTR(counterName),
)
pcchbufferSize = DWORD(0)
# First run we just try to get the buffer size so we can allocate a
# string big enough to fill it
if (pdh.PdhMakeCounterPathA(
pointer(pCounterPathElements),
LPCSTR(0),
pointer(pcchbufferSize),
DWORD(0),
) != _PDH_MORE_DATA):
raise TalosError(
"Could not create counter path for counter %s for %s" %
(counterName, processName))
szFullPathBuffer = LPCSTR("\0" * pcchbufferSize.value)
# Then we run to get the actual value
if (pdh.PdhMakeCounterPathA(
pointer(pCounterPathElements),
szFullPathBuffer,
pointer(pcchbufferSize),
DWORD(0),
) != 0):
raise TalosError(
"Could not create counter path for counter %s for %s" %
(counterName, processName))
path = szFullPathBuffer.value
hq = HANDLE()
if pdh.PdhOpenQuery(None, None, byref(hq)) != 0:
raise TalosError("Could not open win32 counter query")
hc = HANDLE()
if pdh.PdhAddCounterA(hq, path, 0, byref(hc)) != 0:
raise TalosError("Could not add win32 counter %s" % path)
self.registeredCounters[counterName] = [hq, [(hc, path)]]
def __init__(self, dict):
if not dict:
self._as_parameter_ = None
else:
values = ["%s=%s" % (key, value) for (key, value) in dict.items()]
values.append("")
self._as_parameter_ = LPCSTR(
"\0\0".join(values).encode("utf-16le"))
def __enter__(self):
self.handle = HANDLE()
name = LPCSTR(self.printer_name)
if not OpenPrinterA(name, pointer(self.handle), None):
raise Exception("failed to open printer %s" % self.printer_name)
log("OpenPrinter: handle=%#x", self.handle.value)
size = DWORD(0)
GetPrinterA(self.handle, 1, None, 0, pointer(size))
if size.value==0:
raise Exception("GetPrinterA PRINTER_INFO_1 failed for '%s'" % self.printer_name)
log("GetPrinter: PRINTER_INFO_1 size=%#x", size.value)
self.info1 = msvcrt.malloc(size.value)
if not GetPrinterA(self.handle, 1, self.info1, size.value, pointer(size)):
raise Exception("GetPrinterA PRINTER_INFO_1 failed for '%s'", self.printer_name)
info = cast(self.info1, POINTER(PRINTER_INFO_1))
log(" flags=%#x" % info[0].Flags)
log(" name=%#s" % info[0].pName)
log(" description=%s" % info[0].pDescription)
log(" comment=%s" % info[0].pComment)
size = DWORD(0)
GetPrinterA(self.handle, 2, None, 0, pointer(size))
if size.value==0:
raise Exception("GetPrinterA PRINTER_INFO_2 failed for '%s'", self.printer_name)
log("GetPrinter: PRINTER_INFO_2 size=%#x", size.value)
self.info2 = msvcrt.malloc(size.value)
if GetPrinterA(self.handle, 2, self.info2, size.value, pointer(size)):
info = cast(self.info2, POINTER(PRINTER_INFO_2))
log(" driver=%#s" % info[0].pDriverName)
size = DWORD(0)
GetPrinterA(self.handle, 8, None, 0, pointer(size))
if size.value==0:
raise Exception("GetPrinter: PRINTER_INFO_8 failed for '%s'" % self.printer_name)
self.info8 = msvcrt.malloc(size.value)
if GetPrinterA(self.handle, 8, self.info8, size.value, pointer(size)):
info = cast(self.info8, POINTER(PRINTER_INFO_8))
if info[0] and info[0].pDevMode:
devmode = cast(info[0].pDevMode, POINTER(DEVMODE))
log("PRINTER_INFO_8: devmode=%s" % devmode)
log("PRINTER_INFO_8: device name='%s'" % devmode[0].dmDeviceName)
size = DWORD(0)
GetPrinterA(self.handle, 9, None, 0, pointer(size))
if size.value==0:
raise Exception("GetPrinter: PRINTER_INFO_9 failed for '%s'" % self.printer_name)
log("GetPrinter: PRINTER_INFO_9 size=%#x" % size.value)
self.info9 = msvcrt.malloc(size.value)
if GetPrinterA(self.handle, 9, self.info9, size.value, pointer(size)):
info = cast(self.info9, POINTER(PRINTER_INFO_9))
if info[0] and info[0].pDevMode:
devmode = cast(info[0].pDevMode, POINTER(DEVMODE))
log("PRINTER_INFO_9: devmode=%s" % devmode)
log("PRINTER_INFO_9: device name=%s" % devmode[0].dmDeviceName)
assert devmode, "failed to query a DEVMODE for %s" % self.printer_name
self.hdc = CreateDCA(None, name, None, devmode)
log("CreateDCA(..)=%#x", self.hdc)
return self.hdc
def MessageBox(HWND, BODY, TITLE, UINT):
code = {3:"Abort",
2:"Cancel",
11:"Continue",
5:"Ignore",
7:"No",
1:"OK",
4:"Retry",
10:"Try Again",
6:"Yes"}
int = windll.User32.MessageBoxA(
HWND,
LPCSTR(BODY),
LPCSTR(TITLE),
UINT
)
return code[int]
def lookup_privilege_value(self, lpSystemName, lpName, luidPrivilege):
# Calling the Windows API Call to
response = self.__advapi_handler.LookupPrivilegeValueA(
lpSystemName, LPCSTR(lpName.encode("utf-8")),
ctypes.byref(luidPrivilege))
if response <= 0 or response is None:
PrintScreen.err(
"lookup_privilege_value: Lookup For {0} Failed".format(lpName))
self.assert_last_error()
else:
PrintScreen.log("Lookup For {0} worked".format(lpName))
return response
def open_event(event_name: str,
desired_access: int = EVENT_ALL_ACCESS,
inherit_handle: bool = False) -> HANDLE:
"""
Attempts to open an event object with the given name at the requested access level.
The name must easily convert to ascii.
:param event_name: a name to open. must be convertible to ascii
:param desired_access:
:param inherit_handle: whether child processes get access to the handle.
:return: a handle for the event if successful
"""
return _open_event(DWORD(desired_access), BOOL(inherit_handle),
LPCSTR(bytes(event_name, 'ASCII')))
def _getExpandedCounterPaths(processName, counterName):
"""
Get list of expanded counter paths given a counter name. Returns a
list of strings or None, if no counter paths can be created
"""
pcchPathListLength = DWORD(0)
szWildCardPath = LPSTR("\\process(%s)\\%s" % (processName, counterName))
if (pdh.PdhExpandCounterPathA(szWildCardPath, LPSTR(None),
pointer(pcchPathListLength)) !=
_PDH_MORE_DATA):
return []
pathListLength = pcchPathListLength.value
szExpandedPathList = LPCSTR("\0" * pathListLength)
if (pdh.PdhExpandCounterPathA(szWildCardPath, szExpandedPathList,
pointer(pcchPathListLength)) != 0):
return []
buffer = create_string_buffer(pcchPathListLength.value)
memmove(buffer, szExpandedPathList, pcchPathListLength.value)
paths = []
i = 0
path = ""
for j in six.moves.range(0, pcchPathListLength.value):
c = struct.unpack_from("c", buffer, offset=j)[0]
if c == "\0":
if j == i:
# double null: we're done
break
paths.append(path)
path = ""
i = j + 1
else:
path += c
return paths
avi.AVIFileCreateStreamA.argtypes = [c_int, POINTER(c_void_p), POINTER(AVISTREAMINFOA)]
avi.AVIFileCreateStreamA.restype = c_int
avi.AVISaveOptions.argtypes = [HWND, UINT, c_int, POINTER(c_void_p), c_void_p]
avi.AVISaveOptions.restype = c_int
avi.AVIFileRelease.argtypes = [c_int]
avi.AVIFileRelease.restype = c_int
avi.AVIStreamRelease.argtypes = [c_void_p]
avi.AVIStreamRelease.restype = c_int
if __name__ == "__main__":
avifile = c_int(0)
avi.AVIFileInit()
avi.AVIFileOpenA(pointer(avifile), LPCSTR("__tmp__.avi"), OF_WRITE|OF_CREATE, 0)
aviinfo = AVISTREAMINFOA()
aviinfo.fccType = fourcc("vids")
stream = c_void_p(0)
avi.AVIFileCreateStreamA(avifile, pointer(stream), pointer(aviinfo))
opt = AVICOMPRESSOPTIONS()
popt = ctypes.pointer(opt)
opt.fccType = fourcc("vids")
avi.AVISaveOptions(0, 0, 1, pointer(stream), pointer(ctypes.pointer(opt)))
print((unfourcc(opt.fccHandler)))
avi.AVIStreamRelease(stream)
avi.AVIFileRelease(avifile)
def priority(level=0, pid=None):
# 0 = normal priority
# 1 = high
# 2 = realtime
gc.disable() if level > 0 else gc.enable()
if kernel32 is None and avrt is None:
# nothing to do if we don't have these
return False
pid = os.getpid()
process = kernel32.OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION, 0, pid)
thread = kernel32.GetCurrentThread()
if thread in thread_pool.keys():
thread_grp = thread_pool[thread]
else:
thread_grp = {'mmcss': None}
thread_pool[thread] = thread_grp
# if this is a MMCSS scheduled thread, need to revert to normal first
if avrt and thread_grp['mmcss']:
avrt.AvRevertMmThreadCharacteristics(thread_grp['mmcss'])
thread_grp['mmcss'] = None
# clear error if anything?
err = get_last_error()
if err:
set_last_error(0)
return False
if level == 1:
kernel32.SetPriorityClass(process, HIGH_PRIORITY_CLASS)
if avrt:
tmp = LPDWORD()
thread_grp['mmcss'] = avrt.AvSetMmMaxThreadCharacteristicsA(LPCSTR(b'Pro Audio'),
LPCSTR(b'Capture'),
byref(tmp))
if not thread_grp['mmcss']: # failed
kernel32.SetThreadPriority(thread, THREAD_PRIORITY_HIGHEST)
elif level >= 2:
# first try to set time critical
if (not kernel32.SetPriorityClass(process, REALTIME_PRIORITY_CLASS) or
kernel32.GetPriorityClass(process) != REALTIME_PRIORITY_CLASS):
# try for high priority scheduling instead
kernel32.SetPriorityClass(process, HIGH_PRIORITY_CLASS)
if avrt:
tmp = LPDWORD()
thread_grp['mmcss'] = avrt.AvSetMmMaxThreadCharacteristicsA(LPCSTR(b'Pro Audio'),
LPCSTR(b'Capture'),
byref(tmp))
if not thread_grp['mmcss']: # failed
kernel32.SetThreadPriority(
thread, THREAD_PRIORITY_ABOVE_NORMAL)
else:
kernel32.SetPriorityClass(process, NORMAL_PRIORITY_CLASS)
kernel32.SetThreadPriority(thread, THREAD_PRIORITY_NORMAL)
return True
]
avi.AVIFileCreateStreamA.restype = c_int
avi.AVISaveOptions.argtypes = [HWND, UINT, c_int, POINTER(c_void_p), c_void_p]
avi.AVISaveOptions.restype = c_int
avi.AVIFileRelease.argtypes = [c_int]
avi.AVIFileRelease.restype = c_int
avi.AVIStreamRelease.argtypes = [c_void_p]
avi.AVIStreamRelease.restype = c_int
if __name__ == "__main__":
avifile = c_int(0)
avi.AVIFileInit()
avi.AVIFileOpenA(pointer(avifile), LPCSTR("__tmp__.avi"),
OF_WRITE | OF_CREATE, 0)
aviinfo = AVISTREAMINFOA()
aviinfo.fccType = fourcc("vids")
stream = c_void_p(0)
avi.AVIFileCreateStreamA(avifile, pointer(stream), pointer(aviinfo))
opt = AVICOMPRESSOPTIONS()
popt = ctypes.pointer(opt)
opt.fccType = fourcc("vids")
avi.AVISaveOptions(0, 0, 1, pointer(stream), pointer(ctypes.pointer(opt)))
print unfourcc(opt.fccHandler)
avi.AVIStreamRelease(stream)
import ctypes
from ctypes.wintypes import LPCSTR, UINT
import os
a1800dll = ctypes.WinDLL('a1800.dll')
# enc doesn't seem to work - need to double-check the parms
encproto = ctypes.WINFUNCTYPE(ctypes.c_uint, LPCSTR, LPCSTR, UINT, ctypes.POINTER(UINT), UINT)
encparamflags = ((1, 'infile'), (1, 'outfile'), (1, 'samprate', 16001), (2, 'fh'), (1,'unk', 0))
encfunc = encproto(('enc', a1800dll), encparamflags)
decproto = ctypes.WINFUNCTYPE(ctypes.c_uint, LPCSTR, LPCSTR, ctypes.POINTER(UINT), UINT, UINT)
decparamflags = ((1, 'infile'), (1, 'outfile'), (2, 'fp'), (1, 'unk1', 16000), (1,'unk2', 0))
decfunc = decproto(('dec', a1800dll), decparamflags)
#ret=encfunc(infile=LPCSTR('cow1.wav'.encode('ascii')), outfile=LPCSTR('out.a18'.encode('ascii')))
#print(ret)
#ret=decfunc(infile=LPCSTR('tu003410_4701Ah_115Eh.a18'.encode('ascii')), outfile=LPCSTR('out.wav'.encode('ascii')))
#print(ret)
files=os.listdir('3410') # directory with the a18 files extracted from the DLC
for f in files:
fname = '3410/' + f
outfile = 'wavs/' + f + '.wav' # directy to output to
print(fname)
decfunc(infile=LPCSTR(fname.encode('ascii')), outfile=LPCSTR(outfile.encode('ascii')))
def __new__(cls, obj):
return LPCSTR.__new__(cls, obj.encode("mbcs"))
def send_single_message(pipe_name, msg, packet_size=DEFAULT_PACKET_SIZE):
pipe_name = _create_pipe_name(pipe_name)
while True:
pipe_handle = CreateFile(
pipe_name,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL
)
if pipe_handle != INVALID_HANDLE_VALUE:
break
if GetLastError() != ERROR_PIPE_BUSY:
pass
elif WaitNamedPipe(pipe_name, 2000) == 0:
CloseHandle(pipe_handle)
return False
pipe_mode = ULONG(PIPE_READMODE_MESSAGE)
result = SetNamedPipeHandleState(
pipe_handle,
ctypes.byref(pipe_mode),
NULL,
NULL
)
if not result:
err = GetLastError()
CloseHandle(pipe_handle)
if err:
raise PipeError(err)
else:
raise PipeError(
'send_single_message SetNamedPipeHandleState failed'
)
write_bytes = ULONG(0)
while len(msg) != write_bytes.value:
result = WriteFile(
pipe_handle,
LPCSTR(msg),
len(msg),
ctypes.byref(write_bytes),
None
)
if not result:
err = GetLastError()
if err != ERROR_MORE_DATA:
CloseHandle(pipe_handle)
raise PipeError(err)
result = 0
read_buffer = ctypes.create_string_buffer(packet_size)
read_bytes = ULONG(0)
while not result: # repeat loop if ERROR_MORE_DATA
result = ReadFile(
pipe_handle,
read_buffer,
packet_size,
ctypes.byref(read_bytes),
NULL
)
err = GetLastError()
if err != ERROR_MORE_DATA:
break
CloseHandle(pipe_handle)
return read_buffer.value
def __new__(cls, obj):
return LPCSTR.__new__(cls, obj.encode("mbcs"))
