static void
port_info(int to, void *to_arg)
{
int i;
for (i = 0; i < erts_max_ports; i++)
print_port_info(to, to_arg, i);
}
static void
port_info(int to, void *to_arg)
{
int i, max = erts_ptab_max(&erts_port);
for (i = 0; i < max; i++) {
Port *p = erts_pix2port(i);
if (p)
print_port_info(p, to, to_arg);
}
}
/* Prints info about NAME translated through X to STREAM, in a way described
by the flags in SHOW. If TYPE is non-zero, it should be what
mach_port_type returns for NAME in X->to_task. */
error_t
print_xlated_port_info (mach_port_t name, mach_port_type_t type,
struct port_name_xlator *x,
unsigned show, FILE *stream)
{
mach_port_t old_name = name;
error_t err = port_name_xlator_xlate (x, name, type, &name, &type);
if (! err)
{
fprintf (stream, (show & PORTINFO_HEX_NAMES) ? "%#6zx => " : "%6zd => ",
old_name);
err = print_port_info (name, type, x->to_task, show, stream);
}
return err;
}
int main(int argc, char **argv)
{
int i;
char *decodeComponentName;
char *renderComponentName;
int err;
ILCLIENT_T *handle;
COMPONENT_T *decodeComponent;
COMPONENT_T *renderComponent;
COMPONENT_T *fxComponent;
int do_deinterlace = 0;
if (argc >= 2)
{
IMG = argv[1];
}
if (argc >= 3)
{
if (strcmp(argv[2],"d")==0)
do_deinterlace = 1;
}
FILE *fp = fopen(IMG, "r");
int toread = get_file_size(IMG);
OMX_BUFFERHEADERTYPE *buff_header;
decodeComponentName = "video_decode";
renderComponentName = "video_render";
bcm_host_init();
handle = ilclient_init();
if (handle == NULL)
{
fprintf(stderr, "IL client init failed\n");
exit(1);
}
if (OMX_Init() != OMX_ErrorNone)
{
ilclient_destroy(handle);
fprintf(stderr, "OMX init failed\n");
exit(1);
}
ilclient_set_error_callback(handle,
error_callback,
NULL);
ilclient_set_eos_callback(handle,
eos_callback,
NULL);
setup_decodeComponent(handle, decodeComponentName, &decodeComponent);
setup_renderComponent(handle, renderComponentName, &renderComponent);
if (do_deinterlace)
setup_fxComponent(handle, "image_fx", &fxComponent);
// both components now in Idle state, no buffers, ports disabled
// input port
ilclient_enable_port_buffers(decodeComponent, 130,
NULL, NULL, NULL);
ilclient_enable_port(decodeComponent, 130);
err = ilclient_change_component_state(decodeComponent,
OMX_StateExecuting);
if (err < 0)
{
fprintf(stderr, "Couldn't change state to Executing\n");
exit(1);
}
printState(ilclient_get_handle(decodeComponent));
// Read the first block so that the decodeComponent can get
// the dimensions of the video and call port settings
// changed on the output port to configure it
while (toread > 0)
{
buff_header =
ilclient_get_input_buffer(decodeComponent,
130,
1 /* block */);
if (buff_header != NULL)
{
read_into_buffer_and_empty(fp,
decodeComponent,
buff_header,
&toread);
// If all the file has been read in, then
// we have to re-read this first block.
// Broadcom bug?
if (toread <= 0)
{
printf("Rewinding\n");
// wind back to start and repeat
fp = freopen(IMG, "r", fp);
toread = get_file_size(IMG);
}
}
if (toread > 0 && ilclient_remove_event(decodeComponent, OMX_EventPortSettingsChanged, 131, 0, 0, 1) == 0)
{
printf("Removed port settings event\n");
break;
}
else
{
printf("No port setting seen yet\n");
}
// wait for first input block to set params for output port
if (toread == 0)
{
// wait for first input block to set params for output port
err = ilclient_wait_for_event(decodeComponent,
OMX_EventPortSettingsChanged,
131, 0, 0, 1,
ILCLIENT_EVENT_ERROR | ILCLIENT_PARAMETER_CHANGED,
2000);
if (err < 0)
{
fprintf(stderr, "No port settings change\n");
//exit(1);
}
else
{
printf("Port settings changed\n");
break;
}
}
}
// set the decode component to idle and disable its ports
err = ilclient_change_component_state(decodeComponent,
OMX_StateIdle);
if (err < 0)
{
fprintf(stderr, "Couldn't change state to Idle\n");
exit(1);
}
ilclient_disable_port(decodeComponent, 131);
ilclient_disable_port_buffers(decodeComponent, 131,
NULL, NULL, NULL);
if (do_deinterlace)
{
// set up the tunnel between decode and fx ports
err = OMX_SetupTunnel(ilclient_get_handle(decodeComponent),
131,
ilclient_get_handle(fxComponent),
190);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting up tunnel 1 %X\n", err);
exit(1);
}
else
{
printf("Tunnel 1 set up ok\n");
}
// set up the tunnel between fx and render ports
err = OMX_SetupTunnel(ilclient_get_handle(fxComponent),
191,
ilclient_get_handle(renderComponent),
90);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting up tunnel 2 %X\n", err);
exit(1);
}
else
{
printf("Tunnel 2 set up ok\n");
}
}
else
{
// set up the tunnel between decode and render ports
err = OMX_SetupTunnel(ilclient_get_handle(decodeComponent),
131,
ilclient_get_handle(renderComponent),
90);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting up tunnel %X\n", err);
exit(1);
}
else
{
printf("Tunnel set up ok\n");
}
}
// Okay to go back to processing data
// enable the decode output ports
//UNNECESSARY?? PGB OMX_SendCommand(ilclient_get_handle(decodeComponent),
//UNNECESSARY?? PGB OMX_CommandPortEnable, 131, NULL);
ilclient_enable_port(decodeComponent, 131);
if (do_deinterlace)
{
setup_shared_buffer_format(decodeComponent, 131, fxComponent, 191);
// enable fx ports
ilclient_enable_port(fxComponent, 190);
ilclient_enable_port(fxComponent, 191);
//UNNECESSARY?? PGB OMX_SendCommand(ilclient_get_handle(renderComponent),
//UNNECESSARY?? PGB OMX_CommandPortEnable, 90, NULL);
// setup_shared_buffer_format(fxComponent, renderComponent);
}
// enable the render output ports
ilclient_enable_port(renderComponent, 90);
// set all components to executing state
err = ilclient_change_component_state(decodeComponent,
OMX_StateExecuting);
if (err < 0)
{
fprintf(stderr, "Couldn't change decode to Executing\n");
exit(1);
}
if (do_deinterlace)
{
err = ilclient_change_component_state(fxComponent,
OMX_StateExecuting);
if (err < 0)
{
fprintf(stderr, "Couldn't change fx to Executing\n");
exit(1);
}
}
err = ilclient_change_component_state(renderComponent,
OMX_StateExecuting);
if (err < 0)
{
fprintf(stderr, "Couldn't change render to Executing\n");
exit(1);
}
print_port_info(ilclient_get_handle(decodeComponent), 131);
if (do_deinterlace)
{
print_port_info(ilclient_get_handle(fxComponent), 190);
print_port_info(ilclient_get_handle(fxComponent), 191);
}
print_port_info(ilclient_get_handle(renderComponent), 90);
// now work through the file
while (toread > 0)
{
OMX_ERRORTYPE r;
// do we have a decode input buffer we can fill and empty?
buff_header =
ilclient_get_input_buffer(decodeComponent,
130,
1 /* block */);
if (buff_header != NULL)
{
read_into_buffer_and_empty(fp,
decodeComponent,
buff_header,
&toread);
}
usleep(100000);
// print_port_info(ilclient_get_handle(renderComponent), 90);
}
ilclient_wait_for_event(renderComponent,
OMX_EventBufferFlag,
90, 0, OMX_BUFFERFLAG_EOS, 0,
ILCLIENT_BUFFER_FLAG_EOS, 10000);
printf("EOS on render\n");
sleep(100);
exit(0);
}
static int
aoeadm_list_ports(int argc, char **argv)
{
AOE_STATUS ret;
aoe_port_list_t *portlist = NULL;
char c;
dladm_handle_t handle;
int i;
int portid = -1;
int verbose = 0;
uint32_t nports;
while ((c = getopt(argc, argv, "v")) != -1) {
switch (c) {
case 'v':
verbose = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc == 1) {
errno = 0;
portid = strtol(argv[0], (char **)NULL, 10);
if (errno != 0 || portid < 0)
usage();
}
ret = aoe_get_port_list(&nports, &portlist);
if (ret != AOE_STATUS_OK) {
(void) fprintf(stderr, _("Failed to list ports: %s\n"),
aoe_strerror(ret));
return (ret);
}
if (nports == 0) {
free(portlist);
return (0);
}
if (dladm_open(&handle) != DLADM_STATUS_OK)
handle = NULL;
for (i = 0; i < nports; i++) {
aoe_port_instance_t *pi = &portlist->ports[i];
char linknames[AOE_MAX_MACOBJ * MAXLINKNAMELEN];
int j;
if (portid >= 0 && pi->api_port_id != portid)
continue;
if ((pi->api_port_type == AOE_CLIENT_INITIATOR &&
strcmp(cmdname, "list-target") == 0) ||
(pi->api_port_type == AOE_CLIENT_TARGET &&
strcmp(cmdname, "list-initiator") == 0))
continue;
/* Convert linkid to interface name */
for (j = 0; j < pi->api_mac_cnt; j++) {
aoe_mac_instance_t *mi = &pi->api_mac[j];
char *linkname = linknames + j * MAXLINKNAMELEN;
if (handle == NULL ||
dladm_datalink_id2info(handle, mi->ami_mac_linkid,
NULL, NULL, NULL, linkname, MAXLINKNAMELEN - 1) !=
DLADM_STATUS_OK)
(void) strcpy(linkname, "<unknown>");
}
print_port_info(pi, linknames, verbose);
if (portid >= 0) {
if (handle != NULL)
dladm_close(handle);
free(portlist);
return (0);
}
}
if (handle != NULL)
dladm_close(handle);
free(portlist);
return (portid >= 0 ? 1 : 0);
}
int
main (int argc, char **argv)
{
error_t err;
task_t task;
int search = 0;
unsigned show = 0; /* what info we print */
mach_port_type_t only = 0, target_only = 0; /* Which names to show */
task_t xlate_task = MACH_PORT_NULL;
int no_translation_errors = 0; /* inhibit complaints about bad names */
struct port_name_xlator *xlator = 0;
/* Parse our options... */
error_t parse_opt (int key, char *arg, struct argp_state *state)
{
switch (key)
{
case 'v': show |= PORTINFO_DETAILS; break;
case 'm': show |= PORTINFO_MEMBERS; break;
case 'x': show |= PORTINFO_HEX_NAMES; break;
case 'r': only |= MACH_PORT_TYPE_RECEIVE; break;
case 's': only |= MACH_PORT_TYPE_SEND; break;
case 'o': only |= MACH_PORT_TYPE_SEND_ONCE; break;
case 'd': only |= MACH_PORT_TYPE_DEAD_NAME; break;
case 'p': only |= MACH_PORT_TYPE_PORT_SET; break;
case 'R': target_only |= MACH_PORT_TYPE_RECEIVE; break;
case 'S': target_only |= MACH_PORT_TYPE_SEND; break;
case 'O': target_only |= MACH_PORT_TYPE_SEND_ONCE; break;
case 't': xlate_task = parse_task (arg); break;
case 'a': search = 1; break;
case 'E': no_translation_errors = 1; break;
case '*':
hold = 1;
while (hold)
sleep (1);
break;
case ARGP_KEY_NO_ARGS:
argp_usage (state);
return EINVAL;
case ARGP_KEY_ARG:
if (state->arg_num == 0)
/* The task */
{
task = parse_task (arg);
if (only == 0)
only = ~0;
if (target_only == 0)
target_only = ~0;
if (xlate_task != MACH_PORT_NULL)
{
if (search)
argp_error (state,
"Both --search and --translate specified");
err = port_name_xlator_create (task, xlate_task, &xlator);
if (err)
error (13, err, "Cannot setup task translation");
}
if (state->next == state->argc)
/* No port names specified, print all of them. */
{
if (xlator)
err = print_xlated_task_ports_info (xlator, only,
show, stdout);
else
err = print_task_ports_info (task, only, show, stdout);
if (err)
error (12, err, "%s", arg);
}
break;
}
/* A port name */
{
char *end;
mach_port_t name = strtoul (arg, &end, 0);
if (name == 0)
error (0, 0, "%s: Invalid port name", arg);
else
{
if (xlator)
{
err = print_xlated_port_info (name, 0, xlator,
show, stdout);
if (err && no_translation_errors)
break;
}
else
err = print_port_info (name, 0, task, show, stdout);
if (err)
error (0, err, "%s", arg);
}
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
const struct argp argp = { options, parse_opt, args_doc, doc };
/* Parse our arguments. */
argp_parse (&argp, argc, argv, 0, 0, 0);
exit (0);
}
