mirror of
				https://github.com/taglib/taglib.git
				synced 2025-11-03 16:26:18 -05:00 
			
		
		
		
	Make use of List iterators.
This commit is contained in:
		@ -35,21 +35,23 @@ using namespace TagLib;
 | 
			
		||||
class MP4::Tag::TagPrivate
 | 
			
		||||
{
 | 
			
		||||
public:
 | 
			
		||||
  TagPrivate() : file(0), atoms(0) {}
 | 
			
		||||
  ~TagPrivate() {}
 | 
			
		||||
  TagPrivate() :
 | 
			
		||||
    file(0),
 | 
			
		||||
    atoms(0) {}
 | 
			
		||||
 | 
			
		||||
  TagLib::File *file;
 | 
			
		||||
  Atoms *atoms;
 | 
			
		||||
  ItemMap items;
 | 
			
		||||
};
 | 
			
		||||
 | 
			
		||||
MP4::Tag::Tag()
 | 
			
		||||
MP4::Tag::Tag() :
 | 
			
		||||
  d(new TagPrivate())
 | 
			
		||||
{
 | 
			
		||||
  d = new TagPrivate;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
MP4::Tag::Tag(TagLib::File *file, MP4::Atoms *atoms)
 | 
			
		||||
MP4::Tag::Tag(TagLib::File *file, MP4::Atoms *atoms) :
 | 
			
		||||
  d(new TagPrivate())
 | 
			
		||||
{
 | 
			
		||||
  d = new TagPrivate;
 | 
			
		||||
  d->file = file;
 | 
			
		||||
  d->atoms = atoms;
 | 
			
		||||
 | 
			
		||||
@ -59,8 +61,8 @@ MP4::Tag::Tag(TagLib::File *file, MP4::Atoms *atoms)
 | 
			
		||||
    return;
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  for(unsigned int i = 0; i < ilst->children.size(); i++) {
 | 
			
		||||
    MP4::Atom *atom = ilst->children[i];
 | 
			
		||||
  for(AtomList::ConstIterator it = ilst->children.begin(); it != ilst->children.end(); ++it) {
 | 
			
		||||
    MP4::Atom *atom = *it;
 | 
			
		||||
    file->seek(atom->offset + 8);
 | 
			
		||||
    if(atom->name == "----") {
 | 
			
		||||
      parseFreeForm(atom);
 | 
			
		||||
@ -149,8 +151,8 @@ MP4::Tag::parseData(const MP4::Atom *atom, int expectedFlags, bool freeForm)
 | 
			
		||||
{
 | 
			
		||||
  AtomDataList data = parseData2(atom, expectedFlags, freeForm);
 | 
			
		||||
  ByteVectorList result;
 | 
			
		||||
  for(uint i = 0; i < data.size(); i++) {
 | 
			
		||||
    result.append(data[i].data);
 | 
			
		||||
  for(AtomDataList::ConstIterator it = data.begin(); it != data.end(); ++it) {
 | 
			
		||||
    result.append(it->data);
 | 
			
		||||
  }
 | 
			
		||||
  return result;
 | 
			
		||||
}
 | 
			
		||||
@ -230,8 +232,8 @@ MP4::Tag::parseText(const MP4::Atom *atom, int expectedFlags)
 | 
			
		||||
  ByteVectorList data = parseData(atom, expectedFlags);
 | 
			
		||||
  if(data.size()) {
 | 
			
		||||
    StringList value;
 | 
			
		||||
    for(unsigned int i = 0; i < data.size(); i++) {
 | 
			
		||||
      value.append(String(data[i], String::UTF8));
 | 
			
		||||
    for(ByteVectorList::ConstIterator it = data.begin(); it != data.end(); ++it) {
 | 
			
		||||
      value.append(String(*it, String::UTF8));
 | 
			
		||||
    }
 | 
			
		||||
    addItem(atom->name, value);
 | 
			
		||||
  }
 | 
			
		||||
@ -242,18 +244,25 @@ MP4::Tag::parseFreeForm(const MP4::Atom *atom)
 | 
			
		||||
{
 | 
			
		||||
  AtomDataList data = parseData2(atom, -1, true);
 | 
			
		||||
  if(data.size() > 2) {
 | 
			
		||||
    String name = "----:" + String(data[0].data, String::UTF8) + ':' + String(data[1].data, String::UTF8);
 | 
			
		||||
    AtomDataType type = data[2].type;
 | 
			
		||||
    for(uint i = 2; i < data.size(); i++) {
 | 
			
		||||
      if(data[i].type != type) {
 | 
			
		||||
    AtomDataList::ConstIterator itBegin = data.begin();
 | 
			
		||||
 | 
			
		||||
    String name = "----:";
 | 
			
		||||
    name += String((itBegin++)->data, String::UTF8);  // data[0].data
 | 
			
		||||
    name += ':';
 | 
			
		||||
    name += String((itBegin++)->data, String::UTF8);  // data[1].data
 | 
			
		||||
 | 
			
		||||
    AtomDataType type = itBegin->type; // data[2].type
 | 
			
		||||
 | 
			
		||||
    for(AtomDataList::ConstIterator it = itBegin; it != data.end(); ++it) {
 | 
			
		||||
      if(it->type != type) {
 | 
			
		||||
        debug("MP4: We currently don't support values with multiple types");
 | 
			
		||||
        break;
 | 
			
		||||
      }
 | 
			
		||||
    }
 | 
			
		||||
    if(type == TypeUTF8) {
 | 
			
		||||
      StringList value;
 | 
			
		||||
      for(uint i = 2; i < data.size(); i++) {
 | 
			
		||||
        value.append(String(data[i].data, String::UTF8));
 | 
			
		||||
      for(AtomDataList::ConstIterator it = itBegin; it != data.end(); ++it) {
 | 
			
		||||
        value.append(String(it->data, String::UTF8));
 | 
			
		||||
      }
 | 
			
		||||
      Item item(value);
 | 
			
		||||
      item.setAtomDataType(type);
 | 
			
		||||
@ -261,8 +270,8 @@ MP4::Tag::parseFreeForm(const MP4::Atom *atom)
 | 
			
		||||
    }
 | 
			
		||||
    else {
 | 
			
		||||
      ByteVectorList value;
 | 
			
		||||
      for(uint i = 2; i < data.size(); i++) {
 | 
			
		||||
        value.append(data[i].data);
 | 
			
		||||
      for(AtomDataList::ConstIterator it = itBegin; it != data.end(); ++it) {
 | 
			
		||||
        value.append(it->data);
 | 
			
		||||
      }
 | 
			
		||||
      Item item(value);
 | 
			
		||||
      item.setAtomDataType(type);
 | 
			
		||||
@ -300,7 +309,7 @@ MP4::Tag::parseCovr(const MP4::Atom *atom)
 | 
			
		||||
    }
 | 
			
		||||
    pos += length;
 | 
			
		||||
  }
 | 
			
		||||
  if(value.size() > 0)
 | 
			
		||||
  if(!value.isEmpty())
 | 
			
		||||
    addItem(atom->name, value);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
@ -406,9 +415,9 @@ MP4::Tag::renderCovr(const ByteVector &name, const MP4::Item &item) const
 | 
			
		||||
{
 | 
			
		||||
  ByteVector data;
 | 
			
		||||
  MP4::CoverArtList value = item.toCoverArtList();
 | 
			
		||||
  for(unsigned int i = 0; i < value.size(); i++) {
 | 
			
		||||
    data.append(renderAtom("data", ByteVector::fromUInt(value[i].format()) +
 | 
			
		||||
                                   ByteVector(4, '\0') + value[i].data()));
 | 
			
		||||
  for(MP4::CoverArtList::ConstIterator it = value.begin(); it != value.end(); ++it) {
 | 
			
		||||
    data.append(renderAtom("data", ByteVector::fromUInt(it->format()) +
 | 
			
		||||
                                   ByteVector(4, '\0') + it->data()));
 | 
			
		||||
  }
 | 
			
		||||
  return renderAtom(name, data);
 | 
			
		||||
}
 | 
			
		||||
@ -505,20 +514,26 @@ MP4::Tag::save()
 | 
			
		||||
void
 | 
			
		||||
MP4::Tag::updateParents(const AtomList &path, long delta, int ignore)
 | 
			
		||||
{
 | 
			
		||||
  for(unsigned int i = 0; i < path.size() - ignore; i++) {
 | 
			
		||||
    d->file->seek(path[i]->offset);
 | 
			
		||||
  if(static_cast<int>(path.size()) <= ignore)
 | 
			
		||||
    return;
 | 
			
		||||
 | 
			
		||||
  AtomList::ConstIterator itEnd = path.end();
 | 
			
		||||
  std::advance(itEnd, 0 - ignore);
 | 
			
		||||
 | 
			
		||||
  for(AtomList::ConstIterator it = path.begin(); it != itEnd; ++it) {
 | 
			
		||||
    d->file->seek((*it)->offset);
 | 
			
		||||
    long size = d->file->readBlock(4).toUInt();
 | 
			
		||||
    // 64-bit
 | 
			
		||||
    if (size == 1) {
 | 
			
		||||
      d->file->seek(4, File::Current); // Skip name
 | 
			
		||||
      long long longSize = d->file->readBlock(8).toLongLong();
 | 
			
		||||
      // Seek the offset of the 64-bit size
 | 
			
		||||
      d->file->seek(path[i]->offset + 8);
 | 
			
		||||
      d->file->seek((*it)->offset + 8);
 | 
			
		||||
      d->file->writeBlock(ByteVector::fromLongLong(longSize + delta));
 | 
			
		||||
    }
 | 
			
		||||
    // 32-bit
 | 
			
		||||
    else {
 | 
			
		||||
      d->file->seek(path[i]->offset);
 | 
			
		||||
      d->file->seek((*it)->offset);
 | 
			
		||||
      d->file->writeBlock(ByteVector::fromUInt(size + delta));
 | 
			
		||||
    }
 | 
			
		||||
  }
 | 
			
		||||
@ -530,8 +545,8 @@ MP4::Tag::updateOffsets(long delta, long offset)
 | 
			
		||||
  MP4::Atom *moov = d->atoms->find("moov");
 | 
			
		||||
  if(moov) {
 | 
			
		||||
    MP4::AtomList stco = moov->findall("stco", true);
 | 
			
		||||
    for(unsigned int i = 0; i < stco.size(); i++) {
 | 
			
		||||
      MP4::Atom *atom = stco[i];
 | 
			
		||||
    for(MP4::AtomList::ConstIterator it = stco.begin(); it != stco.end(); ++it) {
 | 
			
		||||
      MP4::Atom *atom = *it;
 | 
			
		||||
      if(atom->offset > offset) {
 | 
			
		||||
        atom->offset += delta;
 | 
			
		||||
      }
 | 
			
		||||
@ -551,8 +566,8 @@ MP4::Tag::updateOffsets(long delta, long offset)
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    MP4::AtomList co64 = moov->findall("co64", true);
 | 
			
		||||
    for(unsigned int i = 0; i < co64.size(); i++) {
 | 
			
		||||
      MP4::Atom *atom = co64[i];
 | 
			
		||||
    for(MP4::AtomList::ConstIterator it = co64.begin(); it != co64.end(); ++it) {
 | 
			
		||||
      MP4::Atom *atom = *it;
 | 
			
		||||
      if(atom->offset > offset) {
 | 
			
		||||
        atom->offset += delta;
 | 
			
		||||
      }
 | 
			
		||||
@ -575,8 +590,8 @@ MP4::Tag::updateOffsets(long delta, long offset)
 | 
			
		||||
  MP4::Atom *moof = d->atoms->find("moof");
 | 
			
		||||
  if(moof) {
 | 
			
		||||
    MP4::AtomList tfhd = moof->findall("tfhd", true);
 | 
			
		||||
    for(unsigned int i = 0; i < tfhd.size(); i++) {
 | 
			
		||||
      MP4::Atom *atom = tfhd[i];
 | 
			
		||||
    for(MP4::AtomList::ConstIterator it = tfhd.begin(); it != tfhd.end(); ++it) {
 | 
			
		||||
      MP4::Atom *atom = *it;
 | 
			
		||||
      if(atom->offset > offset) {
 | 
			
		||||
        atom->offset += delta;
 | 
			
		||||
      }
 | 
			
		||||
@ -609,7 +624,7 @@ MP4::Tag::saveNew(ByteVector data)
 | 
			
		||||
    data = renderAtom("udta", data);
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  long offset = path[path.size() - 1]->offset + 8;
 | 
			
		||||
  long offset = path.back()->offset + 8;
 | 
			
		||||
  d->file->insert(data, offset, 0);
 | 
			
		||||
 | 
			
		||||
  updateParents(path, data.size());
 | 
			
		||||
@ -619,11 +634,13 @@ MP4::Tag::saveNew(ByteVector data)
 | 
			
		||||
void
 | 
			
		||||
MP4::Tag::saveExisting(ByteVector data, const AtomList &path)
 | 
			
		||||
{
 | 
			
		||||
  MP4::Atom *ilst = path[path.size() - 1];
 | 
			
		||||
  AtomList::ConstIterator it = path.end();
 | 
			
		||||
 | 
			
		||||
  MP4::Atom *ilst = *(--it);
 | 
			
		||||
  long offset = ilst->offset;
 | 
			
		||||
  long length = ilst->length;
 | 
			
		||||
 | 
			
		||||
  MP4::Atom *meta = path[path.size() - 2];
 | 
			
		||||
  MP4::Atom *meta = *(--it);
 | 
			
		||||
  AtomList::ConstIterator index = meta->children.find(ilst);
 | 
			
		||||
 | 
			
		||||
  // check if there is an atom before 'ilst', and possibly use it as padding
 | 
			
		||||
 | 
			
		||||
		Reference in New Issue
	
	Block a user