According to the ctypes callback docs you can define python function

def my_callback(a, p, frame, p1, p2)
    pass

and then create a pointer to a C callable function like this:

callback = write_callback_prototype(my_callback)

This function pointer can then be passed into FLAC

The function ctypes.POINTER takes an argument that is a ctypes type. When you use it in the line

_lib.solve.argtypes = (ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double))

that's exactly what you're doing, since ctypes.c_double is a type.

When later you call it like this:

ctypes.POINTER(p)

the argument isn't a type but an instance of a type - an already initialized variable of type ctypes.c_double.

All you need to do is to create a pointer to the already initialized variables p and q. Just replace ctypes.POINTER(p) with ctypes.byref(p).

I played with this awhile but since the way to instantiate a function with paramflags requires an exported function name and DLL in the syntax, it doesn't account for exported global function pointers.

Of course, you can get the same behavior with a little work by defining a wrapper to allocate and return the output parameter:

_four = function.in_dll( dll, 'four' )
def four(input):
    output = ctypes.c_int()
    _four(output,input)
    return output.value
output = four(5)
print('output =',output)

Post actual code. The C/C++ code doesn't compile as either C or C++. The Python code has syntax errors (] ending function call Foo). The code below works. The main issue after fixing syntax and compiler errors was declaring the function __stdcall so windll could be used in the Python code. The other option is to use __cdecl (normally the default) and use cdll instead of windll in the Python code.

mydll.c (cl /W4 /LD mydll.c)

#include <stdlib.h>

__declspec(dllexport) void __stdcall Foo(unsigned char** ppMem, int* pSize)
{
    char i;
    *pSize = 4;
    *ppMem = malloc(*pSize);
    for(i = 0; i < *pSize; i++)
        (*ppMem)[i] = i;
}

demo.py (Python 2/3 and 32-/64-bit compatible)

from __future__ import print_function
from ctypes import *

Foo = WinDLL('./mydll').Foo
Foo.argtypes = POINTER(POINTER(c_ubyte)), POINTER(c_int)
Foo.restype = None

mem = POINTER(c_ubyte)()
size = c_int()
Foo(byref(mem),byref(size))
print(size.value, mem[0], mem[1], mem[2], mem[3])

Output

4 0 1 2 3