%PDF-
%PDF-
Mini Shell
Mini Shell
from ctypes import c_int, c_double, c_char_p, byref, \
CFUNCTYPE, POINTER, string_at
from bento4 import *
from bento4.errors import check_result, SUCCESS, ERROR_READ_FAILED, FAILURE, \
ERROR_WRITE_FAILED, ERROR_EOS, ERROR_OUT_OF_RANGE, \
ERROR_NOT_SUPPORTED
class ByteStream(object):
"""abstract ByteStream class"""
def __init__(self, bt4stream):
self.bt4stream = bt4stream
super(ByteStream, self).__init__()
def __del__(self):
lb4.AP4_ByteStream_Release(self.bt4stream)
@property
def size(self):
v = Ap4LargeSize()
f = lb4.AP4_ByteStream_GetSize
f.restype = check_result
f(self.bt4stream, byref(v))
return v.value
def read_partial(self, bytes_to_read):
bytes_read = Ap4Size()
p = create_string_buffer(bytes_to_read)
f = lb4.AP4_ByteStream_ReadPartial
f.restype = check_result
f(self.bt4stream, p, Ap4Size(bytes_to_read), byref(bytes_read))
return (p.raw, bytes_read.value)
def read(self, bytes_to_read):
p = create_string_buffer(bytes_to_read)
f = lb4.AP4_ByteStream_Read
f.restype = check_result
f(self.bt4stream, p, Ap4Size(bytes_to_read))
return p.raw
def read_double(self):
v = c_double()
f = lb4.AP4_ByteStream_ReadDouble
f.restype = check_result
f(self.bt4stream, byref(v))
return v.value
def read_ui64(self):
v = Ap4UI64()
f = lb4.AP4_ByteStream_ReadUI64
f.restype = check_result
f(self.bt4stream, byref(v))
return v.value
def read_ui32(self):
v = Ap4UI32()
f = lb4.AP4_ByteStream_ReadUI32
f.restype = check_result
f(self.bt4stream, byref(v))
return v.value
def read_ui24(self):
v = Ap4UI32()
f = lb4.AP4_ByteStream_ReadUI24
f.restype = check_result
f(self.bt4stream, byref(v))
return v.value
def read_ui16(self):
v = Ap4UI16()
f = lb4.AP4_ByteStream_ReadUI16
f.restype = check_result
f(self.bt4stream, byref(v))
return v.value
def read_ui08(self):
v = Ap4UI08()
f = lb4.AP4_ByteStream_ReadUI08
f.restype = check_result
f(self.straem, byref(v))
return v.value
def read_string(self, length):
p = create_string_buffer(length+1)
f = lb4.AP4_ByteStream_ReadString
f.restype = check_result
f(self.bt4stream, p, Ap4Size(length+1))
return p.value
def write_partial(self, buffer):
bytes_written = Ap4Size()
f = lb4.AP4_ByteStream_WritePartial
f.restype = check_result
f(self.bt4stream, c_char_p(buffer),
Ap4Size(len(buffer)),byref(bytes_written))
return bytes_written
def write(self, buffer):
f = lb4.AP4_ByteStream_Write
f.restype = check_result
f(self.bt4stream, c_char_p(buffer), Ap4Size(len(buffer)))
def write_double(self, value):
f = lb4.AP4_ByteStream_WriteDouble
f.restype = check_result
f(self.bt4stream, c_double(value))
def write_ui64(self, value):
f = lb4.AP4_ByteStream_WriteUI64
f.restype = check_result
f(self.bt4stream, Ap4UI64(value))
def write_ui32(self, value):
f = lb4.AP4_ByteStream_WriteUI32
f.restype = check_result
f(self.bt4stream, Ap4UI32(value))
def write_ui24(self, value):
f = lb4.AP4_ByteStream_WriteUI24
f.restype = check_result
f(self.bt4stream, Ap4UI32(value))
def write_ui16(self, value):
f = lb4.AP4_ByteStream_WriteUI16
f.restype = check_result
f(self.bt4stream, Ap4UI16(value))
def write_ui08(self, value):
f = lb4.AP4_ByteStream_WriteUI08
f.restype = check_result
f(self.bt4stream, Ap4UI08(value))
def write_string(self, value):
f = lb4.AP4_ByteStream_Write
f.restype = check_result
f(self.bt4stream, c_char_p(buffer))
def copy_to(self, receiver, size):
f = lb4.AP4_ByteStream_CopyTo
f.restype = check_result
f(self.bt4stream, receiver.stream, AP4_Size(size))
def seek(self, position):
f = lb4.AP4_ByteStream_Seek
f.restype = check_result
f(self.bt4stream, Ap4Position(position))
def flush(self):
f = lb4.AP4_ByteStream_Flush
f.restype = check_result
f(self.bt4stream)
def tell(self):
pos = Ap4Position()
f = lb4.AP4_ByteStream_Tell
f.restype = check_result
f(self.bt4stream, byref(pos))
return pos.value
class MemoryByteStream(ByteStream):
@staticmethod
def from_buffer(buffer):
"""Factory method"""
buffer_size = Ap4Size(len(buffer))
bt4stream = lb4.AP4_MemoryByteStream_FromBuffer(c_char_p(buffer),
buffer_size)
return MemoryByteStream(bt4stream=bt4stream)
def __init__(self, size=0, bt4stream=None):
if bt4stream is None:
bt4stream = lb4.AP4_MemoryByteStream_Create(Ap4Size(size))
super(MemoryByteStream, self).__init__(bt4stream)
class FileByteStream(ByteStream):
MODE_READ = 0
MODE_WRITE = 1
MODE_READ_WRITE = 2
def __init__(self, name, mode):
result = Ap4Result(0)
f = lb4.AP4_FileByteStream_Create
bt4stream = f(c_char_p(name), c_int(mode), byref(result))
check_result(result)
super(FileByteStream, self).__init__(bt4stream)
class ByteStreamDelegate(Structure):
pass
read_partial_proto = CFUNCTYPE(Ap4Result,
POINTER(ByteStreamDelegate),
POINTER(Ap4Byte),
Ap4Size,
POINTER(Ap4Size))
write_partial_proto = CFUNCTYPE(Ap4Result,
POINTER(ByteStreamDelegate),
c_void_p,
Ap4Size,
POINTER(Ap4Size))
seek_proto = CFUNCTYPE(Ap4Result,
POINTER(ByteStreamDelegate),
Ap4Position)
tell_proto = CFUNCTYPE(Ap4Result,
POINTER(ByteStreamDelegate),
POINTER(Ap4Position))
get_size_proto = CFUNCTYPE(Ap4Result,
POINTER(ByteStreamDelegate),
POINTER(Ap4LargeSize))
flush_proto = CFUNCTYPE(Ap4Result,
POINTER(ByteStreamDelegate))
ByteStreamDelegate._fields_ = [("read_partial", read_partial_proto),
("write_partial", write_partial_proto),
("seek", seek_proto),
("tell", tell_proto),
("get_size", get_size_proto),
("flush", flush_proto),
("destroy", c_void_p), # must be set to None
("oid", c_int)] # object id
# dict where we are going to store the pybytestream instances by id
PYSTREAM_OBJECTS = {}
def delegate_read_partial(pdelegate, buffer, bytes_to_read, bytes_read):
pystream = PYSTREAM_OBJECTS[pdelegate[0].oid]
return pystream.c_read_partial(buffer,
bytes_to_read,
bytes_read)
def delegate_read_partial(pdelegate, buffer, bytes_to_write, bytes_written):
pystream = PYSTREAM_OBJECTS[pdelegate[0].oid]
return pystream.c_write_partial(buffer,
bytes_to_write,
bytes_written)
def delegate_seek(pdelegate, position):
pystream = PYSTREAM_OBJECTS[pdelegate[0].oid]
return pystream.c_seek(position)
def delegate_tell(pdelegate, position):
pystream = PYSTREAM_OBJECTS[pdelegate[0].oid]
return pystream.c_tell(position)
def delegate_get_size(pdelegate, size):
pystream = PYSTREAM_OBJECTS[pdelegate[0].oid]
return pystream.c_get_size(size)
def delegate_flush(pdelegate, size):
pystream = PYSTREAM_OBJECTS[pdelegate[0].oid]
return pystream.c_flush()
class PyByteStream(ByteStream):
def __init__(self, pystream):
self.delegate = ByteStreamDelegate(
read_partial=read_partial_proto(delegate_read_partial),
write_partial=write_partial_proto(delegate_write_partial),
seek=seek_proto(delegate_seek),
tell=tell_proto(delegate_tell),
get_size=get_size_proto(delegate_get_size),
flush=flush_proto(delegate_flush),
destroy=None,
oid=id(stream))
PYSTREAM_OBJECTS[id(pystream)] = pystream # store the stream
bt4stream = lb4.AP4_ByteStream_FromDelegate(byref(self.delegate))
super(PyByteStream, self).__init__(bt4stream)
def c_read_partial(self, buffer, bytes_to_read, bytes_read):
return ERROR_NOT_SUPPORTED
def c_write_partial(self, buffer, bytes_to_write, bytes_written):
return ERROR_NOT_SUPPORTED
def c_seek(self, position):
return ERROR_NOT_SUPPORTED
def c_tell(self, position):
return ERROR_NOT_SUPPORTED
def c_get_size(self, size):
return ERROR_NOT_SUPPORTED
def c_flush(self):
return ERROR_NOT_SUPPORTED
class PyFileByteStream(PyByteStream):
def __init__(self, file, size=0):
self.file = file
self.size = size
super(PyFileByteStream, self).__init__(self)
def c_read_partial(self, buffer, bytes_to_read, bytes_read):
try:
s = self.file.read(bytes_to_read)
bytes_read[0] = len(s)
buffer[:bytes_to_read] = s[:bytes_to_read] # copy the buffer
except EOFError:
return ERROR_EOS
except IOError:
return READ_FAILED
return SUCCESS
def c_write_partial(self, buffer, bytes_to_write, bytes_written):
try:
self.file.write(string_at(buffer, bytes_to_write))
bytes_written[0] = bytes_to_write
except IOError:
return WRITE_FAILED
return SUCCESS
def c_seek(self, position):
try:
self.file.seek(position)
except Exception:
return ERROR_OUT_OF_RANGE
return SUCCESS
def c_tell(self, position):
try:
position[0] = self.file.tell()
except Exception:
return FAILURE
return SUCCESS
def c_get_size(self, size):
if self.size:
size[0] = self.size
return SUCCESS
else:
return ERROR_NOT_SUPPORTED
def c_flush(self):
try:
self.file.flush()
except Exception:
return FAILURE
return SUCCESS
Zerion Mini Shell 1.0