static void show_format(AVFormatContext *fmt_ctx)
{
char val_str[128];
int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
probe_object_header("format");
probe_str("filename", fmt_ctx->filename);
probe_int("nb_streams", fmt_ctx->nb_streams);
probe_str("format_name", fmt_ctx->iformat->name);
probe_str("format_long_name", fmt_ctx->iformat->long_name);
probe_str("start_time",
time_value_string(val_str, sizeof(val_str),
fmt_ctx->start_time, &AV_TIME_BASE_Q));
probe_str("duration",
time_value_string(val_str, sizeof(val_str),
fmt_ctx->duration, &AV_TIME_BASE_Q));
probe_str("size",
size >= 0 ? value_string(val_str, sizeof(val_str),
size, unit_byte_str)
: "unknown");
probe_str("bit_rate",
value_string(val_str, sizeof(val_str),
fmt_ctx->bit_rate, unit_bit_per_second_str));
probe_dict(fmt_ctx->metadata, "tags");
probe_object_footer("format");
}
static void show_format(AVFormatContext *fmt_ctx)
{
AVDictionaryEntry *tag = NULL;
char val_str[128];
int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
print_format_entry(NULL, "[FORMAT]");
print_format_entry("filename", fmt_ctx->filename);
snprintf(val_str, sizeof(val_str) - 1, "%d", fmt_ctx->nb_streams);
print_format_entry("nb_streams", val_str);
print_format_entry("format_name", fmt_ctx->iformat->name);
print_format_entry("format_long_name", fmt_ctx->iformat->long_name);
print_format_entry("start_time",
time_value_string(val_str, sizeof(val_str),
fmt_ctx->start_time, &AV_TIME_BASE_Q));
print_format_entry("duration",
time_value_string(val_str, sizeof(val_str),
fmt_ctx->duration, &AV_TIME_BASE_Q));
print_format_entry("size",
size >= 0 ? value_string(val_str, sizeof(val_str),
size, unit_byte_str)
: "unknown");
print_format_entry("bit_rate",
value_string(val_str, sizeof(val_str),
fmt_ctx->bit_rate, unit_bit_per_second_str));
while ((tag = av_dict_get(fmt_ctx->metadata, "", tag,
AV_DICT_IGNORE_SUFFIX))) {
snprintf(val_str, sizeof(val_str) - 1, "TAG:%s", tag->key);
print_format_entry(val_str, tag->value);
}
print_format_entry(NULL, "[/FORMAT]");
}
static void show_format(AVFormatContext *fmt_ctx)
{
AVDictionaryEntry *tag = NULL;
char val_str[128];
printf("[FORMAT]\n");
printf("filename=%s\n", fmt_ctx->filename);
printf("nb_streams=%d\n", fmt_ctx->nb_streams);
printf("format_name=%s\n", fmt_ctx->iformat->name);
printf("format_long_name=%s\n", fmt_ctx->iformat->long_name);
printf("start_time=%s\n", time_value_string(val_str, sizeof(val_str), fmt_ctx->start_time,
&AV_TIME_BASE_Q));
printf("duration=%s\n", time_value_string(val_str, sizeof(val_str), fmt_ctx->duration,
&AV_TIME_BASE_Q));
printf("size=%s\n", value_string(val_str, sizeof(val_str), fmt_ctx->file_size,
unit_byte_str));
printf("bit_rate=%s\n", value_string(val_str, sizeof(val_str), fmt_ctx->bit_rate,
unit_bit_per_second_str));
while ((tag = av_dict_get(fmt_ctx->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
printf("TAG:%s=%s\n", tag->key, tag->value);
printf("[/FORMAT]\n");
}
CORE_ADDR
lookup_child_selector (struct gdbarch *gdbarch, char *selname)
{
struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value * function, *selstring;
if (! target_has_execution)
{
/* Can't call into inferior to lookup selector. */
return 0;
}
if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym)
function = find_function_in_inferior("sel_getUid", NULL);
else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym)
function = find_function_in_inferior("sel_get_any_uid", NULL);
else
{
complaint (&symfile_complaints,
_("no way to lookup Objective-C selectors"));
return 0;
}
selstring = value_coerce_array (value_string (selname,
strlen (selname) + 1,
char_type));
return value_as_long (call_function_by_hand (function, 1, &selstring));
}
/**
* Test that choice_option correctly reports its capabilities.
*/
TEST(choice_option_test, capabilities)
{
auto short_name = std::string("f");
auto name = std::string("foo");
auto option = qflags::choice_option(name.c_str(), short_name.c_str(), {"bar", "baz"}, "bar");
EXPECT_EQ(name, option.name());
EXPECT_EQ(short_name, option.short_name());
EXPECT_EQ(false, option.is_set());
EXPECT_EQ(false, option.is_flag());
EXPECT_EQ(false, option.is_command());
EXPECT_EQ(false, option.is_array());
EXPECT_EQ(false, option.is_boolean());
EXPECT_EQ(false, option.is_integer());
EXPECT_EQ(true, option.is_string());
EXPECT_EQ(0u, option.array_size());
EXPECT_THROW(option.value_boolean(), std::logic_error);
EXPECT_THROW(option.value_integer(), std::logic_error);
EXPECT_EQ("bar", option.value_string());
EXPECT_THROW(option.value_array(0), std::logic_error);
EXPECT_THROW(static_cast<bool>(option), std::logic_error);
EXPECT_THROW(static_cast<int64_t>(option), std::logic_error);
EXPECT_THROW(static_cast<int>(option), std::logic_error);
EXPECT_EQ("bar", static_cast<std::string>(option));
}
static void show_packet(AVFormatContext *fmt_ctx, AVPacket *pkt)
{
char val_str[128];
AVStream *st = fmt_ctx->streams[pkt->stream_index];
printf("[PACKET]\n");
printf("codec_type=%s\n", media_type_string(st->codec->codec_type));
printf("stream_index=%d\n", pkt->stream_index);
printf("pts=%s\n", ts_value_string(val_str, sizeof(val_str), pkt->pts));
printf("pts_time=%s\n", time_value_string(val_str, sizeof(val_str),
pkt->pts, &st->time_base));
printf("dts=%s\n", ts_value_string(val_str, sizeof(val_str), pkt->dts));
printf("dts_time=%s\n", time_value_string(val_str, sizeof(val_str),
pkt->dts, &st->time_base));
printf("duration=%s\n", ts_value_string(val_str, sizeof(val_str),
pkt->duration));
printf("duration_time=%s\n", time_value_string(val_str, sizeof(val_str),
pkt->duration,
&st->time_base));
printf("size=%s\n", value_string(val_str, sizeof(val_str),
pkt->size, unit_byte_str));
printf("pos=%"PRId64"\n", pkt->pos);
printf("flags=%c\n", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_');
printf("[/PACKET]\n");
}
CORE_ADDR
lookup_objc_class (struct gdbarch *gdbarch, char *classname)
{
struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value * function, *classval;
if (! target_has_execution)
{
/* Can't call into inferior to lookup class. */
return 0;
}
if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym)
function = find_function_in_inferior("objc_lookUpClass", NULL);
else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym)
function = find_function_in_inferior("objc_lookup_class", NULL);
else
{
complaint (&symfile_complaints,
_("no way to lookup Objective-C classes"));
return 0;
}
classval = value_string (classname, strlen (classname) + 1, char_type);
classval = value_coerce_array (classval);
return (CORE_ADDR) value_as_long (call_function_by_hand (function,
1, &classval));
}
static void show_packet(AVFormatContext *fmt_ctx, AVPacket *pkt)
{
char val_str[128];
AVStream *st = fmt_ctx->streams[pkt->stream_index];
probe_object_header("packet");
probe_str("codec_type", media_type_string(st->codec->codec_type));
probe_int("stream_index", pkt->stream_index);
probe_str("pts", ts_value_string(val_str, sizeof(val_str), pkt->pts));
probe_str("pts_time", time_value_string(val_str, sizeof(val_str),
pkt->pts, &st->time_base));
probe_str("dts", ts_value_string(val_str, sizeof(val_str), pkt->dts));
probe_str("dts_time", time_value_string(val_str, sizeof(val_str),
pkt->dts, &st->time_base));
probe_str("duration", ts_value_string(val_str, sizeof(val_str),
pkt->duration));
probe_str("duration_time", time_value_string(val_str, sizeof(val_str),
pkt->duration,
&st->time_base));
probe_str("size", value_string(val_str, sizeof(val_str),
pkt->size, unit_byte_str));
probe_int("pos", pkt->pos);
probe_str("flags", pkt->flags & AV_PKT_FLAG_KEY ? "K" : "_");
probe_object_footer("packet");
}
/* Use inferior's dlopen() to bring in some helper functions: */
void
load_helpers(void)
{
struct value *dlfn, *args[2], *val;
long rslt;
args[0] = value_string(LIBCHECKPOINT_NAME,
(strlen(LIBCHECKPOINT_NAME) + 1UL));
args[0] = value_coerce_array(args[0]);
args[1] = value_from_longest(builtin_type_int, (LONGEST)RTLD_NOW);
if (lookup_minimal_symbol("dlopen", 0, 0)
&& (dlfn = find_function_in_inferior("dlopen", builtin_type_int)))
{
val = call_function_by_hand_expecting_type(dlfn,
builtin_type_int, 2,
args, 1);
rslt = (long)value_as_long(val);
if (rslt == 0)
warning("dlopen of checkpoint library returned NULL");
}
else
{
warning("dlopen not found, libcheckpoint functions not loaded");
}
}
void populateSettings(const QByteArray &xSettings)
{
if (xSettings.length() < 12)
return;
// we ignore byteorder for now
char byteOrder = xSettings.at(1);
Q_UNUSED(byteOrder);
uint serial = *reinterpret_cast<const uint *>(xSettings.mid(4,4).constData());
serial = serial;
uint number_of_settings = *reinterpret_cast<const uint *>(xSettings.mid(8,4).constData());
const char *data = xSettings.constData() + 12;
size_t offset = 0;
for (uint i = 0; i < number_of_settings; i++) {
int local_offset = 0;
XSettingsType type = static_cast<XSettingsType>(*reinterpret_cast<const quint8 *>(data + offset));
local_offset += 2;
quint16 name_len = *reinterpret_cast<const quint16 *>(data + offset + local_offset);
local_offset += 2;
QByteArray name(data + offset + local_offset, name_len);
local_offset += round_to_nearest_multiple_of_4(name_len);
int last_change_serial = *reinterpret_cast<const int *>(data + offset + local_offset);
Q_UNUSED(last_change_serial);
local_offset += 4;
QVariant value;
if (type == XSettingsTypeString) {
int value_length = *reinterpret_cast<const int *>(data + offset + local_offset);
local_offset+=4;
QByteArray value_string(data + offset + local_offset, value_length);
value.setValue(value_string);
local_offset += round_to_nearest_multiple_of_4(value_length);
} else if (type == XSettingsTypeInteger) {
int value_length = *reinterpret_cast<const int *>(data + offset + local_offset);
local_offset += 4;
value.setValue(value_length);
} else if (type == XSettingsTypeColor) {
quint16 red = *reinterpret_cast<const quint16 *>(data + offset + local_offset);
local_offset += 2;
quint16 green = *reinterpret_cast<const quint16 *>(data + offset + local_offset);
local_offset += 2;
quint16 blue = *reinterpret_cast<const quint16 *>(data + offset + local_offset);
local_offset += 2;
quint16 alpha= *reinterpret_cast<const quint16 *>(data + offset + local_offset);
local_offset += 2;
QColor color_value(red,green,blue,alpha);
value.setValue(color_value);
}
offset += local_offset;
settings[name].updateValue(screen,name,value,last_change_serial);
}
}
static char *time_value_string(char *buf, int buf_size, int64_t val, const AVRational *time_base)
{
if (val == AV_NOPTS_VALUE) {
snprintf(buf, buf_size, "N/A");
} else {
value_string(buf, buf_size, val * av_q2d(*time_base), unit_second_str);
}
return buf;
}
int do_value(string arg)
{
object ob;
int value;
if( !arg || !(ob = present(arg, this_player())) )
return notify_fail("你要拿什么物品给当铺估价？\n");
if( ob->query("money_id") )
return notify_fail("这是「钱」，你没见过吗？\n");
value = ob->query("value");
if( !value ) printf("%s一文不值。\n", ob->query("name"));
else
printf("%s价值%s。\n如果你要典当(pawn)，可以拿到%s及一张当票。\n如果卖断(sell)，可以拿到%s。\n",
ob->query("name"), value_string(value),
value_string(value * 60 / 100), value_string(value * 80 / 100));
return 1;
}
string
paramList::getString(unsigned int const paramNumber) const {
if (paramNumber >= this->paramVector.size())
throw(fault("Not enough parameters", fault::CODE_TYPE));
if (this->paramVector[paramNumber].type() != value::TYPE_STRING)
throw(fault("Parameter that is supposed to be a string is not",
fault::CODE_TYPE));
return static_cast<string>(value_string(this->paramVector[paramNumber]));
}
/* The c++ function for: string2module(s:string) [NEW_ALLOC] */
module * string2module_string(char *s)
{ { module *Result ;
{ ClaireObject *V_CC ;
{ OID m = value_string(s);
if (INHERIT(OWNER(m),Kernel._module))
V_CC = OBJECT(module,m);
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("~A is not a module")),
_oid_(list::alloc(1,_string_(s))))));
}
Result= (module *) V_CC;}
return (Result);}
}
void produce_csv_value_csv(void *csv_metadata, const char *s, size_t len) {
struct csv_metadata *c = (struct csv_metadata *)csv_metadata;
readstat_variable_t *var = &c->variables[c->columns];
int is_date = c->is_date[c->columns];
int obs_index = c->rows - 1; // TODO: ???
readstat_value_t value;
if (len == 0) {
value = value_sysmiss(s, len, c);
} else if (is_date) {
value = value_string(s, len, c);
} else if (var->type == READSTAT_TYPE_DOUBLE) {
value = value_double(s, len, c);
} else if (var->type == READSTAT_TYPE_STRING) {
value = value_string(s, len, c);
} else {
fprintf(stderr, "%s:%d unsupported variable type %d\n", __FILE__, __LINE__, var->type);
exit(EXIT_FAILURE);
}
c->handle.value(obs_index, var, value, c->user_ctx);
}
struct value *
value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
{
struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value *stringValue[3];
struct value *function, *nsstringValue;
struct symbol *sym;
struct type *type;
if (!target_has_execution)
return 0; /* Can't call into inferior to create NSString. */
stringValue[2] = value_string(ptr, len, char_type);
stringValue[2] = value_coerce_array(stringValue[2]);
/* _NSNewStringFromCString replaces "istr" after Lantern2A. */
if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym)
{
function = find_function_in_inferior("_NSNewStringFromCString", NULL);
nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
}
else if (lookup_minimal_symbol("istr", 0, 0).minsym)
{
function = find_function_in_inferior("istr", NULL);
nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
}
else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym)
{
function
= find_function_in_inferior("+[NSString stringWithCString:]", NULL);
type = builtin_type (gdbarch)->builtin_long;
stringValue[0] = value_from_longest
(type, lookup_objc_class (gdbarch, "NSString"));
stringValue[1] = value_from_longest
(type, lookup_child_selector (gdbarch, "stringWithCString:"));
nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
}
else
error (_("NSString: internal error -- no way to create new NSString"));
sym = lookup_struct_typedef("NSString", 0, 1);
if (sym == NULL)
sym = lookup_struct_typedef("NXString", 0, 1);
if (sym == NULL)
type = builtin_type (gdbarch)->builtin_data_ptr;
else
type = lookup_pointer_type(SYMBOL_TYPE (sym));
deprecated_set_value_type (nsstringValue, type);
return nsstringValue;
}
int do_pawn(string arg)
{
object ob;
int value;
if( !arg || !(ob = present(arg, this_player())) )
return notify_fail("你要典当什么物品？\n");
if( ob->query("money_id") ) return notify_fail("你要当「钱」？\n");
value = ob->query("value");
if( !value ) return notify_fail("这样东西不值钱。\n");
message_vision("$N把身上的" + ob->query("name") + "拿出来典当了"
+ value_string(value * 60 / 100) + "。\n", this_player());
pay_player(this_player(), value * 60 / 100);
destruct(ob);
return 1;
}
// Overloaded methods
void value(const std::basic_string<Char>& value)
{
value_string(value);
}
static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)
{
AVStream *stream = fmt_ctx->streams[stream_idx];
AVCodecContext *dec_ctx;
AVCodec *dec;
char val_str[128];
AVDictionaryEntry *tag = NULL;
AVRational display_aspect_ratio;
printf("[STREAM]\n");
printf("index=%d\n", stream->index);
if ((dec_ctx = stream->codec)) {
if ((dec = dec_ctx->codec)) {
printf("codec_name=%s\n", dec->name);
printf("codec_long_name=%s\n", dec->long_name);
} else {
printf("codec_name=unknown\n");
}
printf("codec_type=%s\n", media_type_string(dec_ctx->codec_type));
printf("codec_time_base=%d/%d\n", dec_ctx->time_base.num, dec_ctx->time_base.den);
/* print AVI/FourCC tag */
av_get_codec_tag_string(val_str, sizeof(val_str), dec_ctx->codec_tag);
printf("codec_tag_string=%s\n", val_str);
printf("codec_tag=0x%04x\n", dec_ctx->codec_tag);
switch (dec_ctx->codec_type) {
case AVMEDIA_TYPE_VIDEO:
printf("width=%d\n", dec_ctx->width);
printf("height=%d\n", dec_ctx->height);
printf("has_b_frames=%d\n", dec_ctx->has_b_frames);
if (dec_ctx->sample_aspect_ratio.num) {
printf("sample_aspect_ratio=%d:%d\n", dec_ctx->sample_aspect_ratio.num,
dec_ctx->sample_aspect_ratio.den);
av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
dec_ctx->width * dec_ctx->sample_aspect_ratio.num,
dec_ctx->height * dec_ctx->sample_aspect_ratio.den,
1024*1024);
printf("display_aspect_ratio=%d:%d\n", display_aspect_ratio.num,
display_aspect_ratio.den);
}
printf("pix_fmt=%s\n", dec_ctx->pix_fmt != PIX_FMT_NONE ?
av_pix_fmt_descriptors[dec_ctx->pix_fmt].name : "unknown");
break;
case AVMEDIA_TYPE_AUDIO:
printf("sample_rate=%s\n", value_string(val_str, sizeof(val_str),
dec_ctx->sample_rate,
unit_hertz_str));
printf("channels=%d\n", dec_ctx->channels);
printf("bits_per_sample=%d\n", av_get_bits_per_sample(dec_ctx->codec_id));
break;
}
} else {
printf("codec_type=unknown\n");
}
if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS)
printf("id=0x%x\n", stream->id);
printf("r_frame_rate=%d/%d\n", stream->r_frame_rate.num, stream->r_frame_rate.den);
printf("avg_frame_rate=%d/%d\n", stream->avg_frame_rate.num, stream->avg_frame_rate.den);
printf("time_base=%d/%d\n", stream->time_base.num, stream->time_base.den);
printf("start_time=%s\n", time_value_string(val_str, sizeof(val_str), stream->start_time,
&stream->time_base));
printf("duration=%s\n", time_value_string(val_str, sizeof(val_str), stream->duration,
&stream->time_base));
if (stream->nb_frames)
printf("nb_frames=%"PRId64"\n", stream->nb_frames);
while ((tag = av_dict_get(stream->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
printf("TAG:%s=%s\n", tag->key, tag->value);
printf("[/STREAM]\n");
}
static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)
{
AVStream *stream = fmt_ctx->streams[stream_idx];
AVCodecContext *dec_ctx;
AVCodec *dec;
const char *profile;
char val_str[128];
AVRational display_aspect_ratio;
probe_object_header("stream");
probe_int("index", stream->index);
if ((dec_ctx = stream->codec)) {
if ((dec = dec_ctx->codec)) {
probe_str("codec_name", dec->name);
probe_str("codec_long_name", dec->long_name);
} else {
probe_str("codec_name", "unknown");
}
probe_str("codec_type", media_type_string(dec_ctx->codec_type));
probe_str("codec_time_base",
rational_string(val_str, sizeof(val_str),
"/", &dec_ctx->time_base));
/* print AVI/FourCC tag */
av_get_codec_tag_string(val_str, sizeof(val_str), dec_ctx->codec_tag);
probe_str("codec_tag_string", val_str);
probe_str("codec_tag", tag_string(val_str, sizeof(val_str),
dec_ctx->codec_tag));
/* print profile, if there is one */
if (dec && (profile = av_get_profile_name(dec, dec_ctx->profile)))
probe_str("profile", profile);
switch (dec_ctx->codec_type) {
case AVMEDIA_TYPE_VIDEO:
probe_int("width", dec_ctx->width);
probe_int("height", dec_ctx->height);
probe_int("has_b_frames", dec_ctx->has_b_frames);
if (dec_ctx->sample_aspect_ratio.num) {
probe_str("sample_aspect_ratio",
rational_string(val_str, sizeof(val_str), ":",
&dec_ctx->sample_aspect_ratio));
av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
dec_ctx->width * dec_ctx->sample_aspect_ratio.num,
dec_ctx->height * dec_ctx->sample_aspect_ratio.den,
1024*1024);
probe_str("display_aspect_ratio",
rational_string(val_str, sizeof(val_str), ":",
&display_aspect_ratio));
}
probe_str("pix_fmt",
dec_ctx->pix_fmt != PIX_FMT_NONE ? av_pix_fmt_descriptors[dec_ctx->pix_fmt].name
: "unknown");
probe_int("level", dec_ctx->level);
break;
case AVMEDIA_TYPE_AUDIO:
probe_str("sample_rate",
value_string(val_str, sizeof(val_str),
dec_ctx->sample_rate,
unit_hertz_str));
probe_int("channels", dec_ctx->channels);
probe_int("bits_per_sample",
av_get_bits_per_sample(dec_ctx->codec_id));
break;
}
} else {
probe_str("codec_type", "unknown");
}
if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS)
probe_int("id", stream->id);
probe_str("avg_frame_rate",
rational_string(val_str, sizeof(val_str), "/",
&stream->avg_frame_rate));
probe_str("time_base",
rational_string(val_str, sizeof(val_str), "/",
&stream->time_base));
probe_str("start_time",
time_value_string(val_str, sizeof(val_str),
stream->start_time, &stream->time_base));
probe_str("duration",
time_value_string(val_str, sizeof(val_str),
stream->duration, &stream->time_base));
if (stream->nb_frames)
probe_int("nb_frames", stream->nb_frames);
probe_dict(stream->metadata, "tags");
probe_object_footer("stream");
}
static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)
{
AVStream *stream = fmt_ctx->streams[stream_idx];
AVCodecContext *dec_ctx;
const AVCodec *dec;
const char *profile;
char val_str[128];
AVRational display_aspect_ratio, *sar = NULL;
const AVPixFmtDescriptor *desc;
probe_object_header("stream");
probe_int("index", stream->index);
if ((dec_ctx = stream->codec)) {
if ((dec = dec_ctx->codec)) {
probe_str("codec_name", dec->name);
probe_str("codec_long_name", dec->long_name);
} else {
probe_str("codec_name", "unknown");
}
probe_str("codec_type", media_type_string(dec_ctx->codec_type));
probe_str("codec_time_base",
rational_string(val_str, sizeof(val_str),
"/", &dec_ctx->time_base));
/* print AVI/FourCC tag */
av_get_codec_tag_string(val_str, sizeof(val_str), dec_ctx->codec_tag);
probe_str("codec_tag_string", val_str);
probe_str("codec_tag", tag_string(val_str, sizeof(val_str),
dec_ctx->codec_tag));
/* print profile, if there is one */
if (dec && (profile = av_get_profile_name(dec, dec_ctx->profile)))
probe_str("profile", profile);
switch (dec_ctx->codec_type) {
case AVMEDIA_TYPE_VIDEO:
probe_int("width", dec_ctx->width);
probe_int("height", dec_ctx->height);
probe_int("coded_width", dec_ctx->coded_width);
probe_int("coded_height", dec_ctx->coded_height);
probe_int("has_b_frames", dec_ctx->has_b_frames);
if (dec_ctx->sample_aspect_ratio.num)
sar = &dec_ctx->sample_aspect_ratio;
else if (stream->sample_aspect_ratio.num)
sar = &stream->sample_aspect_ratio;
if (sar) {
probe_str("sample_aspect_ratio",
rational_string(val_str, sizeof(val_str), ":", sar));
av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
dec_ctx->width * sar->num, dec_ctx->height * sar->den,
1024*1024);
probe_str("display_aspect_ratio",
rational_string(val_str, sizeof(val_str), ":",
&display_aspect_ratio));
}
desc = av_pix_fmt_desc_get(dec_ctx->pix_fmt);
probe_str("pix_fmt", desc ? desc->name : "unknown");
probe_int("level", dec_ctx->level);
probe_str("color_range", av_color_range_name(dec_ctx->color_range));
probe_str("color_space", av_color_space_name(dec_ctx->colorspace));
probe_str("color_trc", av_color_transfer_name(dec_ctx->color_trc));
probe_str("color_pri", av_color_primaries_name(dec_ctx->color_primaries));
probe_str("chroma_loc", av_chroma_location_name(dec_ctx->chroma_sample_location));
break;
case AVMEDIA_TYPE_AUDIO:
probe_str("sample_rate",
value_string(val_str, sizeof(val_str),
dec_ctx->sample_rate,
unit_hertz_str));
probe_int("channels", dec_ctx->channels);
probe_int("bits_per_sample",
av_get_bits_per_sample(dec_ctx->codec_id));
break;
}
} else {
probe_str("codec_type", "unknown");
}
if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS)
probe_int("id", stream->id);
probe_str("avg_frame_rate",
rational_string(val_str, sizeof(val_str), "/",
&stream->avg_frame_rate));
if (dec_ctx->bit_rate)
probe_str("bit_rate",
value_string(val_str, sizeof(val_str),
dec_ctx->bit_rate, unit_bit_per_second_str));
probe_str("time_base",
rational_string(val_str, sizeof(val_str), "/",
&stream->time_base));
probe_str("start_time",
time_value_string(val_str, sizeof(val_str),
stream->start_time, &stream->time_base));
probe_str("duration",
time_value_string(val_str, sizeof(val_str),
stream->duration, &stream->time_base));
if (stream->nb_frames)
probe_int("nb_frames", stream->nb_frames);
probe_dict(stream->metadata, "tags");
if (stream->nb_side_data) {
int i, j;
probe_object_header("sidedata");
for (i = 0; i < stream->nb_side_data; i++) {
const AVPacketSideData* sd = &stream->side_data[i];
switch (sd->type) {
case AV_PKT_DATA_DISPLAYMATRIX:
probe_object_header("displaymatrix");
probe_array_header("matrix", 1);
for (j = 0; j < 9; j++)
probe_int(NULL, ((int32_t *)sd->data)[j]);
probe_array_footer("matrix", 1);
probe_int("rotation",
av_display_rotation_get((int32_t *)sd->data));
probe_object_footer("displaymatrix");
break;
}
}
probe_object_footer("sidedata");
}
probe_object_footer("stream");
}
void populateSettings(const QByteArray &xSettings)
{
if (xSettings.length() < 12)
return;
char byteOrder = xSettings.at(0);
if (byteOrder != LSBFirst && byteOrder != MSBFirst) {
qWarning("%s ByteOrder byte %d not 0 or 1", Q_FUNC_INFO , byteOrder);
return;
}
#define ADJUST_BO(b, t, x) \
((b == LSBFirst) ? \
qFromLittleEndian<t>((const uchar *)(x)) : \
qFromBigEndian<t>((const uchar *)(x)))
#define VALIDATE_LENGTH(x) \
if ((size_t)xSettings.length() < (offset + local_offset + 12 + x)) { \
qWarning("%s Length %d runs past end of data", Q_FUNC_INFO , x); \
return; \
}
uint number_of_settings = ADJUST_BO(byteOrder, quint32, xSettings.mid(8,4).constData());
const char *data = xSettings.constData() + 12;
size_t offset = 0;
for (uint i = 0; i < number_of_settings; i++) {
int local_offset = 0;
VALIDATE_LENGTH(2);
XSettingsType type = static_cast<XSettingsType>(*reinterpret_cast<const quint8 *>(data + offset));
local_offset += 2;
VALIDATE_LENGTH(2);
quint16 name_len = ADJUST_BO(byteOrder, quint16, data + offset + local_offset);
local_offset += 2;
VALIDATE_LENGTH(name_len);
QByteArray name(data + offset + local_offset, name_len);
local_offset += round_to_nearest_multiple_of_4(name_len);
VALIDATE_LENGTH(4);
int last_change_serial = ADJUST_BO(byteOrder, qint32, data + offset + local_offset);
Q_UNUSED(last_change_serial);
local_offset += 4;
QVariant value;
if (type == XSettingsTypeString) {
VALIDATE_LENGTH(4);
int value_length = ADJUST_BO(byteOrder, qint32, data + offset + local_offset);
local_offset+=4;
VALIDATE_LENGTH(value_length);
QByteArray value_string(data + offset + local_offset, value_length);
value.setValue(value_string);
local_offset += round_to_nearest_multiple_of_4(value_length);
} else if (type == XSettingsTypeInteger) {
VALIDATE_LENGTH(4);
int value_length = ADJUST_BO(byteOrder, qint32, data + offset + local_offset);
local_offset += 4;
value.setValue(value_length);
} else if (type == XSettingsTypeColor) {
VALIDATE_LENGTH(2*4);
quint16 red = ADJUST_BO(byteOrder, quint16, data + offset + local_offset);
local_offset += 2;
quint16 green = ADJUST_BO(byteOrder, quint16, data + offset + local_offset);
local_offset += 2;
quint16 blue = ADJUST_BO(byteOrder, quint16, data + offset + local_offset);
local_offset += 2;
quint16 alpha= ADJUST_BO(byteOrder, quint16, data + offset + local_offset);
local_offset += 2;
QColor color_value(red,green,blue,alpha);
value.setValue(color_value);
}
offset += local_offset;
settings[name].updateValue(screen,name,value,last_change_serial);
}
}
/* The c++ function for: main(lp:list[string]) [NEW_ALLOC+BAG_UPDATE+SLOT_UPDATE+STRING_UPDATE] */
void main_list(list *lp)
{ GC_BIND;
{ ClaireBoolean * rCode = CTRUE;
char * _Zcm = copy_string("");
char * _Zcf = copy_string("");
int dblevel = 1;
char * _Zout = copy_string("");
char * _Zcj = copy_string("");
int slevel = 0;
int clevel = 1;
ClaireBoolean * _Zinit_ask = CTRUE;
int vlevel = 2;
list * l = ((list *) copy_bag(lp));
{ ClaireHandler c_handle = ClaireHandler();
if ERROR_IN
{ { (Reader._starfs_star->value= _string_(copy_string("\\")));
(OBJECT(Generate_producer,Generate.PRODUCER->value)->extension = copy_string(".cpp"));
update_property(Optimize.libraries_dir,
Optimize.compiler,
17,
Kernel._object,
_oid_(list::alloc(Kernel._any,3,_string_(copy_string("c:\\claire\\v3.3\\bin\\public\\ntv")),
_string_(copy_string("c:\\claire\\v3.3\\bin\\debug\\ntv")),
_string_(copy_string("c:\\claire\\v3.3\\bin\\public\\ntv")))));
(Optimize.compiler->headers_dir = copy_string("c:\\claire\\v3.3\\bin\\include"));
update_property(Optimize.options,
Optimize.compiler,
19,
Kernel._object,
_oid_(list::alloc(Kernel._any,3,_string_(copy_string("-c /O2 /Oi")),
_string_(copy_string("-c /Zi")),
_string_(copy_string("-c /Zi")))));
(Optimize.compiler->env = copy_string("ntv"));
(Optimize.claire_lib->value= _string_(copy_string("")));
{ while ((l->length != 0))
{ if ((equal((*(l))[1],_string_(copy_string("?"))) == CTRUE) ||
(equal((*(l))[1],_string_(copy_string("-help"))) == CTRUE))
printHelp_void();
else if (equal((*(l))[1],_string_(copy_string("-s"))) == CTRUE)
{ if (3 <= l->length)
l= skip_list(l,3);
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -s <s1> <s2>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-f"))) == CTRUE)
{ if (2 <= l->length)
{ load_string(string_v((*(l))[2]));
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -f <filename>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-env"))) == CTRUE)
{ if (2 <= l->length)
{ (Optimize.compiler->env = string_v((*(l))[2]));
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -env <OS name>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-m"))) == CTRUE)
{ if (2 <= l->length)
{ if (_Zinit_ask == CTRUE)
{ load_string(copy_string("init"));
_Zinit_ask= CFALSE;
}
{ module * m = string2module_string(string_v((*(l))[2]));
load_module(m);
begin_module(m);
l= skip_list(l,2);
(Optimize.claire_modules->value= _oid_(OBJECT(list,Optimize.claire_modules->value)->addFast(_oid_(m))));
}
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -m <module>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-v"))) == CTRUE)
{ if (2 <= l->length)
{ vlevel= (vlevel+integer_I_string(string_v((*(l))[2])));
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -v <integer>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-ld"))) == CTRUE)
{ if (2 <= l->length)
{ (Optimize.claire_lib->value= (*(l))[2]);
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -od <directory>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-od"))) == CTRUE)
{ if (2 <= l->length)
{ (Optimize.compiler->source = string_v((*(l))[2]));
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -od <directory>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-os"))) == CTRUE)
{ if (2 <= l->length)
{ slevel= integer_I_string(string_v((*(l))[2]));
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -ol <int>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-S"))) == CTRUE)
{ if (2 <= l->length)
{ (CLREAD(global_variable,new_class2(Core._global_variable,symbol_I_string2(string_v((*(l))[2]))),value) = Kernel.ctrue);
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -S <FLAG>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-o"))) == CTRUE)
{ if (2 <= l->length)
{ _Zout= string_v((*(l))[2]);
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -o <name>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-p"))) == CTRUE)
{ (Optimize.OPT->profile_ask = CTRUE);
dblevel= ((dblevel <= 1) ?
1 :
dblevel );
l= skip_list(l,1);
}
else if (equal((*(l))[1],_string_(copy_string("-D"))) == CTRUE)
{ dblevel= 0;
l= skip_list(l,1);
}
else if (equal((*(l))[1],_string_(copy_string("-safe"))) == CTRUE)
{ (Optimize.compiler->safety = ((dblevel == 0) ?
0 :
1 ));
(Optimize.claire_lib->value= (*(Optimize.compiler->libraries_dir))[2]);
(Optimize.claire_options->value= (*(Optimize.compiler->options))[2]);
l= skip_list(l,1);
}
else if (equal((*(l))[1],_string_(copy_string("-O"))) == CTRUE)
{ (Optimize.compiler->optimize_ask = CTRUE);
dblevel= 2;
l= skip_list(l,1);
}
else if (equal((*(l))[1],_string_(copy_string("-l"))) == CTRUE)
{ if (2 <= l->length)
{ Optimize.compiler->libraries->addFast((*(l))[2]);
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -l <library>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-cl"))) == CTRUE)
{ if (2 <= l->length)
{ _Zcm= string_v((*(l))[2]);
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -cm <module>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-cc"))) == CTRUE)
{ if (2 <= l->length)
{ clevel= 0;
_Zcm= string_v((*(l))[2]);
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -cc <module>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-cm"))) == CTRUE)
{ if (2 <= l->length)
{ clevel= 2;
_Zcm= string_v((*(l))[2]);
l= skip_list(l,2);
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -cl <module>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-cj"))) == CTRUE)
{ if (2 <= l->length)
{ _Zcj= string_v((*(l))[2]);
l= skip_list(l,2);
}
}
else if (equal((*(l))[1],_string_(copy_string("-cjx"))) == CTRUE)
{ if (2 <= l->length)
{ _Zcj= string_v((*(l))[2]);
clevel= 0;
l= skip_list(l,2);
}
}
else if (equal((*(l))[1],_string_(copy_string("-cx"))) == CTRUE)
{ if (2 <= l->length)
{ _Zcf= string_v((*(l))[2]);
l= skip_list(l,2);
clevel= 2;
}
else close_exception(((general_error *) (*Core._general_error)(_string_(copy_string("option: -cx <filename>")),
_oid_(Kernel.nil))));
}
else if (equal((*(l))[1],_string_(copy_string("-n"))) == CTRUE)
{ _Zinit_ask= CFALSE;
l= skip_list(l,1);
}
else { if (string_v((*(l))[1])[1 - 1] == '-')
{ print_any((*(l))[1]);
princ_string(copy_string(" is an unvalid option\n"));
printHelp_void();
}
rCode= CFALSE;
l= list::empty(Kernel._string);
}
}
}
if (equal_string(_Zout,copy_string("")) == CTRUE)
{ if (equal_string(_Zcm,copy_string("")) != CTRUE)
_Zout= _Zcm;
else if (equal_string(_Zcf,copy_string("")) != CTRUE)
_Zout= _Zcf;
}
if (_Zinit_ask == CTRUE)
load_string(copy_string("init"));
(Optimize.claire_options->value= (*(Optimize.compiler->options))[((dblevel == 0) ?
2 :
((dblevel == 2) ?
1 :
3 ) )]);
if (equal(Optimize.claire_lib->value,_string_(copy_string(""))) == CTRUE)
(Optimize.claire_lib->value= (*(Optimize.compiler->libraries_dir))[((dblevel == 0) ?
2 :
((dblevel == 2) ?
1 :
3 ) )]);
(ClEnv->verbose = vlevel);
if (slevel > 0)
(Optimize.compiler->safety = slevel);
if (equal_string(_Zcm,copy_string("")) != CTRUE)
{ module * m = string2module_string(_Zcm);
(Optimize.compiler->active_ask = CTRUE);
if (equal(_oid_(m->uses),_oid_(list::alloc(1,GC_OID((*(OBJECT(bag,Optimize.claire_modules->value)))[2])))) == CTRUE)
{ (Optimize.claire_modules->value= _oid_(shrink_list(OBJECT(bag,Optimize.claire_modules->value),2)));
tformat_string(copy_string("=== Light Module ~S:~S -> use ~S=== "),0,list::alloc(3,_oid_(m),
GC_OID(_oid_(m->uses)),
GC_OID(Optimize.claire_modules->value)));
}
(Optimize.claire_modules->value= _oid_(OBJECT(list,Optimize.claire_modules->value)->addFast(_oid_(m))));
(*Reader.load)(value_string(copy_string("Compile")));
if (equal_string(_Zout,copy_string("")) != CTRUE)
(m->external = _Zout);
load_module(m);
if (dblevel < 1)
{ (Optimize.compiler->safety = ((Optimize.compiler->safety <= 4) ?
Optimize.compiler->safety :
4 ));
Optimize.compiler->debug_ask->addFast(_oid_(m));
}
compile_module(m);
if (clevel == 1)
{ if (equal_string(_Zout,copy_string("")) != CTRUE)
(m->external = _Zout);
cmakefile_any(_oid_(m),copy_string(""));
}
else if (clevel == 2)
cmakefile_any(_oid_(m),_Zout);
CL_exit(0);
}
else if (equal_string(_Zcj,copy_string("")) != CTRUE)
(*Core.call)(value_string(copy_string("jcmakefile")),
_oid_(string2module_string(_Zcj)),
_string_(_Zout),
_oid_(equal(clevel,0)));
else if (equal_string(_Zcf,copy_string("")) != CTRUE)
{ (Optimize.compiler->active_ask = CTRUE);
(*Reader.load)(value_string(copy_string("Compile")));
load_string(_Zcf);
function_compile_string(_Zcf,_Zcf);
cmakefile_any(_string_(_Zcf),_Zout);
CL_exit(0);
}
}
ClEnv->cHandle--;}
else if (belong_to(_oid_(ClEnv->exception_I),_oid_(Kernel._any)) == CTRUE)
{ c_handle.catchIt();{ restore_state_meta_reader(Reader.reader);
debug_if_possible_void();
}
}
else PREVIOUS_HANDLER;}
}
struct value *
value_concat (struct value *arg1, struct value *arg2)
{
struct value *inval1;
struct value *inval2;
struct value *outval = NULL;
int inval1len, inval2len;
int count, idx;
char *ptr;
char inchar;
struct type *type1 = check_typedef (value_type (arg1));
struct type *type2 = check_typedef (value_type (arg2));
struct type *char_type;
/* First figure out if we are dealing with two values to be concatenated
or a repeat count and a value to be repeated. INVAL1 is set to the
first of two concatenated values, or the repeat count. INVAL2 is set
to the second of the two concatenated values or the value to be
repeated. */
if (TYPE_CODE (type2) == TYPE_CODE_INT)
{
struct type *tmp = type1;
type1 = tmp;
tmp = type2;
inval1 = arg2;
inval2 = arg1;
}
else
{
inval1 = arg1;
inval2 = arg2;
}
/* Now process the input values. */
if (TYPE_CODE (type1) == TYPE_CODE_INT)
{
/* We have a repeat count. Validate the second value and then
construct a value repeated that many times. */
if (TYPE_CODE (type2) == TYPE_CODE_STRING
|| TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
count = longest_to_int (value_as_long (inval1));
inval2len = TYPE_LENGTH (type2);
ptr = (char *) alloca (count * inval2len);
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
char_type = type2;
inchar = (char) unpack_long (type2,
value_contents (inval2));
for (idx = 0; idx < count; idx++)
{
*(ptr + idx) = inchar;
}
}
else
{
char_type = TYPE_TARGET_TYPE (type2);
for (idx = 0; idx < count; idx++)
{
memcpy (ptr + (idx * inval2len), value_contents (inval2),
inval2len);
}
}
outval = value_string (ptr, count * inval2len, char_type);
}
else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
|| TYPE_CODE (type2) == TYPE_CODE_BOOL)
{
error (_("unimplemented support for bitstring/boolean repeats"));
}
else
{
error (_("can't repeat values of that type"));
}
}
else if (TYPE_CODE (type1) == TYPE_CODE_STRING
|| TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
/* We have two character strings to concatenate. */
if (TYPE_CODE (type2) != TYPE_CODE_STRING
&& TYPE_CODE (type2) != TYPE_CODE_CHAR)
{
error (_("Strings can only be concatenated with other strings."));
}
inval1len = TYPE_LENGTH (type1);
inval2len = TYPE_LENGTH (type2);
ptr = (char *) alloca (inval1len + inval2len);
if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
char_type = type1;
*ptr = (char) unpack_long (type1, value_contents (inval1));
}
else
{
char_type = TYPE_TARGET_TYPE (type1);
memcpy (ptr, value_contents (inval1), inval1len);
}
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
*(ptr + inval1len) =
(char) unpack_long (type2, value_contents (inval2));
}
else
{
memcpy (ptr + inval1len, value_contents (inval2), inval2len);
}
outval = value_string (ptr, inval1len + inval2len, char_type);
}
else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
|| TYPE_CODE (type1) == TYPE_CODE_BOOL)
{
/* We have two bitstrings to concatenate. */
if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
&& TYPE_CODE (type2) != TYPE_CODE_BOOL)
{
error (_("Bitstrings or booleans can only be concatenated "
"with other bitstrings or booleans."));
}
error (_("unimplemented support for bitstring/boolean concatenation."));
}
else
{
/* We don't know how to concatenate these operands. */
error (_("illegal operands for concatenation."));
}
return (outval);
}
