Пример #1
0
Result SoundSourceCoreAudio::parseHeader() {
    if (getFilename().endsWith(".m4a")) {
        setType("m4a");
        TagLib::MP4::File f(getFilename().toLocal8Bit().constData());
        if (!readFileHeader(this, f)) {
            return ERR;
        }
        TagLib::MP4::Tag *mp4(f.tag());
        if (mp4) {
            readMP4Tag(this, *mp4);
        } else {
            // fallback
            const TagLib::Tag *tag(f.tag());
            if (tag) {
                readTag(this, *tag);
            } else {
                return ERR;
            }
        }
    } else if (getFilename().endsWith(".mp3")) {
        setType("mp3");
        TagLib::MPEG::File f(getFilename().toLocal8Bit().constData());
        if (!readFileHeader(this, f)) {
            return ERR;
        }
        TagLib::ID3v2::Tag* id3v2 = f.ID3v2Tag();
        if (id3v2) {
            readID3v2Tag(this, *id3v2);
        } else {
            TagLib::APE::Tag *ape = f.APETag();
            if (ape) {
                readAPETag(this, *ape);
            } else {
                // fallback
                const TagLib::Tag *tag(f.tag());
                if (tag) {
                    readTag(this, *tag);
                } else {
                    return ERR;
                }
            }
        }
    } else if (getFilename().endsWith(".mp2")) {
        setType("mp2");
        //TODO: MP2 metadata. Does anyone use mp2 files anymore?
        //      Feels like 1995 again...
        return ERR;
    }

    return OK;
}
Пример #2
0
int PackVmlinuzI386::canUnpack()
{
    if (readFileHeader() != getFormat())
        return false;
    fi->seek(setup_size, SEEK_SET);
    return readPackHeader(1024) ? 1 : -1;
}
Пример #3
0
BMP readBMP(FILE* source, int* error) {
	BMP bmp;
	bmp.fileHeader = readFileHeader(source);

	if (bmp.fileHeader.type != 0x4d42) {
		*error = CABEZERA_INCORRECTA;
		return bmp;
	}

	fread(&bmp.size, sizeof(bmp.size), 1, source);
	fread(&bmp.width, sizeof(bmp.width), 1, source);
	fread(&bmp.height, sizeof(bmp.height), 1, source);
	fread(&bmp.planes, sizeof(bmp.planes), 1, source);
	fread(&bmp.bits, sizeof(bmp.bits), 1, source);
	fread(&bmp.compression, sizeof(bmp.compression), 1, source);
	fread(&bmp.imagesize, sizeof(bmp.imagesize), 1, source);
	fread(&bmp.xresolution, sizeof(bmp.xresolution), 1, source);
	fread(&bmp.yresolution, sizeof(bmp.yresolution), 1, source);
	fread(&bmp.ncolours, sizeof(bmp.ncolours), 1, source);
	fread(&bmp.importantcolours, sizeof(bmp.importantcolours), 1, source);

	bmp.memory = malloc(bmp.imagesize);
	fread(bmp.memory, 1, bmp.imagesize, source);

	return bmp;
}
Пример #4
0
int PackTmt::canUnpack()
{
    if (!readFileHeader())
        return false;
    fi->seek(adam_offset, SEEK_SET);
    return readPackHeader(512) ? 1 : -1;
}
	void LodConfigSerializer::importLodConfig(Ogre::LodConfig* config, DataStreamPtr& stream)
	{
		mStream = stream;
		mLodConfig = config;

		// Determine endianness (must be the first thing we do!)
		determineEndianness(mStream);

		// Check header
		readFileHeader(mStream);

		pushInnerChunk(mStream);
		while (!mStream->eof())
		{
			unsigned short streamID = readChunk(mStream);
			switch (streamID)
			{
			case LCCID_LOD_CONFIG:
				readLodConfig();
				break;
			default:
				backpedalChunkHeader(mStream);
				popInnerChunk(mStream);
				return;
			}
		}
		popInnerChunk(mStream);
	}
    //---------------------------------------------------------------------
    void SkeletonSerializer::importSkeleton(DataStreamPtr& stream, Skeleton* pSkel)
    {
		// Determine endianness (must be the first thing we do!)
		determineEndianness(stream);

		// Check header
        readFileHeader(stream);

        unsigned short streamID;
        while(!stream->eof())
        {
            streamID = readChunk(stream);
            switch (streamID)
            {
            case SKELETON_BONE:
                readBone(stream, pSkel);
                break;
            case SKELETON_BONE_PARENT:
                readBoneParent(stream, pSkel);
                break;
            case SKELETON_ANIMATION:
                readAnimation(stream, pSkel);
				break;
			case SKELETON_ANIMATION_LINK:
				readSkeletonAnimationLink(stream, pSkel);
				break;
            }
        }

        // Assume bones are stored in the binding pose
        pSkel->setBindingPose();


    }
Пример #7
0
YUV::YUV(char *filename) {

	if (readFileHeader(filename))
		throw new std::runtime_error("Unable to read file header!");

	init();
}
Пример #8
0
void PackTos::fileInfo()
{
    if (!readFileHeader())
        return;
    con_fprintf(stdout, "    text: %d, data: %d, sym: %d, bss: %d, flags=0x%x\n",
                (int)ih.fh_text, (int)ih.fh_data, (int)ih.fh_sym, (int)ih.fh_bss, (int)ih.fh_flag);
}
Пример #9
0
bool PackArmPe::canPack()
{
    if (!readFileHeader() || (ih.cpu != 0x1c0 && ih.cpu != 0x1c2))
        return false;
    use_thumb_stub |= ih.cpu == 0x1c2 || (ih.entry & 1) == 1;
    use_thumb_stub |= (opt->cpu == opt->CPU_8086); // FIXME
    return true;
}
Пример #10
0
void Application::paramChange(void *)
{
    //fprintf(stderr,"param change\n");
    int i;
    char msg[200];

    // clear data
    delete_data();

    // read data file name parameter
    if (!getFilename())
        return;

    // open the file
    if (!openFile())
        return;

    // read the file header
    if (!readFileHeader(fp, Title, &nVars, VarNames))
    {
        fclose(fp);
        return;
    }
    fclose(fp);
    sprintf(msg, "TITLE: \"%s\"", Title);
    Covise::sendInfo(msg);
    sprintf(msg, "%i VARIABLES", nVars);
    Covise::sendInfo(msg);

    // copy variable names to choice param
    //  Covise::update_choice_param ("datax", nVars+1, VarNames, 1);
    strcpy(msg, "(none)");
    if (nVars >= MAX_N_VARS)
    {
        Covise::sendError("Limit of maximum number of variables exceeded in ReadFlower");
        return;
    }
    for (i = 1; i < nVars + 1; i++)
    {
        strcat(msg, " ");
        strcat(msg, VarNames[i]);
    }
    if (!Covise::update_string_param("allVars", msg))
    {
        Covise::sendError("error at call 'update_string_param ()' in function 'paramChange'.");
        return;
    }

    strcpy(msg, VarNames[1]);
    for (i = 2; i < 4; i++)
    {
        strcat(msg, "/");
        strcat(msg, VarNames[i]);
    }
    Covise::update_string_param("gridselect", msg);

    preInitOK = TRUE;
}
Пример #11
0
IMAGE* readRGB(char *fileName, bool printInfo) {
    if(printInfo) printf("Reading File...\n");
    FileHeader fileHeader;
    BMPHeader bmpHeader;

    FILE *fhandle = fopen(fileName,"rb");
    readFileHeader(fhandle, &fileHeader, printInfo);
    readDataHeader(fhandle, &bmpHeader, printInfo);
    IMAGE *image = readRaster(fhandle, &fileHeader, &bmpHeader, printInfo);
    fclose(fhandle);

    return image;
}
Пример #12
0
/** Read image in @e filename into memory.
 * 
 * @throw ImageException from open()
 * @throw ImageException from readFileHeader()
 * @throw ImageException from readInfoHeader()
 * @throw ImageException from readPixels()
 * 
 * @see getFormat()
 * @see getPixels()
 * @see getSize()
 * @see getWidth()
 * @see getHeight()
 */
void BmpImageReader::read(const string &filename) {
	
	try {
		open(filename);
		readFileHeader();
		readInfoHeader();
		readPixels();
		close();
	} catch (BasicException &e) {
		close();
		throw e;
	}
}
void ImportAnnotationsFromCSVDialog::preview(bool silent) {
    QString fileName = checkInputGroup(silent);
    if (fileName.isEmpty()) {
        return;
    }
    QString text = readFileHeader(fileName, silent);

    previewTable->clear();
    rawPreview->clear();

    rawPreview->setPlainText(text);

    if (!checkSeparators(true)) {
        return;
    }
    CSVParsingConfig parseOptions;
    toParsingConfig(parseOptions);
    if (parseOptions.splitToken.isEmpty() && parseOptions.parsingScript.isEmpty()) {
        return;
    }


    int columnCount = 0;
    TaskStateInfo ti;
    QList<QStringList> lines = ReadCSVAsAnnotationsTask::parseLinesIntoTokens(text, parseOptions, columnCount, ti);
    if (ti.hasError()) {
        QMessageBox::critical(this, L10N::errorTitle(), ti.getError());
        return;
    }
    prepareColumnsConfig(columnCount);
    columnCount = qMax(columnCount, columnsConfig.size());

    previewTable->setRowCount(lines.size());
    previewTable->setColumnCount(columnCount);

    for (int column = 0; column < columnCount; column++) {
        QTableWidgetItem* headerItem = createHeaderItem(column);
        previewTable->setHorizontalHeaderItem(column, headerItem);
    }
    for (int row = 0; row < lines.size(); row++) {
        const QStringList& rowData = lines.at(row);
        for (int column = 0; column < rowData.size(); column ++) {
            QString token = rowData.at(column);
            QTableWidgetItem* item = new QTableWidgetItem(token);
            item->setFlags(Qt::ItemIsEnabled);
            previewTable->setItem(row, column, item);
        }
    }
}
Пример #14
0
int PackTos::canUnpack()
{
    if (!readFileHeader())
        return false;
    if (!readPackHeader(768))
        return false;
    // check header as set by packer
    if ((ih.fh_text & 3) != 0 || (ih.fh_data & 3) != 0 || (ih.fh_bss & 3) != 0
        || ih.fh_sym != 0 || ih.fh_reserved != 0 || ih.fh_reloc > 1)
        throwCantUnpack("program header damaged");
    // generic check
    if (!checkFileHeader())
        throwCantUnpack("unsupported header flags");
    return true;
}
Пример #15
0
bool PackTos::canPack()
{
    if (!readFileHeader())
        return false;

    unsigned char buf[768];
    fi->readx(buf, sizeof(buf));
    checkAlreadyPacked(buf, sizeof(buf));

    if (!checkFileHeader())
        throwCantPack("unsupported header flags");
    if (file_size < 1024)
        throwCantPack("program is too small");

    return true;
}
Пример #16
0
IMAGE* readGrey(char *fileName, bool printInfo) {
    if(printInfo) printf("Reading File...\n");
    FileHeader fileHeader;
    BMPHeader bmpHeader;

    FILE *fhandle = fopen(fileName,"rb");
    readFileHeader(fhandle, &fileHeader, printInfo);
    readDataHeader(fhandle, &bmpHeader, printInfo);

    IMAGE *image;
    if(bmpHeader.bitCount == 8) image = readRaster(fhandle, &fileHeader, &bmpHeader, printInfo);
    else image = readLuminance(fhandle, &fileHeader, &bmpHeader, printInfo);
    fclose(fhandle);

    return image;
}
Пример #17
0
    //---------------------------------------------------------------------
    void SkeletonSerializer::importSkeleton(DataStreamPtr& stream, Skeleton* pSkel)
    {
        // Determine endianness (must be the first thing we do!)
        determineEndianness(stream);

        // Check header
        readFileHeader(stream);
        pushInnerChunk(stream);
        unsigned short streamID = readChunk(stream);

        while(!stream->eof())
        {
            switch (streamID)
            {
            case SKELETON_BLENDMODE:
            {
                // Optional blend mode
                uint16 blendMode;
                readShorts(stream, &blendMode, 1);
                pSkel->setBlendMode(static_cast<SkeletonAnimationBlendMode>(blendMode));
                break;
            }
            case SKELETON_BONE:
                readBone(stream, pSkel);
                break;
            case SKELETON_BONE_PARENT:
                readBoneParent(stream, pSkel);
                break;
            case SKELETON_ANIMATION:
                readAnimation(stream, pSkel);
                break;
            case SKELETON_ANIMATION_LINK:
                readSkeletonAnimationLink(stream, pSkel);
                break;
            default:
                break;
            }

            streamID = readChunk(stream);
        }
        // Assume bones are stored in the binding pose
        pSkel->setBindingPose();
        popInnerChunk(stream);

    }
void ImportAnnotationsFromCSVDialog::guessSeparator(bool silent) {
    QString url = checkInputGroup(silent);
    if (url.isEmpty()) {
        return;
    }
    QString text = readFileHeader(url, silent);
    CSVParsingConfig config;
    toParsingConfig(config);
    QString sep = ReadCSVAsAnnotationsTask::guessSeparatorString(text, config);
    if (sep.isEmpty()) {
        if (!silent) {
            QMessageBox::critical(this, L10N::errorTitle(), tr("Failed to guess separator sequence!"));
            readFileName->setFocus();
        }
        return;
    }
    separatorEdit->setText(sep);
    preview(silent);
}
Пример #19
0
int main(int argc, char *argv[])
{
	FILE * fin = NULL;
	FILE * fout = NULL;
	char ltr[MAX];
	char lineOne[MAX];
	char lineTwo[MAX];
	char outputName[MAX];
	int  edgeWidth, centerRow, centerColumn, radius;
	int ** imageNumbers = NULL;
	int rows, columns, intensity;
	int i;

	fin = openFile(argc, argv, ltr, &edgeWidth, &centerRow, &centerColumn, &radius, outputName);
	fout = fopen(outputName, "w");

	readFileHeader(fin, &rows, &columns, &intensity, lineOne, lineTwo);

	imageNumbers = (int**) malloc(rows * sizeof(int*));
    for(i = 0; i < rows; i++)
		imageNumbers[i] = (int*)malloc(columns * sizeof(int));

	fill2DArray(imageNumbers, rows, columns, fin);

	if(strcmp(ltr, "-e") == 0)
        createBorder(imageNumbers, rows, columns, edgeWidth);
    else
        createCircle(imageNumbers, centerRow, centerColumn, radius, rows, columns);

    intensity = findMax2DArray(imageNumbers,rows,columns);
    printArray2DToFile(imageNumbers, rows, columns, fout, lineOne, outputName, intensity);

    cleanUp(imageNumbers,rows);

	if(fin != NULL)
        fclose(fin);
	if(fout != NULL)
        fclose(fout);

	return 0;
}
Пример #20
0
/*------------------------------------------------------------------------------------------------------------
 * ビットマップファイルを読み込む
 *
 * path: 読み込むビットマップファイル
 */
void Bitmap::readFile(const char *path)
{
    FILE *ifp = fopen(path, "rb");
    
    if (ifp == 0) {
        perror("fopen");
        fprintf(stderr, "file: %s\n", path);
        throw MyError("bitmap file open failed", __FUNCTION__);
    }
    
    int error;
    error = readFileHeader(ifp);
    if (error > 0) {
        throw MyError("failed to read bitmap file header", __FUNCTION__);
    }
    
    error = readInfoHeader(ifp);
    if (error > 0) {
        throw MyError("failed to read bitmap info header", __FUNCTION__);
    }
    
    mDataSize = mFileHeader.bfSize - mInfoHeader.biSize - sizeof(mFileHeader);
    if (mDataSize != 0) {
        delete [] mData;
    }
    mData = new unsigned char[mDataSize];
    
    error = readBitmapData(ifp);
    if (error > 0) {
        throw MyError("failed toread bitmap data", __FUNCTION__);
    }
    
    
    mWidth = mInfoHeader.biWidth;
    mHeight = mInfoHeader.biHeight;
    
    fclose(ifp);
}
Пример #21
0
/*
   Parse the the file to get metadata
 */
Result SoundSourceOggVorbis::parseHeader() {
    QByteArray qBAFilename = getFilename().toLocal8Bit();
    TagLib::Ogg::Vorbis::File f(qBAFilename.constData());

    if (!readFileHeader(this, f)) {
        return ERR;
    }

    TagLib::Ogg::XiphComment *xiph = f.tag();
    if (xiph) {
        readXiphComment(this, *xiph);
    } else {
        // fallback
        const TagLib::Tag *tag(f.tag());
        if (tag) {
            readTag(this, *tag);
        } else {
            return ERR;
        }
    }

    return OK;
}
Пример #22
0
void OgreMeshDeserializer::deserialize()
{

    // Determine endianness (must be the first thing we do!)
    determineEndianness(m_stream);

    // Check header
    readFileHeader(m_stream);

    unsigned short streamID = readChunk(m_stream);

    while (!m_stream.eof()) {
        switch (streamID) {
            case M_MESH:
                readMesh();
                break;
            default:
                skipChunk(m_stream);
        }

        streamID = readChunk(m_stream);
    }

}
Пример #23
0
int
MidiFile::read(const char *fileName) {
	if (fileName == NULL)
		return 1;
	
	setFileName(fileName);
	_target = openFile(fileName);
	
	if (!_target)
		return 1;

	readFileHeader();
	setType();
	setTrackCount();
	setBPM();
	for (int i = 0; i < _fileHeader._tracks; i++) {
		_curTrack = i;
		readTrack();
		printContour();
	}

	fclose(_target);
   	return 0;
}		
Пример #24
0
bool PackVmlinuzI386::canPack()
{
    return readFileHeader() == getFormat();
}
Пример #25
0
/*********************************************************************
功能:载入文件到数据集中,并保存传入文件名记录为当前文件名
参数:filename,文件名
返回:>0,成功,记录数;<0,失败
作者:叶文林	2012-08-22
*********************************************************************/
int CFixedLenRecordFile::load(const char * filename)
{
	if (filename == NULL)	return -1;

	m_pCritical->enter(); //进临界区

	int ret1 = 0;
	DWORD count = 0;
	DWORD readlen = 0;
	int len = 0;

	//保存文件名
	saveFileName(filename);

	//打开文件
	int res = -1;
	FILE * f = fopen(filename,"rb");
	if (f == NULL)	goto LAB_END_ERR_LOADFILE;

	//读文件头
    res = -2;
	TFileHeaderFixedLenRecord fileHeader;
	ret1 = readFileHeader(&fileHeader,f);
	if (ret1 <= 0)	goto LAB_END_ERR_LOADFILE;

	//读文件体
    res = -3;
	count   = (fileHeader.recoredCount < m_maxRecCount) ? fileHeader.recoredCount : m_maxRecCount; //可读取记录数
	fileHeader.recoredCount = count;
	readlen = fileHeader.perRecLen * count;
	
	if (m_pBody != NULL)	delete [] m_pBody;
	m_recCountForBodyMem = (count + m_reservedRecCountForBody < m_maxRecCount) ? count + m_reservedRecCountForBody : m_maxRecCount; //实际为文件body区分配内存
	m_pBody = NULL;
	m_pBody = new BYTE [m_recCountForBodyMem * fileHeader.perRecLen];

	len = fread(m_pBody,1,readlen,f);

	if (len <readlen)	goto LAB_END_ERR_READBODY;

	//关闭文件
	fclose(f);

	//保存文件头
	memcpy(&m_header,&fileHeader,sizeof(TFileHeaderFixedLenRecord));

	//给索引指针重赋值
	resetRecList();

	res = fileHeader.recoredCount;
	goto LAB_END;

LAB_END_ERR_READBODY:                                                //分配文件体空间后,读取出错
	delete [] m_pBody;
	m_pBody = NULL;

LAB_END_ERR_LOADFILE:                                                //未能成功载入文件
	if (f != NULL)	fclose(f);                                       //关闭文件
	//分配空间(只分配最小预留内存)
	if (m_pBody == NULL)
	{
		initEmpFileHeader();
		m_recCountForBodyMem = m_reservedRecCountForBody;
		if (m_recCountForBodyMem>0)
		{
			
			m_pBody = new BYTE [m_recCountForBodyMem * m_header.perRecLen];
			WLOutDebug(">> m_pBody = %.8X,len = %d",m_pBody,m_recCountForBodyMem * m_header.perRecLen);
		}
	}

LAB_END:                                                             //完成
	m_pCritical->leave(); //出临界区

	return res;
}
Пример #26
0
int PackArmPe::canUnpack()
{
    if (!readFileHeader() || (ih.cpu != 0x1c0 && ih.cpu != 0x1c2))
        return false;

    unsigned objs = ih.objects;
    isection = new pe_section_t[objs];
    fi->seek(pe_offset+sizeof(ih),SEEK_SET);
    fi->readx(isection,sizeof(pe_section_t)*objs);
    if (ih.objects < 3)
        return -1;
    bool is_packed = ((ih.objects == 3 || ih.objects == 4) &&
                      (IDSIZE(15) || ih.entry > isection[1].vaddr));
    bool found_ph = false;
    if (memcmp(isection[0].name,"UPX",3) == 0)
    {
        // current version
        fi->seek(isection[1].rawdataptr - 64, SEEK_SET);
        found_ph = readPackHeader(1024);
        if (!found_ph)
        {
            // old versions
            fi->seek(isection[2].rawdataptr, SEEK_SET);
            found_ph = readPackHeader(1024);
        }
    }
    if (is_packed && found_ph)
        return true;
    if (!is_packed && !found_ph)
        return -1;
    if (is_packed && ih.entry < isection[2].vaddr)
    {
        unsigned char buf[256];
        bool x = false;

        memset(buf, 0, sizeof(buf));
        try {
            fi->seek(ih.entry - isection[1].vaddr + isection[1].rawdataptr, SEEK_SET);
            fi->read(buf, sizeof(buf));

            // FIXME this is for x86
            static const unsigned char magic[] = "\x8b\x1e\x83\xee\xfc\x11\xdb";
            // mov ebx, [esi];    sub esi, -4;    adc ebx,ebx

            int offset = find(buf, sizeof(buf), magic, 7);
            if (offset >= 0 && find(buf + offset + 1, sizeof(buf) - offset - 1, magic, 7) >= 0)
                x = true;
        } catch (...) {
            //x = true;
        }
        if (x)
            throwCantUnpack("file is modified/hacked/protected; take care!!!");
        else
            throwCantUnpack("file is possibly modified/hacked/protected; take care!");
        return false;   // not reached
    }

    // FIXME: what should we say here ?
    //throwCantUnpack("file is possibly modified/hacked/protected; take care!");
    return false;
}
Пример #27
0
Result SoundSourceSndFile::parseHeader()
{
    QString location = getFilename();
    setType(location.section(".",-1).toLower());

    bool is_flac = location.endsWith("flac", Qt::CaseInsensitive);
    bool is_wav = location.endsWith("wav", Qt::CaseInsensitive);
    QByteArray qBAFilename = getFilename().toLocal8Bit();

    if (is_flac) {
        TagLib::FLAC::File f(qBAFilename.constData());
        if (!readFileHeader(this, f)) {
            return ERR;
        }
        TagLib::Ogg::XiphComment* xiph = f.xiphComment();
        if (xiph) {
            readXiphComment(this, *xiph);
        }
        else {
            TagLib::ID3v2::Tag *id3v2(f.ID3v2Tag());
            if (id3v2) {
                readID3v2Tag(this, *id3v2);
            } else {
                // fallback
                const TagLib::Tag *tag(f.tag());
                if (tag) {
                    readTag(this, *tag);
                } else {
                    return ERR;
                }
            }
        }
    } else if (is_wav) {
        TagLib::RIFF::WAV::File f(qBAFilename.constData());
        if (!readFileHeader(this, f)) {
            return ERR;
        }
        TagLib::ID3v2::Tag *id3v2(f.ID3v2Tag());
        if (id3v2) {
            readID3v2Tag(this, *id3v2);
        } else {
            // fallback
            const TagLib::Tag *tag(f.tag());
            if (tag) {
                readTag(this, *tag);
            } else {
                return ERR;
            }
        }

        if (getDuration() <= 0) {
            // we're using a taglib version which doesn't know how to do wav
            // durations, set it with info from sndfile -bkgood
            // XXX remove this when ubuntu ships with an sufficiently
            // intelligent version of taglib, should happen in 11.10

            // Have to open the file for info to be valid.
            if (fh == NULL) {
                open();
            }

            if (info.samplerate > 0) {
                setDuration(info.frames / info.samplerate);
            } else {
                qDebug() << "WARNING: WAV file with invalid samplerate."
                         << "Can't get duration using libsndfile.";
            }
        }
    } else {
        // Try AIFF
        TagLib::RIFF::AIFF::File f(qBAFilename.constData());
        if (!readFileHeader(this, f)) {
            return ERR;
        }
        TagLib::ID3v2::Tag *id3v2(f.tag());
        if (id3v2) {
            readID3v2Tag(this, *id3v2);
        } else {
            return ERR;
        }
    }

    return OK;
}
Пример #28
0
bool ZipArchive::readZipFile() {
    if (checkFileHandleValid() == false)
        return false;

    ZipEOCDHeaderRecord eocdHeaderRec;
    if (readEOCDHeaderRecord(eocdHeaderRec) == false)
        return false;

    if (eocdHeaderRec.numberOfDisk != eocdHeaderRec.numberOfDiskWithStartOfCD) {
        LERROR("Need disk #" << eocdHeaderRec.numberOfDiskWithStartOfCD << " to read central directory!");
        return false;
    }

    if (eocdHeaderRec.numberOfEntriesInCD <= 0) {
        LERROR("Error: central directory does not contain any entries!");
        return false;
    }

    size_t offset = eocdHeaderRec.offsetStartCD;
    for (uint16_t i = 0; i < eocdHeaderRec.numberOfEntriesInCD; ++i) {
        ArchivedFile af;
        ZipFileHeader& fileHeader = af.zipFileHader_;
        bool res = readFileHeader(af.zipFileHader_, offset);
        if (res == true) {
            if (fileHeader.generalPurposeFlag != 0x0000) {
                LWARNING("A file seems to make use of advanced features ");
                LWARNING("this reader is unable to understand. skipping...");
                continue;
            }

            bool validCompression = false;
            switch (fileHeader.compressionMethod) {
                case 0:
                case 8:
                    validCompression = true;
                    break;
                default:
                    break;
            }

            if (validCompression == false) {
                LWARNING("Unsupported compression method (code = " << fileHeader.compressionMethod << ")!");
                LWARNING("This archiver only supports standard deflate (code 8) and uncompressed (code 0).");
                continue;
            }

            size_t fileNameOffset = (offset + SIZE_ZIPFILEHEADER);
            size_t extraFieldOffset = fileNameOffset + fileHeader.filenameLength;
            size_t commentOffset = extraFieldOffset + fileHeader.extraFieldLength;

            if (fileHeader.filenameLength > 0)
                af.fileName_ = readString(fileNameOffset, fileHeader.filenameLength);

            if (fileHeader.extraFieldLength > 0)
                af.fileExtra_ = readString(extraFieldOffset, fileHeader.extraFieldLength);

            if (fileHeader.fileCommentLength > 0)
                af.fileComment_ = readString(commentOffset, fileHeader.fileCommentLength);

            af.isNewInArchive_ = false;
            af.localHeaderOffset_ = fileHeader.localHeaderOffset;
            std::pair<ArchiveMap::iterator, bool> rs =
                files_.insert(std::make_pair(af.fileName_, af));
            if (rs.second == false)
                LERROR("failed to extract directory entry for file '" << af.fileName_ << "'!");
        } else
            LERROR("Failed to read directory entry for entry #" << i << "!");

        // The next file header is found at the current offset plus the size of
        // this FileHeader struct (constant) and plus the 3 variable length fields
        //
        offset += (SIZE_ZIPFILEHEADER + fileHeader.filenameLength
            + fileHeader.extraFieldLength + fileHeader.fileCommentLength);
    }

    return true;
}
Пример #29
0
/**
 * Initialize data structures needed buy the player and read the whole file into memory
 * @param filename Video file name
 * @param frameCallback Function to call each video frame
 * @param game Pointer to the Game instance
 * @param dx An offset on the x axis for the video to be rendered
 * @param dy An offset on the y axis for the video to be rendered
 */
bool FlcPlayer::init(const char *filename, void(*frameCallBack)(), Game *game, int dx, int dy)
{
	if (_fileBuf != 0)
	{
		Log(LOG_ERROR) << "Trying to init a video player that is already initialized";
		return false;
	}

	_frameCallBack = frameCallBack;
	_realScreen = game->getScreen();
	_realScreen->clear();
	_game = game;
	_dx = dx;
	_dy = dy;
	
	_fileSize = 0;
	_frameCount = 0;
	_audioFrameData = 0;
	_hasAudio = false;
	_audioData.loadingBuffer = 0;
	_audioData.playingBuffer = 0;

	std::ifstream file;
	file.open(filename, std::ifstream::in | std::ifstream::binary | std::ifstream::ate);
	if (!file.is_open())
	{
		Log(LOG_ERROR) << "Could not open FLI/FLC file: " << filename;
		return false;
	}

	std::streamoff size = file.tellg();
	file.seekg(0, std::ifstream::beg);

	// TODO: substitute with a cross-platform memory mapped file?
	_fileBuf = new Uint8[size];
	_fileSize = size;
	file.read((char *)_fileBuf, size);
	file.close();

	_audioFrameData = _fileBuf + 128;

	// Let's read the first 128 bytes
	readFileHeader();

	// If it's a FLC or FLI file, it's ok
	if (_headerType == SDL_SwapLE16(FLI_TYPE) || (_headerType == SDL_SwapLE16(FLC_TYPE)))
	{
		_screenWidth = _headerWidth;
		_screenHeight = _headerHeight;
		_screenDepth = 8;

		Log(LOG_INFO) << "Playing flx, " << _screenWidth << "x" << _screenHeight << ", " << _headerFrames << " frames";
	}
	else
	{
		Log(LOG_ERROR) << "Flx file failed header check.";
		return false;
	}

	// If the current surface used is at 8bpp use it
	if (_realScreen->getSurface()->getSurface()->format->BitsPerPixel == 8)
	{
		_mainScreen = _realScreen->getSurface()->getSurface();
	}
	else // Otherwise create a new one
	{
		_mainScreen = SDL_AllocSurface(SDL_SWSURFACE, _screenWidth, _screenHeight, 8, 0, 0, 0, 0);
	}

	

	return true;
}
Пример #30
0
bool PackTmt::canPack()
{
    if (!readFileHeader())
        return false;
    return true;
}