media_new_callbacks: c_char_p for foreign buffer

[albestro]

DISCLAIMER
I'm new both to libvlc and ctypes, so please correct me if I'm wrong on something.

I'm experimenting with media_new_callbacks and I addressed some problems defining the read callback read_cb.

In libvlc the signature for the read callback is defined as

typedef ssize_t(* libvlc_media_read_cb) (void *opaque, unsigned char *buf, size_t len)

where the 2nd argument unsigned char *buf points to a buffer allocated by VLC and that the callback implementation should populate.

In python-vlc this signature is mapped to vlc.CallbackDecorators.MediaReadCb that is

MediaReadCb = ctypes.CFUNCTYPE(
  ctypes.c_void_p,
  ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t)

where the type of the 2nd argument (the 3rd of this signature, since the 1st should be the return type) is ctypes.c_char_p.

In my knowledge, ctypes.c_char_p does not allow to change the value of the pointed data, and if you request the value, you get a copy of it (usually, I see it used with immutable objects). Moreover, inside the callback, the buffer parameter is automatically translated to a <class bytes>, so I was not able to populate the VLC buffer.

After a lot of tests, I decided to use my own signature of MediaReadCb by changing c_char_p to POINTER(c_char), which now is

MediaReadCb = ctypes.CFUNCTYPE(
  ctypes.c_void_p,
  ctypes.c_void_p, ctypes.POINTER(c_char), ctypes.c_size_t)

and now from inside the read callback, I'm able to do something like

@MediaReadCb
def media_read_cb(opaque, buffer, length):
  # ...
  new_data = stream.read() # stream is a _io.BufferedReader
  bytes_read = len(new_data)
  buffer_array = ctypes.cast(buffer, ctypes.POINTER(ctypes.c_char * length))
  ctypes.memmove(buffer_array, new_data, bytes_read)

and it works!

Is this a real problem or I can do it with c_char_p (can I cast it or get the pointer? from ctypes documentation I didn't find anything in the direction of "pointer to mutable").

Thank you in advance for any feedback!

[daniel5gh]

Just for reference, this looks like it is similar to what I encountered with callbacks for video_set_callbacks

#17

[oaubert]

Your solution seems appropriate. It could be generalized into a helper function, to use in all relevant locations. The issue here is to be able to distinguish in the generator between the cases where c_char_p is appropriate, and the cases where a cast/memmove is necessary. This does not seem possible by introspecting the code alone, some heuristics have to be found. I will gladly integrate contributions if you get something.

[albestro]

After a quick look at the code, I see that constness information for parameters is discarded

python-vlc/generator/generate.py

Lines 688 to 696 in 74bcbb0

	def parse_param(self, param):
	"""Parse a C parameter expression.
	It is used to parse the type/name of functions
	and type/name of the function parameters.
	@return: a Par instance.
	"""
	t = param.replace('const', '').strip()

You may have already evaluated to use this information to distinguish between immutable/mutable data, and so to use it to decide whether to use c_char_p or POINTER(c_char).

What do you think about this?

[oaubert]

Well spotted, it would be a first step to allow for proper ctypes mapping. This could be stored as a new property of the Par class, which would allow to do specific mapping. Do you want to try it?