CloudStream::CloudStream( QUrl& url,
const QString& filename,
const QString& fileId,
const long length,
const QString& mimeType,
QVariantMap& headers,
QtScriptResolver* scriptResolver,
const QString & javascriptRefreshUrlFunction,
const QString& javascriptCallbackFunction,
const bool refreshUrlEachTime )
: m_url( url )
, m_filename( filename )
, m_fileId( fileId )
, m_encoded_filename( m_filename.toUtf8() )
, m_length( length )
, m_headers( headers )
, m_cursor( 0 )
, m_cache( length )
, m_num_requests( 0 )
, m_num_requests_in_error( 0 )
, m_scriptResolver( scriptResolver )
, m_javascriptRefreshUrlFunction( javascriptRefreshUrlFunction )
, m_javascriptCallbackFunction( javascriptCallbackFunction )
, m_refreshUrlEachTime( refreshUrlEachTime )
, m_currentBlocklength( 0 )
, m_cacheState( CloudStream::BeginningCache )
, m_tags( QVariantMap() )
{
m_network = TomahawkUtils::nam();
connect( this, SIGNAL( cacheReadFinished() ), this, SLOT( precache() ) );
m_tags["fileId"] = fileId;
m_tags["mimetype"] = mimeType;
}
void
CloudStream::onRequestFinished()
{
m_reply->deleteLater();
int code = m_reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ).toInt();
tDebug() << "######### CloudStream : HTTP reply : #########";
tDebug( LOGINFO ) << "#### Cloudstream : HttpStatusCode : " << code;
tDebug( LOGINFO ) << "#### Cloudstream : URL : " << m_reply->url();
QByteArray data = m_reply->readAll();
if ( code != 206 )
{
m_num_requests_in_error++;
tDebug( LOGINFO ) << "#### Cloudstream : Error " << code << " retrieving url to tag for " << m_filename;
tDebug() << "#### CloudStream : body response : " << data;
if ( refreshStreamUrl() )
{
readBlock (m_currentBlocklength);
return;
}
else
{
//return TagLib::ByteVector();
precache();
return ;
}
}
TagLib::ByteVector bytes( data.data(), data.size() );
m_cursor += data.size();
FillCache( m_currentStart, bytes );
precache();
}
MetricNumType Metric_INTEL_perfquery::numType() {
if (!m_precached) precache();
return m_nType;
}
unsigned Metric_INTEL_perfquery::offset() {
if (!m_precached) precache();
return m_offset;
}
std::string Metric_INTEL_perfquery::name() {
if (!m_precached) precache();
return m_name;
}
int
main(int argc, char **argv)
{
int i, do_precache = 0, valgrind_mode = 0;
int valgrind_tool = 0;
char buf[16384], **args, *p;
char valgrind_path[PATH_MAX] = "";
const char *valgrind_log = NULL;
eina_init();
prefix_determine(argv[0]);
env_set("E_START", argv[0]);
p = getenv("PATH");
if (p) snprintf(buf, sizeof(buf), "%s:%s", eina_prefix_bin_get(pfx), p);
else snprintf(buf, sizeof(buf), "%s", eina_prefix_bin_get(pfx));
env_set("PATH", buf);
p = getenv("LD_LIBRARY_PATH");
if (p) snprintf(buf, sizeof(buf), "%s:%s", eina_prefix_lib_get(pfx), p);
else snprintf(buf, sizeof(buf), "%s", eina_prefix_lib_get(pfx));
env_set("LD_LIBRARY_PATH", buf);
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-no-precache")) do_precache = 0;
else if (!strncmp(argv[i], "-valgrind", sizeof("-valgrind") - 1))
{
const char *val = argv[i] + sizeof("-valgrind") - 1;
if (*val == '\0') valgrind_mode = 1;
else if (*val == '-')
{
val++;
if (!strncmp(val, "log-file=", sizeof("log-file=") - 1))
{
valgrind_log = val + sizeof("log-file=") - 1;
if (*valgrind_log == '\0') valgrind_log = NULL;
}
}
else if (*val == '=')
{
val++;
if (!strcmp(val, "all")) valgrind_mode = VALGRIND_MODE_ALL;
else valgrind_mode = atoi(val);
}
else
printf("Unknown valgrind option: %s\n", argv[i]);
}
else if (!strcmp(argv[i], "-massif")) valgrind_tool = 1;
else if (!strcmp(argv[i], "-callgrind")) valgrind_tool = 2;
else if ((!strcmp(argv[i], "-h")) ||
(!strcmp(argv[i], "-help")) ||
(!strcmp(argv[i], "--help")))
{
printf
(
"Options:\n"
"\t-no-precache\n"
"\t\tDisable pre-caching of files\n"
"\t-valgrind[=MODE]\n"
"\t\tRun enlightenment from inside valgrind, mode is OR of:\n"
"\t\t 1 = plain valgrind to catch crashes (default)\n"
"\t\t 2 = trace children (thumbnailer, efm slaves, ...)\n"
"\t\t 4 = check leak\n"
"\t\t 8 = show reachable after processes finish.\n"
"\t\t all = all of above\n"
"\t-massif\n"
"\t\tRun enlightenment from inside massif valgrind tool.\n"
"\t-callgrind\n"
"\t\tRun enlightenment from inside callgrind valgrind tool.\n"
"\t-valgrind-log-file=<FILENAME>\n"
"\t\tSave valgrind log to file, see valgrind's --log-file for details.\n"
"\n"
"Please run:\n"
"\tenlightenment %s\n"
"for more options.\n",
argv[i]);
exit(0);
}
}
if (valgrind_mode || valgrind_tool)
{
if (!find_valgrind(valgrind_path, sizeof(valgrind_path)))
{
printf("E - valgrind required but no binary found! Ignoring request.\n");
valgrind_mode = 0;
}
}
printf("E - PID=%i, do_precache=%i, valgrind=%d", getpid(), do_precache, valgrind_mode);
if (valgrind_mode)
{
printf(" valgrind-command='%s'", valgrind_path);
if (valgrind_log) printf(" valgrind-log-file='%s'", valgrind_log);
}
putchar('\n');
if (do_precache)
{
void *lib, *func;
/* sanity checks - if precache might fail - check here first */
lib = dlopen("libeina.so", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) dlopen("libeina.so.1", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) goto done;
func = dlsym(lib, "eina_init");
if (!func) goto done;
lib = dlopen("libecore.so", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) dlopen("libecore.so.1", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) goto done;
func = dlsym(lib, "ecore_init");
if (!func) goto done;
lib = dlopen("libecore_file.so", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) dlopen("libecore_file.so.1", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) goto done;
func = dlsym(lib, "ecore_file_init");
if (!func) goto done;
lib = dlopen("libecore_x.so", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) dlopen("libecore_x.so.1", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) goto done;
func = dlsym(lib, "ecore_x_init");
if (!func) goto done;
lib = dlopen("libevas.so", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) dlopen("libevas.so.1", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) goto done;
func = dlsym(lib, "evas_init");
if (!func) goto done;
lib = dlopen("libedje.so", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) dlopen("libedje.so.1", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) goto done;
func = dlsym(lib, "edje_init");
if (!func) goto done;
lib = dlopen("libeet.so", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) dlopen("libeet.so.0", RTLD_GLOBAL | RTLD_LAZY);
if (!lib) goto done;
func = dlsym(lib, "eet_init");
if (!func) goto done;
/* precache SHOULD work */
snprintf(buf, sizeof(buf), "%s/enlightenment/preload/e_precache.so",
eina_prefix_lib_get(pfx));
env_set("LD_PRELOAD", buf);
printf("E - PRECACHE GOING NOW...\n");
fflush(stdout);
precache();
}
done:
/* mtrack memory tracker support */
p = getenv("HOME");
if (p)
{
FILE *f;
/* if you have ~/.e-mtrack, then the tracker will be enabled
* using the content of this file as the path to the mtrack.so
* shared object that is the mtrack preload */
snprintf(buf, sizeof(buf), "%s/.e-mtrack", p);
f = fopen(buf, "r");
if (f)
{
if (fgets(buf, sizeof(buf), f))
{
int len = strlen(buf);
if ((len > 1) && (buf[len - 1] == '\n'))
{
buf[len - 1] = 0;
len--;
}
env_set("LD_PRELOAD", buf);
env_set("MTRACK", "track");
env_set("E_START_MTRACK", "track");
snprintf(buf, sizeof(buf), "%s/.e-mtrack.log", p);
env_set("MTRACK_TRACE_FILE", buf);
}
fclose(f);
}
}
/* try dbus-launch */
snprintf(buf, sizeof(buf), "%s/enlightenment", eina_prefix_bin_get(pfx));
args = alloca((argc + 2 + VALGRIND_MAX_ARGS) * sizeof(char *));
if ((!getenv("DBUS_SESSION_BUS_ADDRESS")) &&
(!getenv("DBUS_LAUNCHD_SESSION_BUS_SOCKET")))
{
args[0] = "dbus-launch";
args[1] = "--exit-with-session";
i = 2 + valgrind_append(args + 2, valgrind_mode, valgrind_tool, valgrind_path, valgrind_log);
args[i++] = buf;
copy_args(args + i, argv + 1, argc - 1);
args[i + argc - 1] = NULL;
execvp("dbus-launch", args);
}
/* dbus-launch failed - run e direct */
i = valgrind_append(args, valgrind_mode, valgrind_tool, valgrind_path, valgrind_log);
args[i++] = buf;
copy_args(args + i, argv + 1, argc - 1);
args[i + argc - 1] = NULL;
execv(args[0], args);
printf("FAILED TO RUN:\n");
printf(" %s\n", buf);
perror("execv");
return -1;
}
void
SetupPreCache(void)
{
if (PreCaching)
{
precache();
PreCacheSoundList(Player_SCTable, SIZ(Player_SCTable));
// actors cache ranges are called from SpriteSetup
// only caches the actor if its on the level
// weapons
PreCacheRange(2000, 2227);
PreCacheRange(4090, 4093);
// Explosions
PreCacheRange(3072, 3225);
// ninja player character
PreCacheRange(1024, 1175);
// console
PreCacheRange(2380, 2409);
PreCacheRange(3600, 3645);
PreCacheRange(2434, 2435);
// common
PreCacheRange(204, 208);
// message font
PreCacheRange(4608, 4701);
// gibs
PreCacheRange(1150,1568);
PreCacheRange(1685,1690);
PreCacheRange(900,944);
PreCacheRange(1670,1681);
// blood
PreCacheRange(1710,1715 );
PreCacheRange(2410,2425);
PreCacheRange(389,389); // blood puddle by itself in art file
PreCacheRange(2500,2503);
// shrap
PreCacheRange(3840,3911);
PreCacheRange(3924,3947);
PreCacheRange(1397,1398);
// water *** animated tiles, can be deleted now ***
// PreCacheRange(780,794);
// switches
PreCacheRange(561,584);
PreCacheRange(551,552);
PreCacheRange(1846,1847);
PreCacheRange(1850,1859);
// bullet smoke
PreCacheRange(1748,1753);
// small blue font
PreCacheRange(2930,3023);
// gas can
PreCacheRange(3038,3042);
// lava *** animated tiles, can be deleted now ***
// PreCacheRange(175,182);
// gas clouds & teleport effect
PreCacheRange(3240,3277);
// nuke mushroom cloud
PreCacheRange(3280,3300);
// blood drops
PreCacheRange(1718,1721);
// smoke
PreCacheRange(3948,3968);
// footprints
PreCacheRange(2490,2492);
// player fists
PreCacheRange(4070,4077);
PreCacheRange(4050,4051);
PreCacheRange(4090,4093);
// fish actor
PreCacheRange(3760,3771);
PreCacheRange(3780,3795);
// coins
PreCacheRange(2531,2533);
// respawn markers & console keys
PreCacheRange(2440,2467);
// light/torch sprites
PreCacheRange(537,548);
PreCacheRange(521,528);
PreCacheRange(512,515);
PreCacheRange(396,399);
PreCacheRange(443,446);
// bubbles
PreCacheRange(716,720);
// bullet splashes
PreCacheRange(772,776);
}
}
MetricNumType Metric_AMD_perfmon::numType() {
if (!m_precached) precache();
return m_nType;
}
std::string Metric_AMD_perfmon::name() {
if (!m_precached) precache();
return m_name;
}
