def run(self, element, context):
alias = element.get('comp')
name = context.cnames[alias]
evtstr = element.get('evt')
log_api ("%s '%s' '%s'" \
% (element.tag, name, evtstr ))
handle = context.handles[alias]
evt = get_il_enum_from_string(evtstr)
if (handle != None):
if (evt == OMX_EventCmdComplete):
context.cmdevents[handle.value].clear()
elif (evt == OMX_EventBufferFlag):
context.eosevents[handle.value].clear()
elif (evt == OMX_EventPortSettingsChanged):
context.settings_changed_events[handle.value].clear()
else:
log_line ()
log_line ("Unhandled event %s" % (evtstr))
return get_il_enum_from_string("OMX_ErrorNotImplemented")
else:
log_line ()
log_line ("Unknown handle")
return get_il_enum_from_string("OMX_ErrorUndefined")
return 0
def run(self, element, context):
alias = element.get('comp')
name = context.cnames[alias]
cmdstr = element.get('cmd')
nparam1str = element.get('nparam1')
cmddatastr = element.get('cmddata')
log_api ("%s '%s' '%s' '%s' '%s'" \
% (element.tag, name, cmdstr, nparam1str, cmddatastr))
handle = context.handles[alias]
cmd = get_il_enum_from_string(cmdstr)
if (cmd == OMX_CommandPortEnable or cmd == OMX_CommandPortDisable):
# nParam1 is the port index to be enabled/disabled, not an enum
nparam1 = int(nparam1str)
else:
nparam1 = get_il_enum_from_string(nparam1str)
if (handle != None):
context.cmdevents[handle.value].clear()
omxerror = OMX_SendCommand(handle, cmd, nparam1, None)
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
log_result (element.tag + " '" + name + "'", err)
if (err == "OMX_ErrorNone"):
return 0
else:
return interror
def run(self, element, context):
alias = element.get('comp')
name = context.cnames[alias]
evtstr = element.get('evt')
log_api ("%s '%s' '%s'" \
% (element.tag, name, evtstr ))
handle = context.handles[alias]
evt = get_il_enum_from_string(evtstr)
if (handle != None):
if (evt == OMX_EventCmdComplete):
context.cmdevents[handle.value].clear()
elif (evt == OMX_EventBufferFlag):
context.eosevents[handle.value].clear()
elif (evt == OMX_EventPortSettingsChanged):
context.settings_changed_events[handle.value].clear()
elif (evt == OMX_EventPortFormatDetected):
context.format_detected_events[handle.value].clear()
else:
log_line()
log_line("Unhandled event %s" % (evtstr))
return get_il_enum_from_string("OMX_ErrorNotImplemented")
else:
log_line()
log_line("Unknown handle")
return get_il_enum_from_string("OMX_ErrorUndefined")
return 0
def encode_video_portdef (param_struct, param2_type, element):
for name, _ in param2_type._fields_:
for name2, val2 in element.items():
if (name2 == name):
if (name == "eColorFormat"):
val2 = get_il_enum_from_string(val2)
if (name == "eCompressionFormat"):
val2 = get_il_enum_from_string(val2)
setattr(param_struct.format.video, name, int(val2))
def run(self, element, context):
indexstr = element.get('index')
alias = element.get('alias')
name = context.cnames[alias]
portstr = element.get('port')
log_api ("%s '%s' '%s:Port-%d'" \
% (element.tag, indexstr, name, int(portstr)))
handle = context.handles[alias]
index = get_il_enum_from_string(indexstr)
param_type = omxil12_indexes[indexstr]
param_struct = param_type()
param_struct.nSize = sizeof(param_type)
if (portstr != None):
param_struct.nPortIndex = int(portstr)
if (handle != None):
omxerror = OMX_GetConfig(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
for name, val in param_type._fields_:
for name2, val2 in element.items():
if (name2 == name):
getattr(param_struct, name, int(val2))
omxerror = OMX_GetConfig(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
domstr = ""
err = get_string_from_il_enum(interror, "OMX_Error")
log_line ()
log_line ("%s" % param_struct.__class__.__name__, 1)
for name, val in param_type._fields_:
if (name == "nVersion"):
log_line ("%s -> '%08x'" \
% (name, param_struct.nVersion.nVersion), 1)
else:
log_line ("%s -> '%s'" \
% (name, getattr(param_struct, name)), 1)
log_result(element.tag, err)
if (err == "OMX_ErrorNone"):
return 0
else:
return interror
else:
log_line ("%s -> '%s %s'" \
% (element.tag, \
"Could not find handle for", context.cnames[alias]))
return get_il_enum_from_string("OMX_ErrorUndefined")
def run(self, element, context):
indexstr = "OMX_IndexParamContentURI"
alias = element.get('alias')
name = context.cnames[alias]
# This param struct does not have a port index.
# portstr = element.get('port')
log_api ("%s '%s' '%s'" \
% (element.tag, indexstr, name))
handle = context.handles[alias]
index = get_il_enum_from_string(indexstr)
param_type = OMX_PARAM_CONTENTURITYPE
param_struct = param_type()
param_struct.nSize = sizeof(param_type)
# This param struct does not have a port index.
# if (portstr != None):
# param_struct.nPortIndex = int(portstr)
if (handle != None):
omxerror = OMX_GetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
uristr = c_char_p()
uristr = cast(param_struct.contentURI, c_char_p)
log_line ()
log_line ("%s" % param_struct.__class__.__name__, 1)
for name, _ in param_type._fields_:
if (name == "nVersion"):
log_line ("%s -> '%08x'" \
% (name, param_struct.nVersion.nVersion), 1)
elif (name == "contentURI"):
log_param (name, uristr.value, 1)
else:
log_param (name, str(getattr(param_struct, name)), 1)
log_result (element.tag, err)
if (err == "OMX_ErrorNone"):
return 0
else:
return interror
else:
log_line ("%s -> '%s %s'" \
% (element.tag, \
"Could not find handle for", context.cnames[alias]))
return get_il_enum_from_string("OMX_ErrorUndefined")
def run(self, element, context):
indexstr = "OMX_IndexParamContentURI"
alias = element.get('alias')
name = context.cnames[alias]
log_api ("%s '%s' '%s'" \
% (element.tag, indexstr, name))
handle = context.handles[alias]
index = get_il_enum_from_string(indexstr)
param_type = OMX_PARAM_CONTENTURITYPE
param_struct = param_type()
param_struct.nSize = sizeof(param_type)
if (handle != None):
omxerror = OMX_GetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
uristr = c_char_p()
uristr = cast(param_struct.contentURI, c_char_p)
log_line ()
log_line ("%s" % param_struct.__class__.__name__, 1)
for name, _ in param_type._fields_:
if (name == "nVersion"):
log_line ("%s -> '%08x'" \
% (name, param_struct.nVersion.nVersion), 1)
elif (name == "URI"):
log_param (name, uristr.value, 1)
else:
log_param (name, str(getattr(param_struct, name)), 1)
log_result (element.tag, err)
if (err == "OMX_ErrorNone"):
return 0
else:
return interror
else:
log_line ("%s -> '%s %s'" \
% (element.tag, \
"Could not find handle for", context.cnames[alias]))
return get_il_enum_from_string("OMX_ErrorUndefined")
def run(self, element, context):
alias = element.get('comp')
name = context.cnames[alias]
errstr = element.get('err')
ndata2str = element.get('ndata2')
log_api ("%s '%s' '%s' '%s'" \
% (element.tag, name, errstr, ndata2str))
handle = context.handles[alias]
err = get_il_enum_from_string(errstr)
# TODO: Check we are receiving an error code
#err = get_string_from_il_enum(interror, "OMX_Error")
if (handle != None):
context.ignored_error_events[handle.value].append(err)
else:
log_line ()
log_line ("Unknown handle")
return get_il_enum_from_string("OMX_ErrorUndefined")
return 0
def run(self, element, context):
alias = element.get('comp')
name = context.cnames[alias]
errstr = element.get('err')
ndata2str = element.get('ndata2')
log_api ("%s '%s' '%s' '%s'" \
% (element.tag, name, errstr, ndata2str))
handle = context.handles[alias]
err = get_il_enum_from_string(errstr)
# TODO: Check we are receiving an error code
#err = get_string_from_il_enum(interror, "OMX_Error")
if (handle != None):
context.ignored_error_events[handle.value].append(err)
else:
log_line()
log_line("Unknown handle")
return get_il_enum_from_string("OMX_ErrorUndefined")
return 0
def run(self, element, context):
indexstr = "OMX_IndexParamStandardComponentRole"
alias = element.get('alias')
name = context.cnames[alias]
rolestr = element.get('role')
log_api ("%s '%s' '%s'" \
% (element.tag, name, rolestr))
handle = context.handles[alias]
index = get_il_enum_from_string(indexstr)
param_type = OMX_PARAM_COMPONENTROLETYPE
param_struct = param_type()
param_struct.nVersion.nVersion = OMX_VERSION
param_struct.nSize = sizeof(param_type)
if (handle != None):
omxerror = OMX_GetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
for name, _ in param_type._fields_:
for name2, val2 in element.items():
if (name != "cRole"):
if (name2 == name):
setattr(param_struct, name, int(val2))
else:
libc = CDLL('libc.so.6')
libc.strcpy(cast(param_struct.cRole, c_char_p),
rolestr)
omxerror = OMX_SetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
rolefield = c_char_p()
rolefield = cast(param_struct.cRole, c_char_p)
log_line ()
log_line ("%s" % param_struct.__class__.__name__, 1)
for name, _ in param_type._fields_:
if (name == "nVersion"):
log_line ("%s -> '%08x'" \
% (name, param_struct.nVersion.nVersion), 1)
elif (name == "cRole"):
log_param (name, rolefield.value, 1)
else:
log_param (name, str(getattr(param_struct, name)), 1)
log_result(element.tag, err)
if (err == "OMX_ErrorNone"):
return 0
else:
return interror
else:
log_line ("%s -> '%s %s'" \
% (element.tag, \
"Could not find handle for", context.cnames[alias]))
return get_il_enum_from_string("OMX_ErrorUndefined")
def run(self, element, context):
indexstr = "OMX_IndexParamContentURI"
uristr = element.get('uri')
alias = element.get('alias')
name = context.cnames[alias]
# Replace '$USER' and '$HOME' strings wih the actual representations
uristr = re.sub("\$USER", pwd.getpwuid(os.getuid())[0], uristr, 1)
uristr = re.sub("\$HOME", pwd.getpwuid(os.getuid())[5], uristr, 1)
log_api ("%s '%s' '%s' '%s'" \
% (element.tag, indexstr, name, uristr))
handle = context.handles[alias]
index = get_il_enum_from_string(indexstr)
param_type = OMX_PARAM_CONTENTURITYPE
param_struct = param_type()
param_struct.nSize = sizeof(param_type)
if (handle != None):
omxerror = OMX_GetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
for name, _ in param_type._fields_:
for name2, val2 in element.items():
if (name != "contentURI"):
if (name2 == name):
setattr(param_struct, name, int(val2))
else:
libc = CDLL('libc.so.6')
libc.strcpy(cast(param_struct.contentURI, c_char_p),
uristr)
omxerror = OMX_SetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
urifield = c_char_p()
urifield = cast(param_struct.contentURI, c_char_p)
log_line ()
log_line ("%s" % param_struct.__class__.__name__, 1)
for name, _ in param_type._fields_:
if (name == "nVersion"):
log_line ("%s -> '%08x'" \
% (name, param_struct.nVersion.nVersion), 1)
elif (name == "contentURI"):
log_param (name, urifield.value, 1)
else:
log_param (name, str(getattr(param_struct, name)), 1)
log_result(element.tag, err)
if (err == "OMX_ErrorNone"):
return 0
else:
return interror
else:
log_line ("%s -> '%s %s'" \
% (element.tag, \
"Could not find handle for", \
context.cnames[alias]))
return get_il_enum_from_string("OMX_ErrorUndefined")
def run(self, element, context):
indexstr = element.get('index')
alias = element.get('alias')
name = context.cnames[alias]
portstr = element.get('port')
log_api ("%s '%s' '%s:Port-%d'" \
"" % (element.tag, indexstr, name, int(portstr)))
handle = context.handles[alias]
index = get_il_enum_from_string(indexstr)
param_type = omxil12_indexes[indexstr]
param_struct = param_type()
param_struct.nSize = sizeof(param_type)
if (portstr != None):
param_struct.nPortIndex = int(portstr)
if (handle != None):
omxerror = OMX_GetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
log_line ()
log_line ("%s" % param_struct.__class__.__name__, 1)
for name, _ in param_type._fields_:
if (name == "nVersion"):
log_line ("%s -> '%08x'" \
% (name, param_struct.nVersion.nVersion),1)
elif (name == "eDir"):
dirstr = get_string_from_il_enum (\
getattr(param_struct, name), "OMX_Dir")
log_param (name, dirstr, 1)
elif (name == "eDomain"):
domstr = get_string_from_il_enum (\
getattr(param_struct, name), "OMX_PortDomain")
log_line ("%s -> '%s'" % (name, domstr),1)
elif (name == "format"):
if (domstr == "OMX_PortDomainAudio"):
param2_type = OMX_AUDIO_PORTDEFINITIONTYPE
decode_audio_portdef (param_struct, param2_type)
elif (domstr == "OMX_PortDomainVideo"):
param2_type = OMX_VIDEO_PORTDEFINITIONTYPE
decode_video_portdef (param_struct, param2_type)
elif (domstr == "OMX_PortDomainImage"):
param2_type = OMX_IMAGE_PORTDEFINITIONTYPE
decode_image_portdef (param_struct, param2_type)
elif (domstr == "OMX_PortDomainOther"):
param2_type = OMX_OTHER_PORTDEFINITIONTYPE
decode_other_portdef (param_struct, param2_type)
else:
log_line ("%s -> '%s'" \
% (name, getattr(param_struct, name)),1)
log_result(element.tag, err)
if (err == "OMX_ErrorNone"):
return 0
else:
return interror
else:
log_line ("%s -> '%s %s'" \
% (element.tag, \
"Could not find handle for", context.cnames[alias]),1)
return get_il_enum_from_string("OMX_ErrorUndefined")
def run (self, manager):
if self.alias not in manager.aliases2ports:
print "allocate_buffer: Wrong alias specified"
sys.exit(1)
if self.pid not in manager.aliases2ports[self.alias]:
print "allocate_buffer: Wrong port index specified"
sys.exit(1)
port = manager.aliases2ports[self.alias][self.pid]
config = get_config()
handle = config.handles[self.alias]
# Retrieve the port definition
indexstr = "OMX_IndexParamPortDefinition"
index = get_il_enum_from_string(indexstr)
param_type = omxil12_indexes[indexstr]
param_struct = param_type()
param_struct.nSize = sizeof(param_type)
param_struct.nPortIndex = int(self.pid)
omxerror = OMX_GetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
port.nBufferCountActual = param_struct.nBufferCountActual
port.nBufferSize = param_struct.nBufferSize
dirstr = get_string_from_il_enum \
(getattr(param_struct, "eDir"), "OMX_Dir")
if "OMX_DirInput" == dirstr:
port.is_input = True
else:
port.is_input = False
if self.howmany.lower() == "all":
self.howmany = port.nBufferCountActual
else:
self.howmany = int(self.howmany)
log_line ("Allocate %d total" % self.howmany)
if self.howmany == 0:
print "allocate_buffer: Need to allocate at least 1 buffer"
sys.exit(1)
if port.allocation_count + self.howmany > \
port.nBufferCountActual:
print "allocate_buffer: Need to allocate at most " \
"nBufferCountActual buffers"
sys.exit(1)
libc = CDLL('libc.so.6')
for i in range(port.allocation_count,
port.allocation_count + self.howmany):
p_header = POINTER(OMX_BUFFERHEADERTYPE)()
if port.allocator:
buf = (c_ubyte * port.nBufferSize)()
omxerror = OMX_UseBuffer(handle,
byref(p_header),
param_struct.nPortIndex,
None,
port.nBufferSize,
buf)
else:
omxerror = OMX_AllocateBuffer(handle,
byref(p_header),
param_struct.nPortIndex,
None,
port.nBufferSize)
port.headers.append(p_header)
port.buffers.append(buf)
port.allocation_count += self.howmany
def run(self, element, context):
indexstr = element.get('index')
alias = element.get('alias')
name = context.cnames[alias]
portstr = element.get('port')
log_api ("%s '%s' '%s:Port-%d'" \
"" % (element.tag, indexstr, name, int(portstr)))
handle = context.handles[alias]
index = get_il_enum_from_string(indexstr)
param_type = omxil12_indexes[indexstr]
param_struct = param_type()
param_struct.nSize = sizeof(param_type)
if (portstr != None):
param_struct.nPortIndex = int(portstr)
if (handle != None):
omxerror = OMX_GetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
log_line()
log_line("%s" % param_struct.__class__.__name__, 1)
for name, _ in param_type._fields_:
if (name == "nVersion"):
log_line ("%s -> '%08x'" \
% (name, param_struct.nVersion.nVersion),1)
elif (name == "eDir"):
dirstr = get_string_from_il_enum (\
getattr(param_struct, name), "OMX_Dir")
log_param(name, dirstr, 1)
elif (name == "eDomain"):
domstr = get_string_from_il_enum (\
getattr(param_struct, name), "OMX_PortDomain")
log_line("%s -> '%s'" % (name, domstr), 1)
elif (name == "format"):
if (domstr == "OMX_PortDomainAudio"):
param2_type = OMX_AUDIO_PORTDEFINITIONTYPE
decode_audio_portdef(param_struct, param2_type)
elif (domstr == "OMX_PortDomainVideo"):
param2_type = OMX_VIDEO_PORTDEFINITIONTYPE
decode_video_portdef(param_struct, param2_type)
elif (domstr == "OMX_PortDomainImage"):
param2_type = OMX_IMAGE_PORTDEFINITIONTYPE
decode_image_portdef(param_struct, param2_type)
elif (domstr == "OMX_PortDomainOther"):
param2_type = OMX_OTHER_PORTDEFINITIONTYPE
decode_other_portdef(param_struct, param2_type)
else:
log_line ("%s -> '%s'" \
% (name, getattr(param_struct, name)),1)
log_result(element.tag, err)
if (err == "OMX_ErrorNone"):
return 0
else:
return interror
else:
log_line ("%s -> '%s %s'" \
% (element.tag, \
"Could not find handle for", context.cnames[alias]),1)
return get_il_enum_from_string("OMX_ErrorUndefined")
def run (self, manager):
if self.alias not in manager.aliases2ports:
print "use_egl_images: Wrong alias specified"
sys.exit(1)
if self.pid not in manager.aliases2ports[self.alias]:
print "use_egl_images: Wrong port index specified"
sys.exit(1)
port = manager.aliases2ports[self.alias][self.pid]
config = get_config()
handle = config.handles[self.alias]
# Retrieve the port definition
indexstr = "OMX_IndexParamPortDefinition"
index = get_il_enum_from_string(indexstr)
param_type = omxil12_indexes[indexstr]
param_struct = param_type()
param_struct.nSize = sizeof(param_type)
param_struct.nPortIndex = int(self.pid)
omxerror = OMX_GetParameter(handle, index, byref(param_struct))
interror = int(omxerror & 0xffffffff)
err = get_string_from_il_enum(interror, "OMX_Error")
port.nBufferCountActual = param_struct.nBufferCountActual
port.nBufferSize = param_struct.nBufferSize
dirstr = get_string_from_il_enum \
(getattr(param_struct, "eDir"), "OMX_Dir")
if "OMX_DirInput" == dirstr:
port.is_input = True
else:
port.is_input = False
if self.howmany.lower() == "all":
self.howmany = port.nBufferCountActual
else:
self.howmany = int(self.howmany)
log_line ("Allocate %d total" % self.howmany)
if self.howmany == 0:
print "use_egl_images: Need to allocate at least 1 buffer"
sys.exit(1)
if port.allocation_count + self.howmany > \
port.nBufferCountActual:
print "use_egl_images: Need to allocate at most " \
"nBufferCountActual buffers"
sys.exit(1)
libc = CDLL('libc.so.6')
for i in range(port.allocation_count,
port.allocation_count + self.howmany):
p_header = POINTER(OMX_BUFFERHEADERTYPE)()
if port.allocator:
print "use_egl_images: Port can't be allocate buffers. " \
"Invalid test setup."
sys.exit(1)
eglimage = (c_ubyte * port.nBufferSize)()
omxerror = OMX_UseEGLImage(handle,
byref(p_header),
param_struct.nPortIndex,
None,
eglimage)
port.headers.append(p_header)
port.buffers.append(eglimage)
port.allocation_count += self.howmany
