JNIEXPORT jint JNICALL Agent_OnLoad(prms_AGENT_ONLOAD)
{
Callbacks CB;
check_AGENT_ONLOAD;
jvmtiEvent events[] = {JVMTI_EVENT_VM_DEATH };
cb_death;
jvmtiEnv *jvmti;
jvmtiError result;
jvmtiCapabilities curr_caps;
jint res = func_for_Agent_OnLoad_JVMTI(vm, options, reserved, &CB,
events, sizeof(events)/4, test_case_name, DEBUG_OUT, &jvmti);
result = jvmti->GetCapabilities(&curr_caps);
fprintf(stderr, "\tnative: GetCapabilities result = %d (must be zero) \n", result);
fprintf(stderr, "\tnative: curr_caps ptr is %p\n", &curr_caps);
fprintf(stderr, "\tnative: curr_caps.can_tag_objects is %d\n", curr_caps.can_tag_objects);
fflush(stderr);
if (result == JVMTI_ERROR_NONE)
{
print_capabilities( curr_caps, "current");
test = true;
}
util = true;
return res;
}
int old_main (int argc, char** argv)
{
IDeckLinkIterator* deckLinkIterator;
IDeckLink* deckLink;
int numDevices = 0;
HRESULT result;
// Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system
deckLinkIterator = CreateDeckLinkIteratorInstance();
if (deckLinkIterator == NULL)
{
fprintf(stderr, "A DeckLink iterator could not be created. The DeckLink drivers may not be installed.\n");
return 1;
}
// Enumerate all cards in this system
while (deckLinkIterator->Next(&deckLink) == S_OK)
{
char * deviceNameString = NULL;
// Increment the total number of DeckLink cards found
numDevices++;
if (numDevices > 1)
printf("\n\n");
// *** Print the model name of the DeckLink card
result = deckLink->GetModelName((const char **) &deviceNameString);
if (result == S_OK)
{
printf("=============== %s ===============\n\n", deviceNameString);
free(deviceNameString);
}
print_attributes(deckLink);
// ** List the video output display modes supported by the card
print_output_modes(deckLink);
// ** List the video input display modes supported by the card
print_input_modes(deckLink);
// ** List the input and output capabilities of the card
print_capabilities(deckLink);
// Release the IDeckLink instance when we've finished with it to prevent leaks
deckLink->Release();
}
deckLinkIterator->Release();
// If no DeckLink cards were found in the system, inform the user
if (numDevices == 0)
printf("No Blackmagic Design devices were found.\n");
printf("\n");
return 0;
}
vector<ofVideoDevice> ofxBlackmagicGrabber::listDevices() {
IDeckLinkIterator* deckLinkIterator;
IDeckLink* deckLink;
int numDevices = 0;
HRESULT result;
vector<ofVideoDevice> devices;
// Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system
deckLinkIterator = CreateDeckLinkIteratorInstance();
if (deckLinkIterator == NULL){
ofLogError(LOG_NAME) << "A DeckLink iterator could not be created. The DeckLink drivers may not be installed.";
}
// Enumerate all cards in this system
while (deckLinkIterator->Next(&deckLink) == S_OK){
CFStringRef deviceNameString;
// Increment the total number of DeckLink cards found
numDevices++;
if (numDevices > 1)
printf("\n\n");
// *** Print the model name of the DeckLink card
result = deckLink->GetModelName(&deviceNameString);
if (result == S_OK)
{
printf("=============== %s ===============\n\n", deviceNameString);
// free(deviceNameString);
}
print_attributes(deckLink);
// ** List the video output display modes supported by the card
print_output_modes(deckLink);
// ** List the input and output capabilities of the card
print_capabilities(deckLink);
// Release the IDeckLink instance when we've finished with it to prevent leaks
deckLink->Release();
}
deckLinkIterator->Release();
// If no DeckLink cards were found in the system, inform the user
if (numDevices == 0)
ofLogError(LOG_NAME) << "No Blackmagic Design devices were found.";
return devices;
}
void audio_capabilities(struct audio_info_struct *ai)
{
int fmts;
int i,j,k,k1=NUM_RATES-1;
struct audio_info_struct ai1 = *ai;
if (param.outmode != DECODE_AUDIO) {
memset(capabilities,1,sizeof(capabilities));
return;
}
memset(capabilities,0,sizeof(capabilities));
if(param.force_rate) {
rates[NUM_RATES-1] = param.force_rate;
k1 = NUM_RATES;
}
/* if audio_open fails, the device is just not capable of anything... */
if(audio_open(&ai1) < 0) {
perror("audio");
}
else
{
for(i=0;i<NUM_CHANNELS;i++) {
for(j=0;j<NUM_RATES;j++) {
ai1.channels = channels[i];
ai1.rate = rates[j];
fmts = audio_get_formats(&ai1);
if(fmts < 0)
continue;
for(k=0;k<NUM_ENCODINGS;k++) {
if((fmts & encodings[k]) == encodings[k])
capabilities[i][k][j] = 1;
}
}
}
audio_close(&ai1);
}
if(param.verbose > 1) print_capabilities(ai);
}
/*
* c=num of channels of stream
* r=rate of stream
* return 0 on error
*/
int audio_fit_capabilities(struct audio_info_struct *ai,int c,int r)
{
int rn;
int f0=0;
if(param.force_8bit) f0 = 2; /* skip the 16bit encodings */
c--; /* stereo=1 ,mono=0 */
/* force stereo is stronger */
if(param.force_mono) c = 0;
if(param.force_stereo) c = 1;
if(param.force_rate) {
rn = rate2num(param.force_rate);
/* 16bit encodings */
if(audio_fit_cap_helper(ai,rn,f0,2,c)) return 1;
/* 8bit encodings */
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c)) return 1;
/* try again with different stereoness */
if(c == 1 && !param.force_stereo) c = 0;
else if(c == 0 && !param.force_mono) c = 1;
/* 16bit encodings */
if(audio_fit_cap_helper(ai,rn,f0,2,c)) return 1;
/* 8bit encodings */
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c)) return 1;
error3("Unable to set up output device! Constraints: %s%s%liHz.",
(param.force_stereo ? "stereo, " :
(param.force_mono ? "mono, " : "")),
(param.force_8bit ? "8bit, " : ""),
param.force_rate);
if(param.verbose <= 1) print_capabilities(ai);
return 0;
}
/* try different rates with 16bit */
rn = rate2num(r>>0);
if(audio_fit_cap_helper(ai,rn,f0,2,c))
return 1;
rn = rate2num(r>>1);
if(audio_fit_cap_helper(ai,rn,f0,2,c))
return 1;
rn = rate2num(r>>2);
if(audio_fit_cap_helper(ai,rn,f0,2,c))
return 1;
/* try different rates with 8bit */
rn = rate2num(r>>0);
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
return 1;
rn = rate2num(r>>1);
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
return 1;
rn = rate2num(r>>2);
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c))
return 1;
/* try again with different stereoness */
if(c == 1 && !param.force_stereo) c = 0;
else if(c == 0 && !param.force_mono) c = 1;
/* 16bit */
rn = rate2num(r>>0);
if(audio_fit_cap_helper(ai,rn,f0,2,c)) return 1;
rn = rate2num(r>>1);
if(audio_fit_cap_helper(ai,rn,f0,2,c)) return 1;
rn = rate2num(r>>2);
if(audio_fit_cap_helper(ai,rn,f0,2,c)) return 1;
/* 8bit */
rn = rate2num(r>>0);
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c)) return 1;
rn = rate2num(r>>1);
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c)) return 1;
rn = rate2num(r>>2);
if(audio_fit_cap_helper(ai,rn,2,NUM_ENCODINGS,c)) return 1;
error5("Unable to set up output device! Constraints: %s%s%i, %i or %iHz.",
(param.force_stereo ? "stereo, " :
(param.force_mono ? "mono, " : "")),
(param.force_8bit ? "8bit, " : ""),
r, r>>1, r>>2);
if(param.verbose <= 1) print_capabilities(ai);
return 0;
}
/* This uses the currently opened audio device, queries its caps.
In case of buffered playback, this works _once_ by querying the buffer for the caps before entering the main loop. */
void audio_capabilities(audio_output_t *ao, mpg123_handle *mh)
{
int force_fmt = 0;
int fmts;
size_t ri;
/* Pitching introduces a difference between decoder rate and playback rate. */
long rate, decode_rate;
int channels;
const long *rates;
size_t num_rates, rlimit;
debug("audio_capabilities");
mpg123_rates(&rates, &num_rates);
mpg123_format_none(mh); /* Start with nothing. */
if(param.force_encoding != NULL)
{
int i;
if(!param.quiet) fprintf(stderr, "Note: forcing output encoding %s\n", param.force_encoding);
for(i=0;i<KNOWN_ENCS;++i)
if(!strncasecmp(encdesc[i].name, param.force_encoding, encdesc[i].nlen))
{
force_fmt = encdesc[i].code;
break;
}
if(i==KNOWN_ENCS)
{
error1("Failed to find an encoding to match requested \"%s\"!\n", param.force_encoding);
return; /* No capabilities at all... */
}
else if(param.verbose > 2) fprintf(stderr, "Note: forcing encoding code 0x%x\n", force_fmt);
}
rlimit = param.force_rate > 0 ? num_rates+1 : num_rates;
for(channels=1; channels<=2; channels++)
for(ri = 0;ri<rlimit;ri++)
{
decode_rate = ri < num_rates ? rates[ri] : param.force_rate;
rate = pitch_rate(decode_rate);
if(param.verbose > 2) fprintf(stderr, "Note: checking support for %liHz/%ich.\n", rate, channels);
#ifndef NOXFERMEM
if(param.usebuffer)
{ /* Ask the buffer process. It is waiting for this. */
buffermem->rate = rate;
buffermem->channels = channels;
buffermem->format = 0; /* Just have it initialized safely. */
debug2("asking for formats for %liHz/%ich", rate, channels);
xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_AUDIOCAP);
xfermem_getcmd(buffermem->fd[XF_WRITER], TRUE);
fmts = buffermem->format;
}
else
#endif
{ /* Check myself. */
ao->rate = rate;
ao->channels = channels;
fmts = ao->get_formats(ao);
}
if(param.verbose > 2) fprintf(stderr, "Note: result 0x%x\n", fmts);
if(force_fmt)
{ /* Filter for forced encoding. */
if((fmts & force_fmt) == force_fmt) fmts = force_fmt;
else fmts = 0; /* Nothing else! */
if(param.verbose > 2) fprintf(stderr, "Note: after forcing 0x%x\n", fmts);
}
if(fmts < 0) continue;
else mpg123_format(mh, decode_rate, channels, fmts);
}
#ifndef NOXFERMEM
/* Buffer loop shall start normal operation now. */
if(param.usebuffer)
{
xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_WAKEUP);
xfermem_getcmd(buffermem->fd[XF_WRITER], TRUE);
}
#endif
if(param.verbose > 1) print_capabilities(ao, mh);
}
static void interpret(char *name, char *val, int comma, int rtype)
{
int type;
while (*name == ' '||*name == '(')
name++;
/* Do some fixups */
if (rtype == AUDIT_EXECVE && name[0] == 'a')
type = T_ESCAPED;
else if (rtype == AUDIT_AVC && strcmp(name, "saddr") == 0)
type = -1;
else if (strcmp(name, "acct") == 0) {
// Remove trailing punctuation
int len = strlen(val);
if (val[len-1] == ':')
val[len-1] = 0;
if (val[0] == '"')
type = T_ESCAPED;
else if (is_hex_string(val))
type = T_ESCAPED;
else
type = -1;
} else
type = audit_lookup_type(name);
switch(type) {
case T_UID:
print_uid(val);
break;
case T_GID:
print_gid(val);
break;
case T_SYSCALL:
print_syscall(val);
break;
case T_ARCH:
print_arch(val);
break;
case T_EXIT:
print_exit(val);
break;
case T_ESCAPED:
print_escaped(val);
break;
case T_PERM:
print_perm(val);
break;
case T_MODE:
print_mode(val);
break;
case T_SOCKADDR:
print_sockaddr(val);
break;
case T_FLAGS:
print_flags(val);
break;
case T_PROMISC:
print_promiscuous(val);
break;
case T_CAPABILITY:
print_capabilities(val);
break;
case T_SIGNAL:
print_signals(val);
break;
case T_KEY:
print_key(val);
break;
case T_LIST:
print_list(val);
break;
case T_TTY_DATA:
print_tty_data(val);
break;
default:
printf("%s%c", val, comma ? ',' : ' ');
}
}
int main(int argc, char **argv)
{
int c;
char *domain = NULL;
char *uri = "xen";
char *file = NULL;
bool xml = false;
bool cap = false;
struct domain *dominfo = NULL;
struct capabilities *capsinfo = NULL;
struct cap_domain_info *capgdinfo = NULL;
int ret;
static struct option lopts[] = {
{"domain", 1, 0, 'd'},
{"uri", 1, 0, 'u'},
{"xml", 0, 0, 'x'},
{"file", 1, 0, 'f'},
{"cap", 0, 0, 'c'},
{"help", 0, 0, 'h'},
{0, 0, 0, 0}};
while (1) {
int optidx = 0;
c = getopt_long(argc, argv, "d:u:f:xch", lopts, &optidx);
if (c == -1)
break;
switch (c) {
case 'd':
domain = optarg;
break;
case 'u':
uri = optarg;
break;
case 'f':
file = optarg;
break;
case 'x':
xml = true;
break;
case 'c':
cap = true;
break;
case '?':
case 'h':
usage();
return c == '?';
};
}
if (file != NULL)
ret = dominfo_from_file(file, &dominfo);
else if (domain != NULL)
ret = dominfo_from_dom(uri, domain, &dominfo);
else {
printf("Need a data source (--domain or --file)\n");
return 1;
}
if (ret == 0) {
printf("Unable to get dominfo\n");
return 2;
}
if (xml)
print_domxml(dominfo, stdout);
else {
print_dominfo(dominfo, stdout);
print_devices(dominfo, stdout);
}
if (cap && file == NULL) {
ret = capinfo_for_dom(uri, dominfo, &capsinfo);
if (ret == 0) {
printf("Unable to get capsinfo\n");
return 3;
} else {
print_capabilities(capsinfo, stdout);
const char *os_type = get_ostype(dominfo);
const char *dom_type = get_domaintype(dominfo);
const char *def_arch = get_default_arch(capsinfo, os_type);
fprintf(stdout, "-- KVM is used: %s\n\n", (use_kvm(capsinfo)?"true":"false"));
fprintf(stdout, "-- For all following default OS type=%s\n", os_type);
fprintf(stdout, "-- Default Arch : %s\n", def_arch);
fprintf(stdout,
"-- Default Machine for arch=NULL : %s\n",
get_default_machine(capsinfo, os_type, NULL, NULL));
fprintf(stdout,
"-- Default Machine for arch=%s and domain type=NULL : %s\n",
def_arch,
get_default_machine(capsinfo, os_type, def_arch, NULL));
fprintf(stdout,
"-- Default Machine for arch=%s and domain type=%s : %s\n",
def_arch, dom_type,
get_default_machine(capsinfo, os_type, def_arch, dom_type));
fprintf(stdout,
"-- Default Machine for arch=NULL and domain type=%s : %s\n",
dom_type,
get_default_machine(capsinfo, os_type, NULL, dom_type));
fprintf(stdout,
"-- Default Emulator for arch=NULL : %s\n",
get_default_emulator(capsinfo, os_type, NULL, NULL));
fprintf(stdout,
"-- Default Emulator for arch=%s and domain type=NULL : %s\n",
def_arch,
get_default_emulator(capsinfo, os_type, def_arch, NULL));
fprintf(stdout,
"-- Default Emulator for arch=%s and domain type=%s : %s\n",
def_arch, dom_type,
get_default_emulator(capsinfo, os_type, def_arch, dom_type));
fprintf(stdout,
"-- Default Emulator for arch=NULL and domain type=%s : %s\n",
dom_type,
get_default_emulator(capsinfo, os_type, NULL, dom_type));
fprintf(stdout, "\n-- Default Domain Search for: \n"
"guest type=hvm - guest arch=* - guest domain type=kvm\n");
capgdinfo = findDomainInfo(capsinfo, "hvm", NULL, "kvm");
print_cap_domain_info(capgdinfo, stdout);
fprintf(stdout, "-- Default Domain Search for: \n"
"guest type=* - guest arch=* - guest domain type=*\n");
capgdinfo = findDomainInfo(capsinfo, NULL, NULL, NULL);
print_cap_domain_info(capgdinfo, stdout);
cleanup_capabilities(&capsinfo);
}
} else if (cap) {
printf("Need a data source (--domain) to get default capabilities\n");
return 4;
}
cleanup_dominfo(&dominfo);
return 0;
}
static void
print_info_basic(const pci_info *info, bool verbose)
{
int domain;
uint8 bus;
__pci_resolve_virtual_bus(info->bus, &domain, &bus);
TRACE(("PCI: [dom %d, bus %2d] bus %3d, device %2d, function %2d: vendor %04x, device %04x, revision %02x\n",
domain, bus, info->bus /* virtual bus*/,
info->device, info->function, info->vendor_id, info->device_id, info->revision));
TRACE(("PCI: class_base %02x, class_function %02x, class_api %02x\n",
info->class_base, info->class_sub, info->class_api));
if (verbose) {
#if USE_PCI_HEADER
const char *venShort;
const char *venFull;
get_vendor_info(info->vendor_id, &venShort, &venFull);
if (!venShort && !venFull) {
TRACE(("PCI: vendor %04x: Unknown\n", info->vendor_id));
} else if (venShort && venFull) {
TRACE(("PCI: vendor %04x: %s - %s\n", info->vendor_id, venShort, venFull));
} else {
TRACE(("PCI: vendor %04x: %s\n", info->vendor_id, venShort ? venShort : venFull));
}
const char *devShort;
const char *devFull;
get_device_info(info->vendor_id, info->device_id, info->u.h0.subsystem_vendor_id, info->u.h0.subsystem_id,
&devShort, &devFull);
if (!devShort && !devFull) {
TRACE(("PCI: device %04x: Unknown\n", info->device_id));
} else if (devShort && devFull) {
TRACE(("PCI: device %04x: %s (%s)\n", info->device_id, devShort, devFull));
} else {
TRACE(("PCI: device %04x: %s\n", info->device_id, devShort ? devShort : devFull));
}
char classInfo[64];
get_class_info(info->class_base, info->class_sub, info->class_api, classInfo, sizeof(classInfo));
TRACE(("PCI: info: %s\n", classInfo));
#endif
}
TRACE(("PCI: line_size %02x, latency %02x, header_type %02x, BIST %02x\n",
info->line_size, info->latency, info->header_type, info->bist));
switch (info->header_type & PCI_header_type_mask) {
case PCI_header_type_generic:
print_generic_info(info, verbose);
break;
case PCI_header_type_PCI_to_PCI_bridge:
print_pci2pci_bridge_info(info, verbose);
break;
case PCI_header_type_cardbus:
print_pci2cardbus_bridge_info(info, verbose);
break;
default:
TRACE(("PCI: unknown header type\n"));
}
print_capabilities(info);
}
static void
list_keyblock_colon( KBNODE keyblock, int secret )
{
int rc = 0;
KBNODE kbctx;
KBNODE node;
PKT_public_key *pk;
PKT_secret_key *sk;
u32 keyid[2];
int any=0;
int trustletter = 0;
int ulti_hack = 0;
/* get the keyid from the keyblock */
node = find_kbnode( keyblock, secret? PKT_SECRET_KEY : PKT_PUBLIC_KEY );
if( !node ) {
log_error("Oops; key lost!\n");
dump_kbnode( keyblock );
return;
}
if( secret ) {
pk = NULL;
sk = node->pkt->pkt.secret_key;
keyid_from_sk( sk, keyid );
printf("sec:u:%u:%d:%08lX%08lX:%s:%s:::",
nbits_from_sk( sk ),
sk->pubkey_algo,
(ulong)keyid[0],(ulong)keyid[1],
colon_datestr_from_sk( sk ),
colon_strtime (sk->expiredate)
/* fixme: add LID here */ );
}
else {
pk = node->pkt->pkt.public_key;
sk = NULL;
keyid_from_pk( pk, keyid );
fputs( "pub:", stdout );
trustletter = 0;
if ( !pk->is_valid )
putchar ('i');
else if ( pk->is_revoked )
putchar ('r');
else if ( pk->has_expired )
putchar ('e');
else if ( opt.fast_list_mode || opt.no_expensive_trust_checks )
;
else {
trustletter = query_trust_info( pk, NULL );
if( trustletter == 'u' )
ulti_hack = 1;
putchar(trustletter);
}
printf(":%u:%d:%08lX%08lX:%s:%s:",
nbits_from_pk( pk ),
pk->pubkey_algo,
(ulong)keyid[0],(ulong)keyid[1],
colon_datestr_from_pk( pk ),
colon_strtime (pk->expiredate) );
if( pk->local_id )
printf("%lu", pk->local_id );
putchar(':');
if( pk->local_id && !opt.fast_list_mode
&& !opt.no_expensive_trust_checks )
putchar( get_ownertrust_info( pk->local_id ) );
putchar(':');
}
if (opt.fixed_list_mode) {
/* do not merge the first uid with the primary key */
putchar(':');
putchar(':');
print_capabilities (pk, sk, keyblock);
putchar('\n');
if( opt.fingerprint )
fingerprint( pk, sk );
if( opt.with_key_data )
print_key_data( pk, keyid );
any = 1;
}
for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
if( node->pkt->pkttype == PKT_USER_ID && !opt.fast_list_mode ) {
/*
* Fixme: We need a is_valid flag here too
*/
if( any ) {
if ( node->pkt->pkt.user_id->is_revoked )
printf("uid:r::::::::");
else if ( opt.no_expensive_trust_checks ) {
printf("uid:::::::::");
}
else {
byte namehash[20];
if( pk && !ulti_hack ) {
if( node->pkt->pkt.user_id->photo )
rmd160_hash_buffer( namehash,
node->pkt->pkt.user_id->photo,
node->pkt->pkt.user_id->photolen);
else
rmd160_hash_buffer( namehash,
node->pkt->pkt.user_id->name,
node->pkt->pkt.user_id->len );
trustletter = query_trust_info( pk, namehash );
}
else
trustletter = 'u';
printf("uid:%c::::::::", trustletter);
}
}
print_string( stdout, node->pkt->pkt.user_id->name,
node->pkt->pkt.user_id->len, ':' );
putchar(':');
if (any)
putchar('\n');
else {
putchar(':');
print_capabilities (pk, sk, keyblock);
putchar('\n');
if( opt.fingerprint )
fingerprint( pk, sk );
if( opt.with_key_data )
print_key_data( pk, keyid );
any = 1;
}
}
else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
u32 keyid2[2];
PKT_public_key *pk2 = node->pkt->pkt.public_key;
if( !any ) {
putchar(':');
putchar(':');
print_capabilities (pk, sk, keyblock);
putchar('\n');
if( opt.fingerprint )
fingerprint( pk, sk ); /* of the main key */
any = 1;
}
keyid_from_pk( pk2, keyid2 );
fputs ("sub:", stdout );
if ( !pk2->is_valid )
putchar ('i');
else if ( pk2->is_revoked )
putchar ('r');
else if ( pk2->has_expired )
putchar ('e');
else if ( opt.fast_list_mode || opt.no_expensive_trust_checks )
;
else {
printf("%c", trustletter );
}
printf(":%u:%d:%08lX%08lX:%s:%s:",
nbits_from_pk( pk2 ),
pk2->pubkey_algo,
(ulong)keyid2[0],(ulong)keyid2[1],
colon_datestr_from_pk( pk2 ),
colon_strtime (pk2->expiredate)
/* fixme: add LID and ownertrust here */
);
if( pk->local_id ) /* use the local_id of the main key??? */
printf("%lu", pk->local_id );
putchar(':');
putchar(':');
putchar(':');
putchar(':');
print_capabilities (pk2, NULL, NULL);
putchar('\n');
if( opt.fingerprint > 1 )
fingerprint( pk2, NULL );
if( opt.with_key_data )
print_key_data( pk2, keyid2 );
}
else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
u32 keyid2[2];
PKT_secret_key *sk2 = node->pkt->pkt.secret_key;
if( !any ) {
putchar(':');
putchar(':');
print_capabilities (pk, sk, keyblock);
putchar('\n');
if( opt.fingerprint )
fingerprint( pk, sk ); /* of the main key */
any = 1;
}
keyid_from_sk( sk2, keyid2 );
printf("ssb::%u:%d:%08lX%08lX:%s:%s:::::",
nbits_from_sk( sk2 ),
sk2->pubkey_algo,
(ulong)keyid2[0],(ulong)keyid2[1],
colon_datestr_from_sk( sk2 ),
colon_strtime (sk2->expiredate)
/* fixme: add LID */ );
print_capabilities (NULL, sk2, NULL);
putchar ('\n');
if( opt.fingerprint > 1 )
fingerprint( NULL, sk2 );
}
else if( opt.list_sigs && node->pkt->pkttype == PKT_SIGNATURE ) {
PKT_signature *sig = node->pkt->pkt.signature;
int sigrc;
char *sigstr;
if( !any ) { /* no user id, (maybe a revocation follows)*/
if( sig->sig_class == 0x20 )
fputs("[revoked]:", stdout);
else if( sig->sig_class == 0x18 )
fputs("[key binding]:", stdout);
else if( sig->sig_class == 0x28 )
fputs("[subkey revoked]:", stdout);
else
putchar (':');
putchar(':');
print_capabilities (pk, sk, keyblock);
putchar('\n');
if( opt.fingerprint )
fingerprint( pk, sk );
any=1;
}
if( sig->sig_class == 0x20 || sig->sig_class == 0x28
|| sig->sig_class == 0x30 )
sigstr = "rev";
else if( (sig->sig_class&~3) == 0x10 )
sigstr = "sig";
else if( sig->sig_class == 0x18 )
sigstr = "sig";
else {
printf("sig::::::::::%02x:\n",sig->sig_class );
continue;
}
if( opt.check_sigs ) {
fflush(stdout);
rc = check_key_signature( keyblock, node, NULL );
switch( rc ) {
case 0: sigrc = '!'; break;
case G10ERR_BAD_SIGN: sigrc = '-'; break;
case G10ERR_NO_PUBKEY:
case G10ERR_UNU_PUBKEY: sigrc = '?'; break;
default: sigrc = '%'; break;
}
}
else {
rc = 0;
sigrc = ' ';
}
fputs( sigstr, stdout );
putchar(':');
if( sigrc != ' ' )
putchar(sigrc);
printf("::%d:%08lX%08lX:%s::::", sig->pubkey_algo,
(ulong)sig->keyid[0],
(ulong)sig->keyid[1], colon_datestr_from_sig(sig));
if( sigrc == '%' )
printf("[%s] ", g10_errstr(rc) );
else if( sigrc == '?' )
;
else if ( !opt.fast_list_mode ) {
size_t n;
char *p = get_user_id( sig->keyid, &n );
print_string( stdout, p, n, ':' );
m_free(p);
}
printf(":%02x:\n", sig->sig_class );
/* fixme: check or list other sigs here */
}
}
if( !any ) {/* oops, no user id */
putchar(':');
putchar(':');
print_capabilities (pk, sk, keyblock);
putchar('\n');
}
}
int main(int sys_argc, char ** sys_argv)
{
int result;
char end_of_files = FALSE;
long parr;
char *fname;
int libpar = 0;
mpg123_pars *mp;
#if !defined(WIN32) && !defined(GENERIC)
struct timeval start_time;
#endif
aux_out = stdout; /* Need to initialize here because stdout is not a constant?! */
#if defined (WANT_WIN32_UNICODE)
if(win32_cmdline_utf8(&argc, &argv) != 0)
{
error("Cannot convert command line to UTF8!");
safe_exit(76);
}
#else
argv = sys_argv;
argc = sys_argc;
#endif
#if defined (WANT_WIN32_SOCKETS)
win32_net_init();
#endif
/* Extract binary and path, take stuff before/after last / or \ . */
if((prgName = strrchr(argv[0], '/')) || (prgName = strrchr(argv[0], '\\')))
{
/* There is some explicit path. */
prgName[0] = 0; /* End byte for path. */
prgName++;
binpath = argv[0];
}
else
{
prgName = argv[0]; /* No path separators there. */
binpath = NULL; /* No path at all. */
}
/* Need to initialize mpg123 lib here for default parameter values. */
result = mpg123_init();
if(result != MPG123_OK)
{
error1("Cannot initialize mpg123 library: %s", mpg123_plain_strerror(result));
safe_exit(77);
}
cleanup_mpg123 = TRUE;
mp = mpg123_new_pars(&result); /* This may get leaked on premature exit(), which is mainly a cosmetic issue... */
if(mp == NULL)
{
error1("Crap! Cannot get mpg123 parameters: %s", mpg123_plain_strerror(result));
safe_exit(78);
}
/* get default values */
mpg123_getpar(mp, MPG123_DOWN_SAMPLE, &parr, NULL);
param.down_sample = (int) parr;
mpg123_getpar(mp, MPG123_RVA, ¶m.rva, NULL);
mpg123_getpar(mp, MPG123_DOWNSPEED, ¶m.halfspeed, NULL);
mpg123_getpar(mp, MPG123_UPSPEED, ¶m.doublespeed, NULL);
mpg123_getpar(mp, MPG123_OUTSCALE, ¶m.outscale, NULL);
mpg123_getpar(mp, MPG123_FLAGS, &parr, NULL);
mpg123_getpar(mp, MPG123_INDEX_SIZE, ¶m.index_size, NULL);
param.flags = (int) parr;
param.flags |= MPG123_SEEKBUFFER; /* Default on, for HTTP streams. */
mpg123_getpar(mp, MPG123_RESYNC_LIMIT, ¶m.resync_limit, NULL);
mpg123_getpar(mp, MPG123_PREFRAMES, ¶m.preframes, NULL);
#ifdef OS2
_wildcard(&argc,&argv);
#endif
while ((result = getlopt(argc, argv, opts)))
switch (result) {
case GLO_UNKNOWN:
fprintf (stderr, "%s: Unknown option \"%s\".\n",
prgName, loptarg);
usage(1);
case GLO_NOARG:
fprintf (stderr, "%s: Missing argument for option \"%s\".\n",
prgName, loptarg);
usage(1);
}
/* Do this _after_ parameter parsing. */
check_locale(); /* Check/set locale; store if it uses UTF-8. */
if(param.list_cpu)
{
const char **all_dec = mpg123_decoders();
printf("Builtin decoders:");
while(*all_dec != NULL){ printf(" %s", *all_dec); ++all_dec; }
printf("\n");
mpg123_delete_pars(mp);
return 0;
}
if(param.test_cpu)
{
const char **all_dec = mpg123_supported_decoders();
printf("Supported decoders:");
while(*all_dec != NULL){ printf(" %s", *all_dec); ++all_dec; }
printf("\n");
mpg123_delete_pars(mp);
return 0;
}
if(param.gain != -1)
{
warning("The parameter -g is deprecated and may be removed in the future.");
}
if (loptind >= argc && !param.listname && !param.remote) usage(1);
/* Init audio as early as possible.
If there is the buffer process to be spawned, it shouldn't carry the mpg123_handle with it. */
bufferblock = mpg123_safe_buffer(); /* Can call that before mpg123_init(), it's stateless. */
if(init_output(&ao) < 0)
{
error("Failed to initialize output, goodbye.");
mpg123_delete_pars(mp);
return 99; /* It's safe here... nothing nasty happened yet. */
}
have_output = TRUE;
/* ========================================================================================================= */
/* Enterning the leaking zone... we start messing with stuff here that should be taken care of when leaving. */
/* Don't just exit() or return out... */
/* ========================================================================================================= */
httpdata_init(&htd);
#if !defined(WIN32) && !defined(GENERIC)
if (param.remote)
{
param.verbose = 0;
param.quiet = 1;
param.flags |= MPG123_QUIET;
}
#endif
/* Set the frame parameters from command line options */
if(param.quiet) param.flags |= MPG123_QUIET;
#ifdef OPT_3DNOW
if(dnow != 0) param.cpu = (dnow == SET_3DNOW) ? "3dnow" : "i586";
#endif
if(param.cpu != NULL && (!strcmp(param.cpu, "auto") || !strcmp(param.cpu, ""))) param.cpu = NULL;
if(!( MPG123_OK == (result = mpg123_par(mp, MPG123_VERBOSE, param.verbose, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_FLAGS, param.flags, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_DOWN_SAMPLE, param.down_sample, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_RVA, param.rva, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_FORCE_RATE, param.force_rate, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_DOWNSPEED, param.halfspeed, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_UPSPEED, param.doublespeed, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_ICY_INTERVAL, 0, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_RESYNC_LIMIT, param.resync_limit, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_TIMEOUT, param.timeout, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_OUTSCALE, param.outscale, 0))
&& ++libpar
&& MPG123_OK == (result = mpg123_par(mp, MPG123_PREFRAMES, param.preframes, 0))
))
{
error2("Cannot set library parameter %i: %s", libpar, mpg123_plain_strerror(result));
safe_exit(45);
}
if (!(param.listentry < 0) && !param.quiet) print_title(stderr); /* do not pollute stdout! */
{
long default_index;
mpg123_getpar(mp, MPG123_INDEX_SIZE, &default_index, NULL);
if( param.index_size != default_index && (result = mpg123_par(mp, MPG123_INDEX_SIZE, param.index_size, 0.)) != MPG123_OK )
error1("Setting of frame index size failed: %s", mpg123_plain_strerror(result));
}
if(param.force_rate && param.down_sample)
{
error("Down sampling and fixed rate options not allowed together!");
safe_exit(1);
}
/* Now actually get an mpg123_handle. */
mh = mpg123_parnew(mp, param.cpu, &result);
if(mh == NULL)
{
error1("Crap! Cannot get a mpg123 handle: %s", mpg123_plain_strerror(result));
safe_exit(77);
}
mpg123_delete_pars(mp); /* Don't need the parameters anymore ,they're in the handle now. */
/* Prepare stream dumping, possibly replacing mpg123 reader. */
if(dump_open(mh) != 0) safe_exit(78);
/* Now either check caps myself or query buffer for that. */
audio_capabilities(ao, mh);
load_equalizer(mh);
#ifdef HAVE_SETPRIORITY
if(param.aggressive) { /* tst */
int mypid = getpid();
setpriority(PRIO_PROCESS,mypid,-20);
}
#endif
#if defined (HAVE_SCHED_SETSCHEDULER) && !defined (__CYGWIN__) && !defined (HAVE_WINDOWS_H)
/* Cygwin --realtime seems to fail when accessing network, using win32 set priority instead */
/* MinGW may have pthread installed, we prefer win32API */
if (param.realtime) { /* Get real-time priority */
struct sched_param sp;
fprintf(stderr,"Getting real-time priority\n");
memset(&sp, 0, sizeof(struct sched_param));
sp.sched_priority = sched_get_priority_min(SCHED_FIFO);
if (sched_setscheduler(0, SCHED_RR, &sp) == -1)
fprintf(stderr,"Can't get real-time priority\n");
}
#endif
#ifdef HAVE_WINDOWS_H
/* argument "3" is equivalent to realtime priority class */
win32_set_priority( param.realtime ? 3 : param.w32_priority);
#endif
if(!param.remote) prepare_playlist(argc, argv);
#if !defined(WIN32) && !defined(GENERIC)
/* Remote mode is special... but normal console and terminal-controlled operation needs to catch the SIGINT.
For one it serves for track skip when not in terminal control mode.
The more important use being a graceful exit, including telling the buffer process what's going on. */
if(!param.remote) catchsignal (SIGINT, catch_interrupt);
#endif
if(param.remote) {
int ret;
ret = control_generic(mh);
safe_exit(ret);
}
#ifdef HAVE_TERMIOS
debug1("param.term_ctrl: %i", param.term_ctrl);
if(param.term_ctrl)
term_init();
#endif
if(APPFLAG(MPG123APP_CONTINUE)) frames_left = param.frame_number;
while ((fname = get_next_file()))
{
char *dirname, *filename;
int newdir;
/* skip_tracks includes the previous one. */
if(skip_tracks) --skip_tracks;
if(skip_tracks)
{
debug("Skipping this track.");
continue;
}
if(param.delay > 0)
{
/* One should enable terminal control during that sleeping phase! */
if(param.verbose > 2) fprintf(stderr, "Note: pausing %i seconds before next track.\n", param.delay);
output_pause(ao);
#ifdef WIN32
Sleep(param.delay*1000);
#else
sleep(param.delay);
#endif
output_unpause(ao);
}
if(!APPFLAG(MPG123APP_CONTINUE)) frames_left = param.frame_number;
debug1("Going to play %s", strcmp(fname, "-") ? fname : "standard input");
if(intflag || !open_track(fname))
{
#ifdef HAVE_TERMIOS
/* We need the opportunity to cancel in case of --loop -1 . */
if(param.term_ctrl) term_control(mh, ao);
#endif
/* No wait for a second interrupt before we started playing. */
if(intflag) break;
continue;
}
if(!param.quiet) fprintf(stderr, "\n");
if(param.index)
{
if(param.verbose) fprintf(stderr, "indexing...\r");
mpg123_scan(mh);
}
/*
Only trigger a seek if we do not want to start with the first frame.
Rationale: Because of libmpg123 sample accuracy, this could cause an unnecessary backwards seek, that even may fail on non-seekable streams.
For start frame of 0, we are already at the correct position!
*/
framenum = 0;
if(param.start_frame > 0)
framenum = mpg123_seek_frame(mh, param.start_frame, SEEK_SET);
if(APPFLAG(MPG123APP_CONTINUE)) param.start_frame = 0;
if(framenum < 0)
{
error1("Initial seek failed: %s", mpg123_strerror(mh));
if(mpg123_errcode(mh) == MPG123_BAD_OUTFORMAT)
{
fprintf(stderr, "%s", "So, you have trouble getting an output format... this is the matrix of currently possible formats:\n");
print_capabilities(ao, mh);
fprintf(stderr, "%s", "Somehow the input data and your choices don't allow one of these.\n");
}
mpg123_close(mh);
continue;
}
/* Prinout and xterm title need this, possibly independently. */
newdir = split_dir_file(fname ? fname : "standard input", &dirname, &filename);
if (!param.quiet)
{
if(newdir) fprintf(stderr, "Directory: %s\n", dirname);
#ifdef HAVE_TERMIOS
/* Reminder about terminal usage. */
if(param.term_ctrl) term_hint();
#endif
fprintf(stderr, "Playing MPEG stream %lu of %lu: %s ...\n", (unsigned long)pl.pos, (unsigned long)pl.fill, filename);
if(htd.icy_name.fill) fprintf(stderr, "ICY-NAME: %s\n", htd.icy_name.p);
if(htd.icy_url.fill) fprintf(stderr, "ICY-URL: %s\n", htd.icy_url.p);
}
#if !defined(GENERIC)
{
const char *term_type;
term_type = getenv("TERM");
if(term_type && param.xterm_title)
{
if(!strncmp(term_type,"xterm",5) || !strncmp(term_type,"rxvt",4))
fprintf(stderr, "\033]0;%s\007", filename);
else if(!strncmp(term_type,"screen",6))
fprintf(stderr, "\033k%s\033\\", filename);
else if(!strncmp(term_type,"iris-ansi",9))
fprintf(stderr, "\033P1.y %s\033\\\033P3.y%s\033\\", filename, filename);
fflush(stderr); /* Paranoia: will the buffer buffer the escapes? */
}
}
#endif
/* Rethink that SIGINT logic... */
#if !defined(WIN32) && !defined(GENERIC)
#ifdef HAVE_TERMIOS
if(!param.term_ctrl)
#endif
gettimeofday (&start_time, NULL);
#endif
while(!intflag)
{
int meta;
if(param.frame_number > -1)
{
debug1("frames left: %li", (long) frames_left);
if(!frames_left)
{
if(APPFLAG(MPG123APP_CONTINUE)) end_of_files = TRUE;
break;
}
}
if(!play_frame()) break;
if(!param.quiet)
{
meta = mpg123_meta_check(mh);
if(meta & (MPG123_NEW_ID3|MPG123_NEW_ICY))
{
if(meta & MPG123_NEW_ID3) print_id3_tag(mh, param.long_id3, stderr);
if(meta & MPG123_NEW_ICY) print_icy(mh, stderr);
mpg123_meta_free(mh); /* Do not waste memory after delivering. */
}
}
if(!fresh && param.verbose)
{
#ifndef NOXFERMEM
if (param.verbose > 1 || !(framenum & 0x7))
print_stat(mh,0,xfermem_get_usedspace(buffermem));
#else
if(param.verbose > 1 || !(framenum & 0x7)) print_stat(mh,0,0);
#endif
}
#ifdef HAVE_TERMIOS
if(!param.term_ctrl) continue;
else term_control(mh, ao);
#endif
}
if(!param.smooth && param.usebuffer) buffer_drain();
if(param.verbose) print_stat(mh,0,xfermem_get_usedspace(buffermem));
if(!param.quiet)
{
double secs;
long frank;
fprintf(stderr, "\n");
if(mpg123_getstate(mh, MPG123_FRANKENSTEIN, &frank, NULL) == MPG123_OK && frank)
fprintf(stderr, "This was a Frankenstein track.\n");
mpg123_position(mh, 0, 0, NULL, NULL, &secs, NULL);
fprintf(stderr,"[%d:%02d] Decoding of %s finished.\n", (int)(secs / 60), ((int)secs) % 60, filename);
}
else if(param.verbose) fprintf(stderr, "\n");
mpg123_close(mh);
if (intflag)
{
if(!skip_or_die(&start_time)) break;
intflag = FALSE;
#ifndef NOXFERMEM
if(!param.smooth && param.usebuffer) buffer_resync();
#endif
}
if(end_of_files) break;
} /* end of loop over input files */
/* Ensure we played everything. */
if(param.smooth && param.usebuffer)
{
buffer_drain();
buffer_resync();
}
if(APPFLAG(MPG123APP_CONTINUE))
{
continue_msg("CONTINUE");
}
/* Free up memory used by playlist */
if(!param.remote) free_playlist();
safe_exit(0); /* That closes output and restores terminal, too. */
return 0;
}
