static GIFmetafile *copy_meta(mf_cgmo *cgmo, GIFmetafile *old,
int sx, int sy)
{
GIFmetafile *newmeta = init_meta(cgmo, sx, sy);
int i;
/* Copy various stuff -- don't copy resize! */
newmeta->lineIndex = old->lineIndex;
newmeta->lineWidth = old->lineWidth;
newmeta->fillIndex = old->fillIndex;
newmeta->styleIndex = old->styleIndex;
newmeta->fillStyleIndex = old->fillStyleIndex;
newmeta->style = (int *)umalloc(sizeof(int) * MaxLineStyleLength);
memcpy(newmeta->style, old->style, sizeof(int)*MaxLineStyleLength);
newmeta->ws = old->ws;
/* Copy the color info */
for (i=0; i < old->numcolors; ++i){
GIFcolor *color = &old->colors[i];
if (old->colors[i].index == -1)
break;
allocate_color(newmeta, i, color->r, color->g, color->b);
}
/* Destroy the old metafile */
destroy_meta(cgmo, old);
/* Add this one */
add_meta(cgmo, newmeta);
return newmeta;
}
static GIFmetafile *create_meta(mf_cgmo *cgmo, int sx, int sy)
{
GIFmetafile *newmeta = init_meta(cgmo, sx, sy);
assert(newmeta->image);
add_meta(cgmo, newmeta);
return newmeta;
}
int config_read(const char *cfg_file) {
char line[1024], r1[1024], r2[1024];
int line_num = 0;
FILE *fp;
fp = fopen(cfg_file, "r");
if (fp == NULL) {
printf("CFG_ERR: Configuration file (%s) not found.\n", cfg_file);
return 1;
}
while(fgets(line, sizeof(line), fp)) {
line_num++;
if (line[0] == '/' && line[1] == '/')
continue;
if (sscanf(line, "%[^:]: %[^\r\n]", r1, r2) == 2) {
if(strcmpi(r1, "login_port") == 0) {
login_port = atoi(r2);
} else if(strcmpi(r1, "login_id") == 0) {
strncpy(login_id, r2, 32);
login_id[31] = '\0';
} else if(strcmpi(r1, "login_pw") == 0) {
strncpy(login_pw, r2, 32);
login_pw[31] = '\0';
} else if(strcmpi(r1, "login_log") == 0) {
set_logfile(r2);
} else if(strcmpi(r1, "dump_log") == 0) {
set_dmpfile(r2);
} else if(strcmpi(r1, "dump_save") == 0) {
dump_save = atoi(r2);
} else if(strcmpi(r1, "meta") == 0) {
add_meta(r2);
} else if(strcmpi(r1,"version")==0) {
nex_version=atoi(r2);
} else if(strcmpi(r1,"deep")==0) {
nex_deep=atoi(r2);
} else if(strcmpi(r1,"sql_ip")==0) {
strcpy(sql_ip,r2);
} else if(strcmpi(r1, "sql_port") == 0) {
sql_port=atoi(r2);
} else if(strcmpi(r1, "sql_id") == 0) {
strcpy(sql_id,r2);
} else if(strcmpi(r1, "sql_pw") == 0) {
strcpy(sql_pw,r2);
} else if(strcmpi(r1, "sql_db") == 0) {
strcpy(sql_db,r2);
} else if(strcmpi(r1, "require_reg") == 0) {
require_reg=atoi(r2);
}
}
}
fclose(fp);
printf("Configuration File (%s) reading finished!\n", cfg_file);
return 0;
}
static bool parse_track_dict( demux_t *p_demux, input_item_node_t *p_input_node,
track_elem_t *p_track, xml_reader_t *p_xml_reader,
const char *psz_element,
xml_elem_hnd_t *p_handlers )
{
VLC_UNUSED(psz_element); VLC_UNUSED(p_handlers);
input_item_t *p_new_input = NULL;
int i_ret;
p_track = new_track();
xml_elem_hnd_t track_elements[] =
// sunqueen modify start
// { {"array", COMPLEX_CONTENT, {.cmplx = skip_element} },
// {"key", SIMPLE_CONTENT, {.smpl = save_data} },
// {"integer", SIMPLE_CONTENT, {.smpl = save_data} },
// {"string", SIMPLE_CONTENT, {.smpl = save_data} },
// {"date", SIMPLE_CONTENT, {.smpl = save_data} },
{ {"array", COMPLEX_CONTENT, {(bool (__cdecl *)(track_elem_t *,const char *,char *))skip_element} },
{"key", SIMPLE_CONTENT, {save_data} },
{"integer", SIMPLE_CONTENT, {save_data} },
{"string", SIMPLE_CONTENT, {save_data} },
{"date", SIMPLE_CONTENT, {save_data} },
// sunqueen modify end
{"true", SIMPLE_CONTENT, {NULL} },
{"false", SIMPLE_CONTENT, {NULL} },
{NULL, UNKNOWN_CONTENT, {NULL} }
};
i_ret = parse_dict( p_demux, p_input_node, p_track,
p_xml_reader, "dict", track_elements );
msg_Dbg( p_demux, "name: %s, artist: %s, album: %s, genre: %s, trackNum: %s, location: %s",
p_track->name, p_track->artist, p_track->album, p_track->genre, p_track->trackNum, p_track->location );
if( !p_track->location )
{
msg_Err( p_demux, "Track needs Location" );
free_track( p_track );
return false;
}
msg_Info( p_demux, "Adding '%s'", p_track->location );
p_new_input = input_item_New( p_track->location, NULL );
input_item_node_AppendItem( p_input_node, p_new_input );
/* add meta info */
add_meta( p_new_input, p_track );
vlc_gc_decref( p_new_input );
p_demux->p_sys->i_ntracks++;
free_track( p_track );
return i_ret;
}
void add_outiface(struct nftnl_rule *r, char *iface, uint32_t op)
{
int iface_len;
iface_len = strlen(iface);
add_meta(r, NFT_META_OIFNAME);
if (iface[iface_len - 1] == '+')
add_cmp_ptr(r, op, iface, iface_len - 1);
else
add_cmp_ptr(r, op, iface, iface_len + 1);
}
static int load_metadata(AVFormatContext *s)
{
GMEContext *gme = s->priv_data;
gme_info_t *info = gme->info;
char buf[30];
add_meta(s, "system", info->system);
add_meta(s, "game", info->game);
add_meta(s, "song", info->song);
add_meta(s, "author", info->author);
add_meta(s, "copyright", info->copyright);
add_meta(s, "comment", info->comment);
add_meta(s, "dumper", info->dumper);
snprintf(buf, sizeof(buf), "%d", (int)gme_track_count(gme->music_emu));
add_meta(s, "tracks", buf);
return 0;
}
static int
update_vorbis_comments (DB_playItem_t *it, OggVorbis_File *vorbis_file, const int tracknum) {
const vorbis_comment *vc = ov_comment(vorbis_file, tracknum);
if (!vc) {
trace("update_vorbis_comments: ov_comment failed\n");
return -1;
}
deadbeef->pl_delete_all_meta (it);
for (int i = 0; i < vc->comments; i++) {
char *tag = strdup(vc->user_comments[i]);
char *value;
if (tag && (value = strchr(tag, '='))
#ifdef ANDROID
&& strlen (value) < 4000
#endif
) {
*value++ = '\0';
if (!replaygain_tag(it, DDB_REPLAYGAIN_ALBUMGAIN, tag, value) &&
!replaygain_tag(it, DDB_REPLAYGAIN_ALBUMPEAK, tag, value) &&
!replaygain_tag(it, DDB_REPLAYGAIN_TRACKGAIN, tag, value) &&
!replaygain_tag(it, DDB_REPLAYGAIN_TRACKPEAK, tag, value)
&& strcasecmp (tag, "METADATA_BLOCK_PICTURE")) {
add_meta(it, oggedit_map_tag(tag, "tag2meta"), value);
}
}
if (tag) {
free(tag);
}
}
deadbeef->pl_add_meta (it, "title", NULL);
uint32_t f = deadbeef->pl_get_item_flags (it);
f &= ~DDB_TAG_MASK;
f |= DDB_TAG_VORBISCOMMENTS;
deadbeef->pl_set_item_flags (it, f);
ddb_playlist_t *plt = deadbeef->plt_get_curr ();
if (plt) {
deadbeef->plt_modified (plt);
deadbeef->plt_unref (plt);
}
deadbeef->sendmessage (DB_EV_PLAYLISTCHANGED, 0, DDB_PLAYLIST_CHANGE_CONTENT, 0);
return 0;
}
void watchman_perf_sample::add_root_meta(
const std::shared_ptr<w_root_t>& root) {
// Note: if the root lock isn't held, we may read inaccurate numbers for
// some of these properties. We're ok with that, and don't want to force
// the root lock to be re-acquired just for this.
auto meta = json_object(
{{"path", w_string_to_json(root->root_path)},
{"recrawl_count", json_integer(root->recrawlInfo.rlock()->recrawlCount)},
{"case_sensitive", json_boolean(root->case_sensitive)}});
// During recrawl, the view may be re-assigned. Protect against
// reading a nullptr.
auto view = root->inner.view;
if (view) {
auto position = view->getMostRecentRootNumberAndTickValue();
meta.set({{"number", json_integer(position.rootNumber)},
{"ticks", json_integer(position.ticks)},
{"watcher", w_string_to_json(view->getName())}});
}
add_meta("root", std::move(meta));
}
void main(int argc, char** argv)
{
char files[MAX_FILES][PATH_MAX] = {'\0'};
char test[MAX_FILES][PATH_MAX] = {'\0'};
int ret = 0;
char* file_to_remove = "a.c";
char* file_to_rename = "b.c";
char* file_to_add = "d.c";
char* new_name_for_file = "wubwub.c";
char* file_name_to_change = "/dir/dir/dir/go.c";
char* name_to_change_file = "gooch.c";
remove_meta(argv[1], file_to_remove);
rename_meta(argv[1], file_to_rename, new_name_for_file);
add_meta(argv[1], file_to_add);
printf("Return value actually was %s\n",change_filename(file_name_to_change, name_to_change_file));
ret = load_meta(&test, argv[1]);
int i = 0;
puts("Files Loaded\n==================");
for(i; i< ret; i++)
{
printf("Index %d : %s\n", i, test[i]);
}
}
/**
* This function optimizes the given transition.
*/
static void optimize_transition(Variables* v,OutputVariables* output,Fst2* fst2,Transition* transition,
OptimizedFst2State state,Fst2Tag* tags,Abstract_allocator prv_alloc) {
if (transition->tag_number<0) {
/* If the transition is a graph call */
add_graph_call(transition,&(state->graph_calls),prv_alloc);
add_graph_call(transition,&(state->unoptimized_graph_calls),prv_alloc);
return;
}
Fst2Tag tag=tags[transition->tag_number];
if (tag==NULL) {
fatal_error("NULL transition tag in optimize_transition\n");
}
int negation=is_bit_mask_set(tag->control,NEGATION_TAG_BIT_MASK);
/* First, we look if there is a compound pattern associated to this tag */
if (tag->compound_pattern!=NO_COMPOUND_PATTERN) {
add_pattern(tag->compound_pattern,transition,&(state->compound_patterns),negation,prv_alloc);
}
/* Then, we look the possible kind of transitions */
switch (tag->type) {
case TOKEN_LIST_TAG: add_token_list(tag->matching_tokens,transition,&(state->token_list),&(state->number_of_tokens),prv_alloc);
return;
case PATTERN_NUMBER_TAG: add_pattern(tag->pattern_number,transition,&(state->patterns),negation,prv_alloc);
return;
case META_TAG: {
add_meta(tag->meta,transition,&(state->metas),negation,prv_alloc);
add_meta(tag->meta,transition,&(state->unoptimized_metas),negation,prv_alloc);
return;
}
case BEGIN_VAR_TAG: {
add_input_variable(v,tag->variable,transition,&(state->input_variable_starts),prv_alloc);
add_input_variable(v,tag->variable,transition,&(state->unoptimized_input_variable_starts),prv_alloc);
return;
}
case END_VAR_TAG: {
add_input_variable(v,tag->variable,transition,&(state->input_variable_ends),prv_alloc);
add_input_variable(v,tag->variable,transition,&(state->unoptimized_input_variable_ends),prv_alloc);
return;
}
case BEGIN_OUTPUT_VAR_TAG: {
add_output_variable(output,tag->variable,transition,&(state->output_variable_starts),prv_alloc);
add_output_variable(output,tag->variable,transition,&(state->unoptimized_output_variable_starts),prv_alloc);
return;
}
case END_OUTPUT_VAR_TAG: {
add_output_variable(output,tag->variable,transition,&(state->output_variable_ends),prv_alloc);
add_output_variable(output,tag->variable,transition,&(state->unoptimized_output_variable_ends),prv_alloc);
return;
}
case BEGIN_POSITIVE_CONTEXT_TAG: add_positive_context(fst2,state,transition,prv_alloc); return;
case BEGIN_NEGATIVE_CONTEXT_TAG: add_negative_context(fst2,state,transition,prv_alloc); return;
case END_CONTEXT_TAG: add_end_context(state,transition,prv_alloc); return;
case LEFT_CONTEXT_TAG: {
add_meta(META_LEFT_CONTEXT,transition,&(state->metas),0,prv_alloc);
add_meta(META_LEFT_CONTEXT,transition,&(state->unoptimized_metas),0,prv_alloc);
return;
}
case BEGIN_MORPHO_TAG: {
struct opt_meta* new_meta=add_meta(META_BEGIN_MORPHO,transition,&(state->metas),0,prv_alloc);
get_reachable_closing_morphological_mode(fst2,transition->state_number,&(new_meta->morphological_mode_ends),prv_alloc);
add_meta(META_BEGIN_MORPHO,transition,&(state->unoptimized_metas),0,prv_alloc);
return;
}
case END_MORPHO_TAG: {
add_meta(META_END_MORPHO,transition,&(state->metas),0,prv_alloc);
add_meta(META_END_MORPHO,transition,&(state->unoptimized_metas),0,prv_alloc);
return;
}
case TEXT_START_TAG: {
add_meta(META_TEXT_START,transition,&(state->metas),0,prv_alloc);
add_meta(META_TEXT_START,transition,&(state->unoptimized_metas),0,prv_alloc);
return;
}
case TEXT_END_TAG: {
add_meta(META_TEXT_END,transition,&(state->metas),0,prv_alloc);
add_meta(META_TEXT_END,transition,&(state->unoptimized_metas),0,prv_alloc);
return;
}
default: fatal_error("Unexpected transition tag type in optimize_transition\n");
}
}
static int read_header_openmpt(AVFormatContext *s)
{
AVStream *st;
OpenMPTContext *openmpt = s->priv_data;
int64_t size;
char *buf;
#if OPENMPT_API_VERSION_AT_LEAST(0,3,0)
int error;
#endif
int ret;
size = avio_size(s->pb);
if (size <= 0)
return AVERROR_INVALIDDATA;
buf = av_malloc(size);
if (!buf)
return AVERROR(ENOMEM);
size = avio_read(s->pb, buf, size);
if (size < 0) {
av_log(s, AV_LOG_ERROR, "Reading input buffer failed.\n");
av_freep(&buf);
return size;
}
#if OPENMPT_API_VERSION_AT_LEAST(0,3,0)
error = OPENMPT_ERROR_OK;
openmpt->module = openmpt_module_create_from_memory2(buf, size, openmpt_logfunc, s, NULL, NULL, &error, NULL, NULL);
av_freep(&buf);
if (!openmpt->module) {
if (error == OPENMPT_ERROR_OUT_OF_MEMORY)
return AVERROR(ENOMEM);
else if (error >= OPENMPT_ERROR_GENERAL)
return AVERROR_INVALIDDATA;
else
return AVERROR_UNKNOWN;
}
#else
openmpt->module = openmpt_module_create_from_memory(buf, size, openmpt_logfunc, s, NULL);
av_freep(&buf);
if (!openmpt->module)
return AVERROR_INVALIDDATA;
#endif
openmpt->channels = av_get_channel_layout_nb_channels(openmpt->layout);
if (openmpt->subsong >= openmpt_module_get_num_subsongs(openmpt->module)) {
openmpt_module_destroy(openmpt->module);
av_log(s, AV_LOG_ERROR, "Invalid subsong index: %d\n", openmpt->subsong);
return AVERROR(EINVAL);
}
if (openmpt->subsong != -2) {
if (openmpt->subsong >= 0) {
av_dict_set_int(&s->metadata, "track", openmpt->subsong + 1, 0);
}
ret = openmpt_module_select_subsong(openmpt->module, openmpt->subsong);
if (!ret){
openmpt_module_destroy(openmpt->module);
av_log(s, AV_LOG_ERROR, "Could not select requested subsong: %d", openmpt->subsong);
return AVERROR(EINVAL);
}
}
openmpt->duration = openmpt_module_get_duration_seconds(openmpt->module);
add_meta(s, "artist", openmpt_module_get_metadata(openmpt->module, "artist"));
add_meta(s, "title", openmpt_module_get_metadata(openmpt->module, "title"));
add_meta(s, "encoder", openmpt_module_get_metadata(openmpt->module, "tracker"));
add_meta(s, "comment", openmpt_module_get_metadata(openmpt->module, "message"));
add_meta(s, "date", openmpt_module_get_metadata(openmpt->module, "date"));
st = avformat_new_stream(s, NULL);
if (!st) {
openmpt_module_destroy(openmpt->module);
openmpt->module = NULL;
return AVERROR(ENOMEM);
}
avpriv_set_pts_info(st, 64, 1, AV_TIME_BASE);
st->duration = llrint(openmpt->duration*AV_TIME_BASE);
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codecpar->codec_id = AV_NE(AV_CODEC_ID_PCM_F32BE, AV_CODEC_ID_PCM_F32LE);
st->codecpar->channels = openmpt->channels;
st->codecpar->sample_rate = openmpt->sample_rate;
return 0;
}
/*
* m a n i f e s t o _ f n
*
* Called by pointer from manifesto(), once for
* each file within the directory.
*
*/
static int manifesto_fn
(char *relpath, char *basedir, char *reldir, char *filename, void *arg)
{
int use_js;
JAR_Digest dig;
char fullname [FNSIZE];
if (verbosity >= 0) {
PR_fprintf(outputFD, "--> %s\n", relpath);
}
/* extension matching */
if (extensionsGiven) {
char *ext = PL_strrchr(relpath, '.');
if (!ext)
return 0;
if (!PL_HashTableLookup(extensions, ext))
return 0;
}
sprintf (fullname, "%s/%s", basedir, relpath);
fprintf (mf, "\n");
use_js = 0;
if (scriptdir && !PORT_Strcmp (scriptdir, reldir))
use_js++;
/* sign non-.js files inside .arc directories using the javascript magic */
if ( (PL_strcaserstr(filename, ".js") != filename + strlen(filename) - 3)
&& (PL_strcaserstr(reldir, ".arc") == reldir + strlen(filename) - 4))
use_js++;
if (use_js) {
fprintf (mf, "Name: %s\n", filename);
fprintf (mf, "Magic: javascript\n");
if (optimize == 0)
fprintf (mf, "javascript.id: %s\n", filename);
if (metafile)
add_meta (mf, filename);
} else {
fprintf (mf, "Name: %s\n", relpath);
if (metafile)
add_meta (mf, relpath);
}
JAR_digest_file (fullname, &dig);
if (optimize == 0) {
fprintf (mf, "Digest-Algorithms: MD5 SHA1\n");
fprintf (mf, "MD5-Digest: %s\n", BTOA_DataToAscii (dig.md5,
MD5_LENGTH));
}
fprintf (mf, "SHA1-Digest: %s\n", BTOA_DataToAscii (dig.sha1, SHA1_LENGTH));
if (!use_js) {
JzipAdd(fullname, relpath, zipfile, compression_level);
}
return 0;
}
/*
* m a n i f e s t o
*
* Run once for every subdirectory in which a
* manifest is to be created -- usually exactly once.
*
*/
static int
manifesto (char *dirname, char *install_script, PRBool recurse)
{
char metadir [FNSIZE], sfname [FNSIZE];
/* Create the META-INF directory to hold signing info */
if (PR_Access (dirname, PR_ACCESS_READ_OK)) {
PR_fprintf(errorFD, "%s: unable to read your directory: %s\n",
PROGRAM_NAME, dirname);
errorCount++;
perror (dirname);
exit (ERRX);
}
if (PR_Access (dirname, PR_ACCESS_WRITE_OK)) {
PR_fprintf(errorFD, "%s: unable to write to your directory: %s\n",
PROGRAM_NAME, dirname);
errorCount++;
perror(dirname);
exit(ERRX);
}
sprintf (metadir, "%s/META-INF", dirname);
strcpy (sfname, metadir);
PR_MkDir (metadir, 0777);
strcat (metadir, "/");
strcat (metadir, MANIFEST);
if ((mf = fopen (metadir, "wb")) == NULL) {
perror (MANIFEST);
PR_fprintf(errorFD, "%s: Probably, the directory you are trying to"
" sign has\n", PROGRAM_NAME);
PR_fprintf(errorFD, "%s: permissions problems or may not exist.\n",
PROGRAM_NAME);
errorCount++;
exit (ERRX);
}
if (verbosity >= 0) {
PR_fprintf(outputFD, "Generating %s file..\n", metadir);
}
fprintf(mf, "Manifest-Version: 1.0\n");
fprintf (mf, "Created-By: %s\n", CREATOR);
fprintf (mf, "Comments: %s\n", BREAKAGE);
if (scriptdir) {
fprintf (mf, "Comments: --\n");
fprintf (mf, "Comments: --\n");
fprintf (mf, "Comments: -- This archive signs Javascripts which may not necessarily\n");
fprintf (mf, "Comments: -- be included in the physical jar file.\n");
fprintf (mf, "Comments: --\n");
fprintf (mf, "Comments: --\n");
}
if (install_script)
fprintf (mf, "Install-Script: %s\n", install_script);
if (metafile)
add_meta (mf, "+");
/* Loop through all files & subdirectories */
foreach (dirname, "", manifesto_fn, recurse, PR_FALSE /*include dirs */,
(void * )NULL);
fclose (mf);
strcat (sfname, "/");
strcat (sfname, base);
strcat (sfname, ".sf");
if (verbosity >= 0) {
PR_fprintf(outputFD, "Generating %s.sf file..\n", base);
}
generate_SF_file (metadir, sfname);
return 0;
}
