2012-10-28 02:12:18 +02:00
|
|
|
/***************************************************************************
|
|
|
|
copyright : (C) 2002 - 2008 by Scott Wheeler
|
|
|
|
email : wheeler@kde.org
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
* This library is free software; you can redistribute it and/or modify *
|
|
|
|
* it under the terms of the GNU Lesser General Public License version *
|
|
|
|
* 2.1 as published by the Free Software Foundation. *
|
|
|
|
* *
|
|
|
|
* This library is distributed in the hope that it will be useful, but *
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
|
|
|
|
* Lesser General Public License for more details. *
|
|
|
|
* *
|
|
|
|
* You should have received a copy of the GNU Lesser General Public *
|
|
|
|
* License along with this library; if not, write to the Free Software *
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA *
|
|
|
|
* 02110-1301 USA *
|
|
|
|
* *
|
|
|
|
* Alternatively, this file is available under the Mozilla Public *
|
|
|
|
* License Version 1.1. You may obtain a copy of the License at *
|
|
|
|
* http://www.mozilla.org/MPL/ *
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
|
|
#include <tagunion.h>
|
|
|
|
#include <id3v2tag.h>
|
|
|
|
#include <id3v2header.h>
|
|
|
|
#include <id3v1tag.h>
|
|
|
|
#include <apefooter.h>
|
|
|
|
#include <apetag.h>
|
|
|
|
#include <tdebug.h>
|
|
|
|
|
|
|
|
#include <bitset>
|
|
|
|
|
|
|
|
#include "mpegfile.h"
|
|
|
|
#include "mpegheader.h"
|
|
|
|
#include "tpropertymap.h"
|
|
|
|
|
|
|
|
using namespace TagLib;
|
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
enum { ID3v2Index = 0, APEIndex = 1, ID3v1Index = 2 };
|
|
|
|
}
|
|
|
|
|
|
|
|
class MPEG::File::FilePrivate
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
FilePrivate(ID3v2::FrameFactory *frameFactory = ID3v2::FrameFactory::instance()) :
|
|
|
|
ID3v2FrameFactory(frameFactory),
|
|
|
|
ID3v2Location(-1),
|
|
|
|
ID3v2OriginalSize(0),
|
|
|
|
APELocation(-1),
|
|
|
|
APEFooterLocation(-1),
|
|
|
|
APEOriginalSize(0),
|
|
|
|
ID3v1Location(-1),
|
|
|
|
hasID3v2(false),
|
|
|
|
hasID3v1(false),
|
|
|
|
hasAPE(false),
|
|
|
|
properties(0)
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
~FilePrivate()
|
|
|
|
{
|
|
|
|
delete properties;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ID3v2::FrameFactory *ID3v2FrameFactory;
|
|
|
|
|
|
|
|
long ID3v2Location;
|
|
|
|
uint ID3v2OriginalSize;
|
|
|
|
|
|
|
|
long APELocation;
|
|
|
|
long APEFooterLocation;
|
|
|
|
uint APEOriginalSize;
|
|
|
|
|
|
|
|
long ID3v1Location;
|
|
|
|
|
|
|
|
TagUnion tag;
|
|
|
|
|
|
|
|
// These indicate whether the file *on disk* has these tags, not if
|
|
|
|
// this data structure does. This is used in computing offsets.
|
|
|
|
|
|
|
|
bool hasID3v2;
|
|
|
|
bool hasID3v1;
|
|
|
|
bool hasAPE;
|
|
|
|
|
|
|
|
Properties *properties;
|
|
|
|
};
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// public members
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
MPEG::File::File(FileName file, bool readProperties,
|
|
|
|
Properties::ReadStyle propertiesStyle) : TagLib::File(file)
|
|
|
|
{
|
|
|
|
d = new FilePrivate;
|
|
|
|
|
|
|
|
if(isOpen())
|
|
|
|
read(readProperties, propertiesStyle);
|
|
|
|
}
|
|
|
|
|
|
|
|
MPEG::File::File(FileName file, ID3v2::FrameFactory *frameFactory,
|
|
|
|
bool readProperties, Properties::ReadStyle propertiesStyle) :
|
|
|
|
TagLib::File(file)
|
|
|
|
{
|
|
|
|
d = new FilePrivate(frameFactory);
|
|
|
|
|
|
|
|
if(isOpen())
|
|
|
|
read(readProperties, propertiesStyle);
|
|
|
|
}
|
|
|
|
|
|
|
|
MPEG::File::File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
|
|
|
|
bool readProperties, Properties::ReadStyle propertiesStyle) :
|
|
|
|
TagLib::File(stream)
|
|
|
|
{
|
|
|
|
d = new FilePrivate(frameFactory);
|
|
|
|
|
|
|
|
if(isOpen())
|
|
|
|
read(readProperties, propertiesStyle);
|
|
|
|
}
|
|
|
|
|
|
|
|
MPEG::File::~File()
|
|
|
|
{
|
|
|
|
delete d;
|
|
|
|
}
|
|
|
|
|
|
|
|
TagLib::Tag *MPEG::File::tag() const
|
|
|
|
{
|
|
|
|
return &d->tag;
|
|
|
|
}
|
|
|
|
|
|
|
|
PropertyMap MPEG::File::properties() const
|
|
|
|
{
|
|
|
|
// once Tag::properties() is virtual, this case distinction could actually be done
|
|
|
|
// within TagUnion.
|
|
|
|
if(d->hasID3v2)
|
|
|
|
return d->tag.access<ID3v2::Tag>(ID3v2Index, false)->properties();
|
|
|
|
if(d->hasAPE)
|
|
|
|
return d->tag.access<APE::Tag>(APEIndex, false)->properties();
|
|
|
|
if(d->hasID3v1)
|
|
|
|
return d->tag.access<ID3v1::Tag>(ID3v1Index, false)->properties();
|
|
|
|
return PropertyMap();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MPEG::File::removeUnsupportedProperties(const StringList &properties)
|
|
|
|
{
|
|
|
|
if(d->hasID3v2)
|
|
|
|
d->tag.access<ID3v2::Tag>(ID3v2Index, false)->removeUnsupportedProperties(properties);
|
|
|
|
else if(d->hasAPE)
|
|
|
|
d->tag.access<APE::Tag>(APEIndex, false)->removeUnsupportedProperties(properties);
|
|
|
|
else if(d->hasID3v1)
|
|
|
|
d->tag.access<ID3v1::Tag>(ID3v1Index, false)->removeUnsupportedProperties(properties);
|
|
|
|
}
|
2013-08-18 04:39:33 +02:00
|
|
|
|
2012-10-28 02:12:18 +02:00
|
|
|
PropertyMap MPEG::File::setProperties(const PropertyMap &properties)
|
|
|
|
{
|
2013-08-18 04:39:33 +02:00
|
|
|
if(d->hasID3v1)
|
|
|
|
// update ID3v1 tag if it exists, but ignore the return value
|
|
|
|
d->tag.access<ID3v1::Tag>(ID3v1Index, false)->setProperties(properties);
|
|
|
|
return d->tag.access<ID3v2::Tag>(ID3v2Index, true)->setProperties(properties);
|
2012-10-28 02:12:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
MPEG::Properties *MPEG::File::audioProperties() const
|
|
|
|
{
|
|
|
|
return d->properties;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::save()
|
|
|
|
{
|
|
|
|
return save(AllTags);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::save(int tags)
|
|
|
|
{
|
|
|
|
return save(tags, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::save(int tags, bool stripOthers)
|
|
|
|
{
|
|
|
|
return save(tags, stripOthers, 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version)
|
2013-08-18 04:39:33 +02:00
|
|
|
{
|
|
|
|
return save(tags, stripOthers, id3v2Version, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version, bool duplicateTags)
|
2012-10-28 02:12:18 +02:00
|
|
|
{
|
|
|
|
if(tags == NoTags && stripOthers)
|
|
|
|
return strip(AllTags);
|
|
|
|
|
|
|
|
if(!ID3v2Tag() && !ID3v1Tag() && !APETag()) {
|
|
|
|
|
|
|
|
if((d->hasID3v1 || d->hasID3v2 || d->hasAPE) && stripOthers)
|
|
|
|
return strip(AllTags);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(readOnly()) {
|
|
|
|
debug("MPEG::File::save() -- File is read only.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-08-18 04:39:33 +02:00
|
|
|
// Create the tags if we've been asked to.
|
|
|
|
|
|
|
|
if (duplicateTags) {
|
2012-10-28 02:12:18 +02:00
|
|
|
|
2013-08-18 04:39:33 +02:00
|
|
|
// Copy the values from the tag that does exist into the new tag,
|
|
|
|
// except if the existing tag is to be stripped.
|
2012-10-28 02:12:18 +02:00
|
|
|
|
2013-08-18 04:39:33 +02:00
|
|
|
if((tags & ID3v2) && ID3v1Tag() && !(stripOthers && !(tags & ID3v1)))
|
|
|
|
Tag::duplicate(ID3v1Tag(), ID3v2Tag(true), false);
|
|
|
|
|
|
|
|
if((tags & ID3v1) && d->tag[ID3v2Index] && !(stripOthers && !(tags & ID3v2)))
|
|
|
|
Tag::duplicate(ID3v2Tag(), ID3v1Tag(true), false);
|
|
|
|
}
|
2012-10-28 02:12:18 +02:00
|
|
|
|
|
|
|
bool success = true;
|
|
|
|
|
|
|
|
if(ID3v2 & tags) {
|
|
|
|
|
|
|
|
if(ID3v2Tag() && !ID3v2Tag()->isEmpty()) {
|
|
|
|
|
|
|
|
if(!d->hasID3v2)
|
|
|
|
d->ID3v2Location = 0;
|
|
|
|
|
|
|
|
insert(ID3v2Tag()->render(id3v2Version), d->ID3v2Location, d->ID3v2OriginalSize);
|
|
|
|
|
|
|
|
d->hasID3v2 = true;
|
|
|
|
|
|
|
|
// v1 tag location has changed, update if it exists
|
|
|
|
|
|
|
|
if(ID3v1Tag())
|
|
|
|
d->ID3v1Location = findID3v1();
|
|
|
|
|
|
|
|
// APE tag location has changed, update if it exists
|
|
|
|
|
|
|
|
if(APETag())
|
|
|
|
findAPE();
|
|
|
|
}
|
|
|
|
else if(stripOthers)
|
|
|
|
success = strip(ID3v2, false) && success;
|
|
|
|
}
|
|
|
|
else if(d->hasID3v2 && stripOthers)
|
|
|
|
success = strip(ID3v2) && success;
|
|
|
|
|
|
|
|
if(ID3v1 & tags) {
|
|
|
|
if(ID3v1Tag() && !ID3v1Tag()->isEmpty()) {
|
|
|
|
int offset = d->hasID3v1 ? -128 : 0;
|
|
|
|
seek(offset, End);
|
|
|
|
writeBlock(ID3v1Tag()->render());
|
|
|
|
d->hasID3v1 = true;
|
|
|
|
d->ID3v1Location = findID3v1();
|
|
|
|
}
|
|
|
|
else if(stripOthers)
|
|
|
|
success = strip(ID3v1) && success;
|
|
|
|
}
|
|
|
|
else if(d->hasID3v1 && stripOthers)
|
|
|
|
success = strip(ID3v1, false) && success;
|
|
|
|
|
|
|
|
// Dont save an APE-tag unless one has been created
|
|
|
|
|
|
|
|
if((APE & tags) && APETag()) {
|
|
|
|
if(d->hasAPE)
|
|
|
|
insert(APETag()->render(), d->APELocation, d->APEOriginalSize);
|
|
|
|
else {
|
|
|
|
if(d->hasID3v1) {
|
|
|
|
insert(APETag()->render(), d->ID3v1Location, 0);
|
|
|
|
d->APEOriginalSize = APETag()->footer()->completeTagSize();
|
|
|
|
d->hasAPE = true;
|
|
|
|
d->APELocation = d->ID3v1Location;
|
|
|
|
d->ID3v1Location += d->APEOriginalSize;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
seek(0, End);
|
|
|
|
d->APELocation = tell();
|
|
|
|
APE::Tag *apeTag = d->tag.access<APE::Tag>(APEIndex, false);
|
|
|
|
d->APEFooterLocation = d->APELocation
|
|
|
|
+ apeTag->footer()->completeTagSize()
|
|
|
|
- APE::Footer::size();
|
|
|
|
writeBlock(APETag()->render());
|
|
|
|
d->APEOriginalSize = APETag()->footer()->completeTagSize();
|
|
|
|
d->hasAPE = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(d->hasAPE && stripOthers)
|
|
|
|
success = strip(APE, false) && success;
|
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
ID3v2::Tag *MPEG::File::ID3v2Tag(bool create)
|
|
|
|
{
|
|
|
|
return d->tag.access<ID3v2::Tag>(ID3v2Index, create);
|
|
|
|
}
|
|
|
|
|
|
|
|
ID3v1::Tag *MPEG::File::ID3v1Tag(bool create)
|
|
|
|
{
|
|
|
|
return d->tag.access<ID3v1::Tag>(ID3v1Index, create);
|
|
|
|
}
|
|
|
|
|
|
|
|
APE::Tag *MPEG::File::APETag(bool create)
|
|
|
|
{
|
|
|
|
return d->tag.access<APE::Tag>(APEIndex, create);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::strip(int tags)
|
|
|
|
{
|
|
|
|
return strip(tags, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::strip(int tags, bool freeMemory)
|
|
|
|
{
|
|
|
|
if(readOnly()) {
|
|
|
|
debug("MPEG::File::strip() - Cannot strip tags from a read only file.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if((tags & ID3v2) && d->hasID3v2) {
|
|
|
|
removeBlock(d->ID3v2Location, d->ID3v2OriginalSize);
|
|
|
|
d->ID3v2Location = -1;
|
|
|
|
d->ID3v2OriginalSize = 0;
|
|
|
|
d->hasID3v2 = false;
|
|
|
|
|
|
|
|
if(freeMemory)
|
|
|
|
d->tag.set(ID3v2Index, 0);
|
|
|
|
|
|
|
|
// v1 tag location has changed, update if it exists
|
|
|
|
|
|
|
|
if(ID3v1Tag())
|
|
|
|
d->ID3v1Location = findID3v1();
|
|
|
|
|
|
|
|
// APE tag location has changed, update if it exists
|
|
|
|
|
|
|
|
if(APETag())
|
|
|
|
findAPE();
|
|
|
|
}
|
|
|
|
|
|
|
|
if((tags & ID3v1) && d->hasID3v1) {
|
|
|
|
truncate(d->ID3v1Location);
|
|
|
|
d->ID3v1Location = -1;
|
|
|
|
d->hasID3v1 = false;
|
|
|
|
|
|
|
|
if(freeMemory)
|
|
|
|
d->tag.set(ID3v1Index, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if((tags & APE) && d->hasAPE) {
|
|
|
|
removeBlock(d->APELocation, d->APEOriginalSize);
|
|
|
|
d->APELocation = -1;
|
|
|
|
d->APEFooterLocation = -1;
|
|
|
|
d->hasAPE = false;
|
|
|
|
if(d->hasID3v1) {
|
|
|
|
if(d->ID3v1Location > d->APELocation)
|
|
|
|
d->ID3v1Location -= d->APEOriginalSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(freeMemory)
|
|
|
|
d->tag.set(APEIndex, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MPEG::File::setID3v2FrameFactory(const ID3v2::FrameFactory *factory)
|
|
|
|
{
|
|
|
|
d->ID3v2FrameFactory = factory;
|
|
|
|
}
|
|
|
|
|
|
|
|
long MPEG::File::nextFrameOffset(long position)
|
|
|
|
{
|
|
|
|
bool foundLastSyncPattern = false;
|
|
|
|
|
|
|
|
ByteVector buffer;
|
|
|
|
|
|
|
|
while(true) {
|
|
|
|
seek(position);
|
|
|
|
buffer = readBlock(bufferSize());
|
|
|
|
|
|
|
|
if(buffer.size() <= 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if(foundLastSyncPattern && secondSynchByte(buffer[0]))
|
|
|
|
return position - 1;
|
|
|
|
|
|
|
|
for(uint i = 0; i < buffer.size() - 1; i++) {
|
|
|
|
if(uchar(buffer[i]) == 0xff && secondSynchByte(buffer[i + 1]))
|
|
|
|
return position + i;
|
|
|
|
}
|
|
|
|
|
|
|
|
foundLastSyncPattern = uchar(buffer[buffer.size() - 1]) == 0xff;
|
|
|
|
position += buffer.size();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
long MPEG::File::previousFrameOffset(long position)
|
|
|
|
{
|
|
|
|
bool foundFirstSyncPattern = false;
|
|
|
|
ByteVector buffer;
|
|
|
|
|
|
|
|
while (position > 0) {
|
|
|
|
long size = ulong(position) < bufferSize() ? position : bufferSize();
|
|
|
|
position -= size;
|
|
|
|
|
|
|
|
seek(position);
|
|
|
|
buffer = readBlock(size);
|
|
|
|
|
|
|
|
if(buffer.size() <= 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if(foundFirstSyncPattern && uchar(buffer[buffer.size() - 1]) == 0xff)
|
|
|
|
return position + buffer.size() - 1;
|
|
|
|
|
|
|
|
for(int i = buffer.size() - 2; i >= 0; i--) {
|
|
|
|
if(uchar(buffer[i]) == 0xff && secondSynchByte(buffer[i + 1]))
|
|
|
|
return position + i;
|
|
|
|
}
|
|
|
|
|
|
|
|
foundFirstSyncPattern = secondSynchByte(buffer[0]);
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
long MPEG::File::firstFrameOffset()
|
|
|
|
{
|
|
|
|
long position = 0;
|
|
|
|
|
|
|
|
if(ID3v2Tag())
|
|
|
|
position = d->ID3v2Location + ID3v2Tag()->header()->completeTagSize();
|
|
|
|
|
|
|
|
return nextFrameOffset(position);
|
|
|
|
}
|
|
|
|
|
|
|
|
long MPEG::File::lastFrameOffset()
|
|
|
|
{
|
|
|
|
return previousFrameOffset(ID3v1Tag() ? d->ID3v1Location - 1 : length());
|
|
|
|
}
|
|
|
|
|
2013-08-18 04:39:33 +02:00
|
|
|
bool MPEG::File::hasID3v1Tag() const
|
|
|
|
{
|
|
|
|
return d->hasID3v1;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::hasID3v2Tag() const
|
|
|
|
{
|
|
|
|
return d->hasID3v2;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::hasAPETag() const
|
|
|
|
{
|
|
|
|
return d->hasAPE;
|
|
|
|
}
|
|
|
|
|
2012-10-28 02:12:18 +02:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// private members
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
void MPEG::File::read(bool readProperties, Properties::ReadStyle propertiesStyle)
|
|
|
|
{
|
|
|
|
// Look for an ID3v2 tag
|
|
|
|
|
|
|
|
d->ID3v2Location = findID3v2();
|
|
|
|
|
|
|
|
if(d->ID3v2Location >= 0) {
|
|
|
|
|
|
|
|
d->tag.set(ID3v2Index, new ID3v2::Tag(this, d->ID3v2Location, d->ID3v2FrameFactory));
|
|
|
|
|
|
|
|
d->ID3v2OriginalSize = ID3v2Tag()->header()->completeTagSize();
|
|
|
|
|
|
|
|
if(ID3v2Tag()->header()->tagSize() <= 0)
|
|
|
|
d->tag.set(ID3v2Index, 0);
|
|
|
|
else
|
|
|
|
d->hasID3v2 = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look for an ID3v1 tag
|
|
|
|
|
|
|
|
d->ID3v1Location = findID3v1();
|
|
|
|
|
|
|
|
if(d->ID3v1Location >= 0) {
|
|
|
|
d->tag.set(ID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
|
|
|
|
d->hasID3v1 = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look for an APE tag
|
|
|
|
|
|
|
|
findAPE();
|
|
|
|
|
|
|
|
if(d->APELocation >= 0) {
|
|
|
|
|
|
|
|
d->tag.set(APEIndex, new APE::Tag(this, d->APEFooterLocation));
|
|
|
|
d->APEOriginalSize = APETag()->footer()->completeTagSize();
|
|
|
|
d->hasAPE = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(readProperties)
|
|
|
|
d->properties = new Properties(this, propertiesStyle);
|
|
|
|
|
|
|
|
// Make sure that we have our default tag types available.
|
|
|
|
|
|
|
|
ID3v2Tag(true);
|
|
|
|
ID3v1Tag(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
long MPEG::File::findID3v2()
|
|
|
|
{
|
|
|
|
// This method is based on the contents of TagLib::File::find(), but because
|
|
|
|
// of some subtlteies -- specifically the need to look for the bit pattern of
|
|
|
|
// an MPEG sync, it has been modified for use here.
|
|
|
|
|
|
|
|
if(isValid() && ID3v2::Header::fileIdentifier().size() <= bufferSize()) {
|
|
|
|
|
|
|
|
// The position in the file that the current buffer starts at.
|
|
|
|
|
|
|
|
long bufferOffset = 0;
|
|
|
|
ByteVector buffer;
|
|
|
|
|
|
|
|
// These variables are used to keep track of a partial match that happens at
|
|
|
|
// the end of a buffer.
|
|
|
|
|
|
|
|
int previousPartialMatch = -1;
|
|
|
|
bool previousPartialSynchMatch = false;
|
|
|
|
|
|
|
|
// Save the location of the current read pointer. We will restore the
|
|
|
|
// position using seek() before all returns.
|
|
|
|
|
|
|
|
long originalPosition = tell();
|
|
|
|
|
|
|
|
// Start the search at the beginning of the file.
|
|
|
|
|
|
|
|
seek(0);
|
|
|
|
|
|
|
|
// This loop is the crux of the find method. There are three cases that we
|
|
|
|
// want to account for:
|
|
|
|
// (1) The previously searched buffer contained a partial match of the search
|
|
|
|
// pattern and we want to see if the next one starts with the remainder of
|
|
|
|
// that pattern.
|
|
|
|
//
|
|
|
|
// (2) The search pattern is wholly contained within the current buffer.
|
|
|
|
//
|
|
|
|
// (3) The current buffer ends with a partial match of the pattern. We will
|
|
|
|
// note this for use in the next itteration, where we will check for the rest
|
|
|
|
// of the pattern.
|
|
|
|
|
|
|
|
for(buffer = readBlock(bufferSize()); buffer.size() > 0; buffer = readBlock(bufferSize())) {
|
|
|
|
|
|
|
|
// (1) previous partial match
|
|
|
|
|
|
|
|
if(previousPartialSynchMatch && secondSynchByte(buffer[0]))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if(previousPartialMatch >= 0 && int(bufferSize()) > previousPartialMatch) {
|
|
|
|
const int patternOffset = (bufferSize() - previousPartialMatch);
|
|
|
|
if(buffer.containsAt(ID3v2::Header::fileIdentifier(), 0, patternOffset)) {
|
|
|
|
seek(originalPosition);
|
|
|
|
return bufferOffset - bufferSize() + previousPartialMatch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// (2) pattern contained in current buffer
|
|
|
|
|
|
|
|
long location = buffer.find(ID3v2::Header::fileIdentifier());
|
|
|
|
if(location >= 0) {
|
|
|
|
seek(originalPosition);
|
|
|
|
return bufferOffset + location;
|
|
|
|
}
|
|
|
|
|
|
|
|
int firstSynchByte = buffer.find(char(uchar(255)));
|
|
|
|
|
|
|
|
// Here we have to loop because there could be several of the first
|
|
|
|
// (11111111) byte, and we want to check all such instances until we find
|
|
|
|
// a full match (11111111 111) or hit the end of the buffer.
|
|
|
|
|
|
|
|
while(firstSynchByte >= 0) {
|
|
|
|
|
|
|
|
// if this *is not* at the end of the buffer
|
|
|
|
|
|
|
|
if(firstSynchByte < int(buffer.size()) - 1) {
|
|
|
|
if(secondSynchByte(buffer[firstSynchByte + 1])) {
|
|
|
|
// We've found the frame synch pattern.
|
|
|
|
seek(originalPosition);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
|
|
|
// We found 11111111 at the end of the current buffer indicating a
|
|
|
|
// partial match of the synch pattern. The find() below should
|
|
|
|
// return -1 and break out of the loop.
|
|
|
|
|
|
|
|
previousPartialSynchMatch = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check in the rest of the buffer.
|
|
|
|
|
|
|
|
firstSynchByte = buffer.find(char(uchar(255)), firstSynchByte + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// (3) partial match
|
|
|
|
|
|
|
|
previousPartialMatch = buffer.endsWithPartialMatch(ID3v2::Header::fileIdentifier());
|
|
|
|
|
|
|
|
bufferOffset += bufferSize();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Since we hit the end of the file, reset the status before continuing.
|
|
|
|
|
|
|
|
clear();
|
|
|
|
|
|
|
|
seek(originalPosition);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
long MPEG::File::findID3v1()
|
|
|
|
{
|
|
|
|
if(isValid()) {
|
|
|
|
seek(-128, End);
|
|
|
|
long p = tell();
|
|
|
|
|
|
|
|
if(readBlock(3) == ID3v1::Tag::fileIdentifier())
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MPEG::File::findAPE()
|
|
|
|
{
|
|
|
|
if(isValid()) {
|
|
|
|
seek(d->hasID3v1 ? -160 : -32, End);
|
|
|
|
|
|
|
|
long p = tell();
|
|
|
|
|
|
|
|
if(readBlock(8) == APE::Tag::fileIdentifier()) {
|
|
|
|
d->APEFooterLocation = p;
|
|
|
|
seek(d->APEFooterLocation);
|
|
|
|
APE::Footer footer(readBlock(APE::Footer::size()));
|
|
|
|
d->APELocation = d->APEFooterLocation - footer.completeTagSize()
|
|
|
|
+ APE::Footer::size();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
d->APELocation = -1;
|
|
|
|
d->APEFooterLocation = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MPEG::File::secondSynchByte(char byte)
|
|
|
|
{
|
|
|
|
std::bitset<8> b(byte);
|
|
|
|
|
|
|
|
// check to see if the byte matches 111xxxxx
|
|
|
|
return b.test(7) && b.test(6) && b.test(5);
|
|
|
|
}
|