---

src/tag.cpp

Go to the documentation of this file.

// $Id: tag.cpp,v 1.41 2001/09/08 02:33:41 shadrack Exp $

// id3lib: a C++ library for creating and manipulating id3v1/v2 tags
// Copyright 1999, 2000  Scott Thomas Haug

// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2 of the License, or (at your
// option) any later version.
//
// 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 Library General Public
// License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with this library; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

// The id3lib authors encourage improvements and optimisations to be sent to
// the id3lib coordinator.  Please see the README file for details on where to
// send such submissions.  See the AUTHORS file for a list of people who have
// contributed to id3lib.  See the ChangeLog file for a list of changes to
// id3lib.  These files are distributed with id3lib at
// http://download.sourceforge.net/id3lib/

#if defined HAVE_CONFIG_H
#include <config.h>
#endif

#include "tag.h"
#include "readers.h"
#include "writers.h"
#include "tag_impl.h"
#include "strings.h"
#include "utils.h"

using namespace dami;

ID3_Tag::ID3_Tag(const char *name)
  : _impl(new ID3_TagImpl(name))
{
}

ID3_Tag::ID3_Tag(const ID3_Tag &tag)
  : _impl(new ID3_TagImpl(tag))
{
}

ID3_Tag::~ID3_Tag()
{
  delete _impl;
}

void ID3_Tag::Clear()
{
  _impl->Clear();
}


bool ID3_Tag::HasChanged() const
{
  return _impl->HasChanged();
}

size_t ID3_Tag::Size() const
{
  return _impl->Size();
}

bool ID3_Tag::SetUnsync(bool b)
{
  return _impl->SetUnsync(b);
}


bool ID3_Tag::SetExtendedHeader(bool ext)
{
  return _impl->SetExtended(ext);
}

bool ID3_Tag::SetPadding(bool pad)
{
  return _impl->SetPadding(pad);
}

bool ID3_Tag::SetExperimental(bool exp)
{
  return _impl->SetExperimental(exp);
}

bool ID3_Tag::GetUnsync() const
{
  return _impl->GetUnsync();
}

bool ID3_Tag::GetExtendedHeader() const
{
  return _impl->GetExtended();
}

bool ID3_Tag::GetExperimental() const
{
  return _impl->GetExperimental();
}

void ID3_Tag::AddFrame(const ID3_Frame& frame)
{
  _impl->AddFrame(frame);
}

void ID3_Tag::AddFrame(const ID3_Frame* frame)
{
  _impl->AddFrame(frame);
}

void ID3_Tag::AttachFrame(ID3_Frame *frame)
{
  _impl->AttachFrame(frame);
}


ID3_Frame* ID3_Tag::RemoveFrame(const ID3_Frame *frame)
{
  return _impl->RemoveFrame(frame);
}

bool ID3_Tag::Parse(ID3_Reader& reader)
{
  return id3::v2::parse(*_impl, reader);
}

size_t ID3_Tag::Parse(const uchar* buffer, size_t bytes)
{
  ID3_MemoryReader mr(buffer, bytes);
  ID3_Reader::pos_type beg = mr.getCur();
  id3::v2::parse(*_impl, mr);
  return mr.getEnd() - beg;
}

size_t ID3_Tag::Parse(const uchar header[ID3_TAGHEADERSIZE],
                      const uchar *buffer)
{
  size_t size = ID3_Tag::IsV2Tag(header);
  if (0 == size)
  {
    return 0;
  }
  BString buf;
  buf.reserve(ID3_TagHeader::SIZE + size);
  buf.append(reinterpret_cast<const BString::value_type *>(header), 
             ID3_TagHeader::SIZE);
  buf.append(reinterpret_cast<const BString::value_type *>(buffer), size);
  return this->Parse(buf.data(), buf.size());
}

size_t ID3_Tag::Render(uchar* buffer, ID3_TagType tt) const
{
  ID3_MemoryWriter mw(buffer, -1);
  return this->Render(mw, tt);
}

size_t ID3_Tag::Render(ID3_Writer& writer, ID3_TagType tt) const
{
  ID3_Writer::pos_type beg = writer.getCur();
  if (ID3TT_ID3V2 & tt)
  {
    id3::v2::render(writer, *this);
  }
  else if (ID3TT_ID3V1 & tt)
  {
    id3::v1::render(writer, *this);
  }
  return writer.getCur() - beg;
}


size_t ID3_Tag::Link(const char *fileInfo, flags_t flags)
{
  return _impl->Link(fileInfo, flags);
}

flags_t ID3_Tag::Update(flags_t flags)
{
  return _impl->Update(flags);
}

flags_t ID3_Tag::Strip(flags_t flags)
{
  return _impl->Strip(flags);
}
  
size_t ID3_Tag::GetPrependedBytes() const 
{
  return _impl->GetPrependedBytes();
}

size_t ID3_Tag::GetAppendedBytes() const 
{ 
  return _impl->GetAppendedBytes();
}

size_t ID3_Tag::GetFileSize() const 
{ 
  return _impl->GetFileSize();
}

const char* ID3_Tag::GetFileName() const 
{ 
  return _impl->GetFileName().c_str();
}


ID3_Frame* ID3_Tag::Find(ID3_FrameID id) const
{
  return _impl->Find(id);
}

ID3_Frame* ID3_Tag::Find(ID3_FrameID id, ID3_FieldID fld, uint32 data) const
{
  return _impl->Find(id, fld, data);
}

ID3_Frame* ID3_Tag::Find(ID3_FrameID id, ID3_FieldID fld, const char* data) const
{
  String str(data);
  return _impl->Find(id, fld, str);
}

ID3_Frame* ID3_Tag::Find(ID3_FrameID id, ID3_FieldID fld, const unicode_t* data) const
{
  WString str = toWString(data, ucslen(data));
  return _impl->Find(id, fld, str);
}

size_t ID3_Tag::NumFrames() const
{
  return _impl->NumFrames();
}

/*
ID3_Frame* ID3_Tag::GetFrameNum(index_t num) const
{
  const size_t numFrames = this->NumFrames();
  if (num >= numFrames)
  {
    return NULL;
  }

  ID3_Frame* frame = NULL;
  index_t curNum = 0;
  // search from the cursor to the end
  for (ID3_TagImpl::const_iterator cur = _impl->begin(); cur != _impl->end(); ++cur)
  {
    if (curNum++ == num)
    {
      frame = *cur;
      break;
    }
  }
  
  return frame;
}
*/

/*
ID3_Frame* ID3_Tag::operator[](index_t index) const
{
  return this->GetFrameNum(index);
}
*/

ID3_Tag& ID3_Tag::operator=( const ID3_Tag &rTag )
{
  if (this != &rTag)
  {
    *_impl = rTag;
  }
  return *this;
}

bool ID3_Tag::HasTagType(uint16 tt) const
{
  return _impl->HasTagType(tt);
}

ID3_V2Spec ID3_Tag::GetSpec() const
{
  return _impl->GetSpec();
}

bool ID3_Tag::SetSpec(ID3_V2Spec spec)
{
  return _impl->SetSpec(spec);
}

size_t ID3_Tag::IsV2Tag(const uchar* const data)
{
  ID3_MemoryReader mr(data, ID3_TagHeader::SIZE);
  return ID3_TagImpl::IsV2Tag(mr);
}

size_t ID3_Tag::IsV2Tag(ID3_Reader& reader)
{
  return ID3_TagImpl::IsV2Tag(reader);
}

void ID3_Tag::AddNewFrame(ID3_Frame* f) 
{ 
  _impl->AttachFrame(f);
}

void ID3_Tag::AddFrames(const ID3_Frame *frames, size_t numFrames)
{
  for (index_t i = numFrames - 1; i >= 0; i--)
  {
    this->AddFrame(frames[i]);
  }
}

size_t ID3_Tag::Link(const char *fileInfo, bool parseID3v1, bool parseLyrics3)
{
  return _impl->Link(fileInfo, parseID3v1, parseLyrics3);
}

void ID3_Tag::SetCompression(bool b) 
{ 
  ; 
}

bool ID3_Tag::HasLyrics() const 
{ 
  return this->HasTagType(ID3TT_LYRICS);
}
bool ID3_Tag::HasV2Tag()  const 
{ 
  return this->HasTagType(ID3TT_ID3V2); 
}
bool ID3_Tag::HasV1Tag()  const 
{ 
  return this->HasTagType(ID3TT_ID3V1); 
}

ID3_Tag& ID3_Tag::operator<<(const ID3_Frame& frame)
{
  this->AddFrame(frame);
  return *this;
}


ID3_Tag& ID3_Tag::operator<<(const ID3_Frame* frame)
{
  if (frame)
  {
    this->AddFrame(frame);
  }
  return *this;
}

int32 ID3_IsTagHeader(const uchar data[ID3_TAGHEADERSIZE])
{
  size_t size = ID3_Tag::IsV2Tag(data);
  
  if (!size)
  {
    return -1;
  }
  
  return size - ID3_TagHeader::SIZE;
}


namespace
{
  class IteratorImpl : public ID3_Tag::Iterator
  {
    ID3_TagImpl::iterator _cur;
    ID3_TagImpl::iterator _end;
  public:
    IteratorImpl(ID3_TagImpl& tag)
      : _cur(tag.begin()), _end(tag.end())
    {
    }

    ID3_Frame* GetNext() 
    { 
      ID3_Frame* next = NULL;
      while (next == NULL && _cur != _end)
      {
        next = *_cur;
        ++_cur;
      }
      return next;
    }
  };

  
  class ConstIteratorImpl : public ID3_Tag::ConstIterator
  {
    ID3_TagImpl::const_iterator _cur;
    ID3_TagImpl::const_iterator _end;
  public:
    ConstIteratorImpl(ID3_TagImpl& tag)
      : _cur(tag.begin()), _end(tag.end())
    {
    }
    const ID3_Frame* GetNext() 
    { 
      ID3_Frame* next = NULL;
      while (next == NULL && _cur != _end)
      {
        next = *_cur;
        ++_cur;
      }
      return next;
    }
  };
}

ID3_Tag::Iterator* 
ID3_Tag::CreateIterator()
{
  return new IteratorImpl(*_impl);
}

ID3_Tag::ConstIterator* 
ID3_Tag::CreateIterator() const
{
  return new ConstIteratorImpl(*_impl);
}

---