FileInformation::FileInformation (SignalServer* signalServer, const QString &FileName_, activefilters ActiveFilters_, activealltracks ActiveAllTracks_,
int FrameCount) :
FileName(FileName_),
ActiveFilters(ActiveFilters_),
ActiveAllTracks(ActiveAllTracks_),
signalServer(signalServer),
m_jobType(Parsing),
streamsStats(NULL),
formatStats(NULL),
m_parsed(false),
m_autoCheckFileUploaded(true),
m_autoUpload(true),
m_hasStats(false),
m_commentsUpdated(false)
{
static struct RegisterMetatypes {
RegisterMetatypes() {
qRegisterMetaType<SharedFile>("SharedFile");
}
} registerMetatypes;
connect(this, SIGNAL(parsingCompleted(bool)), this, SLOT(parsingDone(bool)));
QString StatsFromExternalData_FileName;
bool StatsFromExternalData_FileName_IsCompressed=false;
// Finding the right file names (both media file and stats file)
static const QString dotQctoolsDotXmlDotGz = ".qctools.xml.gz";
static const QString dotQctoolsDotXml = ".qctools.xml";
static const QString dotXmlDotGz = ".xml.gz";
static const QString dotQctoolsDotMkv = ".qctools.mkv";
QByteArray attachment;
if (FileName.endsWith(dotQctoolsDotXmlDotGz))
{
StatsFromExternalData_FileName=FileName;
FileName.resize(FileName.length() - dotQctoolsDotXmlDotGz.length());
StatsFromExternalData_FileName_IsCompressed=true;
}
else if (FileName.endsWith(dotQctoolsDotXml))
{
StatsFromExternalData_FileName=FileName;
FileName.resize(FileName.length() - dotQctoolsDotXml.length());
}
else if (FileName.endsWith(dotXmlDotGz))
{
StatsFromExternalData_FileName=FileName;
FileName.resize(FileName.length() - dotXmlDotGz.length());
StatsFromExternalData_FileName_IsCompressed=true;
}
else if (FileName.endsWith(dotQctoolsDotMkv))
{
attachment = FFmpeg_Glue::getAttachment(FileName, StatsFromExternalData_FileName);
FileName.resize(FileName.length() - dotQctoolsDotMkv.length());
if(!QFile::exists(FileName)) {
FileName = FileName + dotQctoolsDotMkv;
}
}
if (StatsFromExternalData_FileName.size()==0)
{
if (QFile::exists(FileName + dotQctoolsDotXmlDotGz))
{
StatsFromExternalData_FileName=FileName + dotQctoolsDotXmlDotGz;
StatsFromExternalData_FileName_IsCompressed=true;
}
else if (QFile::exists(FileName + dotQctoolsDotXml))
{
StatsFromExternalData_FileName=FileName + dotQctoolsDotXml;
}
else if (QFile::exists(FileName + dotXmlDotGz))
{
StatsFromExternalData_FileName=FileName + dotXmlDotGz;
StatsFromExternalData_FileName_IsCompressed=true;
}
else if (QFile::exists(FileName + dotQctoolsDotMkv))
{
attachment = FFmpeg_Glue::getAttachment(FileName + dotQctoolsDotMkv, StatsFromExternalData_FileName);
}
}
QString shortFileName;
std::unique_ptr<QIODevice> StatsFromExternalData_File;
if(attachment.isEmpty()) {
QFileInfo fileInfo(StatsFromExternalData_FileName);
shortFileName = fileInfo.fileName();
StatsFromExternalData_File.reset(new QFile(StatsFromExternalData_FileName));
} else {
shortFileName = StatsFromExternalData_FileName;
StatsFromExternalData_File.reset(new QBuffer(&attachment));
StatsFromExternalData_FileName_IsCompressed = true;
}
// External data optional input
bool StatsFromExternalData_IsOpen=StatsFromExternalData_File->open(QIODevice::ReadOnly);
// Running FFmpeg
string FileName_string=FileName.toUtf8().data();
#ifdef _WIN32
replace(FileName_string.begin(), FileName_string.end(), '/', '\\' );
#endif
string Filters[Type_Max];
if (!StatsFromExternalData_IsOpen)
{
if (ActiveFilters[ActiveFilter_Video_signalstats])
Filters[0]+=",signalstats=stat=tout+vrep+brng";
if (ActiveFilters[ActiveFilter_Video_cropdetect])
Filters[0]+=",cropdetect=reset=1:round=1";
if (ActiveFilters[ActiveFilter_Video_Idet])
Filters[0]+=",idet=half_life=1";
if (ActiveFilters[ActiveFilter_Video_Deflicker])
Filters[0]+=",deflicker=bypass=1";
if (ActiveFilters[ActiveFilter_Video_Entropy])
Filters[0]+=",entropy=mode=normal";
if (ActiveFilters[ActiveFilter_Video_EntropyDiff])
Filters[0]+=",entropy=mode=diff";
if (ActiveFilters[ActiveFilter_Video_Psnr] && ActiveFilters[ActiveFilter_Video_Ssim])
{
Filters[0]+=",split[a][b];[a]field=top[a1];[b]field=bottom,split[b1][b2];[a1][b1]psnr[c1];[c1][b2]ssim";
}
else
{
if (ActiveFilters[ActiveFilter_Video_Psnr])
Filters[0]+=",split[a][b];[a]field=top[a1];[b]field=bottom[b1];[a1][b1]psnr";
if (ActiveFilters[ActiveFilter_Video_Ssim])
Filters[0]+=",split[a][b];[a]field=top[a1];[b]field=bottom[b1];[a1][b1]ssim";
}
Filters[0].erase(0, 1); // remove first comma
if (ActiveFilters[ActiveFilter_Audio_astats])
Filters[1]+=",astats=metadata=1:reset=1:length=0.4";
if (ActiveFilters[ActiveFilter_Audio_aphasemeter])
Filters[1]+=",aphasemeter=video=0";
if (ActiveFilters[ActiveFilter_Audio_EbuR128])
Filters[1]+=",ebur128=metadata=1";
Filters[1].erase(0, 1); // remove first comma
}
else
{
readStats(*StatsFromExternalData_File, StatsFromExternalData_FileName_IsCompressed);
if(signalServer->enabled() && m_autoCheckFileUploaded)
{
checkFileUploaded(shortFileName);
}
}
std::string fileName = FileName_string;
if(fileName == "-")
fileName = "pipe:0";
Glue=new FFmpeg_Glue(fileName, ActiveAllTracks, &Stats, &streamsStats, &formatStats, Stats.empty());
if (!FileName_string.empty() && Glue->ContainerFormat_Get().empty())
{
delete Glue;
Glue=NULL;
for (size_t Pos=0; Pos<Stats.size(); Pos++)
Stats[Pos]->StatsFinish();
}
if (Glue)
{
Glue->AddOutput(0, 72, 72, FFmpeg_Glue::Output_Jpeg);
Glue->AddOutput(1, 0, 0, FFmpeg_Glue::Output_Stats, 0, Filters[0]);
Glue->AddOutput(0, 0, 0, FFmpeg_Glue::Output_Stats, 1, Filters[1]);
}
// Looking for the reference stream (video or audio)
ReferenceStream_Pos=0;
for (; ReferenceStream_Pos<Stats.size(); ReferenceStream_Pos++)
if (Stats[ReferenceStream_Pos] && Stats[ReferenceStream_Pos]->Type_Get()==0)
break;
if (ReferenceStream_Pos>=Stats.size())
{
ReferenceStream_Pos = 0;
for (; ReferenceStream_Pos<Stats.size(); ReferenceStream_Pos++)
if (Stats[ReferenceStream_Pos] && Stats[ReferenceStream_Pos]->Type_Get()==1) //Audio
break;
if (ReferenceStream_Pos>=Stats.size())
Stats.clear(); //Removing all, as we can not sync with video or audio
}
Frames_Pos=0;
WantToStop=false;
startParse();
}
// This function needs to be re-entrant, it can be called recursively from inside of resolveAll
// to load files that the first file depends on.
daeInt daeLIBXMLPlugin::read(daeURI& uri, daeString docBuffer)
{
// Make sure topMeta has been set before proceeding
if (topMeta == NULL)
{
return DAE_ERR_BACKEND_IO;
}
// Generate a version of the URI with the fragment removed
daeURI fileURI(uri.getURI(),true);
// Create the right type of xmlTextReader on the stack so this function can be re-entrant
xmlTextReaderPtr reader;
if(docBuffer)
{
// Load from memory (experimental)
#if 0 //debug stuff
printf("Reading %s from memory buffer\n", fileURI.getURI());
#endif
reader = xmlReaderForDoc((xmlChar*)docBuffer, fileURI.getURI(), NULL,0);
}
else
{
// Load from URI
#if 0 //debug stuff
printf("Opening %s\n", fileURI.getURI());
#endif
reader = xmlReaderForFile(fileURI.getURI(), NULL,0);
}
if(!reader)
{
printf( "no libxml2 reader\n");
return DAE_ERR_BACKEND_IO;
}
// Start parsing the file
daeElementRef domObject = startParse(topMeta, reader);
// Parsing done, free the xmlReader and error check to make sure we got a valid DOM back
xmlFreeTextReader(reader);
if (!domObject)
{
#if defined(_DEBUG) && defined(WIN32)
fprintf(stderr,"daeLIBXMLPlugin::read(%s) failed - XML Parse Failed\n",
fileURI.getFile());
fflush(stdout);
#endif
printf("not able to load\n");
return DAE_ERR_BACKEND_IO;
}
// Insert the document into the database, the Database will keep a ref on the main dom, so it won't gets deleted
// until we clear the database
daeDocument *document = NULL;
int res = database->insertDocument(fileURI.getURI(),domObject,&document);
if (res!= DAE_OK)
return res;
// Make a vector to store a list of the integration items that need to be processed later
// postProcessDom will fill this in for us (this should probably not be done in the IOPlugin)
std::vector<INTEGRATION_ITEM> intItems;
//insert the elements into the database, for this DB the elements are the Collada object which have
//an ID.
//this function will fill the _integrationItems array as well
postProcessDom(document, domObject, intItems);
database->validate();
daeElement::resolveAll();
//create the integration objects
int size = (int)intItems.size();
int i;
for (i=0;i<size;i++)
intItems[i].intObject->createFromChecked(intItems[i].element);
for (i=0;i<size;i++)
intItems[i].intObject->fromCOLLADAChecked();
for (i=0;i<size;i++)
intItems[i].intObject->fromCOLLADAPostProcessChecked();
//clear the temporary integration items array
intItems.clear();
return DAE_OK;
}
int rdbParse(char *rdbFile, keyValueHandler handler) {
int type, loops = 0, dbid, valType;
unsigned int rlen;
char buf[1024];
time_t expiretime = -1;
FILE *fp;
sds key, sval; /* sval is simple string value.*/
sds *cval; /*complicatae value*/
/* Double constants initialization */
R_Zero = 0.0;
R_PosInf = 1.0/R_Zero;
R_NegInf = -1.0/R_Zero;
R_Nan = R_Zero/R_Zero;
if((fp = fopen(rdbFile, "r")) == NULL) {
return PARSE_ERR;
}
if (freadCheck(buf, 9, 1, fp) == 0) {
fclose(fp);
fprintf(stderr, "fread err :%s\n", strerror(errno));
return PARSE_ERR;
}
buf[9] = '\0';
if (memcmp(buf, "REDIS", 5) != 0) {
fclose(fp);
fprintf(stderr, "Wrong signature trying to load DB from file\n");
return PARSE_ERR;
}
rdb_version = atoi(buf+5);
if (rdb_version > 6) {
fclose(fp);
fprintf(stderr, "Can't handle RDB format version %d\n", rdb_version);
return PARSE_ERR;
}
startParse(fp);
while(1) {
if(!(loops++ % 1000)) {
/* record parse progress every 1000 loops. */
parseProgress(ftello(fp));
}
if((type = rdbLoadType(fp)) == -1) return PARSE_ERR;
if(type == REDIS_EXPIRETIME) {
if ((expiretime = rdbLoadTime(fp)) == -1) return PARSE_ERR;
if((type = rdbLoadType(fp)) == -1) return PARSE_ERR;
}
/* file end. */
if(type == REDIS_EOF) {
break;
}
/* select db */
if(type == REDIS_SELECTDB) {
dbid = rdbLoadLen(fp,NULL);
continue;
}
/* load key. */
if ((key = rdbLoadStringObject(fp)) == NULL) {
return PARSE_ERR;
}
if(type == REDIS_HASH_ZIPMAP) {
valType = REDIS_HASH;
} else if(type == REDIS_LIST_ZIPLIST) {
valType = REDIS_LIST;
} else if(type == REDIS_SET_INTSET) {
valType = REDIS_SET;
} else if(type == REDIS_ZSET_ZIPLIST) {
valType = REDIS_ZSET;
} else {
valType = type;
}
/* load value. */
if(type == REDIS_STRING) {
sval = rdbLoadValueObject(fp, type, &rlen);
handler(valType, key, sval, rlen, expiretime);
} else {
cval = rdbLoadValueObject(fp, type, &rlen);
handler(valType, key, cval, rlen, expiretime);
}
/* clean*/
sdsfree(key);
if(valType == REDIS_STRING) {
sdsfree(sval);
} else {
unsigned int k;
for(k = 0; k < rlen; k++) {
sdsfree(cval[k]);
}
zfree(cval);
}
}
/* checksum */
uint64_t checksum = 0;
int ret;
ret = fread(&checksum, sizeof(checksum), 1, fp);
if (ret == 1) {
if ((long long)checksum != digest) {
fprintf(stderr, "DB load failed, checksum does not match: %016llx != %016llx\n", (long long)checksum, digest);
exit(1);
}
fprintf(stderr, "DB loaded, checksum: %016llx\n", digest);
}
parser_stats.stop_time = time(NULL);
fclose(fp);
return PARSE_OK;
}
