add methods to SeekTable, Padding, and VorbisComment

include/FLAC++/metadata.h

@@ -114,6 +114,8 @@ namespace FLAC {
 			inline void operator=(const Padding &object) { Prototype::operator=(object); }
 			inline void operator=(const ::FLAC__StreamMetaData &object) { Prototype::operator=(object); }
 			inline void operator=(const ::FLAC__StreamMetaData *object) { Prototype::operator=(object); }
+
+			void set_length(unsigned length);
 		};
 
 		class Application : public Prototype {
@@ -142,10 +144,61 @@ namespace FLAC {
 			inline void operator=(const SeekTable &object) { Prototype::operator=(object); }
 			inline void operator=(const ::FLAC__StreamMetaData &object) { Prototype::operator=(object); }
 			inline void operator=(const ::FLAC__StreamMetaData *object) { Prototype::operator=(object); }
+
+			unsigned get_num_points() const;
+			::FLAC__StreamMetaData_SeekPoint get_point(unsigned index) const;
+
+			void set_point(unsigned index, const ::FLAC__StreamMetaData_SeekPoint &point);
+			bool insert_point(unsigned index, const ::FLAC__StreamMetaData_SeekPoint &point);
+			bool delete_point(unsigned index);
 		};
 
 		class VorbisComment : public Prototype {
 		public:
+			class Entry {
+			public:
+				Entry();
+				Entry(const char *field, unsigned field_length);
+				Entry(const char *field_name, const char *field_value, unsigned field_value_length);
+				Entry(const Entry &entry);
+				void operator=(const Entry &entry);
+
+				virtual ~Entry();
+
+				virtual bool is_valid() const;
+				inline operator bool() const { return is_valid(); }
+
+				unsigned get_field_length() const;
+				unsigned get_field_name_length() const;
+				unsigned get_field_value_length() const;
+
+				::FLAC__StreamMetaData_VorbisComment_Entry get_entry() const;
+				const char *get_field() const;
+				const char *get_field_name() const;
+				const char *get_field_value() const;
+
+				bool set_field(const char *field, unsigned field_length);
+				bool set_field_name(const char *field_name);
+				bool set_field_value(const char *field_value, unsigned field_value_length);
+			protected:
+				bool is_valid_;
+				::FLAC__StreamMetaData_VorbisComment_Entry entry_;
+				char *field_name_;
+				unsigned field_name_length_;
+				char *field_value_;
+				unsigned field_value_length_;
+			private:
+				void zero();
+				void clear();
+				void clear_entry();
+				void clear_field_name();
+				void clear_field_value();
+				void construct(const char *field, unsigned field_length);
+				void construct(const char *field_name, const char *field_value, unsigned field_value_length);
+				void compose_field();
+				void parse_field();
+			};
+
 			VorbisComment();
 			VorbisComment(::FLAC__StreamMetaData *object, bool copy = false);
 			~VorbisComment();
@@ -153,8 +206,18 @@ namespace FLAC {
 			inline void operator=(const VorbisComment &object) { Prototype::operator=(object); }
 			inline void operator=(const ::FLAC__StreamMetaData &object) { Prototype::operator=(object); }
 			inline void operator=(const ::FLAC__StreamMetaData *object) { Prototype::operator=(object); }
+
+			unsigned get_num_comments() const;
+			Entry get_vendor_string() const;
+			Entry get_comment(unsigned index) const;
+
+			bool set_vendor_string(const Entry &entry);
+			bool set_comment(unsigned index, const Entry &entry);
+			bool insert_comment(unsigned index, const Entry &entry);
+			bool delete_comment(unsigned index);
 		};
 
+
 		// ============================================================
 		//
 		//  Level 0
@@ -163,6 +226,7 @@ namespace FLAC {
 
 		bool get_streaminfo(const char *filename, StreamInfo &streaminfo);
 
+
 		// ============================================================
 		//
 		//  Level 1
@@ -226,6 +290,7 @@ namespace FLAC {
 			void clear();
 		};
 
+
 		// ============================================================
 		//
 		//  Level 2

src/libFLAC++/metadata.cc

@@ -19,7 +19,8 @@
 
 #include "FLAC++/metadata.h"
 #include "FLAC/assert.h"
-#include <string.h> // for memcpy()
+#include <stdlib.h> // for malloc(), free()
+#include <string.h> // for memcpy() etc.
 
 namespace FLAC {
 	namespace Metadata {
@@ -123,6 +124,7 @@ namespace FLAC {
 			return object_->length;
 		}
 
+
 		//
 		// StreamInfo
 		//
@@ -259,6 +261,7 @@ namespace FLAC {
 			memcpy(object_->data.stream_info.md5sum, value, 16);
 		}
 
+
 		//
 		// Padding
 		//
@@ -274,6 +277,13 @@ namespace FLAC {
 		Padding::~Padding()
 		{ }
 
+		void Padding::set_length(unsigned length)
+		{
+			FLAC__ASSERT(is_valid());
+			object_->length = length;
+		}
+
+
 		//
 		// Application
 		//
@@ -314,6 +324,7 @@ namespace FLAC {
 			return FLAC__metadata_object_application_set_data(object_, data, length, copy);
 		}
 
+
 		//
 		// SeekTable
 		//
@@ -329,6 +340,307 @@ namespace FLAC {
 		SeekTable::~SeekTable()
 		{ }
 
+		unsigned SeekTable::get_num_points() const
+		{
+			FLAC__ASSERT(is_valid());
+			return object_->data.seek_table.num_points;
+		}
+
+		::FLAC__StreamMetaData_SeekPoint SeekTable::get_point(unsigned index) const
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(index < object_->data.seek_table.num_points);
+			return object_->data.seek_table.points[index];
+		}
+
+		void SeekTable::set_point(unsigned index, const ::FLAC__StreamMetaData_SeekPoint &point)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(index < object_->data.seek_table.num_points);
+			::FLAC__metadata_object_seektable_set_point(object_, index, point);
+		}
+
+		bool SeekTable::insert_point(unsigned index, const ::FLAC__StreamMetaData_SeekPoint &point)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(index <= object_->data.seek_table.num_points);
+			return ::FLAC__metadata_object_seektable_insert_point(object_, index, point);
+		}
+
+		bool SeekTable::delete_point(unsigned index)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(index < object_->data.seek_table.num_points);
+			return ::FLAC__metadata_object_seektable_delete_point(object_, index);
+		}
+
+
+		//
+		// VorbisComment::Entry
+		//
+
+		VorbisComment::Entry::Entry()
+		{
+			zero();
+		}
+
+		VorbisComment::Entry::Entry(const char *field, unsigned field_length)
+		{
+			zero();
+			construct(field, field_length);
+		}
+
+		VorbisComment::Entry::Entry(const char *field_name, const char *field_value, unsigned field_value_length)
+		{
+			zero();
+			construct(field_name, field_value, field_value_length);
+		}
+
+		VorbisComment::Entry::Entry(const Entry &entry)
+		{
+			zero();
+			if(entry.is_valid())
+				construct((const char *)entry.entry_.entry, entry.entry_.length);
+		}
+
+		void VorbisComment::Entry::operator=(const Entry &entry)
+		{
+			clear();
+			if(entry.is_valid())
+				construct((const char *)entry.entry_.entry, entry.entry_.length);
+		}
+
+		VorbisComment::Entry::~Entry()
+		{
+			clear();
+		}
+
+		bool VorbisComment::Entry::is_valid() const
+		{
+			return is_valid_;
+		}
+
+		unsigned VorbisComment::Entry::get_field_length() const
+		{
+			FLAC__ASSERT(is_valid());
+			return entry_.length;
+		}
+
+		unsigned VorbisComment::Entry::get_field_name_length() const
+		{
+			FLAC__ASSERT(is_valid());
+			return field_name_length_;
+		}
+
+		unsigned VorbisComment::Entry::get_field_value_length() const
+		{
+			FLAC__ASSERT(is_valid());
+			return field_value_length_;
+		}
+
+		::FLAC__StreamMetaData_VorbisComment_Entry VorbisComment::Entry::get_entry() const
+		{
+			FLAC__ASSERT(is_valid());
+			return entry_;
+		}
+
+		const char *VorbisComment::Entry::get_field() const
+		{
+			FLAC__ASSERT(is_valid());
+			return (const char *)entry_.entry;
+		}
+
+		const char *VorbisComment::Entry::get_field_name() const
+		{
+			FLAC__ASSERT(is_valid());
+			return field_name_;
+		}
+
+		const char *VorbisComment::Entry::get_field_value() const
+		{
+			FLAC__ASSERT(is_valid());
+			return field_value_;
+		}
+
+		bool VorbisComment::Entry::set_field(const char *field, unsigned field_length)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(0 != field);
+
+			clear_entry();
+
+			if(0 == (entry_.entry = (FLAC__byte*)malloc(field_length))) {
+				clear();
+				is_valid_ = false;
+			}
+			else {
+				entry_.length = field_length;
+				memcpy(entry_.entry, field, field_length);
+				parse_field();
+				is_valid_ = true;
+			}
+
+			return is_valid_;
+		}
+
+		bool VorbisComment::Entry::set_field_name(const char *field_name)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(0 != field_name);
+
+			clear_field_name();
+
+			if(0 == (field_name_ = strdup(field_name))) {
+				clear();
+				is_valid_ = false;
+			}
+			else {
+				field_name_length_ = strlen(field_name_);
+				compose_field();
+				is_valid_ = true;
+			}
+
+			return is_valid_;
+		}
+
+		bool VorbisComment::Entry::set_field_value(const char *field_value, unsigned field_value_length)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(0 != field_value);
+
+			clear_field_value();
+
+			if(0 == (field_value_ = (char *)malloc(field_value_length))) {
+				clear();
+				is_valid_ = false;
+			}
+			else {
+				field_value_length_ = field_value_length;
+				memcpy(field_value_, field_value, field_value_length);
+				compose_field();
+				is_valid_ = true;
+			}
+
+			return is_valid_;
+		}
+
+		void VorbisComment::Entry::zero()
+		{
+			is_valid_ = false;
+			entry_.length = 0;
+			entry_.entry = 0;
+			field_name_ = 0;
+			field_name_length_ = 0;
+			field_value_ = 0;
+			field_value_length_ = 0;
+		}
+
+		void VorbisComment::Entry::clear()
+		{
+			clear_entry();
+			clear_field_name();
+			clear_field_value();
+			is_valid_ = false;
+		}
+
+		void VorbisComment::Entry::clear_entry()
+		{
+			if(0 != entry_.entry) {
+				FLAC__ASSERT(entry_.length == 0);
+				free(entry_.entry);
+				entry_.entry = 0;
+				entry_.length = 0;
+			}
+		}
+
+		void VorbisComment::Entry::clear_field_name()
+		{
+			if(0 != field_name_) {
+				FLAC__ASSERT(field_name_length_ == 0);
+				free(field_name_);
+				field_name_ = 0;
+				field_name_length_ = 0;
+			}
+		}
+
+		void VorbisComment::Entry::clear_field_value()
+		{
+			if(0 != field_value_) {
+				FLAC__ASSERT(field_name_length_ == 0);
+				free(field_value_);
+				field_value_ = 0;
+				field_value_length_ = 0;
+			}
+		}
+
+		void VorbisComment::Entry::construct(const char *field, unsigned field_length)
+		{
+			set_field(field, field_length);
+			if(is_valid_) {
+				parse_field();
+			}
+		}
+
+		void VorbisComment::Entry::construct(const char *field_name, const char *field_value, unsigned field_value_length)
+		{
+			set_field_name(field_name);
+			if(is_valid_) {
+				set_field_value(field_value, field_value_length);
+				if(is_valid_) {
+					compose_field();
+				}
+			}
+		}
+
+		void VorbisComment::Entry::compose_field()
+		{
+			clear_entry();
+
+			if(0 == (entry_.entry = (FLAC__byte*)malloc(field_name_length_ + 1 + field_value_length_))) {
+				clear();
+			}
+			else {
+				memcpy(entry_.entry, field_name_, field_name_length_);
+				entry_.length += field_name_length_;
+				memcpy(entry_.entry + entry_.length, "=", 1);
+				entry_.length += 1;
+				memcpy(entry_.entry, field_value_, field_value_length_);
+				entry_.length += field_value_length_;
+				is_valid_ = true;
+			}
+		}
+
+		void VorbisComment::Entry::parse_field()
+		{
+			clear_field_name();
+			clear_field_value();
+
+			const char *p = (const char *)memchr(entry_.entry, '=', entry_.length);
+
+			if(0 == p) {
+				clear();
+				return;
+			}
+
+			if(0 == (field_name_ = (char *)malloc(p - (const char *)entry_.entry + 1))) { // +1 for the trailing \0
+				clear();
+				return;
+			}
+			field_name_length_ = p - (const char *)entry_.entry;
+			memcpy(field_name_, entry_.entry, field_name_length_);
+			field_name_[field_name_length_] = '\0';
+
+			if(0 == (field_value_ = (char *)malloc(entry_.length - field_name_length_ - 1))) {
+				clear();
+				return;
+			}
+			field_value_length_ = entry_.length - field_name_length_ - 1;
+			memcpy(field_value_, ++p, field_value_length_);
+
+			is_valid_ = true;
+		}
+
+
 		//
 		// VorbisComment
 		//
@@ -344,6 +656,52 @@ namespace FLAC {
 		VorbisComment::~VorbisComment()
 		{ }
 
+		unsigned VorbisComment::get_num_comments() const
+		{
+			FLAC__ASSERT(is_valid());
+			return object_->data.vorbis_comment.num_comments;
+		}
+
+		VorbisComment::Entry VorbisComment::get_vendor_string() const
+		{
+			FLAC__ASSERT(is_valid());
+			return Entry((const char *)object_->data.vorbis_comment.vendor_string.entry, object_->data.vorbis_comment.vendor_string.length);
+		}
+
+		VorbisComment::Entry VorbisComment::get_comment(unsigned index) const
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(index < object_->data.vorbis_comment.num_comments);
+			return Entry((const char *)object_->data.vorbis_comment.vendor_string.entry, object_->data.vorbis_comment.vendor_string.length);
+		}
+
+		bool VorbisComment::set_vendor_string(const VorbisComment::Entry &entry)
+		{
+			FLAC__ASSERT(is_valid());
+			return ::FLAC__metadata_object_vorbiscomment_set_vendor_string(object_, entry.get_entry(), /*copy=*/true);
+		}
+
+		bool VorbisComment::set_comment(unsigned index, const VorbisComment::Entry &entry)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(index < object_->data.vorbis_comment.num_comments);
+			return ::FLAC__metadata_object_vorbiscomment_set_comment(object_, index, entry.get_entry(), /*copy=*/true);
+		}
+
+		bool VorbisComment::insert_comment(unsigned index, const VorbisComment::Entry &entry)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(index <= object_->data.vorbis_comment.num_comments);
+			return ::FLAC__metadata_object_vorbiscomment_insert_comment(object_, index, entry.get_entry(), /*copy=*/true);
+		}
+
+		bool VorbisComment::delete_comment(unsigned index)
+		{
+			FLAC__ASSERT(is_valid());
+			FLAC__ASSERT(index < object_->data.vorbis_comment.num_comments);
+			return ::FLAC__metadata_object_vorbiscomment_delete_comment(object_, index);
+		}
+
 
 		// ============================================================
 		//